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>
27 #include <TDirectory.h>
31 //____________________________________________________________________
32 ClassImp(AliESDtrackCuts)
35 const Char_t* AliESDtrackCuts::fgkCutNames[kNCuts] = {
37 "require TPC standalone",
41 "#Chi^{2}/cluster TPC",
42 "#Chi^{2}/cluster ITS",
58 "trk-to-vtx max dca 2D absolute",
59 "trk-to-vtx max dca xy absolute",
60 "trk-to-vtx max dca z absolute",
61 "trk-to-vtx min dca 2D absolute",
62 "trk-to-vtx min dca xy absolute",
63 "trk-to-vtx min dca z absolute",
64 "SPD cluster requirement",
65 "SDD cluster requirement",
66 "SSD cluster requirement",
67 "require ITS stand-alone",
68 "rel 1/pt uncertainty",
69 "TPC n shared clusters",
70 "TPC rel shared clusters",
73 "n crossed rows / n findable clusters",
77 //____________________________________________________________________
78 AliESDtrackCuts::AliESDtrackCuts(const Char_t* name, const Char_t* title) : AliAnalysisCuts(name,title),
79 fCutMinNClusterTPC(0),
80 fCutMinNClusterITS(0),
81 fCutMinNCrossedRowsTPC(0),
82 fCutMinRatioCrossedRowsOverFindableClustersTPC(0),
83 fCutMaxChi2PerClusterTPC(0),
84 fCutMaxChi2PerClusterITS(0),
85 fCutMaxMissingITSPoints(0),
91 fCutMaxRel1PtUncertainty(0),
92 fCutAcceptKinkDaughters(0),
93 fCutAcceptSharedTPCClusters(0),
94 fCutMaxFractionSharedTPCClusters(0),
95 fCutRequireTPCRefit(0),
96 fCutRequireTPCStandAlone(0),
97 fCutRequireITSRefit(0),
99 fCutRequireITSStandAlone(0),
100 fCutRequireITSpureSA(0),
101 fCutNsigmaToVertex(0),
102 fCutSigmaToVertexRequired(0),
103 fCutMaxDCAToVertexXY(0),
104 fCutMaxDCAToVertexZ(0),
105 fCutMinDCAToVertexXY(0),
106 fCutMinDCAToVertexZ(0),
107 fCutMaxDCAToVertexXYPtDep(""),
108 fCutMaxDCAToVertexZPtDep(""),
109 fCutMinDCAToVertexXYPtDep(""),
110 fCutMinDCAToVertexZPtDep(""),
111 f1CutMaxDCAToVertexXYPtDep(0x0),
112 f1CutMaxDCAToVertexZPtDep(0x0),
113 f1CutMinDCAToVertexXYPtDep(0x0),
114 f1CutMinDCAToVertexZPtDep(0x0),
115 fCutDCAToVertex2D(0),
141 //##############################################################################
142 // setting default cuts
143 SetMinNClustersTPC();
144 SetMinNClustersITS();
145 SetMinNCrossedRowsTPC();
146 SetMinRatioCrossedRowsOverFindableClustersTPC();
147 SetMaxChi2PerClusterTPC();
148 SetMaxChi2PerClusterITS();
149 SetMaxNOfMissingITSPoints();
150 SetMaxCovDiagonalElements();
151 SetMaxRel1PtUncertainty();
152 SetRequireTPCRefit();
153 SetRequireTPCStandAlone();
154 SetRequireITSRefit();
155 SetRequireITSPid(kFALSE);
156 SetRequireITSStandAlone(kFALSE);
157 SetRequireITSPureStandAlone(kFALSE);
158 SetAcceptKinkDaughters();
159 SetAcceptSharedTPCClusters();
160 SetMaxFractionSharedTPCClusters();
161 SetMaxNsigmaToVertex();
162 SetMaxDCAToVertexXY();
163 SetMaxDCAToVertexZ();
165 SetMinDCAToVertexXY();
166 SetMinDCAToVertexZ();
174 SetClusterRequirementITS(kSPD);
175 SetClusterRequirementITS(kSDD);
176 SetClusterRequirementITS(kSSD);
181 //_____________________________________________________________________________
182 AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : AliAnalysisCuts(c),
183 fCutMinNClusterTPC(0),
184 fCutMinNClusterITS(0),
185 fCutMinNCrossedRowsTPC(0),
186 fCutMinRatioCrossedRowsOverFindableClustersTPC(0),
187 fCutMaxChi2PerClusterTPC(0),
188 fCutMaxChi2PerClusterITS(0),
189 fCutMaxMissingITSPoints(0),
195 fCutMaxRel1PtUncertainty(0),
196 fCutAcceptKinkDaughters(0),
197 fCutAcceptSharedTPCClusters(0),
198 fCutMaxFractionSharedTPCClusters(0),
199 fCutRequireTPCRefit(0),
200 fCutRequireTPCStandAlone(0),
201 fCutRequireITSRefit(0),
202 fCutRequireITSPid(0),
203 fCutRequireITSStandAlone(0),
204 fCutRequireITSpureSA(0),
205 fCutNsigmaToVertex(0),
206 fCutSigmaToVertexRequired(0),
207 fCutMaxDCAToVertexXY(0),
208 fCutMaxDCAToVertexZ(0),
209 fCutMinDCAToVertexXY(0),
210 fCutMinDCAToVertexZ(0),
211 fCutMaxDCAToVertexXYPtDep(""),
212 fCutMaxDCAToVertexZPtDep(""),
213 fCutMinDCAToVertexXYPtDep(""),
214 fCutMinDCAToVertexZPtDep(""),
215 f1CutMaxDCAToVertexXYPtDep(0x0),
216 f1CutMaxDCAToVertexZPtDep(0x0),
217 f1CutMinDCAToVertexXYPtDep(0x0),
218 f1CutMinDCAToVertexZPtDep(0x0),
219 fCutDCAToVertex2D(0),
243 ((AliESDtrackCuts &) c).Copy(*this);
246 AliESDtrackCuts::~AliESDtrackCuts()
252 for (Int_t i=0; i<2; i++) {
254 if (fhNClustersITS[i])
255 delete fhNClustersITS[i];
256 if (fhNClustersTPC[i])
257 delete fhNClustersTPC[i];
258 if (fhNSharedClustersTPC[i])
259 delete fhNSharedClustersTPC[i];
260 if (fhNCrossedRowsTPC[i])
261 delete fhNCrossedRowsTPC[i];
262 if (fhRatioCrossedRowsOverFindableClustersTPC[i])
263 delete fhRatioCrossedRowsOverFindableClustersTPC[i];
264 if (fhChi2PerClusterITS[i])
265 delete fhChi2PerClusterITS[i];
266 if (fhChi2PerClusterTPC[i])
267 delete fhChi2PerClusterTPC[i];
268 if(fhNClustersForITSPID[i])
269 delete fhNClustersForITSPID[i];
270 if(fhNMissingITSPoints[i])
271 delete fhNMissingITSPoints[i];
283 if (fhRel1PtUncertainty[i])
284 delete fhRel1PtUncertainty[i];
295 if (fhDXYNormalized[i])
296 delete fhDXYNormalized[i];
297 if (fhDZNormalized[i])
298 delete fhDZNormalized[i];
299 if (fhDXYvsDZNormalized[i])
300 delete fhDXYvsDZNormalized[i];
301 if (fhNSigmaToVertex[i])
302 delete fhNSigmaToVertex[i];
309 if(f1CutMaxDCAToVertexXYPtDep)delete f1CutMaxDCAToVertexXYPtDep;
310 f1CutMaxDCAToVertexXYPtDep = 0;
311 if( f1CutMaxDCAToVertexZPtDep) delete f1CutMaxDCAToVertexZPtDep;
312 f1CutMaxDCAToVertexZPtDep = 0;
313 if( f1CutMinDCAToVertexXYPtDep)delete f1CutMinDCAToVertexXYPtDep;
314 f1CutMinDCAToVertexXYPtDep = 0;
315 if(f1CutMinDCAToVertexZPtDep)delete f1CutMinDCAToVertexZPtDep;
316 f1CutMinDCAToVertexZPtDep = 0;
320 delete ffDTheoretical;
323 delete fhCutStatistics;
324 if (fhCutCorrelation)
325 delete fhCutCorrelation;
328 void AliESDtrackCuts::Init()
331 // sets everything to zero
334 fCutMinNClusterTPC = 0;
335 fCutMinNClusterITS = 0;
337 fCutMaxChi2PerClusterTPC = 0;
338 fCutMaxChi2PerClusterITS = 0;
339 fCutMaxMissingITSPoints = 0;
341 for (Int_t i = 0; i < 3; i++)
342 fCutClusterRequirementITS[i] = kOff;
350 fCutMaxRel1PtUncertainty = 0;
352 fCutAcceptKinkDaughters = 0;
353 fCutAcceptSharedTPCClusters = 0;
354 fCutMaxFractionSharedTPCClusters = 0;
355 fCutRequireTPCRefit = 0;
356 fCutRequireTPCStandAlone = 0;
357 fCutRequireITSRefit = 0;
358 fCutRequireITSPid = 0;
359 fCutRequireITSStandAlone = 0;
360 fCutRequireITSpureSA = 0;
362 fCutNsigmaToVertex = 0;
363 fCutSigmaToVertexRequired = 0;
364 fCutMaxDCAToVertexXY = 0;
365 fCutMaxDCAToVertexZ = 0;
366 fCutDCAToVertex2D = 0;
367 fCutMinDCAToVertexXY = 0;
368 fCutMinDCAToVertexZ = 0;
369 fCutMaxDCAToVertexXYPtDep = "";
370 fCutMaxDCAToVertexZPtDep = "";
371 fCutMinDCAToVertexXYPtDep = "";
372 fCutMinDCAToVertexZPtDep = "";
374 if(f1CutMaxDCAToVertexXYPtDep)delete f1CutMaxDCAToVertexXYPtDep;
375 f1CutMaxDCAToVertexXYPtDep = 0;
376 if( f1CutMaxDCAToVertexXYPtDep) delete f1CutMaxDCAToVertexXYPtDep;
377 f1CutMaxDCAToVertexXYPtDep = 0;
378 if( f1CutMaxDCAToVertexZPtDep) delete f1CutMaxDCAToVertexZPtDep;
379 f1CutMaxDCAToVertexZPtDep = 0;
380 if( f1CutMinDCAToVertexXYPtDep)delete f1CutMinDCAToVertexXYPtDep;
381 f1CutMinDCAToVertexXYPtDep = 0;
382 if(f1CutMinDCAToVertexZPtDep)delete f1CutMinDCAToVertexZPtDep;
383 f1CutMinDCAToVertexZPtDep = 0;
401 fHistogramsOn = kFALSE;
403 for (Int_t i=0; i<2; ++i)
405 fhNClustersITS[i] = 0;
406 fhNClustersTPC[i] = 0;
407 fhNSharedClustersTPC[i] = 0;
408 fhNCrossedRowsTPC[i] = 0;
409 fhRatioCrossedRowsOverFindableClustersTPC[i] = 0;
411 fhChi2PerClusterITS[i] = 0;
412 fhChi2PerClusterTPC[i] = 0;
413 fhNClustersForITSPID[i] = 0;
414 fhNMissingITSPoints[i] = 0;
422 fhRel1PtUncertainty[i] = 0;
429 fhDXYNormalized[i] = 0;
430 fhDZNormalized[i] = 0;
431 fhDXYvsDZNormalized[i] = 0;
432 fhNSigmaToVertex[i] = 0;
440 fhCutCorrelation = 0;
443 //_____________________________________________________________________________
444 AliESDtrackCuts &AliESDtrackCuts::operator=(const AliESDtrackCuts &c)
447 // Assignment operator
450 if (this != &c) ((AliESDtrackCuts &) c).Copy(*this);
454 //_____________________________________________________________________________
455 void AliESDtrackCuts::Copy(TObject &c) const
461 AliESDtrackCuts& target = (AliESDtrackCuts &) c;
465 target.fCutMinNClusterTPC = fCutMinNClusterTPC;
466 target.fCutMinNClusterITS = fCutMinNClusterITS;
467 target.fCutMinNCrossedRowsTPC = fCutMinNCrossedRowsTPC;
468 target.fCutMinRatioCrossedRowsOverFindableClustersTPC = fCutMinRatioCrossedRowsOverFindableClustersTPC;
471 target.fCutMaxChi2PerClusterTPC = fCutMaxChi2PerClusterTPC;
472 target.fCutMaxChi2PerClusterITS = fCutMaxChi2PerClusterITS;
473 target.fCutMaxMissingITSPoints = fCutMaxMissingITSPoints;
475 for (Int_t i = 0; i < 3; i++)
476 target.fCutClusterRequirementITS[i] = fCutClusterRequirementITS[i];
478 target.fCutMaxC11 = fCutMaxC11;
479 target.fCutMaxC22 = fCutMaxC22;
480 target.fCutMaxC33 = fCutMaxC33;
481 target.fCutMaxC44 = fCutMaxC44;
482 target.fCutMaxC55 = fCutMaxC55;
484 target.fCutMaxRel1PtUncertainty = fCutMaxRel1PtUncertainty;
486 target.fCutAcceptKinkDaughters = fCutAcceptKinkDaughters;
487 target.fCutAcceptSharedTPCClusters = fCutAcceptSharedTPCClusters;
488 target.fCutMaxFractionSharedTPCClusters = fCutMaxFractionSharedTPCClusters;
489 target.fCutRequireTPCRefit = fCutRequireTPCRefit;
490 target.fCutRequireTPCStandAlone = fCutRequireTPCStandAlone;
491 target.fCutRequireITSRefit = fCutRequireITSRefit;
492 target.fCutRequireITSPid = fCutRequireITSPid;
493 target.fCutRequireITSStandAlone = fCutRequireITSStandAlone;
494 target.fCutRequireITSpureSA = fCutRequireITSpureSA;
496 target.fCutNsigmaToVertex = fCutNsigmaToVertex;
497 target.fCutSigmaToVertexRequired = fCutSigmaToVertexRequired;
498 target.fCutMaxDCAToVertexXY = fCutMaxDCAToVertexXY;
499 target.fCutMaxDCAToVertexZ = fCutMaxDCAToVertexZ;
500 target.fCutDCAToVertex2D = fCutDCAToVertex2D;
501 target.fCutMinDCAToVertexXY = fCutMinDCAToVertexXY;
502 target.fCutMinDCAToVertexZ = fCutMinDCAToVertexZ;
504 target.fCutMaxDCAToVertexXYPtDep = fCutMaxDCAToVertexXYPtDep;
505 target.SetMaxDCAToVertexXYPtDep(fCutMaxDCAToVertexXYPtDep.Data());
507 target.fCutMaxDCAToVertexZPtDep = fCutMaxDCAToVertexZPtDep;
508 target.SetMaxDCAToVertexZPtDep(fCutMaxDCAToVertexZPtDep.Data());
510 target.fCutMinDCAToVertexXYPtDep = fCutMinDCAToVertexXYPtDep;
511 target.SetMinDCAToVertexXYPtDep(fCutMinDCAToVertexXYPtDep.Data());
513 target.fCutMinDCAToVertexZPtDep = fCutMinDCAToVertexZPtDep;
514 target.SetMinDCAToVertexZPtDep(fCutMinDCAToVertexZPtDep.Data());
516 target.fPMin = fPMin;
517 target.fPMax = fPMax;
518 target.fPtMin = fPtMin;
519 target.fPtMax = fPtMax;
520 target.fPxMin = fPxMin;
521 target.fPxMax = fPxMax;
522 target.fPyMin = fPyMin;
523 target.fPyMax = fPyMax;
524 target.fPzMin = fPzMin;
525 target.fPzMax = fPzMax;
526 target.fEtaMin = fEtaMin;
527 target.fEtaMax = fEtaMax;
528 target.fRapMin = fRapMin;
529 target.fRapMax = fRapMax;
531 target.fHistogramsOn = fHistogramsOn;
533 for (Int_t i=0; i<2; ++i)
535 if (fhNClustersITS[i]) target.fhNClustersITS[i] = (TH1F*) fhNClustersITS[i]->Clone();
536 if (fhNClustersTPC[i]) target.fhNClustersTPC[i] = (TH1F*) fhNClustersTPC[i]->Clone();
537 if (fhNSharedClustersTPC[i]) target.fhNSharedClustersTPC[i] = (TH1F*) fhNSharedClustersTPC[i]->Clone();
538 if (fhNCrossedRowsTPC[i]) target.fhNCrossedRowsTPC[i] = (TH1F*) fhNCrossedRowsTPC[i]->Clone();
539 if (fhRatioCrossedRowsOverFindableClustersTPC[i]) target.fhRatioCrossedRowsOverFindableClustersTPC[i] = (TH1F*) fhRatioCrossedRowsOverFindableClustersTPC[i]->Clone();
541 if (fhChi2PerClusterITS[i]) target.fhChi2PerClusterITS[i] = (TH1F*) fhChi2PerClusterITS[i]->Clone();
542 if (fhChi2PerClusterTPC[i]) target.fhChi2PerClusterTPC[i] = (TH1F*) fhChi2PerClusterTPC[i]->Clone();
543 if (fhNClustersForITSPID[i]) target.fhNClustersForITSPID[i] = (TH1F*) fhNClustersForITSPID[i]->Clone();
544 if (fhNMissingITSPoints[i]) target.fhNMissingITSPoints[i] = (TH1F*) fhNMissingITSPoints[i]->Clone();
546 if (fhC11[i]) target.fhC11[i] = (TH1F*) fhC11[i]->Clone();
547 if (fhC22[i]) target.fhC22[i] = (TH1F*) fhC22[i]->Clone();
548 if (fhC33[i]) target.fhC33[i] = (TH1F*) fhC33[i]->Clone();
549 if (fhC44[i]) target.fhC44[i] = (TH1F*) fhC44[i]->Clone();
550 if (fhC55[i]) target.fhC55[i] = (TH1F*) fhC55[i]->Clone();
552 if (fhRel1PtUncertainty[i]) target.fhRel1PtUncertainty[i] = (TH1F*) fhRel1PtUncertainty[i]->Clone();
554 if (fhDXY[i]) target.fhDXY[i] = (TH1F*) fhDXY[i]->Clone();
555 if (fhDZ[i]) target.fhDZ[i] = (TH1F*) fhDZ[i]->Clone();
556 if (fhDXYDZ[i]) target.fhDXYDZ[i] = (TH1F*) fhDXYDZ[i]->Clone();
557 if (fhDXYvsDZ[i]) target.fhDXYvsDZ[i] = (TH2F*) fhDXYvsDZ[i]->Clone();
559 if (fhDXYNormalized[i]) target.fhDXYNormalized[i] = (TH1F*) fhDXYNormalized[i]->Clone();
560 if (fhDZNormalized[i]) target.fhDZNormalized[i] = (TH1F*) fhDZNormalized[i]->Clone();
561 if (fhDXYvsDZNormalized[i]) target.fhDXYvsDZNormalized[i] = (TH2F*) fhDXYvsDZNormalized[i]->Clone();
562 if (fhNSigmaToVertex[i]) target.fhNSigmaToVertex[i] = (TH1F*) fhNSigmaToVertex[i]->Clone();
564 if (fhPt[i]) target.fhPt[i] = (TH1F*) fhPt[i]->Clone();
565 if (fhEta[i]) target.fhEta[i] = (TH1F*) fhEta[i]->Clone();
567 if (ffDTheoretical) target.ffDTheoretical = (TF1*) ffDTheoretical->Clone();
569 if (fhCutStatistics) target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
570 if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
575 //_____________________________________________________________________________
576 Long64_t AliESDtrackCuts::Merge(TCollection* list) {
577 // Merge a list of AliESDtrackCuts objects with this (needed for PROOF)
578 // Returns the number of merged objects (including this)
585 TIterator* iter = list->MakeIterator();
588 // collection of measured and generated histograms
590 while ((obj = iter->Next())) {
592 AliESDtrackCuts* entry = dynamic_cast<AliESDtrackCuts*>(obj);
596 if (!entry->fHistogramsOn)
599 for (Int_t i=0; i<2; i++) {
601 fhNClustersITS[i] ->Add(entry->fhNClustersITS[i] );
602 fhNClustersTPC[i] ->Add(entry->fhNClustersTPC[i] );
603 if (fhNSharedClustersTPC[i])
604 fhNSharedClustersTPC[i] ->Add(entry->fhNSharedClustersTPC[i] );
605 if (fhNCrossedRowsTPC[i])
606 fhNCrossedRowsTPC[i] ->Add(entry->fhNCrossedRowsTPC[i] );
607 if (fhRatioCrossedRowsOverFindableClustersTPC[i])
608 fhRatioCrossedRowsOverFindableClustersTPC[i] ->Add(entry->fhRatioCrossedRowsOverFindableClustersTPC[i] );
610 fhChi2PerClusterITS[i] ->Add(entry->fhChi2PerClusterITS[i]);
611 fhChi2PerClusterTPC[i] ->Add(entry->fhChi2PerClusterTPC[i]);
612 if (fhNClustersForITSPID[i])
613 fhNClustersForITSPID[i]->Add(entry->fhNClustersForITSPID[i]);
614 if (fhNMissingITSPoints[i])
615 fhNMissingITSPoints[i] ->Add(entry->fhNMissingITSPoints[i]);
617 fhC11[i] ->Add(entry->fhC11[i] );
618 fhC22[i] ->Add(entry->fhC22[i] );
619 fhC33[i] ->Add(entry->fhC33[i] );
620 fhC44[i] ->Add(entry->fhC44[i] );
621 fhC55[i] ->Add(entry->fhC55[i] );
623 fhRel1PtUncertainty[i] ->Add(entry->fhRel1PtUncertainty[i]);
625 fhDXY[i] ->Add(entry->fhDXY[i] );
626 fhDZ[i] ->Add(entry->fhDZ[i] );
627 fhDXYDZ[i] ->Add(entry->fhDXYDZ[i] );
628 fhDXYvsDZ[i] ->Add(entry->fhDXYvsDZ[i] );
630 fhDXYNormalized[i] ->Add(entry->fhDXYNormalized[i] );
631 fhDZNormalized[i] ->Add(entry->fhDZNormalized[i] );
632 fhDXYvsDZNormalized[i] ->Add(entry->fhDXYvsDZNormalized[i]);
633 fhNSigmaToVertex[i] ->Add(entry->fhNSigmaToVertex[i]);
635 fhPt[i] ->Add(entry->fhPt[i]);
636 fhEta[i] ->Add(entry->fhEta[i]);
639 fhCutStatistics ->Add(entry->fhCutStatistics);
640 fhCutCorrelation ->Add(entry->fhCutCorrelation);
647 //____________________________________________________________________
648 AliESDtrackCuts* AliESDtrackCuts::GetStandardTPCOnlyTrackCuts()
650 // creates an AliESDtrackCuts object and fills it with standard (pre data-taking) values for TPC-only cuts
652 Printf("AliESDtrackCuts::GetStandardTPCOnlyTrackCuts: Creating track cuts for TPC-only.");
654 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
656 esdTrackCuts->SetMinNClustersTPC(50);
657 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
658 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
660 esdTrackCuts->SetMaxDCAToVertexZ(3.2);
661 esdTrackCuts->SetMaxDCAToVertexXY(2.4);
662 esdTrackCuts->SetDCAToVertex2D(kTRUE);
667 //____________________________________________________________________
668 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(Bool_t selPrimaries)
670 // creates an AliESDtrackCuts object and fills it with standard values for ITS-TPC cuts for pp 2009 data
672 Printf("AliESDtrackCuts::GetStandardITSTPCTrackCuts: Creating track cuts for ITS+TPC.");
674 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
677 esdTrackCuts->SetRequireTPCStandAlone(kTRUE); // to get chi2 and ncls of kTPCin
678 esdTrackCuts->SetMinNClustersTPC(70);
679 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
680 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
681 esdTrackCuts->SetRequireTPCRefit(kTRUE);
683 esdTrackCuts->SetRequireITSRefit(kTRUE);
684 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
685 AliESDtrackCuts::kAny);
687 // 7*(0.0050+0.0060/pt^0.9)
688 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
690 esdTrackCuts->SetMaxDCAToVertexZ(1.e6);
691 esdTrackCuts->SetDCAToVertex2D(kFALSE);
692 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
693 //esdTrackCuts->SetEtaRange(-0.8,+0.8);
698 //____________________________________________________________________
699 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(Bool_t selPrimaries,Int_t clusterCut)
701 // creates an AliESDtrackCuts object and fills it with standard values for ITS-TPC cuts for pp 2010 data
702 // if clusterCut = 1, the cut on the number of clusters is replaced by
703 // a cut on the number of crossed rows and on the ration crossed
704 // rows/findable clusters
706 Printf("AliESDtrackCuts::GetStandardITSTPCTrackCuts: Creating track cuts for ITS+TPC.");
708 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
711 if(clusterCut == 0) esdTrackCuts->SetMinNClustersTPC(70);
712 else if (clusterCut == 1) {
713 esdTrackCuts->SetMinNCrossedRowsTPC(70);
714 esdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);
717 Printf("Wrong value of the clusterCut parameter (%d), using cut on Nclusters",clusterCut);
718 esdTrackCuts->SetMinNClustersTPC(70);
720 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
721 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
722 esdTrackCuts->SetRequireTPCRefit(kTRUE);
724 esdTrackCuts->SetRequireITSRefit(kTRUE);
725 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
726 AliESDtrackCuts::kAny);
728 // 7*(0.0026+0.0050/pt^1.01)
729 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
731 esdTrackCuts->SetMaxDCAToVertexZ(2);
732 esdTrackCuts->SetDCAToVertex2D(kFALSE);
733 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
738 //____________________________________________________________________
742 //____________________________________________________________________
743 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(Bool_t selPrimaries, Bool_t useForPid)
745 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks
747 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
748 esdTrackCuts->SetRequireITSPureStandAlone(kTRUE);
749 esdTrackCuts->SetRequireITSRefit(kTRUE);
750 esdTrackCuts->SetMinNClustersITS(4);
751 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
752 AliESDtrackCuts::kAny);
753 esdTrackCuts->SetMaxChi2PerClusterITS(1.);
756 // 7*(0.0085+0.0026/pt^1.55)
757 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55");
760 esdTrackCuts->SetRequireITSPid(kTRUE);
765 //____________________________________________________________________
766 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSPureSATrackCuts2010(Bool_t selPrimaries, Bool_t useForPid)
768 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks - pp 2010
770 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
771 esdTrackCuts->SetRequireITSPureStandAlone(kTRUE);
772 esdTrackCuts->SetRequireITSRefit(kTRUE);
773 esdTrackCuts->SetMinNClustersITS(4);
774 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
775 AliESDtrackCuts::kAny);
776 esdTrackCuts->SetMaxChi2PerClusterITS(2.5);
779 // 7*(0.0033+0.0045/pt^1.3)
780 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0231+0.0315/pt^1.3");
783 esdTrackCuts->SetRequireITSPid(kTRUE);
788 //____________________________________________________________________
789 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSSATrackCuts2009(Bool_t selPrimaries, Bool_t useForPid)
791 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks
793 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
794 esdTrackCuts->SetRequireITSStandAlone(kTRUE);
795 esdTrackCuts->SetRequireITSPureStandAlone(kFALSE);
796 esdTrackCuts->SetRequireITSRefit(kTRUE);
797 esdTrackCuts->SetMinNClustersITS(4);
798 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
799 AliESDtrackCuts::kAny);
800 esdTrackCuts->SetMaxChi2PerClusterITS(1.);
803 // 7*(0.0085+0.0026/pt^1.55)
804 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55");
807 esdTrackCuts->SetRequireITSPid(kTRUE);
812 //____________________________________________________________________
813 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSSATrackCuts2010(Bool_t selPrimaries, Bool_t useForPid)
815 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks --pp 2010
817 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
818 esdTrackCuts->SetRequireITSStandAlone(kTRUE);
819 esdTrackCuts->SetRequireITSPureStandAlone(kFALSE);
820 esdTrackCuts->SetRequireITSRefit(kTRUE);
821 esdTrackCuts->SetMinNClustersITS(4);
822 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
823 AliESDtrackCuts::kAny);
824 esdTrackCuts->SetMaxChi2PerClusterITS(2.5);
827 // 7*(0.0033+0.0045/pt^1.3)
828 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0231+0.0315/pt^1.3");
831 esdTrackCuts->SetRequireITSPid(kTRUE);
836 //____________________________________________________________________
837 AliESDtrackCuts* AliESDtrackCuts::GetStandardITSSATrackCutsPbPb2010(Bool_t selPrimaries, Bool_t useForPid)
839 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks -- PbPb 2010
841 AliESDtrackCuts* esdTrackCuts = GetStandardITSSATrackCuts2010(selPrimaries, useForPid);
842 esdTrackCuts->SetMaxNOfMissingITSPoints(1);
847 //____________________________________________________________________
848 Int_t AliESDtrackCuts::GetReferenceMultiplicity(const AliESDEvent* esd, Bool_t tpcOnly)
850 // Gets reference multiplicity following the standard cuts and a defined fiducial volume
851 // tpcOnly = kTRUE -> consider TPC-only tracks
852 // = kFALSE -> consider global tracks
856 Printf("AliESDtrackCuts::GetReferenceMultiplicity: Not implemented for global tracks!");
860 static AliESDtrackCuts* esdTrackCuts = 0;
863 esdTrackCuts = GetStandardTPCOnlyTrackCuts();
864 esdTrackCuts->SetEtaRange(-0.8, 0.8);
865 esdTrackCuts->SetPtRange(0.15);
868 Int_t nTracks = esdTrackCuts->CountAcceptedTracks(esd);
873 //____________________________________________________________________
874 Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* const esdTrack)
876 // Calculates the number of sigma to the vertex.
881 esdTrack->GetImpactParameters(b,bCov);
883 if (bCov[0]<=0 || bCov[2]<=0) {
884 AliDebugClass(1, "Estimated b resolution lower or equal zero!");
885 bCov[0]=0; bCov[2]=0;
887 bRes[0] = TMath::Sqrt(bCov[0]);
888 bRes[1] = TMath::Sqrt(bCov[2]);
890 // -----------------------------------
891 // How to get to a n-sigma cut?
893 // The accumulated statistics from 0 to d is
895 // -> Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma)
896 // -> 1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma)
898 // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-d**2)/2)
899 // Can this be expressed in a different way?
901 if (bRes[0] == 0 || bRes[1] ==0)
904 Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
906 // work around precision problem
907 // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
908 // 1e-15 corresponds to nsigma ~ 7.7
909 if (TMath::Exp(-d * d / 2) < 1e-15)
912 Float_t nSigma = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
916 void AliESDtrackCuts::EnableNeededBranches(TTree* tree)
918 // enables the branches needed by AcceptTrack, for a list see comment of AcceptTrack
920 tree->SetBranchStatus("fTracks.fFlags", 1);
921 tree->SetBranchStatus("fTracks.fITSncls", 1);
922 tree->SetBranchStatus("fTracks.fTPCncls", 1);
923 tree->SetBranchStatus("fTracks.fITSchi2", 1);
924 tree->SetBranchStatus("fTracks.fTPCchi2", 1);
925 tree->SetBranchStatus("fTracks.fC*", 1);
926 tree->SetBranchStatus("fTracks.fD", 1);
927 tree->SetBranchStatus("fTracks.fZ", 1);
928 tree->SetBranchStatus("fTracks.fCdd", 1);
929 tree->SetBranchStatus("fTracks.fCdz", 1);
930 tree->SetBranchStatus("fTracks.fCzz", 1);
931 tree->SetBranchStatus("fTracks.fP*", 1);
932 tree->SetBranchStatus("fTracks.fR*", 1);
933 tree->SetBranchStatus("fTracks.fKinkIndexes*", 1);
936 //____________________________________________________________________
937 Bool_t AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack)
940 // figure out if the tracks survives all the track cuts defined
942 // the different quality parameter and kinematic values are first
943 // retrieved from the track. then it is found out what cuts the
944 // track did not survive and finally the cuts are imposed.
946 // this function needs the following branches:
952 // fTracks.fC //GetExternalCovariance
953 // fTracks.fD //GetImpactParameters
954 // fTracks.fZ //GetImpactParameters
955 // fTracks.fCdd //GetImpactParameters
956 // fTracks.fCdz //GetImpactParameters
957 // fTracks.fCzz //GetImpactParameters
958 // fTracks.fP //GetPxPyPz
959 // fTracks.fR //GetMass
960 // fTracks.fP //GetMass
961 // fTracks.fKinkIndexes
963 UInt_t status = esdTrack->GetStatus();
965 // getting quality parameters from the ESD track
966 Int_t nClustersITS = esdTrack->GetITSclusters(0);
967 Int_t nClustersTPC = -1;
968 if(fCutRequireTPCStandAlone) {
969 nClustersTPC = esdTrack->GetTPCNclsIter1();
972 nClustersTPC = esdTrack->GetTPCclusters(0);
974 Float_t nCrossedRowsTPC = esdTrack->GetTPCClusterInfo(2,1);
975 Float_t ratioCrossedRowsOverFindableClustersTPC = 1.0;
976 if (esdTrack->GetTPCNclsF()>0) {
977 ratioCrossedRowsOverFindableClustersTPC = nCrossedRowsTPC / esdTrack->GetTPCNclsF();
980 Int_t nClustersTPCShared = esdTrack->GetTPCnclsS();
981 Float_t fracClustersTPCShared = -1.;
983 Float_t chi2PerClusterITS = -1;
984 Float_t chi2PerClusterTPC = -1;
986 chi2PerClusterITS = esdTrack->GetITSchi2()/Float_t(nClustersITS);
987 if (nClustersTPC!=0) {
988 if(fCutRequireTPCStandAlone) {
989 chi2PerClusterTPC = esdTrack->GetTPCchi2Iter1()/Float_t(nClustersTPC);
991 chi2PerClusterTPC = esdTrack->GetTPCchi2()/Float_t(nClustersTPC);
993 fracClustersTPCShared = Float_t(nClustersTPCShared)/Float_t(nClustersTPC);
997 esdTrack->GetExternalCovariance(extCov);
999 // getting the track to vertex parameters
1000 Float_t nSigmaToVertex = GetSigmaToVertex(esdTrack);
1004 esdTrack->GetImpactParameters(b,bCov);
1005 if (bCov[0]<=0 || bCov[2]<=0) {
1006 AliDebug(1, "Estimated b resolution lower or equal zero!");
1007 bCov[0]=0; bCov[2]=0;
1011 // set pt-dependent DCA cuts, if requested
1012 SetPtDepDCACuts(esdTrack->Pt());
1015 Float_t dcaToVertexXY = b[0];
1016 Float_t dcaToVertexZ = b[1];
1018 Float_t dcaToVertex = -1;
1020 if (fCutDCAToVertex2D)
1022 dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY/fCutMaxDCAToVertexXY/fCutMaxDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMaxDCAToVertexZ/fCutMaxDCAToVertexZ);
1025 dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY + dcaToVertexZ*dcaToVertexZ);
1027 // getting the kinematic variables of the track
1028 // (assuming the mass is known)
1030 esdTrack->GetPxPyPz(p);
1032 Float_t momentum = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2) + TMath::Power(p[2],2));
1033 Float_t pt = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2));
1034 Float_t energy = TMath::Sqrt(TMath::Power(esdTrack->GetMass(),2) + TMath::Power(momentum,2));
1036 //y-eta related calculations
1037 Float_t eta = -100.;
1039 if((momentum != TMath::Abs(p[2]))&&(momentum != 0))
1040 eta = 0.5*TMath::Log((momentum + p[2])/(momentum - p[2]));
1041 if((energy != TMath::Abs(p[2]))&&(momentum != 0))
1042 y = 0.5*TMath::Log((energy + p[2])/(energy - p[2]));
1046 Printf("AliESDtrackCuts::AcceptTrack: WARNING: GetSigma1Pt2() returns negative value for external covariance matrix element fC[14]: %f. Corrupted track information, track will not be accepted!", extCov[14]);
1049 Float_t relUncertainty1Pt = TMath::Sqrt(extCov[14])*pt;
1051 //########################################################################
1054 Bool_t cuts[kNCuts];
1055 for (Int_t i=0; i<kNCuts; i++) cuts[i]=kFALSE;
1057 // track quality cuts
1058 if (fCutRequireTPCRefit && (status&AliESDtrack::kTPCrefit)==0)
1060 if (fCutRequireTPCStandAlone && (status&AliESDtrack::kTPCin)==0)
1062 if (fCutRequireITSRefit && (status&AliESDtrack::kITSrefit)==0)
1064 if (nClustersTPC<fCutMinNClusterTPC)
1066 if (nClustersITS<fCutMinNClusterITS)
1068 if (chi2PerClusterTPC>fCutMaxChi2PerClusterTPC)
1070 if (chi2PerClusterITS>fCutMaxChi2PerClusterITS)
1072 if (extCov[0] > fCutMaxC11)
1074 if (extCov[2] > fCutMaxC22)
1076 if (extCov[5] > fCutMaxC33)
1078 if (extCov[9] > fCutMaxC44)
1080 if (extCov[14] > fCutMaxC55)
1082 if (nSigmaToVertex > fCutNsigmaToVertex && fCutSigmaToVertexRequired)
1084 // if n sigma could not be calculated
1085 if (nSigmaToVertex<0 && fCutSigmaToVertexRequired)
1087 if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
1089 // track kinematics cut
1090 if((momentum < fPMin) || (momentum > fPMax))
1092 if((pt < fPtMin) || (pt > fPtMax))
1094 if((p[0] < fPxMin) || (p[0] > fPxMax))
1096 if((p[1] < fPyMin) || (p[1] > fPyMax))
1098 if((p[2] < fPzMin) || (p[2] > fPzMax))
1100 if((eta < fEtaMin) || (eta > fEtaMax))
1102 if((y < fRapMin) || (y > fRapMax))
1104 if (fCutDCAToVertex2D && dcaToVertex > 1)
1106 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) > fCutMaxDCAToVertexXY)
1108 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) > fCutMaxDCAToVertexZ)
1110 if (fCutDCAToVertex2D && fCutMinDCAToVertexXY > 0 && fCutMinDCAToVertexZ > 0 && dcaToVertexXY*dcaToVertexXY/fCutMinDCAToVertexXY/fCutMinDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMinDCAToVertexZ/fCutMinDCAToVertexZ < 1)
1112 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) < fCutMinDCAToVertexXY)
1114 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) < fCutMinDCAToVertexZ)
1117 for (Int_t i = 0; i < 3; i++)
1118 cuts[28+i] = !CheckITSClusterRequirement(fCutClusterRequirementITS[i], esdTrack->HasPointOnITSLayer(i*2), esdTrack->HasPointOnITSLayer(i*2+1));
1120 if(fCutRequireITSStandAlone || fCutRequireITSpureSA){
1121 if ((status & AliESDtrack::kITSin) == 0 || (status & AliESDtrack::kTPCin)){
1125 // ITS standalone tracks
1126 if(fCutRequireITSStandAlone && !fCutRequireITSpureSA){
1127 if(status & AliESDtrack::kITSpureSA) cuts[31] = kTRUE;
1128 }else if(fCutRequireITSpureSA){
1129 if(!(status & AliESDtrack::kITSpureSA)) cuts[31] = kTRUE;
1134 if (relUncertainty1Pt > fCutMaxRel1PtUncertainty)
1137 if (!fCutAcceptSharedTPCClusters && nClustersTPCShared!=0)
1140 if (fracClustersTPCShared > fCutMaxFractionSharedTPCClusters)
1143 Int_t nITSPointsForPid=0;
1144 UChar_t clumap=esdTrack->GetITSClusterMap();
1145 for(Int_t i=2; i<6; i++){
1146 if(clumap&(1<<i)) ++nITSPointsForPid;
1148 if(fCutRequireITSPid && nITSPointsForPid<3) cuts[35] = kTRUE;
1151 if (nCrossedRowsTPC<fCutMinNCrossedRowsTPC)
1153 if (ratioCrossedRowsOverFindableClustersTPC<fCutMinRatioCrossedRowsOverFindableClustersTPC)
1156 Int_t nMissITSpts=0;
1157 Int_t idet,statusLay;
1159 for(Int_t iLay=0; iLay<6; iLay++){
1160 Bool_t retc=esdTrack->GetITSModuleIndexInfo(iLay,idet,statusLay,xloc,zloc);
1161 if(retc && statusLay==5) ++nMissITSpts;
1163 if(nMissITSpts>fCutMaxMissingITSPoints) cuts[38] = kTRUE;
1166 for (Int_t i=0; i<kNCuts; i++)
1167 if (cuts[i]) {cut = kTRUE;}
1170 //########################################################################
1171 // filling histograms
1172 if (fHistogramsOn) {
1173 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n tracks")));
1175 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n cut tracks")));
1177 for (Int_t i=0; i<kNCuts; i++) {
1178 if (fhCutStatistics->GetXaxis()->FindBin(fgkCutNames[i]) < 1)
1179 AliFatal(Form("Inconsistency! Cut %d with name %s not found", i, fgkCutNames[i]));
1182 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin(fgkCutNames[i])));
1184 for (Int_t j=i; j<kNCuts; j++) {
1185 if (cuts[i] && cuts[j]) {
1186 Float_t xC = fhCutCorrelation->GetXaxis()->GetBinCenter(fhCutCorrelation->GetXaxis()->FindBin(fgkCutNames[i]));
1187 Float_t yC = fhCutCorrelation->GetYaxis()->GetBinCenter(fhCutCorrelation->GetYaxis()->FindBin(fgkCutNames[j]));
1188 fhCutCorrelation->Fill(xC, yC);
1194 // now we loop over the filling of the histograms twice: once "before" the cut, once "after"
1195 // the code is not in a function due to too many local variables that would need to be passed
1197 for (Int_t id = 0; id < 2; id++)
1199 // id = 0 --> before cut
1200 // id = 1 --> after cut
1204 fhNClustersITS[id]->Fill(nClustersITS);
1205 fhNClustersTPC[id]->Fill(nClustersTPC);
1206 fhNSharedClustersTPC[id]->Fill(nClustersTPCShared);
1207 fhNCrossedRowsTPC[id]->Fill(nCrossedRowsTPC);
1208 fhRatioCrossedRowsOverFindableClustersTPC[id]->Fill(ratioCrossedRowsOverFindableClustersTPC);
1209 fhChi2PerClusterITS[id]->Fill(chi2PerClusterITS);
1210 fhChi2PerClusterTPC[id]->Fill(chi2PerClusterTPC);
1211 fhNClustersForITSPID[id]->Fill(nITSPointsForPid);
1212 fhNMissingITSPoints[id]->Fill(nMissITSpts);
1214 fhC11[id]->Fill(extCov[0]);
1215 fhC22[id]->Fill(extCov[2]);
1216 fhC33[id]->Fill(extCov[5]);
1217 fhC44[id]->Fill(extCov[9]);
1218 fhC55[id]->Fill(extCov[14]);
1220 fhRel1PtUncertainty[id]->Fill(relUncertainty1Pt);
1223 fhEta[id]->Fill(eta);
1226 bRes[0] = TMath::Sqrt(bCov[0]);
1227 bRes[1] = TMath::Sqrt(bCov[2]);
1229 fhDZ[id]->Fill(b[1]);
1230 fhDXY[id]->Fill(b[0]);
1231 fhDXYDZ[id]->Fill(dcaToVertex);
1232 fhDXYvsDZ[id]->Fill(b[1],b[0]);
1234 if (bRes[0]!=0 && bRes[1]!=0) {
1235 fhDZNormalized[id]->Fill(b[1]/bRes[1]);
1236 fhDXYNormalized[id]->Fill(b[0]/bRes[0]);
1237 fhDXYvsDZNormalized[id]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
1238 fhNSigmaToVertex[id]->Fill(nSigmaToVertex);
1250 //____________________________________________________________________
1251 Bool_t AliESDtrackCuts::CheckITSClusterRequirement(ITSClusterRequirement req, Bool_t clusterL1, Bool_t clusterL2)
1253 // checks if the cluster requirement is fullfilled (in this case: return kTRUE)
1257 case kOff: return kTRUE;
1258 case kNone: return !clusterL1 && !clusterL2;
1259 case kAny: return clusterL1 || clusterL2;
1260 case kFirst: return clusterL1;
1261 case kOnlyFirst: return clusterL1 && !clusterL2;
1262 case kSecond: return clusterL2;
1263 case kOnlySecond: return clusterL2 && !clusterL1;
1264 case kBoth: return clusterL1 && clusterL2;
1270 //____________________________________________________________________
1271 AliESDtrack* AliESDtrackCuts::GetTPCOnlyTrack(AliESDEvent* esd, Int_t iTrack)
1274 // Utility function to
1275 // create a TPC only track from the given esd track
1277 // IMPORTANT: The track has to be deleted by the user
1279 // NB. most of the functionality to get a TPC only track from an ESD track is in AliESDtrack, where it should be
1280 // there are only missing propagations here that are needed for old data
1281 // this function will therefore become obsolete
1283 // adapted from code provided by CKB
1285 if (!esd->GetPrimaryVertexTPC())
1286 return 0; // No TPC vertex no TPC tracks
1288 if(!esd->GetPrimaryVertexTPC()->GetStatus())
1289 return 0; // TPC Vertex is created by default in AliESDEvent, do not use in this case
1291 AliESDtrack* track = esd->GetTrack(iTrack);
1295 AliESDtrack *tpcTrack = new AliESDtrack();
1297 // only true if we have a tpc track
1298 if (!track->FillTPCOnlyTrack(*tpcTrack))
1304 // propagate to Vertex
1305 // not needed for normal reconstructed ESDs...
1306 // Double_t pTPC[2],covTPC[3];
1307 // tpcTrack->PropagateToDCA(esd->GetPrimaryVertexTPC(), esd->GetMagneticField(), 10000, pTPC, covTPC);
1312 //____________________________________________________________________
1313 TObjArray* AliESDtrackCuts::GetAcceptedTracks(AliESDEvent* esd,Bool_t bTPC)
1316 // returns an array of all tracks that pass the cuts
1317 // or an array of TPC only tracks (propagated to the TPC vertex during reco)
1318 // tracks that pass the cut
1320 // NOTE: List has to be deleted by the user
1322 TObjArray* acceptedTracks = new TObjArray();
1324 // loop over esd tracks
1325 for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
1327 if(!esd->GetPrimaryVertexTPC())return acceptedTracks; // No TPC vertex no TPC tracks
1328 if(!esd->GetPrimaryVertexTPC()->GetStatus())return acceptedTracks; // No proper TPC vertex, only the default
1330 AliESDtrack *tpcTrack = GetTPCOnlyTrack(esd, iTrack);
1334 if (AcceptTrack(tpcTrack)) {
1335 acceptedTracks->Add(tpcTrack);
1342 AliESDtrack* track = esd->GetTrack(iTrack);
1343 if(AcceptTrack(track))
1344 acceptedTracks->Add(track);
1347 if(bTPC)acceptedTracks->SetOwner(kTRUE);
1348 return acceptedTracks;
1351 //____________________________________________________________________
1352 Int_t AliESDtrackCuts::CountAcceptedTracks(const AliESDEvent* const esd)
1355 // returns an the number of tracks that pass the cuts
1360 // loop over esd tracks
1361 for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
1362 AliESDtrack* track = esd->GetTrack(iTrack);
1363 if (AcceptTrack(track))
1370 //____________________________________________________________________
1371 void AliESDtrackCuts::DefineHistograms(Int_t color) {
1373 // diagnostics histograms are defined
1376 fHistogramsOn=kTRUE;
1378 Bool_t oldStatus = TH1::AddDirectoryStatus();
1379 TH1::AddDirectory(kFALSE);
1381 //###################################################################################
1382 // defining histograms
1384 fhCutStatistics = new TH1F("cut_statistics","cut statistics",kNCuts+4,-0.5,kNCuts+3.5);
1386 fhCutStatistics->GetXaxis()->SetBinLabel(1,"n tracks");
1387 fhCutStatistics->GetXaxis()->SetBinLabel(2,"n cut tracks");
1389 fhCutCorrelation = new TH2F("cut_correlation","cut correlation",kNCuts,-0.5,kNCuts-0.5,kNCuts,-0.5,kNCuts-0.5);;
1391 for (Int_t i=0; i<kNCuts; i++) {
1392 fhCutStatistics->GetXaxis()->SetBinLabel(i+4,fgkCutNames[i]);
1393 fhCutCorrelation->GetXaxis()->SetBinLabel(i+1,fgkCutNames[i]);
1394 fhCutCorrelation->GetYaxis()->SetBinLabel(i+1,fgkCutNames[i]);
1397 fhCutStatistics ->SetLineColor(color);
1398 fhCutCorrelation ->SetLineColor(color);
1399 fhCutStatistics ->SetLineWidth(2);
1400 fhCutCorrelation ->SetLineWidth(2);
1402 for (Int_t i=0; i<2; i++) {
1403 fhNClustersITS[i] = new TH1F("nClustersITS" ,"",8,-0.5,7.5);
1404 fhNClustersTPC[i] = new TH1F("nClustersTPC" ,"",165,-0.5,164.5);
1405 fhNSharedClustersTPC[i] = new TH1F("nSharedClustersTPC" ,"",165,-0.5,164.5);
1406 fhNCrossedRowsTPC[i] = new TH1F("nCrossedRowsTPC" ,"",165,-0.5,164.5);
1407 fhRatioCrossedRowsOverFindableClustersTPC[i] = new TH1F("ratioCrossedRowsOverFindableClustersTPC" ,"",60,0,1.5);
1408 fhChi2PerClusterITS[i] = new TH1F("chi2PerClusterITS","",500,0,10);
1409 fhChi2PerClusterTPC[i] = new TH1F("chi2PerClusterTPC","",500,0,10);
1410 fhNClustersForITSPID[i] = new TH1F("nPointsForITSpid","",5,-0.5,4.5);
1411 fhNMissingITSPoints[i] = new TH1F("nMissingITSClusters","",7,-0.5,6.5);
1413 fhC11[i] = new TH1F("covMatrixDiagonal11","",2000,0,20);
1414 fhC22[i] = new TH1F("covMatrixDiagonal22","",2000,0,20);
1415 fhC33[i] = new TH1F("covMatrixDiagonal33","",1000,0,0.1);
1416 fhC44[i] = new TH1F("covMatrixDiagonal44","",1000,0,0.1);
1417 fhC55[i] = new TH1F("covMatrixDiagonal55","",1000,0,5);
1419 fhRel1PtUncertainty[i] = new TH1F("rel1PtUncertainty","",1000,0,5);
1421 fhDXY[i] = new TH1F("dXY" ,"",500,-10,10);
1422 fhDZ[i] = new TH1F("dZ" ,"",500,-10,10);
1423 fhDXYDZ[i] = new TH1F("dXYDZ" ,"",500,0,10);
1424 fhDXYvsDZ[i] = new TH2F("dXYvsDZ","",200,-10,10,200,-10,10);
1426 fhDXYNormalized[i] = new TH1F("dXYNormalized" ,"",500,-10,10);
1427 fhDZNormalized[i] = new TH1F("dZNormalized" ,"",500,-10,10);
1428 fhDXYvsDZNormalized[i] = new TH2F("dXYvsDZNormalized","",200,-10,10,200,-10,10);
1430 fhNSigmaToVertex[i] = new TH1F("nSigmaToVertex","",500,0,10);
1432 fhPt[i] = new TH1F("pt" ,"p_{T} distribution;p_{T} (GeV/c)", 800, 0.0, 10.0);
1433 fhEta[i] = new TH1F("eta" ,"#eta distribution;#eta",40,-2.0,2.0);
1435 fhNClustersITS[i]->SetTitle("n ITS clusters");
1436 fhNClustersTPC[i]->SetTitle("n TPC clusters");
1437 fhNSharedClustersTPC[i]->SetTitle("n TPC shared clusters");
1438 fhChi2PerClusterITS[i]->SetTitle("#Chi^{2} per ITS cluster");
1439 fhChi2PerClusterTPC[i]->SetTitle("#Chi^{2} per TPC cluster");
1440 fhNClustersForITSPID[i]->SetTitle("n ITS points for PID");
1441 fhNMissingITSPoints[i]->SetTitle("n ITS layers with missing cluster");
1443 fhC11[i]->SetTitle("cov 11 : #sigma_{y}^{2} [cm^{2}]");
1444 fhC22[i]->SetTitle("cov 22 : #sigma_{z}^{2} [cm^{2}]");
1445 fhC33[i]->SetTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
1446 fhC44[i]->SetTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
1447 fhC55[i]->SetTitle("cov 55 : #sigma_{1/p_{T}}^{2} [(c/GeV)^2]");
1449 fhRel1PtUncertainty[i]->SetTitle("rel. uncertainty of 1/p_{T}");
1451 fhDXY[i]->SetXTitle("transverse impact parameter (cm)");
1452 fhDZ[i]->SetXTitle("longitudinal impact parameter (cm)");
1453 fhDXYDZ[i]->SetTitle("absolute impact parameter;sqrt(dXY**2 + dZ**2) (cm)");
1454 fhDXYvsDZ[i]->SetXTitle("longitudinal impact parameter (cm)");
1455 fhDXYvsDZ[i]->SetYTitle("transverse impact parameter (cm)");
1457 fhDXYNormalized[i]->SetTitle("normalized trans impact par (n#sigma)");
1458 fhDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)");
1459 fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)");
1460 fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par (n#sigma)");
1461 fhNSigmaToVertex[i]->SetTitle("n #sigma to vertex");
1463 fhNClustersITS[i]->SetLineColor(color); fhNClustersITS[i]->SetLineWidth(2);
1464 fhNClustersTPC[i]->SetLineColor(color); fhNClustersTPC[i]->SetLineWidth(2);
1465 fhNSharedClustersTPC[i]->SetLineColor(color); fhNSharedClustersTPC[i]->SetLineWidth(2);
1466 fhChi2PerClusterITS[i]->SetLineColor(color); fhChi2PerClusterITS[i]->SetLineWidth(2);
1467 fhChi2PerClusterTPC[i]->SetLineColor(color); fhChi2PerClusterTPC[i]->SetLineWidth(2);
1468 fhNClustersForITSPID[i]->SetLineColor(color); fhNClustersForITSPID[i]->SetLineWidth(2);
1469 fhNMissingITSPoints[i]->SetLineColor(color); fhNMissingITSPoints[i]->SetLineWidth(2);
1471 fhC11[i]->SetLineColor(color); fhC11[i]->SetLineWidth(2);
1472 fhC22[i]->SetLineColor(color); fhC22[i]->SetLineWidth(2);
1473 fhC33[i]->SetLineColor(color); fhC33[i]->SetLineWidth(2);
1474 fhC44[i]->SetLineColor(color); fhC44[i]->SetLineWidth(2);
1475 fhC55[i]->SetLineColor(color); fhC55[i]->SetLineWidth(2);
1477 fhRel1PtUncertainty[i]->SetLineColor(color); fhRel1PtUncertainty[i]->SetLineWidth(2);
1479 fhDXY[i]->SetLineColor(color); fhDXY[i]->SetLineWidth(2);
1480 fhDZ[i]->SetLineColor(color); fhDZ[i]->SetLineWidth(2);
1481 fhDXYDZ[i]->SetLineColor(color); fhDXYDZ[i]->SetLineWidth(2);
1483 fhDXYNormalized[i]->SetLineColor(color); fhDXYNormalized[i]->SetLineWidth(2);
1484 fhDZNormalized[i]->SetLineColor(color); fhDZNormalized[i]->SetLineWidth(2);
1485 fhNSigmaToVertex[i]->SetLineColor(color); fhNSigmaToVertex[i]->SetLineWidth(2);
1488 // The number of sigmas to the vertex is per definition gaussian
1489 ffDTheoretical = new TF1("nSigmaToVertexTheoretical","([0]/2.506628274)*exp(-(x**2)/2)",0,50);
1490 ffDTheoretical->SetParameter(0,1);
1492 TH1::AddDirectory(oldStatus);
1495 //____________________________________________________________________
1496 Bool_t AliESDtrackCuts::LoadHistograms(const Char_t* dir)
1499 // loads the histograms from a file
1500 // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
1506 if (!gDirectory->cd(dir))
1509 ffDTheoretical = dynamic_cast<TF1*> (gDirectory->Get("nSigmaToVertexTheory"));
1511 fhCutStatistics = dynamic_cast<TH1F*> (gDirectory->Get("cut_statistics"));
1512 fhCutCorrelation = dynamic_cast<TH2F*> (gDirectory->Get("cut_correlation"));
1514 for (Int_t i=0; i<2; i++) {
1517 gDirectory->cd("before_cuts");
1520 gDirectory->cd("after_cuts");
1522 fhNClustersITS[i] = dynamic_cast<TH1F*> (gDirectory->Get("nClustersITS" ));
1523 fhNClustersTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("nClustersTPC" ));
1524 fhNSharedClustersTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("nSharedClustersTPC" ));
1525 fhNCrossedRowsTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("nCrossedRowsTPC" ));
1526 fhRatioCrossedRowsOverFindableClustersTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("ratioCrossedRowsOverFindableClustersTPC" ));
1527 fhChi2PerClusterITS[i] = dynamic_cast<TH1F*> (gDirectory->Get("chi2PerClusterITS"));
1528 fhChi2PerClusterTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("chi2PerClusterTPC"));
1529 fhNClustersForITSPID[i] = dynamic_cast<TH1F*> (gDirectory->Get("nPointsForITSpid"));
1530 fhNMissingITSPoints[i] = dynamic_cast<TH1F*> (gDirectory->Get("nMissingITSClusters"));
1532 fhC11[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal11"));
1533 fhC22[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal22"));
1534 fhC33[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal33"));
1535 fhC44[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal44"));
1536 fhC55[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal55"));
1538 fhRel1PtUncertainty[i] = dynamic_cast<TH1F*> (gDirectory->Get("rel1PtUncertainty"));
1540 fhDXY[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXY" ));
1541 fhDZ[i] = dynamic_cast<TH1F*> (gDirectory->Get("dZ" ));
1542 fhDXYDZ[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXYDZ"));
1543 fhDXYvsDZ[i] = dynamic_cast<TH2F*> (gDirectory->Get("dXYvsDZ"));
1545 fhDXYNormalized[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXYNormalized" ));
1546 fhDZNormalized[i] = dynamic_cast<TH1F*> (gDirectory->Get("dZNormalized" ));
1547 fhDXYvsDZNormalized[i] = dynamic_cast<TH2F*> (gDirectory->Get("dXYvsDZNormalized"));
1548 fhNSigmaToVertex[i] = dynamic_cast<TH1F*> (gDirectory->Get("nSigmaToVertex"));
1550 fhPt[i] = dynamic_cast<TH1F*> (gDirectory->Get("pt"));
1551 fhEta[i] = dynamic_cast<TH1F*> (gDirectory->Get("eta"));
1553 gDirectory->cd("../");
1556 gDirectory->cd("..");
1561 //____________________________________________________________________
1562 void AliESDtrackCuts::SaveHistograms(const Char_t* dir) {
1564 // saves the histograms in a directory (dir)
1567 if (!fHistogramsOn) {
1568 AliDebug(0, "Histograms not on - cannot save histograms!!!");
1575 gDirectory->mkdir(dir);
1576 gDirectory->cd(dir);
1578 gDirectory->mkdir("before_cuts");
1579 gDirectory->mkdir("after_cuts");
1581 // a factor of 2 is needed since n sigma is positive
1582 ffDTheoretical->SetParameter(0,2*fhNSigmaToVertex[0]->Integral("width"));
1583 ffDTheoretical->Write("nSigmaToVertexTheory");
1585 fhCutStatistics->Write();
1586 fhCutCorrelation->Write();
1588 for (Int_t i=0; i<2; i++) {
1590 gDirectory->cd("before_cuts");
1592 gDirectory->cd("after_cuts");
1594 fhNClustersITS[i] ->Write();
1595 fhNClustersTPC[i] ->Write();
1596 fhNSharedClustersTPC[i] ->Write();
1597 fhNCrossedRowsTPC[i] ->Write();
1598 fhRatioCrossedRowsOverFindableClustersTPC[i] ->Write();
1599 fhChi2PerClusterITS[i] ->Write();
1600 fhChi2PerClusterTPC[i] ->Write();
1601 fhNClustersForITSPID[i] ->Write();
1602 fhNMissingITSPoints[i] ->Write();
1610 fhRel1PtUncertainty[i] ->Write();
1614 fhDXYDZ[i] ->Write();
1615 fhDXYvsDZ[i] ->Write();
1617 fhDXYNormalized[i] ->Write();
1618 fhDZNormalized[i] ->Write();
1619 fhDXYvsDZNormalized[i] ->Write();
1620 fhNSigmaToVertex[i] ->Write();
1625 gDirectory->cd("../");
1628 gDirectory->cd("../");
1631 //____________________________________________________________________
1632 void AliESDtrackCuts::DrawHistograms()
1634 // draws some histograms
1636 TCanvas* canvas1 = new TCanvas(Form("%s_1", GetName()), "Track Quality Results1", 800, 800);
1637 canvas1->Divide(2, 2);
1640 fhNClustersTPC[0]->SetStats(kFALSE);
1641 fhNClustersTPC[0]->Draw();
1644 fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1645 fhChi2PerClusterTPC[0]->Draw();
1648 fhNSigmaToVertex[0]->SetStats(kFALSE);
1649 fhNSigmaToVertex[0]->GetXaxis()->SetRangeUser(0, 10);
1650 fhNSigmaToVertex[0]->Draw();
1652 canvas1->SaveAs(Form("%s_%s.gif", GetName(), canvas1->GetName()));
1654 TCanvas* canvas2 = new TCanvas(Form("%s_2", GetName()), "Track Quality Results2", 1200, 800);
1655 canvas2->Divide(3, 2);
1658 fhC11[0]->SetStats(kFALSE);
1663 fhC22[0]->SetStats(kFALSE);
1668 fhC33[0]->SetStats(kFALSE);
1673 fhC44[0]->SetStats(kFALSE);
1678 fhC55[0]->SetStats(kFALSE);
1683 fhRel1PtUncertainty[0]->SetStats(kFALSE);
1685 fhRel1PtUncertainty[0]->Draw();
1687 canvas2->SaveAs(Form("%s_%s.gif", GetName(), canvas2->GetName()));
1689 TCanvas* canvas3 = new TCanvas(Form("%s_3", GetName()), "Track Quality Results3", 1200, 800);
1690 canvas3->Divide(3, 2);
1693 fhDXY[0]->SetStats(kFALSE);
1698 fhDZ[0]->SetStats(kFALSE);
1703 fhDXYvsDZ[0]->SetStats(kFALSE);
1705 gPad->SetRightMargin(0.15);
1706 fhDXYvsDZ[0]->Draw("COLZ");
1709 fhDXYNormalized[0]->SetStats(kFALSE);
1711 fhDXYNormalized[0]->Draw();
1714 fhDZNormalized[0]->SetStats(kFALSE);
1716 fhDZNormalized[0]->Draw();
1719 fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1721 gPad->SetRightMargin(0.15);
1722 fhDXYvsDZNormalized[0]->Draw("COLZ");
1724 canvas3->SaveAs(Form("%s_%s.gif", GetName(), canvas3->GetName()));
1726 TCanvas* canvas4 = new TCanvas(Form("%s_4", GetName()), "Track Quality Results4", 800, 500);
1727 canvas4->Divide(2, 1);
1730 fhCutStatistics->SetStats(kFALSE);
1731 fhCutStatistics->LabelsOption("v");
1732 gPad->SetBottomMargin(0.3);
1733 fhCutStatistics->Draw();
1736 fhCutCorrelation->SetStats(kFALSE);
1737 fhCutCorrelation->LabelsOption("v");
1738 gPad->SetBottomMargin(0.3);
1739 gPad->SetLeftMargin(0.3);
1740 fhCutCorrelation->Draw("COLZ");
1742 canvas4->SaveAs(Form("%s_%s.gif", GetName(), canvas4->GetName()));
1745 fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1746 fhDXYvsDZNormalized[0]->DrawCopy("COLZ");
1749 fhNClustersTPC[0]->SetStats(kFALSE);
1750 fhNClustersTPC[0]->DrawCopy();
1753 fhChi2PerClusterITS[0]->SetStats(kFALSE);
1754 fhChi2PerClusterITS[0]->DrawCopy();
1755 fhChi2PerClusterITS[1]->SetLineColor(2);
1756 fhChi2PerClusterITS[1]->DrawCopy("SAME");
1759 fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1760 fhChi2PerClusterTPC[0]->DrawCopy();
1761 fhChi2PerClusterTPC[1]->SetLineColor(2);
1762 fhChi2PerClusterTPC[1]->DrawCopy("SAME");*/
1764 //--------------------------------------------------------------------------
1765 void AliESDtrackCuts::SetPtDepDCACuts(Double_t pt) {
1767 // set the pt-dependent DCA cuts
1770 if(f1CutMaxDCAToVertexXYPtDep) {
1771 fCutMaxDCAToVertexXY=f1CutMaxDCAToVertexXYPtDep->Eval(pt);
1774 if(f1CutMaxDCAToVertexZPtDep) {
1775 fCutMaxDCAToVertexZ=f1CutMaxDCAToVertexZPtDep->Eval(pt);
1778 if(f1CutMinDCAToVertexXYPtDep) {
1779 fCutMinDCAToVertexXY=f1CutMinDCAToVertexXYPtDep->Eval(pt);
1782 if(f1CutMinDCAToVertexZPtDep) {
1783 fCutMinDCAToVertexZ=f1CutMinDCAToVertexZPtDep->Eval(pt);
1792 //--------------------------------------------------------------------------
1793 Bool_t AliESDtrackCuts::CheckPtDepDCA(TString dist,Bool_t print) const {
1795 // Check the correctness of the string syntax
1797 Bool_t retval=kTRUE;
1799 if(!dist.Contains("pt")) {
1800 if(print) printf("AliESDtrackCuts::CheckPtDepDCA(): string must contain \"pt\"\n");
1806 void AliESDtrackCuts::SetMaxDCAToVertexXYPtDep(const char *dist){
1808 if(f1CutMaxDCAToVertexXYPtDep){
1809 delete f1CutMaxDCAToVertexXYPtDep;
1811 f1CutMaxDCAToVertexXYPtDep = 0;
1812 fCutMaxDCAToVertexXYPtDep = "";
1814 if(!CheckPtDepDCA(dist,kTRUE)){
1817 fCutMaxDCAToVertexXYPtDep = dist;
1819 tmp.ReplaceAll("pt","x");
1820 f1CutMaxDCAToVertexXYPtDep = new TFormula("f1CutMaxDCAToVertexXYPtDep",tmp.Data());
1824 void AliESDtrackCuts::SetMaxDCAToVertexZPtDep(const char *dist){
1827 if(f1CutMaxDCAToVertexZPtDep){
1828 delete f1CutMaxDCAToVertexZPtDep;
1830 f1CutMaxDCAToVertexZPtDep = 0;
1831 fCutMaxDCAToVertexZPtDep = "";
1833 if(!CheckPtDepDCA(dist,kTRUE))return;
1835 fCutMaxDCAToVertexZPtDep = dist;
1837 tmp.ReplaceAll("pt","x");
1838 f1CutMaxDCAToVertexZPtDep = new TFormula("f1CutMaxDCAToVertexZPtDep",tmp.Data());
1844 void AliESDtrackCuts::SetMinDCAToVertexXYPtDep(const char *dist){
1847 if(f1CutMinDCAToVertexXYPtDep){
1848 delete f1CutMinDCAToVertexXYPtDep;
1850 f1CutMinDCAToVertexXYPtDep = 0;
1851 fCutMinDCAToVertexXYPtDep = "";
1853 if(!CheckPtDepDCA(dist,kTRUE))return;
1855 fCutMinDCAToVertexXYPtDep = dist;
1857 tmp.ReplaceAll("pt","x");
1858 f1CutMinDCAToVertexXYPtDep = new TFormula("f1CutMinDCAToVertexXYPtDep",tmp.Data());
1863 void AliESDtrackCuts::SetMinDCAToVertexZPtDep(const char *dist){
1867 if(f1CutMinDCAToVertexZPtDep){
1868 delete f1CutMinDCAToVertexZPtDep;
1870 f1CutMinDCAToVertexZPtDep = 0;
1871 fCutMinDCAToVertexZPtDep = "";
1873 if(!CheckPtDepDCA(dist,kTRUE))return;
1874 fCutMinDCAToVertexZPtDep = dist;
1876 tmp.ReplaceAll("pt","x");
1877 f1CutMinDCAToVertexZPtDep = new TFormula("f1CutMinDCAToVertexZPtDep",tmp.Data());