1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
16 /* $Id: AliESDtrackCuts.cxx 24534 2008-03-16 22:22:11Z fca $ */
18 #include "AliESDtrackCuts.h"
20 #include <AliESDtrack.h>
21 #include <AliESDVertex.h>
22 #include <AliESDEvent.h>
23 #include <AliMultiplicity.h>
28 #include <TDirectory.h>
32 //____________________________________________________________________
33 ClassImp(AliESDtrackCuts)
36 const Char_t* AliESDtrackCuts::fgkCutNames[kNCuts] = {
38 "require TPC standalone",
42 "#Chi^{2}/cluster TPC",
43 "#Chi^{2}/cluster ITS",
59 "trk-to-vtx max dca 2D absolute",
60 "trk-to-vtx max dca xy absolute",
61 "trk-to-vtx max dca z absolute",
62 "trk-to-vtx min dca 2D absolute",
63 "trk-to-vtx min dca xy absolute",
64 "trk-to-vtx min dca z absolute",
65 "SPD cluster requirement",
66 "SDD cluster requirement",
67 "SSD cluster requirement",
68 "require ITS stand-alone",
69 "rel 1/pt uncertainty",
70 "TPC n shared clusters",
71 "TPC rel shared clusters",
74 "n crossed rows / n findable clusters",
76 "#Chi^{2} TPC constrained vs. global",
81 AliESDtrackCuts* AliESDtrackCuts::fgMultEstTrackCuts[AliESDtrackCuts::kNMultEstTrackCuts] = { 0, 0, 0, 0 };
82 Char_t AliESDtrackCuts::fgBeamTypeFlag = -1;
84 //____________________________________________________________________
85 AliESDtrackCuts::AliESDtrackCuts(const Char_t* name, const Char_t* title) : AliAnalysisCuts(name,title),
86 fCutMinNClusterTPC(0),
87 fCutMinNClusterITS(0),
88 fCutMinNCrossedRowsTPC(0),
89 fCutMinRatioCrossedRowsOverFindableClustersTPC(0),
90 f1CutMinNClustersTPCPtDep(0x0),
91 fCutMaxPtDepNClustersTPC(0),
92 fCutMaxChi2PerClusterTPC(0),
93 fCutMaxChi2PerClusterITS(0),
94 fCutMaxChi2TPCConstrainedVsGlobal(0),
95 fCutMaxChi2TPCConstrainedVsGlobalVertexType(kVertexTracks | kVertexSPD),
96 fCutMaxMissingITSPoints(0),
102 fCutMaxRel1PtUncertainty(0),
103 fCutAcceptKinkDaughters(0),
104 fCutAcceptSharedTPCClusters(0),
105 fCutMaxFractionSharedTPCClusters(0),
106 fCutRequireTPCRefit(0),
107 fCutRequireTPCStandAlone(0),
108 fCutRequireITSRefit(0),
109 fCutRequireITSPid(0),
110 fCutRequireITSStandAlone(0),
111 fCutRequireITSpureSA(0),
112 fCutNsigmaToVertex(0),
113 fCutSigmaToVertexRequired(0),
114 fCutMaxDCAToVertexXY(0),
115 fCutMaxDCAToVertexZ(0),
116 fCutMinDCAToVertexXY(0),
117 fCutMinDCAToVertexZ(0),
118 fCutMaxDCAToVertexXYPtDep(""),
119 fCutMaxDCAToVertexZPtDep(""),
120 fCutMinDCAToVertexXYPtDep(""),
121 fCutMinDCAToVertexZPtDep(""),
122 f1CutMaxDCAToVertexXYPtDep(0x0),
123 f1CutMaxDCAToVertexZPtDep(0x0),
124 f1CutMinDCAToVertexXYPtDep(0x0),
125 f1CutMinDCAToVertexZPtDep(0x0),
126 fCutDCAToVertex2D(0),
141 fCutRequireTOFout(kFALSE),
142 fFlagCutTOFdistance(kFALSE),
155 //##############################################################################
156 // setting default cuts
157 SetMinNClustersTPC();
158 SetMinNClustersITS();
159 SetMinNCrossedRowsTPC();
160 SetMinRatioCrossedRowsOverFindableClustersTPC();
161 SetMaxChi2PerClusterTPC();
162 SetMaxChi2PerClusterITS();
163 SetMaxChi2TPCConstrainedGlobal();
164 SetMaxChi2TPCConstrainedGlobalVertexType();
165 SetMaxNOfMissingITSPoints();
166 SetMaxCovDiagonalElements();
167 SetMaxRel1PtUncertainty();
168 SetRequireTPCRefit();
169 SetRequireTPCStandAlone();
170 SetRequireITSRefit();
171 SetRequireITSPid(kFALSE);
172 SetRequireITSStandAlone(kFALSE);
173 SetRequireITSPureStandAlone(kFALSE);
174 SetAcceptKinkDaughters();
175 SetAcceptSharedTPCClusters();
176 SetMaxFractionSharedTPCClusters();
177 SetMaxNsigmaToVertex();
178 SetMaxDCAToVertexXY();
179 SetMaxDCAToVertexZ();
181 SetMinDCAToVertexXY();
182 SetMinDCAToVertexZ();
190 SetClusterRequirementITS(kSPD);
191 SetClusterRequirementITS(kSDD);
192 SetClusterRequirementITS(kSSD);
197 //_____________________________________________________________________________
198 AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : AliAnalysisCuts(c),
199 fCutMinNClusterTPC(0),
200 fCutMinNClusterITS(0),
201 fCutMinNCrossedRowsTPC(0),
202 fCutMinRatioCrossedRowsOverFindableClustersTPC(0),
203 f1CutMinNClustersTPCPtDep(0x0),
204 fCutMaxPtDepNClustersTPC(0),
205 fCutMaxChi2PerClusterTPC(0),
206 fCutMaxChi2PerClusterITS(0),
207 fCutMaxChi2TPCConstrainedVsGlobal(0),
208 fCutMaxChi2TPCConstrainedVsGlobalVertexType(kVertexTracks | kVertexSPD),
209 fCutMaxMissingITSPoints(0),
215 fCutMaxRel1PtUncertainty(0),
216 fCutAcceptKinkDaughters(0),
217 fCutAcceptSharedTPCClusters(0),
218 fCutMaxFractionSharedTPCClusters(0),
219 fCutRequireTPCRefit(0),
220 fCutRequireTPCStandAlone(0),
221 fCutRequireITSRefit(0),
222 fCutRequireITSPid(0),
223 fCutRequireITSStandAlone(0),
224 fCutRequireITSpureSA(0),
225 fCutNsigmaToVertex(0),
226 fCutSigmaToVertexRequired(0),
227 fCutMaxDCAToVertexXY(0),
228 fCutMaxDCAToVertexZ(0),
229 fCutMinDCAToVertexXY(0),
230 fCutMinDCAToVertexZ(0),
231 fCutMaxDCAToVertexXYPtDep(""),
232 fCutMaxDCAToVertexZPtDep(""),
233 fCutMinDCAToVertexXYPtDep(""),
234 fCutMinDCAToVertexZPtDep(""),
235 f1CutMaxDCAToVertexXYPtDep(0x0),
236 f1CutMaxDCAToVertexZPtDep(0x0),
237 f1CutMinDCAToVertexXYPtDep(0x0),
238 f1CutMinDCAToVertexZPtDep(0x0),
239 fCutDCAToVertex2D(0),
254 fCutRequireTOFout(kFALSE),
255 fFlagCutTOFdistance(kFALSE),
266 ((AliESDtrackCuts &) c).Copy(*this);
269 AliESDtrackCuts::~AliESDtrackCuts()
275 for (Int_t i=0; i<2; i++) {
277 if (fhNClustersITS[i])
278 delete fhNClustersITS[i];
279 if (fhNClustersTPC[i])
280 delete fhNClustersTPC[i];
281 if (fhNSharedClustersTPC[i])
282 delete fhNSharedClustersTPC[i];
283 if (fhNCrossedRowsTPC[i])
284 delete fhNCrossedRowsTPC[i];
285 if (fhRatioCrossedRowsOverFindableClustersTPC[i])
286 delete fhRatioCrossedRowsOverFindableClustersTPC[i];
287 if (fhChi2PerClusterITS[i])
288 delete fhChi2PerClusterITS[i];
289 if (fhChi2PerClusterTPC[i])
290 delete fhChi2PerClusterTPC[i];
291 if (fhChi2TPCConstrainedVsGlobal[i])
292 delete fhChi2TPCConstrainedVsGlobal[i];
293 if(fhNClustersForITSPID[i])
294 delete fhNClustersForITSPID[i];
295 if(fhNMissingITSPoints[i])
296 delete fhNMissingITSPoints[i];
308 if (fhRel1PtUncertainty[i])
309 delete fhRel1PtUncertainty[i];
320 if (fhDXYNormalized[i])
321 delete fhDXYNormalized[i];
322 if (fhDZNormalized[i])
323 delete fhDZNormalized[i];
324 if (fhDXYvsDZNormalized[i])
325 delete fhDXYvsDZNormalized[i];
326 if (fhNSigmaToVertex[i])
327 delete fhNSigmaToVertex[i];
332 if (fhTOFdistance[i])
333 delete fhTOFdistance[i];
336 if(f1CutMaxDCAToVertexXYPtDep)delete f1CutMaxDCAToVertexXYPtDep;
337 f1CutMaxDCAToVertexXYPtDep = 0;
338 if( f1CutMaxDCAToVertexZPtDep) delete f1CutMaxDCAToVertexZPtDep;
339 f1CutMaxDCAToVertexZPtDep = 0;
340 if( f1CutMinDCAToVertexXYPtDep)delete f1CutMinDCAToVertexXYPtDep;
341 f1CutMinDCAToVertexXYPtDep = 0;
342 if(f1CutMinDCAToVertexZPtDep)delete f1CutMinDCAToVertexZPtDep;
343 f1CutMinDCAToVertexZPtDep = 0;
347 delete ffDTheoretical;
350 delete fhCutStatistics;
351 if (fhCutCorrelation)
352 delete fhCutCorrelation;
354 if(f1CutMinNClustersTPCPtDep)
355 delete f1CutMinNClustersTPCPtDep;
359 void AliESDtrackCuts::Init()
362 // sets everything to zero
365 fCutMinNClusterTPC = 0;
366 fCutMinNClusterITS = 0;
368 fCutMaxChi2PerClusterTPC = 0;
369 fCutMaxChi2PerClusterITS = 0;
370 fCutMaxChi2TPCConstrainedVsGlobal = 0;
371 fCutMaxChi2TPCConstrainedVsGlobalVertexType = kVertexTracks | kVertexSPD;
372 fCutMaxMissingITSPoints = 0;
374 for (Int_t i = 0; i < 3; i++)
375 fCutClusterRequirementITS[i] = kOff;
383 fCutMaxRel1PtUncertainty = 0;
385 fCutAcceptKinkDaughters = 0;
386 fCutAcceptSharedTPCClusters = 0;
387 fCutMaxFractionSharedTPCClusters = 0;
388 fCutRequireTPCRefit = 0;
389 fCutRequireTPCStandAlone = 0;
390 fCutRequireITSRefit = 0;
391 fCutRequireITSPid = 0;
392 fCutRequireITSStandAlone = 0;
393 fCutRequireITSpureSA = 0;
395 fCutNsigmaToVertex = 0;
396 fCutSigmaToVertexRequired = 0;
397 fCutMaxDCAToVertexXY = 0;
398 fCutMaxDCAToVertexZ = 0;
399 fCutDCAToVertex2D = 0;
400 fCutMinDCAToVertexXY = 0;
401 fCutMinDCAToVertexZ = 0;
402 fCutMaxDCAToVertexXYPtDep = "";
403 fCutMaxDCAToVertexZPtDep = "";
404 fCutMinDCAToVertexXYPtDep = "";
405 fCutMinDCAToVertexZPtDep = "";
407 if(f1CutMaxDCAToVertexXYPtDep)delete f1CutMaxDCAToVertexXYPtDep;
408 f1CutMaxDCAToVertexXYPtDep = 0;
409 if( f1CutMaxDCAToVertexXYPtDep) delete f1CutMaxDCAToVertexXYPtDep;
410 f1CutMaxDCAToVertexXYPtDep = 0;
411 if( f1CutMaxDCAToVertexZPtDep) delete f1CutMaxDCAToVertexZPtDep;
412 f1CutMaxDCAToVertexZPtDep = 0;
413 if( f1CutMinDCAToVertexXYPtDep)delete f1CutMinDCAToVertexXYPtDep;
414 f1CutMinDCAToVertexXYPtDep = 0;
415 if(f1CutMinDCAToVertexZPtDep)delete f1CutMinDCAToVertexZPtDep;
416 f1CutMinDCAToVertexZPtDep = 0;
434 fHistogramsOn = kFALSE;
436 for (Int_t i=0; i<2; ++i)
438 fhNClustersITS[i] = 0;
439 fhNClustersTPC[i] = 0;
440 fhNSharedClustersTPC[i] = 0;
441 fhNCrossedRowsTPC[i] = 0;
442 fhRatioCrossedRowsOverFindableClustersTPC[i] = 0;
444 fhChi2PerClusterITS[i] = 0;
445 fhChi2PerClusterTPC[i] = 0;
446 fhChi2TPCConstrainedVsGlobal[i] = 0;
447 fhNClustersForITSPID[i] = 0;
448 fhNMissingITSPoints[i] = 0;
456 fhRel1PtUncertainty[i] = 0;
463 fhDXYNormalized[i] = 0;
464 fhDZNormalized[i] = 0;
465 fhDXYvsDZNormalized[i] = 0;
466 fhNSigmaToVertex[i] = 0;
470 fhTOFdistance[i] = 0;
475 fhCutCorrelation = 0;
478 //_____________________________________________________________________________
479 AliESDtrackCuts &AliESDtrackCuts::operator=(const AliESDtrackCuts &c)
482 // Assignment operator
485 if (this != &c) ((AliESDtrackCuts &) c).Copy(*this);
489 //_____________________________________________________________________________
490 void AliESDtrackCuts::Copy(TObject &c) const
496 AliESDtrackCuts& target = (AliESDtrackCuts &) c;
500 target.fCutMinNClusterTPC = fCutMinNClusterTPC;
501 target.fCutMinNClusterITS = fCutMinNClusterITS;
502 target.fCutMinNCrossedRowsTPC = fCutMinNCrossedRowsTPC;
503 target.fCutMinRatioCrossedRowsOverFindableClustersTPC = fCutMinRatioCrossedRowsOverFindableClustersTPC;
504 if(f1CutMinNClustersTPCPtDep){
505 target.f1CutMinNClustersTPCPtDep = (TFormula*) f1CutMinNClustersTPCPtDep->Clone("f1CutMinNClustersTPCPtDep");
507 target.fCutMaxPtDepNClustersTPC = fCutMaxPtDepNClustersTPC;
509 target.fCutMaxChi2PerClusterTPC = fCutMaxChi2PerClusterTPC;
510 target.fCutMaxChi2PerClusterITS = fCutMaxChi2PerClusterITS;
511 target.fCutMaxChi2TPCConstrainedVsGlobal = fCutMaxChi2TPCConstrainedVsGlobal;
512 target.fCutMaxChi2TPCConstrainedVsGlobalVertexType = fCutMaxChi2TPCConstrainedVsGlobalVertexType;
513 target.fCutMaxMissingITSPoints = fCutMaxMissingITSPoints;
515 for (Int_t i = 0; i < 3; i++)
516 target.fCutClusterRequirementITS[i] = fCutClusterRequirementITS[i];
518 target.fCutMaxC11 = fCutMaxC11;
519 target.fCutMaxC22 = fCutMaxC22;
520 target.fCutMaxC33 = fCutMaxC33;
521 target.fCutMaxC44 = fCutMaxC44;
522 target.fCutMaxC55 = fCutMaxC55;
524 target.fCutMaxRel1PtUncertainty = fCutMaxRel1PtUncertainty;
526 target.fCutAcceptKinkDaughters = fCutAcceptKinkDaughters;
527 target.fCutAcceptSharedTPCClusters = fCutAcceptSharedTPCClusters;
528 target.fCutMaxFractionSharedTPCClusters = fCutMaxFractionSharedTPCClusters;
529 target.fCutRequireTPCRefit = fCutRequireTPCRefit;
530 target.fCutRequireTPCStandAlone = fCutRequireTPCStandAlone;
531 target.fCutRequireITSRefit = fCutRequireITSRefit;
532 target.fCutRequireITSPid = fCutRequireITSPid;
533 target.fCutRequireITSStandAlone = fCutRequireITSStandAlone;
534 target.fCutRequireITSpureSA = fCutRequireITSpureSA;
536 target.fCutNsigmaToVertex = fCutNsigmaToVertex;
537 target.fCutSigmaToVertexRequired = fCutSigmaToVertexRequired;
538 target.fCutMaxDCAToVertexXY = fCutMaxDCAToVertexXY;
539 target.fCutMaxDCAToVertexZ = fCutMaxDCAToVertexZ;
540 target.fCutDCAToVertex2D = fCutDCAToVertex2D;
541 target.fCutMinDCAToVertexXY = fCutMinDCAToVertexXY;
542 target.fCutMinDCAToVertexZ = fCutMinDCAToVertexZ;
544 target.fCutMaxDCAToVertexXYPtDep = fCutMaxDCAToVertexXYPtDep;
545 if(fCutMaxDCAToVertexXYPtDep.Length()>0)target.SetMaxDCAToVertexXYPtDep(fCutMaxDCAToVertexXYPtDep.Data());
547 target.fCutMaxDCAToVertexZPtDep = fCutMaxDCAToVertexZPtDep;
548 if(fCutMaxDCAToVertexZPtDep.Length()>0)target.SetMaxDCAToVertexZPtDep(fCutMaxDCAToVertexZPtDep.Data());
550 target.fCutMinDCAToVertexXYPtDep = fCutMinDCAToVertexXYPtDep;
551 if(fCutMinDCAToVertexXYPtDep.Length()>0)target.SetMinDCAToVertexXYPtDep(fCutMinDCAToVertexXYPtDep.Data());
553 target.fCutMinDCAToVertexZPtDep = fCutMinDCAToVertexZPtDep;
554 if(fCutMinDCAToVertexZPtDep.Length()>0)target.SetMinDCAToVertexZPtDep(fCutMinDCAToVertexZPtDep.Data());
556 target.fPMin = fPMin;
557 target.fPMax = fPMax;
558 target.fPtMin = fPtMin;
559 target.fPtMax = fPtMax;
560 target.fPxMin = fPxMin;
561 target.fPxMax = fPxMax;
562 target.fPyMin = fPyMin;
563 target.fPyMax = fPyMax;
564 target.fPzMin = fPzMin;
565 target.fPzMax = fPzMax;
566 target.fEtaMin = fEtaMin;
567 target.fEtaMax = fEtaMax;
568 target.fRapMin = fRapMin;
569 target.fRapMax = fRapMax;
571 target.fFlagCutTOFdistance = fFlagCutTOFdistance;
572 target.fCutTOFdistance = fCutTOFdistance;
573 target.fCutRequireTOFout = fCutRequireTOFout;
575 target.fHistogramsOn = fHistogramsOn;
577 for (Int_t i=0; i<2; ++i)
579 if (fhNClustersITS[i]) target.fhNClustersITS[i] = (TH1F*) fhNClustersITS[i]->Clone();
580 if (fhNClustersTPC[i]) target.fhNClustersTPC[i] = (TH1F*) fhNClustersTPC[i]->Clone();
581 if (fhNSharedClustersTPC[i]) target.fhNSharedClustersTPC[i] = (TH1F*) fhNSharedClustersTPC[i]->Clone();
582 if (fhNCrossedRowsTPC[i]) target.fhNCrossedRowsTPC[i] = (TH1F*) fhNCrossedRowsTPC[i]->Clone();
583 if (fhRatioCrossedRowsOverFindableClustersTPC[i]) target.fhRatioCrossedRowsOverFindableClustersTPC[i] = (TH1F*) fhRatioCrossedRowsOverFindableClustersTPC[i]->Clone();
585 if (fhChi2PerClusterITS[i]) target.fhChi2PerClusterITS[i] = (TH1F*) fhChi2PerClusterITS[i]->Clone();
586 if (fhChi2PerClusterTPC[i]) target.fhChi2PerClusterTPC[i] = (TH1F*) fhChi2PerClusterTPC[i]->Clone();
587 if (fhChi2TPCConstrainedVsGlobal[i]) target.fhChi2TPCConstrainedVsGlobal[i] = (TH1F*) fhChi2TPCConstrainedVsGlobal[i]->Clone();
588 if (fhNClustersForITSPID[i]) target.fhNClustersForITSPID[i] = (TH1F*) fhNClustersForITSPID[i]->Clone();
589 if (fhNMissingITSPoints[i]) target.fhNMissingITSPoints[i] = (TH1F*) fhNMissingITSPoints[i]->Clone();
591 if (fhC11[i]) target.fhC11[i] = (TH1F*) fhC11[i]->Clone();
592 if (fhC22[i]) target.fhC22[i] = (TH1F*) fhC22[i]->Clone();
593 if (fhC33[i]) target.fhC33[i] = (TH1F*) fhC33[i]->Clone();
594 if (fhC44[i]) target.fhC44[i] = (TH1F*) fhC44[i]->Clone();
595 if (fhC55[i]) target.fhC55[i] = (TH1F*) fhC55[i]->Clone();
597 if (fhRel1PtUncertainty[i]) target.fhRel1PtUncertainty[i] = (TH1F*) fhRel1PtUncertainty[i]->Clone();
599 if (fhDXY[i]) target.fhDXY[i] = (TH1F*) fhDXY[i]->Clone();
600 if (fhDZ[i]) target.fhDZ[i] = (TH1F*) fhDZ[i]->Clone();
601 if (fhDXYDZ[i]) target.fhDXYDZ[i] = (TH1F*) fhDXYDZ[i]->Clone();
602 if (fhDXYvsDZ[i]) target.fhDXYvsDZ[i] = (TH2F*) fhDXYvsDZ[i]->Clone();
604 if (fhDXYNormalized[i]) target.fhDXYNormalized[i] = (TH1F*) fhDXYNormalized[i]->Clone();
605 if (fhDZNormalized[i]) target.fhDZNormalized[i] = (TH1F*) fhDZNormalized[i]->Clone();
606 if (fhDXYvsDZNormalized[i]) target.fhDXYvsDZNormalized[i] = (TH2F*) fhDXYvsDZNormalized[i]->Clone();
607 if (fhNSigmaToVertex[i]) target.fhNSigmaToVertex[i] = (TH1F*) fhNSigmaToVertex[i]->Clone();
609 if (fhPt[i]) target.fhPt[i] = (TH1F*) fhPt[i]->Clone();
610 if (fhEta[i]) target.fhEta[i] = (TH1F*) fhEta[i]->Clone();
611 if (fhTOFdistance[i]) target.fhTOFdistance[i] = (TH2F*) fhTOFdistance[i]->Clone();
613 if (ffDTheoretical) target.ffDTheoretical = (TF1*) ffDTheoretical->Clone();
615 if (fhCutStatistics) target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
616 if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
621 //_____________________________________________________________________________
622 Long64_t AliESDtrackCuts::Merge(TCollection* list) {
623 // Merge a list of AliESDtrackCuts objects with this (needed for PROOF)
624 // Returns the number of merged objects (including this)
631 TIterator* iter = list->MakeIterator();
634 // collection of measured and generated histograms
636 while ((obj = iter->Next())) {
638 AliESDtrackCuts* entry = dynamic_cast<AliESDtrackCuts*>(obj);
642 if (!entry->fHistogramsOn)
645 for (Int_t i=0; i<2; i++) {
647 fhNClustersITS[i] ->Add(entry->fhNClustersITS[i] );
648 fhNClustersTPC[i] ->Add(entry->fhNClustersTPC[i] );
649 if (fhNSharedClustersTPC[i])
650 fhNSharedClustersTPC[i] ->Add(entry->fhNSharedClustersTPC[i] );
651 if (fhNCrossedRowsTPC[i])
652 fhNCrossedRowsTPC[i] ->Add(entry->fhNCrossedRowsTPC[i] );
653 if (fhRatioCrossedRowsOverFindableClustersTPC[i])
654 fhRatioCrossedRowsOverFindableClustersTPC[i] ->Add(entry->fhRatioCrossedRowsOverFindableClustersTPC[i] );
656 fhChi2PerClusterITS[i] ->Add(entry->fhChi2PerClusterITS[i]);
657 fhChi2PerClusterTPC[i] ->Add(entry->fhChi2PerClusterTPC[i]);
658 if (fhChi2TPCConstrainedVsGlobal[i])
659 fhChi2TPCConstrainedVsGlobal[i]->Add(entry->fhChi2TPCConstrainedVsGlobal[i]);
660 if (fhNClustersForITSPID[i])
661 fhNClustersForITSPID[i]->Add(entry->fhNClustersForITSPID[i]);
662 if (fhNMissingITSPoints[i])
663 fhNMissingITSPoints[i] ->Add(entry->fhNMissingITSPoints[i]);
665 fhC11[i] ->Add(entry->fhC11[i] );
666 fhC22[i] ->Add(entry->fhC22[i] );
667 fhC33[i] ->Add(entry->fhC33[i] );
668 fhC44[i] ->Add(entry->fhC44[i] );
669 fhC55[i] ->Add(entry->fhC55[i] );
671 fhRel1PtUncertainty[i] ->Add(entry->fhRel1PtUncertainty[i]);
673 fhDXY[i] ->Add(entry->fhDXY[i] );
674 fhDZ[i] ->Add(entry->fhDZ[i] );
675 fhDXYDZ[i] ->Add(entry->fhDXYDZ[i] );
676 fhDXYvsDZ[i] ->Add(entry->fhDXYvsDZ[i] );
678 fhDXYNormalized[i] ->Add(entry->fhDXYNormalized[i] );
679 fhDZNormalized[i] ->Add(entry->fhDZNormalized[i] );
680 fhDXYvsDZNormalized[i] ->Add(entry->fhDXYvsDZNormalized[i]);
681 fhNSigmaToVertex[i] ->Add(entry->fhNSigmaToVertex[i]);
683 fhPt[i] ->Add(entry->fhPt[i]);
684 fhEta[i] ->Add(entry->fhEta[i]);
685 fhTOFdistance[i] ->Add(entry->fhTOFdistance[i]);
688 fhCutStatistics ->Add(entry->fhCutStatistics);
689 fhCutCorrelation ->Add(entry->fhCutCorrelation);
696 void AliESDtrackCuts::SetMinNClustersTPCPtDep(TFormula *f1, Float_t ptmax)
699 // Sets the pT dependent NClustersTPC cut
703 delete f1CutMinNClustersTPCPtDep;
704 f1CutMinNClustersTPCPtDep = (TFormula*)f1->Clone("f1CutMinNClustersTPCPtDep");
706 fCutMaxPtDepNClustersTPC=ptmax;
709 //____________________________________________________________________
710 AliESDtrackCuts* AliESDtrackCuts::GetStandardTPCOnlyTrackCuts()
712 // creates an AliESDtrackCuts object and fills it with standard (pre data-taking) values for TPC-only cuts
714 AliInfoClass("Creating track cuts for TPC-only.");
716 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
718 esdTrackCuts->SetMinNClustersTPC(50);
719 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
720 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
722 esdTrackCuts->SetMaxDCAToVertexZ(3.2);
723 esdTrackCuts->SetMaxDCAToVertexXY(2.4);
724 esdTrackCuts->SetDCAToVertex2D(kTRUE);
729 //____________________________________________________________________
730 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(Bool_t selPrimaries)
732 // creates an AliESDtrackCuts object and fills it with standard values for ITS-TPC cuts for pp 2009 data
734 AliInfoClass("Creating track cuts for ITS+TPC (2009 definition).");
736 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
739 esdTrackCuts->SetRequireTPCStandAlone(kTRUE); // to get chi2 and ncls of kTPCin
740 esdTrackCuts->SetMinNClustersTPC(70);
741 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
742 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
743 esdTrackCuts->SetRequireTPCRefit(kTRUE);
745 esdTrackCuts->SetRequireITSRefit(kTRUE);
746 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
747 AliESDtrackCuts::kAny);
749 // 7*(0.0050+0.0060/pt^0.9)
750 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
751 esdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
753 esdTrackCuts->SetMaxDCAToVertexZ(1.e6);
754 esdTrackCuts->SetDCAToVertex2D(kFALSE);
755 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
756 //esdTrackCuts->SetEtaRange(-0.8,+0.8);
758 esdTrackCuts->SetMaxChi2PerClusterITS(36);
763 //____________________________________________________________________
764 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(Bool_t selPrimaries, Int_t clusterCut)
766 // creates an AliESDtrackCuts object and fills it with standard values for ITS-TPC cuts for pp 2011 data
767 // if clusterCut = 1, the cut on the number of clusters is replaced by
768 // a cut on the number of crossed rows and on the ration crossed
769 // rows/findable clusters
771 AliInfoClass("Creating track cuts for ITS+TPC (2011 definition).");
773 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
776 if(clusterCut == 0) esdTrackCuts->SetMinNClustersTPC(50);
777 else if (clusterCut == 1) {
778 esdTrackCuts->SetMinNCrossedRowsTPC(70);
779 esdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);
782 AliWarningClass(Form("Wrong value of the clusterCut parameter (%d), using cut on Nclusters",clusterCut));
783 esdTrackCuts->SetMinNClustersTPC(50);
785 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
786 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
787 esdTrackCuts->SetRequireTPCRefit(kTRUE);
789 esdTrackCuts->SetRequireITSRefit(kTRUE);
790 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
791 AliESDtrackCuts::kAny);
793 // 7*(0.0015+0.0050/pt^1.1)
794 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0105+0.0350/pt^1.1");
795 esdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
797 esdTrackCuts->SetMaxDCAToVertexZ(2);
798 esdTrackCuts->SetDCAToVertex2D(kFALSE);
799 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
801 esdTrackCuts->SetMaxChi2PerClusterITS(36);
806 //____________________________________________________________________
807 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(Bool_t selPrimaries,Int_t clusterCut)
809 // creates an AliESDtrackCuts object and fills it with standard values for ITS-TPC cuts for pp 2010 data
810 // if clusterCut = 1, the cut on the number of clusters is replaced by
811 // a cut on the number of crossed rows and on the ration crossed
812 // rows/findable clusters
814 AliInfoClass("Creating track cuts for ITS+TPC (2010 definition).");
816 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
819 if(clusterCut == 0) esdTrackCuts->SetMinNClustersTPC(70);
820 else if (clusterCut == 1) {
821 esdTrackCuts->SetMinNCrossedRowsTPC(70);
822 esdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);
825 AliWarningClass(Form("Wrong value of the clusterCut parameter (%d), using cut on Nclusters",clusterCut));
826 esdTrackCuts->SetMinNClustersTPC(70);
828 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
829 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
830 esdTrackCuts->SetRequireTPCRefit(kTRUE);
832 esdTrackCuts->SetRequireITSRefit(kTRUE);
833 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
834 AliESDtrackCuts::kAny);
836 // 7*(0.0026+0.0050/pt^1.01)
837 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
838 esdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
840 esdTrackCuts->SetMaxDCAToVertexZ(2);
841 esdTrackCuts->SetDCAToVertex2D(kFALSE);
842 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
844 esdTrackCuts->SetMaxChi2PerClusterITS(36);
849 //____________________________________________________________________
850 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(Bool_t selPrimaries, Bool_t useForPid)
852 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks
854 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
855 esdTrackCuts->SetRequireITSPureStandAlone(kTRUE);
856 esdTrackCuts->SetRequireITSRefit(kTRUE);
857 esdTrackCuts->SetMinNClustersITS(4);
858 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
859 AliESDtrackCuts::kAny);
860 esdTrackCuts->SetMaxChi2PerClusterITS(1.);
863 // 7*(0.0085+0.0026/pt^1.55)
864 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55");
867 esdTrackCuts->SetRequireITSPid(kTRUE);
872 //____________________________________________________________________
873 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(Bool_t selPrimaries, Bool_t useForPid)
875 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks - pp 2010
877 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
878 esdTrackCuts->SetRequireITSPureStandAlone(kTRUE);
879 esdTrackCuts->SetRequireITSRefit(kTRUE);
880 esdTrackCuts->SetMinNClustersITS(4);
881 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
882 AliESDtrackCuts::kAny);
883 esdTrackCuts->SetMaxChi2PerClusterITS(2.5);
886 // 7*(0.0033+0.0045/pt^1.3)
887 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0231+0.0315/pt^1.3");
890 esdTrackCuts->SetRequireITSPid(kTRUE);
895 //____________________________________________________________________
896 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSSATrackCuts2009(Bool_t selPrimaries, Bool_t useForPid)
898 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks
900 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
901 esdTrackCuts->SetRequireITSStandAlone(kTRUE);
902 esdTrackCuts->SetRequireITSPureStandAlone(kFALSE);
903 esdTrackCuts->SetRequireITSRefit(kTRUE);
904 esdTrackCuts->SetMinNClustersITS(4);
905 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
906 AliESDtrackCuts::kAny);
907 esdTrackCuts->SetMaxChi2PerClusterITS(1.);
910 // 7*(0.0085+0.0026/pt^1.55)
911 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55");
914 esdTrackCuts->SetRequireITSPid(kTRUE);
919 //____________________________________________________________________
920 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSSATrackCuts2010(Bool_t selPrimaries, Bool_t useForPid)
922 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks --pp 2010
924 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
925 esdTrackCuts->SetRequireITSStandAlone(kTRUE);
926 esdTrackCuts->SetRequireITSPureStandAlone(kFALSE);
927 esdTrackCuts->SetRequireITSRefit(kTRUE);
928 esdTrackCuts->SetMinNClustersITS(4);
929 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
930 AliESDtrackCuts::kAny);
931 esdTrackCuts->SetMaxChi2PerClusterITS(2.5);
934 // 7*(0.0033+0.0045/pt^1.3)
935 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0231+0.0315/pt^1.3");
938 esdTrackCuts->SetRequireITSPid(kTRUE);
943 //____________________________________________________________________
944 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSSATrackCutsPbPb2010(Bool_t selPrimaries, Bool_t useForPid)
946 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks -- PbPb 2010
948 AliESDtrackCuts* esdTrackCuts = GetStandardITSSATrackCuts2010(selPrimaries, useForPid);
949 esdTrackCuts->SetMaxNOfMissingITSPoints(1);
953 //____________________________________________________________________
955 AliESDtrackCuts* AliESDtrackCuts::GetStandardV0DaughterCuts()
957 // creates a AliESDtrackCuts object and fills it with standard cuts for V0 daughters
958 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
959 esdTrackCuts->SetRequireTPCRefit(kTRUE);
960 esdTrackCuts->SetMinNClustersTPC(70);
961 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
965 //____________________________________________________________________
966 Int_t AliESDtrackCuts::GetReferenceMultiplicity(const AliESDEvent* esd, Bool_t tpcOnly)
968 // Gets reference multiplicity following the standard cuts and a defined fiducial volume
969 // tpcOnly = kTRUE -> consider TPC-only tracks
970 // = kFALSE -> consider global tracks
972 // DEPRECATED Use GetReferenceMultiplicity with the enum as second argument instead
976 AliErrorClass("Not implemented for global tracks!");
980 static AliESDtrackCuts* esdTrackCuts = 0;
983 esdTrackCuts = GetStandardTPCOnlyTrackCuts();
984 esdTrackCuts->SetEtaRange(-0.8, 0.8);
985 esdTrackCuts->SetPtRange(0.15);
988 Int_t nTracks = esdTrackCuts->CountAcceptedTracks(esd);
993 //____________________________________________________________________
994 Float_t AliESDtrackCuts::GetSigmaToVertex(const AliESDtrack* const esdTrack)
996 // Calculates the number of sigma to the vertex.
1001 esdTrack->GetImpactParameters(b,bCov);
1003 if (bCov[0]<=0 || bCov[2]<=0) {
1004 AliDebugClass(1, "Estimated b resolution lower or equal zero!");
1005 bCov[0]=0; bCov[2]=0;
1007 bRes[0] = TMath::Sqrt(bCov[0]);
1008 bRes[1] = TMath::Sqrt(bCov[2]);
1010 // -----------------------------------
1011 // How to get to a n-sigma cut?
1013 // The accumulated statistics from 0 to d is
1015 // -> Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma)
1016 // -> 1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma)
1018 // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-d**2)/2)
1019 // Can this be expressed in a different way?
1021 if (bRes[0] == 0 || bRes[1] ==0)
1024 Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
1026 // work around precision problem
1027 // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
1028 // 1e-15 corresponds to nsigma ~ 7.7
1029 if (TMath::Exp(-d * d / 2) < 1e-15)
1032 Float_t nSigma = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
1036 void AliESDtrackCuts::EnableNeededBranches(TTree* tree)
1038 // enables the branches needed by AcceptTrack, for a list see comment of AcceptTrack
1040 tree->SetBranchStatus("fTracks.fFlags", 1);
1041 tree->SetBranchStatus("fTracks.fITSncls", 1);
1042 tree->SetBranchStatus("fTracks.fTPCncls", 1);
1043 tree->SetBranchStatus("fTracks.fITSchi2", 1);
1044 tree->SetBranchStatus("fTracks.fTPCchi2", 1);
1045 tree->SetBranchStatus("fTracks.fC*", 1);
1046 tree->SetBranchStatus("fTracks.fD", 1);
1047 tree->SetBranchStatus("fTracks.fZ", 1);
1048 tree->SetBranchStatus("fTracks.fCdd", 1);
1049 tree->SetBranchStatus("fTracks.fCdz", 1);
1050 tree->SetBranchStatus("fTracks.fCzz", 1);
1051 tree->SetBranchStatus("fTracks.fP*", 1);
1052 tree->SetBranchStatus("fTracks.fR*", 1);
1053 tree->SetBranchStatus("fTracks.fKinkIndexes*", 1);
1056 //____________________________________________________________________
1057 Bool_t AliESDtrackCuts::AcceptTrack(const AliESDtrack* esdTrack)
1060 // figure out if the tracks survives all the track cuts defined
1062 // the different quality parameter and kinematic values are first
1063 // retrieved from the track. then it is found out what cuts the
1064 // track did not survive and finally the cuts are imposed.
1066 // this function needs the following branches:
1072 // fTracks.fC //GetExternalCovariance
1073 // fTracks.fD //GetImpactParameters
1074 // fTracks.fZ //GetImpactParameters
1075 // fTracks.fCdd //GetImpactParameters
1076 // fTracks.fCdz //GetImpactParameters
1077 // fTracks.fCzz //GetImpactParameters
1078 // fTracks.fP //GetPxPyPz
1079 // fTracks.fR //GetMass
1080 // fTracks.fP //GetMass
1081 // fTracks.fKinkIndexes
1083 // esdEvent is only required for the MaxChi2TPCConstrainedVsGlobal
1085 UInt_t status = esdTrack->GetStatus();
1087 // getting quality parameters from the ESD track
1088 Int_t nClustersITS = esdTrack->GetITSclusters(0);
1089 Int_t nClustersTPC = -1;
1090 if(fCutRequireTPCStandAlone) {
1091 nClustersTPC = esdTrack->GetTPCNclsIter1();
1094 nClustersTPC = esdTrack->GetTPCclusters(0);
1097 //Pt dependent NClusters Cut
1098 if(f1CutMinNClustersTPCPtDep) {
1099 if(esdTrack->Pt()<fCutMaxPtDepNClustersTPC)
1100 fCutMinNClusterTPC = f1CutMinNClustersTPCPtDep->Eval(esdTrack->Pt());
1102 fCutMinNClusterTPC = f1CutMinNClustersTPCPtDep->Eval(fCutMaxPtDepNClustersTPC);
1105 Float_t nCrossedRowsTPC = esdTrack->GetTPCCrossedRows();
1106 Float_t ratioCrossedRowsOverFindableClustersTPC = 1.0;
1107 if (esdTrack->GetTPCNclsF()>0) {
1108 ratioCrossedRowsOverFindableClustersTPC = nCrossedRowsTPC / esdTrack->GetTPCNclsF();
1111 Int_t nClustersTPCShared = esdTrack->GetTPCnclsS();
1112 Float_t fracClustersTPCShared = -1.;
1114 Float_t chi2PerClusterITS = -1;
1115 Float_t chi2PerClusterTPC = -1;
1116 if (nClustersITS!=0)
1117 chi2PerClusterITS = esdTrack->GetITSchi2()/Float_t(nClustersITS);
1118 if (nClustersTPC!=0) {
1119 if(fCutRequireTPCStandAlone) {
1120 chi2PerClusterTPC = esdTrack->GetTPCchi2Iter1()/Float_t(nClustersTPC);
1122 chi2PerClusterTPC = esdTrack->GetTPCchi2()/Float_t(nClustersTPC);
1124 fracClustersTPCShared = Float_t(nClustersTPCShared)/Float_t(nClustersTPC);
1127 Double_t extCov[15];
1128 esdTrack->GetExternalCovariance(extCov);
1132 esdTrack->GetImpactParameters(b,bCov);
1133 if (bCov[0]<=0 || bCov[2]<=0) {
1134 AliDebug(1, "Estimated b resolution lower or equal zero!");
1135 bCov[0]=0; bCov[2]=0;
1139 // set pt-dependent DCA cuts, if requested
1140 SetPtDepDCACuts(esdTrack->Pt());
1143 Float_t dcaToVertexXY = b[0];
1144 Float_t dcaToVertexZ = b[1];
1146 Float_t dcaToVertex = -1;
1148 if (fCutDCAToVertex2D)
1150 dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY/fCutMaxDCAToVertexXY/fCutMaxDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMaxDCAToVertexZ/fCutMaxDCAToVertexZ);
1153 dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY + dcaToVertexZ*dcaToVertexZ);
1155 // getting the kinematic variables of the track
1156 // (assuming the mass is known)
1158 esdTrack->GetPxPyPz(p);
1160 Float_t momentum = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2) + TMath::Power(p[2],2));
1161 Float_t pt = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2));
1162 Float_t energy = TMath::Sqrt(TMath::Power(esdTrack->GetMass(),2) + TMath::Power(momentum,2));
1164 //y-eta related calculations
1165 Float_t eta = -100.;
1167 if((momentum != TMath::Abs(p[2]))&&(momentum != 0))
1168 eta = 0.5*TMath::Log((momentum + p[2])/(momentum - p[2]));
1169 if((energy != TMath::Abs(p[2]))&&(momentum != 0))
1170 y = 0.5*TMath::Log((energy + p[2])/(energy - p[2]));
1174 AliWarning(Form("GetSigma1Pt2() returns negative value for external covariance matrix element fC[14]: %f. Corrupted track information, track will not be accepted!", extCov[14]));
1177 Float_t relUncertainty1Pt = TMath::Sqrt(extCov[14])*pt;
1179 //########################################################################
1182 Bool_t cuts[kNCuts];
1183 for (Int_t i=0; i<kNCuts; i++) cuts[i]=kFALSE;
1185 // track quality cuts
1186 if (fCutRequireTPCRefit && (status&AliESDtrack::kTPCrefit)==0)
1188 if (fCutRequireTPCStandAlone && (status&AliESDtrack::kTPCin)==0)
1190 if (fCutRequireITSRefit && (status&AliESDtrack::kITSrefit)==0)
1192 if (nClustersTPC<fCutMinNClusterTPC)
1194 if (nClustersITS<fCutMinNClusterITS)
1196 if (chi2PerClusterTPC>fCutMaxChi2PerClusterTPC)
1198 if (chi2PerClusterITS>fCutMaxChi2PerClusterITS)
1200 if (extCov[0] > fCutMaxC11)
1202 if (extCov[2] > fCutMaxC22)
1204 if (extCov[5] > fCutMaxC33)
1206 if (extCov[9] > fCutMaxC44)
1208 if (extCov[14] > fCutMaxC55)
1211 // cut 12 and 13 see below
1213 if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
1215 // track kinematics cut
1216 if((momentum < fPMin) || (momentum > fPMax))
1218 if((pt < fPtMin) || (pt > fPtMax))
1220 if((p[0] < fPxMin) || (p[0] > fPxMax))
1222 if((p[1] < fPyMin) || (p[1] > fPyMax))
1224 if((p[2] < fPzMin) || (p[2] > fPzMax))
1226 if((eta < fEtaMin) || (eta > fEtaMax))
1228 if((y < fRapMin) || (y > fRapMax))
1230 if (fCutDCAToVertex2D && dcaToVertex > 1)
1232 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) > fCutMaxDCAToVertexXY)
1234 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) > fCutMaxDCAToVertexZ)
1236 if (fCutDCAToVertex2D && fCutMinDCAToVertexXY > 0 && fCutMinDCAToVertexZ > 0 && dcaToVertexXY*dcaToVertexXY/fCutMinDCAToVertexXY/fCutMinDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMinDCAToVertexZ/fCutMinDCAToVertexZ < 1)
1238 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) < fCutMinDCAToVertexXY)
1240 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) < fCutMinDCAToVertexZ)
1243 for (Int_t i = 0; i < 3; i++)
1244 cuts[28+i] = !CheckITSClusterRequirement(fCutClusterRequirementITS[i], esdTrack->HasPointOnITSLayer(i*2), esdTrack->HasPointOnITSLayer(i*2+1));
1246 if(fCutRequireITSStandAlone || fCutRequireITSpureSA){
1247 if ((status & AliESDtrack::kITSin) == 0 || (status & AliESDtrack::kTPCin)){
1251 // ITS standalone tracks
1252 if(fCutRequireITSStandAlone && !fCutRequireITSpureSA){
1253 if(status & AliESDtrack::kITSpureSA) cuts[31] = kTRUE;
1254 }else if(fCutRequireITSpureSA){
1255 if(!(status & AliESDtrack::kITSpureSA)) cuts[31] = kTRUE;
1260 if (relUncertainty1Pt > fCutMaxRel1PtUncertainty)
1263 if (!fCutAcceptSharedTPCClusters && nClustersTPCShared!=0)
1266 if (fracClustersTPCShared > fCutMaxFractionSharedTPCClusters)
1269 Int_t nITSPointsForPid=0;
1270 UChar_t clumap=esdTrack->GetITSClusterMap();
1271 for(Int_t i=2; i<6; i++){
1272 if(clumap&(1<<i)) ++nITSPointsForPid;
1274 if(fCutRequireITSPid && nITSPointsForPid<3) cuts[35] = kTRUE;
1277 if (nCrossedRowsTPC<fCutMinNCrossedRowsTPC)
1279 if (ratioCrossedRowsOverFindableClustersTPC<fCutMinRatioCrossedRowsOverFindableClustersTPC)
1282 Int_t nMissITSpts=0;
1283 Int_t idet,statusLay;
1285 for(Int_t iLay=0; iLay<6; iLay++){
1286 Bool_t retc=esdTrack->GetITSModuleIndexInfo(iLay,idet,statusLay,xloc,zloc);
1287 if(retc && statusLay==5) ++nMissITSpts;
1289 if(nMissITSpts>fCutMaxMissingITSPoints) cuts[38] = kTRUE;
1292 if (fCutRequireTOFout && (status&AliESDtrack::kTOFout)==0)
1295 // TOF signal Dz cut
1296 Float_t dxTOF = esdTrack->GetTOFsignalDx();
1297 Float_t dzTOF = esdTrack->GetTOFsignalDz();
1298 if (fFlagCutTOFdistance && (esdTrack->GetStatus() & AliESDtrack::kTOFout) == AliESDtrack::kTOFout){ // applying the TOF distance cut only if requested, and only on tracks that reached the TOF and where associated with a TOF hit
1299 if (fgBeamTypeFlag < 0) { // the check on the beam type was not done yet
1300 const AliESDEvent* event = esdTrack->GetESDEvent();
1302 TString beamTypeESD = event->GetBeamType();
1303 AliDebug(2,Form("Beam type from ESD event = %s",beamTypeESD.Data()));
1304 if (beamTypeESD.CompareTo("A-A",TString::kIgnoreCase) == 0){ // we are in PbPb collisions --> fgBeamTypeFlag will be set to 1, to apply the cut on TOF signal Dz
1307 else { // we are NOT in PbPb collisions --> fgBeamTypeFlag will be set to 0, to NOT apply the cu6 on TOF signal Dz
1312 AliFatal("Beam type not available, but it is needed to apply the TOF cut!");
1316 if (fgBeamTypeFlag == 1){ // we are in PbPb collisions --> apply the cut on TOF signal Dz
1317 Float_t radiusTOF = TMath::Sqrt(dxTOF*dxTOF + dzTOF*dzTOF);
1318 AliDebug(3,Form("TOF check (with fCutTOFdistance = %f) --> dx = %f, dz = %f, radius = %f", fCutTOFdistance, dxTOF, dzTOF, radiusTOF));
1319 if (radiusTOF > fCutTOFdistance){
1320 AliDebug(2, Form("************* the radius is outside the range! %f > %f, the track will be skipped", radiusTOF, fCutTOFdistance));
1327 for (Int_t i=0; i<kNCuts; i++)
1328 if (cuts[i]) {cut = kTRUE;}
1330 // for performance evaluate the CPU intensive cuts only when the others have passed, and when they are requested
1331 Double_t chi2TPCConstrainedVsGlobal = -2;
1332 Float_t nSigmaToVertex = -2;
1335 // getting the track to vertex parameters
1336 if (fCutSigmaToVertexRequired)
1338 nSigmaToVertex = GetSigmaToVertex(esdTrack);
1339 if (nSigmaToVertex > fCutNsigmaToVertex && fCutSigmaToVertexRequired)
1344 // if n sigma could not be calculated
1345 if (nSigmaToVertex<0 && fCutSigmaToVertexRequired)
1352 // max chi2 TPC constrained vs global track only if track passed the other cut
1353 if (fCutMaxChi2TPCConstrainedVsGlobal < 1e9)
1355 const AliESDEvent* esdEvent = esdTrack->GetESDEvent();
1358 AliFatal("fCutMaxChi2TPCConstrainedVsGlobal set but ESD event not set in AliESDTrack. Use AliESDTrack::SetESDEvent before calling AliESDtrackCuts.");
1361 const AliESDVertex* vertex = 0;
1362 if (fCutMaxChi2TPCConstrainedVsGlobalVertexType & kVertexTracks)
1363 vertex = esdEvent->GetPrimaryVertexTracks();
1365 if ((!vertex || !vertex->GetStatus()) && fCutMaxChi2TPCConstrainedVsGlobalVertexType & kVertexSPD)
1366 vertex = esdEvent->GetPrimaryVertexSPD();
1368 if ((!vertex || !vertex->GetStatus()) && fCutMaxChi2TPCConstrainedVsGlobalVertexType & kVertexTPC)
1369 vertex = esdEvent->GetPrimaryVertexTPC();
1371 if (vertex->GetStatus())
1372 chi2TPCConstrainedVsGlobal = esdTrack->GetChi2TPCConstrainedVsGlobal(vertex);
1374 if (chi2TPCConstrainedVsGlobal < 0 || chi2TPCConstrainedVsGlobal > fCutMaxChi2TPCConstrainedVsGlobal)
1382 //########################################################################
1383 // filling histograms
1384 if (fHistogramsOn) {
1385 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n tracks")));
1387 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n cut tracks")));
1389 for (Int_t i=0; i<kNCuts; i++) {
1390 if (fhCutStatistics->GetXaxis()->FindBin(fgkCutNames[i]) < 1)
1391 AliFatal(Form("Inconsistency! Cut %d with name %s not found", i, fgkCutNames[i]));
1394 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin(fgkCutNames[i])));
1396 for (Int_t j=i; j<kNCuts; j++) {
1397 if (cuts[i] && cuts[j]) {
1398 Float_t xC = fhCutCorrelation->GetXaxis()->GetBinCenter(fhCutCorrelation->GetXaxis()->FindBin(fgkCutNames[i]));
1399 Float_t yC = fhCutCorrelation->GetYaxis()->GetBinCenter(fhCutCorrelation->GetYaxis()->FindBin(fgkCutNames[j]));
1400 fhCutCorrelation->Fill(xC, yC);
1406 // now we loop over the filling of the histograms twice: once "before" the cut, once "after"
1407 // the code is not in a function due to too many local variables that would need to be passed
1409 for (Int_t id = 0; id < 2; id++)
1411 // id = 0 --> before cut
1412 // id = 1 --> after cut
1416 fhNClustersITS[id]->Fill(nClustersITS);
1417 fhNClustersTPC[id]->Fill(nClustersTPC);
1418 fhNSharedClustersTPC[id]->Fill(nClustersTPCShared);
1419 fhNCrossedRowsTPC[id]->Fill(nCrossedRowsTPC);
1420 fhRatioCrossedRowsOverFindableClustersTPC[id]->Fill(ratioCrossedRowsOverFindableClustersTPC);
1421 fhChi2PerClusterITS[id]->Fill(chi2PerClusterITS);
1422 fhChi2PerClusterTPC[id]->Fill(chi2PerClusterTPC);
1423 fhChi2TPCConstrainedVsGlobal[id]->Fill(chi2TPCConstrainedVsGlobal);
1424 fhNClustersForITSPID[id]->Fill(nITSPointsForPid);
1425 fhNMissingITSPoints[id]->Fill(nMissITSpts);
1427 fhC11[id]->Fill(extCov[0]);
1428 fhC22[id]->Fill(extCov[2]);
1429 fhC33[id]->Fill(extCov[5]);
1430 fhC44[id]->Fill(extCov[9]);
1431 fhC55[id]->Fill(extCov[14]);
1433 fhRel1PtUncertainty[id]->Fill(relUncertainty1Pt);
1436 fhEta[id]->Fill(eta);
1437 fhTOFdistance[id]->Fill(dxTOF, dzTOF);
1440 bRes[0] = TMath::Sqrt(bCov[0]);
1441 bRes[1] = TMath::Sqrt(bCov[2]);
1443 fhDZ[id]->Fill(b[1]);
1444 fhDXY[id]->Fill(b[0]);
1445 fhDXYDZ[id]->Fill(dcaToVertex);
1446 fhDXYvsDZ[id]->Fill(b[1],b[0]);
1448 if (bRes[0]!=0 && bRes[1]!=0) {
1449 fhDZNormalized[id]->Fill(b[1]/bRes[1]);
1450 fhDXYNormalized[id]->Fill(b[0]/bRes[0]);
1451 fhDXYvsDZNormalized[id]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
1452 fhNSigmaToVertex[id]->Fill(nSigmaToVertex);
1464 //____________________________________________________________________
1465 Bool_t AliESDtrackCuts::CheckITSClusterRequirement(ITSClusterRequirement req, Bool_t clusterL1, Bool_t clusterL2)
1467 // checks if the cluster requirement is fullfilled (in this case: return kTRUE)
1471 case kOff: return kTRUE;
1472 case kNone: return !clusterL1 && !clusterL2;
1473 case kAny: return clusterL1 || clusterL2;
1474 case kFirst: return clusterL1;
1475 case kOnlyFirst: return clusterL1 && !clusterL2;
1476 case kSecond: return clusterL2;
1477 case kOnlySecond: return clusterL2 && !clusterL1;
1478 case kBoth: return clusterL1 && clusterL2;
1484 //____________________________________________________________________
1485 AliESDtrack* AliESDtrackCuts::GetTPCOnlyTrack(const AliESDEvent* esd, Int_t iTrack)
1487 // Utility function to create a TPC only track from the given esd track
1489 // IMPORTANT: The track has to be deleted by the user
1491 // NB. most of the functionality to get a TPC only track from an ESD track is in AliESDtrack, where it should be
1492 // there are only missing propagations here that are needed for old data
1493 // this function will therefore become obsolete
1495 // adapted from code provided by CKB
1497 if (!esd->GetPrimaryVertexTPC())
1498 return 0; // No TPC vertex no TPC tracks
1500 if(!esd->GetPrimaryVertexTPC()->GetStatus())
1501 return 0; // TPC Vertex is created by default in AliESDEvent, do not use in this case
1503 AliESDtrack* track = esd->GetTrack(iTrack);
1507 AliESDtrack *tpcTrack = new AliESDtrack();
1509 // only true if we have a tpc track
1510 if (!track->FillTPCOnlyTrack(*tpcTrack))
1519 //____________________________________________________________________
1520 TObjArray* AliESDtrackCuts::GetAcceptedTracks(const AliESDEvent* esd, Bool_t bTPC)
1523 // returns an array of all tracks that pass the cuts
1524 // or an array of TPC only tracks (propagated to the TPC vertex during reco)
1525 // tracks that pass the cut
1527 // NOTE: List has to be deleted by the user
1529 TObjArray* acceptedTracks = new TObjArray();
1531 // loop over esd tracks
1532 for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
1534 if(!esd->GetPrimaryVertexTPC())return acceptedTracks; // No TPC vertex no TPC tracks
1535 if(!esd->GetPrimaryVertexTPC()->GetStatus())return acceptedTracks; // No proper TPC vertex, only the default
1537 AliESDtrack *tpcTrack = GetTPCOnlyTrack(esd, iTrack);
1541 if (AcceptTrack(tpcTrack)) {
1542 acceptedTracks->Add(tpcTrack);
1549 AliESDtrack* track = esd->GetTrack(iTrack);
1550 if(AcceptTrack(track))
1551 acceptedTracks->Add(track);
1554 if(bTPC)acceptedTracks->SetOwner(kTRUE);
1555 return acceptedTracks;
1558 //____________________________________________________________________
1559 Int_t AliESDtrackCuts::CountAcceptedTracks(const AliESDEvent* const esd)
1562 // returns an the number of tracks that pass the cuts
1567 // loop over esd tracks
1568 for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
1569 AliESDtrack* track = esd->GetTrack(iTrack);
1570 if (AcceptTrack(track))
1577 //____________________________________________________________________
1578 void AliESDtrackCuts::DefineHistograms(Int_t color) {
1580 // diagnostics histograms are defined
1583 fHistogramsOn=kTRUE;
1585 Bool_t oldStatus = TH1::AddDirectoryStatus();
1586 TH1::AddDirectory(kFALSE);
1588 //###################################################################################
1589 // defining histograms
1591 fhCutStatistics = new TH1F("cut_statistics","cut statistics",kNCuts+4,-0.5,kNCuts+3.5);
1593 fhCutStatistics->GetXaxis()->SetBinLabel(1,"n tracks");
1594 fhCutStatistics->GetXaxis()->SetBinLabel(2,"n cut tracks");
1596 fhCutCorrelation = new TH2F("cut_correlation","cut correlation",kNCuts,-0.5,kNCuts-0.5,kNCuts,-0.5,kNCuts-0.5);;
1598 for (Int_t i=0; i<kNCuts; i++) {
1599 fhCutStatistics->GetXaxis()->SetBinLabel(i+4,fgkCutNames[i]);
1600 fhCutCorrelation->GetXaxis()->SetBinLabel(i+1,fgkCutNames[i]);
1601 fhCutCorrelation->GetYaxis()->SetBinLabel(i+1,fgkCutNames[i]);
1604 fhCutStatistics ->SetLineColor(color);
1605 fhCutCorrelation ->SetLineColor(color);
1606 fhCutStatistics ->SetLineWidth(2);
1607 fhCutCorrelation ->SetLineWidth(2);
1609 for (Int_t i=0; i<2; i++) {
1610 fhNClustersITS[i] = new TH1F("nClustersITS" ,"",8,-0.5,7.5);
1611 fhNClustersTPC[i] = new TH1F("nClustersTPC" ,"",165,-0.5,164.5);
1612 fhNSharedClustersTPC[i] = new TH1F("nSharedClustersTPC" ,"",165,-0.5,164.5);
1613 fhNCrossedRowsTPC[i] = new TH1F("nCrossedRowsTPC" ,"",165,-0.5,164.5);
1614 fhRatioCrossedRowsOverFindableClustersTPC[i] = new TH1F("ratioCrossedRowsOverFindableClustersTPC" ,"",60,0,1.5);
1615 fhChi2PerClusterITS[i] = new TH1F("chi2PerClusterITS","",500,0,10);
1616 fhChi2PerClusterTPC[i] = new TH1F("chi2PerClusterTPC","",500,0,10);
1617 fhChi2TPCConstrainedVsGlobal[i] = new TH1F("chi2TPCConstrainedVsGlobal","",600,-2,50);
1618 fhNClustersForITSPID[i] = new TH1F("nPointsForITSpid","",5,-0.5,4.5);
1619 fhNMissingITSPoints[i] = new TH1F("nMissingITSClusters","",7,-0.5,6.5);
1621 fhC11[i] = new TH1F("covMatrixDiagonal11","",2000,0,20);
1622 fhC22[i] = new TH1F("covMatrixDiagonal22","",2000,0,20);
1623 fhC33[i] = new TH1F("covMatrixDiagonal33","",1000,0,0.1);
1624 fhC44[i] = new TH1F("covMatrixDiagonal44","",1000,0,0.1);
1625 fhC55[i] = new TH1F("covMatrixDiagonal55","",1000,0,5);
1627 fhRel1PtUncertainty[i] = new TH1F("rel1PtUncertainty","",1000,0,5);
1629 fhDXY[i] = new TH1F("dXY" ,"",500,-10,10);
1630 fhDZ[i] = new TH1F("dZ" ,"",500,-10,10);
1631 fhDXYDZ[i] = new TH1F("dXYDZ" ,"",500,0,10);
1632 fhDXYvsDZ[i] = new TH2F("dXYvsDZ","",200,-10,10,200,-10,10);
1634 fhDXYNormalized[i] = new TH1F("dXYNormalized" ,"",500,-10,10);
1635 fhDZNormalized[i] = new TH1F("dZNormalized" ,"",500,-10,10);
1636 fhDXYvsDZNormalized[i] = new TH2F("dXYvsDZNormalized","",200,-10,10,200,-10,10);
1638 fhNSigmaToVertex[i] = new TH1F("nSigmaToVertex","",500,0,10);
1640 fhPt[i] = new TH1F("pt" ,"p_{T} distribution;p_{T} (GeV/c)", 800, 0.0, 10.0);
1641 fhEta[i] = new TH1F("eta" ,"#eta distribution;#eta",40,-2.0,2.0);
1642 fhTOFdistance[i] = new TH2F("TOFdistance" ,"TOF distance;dx (cm};dz (cm)", 150, -15, 15, 150, -15, 15);
1644 fhNClustersITS[i]->SetTitle("n ITS clusters");
1645 fhNClustersTPC[i]->SetTitle("n TPC clusters");
1646 fhNSharedClustersTPC[i]->SetTitle("n TPC shared clusters");
1647 fhChi2PerClusterITS[i]->SetTitle("#Chi^{2} per ITS cluster");
1648 fhChi2PerClusterTPC[i]->SetTitle("#Chi^{2} per TPC cluster");
1649 fhChi2TPCConstrainedVsGlobal[i]->SetTitle("#Chi^{2} TPC constrained track vs global track");
1650 fhNClustersForITSPID[i]->SetTitle("n ITS points for PID");
1651 fhNMissingITSPoints[i]->SetTitle("n ITS layers with missing cluster");
1653 fhC11[i]->SetTitle("cov 11 : #sigma_{y}^{2} [cm^{2}]");
1654 fhC22[i]->SetTitle("cov 22 : #sigma_{z}^{2} [cm^{2}]");
1655 fhC33[i]->SetTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
1656 fhC44[i]->SetTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
1657 fhC55[i]->SetTitle("cov 55 : #sigma_{1/p_{T}}^{2} [(c/GeV)^2]");
1659 fhRel1PtUncertainty[i]->SetTitle("rel. uncertainty of 1/p_{T}");
1661 fhDXY[i]->SetXTitle("transverse impact parameter (cm)");
1662 fhDZ[i]->SetXTitle("longitudinal impact parameter (cm)");
1663 fhDXYDZ[i]->SetTitle("absolute impact parameter;sqrt(dXY**2 + dZ**2) (cm)");
1664 fhDXYvsDZ[i]->SetXTitle("longitudinal impact parameter (cm)");
1665 fhDXYvsDZ[i]->SetYTitle("transverse impact parameter (cm)");
1667 fhDXYNormalized[i]->SetTitle("normalized trans impact par (n#sigma)");
1668 fhDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)");
1669 fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)");
1670 fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par (n#sigma)");
1671 fhNSigmaToVertex[i]->SetTitle("n #sigma to vertex");
1673 fhNClustersITS[i]->SetLineColor(color); fhNClustersITS[i]->SetLineWidth(2);
1674 fhNClustersTPC[i]->SetLineColor(color); fhNClustersTPC[i]->SetLineWidth(2);
1675 fhNSharedClustersTPC[i]->SetLineColor(color); fhNSharedClustersTPC[i]->SetLineWidth(2);
1676 fhChi2PerClusterITS[i]->SetLineColor(color); fhChi2PerClusterITS[i]->SetLineWidth(2);
1677 fhChi2PerClusterTPC[i]->SetLineColor(color); fhChi2PerClusterTPC[i]->SetLineWidth(2);
1678 fhChi2TPCConstrainedVsGlobal[i]->SetLineColor(color); fhChi2TPCConstrainedVsGlobal[i]->SetLineWidth(2);
1679 fhNClustersForITSPID[i]->SetLineColor(color); fhNClustersForITSPID[i]->SetLineWidth(2);
1680 fhNMissingITSPoints[i]->SetLineColor(color); fhNMissingITSPoints[i]->SetLineWidth(2);
1682 fhC11[i]->SetLineColor(color); fhC11[i]->SetLineWidth(2);
1683 fhC22[i]->SetLineColor(color); fhC22[i]->SetLineWidth(2);
1684 fhC33[i]->SetLineColor(color); fhC33[i]->SetLineWidth(2);
1685 fhC44[i]->SetLineColor(color); fhC44[i]->SetLineWidth(2);
1686 fhC55[i]->SetLineColor(color); fhC55[i]->SetLineWidth(2);
1688 fhRel1PtUncertainty[i]->SetLineColor(color); fhRel1PtUncertainty[i]->SetLineWidth(2);
1690 fhDXY[i]->SetLineColor(color); fhDXY[i]->SetLineWidth(2);
1691 fhDZ[i]->SetLineColor(color); fhDZ[i]->SetLineWidth(2);
1692 fhDXYDZ[i]->SetLineColor(color); fhDXYDZ[i]->SetLineWidth(2);
1694 fhDXYNormalized[i]->SetLineColor(color); fhDXYNormalized[i]->SetLineWidth(2);
1695 fhDZNormalized[i]->SetLineColor(color); fhDZNormalized[i]->SetLineWidth(2);
1696 fhNSigmaToVertex[i]->SetLineColor(color); fhNSigmaToVertex[i]->SetLineWidth(2);
1699 // The number of sigmas to the vertex is per definition gaussian
1700 ffDTheoretical = new TF1("nSigmaToVertexTheoretical","([0]/2.506628274)*exp(-(x**2)/2)",0,50);
1701 ffDTheoretical->SetParameter(0,1);
1703 TH1::AddDirectory(oldStatus);
1706 //____________________________________________________________________
1707 Bool_t AliESDtrackCuts::LoadHistograms(const Char_t* dir)
1710 // loads the histograms from a file
1711 // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
1717 if (!gDirectory->cd(dir))
1720 ffDTheoretical = dynamic_cast<TF1*> (gDirectory->Get("nSigmaToVertexTheory"));
1722 fhCutStatistics = dynamic_cast<TH1F*> (gDirectory->Get("cut_statistics"));
1723 fhCutCorrelation = dynamic_cast<TH2F*> (gDirectory->Get("cut_correlation"));
1725 for (Int_t i=0; i<2; i++) {
1728 gDirectory->cd("before_cuts");
1731 gDirectory->cd("after_cuts");
1733 fhNClustersITS[i] = dynamic_cast<TH1F*> (gDirectory->Get("nClustersITS" ));
1734 fhNClustersTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("nClustersTPC" ));
1735 fhNSharedClustersTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("nSharedClustersTPC" ));
1736 fhNCrossedRowsTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("nCrossedRowsTPC" ));
1737 fhRatioCrossedRowsOverFindableClustersTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("ratioCrossedRowsOverFindableClustersTPC" ));
1738 fhChi2PerClusterITS[i] = dynamic_cast<TH1F*> (gDirectory->Get("chi2PerClusterITS"));
1739 fhChi2PerClusterTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("chi2PerClusterTPC"));
1740 fhChi2TPCConstrainedVsGlobal[i] = dynamic_cast<TH1F*> (gDirectory->Get("fhChi2TPCConstrainedVsGlobal"));
1741 fhNClustersForITSPID[i] = dynamic_cast<TH1F*> (gDirectory->Get("nPointsForITSpid"));
1742 fhNMissingITSPoints[i] = dynamic_cast<TH1F*> (gDirectory->Get("nMissingITSClusters"));
1744 fhC11[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal11"));
1745 fhC22[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal22"));
1746 fhC33[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal33"));
1747 fhC44[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal44"));
1748 fhC55[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal55"));
1750 fhRel1PtUncertainty[i] = dynamic_cast<TH1F*> (gDirectory->Get("rel1PtUncertainty"));
1752 fhDXY[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXY" ));
1753 fhDZ[i] = dynamic_cast<TH1F*> (gDirectory->Get("dZ" ));
1754 fhDXYDZ[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXYDZ"));
1755 fhDXYvsDZ[i] = dynamic_cast<TH2F*> (gDirectory->Get("dXYvsDZ"));
1757 fhDXYNormalized[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXYNormalized" ));
1758 fhDZNormalized[i] = dynamic_cast<TH1F*> (gDirectory->Get("dZNormalized" ));
1759 fhDXYvsDZNormalized[i] = dynamic_cast<TH2F*> (gDirectory->Get("dXYvsDZNormalized"));
1760 fhNSigmaToVertex[i] = dynamic_cast<TH1F*> (gDirectory->Get("nSigmaToVertex"));
1762 fhPt[i] = dynamic_cast<TH1F*> (gDirectory->Get("pt"));
1763 fhEta[i] = dynamic_cast<TH1F*> (gDirectory->Get("eta"));
1764 fhTOFdistance[i] = dynamic_cast<TH2F*> (gDirectory->Get("TOFdistance"));
1766 gDirectory->cd("../");
1769 gDirectory->cd("..");
1774 //____________________________________________________________________
1775 void AliESDtrackCuts::SaveHistograms(const Char_t* dir) {
1777 // saves the histograms in a directory (dir)
1780 if (!fHistogramsOn) {
1781 AliDebug(0, "Histograms not on - cannot save histograms!!!");
1788 gDirectory->mkdir(dir);
1789 gDirectory->cd(dir);
1791 gDirectory->mkdir("before_cuts");
1792 gDirectory->mkdir("after_cuts");
1794 // a factor of 2 is needed since n sigma is positive
1795 ffDTheoretical->SetParameter(0,2*fhNSigmaToVertex[0]->Integral("width"));
1796 ffDTheoretical->Write("nSigmaToVertexTheory");
1798 fhCutStatistics->Write();
1799 fhCutCorrelation->Write();
1801 for (Int_t i=0; i<2; i++) {
1803 gDirectory->cd("before_cuts");
1805 gDirectory->cd("after_cuts");
1807 fhNClustersITS[i] ->Write();
1808 fhNClustersTPC[i] ->Write();
1809 fhNSharedClustersTPC[i] ->Write();
1810 fhNCrossedRowsTPC[i] ->Write();
1811 fhRatioCrossedRowsOverFindableClustersTPC[i] ->Write();
1812 fhChi2PerClusterITS[i] ->Write();
1813 fhChi2PerClusterTPC[i] ->Write();
1814 fhChi2TPCConstrainedVsGlobal[i] ->Write();
1815 fhNClustersForITSPID[i] ->Write();
1816 fhNMissingITSPoints[i] ->Write();
1824 fhRel1PtUncertainty[i] ->Write();
1828 fhDXYDZ[i] ->Write();
1829 fhDXYvsDZ[i] ->Write();
1831 fhDXYNormalized[i] ->Write();
1832 fhDZNormalized[i] ->Write();
1833 fhDXYvsDZNormalized[i] ->Write();
1834 fhNSigmaToVertex[i] ->Write();
1838 fhTOFdistance[i] ->Write();
1840 gDirectory->cd("../");
1843 gDirectory->cd("../");
1846 //____________________________________________________________________
1847 void AliESDtrackCuts::DrawHistograms()
1849 // draws some histograms
1851 TCanvas* canvas1 = new TCanvas(Form("%s_1", GetName()), "Track Quality Results1", 800, 800);
1852 canvas1->Divide(2, 2);
1855 fhNClustersTPC[0]->SetStats(kFALSE);
1856 fhNClustersTPC[0]->Draw();
1859 fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1860 fhChi2PerClusterTPC[0]->Draw();
1863 fhNSigmaToVertex[0]->SetStats(kFALSE);
1864 fhNSigmaToVertex[0]->GetXaxis()->SetRangeUser(0, 10);
1865 fhNSigmaToVertex[0]->Draw();
1867 canvas1->SaveAs(Form("%s_%s.gif", GetName(), canvas1->GetName()));
1869 TCanvas* canvas2 = new TCanvas(Form("%s_2", GetName()), "Track Quality Results2", 1200, 800);
1870 canvas2->Divide(3, 2);
1873 fhC11[0]->SetStats(kFALSE);
1878 fhC22[0]->SetStats(kFALSE);
1883 fhC33[0]->SetStats(kFALSE);
1888 fhC44[0]->SetStats(kFALSE);
1893 fhC55[0]->SetStats(kFALSE);
1898 fhRel1PtUncertainty[0]->SetStats(kFALSE);
1900 fhRel1PtUncertainty[0]->Draw();
1902 canvas2->SaveAs(Form("%s_%s.gif", GetName(), canvas2->GetName()));
1904 TCanvas* canvas3 = new TCanvas(Form("%s_3", GetName()), "Track Quality Results3", 1200, 800);
1905 canvas3->Divide(3, 2);
1908 fhDXY[0]->SetStats(kFALSE);
1913 fhDZ[0]->SetStats(kFALSE);
1918 fhDXYvsDZ[0]->SetStats(kFALSE);
1920 gPad->SetRightMargin(0.15);
1921 fhDXYvsDZ[0]->Draw("COLZ");
1924 fhDXYNormalized[0]->SetStats(kFALSE);
1926 fhDXYNormalized[0]->Draw();
1929 fhDZNormalized[0]->SetStats(kFALSE);
1931 fhDZNormalized[0]->Draw();
1934 fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1936 gPad->SetRightMargin(0.15);
1937 fhDXYvsDZNormalized[0]->Draw("COLZ");
1939 canvas3->SaveAs(Form("%s_%s.gif", GetName(), canvas3->GetName()));
1941 TCanvas* canvas4 = new TCanvas(Form("%s_4", GetName()), "Track Quality Results4", 800, 500);
1942 canvas4->Divide(2, 1);
1945 fhCutStatistics->SetStats(kFALSE);
1946 fhCutStatistics->LabelsOption("v");
1947 gPad->SetBottomMargin(0.3);
1948 fhCutStatistics->Draw();
1951 fhCutCorrelation->SetStats(kFALSE);
1952 fhCutCorrelation->LabelsOption("v");
1953 gPad->SetBottomMargin(0.3);
1954 gPad->SetLeftMargin(0.3);
1955 fhCutCorrelation->Draw("COLZ");
1957 canvas4->SaveAs(Form("%s_%s.gif", GetName(), canvas4->GetName()));
1960 fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1961 fhDXYvsDZNormalized[0]->DrawCopy("COLZ");
1964 fhNClustersTPC[0]->SetStats(kFALSE);
1965 fhNClustersTPC[0]->DrawCopy();
1968 fhChi2PerClusterITS[0]->SetStats(kFALSE);
1969 fhChi2PerClusterITS[0]->DrawCopy();
1970 fhChi2PerClusterITS[1]->SetLineColor(2);
1971 fhChi2PerClusterITS[1]->DrawCopy("SAME");
1974 fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1975 fhChi2PerClusterTPC[0]->DrawCopy();
1976 fhChi2PerClusterTPC[1]->SetLineColor(2);
1977 fhChi2PerClusterTPC[1]->DrawCopy("SAME");*/
1979 //--------------------------------------------------------------------------
1980 void AliESDtrackCuts::SetPtDepDCACuts(Double_t pt) {
1982 // set the pt-dependent DCA cuts
1985 if(f1CutMaxDCAToVertexXYPtDep) {
1986 fCutMaxDCAToVertexXY=f1CutMaxDCAToVertexXYPtDep->Eval(pt);
1989 if(f1CutMaxDCAToVertexZPtDep) {
1990 fCutMaxDCAToVertexZ=f1CutMaxDCAToVertexZPtDep->Eval(pt);
1993 if(f1CutMinDCAToVertexXYPtDep) {
1994 fCutMinDCAToVertexXY=f1CutMinDCAToVertexXYPtDep->Eval(pt);
1997 if(f1CutMinDCAToVertexZPtDep) {
1998 fCutMinDCAToVertexZ=f1CutMinDCAToVertexZPtDep->Eval(pt);
2007 //--------------------------------------------------------------------------
2008 Bool_t AliESDtrackCuts::CheckPtDepDCA(TString dist,Bool_t print) const {
2010 // Check the correctness of the string syntax
2012 Bool_t retval=kTRUE;
2014 if(!dist.Contains("pt")) {
2015 if(print) AliError("string must contain \"pt\"");
2021 void AliESDtrackCuts::SetMaxDCAToVertexXYPtDep(const char *dist){
2023 if(f1CutMaxDCAToVertexXYPtDep){
2024 delete f1CutMaxDCAToVertexXYPtDep;
2026 f1CutMaxDCAToVertexXYPtDep = 0;
2027 fCutMaxDCAToVertexXYPtDep = "";
2029 if(!CheckPtDepDCA(dist,kTRUE)){
2032 fCutMaxDCAToVertexXYPtDep = dist;
2034 tmp.ReplaceAll("pt","x");
2035 f1CutMaxDCAToVertexXYPtDep = new TFormula("f1CutMaxDCAToVertexXYPtDep",tmp.Data());
2039 void AliESDtrackCuts::SetMaxDCAToVertexZPtDep(const char *dist){
2042 if(f1CutMaxDCAToVertexZPtDep){
2043 delete f1CutMaxDCAToVertexZPtDep;
2045 f1CutMaxDCAToVertexZPtDep = 0;
2046 fCutMaxDCAToVertexZPtDep = "";
2048 if(!CheckPtDepDCA(dist,kTRUE))return;
2050 fCutMaxDCAToVertexZPtDep = dist;
2052 tmp.ReplaceAll("pt","x");
2053 f1CutMaxDCAToVertexZPtDep = new TFormula("f1CutMaxDCAToVertexZPtDep",tmp.Data());
2059 void AliESDtrackCuts::SetMinDCAToVertexXYPtDep(const char *dist){
2062 if(f1CutMinDCAToVertexXYPtDep){
2063 delete f1CutMinDCAToVertexXYPtDep;
2065 f1CutMinDCAToVertexXYPtDep = 0;
2066 fCutMinDCAToVertexXYPtDep = "";
2068 if(!CheckPtDepDCA(dist,kTRUE))return;
2070 fCutMinDCAToVertexXYPtDep = dist;
2072 tmp.ReplaceAll("pt","x");
2073 f1CutMinDCAToVertexXYPtDep = new TFormula("f1CutMinDCAToVertexXYPtDep",tmp.Data());
2078 void AliESDtrackCuts::SetMinDCAToVertexZPtDep(const char *dist){
2082 if(f1CutMinDCAToVertexZPtDep){
2083 delete f1CutMinDCAToVertexZPtDep;
2085 f1CutMinDCAToVertexZPtDep = 0;
2086 fCutMinDCAToVertexZPtDep = "";
2088 if(!CheckPtDepDCA(dist,kTRUE))return;
2089 fCutMinDCAToVertexZPtDep = dist;
2091 tmp.ReplaceAll("pt","x");
2092 f1CutMinDCAToVertexZPtDep = new TFormula("f1CutMinDCAToVertexZPtDep",tmp.Data());
2095 AliESDtrackCuts* AliESDtrackCuts::GetMultEstTrackCuts(MultEstTrackCuts cut)
2097 // returns the multiplicity estimator track cuts objects to allow for user configuration
2098 // upon first call the objects are created
2100 // the cut defined here correspond to GetStandardITSTPCTrackCuts2010 (apart from the one for without SPD)
2102 if (!fgMultEstTrackCuts[kMultEstTrackCutGlobal])
2104 // quality cut on ITS+TPC tracks
2105 fgMultEstTrackCuts[kMultEstTrackCutGlobal] = new AliESDtrackCuts();
2106 fgMultEstTrackCuts[kMultEstTrackCutGlobal]->SetMinNClustersTPC(70);
2107 fgMultEstTrackCuts[kMultEstTrackCutGlobal]->SetMaxChi2PerClusterTPC(4);
2108 fgMultEstTrackCuts[kMultEstTrackCutGlobal]->SetAcceptKinkDaughters(kFALSE);
2109 fgMultEstTrackCuts[kMultEstTrackCutGlobal]->SetRequireTPCRefit(kTRUE);
2110 fgMultEstTrackCuts[kMultEstTrackCutGlobal]->SetRequireITSRefit(kTRUE);
2111 //multiplicity underestimate if we use global tracks with |eta| > 0.9
2112 fgMultEstTrackCuts[kMultEstTrackCutGlobal]->SetEtaRange(-0.9, 0.9);
2114 // quality cut on ITS_SA tracks (complementary to ITS+TPC)
2115 fgMultEstTrackCuts[kMultEstTrackCutITSSA] = new AliESDtrackCuts();
2116 fgMultEstTrackCuts[kMultEstTrackCutITSSA]->SetRequireITSRefit(kTRUE);
2118 // primary selection for tracks with SPD hits
2119 fgMultEstTrackCuts[kMultEstTrackCutDCAwSPD] = new AliESDtrackCuts();
2120 fgMultEstTrackCuts[kMultEstTrackCutDCAwSPD]->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
2121 fgMultEstTrackCuts[kMultEstTrackCutDCAwSPD]->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
2122 fgMultEstTrackCuts[kMultEstTrackCutDCAwSPD]->SetMaxDCAToVertexZ(2);
2124 // primary selection for tracks w/o SPD hits
2125 fgMultEstTrackCuts[kMultEstTrackCutDCAwoSPD] = new AliESDtrackCuts();
2126 fgMultEstTrackCuts[kMultEstTrackCutDCAwoSPD]->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kNone);
2127 fgMultEstTrackCuts[kMultEstTrackCutDCAwoSPD]->SetMaxDCAToVertexXYPtDep("1.5*(0.0182+0.0350/pt^1.01)");
2128 fgMultEstTrackCuts[kMultEstTrackCutDCAwoSPD]->SetMaxDCAToVertexZ(2);
2131 return fgMultEstTrackCuts[cut];
2134 Int_t AliESDtrackCuts::GetReferenceMultiplicity(const AliESDEvent* esd, MultEstTrackType trackType, Float_t etaRange)
2136 // Get multiplicity estimate based on TPC/ITS tracks and tracklets
2137 // Adapted for AliESDtrackCuts from a version developed by: Ruben Shahoyan, Anton Alkin, Arvinder Palaha
2139 // Returns a negative value if no reliable estimate can be provided:
2140 // -1 SPD vertex missing
2141 // -2 SPD VertexerZ dispersion too large
2142 // -3 Track vertex missing (not checked for kTracklets)
2143 // -4 Distance between SPD and track vertices too large (not checked for kTracklets)
2145 // WARNING This functions does not cut on the z vtx. Depending on the eta range requested, you need to restrict your z vertex range!
2147 // Strategy for combined estimators
2148 // 1. Count global tracks and flag them
2149 // 2. Count ITSSA as complementaries for ITSTPC+ or as main tracks
2150 // 3. Count the complementary SPD tracklets
2152 const AliESDVertex* vertices[2];
2153 vertices[0] = esd->GetPrimaryVertexSPD();
2154 vertices[1] = esd->GetPrimaryVertexTracks();
2156 if (!vertices[0]->GetStatus())
2158 AliDebugClass(AliLog::kDebug, "No SPD vertex. Not able to make a reliable multiplicity estimate.");
2162 if (vertices[0]->IsFromVertexerZ() && vertices[0]->GetDispersion() > 0.02)
2164 AliDebugClass(AliLog::kDebug, "Vertexer z dispersion > 0.02. Not able to make a reliable multiplicity estimate.");
2168 Int_t multiplicityEstimate = 0;
2170 // SPD tracklet-only estimate
2171 if (trackType == kTracklets)
2173 const AliMultiplicity* spdmult = esd->GetMultiplicity(); // spd multiplicity object
2174 for (Int_t i=0; i<spdmult->GetNumberOfTracklets(); ++i)
2176 if (TMath::Abs(spdmult->GetEta(i)) > etaRange)
2177 continue; // eta selection for tracklets
2178 multiplicityEstimate++;
2180 return multiplicityEstimate;
2183 if (!vertices[1]->GetStatus())
2185 AliDebugClass(AliLog::kDebug, "No track vertex. Not able to make a reliable multiplicity estimate.");
2189 // TODO value of displacement to be studied
2190 const Float_t maxDisplacement = 0.5;
2191 //check for displaced vertices
2192 Double_t displacement = TMath::Abs(vertices[0]->GetZ() - vertices[1]->GetZ());
2193 if (displacement > maxDisplacement)
2195 AliDebugClass(AliLog::kDebug, Form("Displaced vertices %f > %f",displacement,maxDisplacement));
2199 // update eta range in track cuts
2200 GetMultEstTrackCuts(kMultEstTrackCutITSSA)->SetEtaRange(-etaRange, etaRange);
2201 GetMultEstTrackCuts(kMultEstTrackCutDCAwSPD)->SetEtaRange(-etaRange, etaRange);
2202 GetMultEstTrackCuts(kMultEstTrackCutDCAwoSPD)->SetEtaRange(-etaRange, etaRange);
2204 //*******************************************************************************************************
2205 //set counters to initial zeros
2206 Int_t tracksITSTPC = 0; //number of global tracks for a given event
2207 Int_t tracksITSSA = 0; //number of ITS standalone tracks for a given event
2208 Int_t tracksITSTPCSA_complementary = 0; //number of ITS standalone tracks complementary to TPC for a given event
2209 Int_t trackletsITSTPC_complementary = 0;//number of SPD tracklets complementary to global/ITSSA tracks for a given events
2210 Int_t trackletsITSSA_complementary = 0; //number of SPD tracklets complementary to ITSSA tracks for a given event
2212 const Int_t nESDTracks = esd->GetNumberOfTracks();
2213 Int_t highestID = 0;
2215 // flags for secondary and rejected tracks
2216 const Int_t kRejBit = BIT(15); // set this bit in global tracks if it is rejected by a cut
2217 const Int_t kSecBit = BIT(16); // set this bit in global tracks if it is secondary according to a cut
2219 for(Int_t itracks=0; itracks < nESDTracks; itracks++) {
2220 if(esd->GetTrack(itracks)->GetLabel() > highestID) highestID = esd->GetTrack(itracks)->GetLabel();
2221 esd->GetTrack(itracks)->ResetBit(kSecBit|kRejBit); //reset bits used for flagging secondaries and rejected tracks in case they were changed before this analysis
2223 const Int_t maxid = highestID+1; // used to define bool array for check multiple associations of tracklets to one track. array starts at 0.
2225 // bit mask for esd tracks, to check if multiple tracklets are associated to it
2226 Bool_t globalBits[maxid], pureITSBits[maxid];
2227 for(Int_t i=0; i<maxid; i++){ // set all bools to false
2228 globalBits[i]=kFALSE;
2229 pureITSBits[i]=kFALSE;
2232 //*******************************************************************************************************
2233 // get multiplicity from global tracks
2234 for(Int_t itracks = 0; itracks < nESDTracks; itracks++) { // flag the tracks
2235 AliESDtrack* track = esd->GetTrack(itracks);
2237 // if track is a secondary from a V0, flag as a secondary
2238 if (track->IsOn(AliESDtrack::kMultInV0)) {
2239 track->SetBit(kSecBit);
2242 /* done via proper DCA cut
2244 if (track->IsOn(AliESDtrack::kMultSec)) {
2245 track->SetBit(kSecBit);
2249 // check tracks with ITS part
2250 //*******************************************************************************************************
2251 if (track->IsOn(AliESDtrack::kITSin) && !track->IsOn(AliESDtrack::kITSpureSA) && trackType == kTrackletsITSTPC) { // track has ITS part but is not an ITS_SA
2252 //*******************************************************************************************************
2254 if (track->IsOn(AliESDtrack::kTPCin)) { // Global track, has ITS and TPC contributions
2255 if (fgMultEstTrackCuts[kMultEstTrackCutGlobal]->AcceptTrack(track)) { // good ITSTPC track
2256 if (fgMultEstTrackCuts[kMultEstTrackCutDCAwSPD]->AcceptTrack(track) || fgMultEstTrackCuts[kMultEstTrackCutDCAwoSPD]->AcceptTrack(track)) {
2257 tracksITSTPC++; //global track counted
2258 globalBits[itracks] = kTRUE;
2260 else track->SetBit(kSecBit); // large DCA -> secondary, don't count either track not associated tracklet
2262 else track->SetBit(kRejBit); // bad quality, don't count the track, but may count tracklet if associated
2264 //*******************************************************************************************************
2265 // ITS complementary
2266 else if (fgMultEstTrackCuts[kMultEstTrackCutITSSA]->AcceptTrack(track)) { // good ITS complementary track
2267 if (fgMultEstTrackCuts[kMultEstTrackCutDCAwSPD]->AcceptTrack(track) || fgMultEstTrackCuts[kMultEstTrackCutDCAwoSPD]->AcceptTrack(track)) {
2268 tracksITSTPCSA_complementary++;
2269 globalBits[itracks] = kTRUE;
2271 else track->SetBit(kSecBit); // large DCA -> secondary, don't count either track not associated tracklet
2273 else track->SetBit(kRejBit); // bad quality, don't count the track, but may count tracklet if associated
2275 //*******************************************************************************************************
2276 // check tracks from ITS_SA_PURE
2277 if (track->IsOn(AliESDtrack::kITSin) && track->IsOn(AliESDtrack::kITSpureSA) && trackType == kTrackletsITSSA){
2278 if (fgMultEstTrackCuts[kMultEstTrackCutITSSA]->AcceptTrack(track)) { // good ITSSA track
2279 if (fgMultEstTrackCuts[kMultEstTrackCutDCAwSPD]->AcceptTrack(track) || fgMultEstTrackCuts[kMultEstTrackCutDCAwoSPD]->AcceptTrack(track)) {
2281 pureITSBits[itracks] = kTRUE;
2283 else track->SetBit(kRejBit);
2285 else track->SetBit(kRejBit);
2287 }//ESD tracks counted
2289 //*******************************************************************************************************
2290 // get multiplicity from ITS tracklets to complement TPC+ITS, and ITSpureSA
2291 const AliMultiplicity* spdmult = esd->GetMultiplicity(); // spd multiplicity object
2292 for (Int_t i=0; i<spdmult->GetNumberOfTracklets(); ++i) {
2293 if (TMath::Abs(spdmult->GetEta(i)) > etaRange) continue; // eta selection for tracklets
2295 // if counting tracks+tracklets, check if clusters were already used in tracks
2296 Int_t id1,id2,id3,id4;
2297 spdmult->GetTrackletTrackIDs(i,0,id1,id2); // references for eventual Global/ITS_SA tracks
2298 AliESDtrack* tr1 = id1>=0 ? esd->GetTrack(id1) : 0;
2299 spdmult->GetTrackletTrackIDs(i,1,id3,id4); // references for eventual ITS_SA_pure tracks
2300 AliESDtrack* tr3 = id3>=0 ? esd->GetTrack(id3) : 0;
2302 // are both clusters from the same tracks? If not, skip the tracklet (shouldn't change things much)
2303 if ((id1!=id2 && id1>=0 && id2>=0) || (id3!=id4 && id3>=0 && id4>=0)) continue;
2305 Bool_t bUsedInGlobal = (id1 != -1) ? globalBits[id1] : 0;// has associated global track been associated to a previous tracklet?
2306 Bool_t bUsedInPureITS = (id3 != -1) ? pureITSBits[id3] : 0;// has associated pure ITS track been associated to a previous tracklet?
2307 //*******************************************************************************************************
2308 if (trackType == kTrackletsITSTPC) {
2309 // count tracklets towards global+complementary tracks
2310 if ( (tr1 && !tr1->TestBit(kSecBit)) && // reject as secondary
2311 (tr1 && tr1->TestBit(kRejBit)) ) { // count tracklet as bad quality track
2313 ++trackletsITSTPC_complementary;
2314 if(id1>0) globalBits[id1] = kTRUE; // mark global track linked to this tracklet as "associated"
2318 ++trackletsITSTPC_complementary; // if no associated track, count the tracklet
2321 // count tracklets towards ITS_SA_pure tracks
2322 if ( (tr3 && !tr3->TestBit(kSecBit)) && // reject as secondary
2323 (tr3 && tr3->TestBit(kRejBit)) ) { // count tracklet as bad quality track
2324 if(!bUsedInPureITS) {
2325 ++trackletsITSSA_complementary;
2326 if(id3>0) pureITSBits[id3] = kTRUE; // mark global track linked to this tracklet as "associated"
2330 ++trackletsITSSA_complementary; // if no associated track, count the tracklet
2335 //*******************************************************************************************************
2336 if (trackType == kTrackletsITSTPC)
2337 multiplicityEstimate = tracksITSTPC + tracksITSTPCSA_complementary + trackletsITSTPC_complementary;
2339 multiplicityEstimate = tracksITSSA + trackletsITSSA_complementary;
2341 return multiplicityEstimate;
2344 //____________________________________________________________________
2345 void AliESDtrackCuts::SetRequireStandardTOFmatchCuts(){
2347 // setting the TOF cuts flags (kTOFout = TOF matching distance) to true, to include the selection on the standard TOF matching
2349 SetRequireTOFout(kTRUE);
2350 SetFlagCutTOFdistance(kTRUE);
2351 SetCutTOFdistance(3.);