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] = {
40 "#Chi^{2}/cluster TPC",
41 "#Chi^{2}/cluster ITS",
57 "trk-to-vtx max dca 2D absolute",
58 "trk-to-vtx max dca xy absolute",
59 "trk-to-vtx max dca z absolute",
60 "trk-to-vtx min dca 2D absolute",
61 "trk-to-vtx min dca xy absolute",
62 "trk-to-vtx min dca z absolute",
63 "SPD cluster requirement",
64 "SDD cluster requirement",
65 "SSD cluster requirement",
66 "require ITS stand-alone",
67 "rel 1/pt uncertainty"
70 //____________________________________________________________________
71 AliESDtrackCuts::AliESDtrackCuts(const Char_t* name, const Char_t* title) : AliAnalysisCuts(name,title),
72 fCutMinNClusterTPC(0),
73 fCutMinNClusterITS(0),
74 fCutMaxChi2PerClusterTPC(0),
75 fCutMaxChi2PerClusterITS(0),
81 fCutMaxRel1PtUncertainty(0),
82 fCutAcceptKinkDaughters(0),
83 fCutRequireTPCRefit(0),
84 fCutRequireITSRefit(0),
85 fCutRequireITSStandAlone(0),
86 fCutNsigmaToVertex(0),
87 fCutSigmaToVertexRequired(0),
88 fCutMaxDCAToVertexXY(0),
89 fCutMaxDCAToVertexZ(0),
90 fCutMinDCAToVertexXY(0),
91 fCutMinDCAToVertexZ(0),
118 //##############################################################################
119 // setting default cuts
120 SetMinNClustersTPC();
121 SetMinNClustersITS();
122 SetMaxChi2PerClusterTPC();
123 SetMaxChi2PerClusterITS();
124 SetMaxCovDiagonalElements();
125 SetMaxRel1PtUncertainty();
126 SetRequireTPCRefit();
127 SetRequireITSRefit();
128 SetRequireITSStandAlone(kFALSE);
129 SetAcceptKinkDaughters();
130 SetMaxNsigmaToVertex();
131 SetMaxDCAToVertexXY();
132 SetMaxDCAToVertexZ();
134 SetMinDCAToVertexXY();
135 SetMinDCAToVertexZ();
143 SetClusterRequirementITS(kSPD);
144 SetClusterRequirementITS(kSDD);
145 SetClusterRequirementITS(kSSD);
150 //_____________________________________________________________________________
151 AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : AliAnalysisCuts(c),
152 fCutMinNClusterTPC(0),
153 fCutMinNClusterITS(0),
154 fCutMaxChi2PerClusterTPC(0),
155 fCutMaxChi2PerClusterITS(0),
161 fCutMaxRel1PtUncertainty(0),
162 fCutAcceptKinkDaughters(0),
163 fCutRequireTPCRefit(0),
164 fCutRequireITSRefit(0),
165 fCutRequireITSStandAlone(0),
166 fCutNsigmaToVertex(0),
167 fCutSigmaToVertexRequired(0),
168 fCutMaxDCAToVertexXY(0),
169 fCutMaxDCAToVertexZ(0),
170 fCutMinDCAToVertexXY(0),
171 fCutMinDCAToVertexZ(0),
172 fCutDCAToVertex2D(0),
196 ((AliESDtrackCuts &) c).Copy(*this);
199 AliESDtrackCuts::~AliESDtrackCuts()
205 for (Int_t i=0; i<2; i++) {
207 if (fhNClustersITS[i])
208 delete fhNClustersITS[i];
209 if (fhNClustersTPC[i])
210 delete fhNClustersTPC[i];
211 if (fhChi2PerClusterITS[i])
212 delete fhChi2PerClusterITS[i];
213 if (fhChi2PerClusterTPC[i])
214 delete fhChi2PerClusterTPC[i];
226 if (fhRel1PtUncertainty[i])
227 delete fhRel1PtUncertainty[i];
238 if (fhDXYNormalized[i])
239 delete fhDXYNormalized[i];
240 if (fhDZNormalized[i])
241 delete fhDZNormalized[i];
242 if (fhDXYvsDZNormalized[i])
243 delete fhDXYvsDZNormalized[i];
244 if (fhNSigmaToVertex[i])
245 delete fhNSigmaToVertex[i];
253 delete ffDTheoretical;
256 delete fhCutStatistics;
257 if (fhCutCorrelation)
258 delete fhCutCorrelation;
261 void AliESDtrackCuts::Init()
264 // sets everything to zero
267 fCutMinNClusterTPC = 0;
268 fCutMinNClusterITS = 0;
270 fCutMaxChi2PerClusterTPC = 0;
271 fCutMaxChi2PerClusterITS = 0;
273 for (Int_t i = 0; i < 3; i++)
274 fCutClusterRequirementITS[i] = kOff;
282 fCutMaxRel1PtUncertainty = 0;
284 fCutAcceptKinkDaughters = 0;
285 fCutRequireTPCRefit = 0;
286 fCutRequireITSRefit = 0;
287 fCutRequireITSStandAlone = 0;
289 fCutNsigmaToVertex = 0;
290 fCutSigmaToVertexRequired = 0;
291 fCutMaxDCAToVertexXY = 0;
292 fCutMaxDCAToVertexZ = 0;
293 fCutDCAToVertex2D = 0;
294 fCutMinDCAToVertexXY = 0;
295 fCutMinDCAToVertexZ = 0;
313 fHistogramsOn = kFALSE;
315 for (Int_t i=0; i<2; ++i)
317 fhNClustersITS[i] = 0;
318 fhNClustersTPC[i] = 0;
320 fhChi2PerClusterITS[i] = 0;
321 fhChi2PerClusterTPC[i] = 0;
329 fhRel1PtUncertainty[i] = 0;
336 fhDXYNormalized[i] = 0;
337 fhDZNormalized[i] = 0;
338 fhDXYvsDZNormalized[i] = 0;
339 fhNSigmaToVertex[i] = 0;
347 fhCutCorrelation = 0;
350 //_____________________________________________________________________________
351 AliESDtrackCuts &AliESDtrackCuts::operator=(const AliESDtrackCuts &c)
354 // Assignment operator
357 if (this != &c) ((AliESDtrackCuts &) c).Copy(*this);
361 //_____________________________________________________________________________
362 void AliESDtrackCuts::Copy(TObject &c) const
368 AliESDtrackCuts& target = (AliESDtrackCuts &) c;
372 target.fCutMinNClusterTPC = fCutMinNClusterTPC;
373 target.fCutMinNClusterITS = fCutMinNClusterITS;
375 target.fCutMaxChi2PerClusterTPC = fCutMaxChi2PerClusterTPC;
376 target.fCutMaxChi2PerClusterITS = fCutMaxChi2PerClusterITS;
378 for (Int_t i = 0; i < 3; i++)
379 target.fCutClusterRequirementITS[i] = fCutClusterRequirementITS[i];
381 target.fCutMaxC11 = fCutMaxC11;
382 target.fCutMaxC22 = fCutMaxC22;
383 target.fCutMaxC33 = fCutMaxC33;
384 target.fCutMaxC44 = fCutMaxC44;
385 target.fCutMaxC55 = fCutMaxC55;
387 target.fCutMaxRel1PtUncertainty = fCutMaxRel1PtUncertainty;
389 target.fCutAcceptKinkDaughters = fCutAcceptKinkDaughters;
390 target.fCutRequireTPCRefit = fCutRequireTPCRefit;
391 target.fCutRequireITSRefit = fCutRequireITSRefit;
392 target.fCutRequireITSStandAlone = fCutRequireITSStandAlone;
394 target.fCutNsigmaToVertex = fCutNsigmaToVertex;
395 target.fCutSigmaToVertexRequired = fCutSigmaToVertexRequired;
396 target.fCutMaxDCAToVertexXY = fCutMaxDCAToVertexXY;
397 target.fCutMaxDCAToVertexZ = fCutMaxDCAToVertexZ;
398 target.fCutDCAToVertex2D = fCutDCAToVertex2D;
399 target.fCutMinDCAToVertexXY = fCutMinDCAToVertexXY;
400 target.fCutMinDCAToVertexZ = fCutMinDCAToVertexZ;
402 target.fPMin = fPMin;
403 target.fPMax = fPMax;
404 target.fPtMin = fPtMin;
405 target.fPtMax = fPtMax;
406 target.fPxMin = fPxMin;
407 target.fPxMax = fPxMax;
408 target.fPyMin = fPyMin;
409 target.fPyMax = fPyMax;
410 target.fPzMin = fPzMin;
411 target.fPzMax = fPzMax;
412 target.fEtaMin = fEtaMin;
413 target.fEtaMax = fEtaMax;
414 target.fRapMin = fRapMin;
415 target.fRapMax = fRapMax;
417 target.fHistogramsOn = fHistogramsOn;
419 for (Int_t i=0; i<2; ++i)
421 if (fhNClustersITS[i]) target.fhNClustersITS[i] = (TH1F*) fhNClustersITS[i]->Clone();
422 if (fhNClustersTPC[i]) target.fhNClustersTPC[i] = (TH1F*) fhNClustersTPC[i]->Clone();
424 if (fhChi2PerClusterITS[i]) target.fhChi2PerClusterITS[i] = (TH1F*) fhChi2PerClusterITS[i]->Clone();
425 if (fhChi2PerClusterTPC[i]) target.fhChi2PerClusterTPC[i] = (TH1F*) fhChi2PerClusterTPC[i]->Clone();
427 if (fhC11[i]) target.fhC11[i] = (TH1F*) fhC11[i]->Clone();
428 if (fhC22[i]) target.fhC22[i] = (TH1F*) fhC22[i]->Clone();
429 if (fhC33[i]) target.fhC33[i] = (TH1F*) fhC33[i]->Clone();
430 if (fhC44[i]) target.fhC44[i] = (TH1F*) fhC44[i]->Clone();
431 if (fhC55[i]) target.fhC55[i] = (TH1F*) fhC55[i]->Clone();
433 if (fhRel1PtUncertainty[i]) target.fhRel1PtUncertainty[i] = (TH1F*) fhRel1PtUncertainty[i]->Clone();
435 if (fhDXY[i]) target.fhDXY[i] = (TH1F*) fhDXY[i]->Clone();
436 if (fhDZ[i]) target.fhDZ[i] = (TH1F*) fhDZ[i]->Clone();
437 if (fhDXYDZ[i]) target.fhDXYDZ[i] = (TH1F*) fhDXYDZ[i]->Clone();
438 if (fhDXYvsDZ[i]) target.fhDXYvsDZ[i] = (TH2F*) fhDXYvsDZ[i]->Clone();
440 if (fhDXYNormalized[i]) target.fhDXYNormalized[i] = (TH1F*) fhDXYNormalized[i]->Clone();
441 if (fhDZNormalized[i]) target.fhDZNormalized[i] = (TH1F*) fhDZNormalized[i]->Clone();
442 if (fhDXYvsDZNormalized[i]) target.fhDXYvsDZNormalized[i] = (TH2F*) fhDXYvsDZNormalized[i]->Clone();
443 if (fhNSigmaToVertex[i]) target.fhNSigmaToVertex[i] = (TH1F*) fhNSigmaToVertex[i]->Clone();
445 if (fhPt[i]) target.fhPt[i] = (TH1F*) fhPt[i]->Clone();
446 if (fhEta[i]) target.fhEta[i] = (TH1F*) fhEta[i]->Clone();
448 if (ffDTheoretical) target.ffDTheoretical = (TF1*) ffDTheoretical->Clone();
450 if (fhCutStatistics) target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
451 if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
456 //_____________________________________________________________________________
457 Long64_t AliESDtrackCuts::Merge(TCollection* list) {
458 // Merge a list of AliESDtrackCuts objects with this (needed for PROOF)
459 // Returns the number of merged objects (including this)
466 TIterator* iter = list->MakeIterator();
469 // collection of measured and generated histograms
471 while ((obj = iter->Next())) {
473 AliESDtrackCuts* entry = dynamic_cast<AliESDtrackCuts*>(obj);
477 if (!entry->fHistogramsOn)
480 for (Int_t i=0; i<2; i++) {
482 fhNClustersITS[i] ->Add(entry->fhNClustersITS[i] );
483 fhNClustersTPC[i] ->Add(entry->fhNClustersTPC[i] );
485 fhChi2PerClusterITS[i] ->Add(entry->fhChi2PerClusterITS[i]);
486 fhChi2PerClusterTPC[i] ->Add(entry->fhChi2PerClusterTPC[i]);
488 fhC11[i] ->Add(entry->fhC11[i] );
489 fhC22[i] ->Add(entry->fhC22[i] );
490 fhC33[i] ->Add(entry->fhC33[i] );
491 fhC44[i] ->Add(entry->fhC44[i] );
492 fhC55[i] ->Add(entry->fhC55[i] );
494 fhRel1PtUncertainty[i] ->Add(entry->fhRel1PtUncertainty[i]);
496 fhDXY[i] ->Add(entry->fhDXY[i] );
497 fhDZ[i] ->Add(entry->fhDZ[i] );
498 fhDXYDZ[i] ->Add(entry->fhDXYDZ[i] );
499 fhDXYvsDZ[i] ->Add(entry->fhDXYvsDZ[i] );
501 fhDXYNormalized[i] ->Add(entry->fhDXYNormalized[i] );
502 fhDZNormalized[i] ->Add(entry->fhDZNormalized[i] );
503 fhDXYvsDZNormalized[i] ->Add(entry->fhDXYvsDZNormalized[i]);
504 fhNSigmaToVertex[i] ->Add(entry->fhNSigmaToVertex[i]);
506 fhPt[i] ->Add(entry->fhPt[i]);
507 fhEta[i] ->Add(entry->fhEta[i]);
510 fhCutStatistics ->Add(entry->fhCutStatistics);
511 fhCutCorrelation ->Add(entry->fhCutCorrelation);
518 //____________________________________________________________________
519 AliESDtrackCuts* AliESDtrackCuts::GetStandardTPCOnlyTrackCuts()
521 // creates an AliESDtrackCuts object and fills it with standard values for TPC-only cuts
522 // see ALICE note: ...
524 Printf("AliESDtrackCuts::GetStandardTPCOnlyTrackCuts: Creating track cuts for TPC-only.");
526 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
528 esdTrackCuts->SetMinNClustersTPC(50);
529 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
530 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
532 esdTrackCuts->SetMaxDCAToVertexZ(3.2);
533 esdTrackCuts->SetMaxDCAToVertexXY(2.4);
534 esdTrackCuts->SetDCAToVertex2D(kTRUE);
539 //____________________________________________________________________
540 Int_t AliESDtrackCuts::GetReferenceMultiplicity(AliESDEvent* esd, Bool_t tpcOnly)
542 // Gets reference multiplicity following the standard cuts and a defined fiducial volume
543 // tpcOnly = kTRUE -> consider TPC-only tracks
544 // = kFALSE -> consider global tracks
548 Printf("AliESDtrackCuts::GetReferenceMultiplicity: Not implemented for global tracks!");
552 AliESDtrackCuts* esdTrackCuts = GetStandardTPCOnlyTrackCuts();
553 esdTrackCuts->SetEtaRange(-0.8, 0.8);
554 esdTrackCuts->SetPtRange(0.15);
556 Int_t nTracks = esdTrackCuts->CountAcceptedTracks(esd);
564 //____________________________________________________________________
565 Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack)
567 // Calculates the number of sigma to the vertex.
572 esdTrack->GetImpactParameters(b,bCov);
574 if (bCov[0]<=0 || bCov[2]<=0) {
575 AliDebugClass(1, "Estimated b resolution lower or equal zero!");
576 bCov[0]=0; bCov[2]=0;
578 bRes[0] = TMath::Sqrt(bCov[0]);
579 bRes[1] = TMath::Sqrt(bCov[2]);
581 // -----------------------------------
582 // How to get to a n-sigma cut?
584 // The accumulated statistics from 0 to d is
586 // -> Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma)
587 // -> 1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma)
589 // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-d**2)/2)
590 // Can this be expressed in a different way?
592 if (bRes[0] == 0 || bRes[1] ==0)
595 Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
597 // work around precision problem
598 // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
599 // 1e-15 corresponds to nsigma ~ 7.7
600 if (TMath::Exp(-d * d / 2) < 1e-15)
603 Float_t nSigma = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
607 void AliESDtrackCuts::EnableNeededBranches(TTree* tree)
609 // enables the branches needed by AcceptTrack, for a list see comment of AcceptTrack
611 tree->SetBranchStatus("fTracks.fFlags", 1);
612 tree->SetBranchStatus("fTracks.fITSncls", 1);
613 tree->SetBranchStatus("fTracks.fTPCncls", 1);
614 tree->SetBranchStatus("fTracks.fITSchi2", 1);
615 tree->SetBranchStatus("fTracks.fTPCchi2", 1);
616 tree->SetBranchStatus("fTracks.fC*", 1);
617 tree->SetBranchStatus("fTracks.fD", 1);
618 tree->SetBranchStatus("fTracks.fZ", 1);
619 tree->SetBranchStatus("fTracks.fCdd", 1);
620 tree->SetBranchStatus("fTracks.fCdz", 1);
621 tree->SetBranchStatus("fTracks.fCzz", 1);
622 tree->SetBranchStatus("fTracks.fP*", 1);
623 tree->SetBranchStatus("fTracks.fR*", 1);
624 tree->SetBranchStatus("fTracks.fKinkIndexes*", 1);
627 //____________________________________________________________________
628 Bool_t AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack)
631 // figure out if the tracks survives all the track cuts defined
633 // the different quality parameter and kinematic values are first
634 // retrieved from the track. then it is found out what cuts the
635 // track did not survive and finally the cuts are imposed.
637 // this function needs the following branches:
643 // fTracks.fC //GetExternalCovariance
644 // fTracks.fD //GetImpactParameters
645 // fTracks.fZ //GetImpactParameters
646 // fTracks.fCdd //GetImpactParameters
647 // fTracks.fCdz //GetImpactParameters
648 // fTracks.fCzz //GetImpactParameters
649 // fTracks.fP //GetPxPyPz
650 // fTracks.fR //GetMass
651 // fTracks.fP //GetMass
652 // fTracks.fKinkIndexes
654 UInt_t status = esdTrack->GetStatus();
656 // getting quality parameters from the ESD track
657 Int_t nClustersITS = esdTrack->GetITSclusters(0);
658 Int_t nClustersTPC = esdTrack->GetTPCclusters(0);
660 Float_t chi2PerClusterITS = -1;
661 Float_t chi2PerClusterTPC = -1;
663 chi2PerClusterITS = esdTrack->GetITSchi2()/Float_t(nClustersITS);
665 chi2PerClusterTPC = esdTrack->GetTPCchi2()/Float_t(nClustersTPC);
667 esdTrack->GetExternalCovariance(extCov);
669 // getting the track to vertex parameters
670 Float_t nSigmaToVertex = GetSigmaToVertex(esdTrack);
674 esdTrack->GetImpactParameters(b,bCov);
675 if (bCov[0]<=0 || bCov[2]<=0) {
676 AliDebug(1, "Estimated b resolution lower or equal zero!");
677 bCov[0]=0; bCov[2]=0;
680 Float_t dcaToVertexXY = b[0];
681 Float_t dcaToVertexZ = b[1];
683 Float_t dcaToVertex = -1;
685 if (fCutDCAToVertex2D)
687 dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY/fCutMaxDCAToVertexXY/fCutMaxDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMaxDCAToVertexZ/fCutMaxDCAToVertexZ);
690 dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY + dcaToVertexZ*dcaToVertexZ);
692 // getting the kinematic variables of the track
693 // (assuming the mass is known)
695 esdTrack->GetPxPyPz(p);
697 Float_t momentum = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2) + TMath::Power(p[2],2));
698 Float_t pt = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2));
699 Float_t energy = TMath::Sqrt(TMath::Power(esdTrack->GetMass(),2) + TMath::Power(momentum,2));
701 //y-eta related calculations
704 if((momentum != TMath::Abs(p[2]))&&(momentum != 0))
705 eta = 0.5*TMath::Log((momentum + p[2])/(momentum - p[2]));
706 if((energy != TMath::Abs(p[2]))&&(momentum != 0))
707 y = 0.5*TMath::Log((energy + p[2])/(energy - p[2]));
711 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]);
714 Float_t relUncertainty1Pt = TMath::Sqrt(extCov[14])*pt;
716 //########################################################################
720 for (Int_t i=0; i<kNCuts; i++) cuts[i]=kFALSE;
722 // track quality cuts
723 if (fCutRequireTPCRefit && (status&AliESDtrack::kTPCrefit)==0)
725 if (fCutRequireITSRefit && (status&AliESDtrack::kITSrefit)==0)
727 if (nClustersTPC<fCutMinNClusterTPC)
729 if (nClustersITS<fCutMinNClusterITS)
731 if (chi2PerClusterTPC>fCutMaxChi2PerClusterTPC)
733 if (chi2PerClusterITS>fCutMaxChi2PerClusterITS)
735 if (extCov[0] > fCutMaxC11)
737 if (extCov[2] > fCutMaxC22)
739 if (extCov[5] > fCutMaxC33)
741 if (extCov[9] > fCutMaxC44)
743 if (extCov[14] > fCutMaxC55)
745 if (nSigmaToVertex > fCutNsigmaToVertex && fCutSigmaToVertexRequired)
747 // if n sigma could not be calculated
748 if (nSigmaToVertex<0 && fCutSigmaToVertexRequired)
750 if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
752 // track kinematics cut
753 if((momentum < fPMin) || (momentum > fPMax))
755 if((pt < fPtMin) || (pt > fPtMax))
757 if((p[0] < fPxMin) || (p[0] > fPxMax))
759 if((p[1] < fPyMin) || (p[1] > fPyMax))
761 if((p[2] < fPzMin) || (p[2] > fPzMax))
763 if((eta < fEtaMin) || (eta > fEtaMax))
765 if((y < fRapMin) || (y > fRapMax))
767 if (fCutDCAToVertex2D && dcaToVertex > 1)
769 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) > fCutMaxDCAToVertexXY)
771 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) > fCutMaxDCAToVertexZ)
773 if (fCutDCAToVertex2D && fCutMinDCAToVertexXY > 0 && fCutMinDCAToVertexZ > 0 && dcaToVertexXY*dcaToVertexXY/fCutMinDCAToVertexXY/fCutMinDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMinDCAToVertexZ/fCutMinDCAToVertexZ < 1)
775 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) < fCutMinDCAToVertexXY)
777 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) < fCutMinDCAToVertexZ)
780 for (Int_t i = 0; i < 3; i++)
781 cuts[27+i] = !CheckITSClusterRequirement(fCutClusterRequirementITS[i], esdTrack->HasPointOnITSLayer(i*2), esdTrack->HasPointOnITSLayer(i*2+1));
783 if (fCutRequireITSStandAlone && ((status & AliESDtrack::kITSin) == 0 || (status & AliESDtrack::kTPCin)))
786 if (relUncertainty1Pt > fCutMaxRel1PtUncertainty)
790 for (Int_t i=0; i<kNCuts; i++)
791 if (cuts[i]) {cut = kTRUE;}
795 //########################################################################
796 // filling histograms
798 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n tracks")));
800 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n cut tracks")));
802 for (Int_t i=0; i<kNCuts; i++) {
804 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin(fgkCutNames[i])));
806 for (Int_t j=i; j<kNCuts; j++) {
807 if (cuts[i] && cuts[j]) {
808 Float_t xC = fhCutCorrelation->GetXaxis()->GetBinCenter(fhCutCorrelation->GetXaxis()->FindBin(fgkCutNames[i]));
809 Float_t yC = fhCutCorrelation->GetYaxis()->GetBinCenter(fhCutCorrelation->GetYaxis()->FindBin(fgkCutNames[j]));
810 fhCutCorrelation->Fill(xC, yC);
816 // now we loop over the filling of the histograms twice: once "before" the cut, once "after"
817 // the code is not in a function due to too many local variables that would need to be passed
819 for (Int_t id = 0; id < 2; id++)
821 // id = 0 --> before cut
822 // id = 1 --> after cut
826 fhNClustersITS[id]->Fill(nClustersITS);
827 fhNClustersTPC[id]->Fill(nClustersTPC);
828 fhChi2PerClusterITS[id]->Fill(chi2PerClusterITS);
829 fhChi2PerClusterTPC[id]->Fill(chi2PerClusterTPC);
831 fhC11[id]->Fill(extCov[0]);
832 fhC22[id]->Fill(extCov[2]);
833 fhC33[id]->Fill(extCov[5]);
834 fhC44[id]->Fill(extCov[9]);
835 fhC55[id]->Fill(extCov[14]);
837 fhRel1PtUncertainty[id]->Fill(relUncertainty1Pt);
840 fhEta[id]->Fill(eta);
843 bRes[0] = TMath::Sqrt(bCov[0]);
844 bRes[1] = TMath::Sqrt(bCov[2]);
846 fhDZ[id]->Fill(b[1]);
847 fhDXY[id]->Fill(b[0]);
848 fhDXYDZ[id]->Fill(dcaToVertex);
849 fhDXYvsDZ[id]->Fill(b[1],b[0]);
851 if (bRes[0]!=0 && bRes[1]!=0) {
852 fhDZNormalized[id]->Fill(b[1]/bRes[1]);
853 fhDXYNormalized[id]->Fill(b[0]/bRes[0]);
854 fhDXYvsDZNormalized[id]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
855 fhNSigmaToVertex[id]->Fill(nSigmaToVertex);
867 //____________________________________________________________________
868 Bool_t AliESDtrackCuts::CheckITSClusterRequirement(ITSClusterRequirement req, Bool_t clusterL1, Bool_t clusterL2)
870 // checks if the cluster requirement is fullfilled (in this case: return kTRUE)
874 case kOff: return kTRUE;
875 case kNone: return !clusterL1 && !clusterL2;
876 case kAny: return clusterL1 || clusterL2;
877 case kFirst: return clusterL1;
878 case kOnlyFirst: return clusterL1 && !clusterL2;
879 case kSecond: return clusterL2;
880 case kOnlySecond: return clusterL2 && !clusterL1;
881 case kBoth: return clusterL1 && clusterL2;
887 //____________________________________________________________________
888 AliESDtrack* AliESDtrackCuts::GetTPCOnlyTrack(AliESDEvent* esd, Int_t iTrack)
890 // creates a TPC only track from the given esd track
891 // the track has to be deleted by the user
893 // NB. most of the functionality to get a TPC only track from an ESD track is in AliESDtrack, where it should be
894 // there are only missing propagations here that are needed for old data
895 // this function will therefore become obsolete
897 // adapted from code provided by CKB
899 if (!esd->GetPrimaryVertexTPC())
900 return 0; // No TPC vertex no TPC tracks
902 if(!esd->GetPrimaryVertexTPC()->GetStatus())
903 return 0; // TPC Vertex is created by default in AliESDEvent, do not use in this case
905 AliESDtrack* track = esd->GetTrack(iTrack);
909 AliESDtrack *tpcTrack = new AliESDtrack();
911 // This should have been done during the reconstruction
912 // fixed by Juri in r26675
913 // but recalculate for older data CKB
915 track->GetImpactParametersTPC(p,cov);
917 track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
920 // only true if we have a tpc track
921 if (!track->FillTPCOnlyTrack(*tpcTrack))
927 // propagate to Vertex
928 // not needed for normal reconstructed ESDs...
929 // Double_t pTPC[2],covTPC[3];
930 // tpcTrack->PropagateToDCA(esd->GetPrimaryVertexTPC(), esd->GetMagneticField(), 10000, pTPC, covTPC);
935 //____________________________________________________________________
936 TObjArray* AliESDtrackCuts::GetAcceptedTracks(AliESDEvent* esd,Bool_t bTPC)
939 // returns an array of all tracks that pass the cuts
940 // or an array of TPC only tracks (propagated to the TPC vertex during reco)
941 // tracks that pass the cut
943 TObjArray* acceptedTracks = new TObjArray();
945 // loop over esd tracks
946 for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
948 if(!esd->GetPrimaryVertexTPC())return acceptedTracks; // No TPC vertex no TPC tracks
949 if(!esd->GetPrimaryVertexTPC()->GetStatus())return acceptedTracks; // No proper TPC vertex, only the default
951 AliESDtrack *tpcTrack = GetTPCOnlyTrack(esd, iTrack);
955 if (AcceptTrack(tpcTrack)) {
956 acceptedTracks->Add(tpcTrack);
963 AliESDtrack* track = esd->GetTrack(iTrack);
964 if(AcceptTrack(track))
965 acceptedTracks->Add(track);
968 if(bTPC)acceptedTracks->SetOwner(kTRUE);
969 return acceptedTracks;
972 //____________________________________________________________________
973 Int_t AliESDtrackCuts::CountAcceptedTracks(AliESDEvent* esd)
976 // returns an the number of tracks that pass the cuts
981 // loop over esd tracks
982 for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
983 AliESDtrack* track = esd->GetTrack(iTrack);
984 if (AcceptTrack(track))
991 //____________________________________________________________________
992 void AliESDtrackCuts::DefineHistograms(Int_t color) {
994 // diagnostics histograms are defined
999 Bool_t oldStatus = TH1::AddDirectoryStatus();
1000 TH1::AddDirectory(kFALSE);
1002 //###################################################################################
1003 // defining histograms
1005 fhCutStatistics = new TH1F("cut_statistics","cut statistics",kNCuts+4,-0.5,kNCuts+3.5);
1007 fhCutStatistics->GetXaxis()->SetBinLabel(1,"n tracks");
1008 fhCutStatistics->GetXaxis()->SetBinLabel(2,"n cut tracks");
1010 fhCutCorrelation = new TH2F("cut_correlation","cut correlation",kNCuts,-0.5,kNCuts-0.5,kNCuts,-0.5,kNCuts-0.5);;
1012 for (Int_t i=0; i<kNCuts; i++) {
1013 fhCutStatistics->GetXaxis()->SetBinLabel(i+4,fgkCutNames[i]);
1014 fhCutCorrelation->GetXaxis()->SetBinLabel(i+1,fgkCutNames[i]);
1015 fhCutCorrelation->GetYaxis()->SetBinLabel(i+1,fgkCutNames[i]);
1018 fhCutStatistics ->SetLineColor(color);
1019 fhCutCorrelation ->SetLineColor(color);
1020 fhCutStatistics ->SetLineWidth(2);
1021 fhCutCorrelation ->SetLineWidth(2);
1023 for (Int_t i=0; i<2; i++) {
1024 fhNClustersITS[i] = new TH1F("nClustersITS" ,"",8,-0.5,7.5);
1025 fhNClustersTPC[i] = new TH1F("nClustersTPC" ,"",165,-0.5,164.5);
1026 fhChi2PerClusterITS[i] = new TH1F("chi2PerClusterITS","",500,0,10);
1027 fhChi2PerClusterTPC[i] = new TH1F("chi2PerClusterTPC","",500,0,10);
1029 fhC11[i] = new TH1F("covMatrixDiagonal11","",2000,0,20);
1030 fhC22[i] = new TH1F("covMatrixDiagonal22","",2000,0,20);
1031 fhC33[i] = new TH1F("covMatrixDiagonal33","",1000,0,0.1);
1032 fhC44[i] = new TH1F("covMatrixDiagonal44","",1000,0,0.1);
1033 fhC55[i] = new TH1F("covMatrixDiagonal55","",1000,0,5);
1035 fhRel1PtUncertainty[i] = new TH1F("rel1PtUncertainty","",1000,0,5);
1037 fhDXY[i] = new TH1F("dXY" ,"",500,-10,10);
1038 fhDZ[i] = new TH1F("dZ" ,"",500,-10,10);
1039 fhDXYDZ[i] = new TH1F("dXYDZ" ,"",500,0,10);
1040 fhDXYvsDZ[i] = new TH2F("dXYvsDZ","",200,-10,10,200,-10,10);
1042 fhDXYNormalized[i] = new TH1F("dXYNormalized" ,"",500,-10,10);
1043 fhDZNormalized[i] = new TH1F("dZNormalized" ,"",500,-10,10);
1044 fhDXYvsDZNormalized[i] = new TH2F("dXYvsDZNormalized","",200,-10,10,200,-10,10);
1046 fhNSigmaToVertex[i] = new TH1F("nSigmaToVertex","",500,0,10);
1048 fhPt[i] = new TH1F("pt" ,"p_{T} distribution;p_{T} (GeV/c)", 800, 0.0, 10.0);
1049 fhEta[i] = new TH1F("eta" ,"#eta distribution;#eta",40,-2.0,2.0);
1051 fhNClustersITS[i]->SetTitle("n ITS clusters");
1052 fhNClustersTPC[i]->SetTitle("n TPC clusters");
1053 fhChi2PerClusterITS[i]->SetTitle("#Chi^{2} per ITS cluster");
1054 fhChi2PerClusterTPC[i]->SetTitle("#Chi^{2} per TPC cluster");
1056 fhC11[i]->SetTitle("cov 11 : #sigma_{y}^{2} [cm^{2}]");
1057 fhC22[i]->SetTitle("cov 22 : #sigma_{z}^{2} [cm^{2}]");
1058 fhC33[i]->SetTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
1059 fhC44[i]->SetTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
1060 fhC55[i]->SetTitle("cov 55 : #sigma_{1/p_{T}}^{2} [(c/GeV)^2]");
1062 fhRel1PtUncertainty[i]->SetTitle("rel. uncertainty of 1/p_{T}");
1064 fhDXY[i]->SetXTitle("transverse impact parameter (cm)");
1065 fhDZ[i]->SetXTitle("longitudinal impact parameter (cm)");
1066 fhDXYDZ[i]->SetTitle("absolute impact parameter;sqrt(dXY**2 + dZ**2) (cm)");
1067 fhDXYvsDZ[i]->SetXTitle("longitudinal impact parameter (cm)");
1068 fhDXYvsDZ[i]->SetYTitle("transverse impact parameter (cm)");
1070 fhDXYNormalized[i]->SetTitle("normalized trans impact par (n#sigma)");
1071 fhDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)");
1072 fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)");
1073 fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par (n#sigma)");
1074 fhNSigmaToVertex[i]->SetTitle("n #sigma to vertex");
1076 fhNClustersITS[i]->SetLineColor(color); fhNClustersITS[i]->SetLineWidth(2);
1077 fhNClustersTPC[i]->SetLineColor(color); fhNClustersTPC[i]->SetLineWidth(2);
1078 fhChi2PerClusterITS[i]->SetLineColor(color); fhChi2PerClusterITS[i]->SetLineWidth(2);
1079 fhChi2PerClusterTPC[i]->SetLineColor(color); fhChi2PerClusterTPC[i]->SetLineWidth(2);
1081 fhC11[i]->SetLineColor(color); fhC11[i]->SetLineWidth(2);
1082 fhC22[i]->SetLineColor(color); fhC22[i]->SetLineWidth(2);
1083 fhC33[i]->SetLineColor(color); fhC33[i]->SetLineWidth(2);
1084 fhC44[i]->SetLineColor(color); fhC44[i]->SetLineWidth(2);
1085 fhC55[i]->SetLineColor(color); fhC55[i]->SetLineWidth(2);
1087 fhRel1PtUncertainty[i]->SetLineColor(color); fhRel1PtUncertainty[i]->SetLineWidth(2);
1089 fhDXY[i]->SetLineColor(color); fhDXY[i]->SetLineWidth(2);
1090 fhDZ[i]->SetLineColor(color); fhDZ[i]->SetLineWidth(2);
1091 fhDXYDZ[i]->SetLineColor(color); fhDXYDZ[i]->SetLineWidth(2);
1093 fhDXYNormalized[i]->SetLineColor(color); fhDXYNormalized[i]->SetLineWidth(2);
1094 fhDZNormalized[i]->SetLineColor(color); fhDZNormalized[i]->SetLineWidth(2);
1095 fhNSigmaToVertex[i]->SetLineColor(color); fhNSigmaToVertex[i]->SetLineWidth(2);
1098 // The number of sigmas to the vertex is per definition gaussian
1099 ffDTheoretical = new TF1("nSigmaToVertexTheoretical","([0]/2.506628274)*exp(-(x**2)/2)",0,50);
1100 ffDTheoretical->SetParameter(0,1);
1102 TH1::AddDirectory(oldStatus);
1105 //____________________________________________________________________
1106 Bool_t AliESDtrackCuts::LoadHistograms(const Char_t* dir)
1109 // loads the histograms from a file
1110 // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
1116 if (!gDirectory->cd(dir))
1119 ffDTheoretical = dynamic_cast<TF1*> (gDirectory->Get("nSigmaToVertexTheory"));
1121 fhCutStatistics = dynamic_cast<TH1F*> (gDirectory->Get("cut_statistics"));
1122 fhCutCorrelation = dynamic_cast<TH2F*> (gDirectory->Get("cut_correlation"));
1124 for (Int_t i=0; i<2; i++) {
1127 gDirectory->cd("before_cuts");
1130 gDirectory->cd("after_cuts");
1132 fhNClustersITS[i] = dynamic_cast<TH1F*> (gDirectory->Get("nClustersITS" ));
1133 fhNClustersTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("nClustersTPC" ));
1134 fhChi2PerClusterITS[i] = dynamic_cast<TH1F*> (gDirectory->Get("chi2PerClusterITS"));
1135 fhChi2PerClusterTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("chi2PerClusterTPC"));
1137 fhC11[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal11"));
1138 fhC22[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal22"));
1139 fhC33[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal33"));
1140 fhC44[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal44"));
1141 fhC55[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal55"));
1143 fhRel1PtUncertainty[i] = dynamic_cast<TH1F*> (gDirectory->Get("rel1PtUncertainty"));
1145 fhDXY[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXY" ));
1146 fhDZ[i] = dynamic_cast<TH1F*> (gDirectory->Get("dZ" ));
1147 fhDXYDZ[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXYDZ"));
1148 fhDXYvsDZ[i] = dynamic_cast<TH2F*> (gDirectory->Get("dXYvsDZ"));
1150 fhDXYNormalized[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXYNormalized" ));
1151 fhDZNormalized[i] = dynamic_cast<TH1F*> (gDirectory->Get("dZNormalized" ));
1152 fhDXYvsDZNormalized[i] = dynamic_cast<TH2F*> (gDirectory->Get("dXYvsDZNormalized"));
1153 fhNSigmaToVertex[i] = dynamic_cast<TH1F*> (gDirectory->Get("nSigmaToVertex"));
1155 fhPt[i] = dynamic_cast<TH1F*> (gDirectory->Get("pt"));
1156 fhEta[i] = dynamic_cast<TH1F*> (gDirectory->Get("eta"));
1158 gDirectory->cd("../");
1161 gDirectory->cd("..");
1166 //____________________________________________________________________
1167 void AliESDtrackCuts::SaveHistograms(const Char_t* dir) {
1169 // saves the histograms in a directory (dir)
1172 if (!fHistogramsOn) {
1173 AliDebug(0, "Histograms not on - cannot save histograms!!!");
1180 gDirectory->mkdir(dir);
1181 gDirectory->cd(dir);
1183 gDirectory->mkdir("before_cuts");
1184 gDirectory->mkdir("after_cuts");
1186 // a factor of 2 is needed since n sigma is positive
1187 ffDTheoretical->SetParameter(0,2*fhNSigmaToVertex[0]->Integral("width"));
1188 ffDTheoretical->Write("nSigmaToVertexTheory");
1190 fhCutStatistics->Write();
1191 fhCutCorrelation->Write();
1193 for (Int_t i=0; i<2; i++) {
1195 gDirectory->cd("before_cuts");
1197 gDirectory->cd("after_cuts");
1199 fhNClustersITS[i] ->Write();
1200 fhNClustersTPC[i] ->Write();
1201 fhChi2PerClusterITS[i] ->Write();
1202 fhChi2PerClusterTPC[i] ->Write();
1210 fhRel1PtUncertainty[i] ->Write();
1214 fhDXYDZ[i] ->Write();
1215 fhDXYvsDZ[i] ->Write();
1217 fhDXYNormalized[i] ->Write();
1218 fhDZNormalized[i] ->Write();
1219 fhDXYvsDZNormalized[i] ->Write();
1220 fhNSigmaToVertex[i] ->Write();
1225 gDirectory->cd("../");
1228 gDirectory->cd("../");
1231 //____________________________________________________________________
1232 void AliESDtrackCuts::DrawHistograms()
1234 // draws some histograms
1236 TCanvas* canvas1 = new TCanvas(Form("%s_1", GetName()), "Track Quality Results1", 800, 800);
1237 canvas1->Divide(2, 2);
1240 fhNClustersTPC[0]->SetStats(kFALSE);
1241 fhNClustersTPC[0]->Draw();
1244 fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1245 fhChi2PerClusterTPC[0]->Draw();
1248 fhNSigmaToVertex[0]->SetStats(kFALSE);
1249 fhNSigmaToVertex[0]->GetXaxis()->SetRangeUser(0, 10);
1250 fhNSigmaToVertex[0]->Draw();
1252 canvas1->SaveAs(Form("%s_%s.gif", GetName(), canvas1->GetName()));
1254 TCanvas* canvas2 = new TCanvas(Form("%s_2", GetName()), "Track Quality Results2", 1200, 800);
1255 canvas2->Divide(3, 2);
1258 fhC11[0]->SetStats(kFALSE);
1263 fhC22[0]->SetStats(kFALSE);
1268 fhC33[0]->SetStats(kFALSE);
1273 fhC44[0]->SetStats(kFALSE);
1278 fhC55[0]->SetStats(kFALSE);
1283 fhRel1PtUncertainty[0]->SetStats(kFALSE);
1285 fhRel1PtUncertainty[0]->Draw();
1287 canvas2->SaveAs(Form("%s_%s.gif", GetName(), canvas2->GetName()));
1289 TCanvas* canvas3 = new TCanvas(Form("%s_3", GetName()), "Track Quality Results3", 1200, 800);
1290 canvas3->Divide(3, 2);
1293 fhDXY[0]->SetStats(kFALSE);
1298 fhDZ[0]->SetStats(kFALSE);
1303 fhDXYvsDZ[0]->SetStats(kFALSE);
1305 gPad->SetRightMargin(0.15);
1306 fhDXYvsDZ[0]->Draw("COLZ");
1309 fhDXYNormalized[0]->SetStats(kFALSE);
1311 fhDXYNormalized[0]->Draw();
1314 fhDZNormalized[0]->SetStats(kFALSE);
1316 fhDZNormalized[0]->Draw();
1319 fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1321 gPad->SetRightMargin(0.15);
1322 fhDXYvsDZNormalized[0]->Draw("COLZ");
1324 canvas3->SaveAs(Form("%s_%s.gif", GetName(), canvas3->GetName()));
1326 TCanvas* canvas4 = new TCanvas(Form("%s_4", GetName()), "Track Quality Results4", 800, 500);
1327 canvas4->Divide(2, 1);
1330 fhCutStatistics->SetStats(kFALSE);
1331 fhCutStatistics->LabelsOption("v");
1332 gPad->SetBottomMargin(0.3);
1333 fhCutStatistics->Draw();
1336 fhCutCorrelation->SetStats(kFALSE);
1337 fhCutCorrelation->LabelsOption("v");
1338 gPad->SetBottomMargin(0.3);
1339 gPad->SetLeftMargin(0.3);
1340 fhCutCorrelation->Draw("COLZ");
1342 canvas4->SaveAs(Form("%s_%s.gif", GetName(), canvas4->GetName()));
1345 fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1346 fhDXYvsDZNormalized[0]->DrawCopy("COLZ");
1349 fhNClustersTPC[0]->SetStats(kFALSE);
1350 fhNClustersTPC[0]->DrawCopy();
1353 fhChi2PerClusterITS[0]->SetStats(kFALSE);
1354 fhChi2PerClusterITS[0]->DrawCopy();
1355 fhChi2PerClusterITS[1]->SetLineColor(2);
1356 fhChi2PerClusterITS[1]->DrawCopy("SAME");
1359 fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1360 fhChi2PerClusterTPC[0]->DrawCopy();
1361 fhChi2PerClusterTPC[1]->SetLineColor(2);
1362 fhChi2PerClusterTPC[1]->DrawCopy("SAME");*/