X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;ds=inline;f=ANALYSIS%2FAliESDtrackCuts.cxx;h=a1ff297551bda05c0fcf2e4af55836e8f9605cf8;hb=2d28db9f9e60d6450bd8eb141987b618841e3058;hp=c9455445609ad732edf1e616864ee42c19069d14;hpb=0f712a2e8acded99abe9a6c201e38d95a0f480b0;p=u%2Fmrichter%2FAliRoot.git diff --git a/ANALYSIS/AliESDtrackCuts.cxx b/ANALYSIS/AliESDtrackCuts.cxx index c9455445609..a1ff297551b 100644 --- a/ANALYSIS/AliESDtrackCuts.cxx +++ b/ANALYSIS/AliESDtrackCuts.cxx @@ -18,12 +18,15 @@ #include "AliESDtrackCuts.h" #include +#include #include #include #include #include #include +#include +#include //____________________________________________________________________ ClassImp(AliESDtrackCuts) @@ -31,11 +34,12 @@ ClassImp(AliESDtrackCuts) // Cut names const Char_t* AliESDtrackCuts::fgkCutNames[kNCuts] = { "require TPC refit", + "require TPC standalone", "require ITS refit", "n clusters TPC", "n clusters ITS", - "#Chi^{2}/clusters TPC", - "#Chi^{2}/clusters ITS", + "#Chi^{2}/cluster TPC", + "#Chi^{2}/cluster ITS", "cov 11", "cov 22", "cov 33", @@ -49,10 +53,20 @@ const Char_t* AliESDtrackCuts::fgkCutNames[kNCuts] = { "p_{x}", "p_{y}", "p_{z}", - "y", "eta", - "trk-to-vtx dca absolute", - "trk-to-vtx dca xy absolute" + "y", + "trk-to-vtx max dca 2D absolute", + "trk-to-vtx max dca xy absolute", + "trk-to-vtx max dca z absolute", + "trk-to-vtx min dca 2D absolute", + "trk-to-vtx min dca xy absolute", + "trk-to-vtx min dca z absolute", + "SPD cluster requirement", + "SDD cluster requirement", + "SSD cluster requirement", + "require ITS stand-alone", + "rel 1/pt uncertainty", + "require ITS Pid" }; //____________________________________________________________________ @@ -66,13 +80,31 @@ AliESDtrackCuts::AliESDtrackCuts(const Char_t* name, const Char_t* title) : AliA fCutMaxC33(0), fCutMaxC44(0), fCutMaxC55(0), + fCutMaxRel1PtUncertainty(0), fCutAcceptKinkDaughters(0), + fCutAcceptSharedTPCClusters(0), + fCutMaxFractionSharedTPCClusters(0), fCutRequireTPCRefit(0), - fCutRequireITSRefit(0), + fCutRequireTPCStandAlone(0), + fCutRequireITSRefit(0), + fCutRequireITSPid(0), + fCutRequireITSStandAlone(0), + fCutRequireITSpureSA(0), fCutNsigmaToVertex(0), fCutSigmaToVertexRequired(0), - fCutDCAToVertex(0), - fCutDCAToVertexXY(0), + fCutMaxDCAToVertexXY(0), + fCutMaxDCAToVertexZ(0), + fCutMinDCAToVertexXY(0), + fCutMinDCAToVertexZ(0), + fCutMaxDCAToVertexXYPtDep(""), + fCutMaxDCAToVertexZPtDep(""), + fCutMinDCAToVertexXYPtDep(""), + fCutMinDCAToVertexZPtDep(""), + f1CutMaxDCAToVertexXYPtDep(0x0), + f1CutMaxDCAToVertexZPtDep(0x0), + f1CutMinDCAToVertexXYPtDep(0x0), + f1CutMinDCAToVertexZPtDep(0x0), + fCutDCAToVertex2D(0), fPMin(0), fPMax(0), fPtMin(0), @@ -104,14 +136,21 @@ AliESDtrackCuts::AliESDtrackCuts(const Char_t* name, const Char_t* title) : AliA SetMinNClustersITS(); SetMaxChi2PerClusterTPC(); SetMaxChi2PerClusterITS(); - SetMaxCovDiagonalElements(); + SetMaxCovDiagonalElements(); + SetMaxRel1PtUncertainty(); SetRequireTPCRefit(); + SetRequireTPCStandAlone(); SetRequireITSRefit(); - SetAcceptKingDaughters(); - SetMinNsigmaToVertex(); - SetRequireSigmaToVertex(); - SetDCAToVertex(); - SetDCAToVertexXY(); + SetRequireITSPid(kFALSE); + SetRequireITSStandAlone(kFALSE); + SetRequireITSPureStandAlone(kFALSE); + SetAcceptKinkDaughters(); + SetMaxNsigmaToVertex(); + SetMaxDCAToVertexXY(); + SetMaxDCAToVertexZ(); + SetDCAToVertex2D(); + SetMinDCAToVertexXY(); + SetMinDCAToVertexZ(); SetPRange(); SetPtRange(); SetPxRange(); @@ -119,6 +158,9 @@ AliESDtrackCuts::AliESDtrackCuts(const Char_t* name, const Char_t* title) : AliA SetPzRange(); SetEtaRange(); SetRapRange(); + SetClusterRequirementITS(kSPD); + SetClusterRequirementITS(kSDD); + SetClusterRequirementITS(kSSD); SetHistogramsOn(); } @@ -134,13 +176,31 @@ AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : AliAnalysisCuts(c), fCutMaxC33(0), fCutMaxC44(0), fCutMaxC55(0), + fCutMaxRel1PtUncertainty(0), fCutAcceptKinkDaughters(0), + fCutAcceptSharedTPCClusters(0), + fCutMaxFractionSharedTPCClusters(0), fCutRequireTPCRefit(0), + fCutRequireTPCStandAlone(0), fCutRequireITSRefit(0), + fCutRequireITSPid(0), + fCutRequireITSStandAlone(0), + fCutRequireITSpureSA(0), fCutNsigmaToVertex(0), fCutSigmaToVertexRequired(0), - fCutDCAToVertex(0), - fCutDCAToVertexXY(0), + fCutMaxDCAToVertexXY(0), + fCutMaxDCAToVertexZ(0), + fCutMinDCAToVertexXY(0), + fCutMinDCAToVertexZ(0), + fCutMaxDCAToVertexXYPtDep(""), + fCutMaxDCAToVertexZPtDep(""), + fCutMinDCAToVertexXYPtDep(""), + fCutMinDCAToVertexZPtDep(""), + f1CutMaxDCAToVertexXYPtDep(0x0), + f1CutMaxDCAToVertexZPtDep(0x0), + f1CutMinDCAToVertexXYPtDep(0x0), + f1CutMinDCAToVertexZPtDep(0x0), + fCutDCAToVertex2D(0), fPMin(0), fPMax(0), fPtMin(0), @@ -192,7 +252,10 @@ AliESDtrackCuts::~AliESDtrackCuts() if (fhC44[i]) delete fhC44[i]; if (fhC55[i]) - delete fhC55[i]; + delete fhC55[i]; + + if (fhRel1PtUncertainty[i]) + delete fhRel1PtUncertainty[i]; if (fhDXY[i]) delete fhDXY[i]; @@ -217,6 +280,16 @@ AliESDtrackCuts::~AliESDtrackCuts() delete fhEta[i]; } + if(f1CutMaxDCAToVertexXYPtDep)delete f1CutMaxDCAToVertexXYPtDep; + f1CutMaxDCAToVertexXYPtDep = 0; + if( f1CutMaxDCAToVertexZPtDep) delete f1CutMaxDCAToVertexZPtDep; + f1CutMaxDCAToVertexZPtDep = 0; + if( f1CutMinDCAToVertexXYPtDep)delete f1CutMinDCAToVertexXYPtDep; + f1CutMinDCAToVertexXYPtDep = 0; + if(f1CutMinDCAToVertexZPtDep)delete f1CutMinDCAToVertexZPtDep; + f1CutMinDCAToVertexZPtDep = 0; + + if (ffDTheoretical) delete ffDTheoretical; @@ -237,22 +310,52 @@ void AliESDtrackCuts::Init() fCutMaxChi2PerClusterTPC = 0; fCutMaxChi2PerClusterITS = 0; + + for (Int_t i = 0; i < 3; i++) + fCutClusterRequirementITS[i] = kOff; fCutMaxC11 = 0; fCutMaxC22 = 0; fCutMaxC33 = 0; fCutMaxC44 = 0; fCutMaxC55 = 0; + + fCutMaxRel1PtUncertainty = 0; fCutAcceptKinkDaughters = 0; + fCutAcceptSharedTPCClusters = 0; + fCutMaxFractionSharedTPCClusters = 0; fCutRequireTPCRefit = 0; + fCutRequireTPCStandAlone = 0; fCutRequireITSRefit = 0; + fCutRequireITSPid = 0; + fCutRequireITSStandAlone = 0; + fCutRequireITSpureSA = 0; fCutNsigmaToVertex = 0; fCutSigmaToVertexRequired = 0; - fCutDCAToVertex = 0; - fCutDCAToVertexXY = 0; + fCutMaxDCAToVertexXY = 0; + fCutMaxDCAToVertexZ = 0; + fCutDCAToVertex2D = 0; + fCutMinDCAToVertexXY = 0; + fCutMinDCAToVertexZ = 0; + fCutMaxDCAToVertexXYPtDep = ""; + fCutMaxDCAToVertexZPtDep = ""; + fCutMinDCAToVertexXYPtDep = ""; + fCutMinDCAToVertexZPtDep = ""; + + if(f1CutMaxDCAToVertexXYPtDep)delete f1CutMaxDCAToVertexXYPtDep; + f1CutMaxDCAToVertexXYPtDep = 0; + if( f1CutMaxDCAToVertexXYPtDep) delete f1CutMaxDCAToVertexXYPtDep; + f1CutMaxDCAToVertexXYPtDep = 0; + if( f1CutMaxDCAToVertexZPtDep) delete f1CutMaxDCAToVertexZPtDep; + f1CutMaxDCAToVertexZPtDep = 0; + if( f1CutMinDCAToVertexXYPtDep)delete f1CutMinDCAToVertexXYPtDep; + f1CutMinDCAToVertexXYPtDep = 0; + if(f1CutMinDCAToVertexZPtDep)delete f1CutMinDCAToVertexZPtDep; + f1CutMinDCAToVertexZPtDep = 0; + fPMin = 0; fPMax = 0; fPtMin = 0; @@ -284,6 +387,8 @@ void AliESDtrackCuts::Init() fhC44[i] = 0; fhC55[i] = 0; + fhRel1PtUncertainty[i] = 0; + fhDXY[i] = 0; fhDZ[i] = 0; fhDXYDZ[i] = 0; @@ -331,20 +436,46 @@ void AliESDtrackCuts::Copy(TObject &c) const target.fCutMaxChi2PerClusterTPC = fCutMaxChi2PerClusterTPC; target.fCutMaxChi2PerClusterITS = fCutMaxChi2PerClusterITS; + for (Int_t i = 0; i < 3; i++) + target.fCutClusterRequirementITS[i] = fCutClusterRequirementITS[i]; + target.fCutMaxC11 = fCutMaxC11; target.fCutMaxC22 = fCutMaxC22; target.fCutMaxC33 = fCutMaxC33; target.fCutMaxC44 = fCutMaxC44; target.fCutMaxC55 = fCutMaxC55; + target.fCutMaxRel1PtUncertainty = fCutMaxRel1PtUncertainty; + target.fCutAcceptKinkDaughters = fCutAcceptKinkDaughters; + target.fCutAcceptSharedTPCClusters = fCutAcceptSharedTPCClusters; + target.fCutMaxFractionSharedTPCClusters = fCutMaxFractionSharedTPCClusters; target.fCutRequireTPCRefit = fCutRequireTPCRefit; + target.fCutRequireTPCStandAlone = fCutRequireTPCStandAlone; target.fCutRequireITSRefit = fCutRequireITSRefit; + target.fCutRequireITSPid = fCutRequireITSPid; + target.fCutRequireITSStandAlone = fCutRequireITSStandAlone; + target.fCutRequireITSpureSA = fCutRequireITSpureSA; target.fCutNsigmaToVertex = fCutNsigmaToVertex; target.fCutSigmaToVertexRequired = fCutSigmaToVertexRequired; - target.fCutDCAToVertex = fCutDCAToVertex; - target.fCutDCAToVertexXY = fCutDCAToVertexXY; + target.fCutMaxDCAToVertexXY = fCutMaxDCAToVertexXY; + target.fCutMaxDCAToVertexZ = fCutMaxDCAToVertexZ; + target.fCutDCAToVertex2D = fCutDCAToVertex2D; + target.fCutMinDCAToVertexXY = fCutMinDCAToVertexXY; + target.fCutMinDCAToVertexZ = fCutMinDCAToVertexZ; + + target.fCutMaxDCAToVertexXYPtDep = fCutMaxDCAToVertexXYPtDep; + target.SetMaxDCAToVertexXYPtDep(fCutMaxDCAToVertexXYPtDep.Data()); + + target.fCutMaxDCAToVertexZPtDep = fCutMaxDCAToVertexZPtDep; + target.SetMaxDCAToVertexZPtDep(fCutMaxDCAToVertexZPtDep.Data()); + + target.fCutMinDCAToVertexXYPtDep = fCutMinDCAToVertexXYPtDep; + target.SetMinDCAToVertexXYPtDep(fCutMinDCAToVertexXYPtDep.Data()); + + target.fCutMinDCAToVertexZPtDep = fCutMinDCAToVertexZPtDep; + target.SetMinDCAToVertexZPtDep(fCutMinDCAToVertexZPtDep.Data()); target.fPMin = fPMin; target.fPMax = fPMax; @@ -377,6 +508,8 @@ void AliESDtrackCuts::Copy(TObject &c) const if (fhC44[i]) target.fhC44[i] = (TH1F*) fhC44[i]->Clone(); if (fhC55[i]) target.fhC55[i] = (TH1F*) fhC55[i]->Clone(); + if (fhRel1PtUncertainty[i]) target.fhRel1PtUncertainty[i] = (TH1F*) fhRel1PtUncertainty[i]->Clone(); + if (fhDXY[i]) target.fhDXY[i] = (TH1F*) fhDXY[i]->Clone(); if (fhDZ[i]) target.fhDZ[i] = (TH1F*) fhDZ[i]->Clone(); if (fhDXYDZ[i]) target.fhDXYDZ[i] = (TH1F*) fhDXYDZ[i]->Clone(); @@ -434,7 +567,9 @@ Long64_t AliESDtrackCuts::Merge(TCollection* list) { fhC22[i] ->Add(entry->fhC22[i] ); fhC33[i] ->Add(entry->fhC33[i] ); fhC44[i] ->Add(entry->fhC44[i] ); - fhC55[i] ->Add(entry->fhC55[i] ); + fhC55[i] ->Add(entry->fhC55[i] ); + + fhRel1PtUncertainty[i] ->Add(entry->fhRel1PtUncertainty[i]); fhDXY[i] ->Add(entry->fhDXY[i] ); fhDZ[i] ->Add(entry->fhDZ[i] ); @@ -458,6 +593,160 @@ Long64_t AliESDtrackCuts::Merge(TCollection* list) { return count+1; } +//____________________________________________________________________ +AliESDtrackCuts* AliESDtrackCuts::GetStandardTPCOnlyTrackCuts() +{ + // creates an AliESDtrackCuts object and fills it with standard (pre data-taking) values for TPC-only cuts + + Printf("AliESDtrackCuts::GetStandardTPCOnlyTrackCuts: Creating track cuts for TPC-only."); + + AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts; + + esdTrackCuts->SetMinNClustersTPC(50); + esdTrackCuts->SetMaxChi2PerClusterTPC(4); + esdTrackCuts->SetAcceptKinkDaughters(kFALSE); + + esdTrackCuts->SetMaxDCAToVertexZ(3.2); + esdTrackCuts->SetMaxDCAToVertexXY(2.4); + esdTrackCuts->SetDCAToVertex2D(kTRUE); + + return esdTrackCuts; +} + +//____________________________________________________________________ +AliESDtrackCuts* AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(Bool_t selPrimaries) +{ + // creates an AliESDtrackCuts object and fills it with standard values for ITS-TPC cuts for pp 2009 data + + Printf("AliESDtrackCuts::GetStandardITSTPCTrackCuts: Creating track cuts for ITS+TPC."); + + AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts; + + // TPC + esdTrackCuts->SetRequireTPCStandAlone(kTRUE); // to get chi2 and ncls of kTPCin + esdTrackCuts->SetMinNClustersTPC(70); + esdTrackCuts->SetMaxChi2PerClusterTPC(4); + esdTrackCuts->SetAcceptKinkDaughters(kFALSE); + esdTrackCuts->SetRequireTPCRefit(kTRUE); + // ITS + esdTrackCuts->SetRequireITSRefit(kTRUE); + esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, + AliESDtrackCuts::kAny); + if(selPrimaries) { + // 7*(0.0050+0.0060/pt^0.9) + esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9"); + } + esdTrackCuts->SetMaxDCAToVertexZ(1.e6); + esdTrackCuts->SetDCAToVertex2D(kFALSE); + esdTrackCuts->SetRequireSigmaToVertex(kFALSE); + //esdTrackCuts->SetEtaRange(-0.8,+0.8); + + return esdTrackCuts; +} + +//____________________________________________________________________ +AliESDtrackCuts* AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(Bool_t selPrimaries) +{ + // creates an AliESDtrackCuts object and fills it with standard values for ITS-TPC cuts for pp 2010 data + + Printf("AliESDtrackCuts::GetStandardITSTPCTrackCuts: Creating track cuts for ITS+TPC."); + + AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts; + + // TPC + esdTrackCuts->SetRequireTPCStandAlone(kTRUE); // to get chi2 and ncls of kTPCin + esdTrackCuts->SetMinNClustersTPC(70); + esdTrackCuts->SetMaxChi2PerClusterTPC(4); + esdTrackCuts->SetAcceptKinkDaughters(kFALSE); + esdTrackCuts->SetRequireTPCRefit(kTRUE); + // ITS + esdTrackCuts->SetRequireITSRefit(kTRUE); + esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, + AliESDtrackCuts::kAny); + if(selPrimaries) { + // 7*(0.0026+0.0050/pt^1.01) + esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01"); + } + esdTrackCuts->SetMaxDCAToVertexZ(2); + esdTrackCuts->SetDCAToVertex2D(kFALSE); + esdTrackCuts->SetRequireSigmaToVertex(kFALSE); + //esdTrackCuts->SetEtaRange(-0.8,+0.8); + + return esdTrackCuts; +} + +//____________________________________________________________________ +AliESDtrackCuts* AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(Bool_t selPrimaries, Bool_t useForPid) +{ + // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks + + AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts; + esdTrackCuts->SetRequireITSPureStandAlone(kTRUE); + esdTrackCuts->SetRequireITSRefit(kTRUE); + esdTrackCuts->SetMinNClustersITS(4); + esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, + AliESDtrackCuts::kAny); + esdTrackCuts->SetMaxChi2PerClusterITS(1.); + + if(selPrimaries) { + // 7*(0.0085+0.0026/pt^1.55) + esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55"); + } + if(useForPid){ + esdTrackCuts->SetRequireITSPid(kTRUE); + } + return esdTrackCuts; +} + +//____________________________________________________________________ +AliESDtrackCuts* AliESDtrackCuts::GetStandardITSSATrackCuts2009(Bool_t selPrimaries, Bool_t useForPid) +{ + // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks + + AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts; + esdTrackCuts->SetRequireITSStandAlone(kTRUE); + esdTrackCuts->SetRequireITSPureStandAlone(kFALSE); + esdTrackCuts->SetRequireITSRefit(kTRUE); + esdTrackCuts->SetMinNClustersITS(4); + esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, + AliESDtrackCuts::kAny); + esdTrackCuts->SetMaxChi2PerClusterITS(1.); + + if(selPrimaries) { + // 7*(0.0085+0.0026/pt^1.55) + esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55"); + } + if(useForPid){ + esdTrackCuts->SetRequireITSPid(kTRUE); + } + return esdTrackCuts; +} + + +//____________________________________________________________________ +Int_t AliESDtrackCuts::GetReferenceMultiplicity(AliESDEvent* esd, Bool_t tpcOnly) +{ + // Gets reference multiplicity following the standard cuts and a defined fiducial volume + // tpcOnly = kTRUE -> consider TPC-only tracks + // = kFALSE -> consider global tracks + + if (!tpcOnly) + { + Printf("AliESDtrackCuts::GetReferenceMultiplicity: Not implemented for global tracks!"); + return -1; + } + + AliESDtrackCuts* esdTrackCuts = GetStandardTPCOnlyTrackCuts(); + esdTrackCuts->SetEtaRange(-0.8, 0.8); + esdTrackCuts->SetPtRange(0.15); + + Int_t nTracks = esdTrackCuts->CountAcceptedTracks(esd); + + delete esdTrackCuts; + esdTrackCuts = 0; + + return nTracks; +} //____________________________________________________________________ Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack) @@ -484,7 +773,7 @@ Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack) // -> Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma) // -> 1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma) // - // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-x**2)/2) + // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-d**2)/2) // Can this be expressed in a different way? if (bRes[0] == 0 || bRes[1] ==0) @@ -523,8 +812,8 @@ void AliESDtrackCuts::EnableNeededBranches(TTree* tree) } //____________________________________________________________________ -Bool_t -AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) { +Bool_t AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) +{ // // figure out if the tracks survives all the track cuts defined // @@ -549,19 +838,34 @@ AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) { // fTracks.fP //GetMass // fTracks.fKinkIndexes - UInt_t status = esdTrack->GetStatus(); // getting quality parameters from the ESD track Int_t nClustersITS = esdTrack->GetITSclusters(0); - Int_t nClustersTPC = esdTrack->GetTPCclusters(0); + Int_t nClustersTPC = -1; + if(fCutRequireTPCStandAlone) { + nClustersTPC = esdTrack->GetTPCNclsIter1(); + } + else { + nClustersTPC = esdTrack->GetTPCclusters(0); + } + + Int_t nClustersTPCShared = esdTrack->GetTPCnclsS(); + Float_t fracClustersTPCShared = -1.; Float_t chi2PerClusterITS = -1; Float_t chi2PerClusterTPC = -1; if (nClustersITS!=0) chi2PerClusterITS = esdTrack->GetITSchi2()/Float_t(nClustersITS); - if (nClustersTPC!=0) - chi2PerClusterTPC = esdTrack->GetTPCchi2()/Float_t(nClustersTPC); + if (nClustersTPC!=0) { + if(fCutRequireTPCStandAlone) { + chi2PerClusterTPC = esdTrack->GetTPCchi2Iter1()/Float_t(nClustersTPC); + } else { + chi2PerClusterTPC = esdTrack->GetTPCchi2()/Float_t(nClustersTPC); + } + fracClustersTPCShared = Float_t(nClustersTPCShared)/Float_t(nClustersTPC); + } + Double_t extCov[15]; esdTrack->GetExternalCovariance(extCov); @@ -575,10 +879,24 @@ AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) { AliDebug(1, "Estimated b resolution lower or equal zero!"); bCov[0]=0; bCov[2]=0; } - Float_t dcaToVertex = TMath::Sqrt(b[0]*b[0] + b[1]*b[1]); - + + + // set pt-dependent DCA cuts, if requested + SetPtDepDCACuts(esdTrack->Pt()); + + Float_t dcaToVertexXY = b[0]; + Float_t dcaToVertexZ = b[1]; + + Float_t dcaToVertex = -1; + if (fCutDCAToVertex2D) + { + dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY/fCutMaxDCAToVertexXY/fCutMaxDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMaxDCAToVertexZ/fCutMaxDCAToVertexZ); + } + else + dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY + dcaToVertexZ*dcaToVertexZ); + // getting the kinematic variables of the track // (assuming the mass is known) Double_t p[3]; @@ -588,7 +906,6 @@ AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) { Float_t pt = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2)); Float_t energy = TMath::Sqrt(TMath::Power(esdTrack->GetMass(),2) + TMath::Power(momentum,2)); - //y-eta related calculations Float_t eta = -100.; Float_t y = -100.; @@ -596,7 +913,13 @@ AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) { eta = 0.5*TMath::Log((momentum + p[2])/(momentum - p[2])); if((energy != TMath::Abs(p[2]))&&(momentum != 0)) y = 0.5*TMath::Log((energy + p[2])/(energy - p[2])); - + + if (extCov[14] < 0) + { + 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]); + return kFALSE; + } + Float_t relUncertainty1Pt = TMath::Sqrt(extCov[14])*pt; //######################################################################## // cut the track? @@ -607,57 +930,101 @@ AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) { // track quality cuts if (fCutRequireTPCRefit && (status&AliESDtrack::kTPCrefit)==0) cuts[0]=kTRUE; - if (fCutRequireITSRefit && (status&AliESDtrack::kITSrefit)==0) + if (fCutRequireTPCStandAlone && (status&AliESDtrack::kTPCin)==0) cuts[1]=kTRUE; - if (nClustersTPCfCutMaxChi2PerClusterTPC) - cuts[4]=kTRUE; + cuts[5]=kTRUE; if (chi2PerClusterITS>fCutMaxChi2PerClusterITS) - cuts[5]=kTRUE; + cuts[6]=kTRUE; if (extCov[0] > fCutMaxC11) - cuts[6]=kTRUE; - if (extCov[2] > fCutMaxC22) cuts[7]=kTRUE; - if (extCov[5] > fCutMaxC33) + if (extCov[2] > fCutMaxC22) cuts[8]=kTRUE; - if (extCov[9] > fCutMaxC44) + if (extCov[5] > fCutMaxC33) cuts[9]=kTRUE; - if (extCov[14] > fCutMaxC55) + if (extCov[9] > fCutMaxC44) cuts[10]=kTRUE; + if (extCov[14] > fCutMaxC55) + cuts[11]=kTRUE; if (nSigmaToVertex > fCutNsigmaToVertex && fCutSigmaToVertexRequired) - cuts[11] = kTRUE; + cuts[12] = kTRUE; // if n sigma could not be calculated if (nSigmaToVertex<0 && fCutSigmaToVertexRequired) - cuts[12]=kTRUE; - if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0) cuts[13]=kTRUE; + if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0) + cuts[14]=kTRUE; // track kinematics cut if((momentum < fPMin) || (momentum > fPMax)) - cuts[14]=kTRUE; + cuts[15]=kTRUE; if((pt < fPtMin) || (pt > fPtMax)) - cuts[15] = kTRUE; - if((p[0] < fPxMin) || (p[0] > fPxMax)) cuts[16] = kTRUE; - if((p[1] < fPyMin) || (p[1] > fPyMax)) + if((p[0] < fPxMin) || (p[0] > fPxMax)) cuts[17] = kTRUE; - if((p[2] < fPzMin) || (p[2] > fPzMax)) + if((p[1] < fPyMin) || (p[1] > fPyMax)) cuts[18] = kTRUE; - if((eta < fEtaMin) || (eta > fEtaMax)) + if((p[2] < fPzMin) || (p[2] > fPzMax)) cuts[19] = kTRUE; - if((y < fRapMin) || (y > fRapMax)) + if((eta < fEtaMin) || (eta > fEtaMax)) cuts[20] = kTRUE; - if (dcaToVertex > fCutDCAToVertex) + if((y < fRapMin) || (y > fRapMax)) cuts[21] = kTRUE; - if (dcaToVertexXY > fCutDCAToVertexXY) + if (fCutDCAToVertex2D && dcaToVertex > 1) cuts[22] = kTRUE; + if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) > fCutMaxDCAToVertexXY) + cuts[23] = kTRUE; + if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) > fCutMaxDCAToVertexZ) + cuts[24] = kTRUE; + if (fCutDCAToVertex2D && fCutMinDCAToVertexXY > 0 && fCutMinDCAToVertexZ > 0 && dcaToVertexXY*dcaToVertexXY/fCutMinDCAToVertexXY/fCutMinDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMinDCAToVertexZ/fCutMinDCAToVertexZ < 1) + cuts[25] = kTRUE; + if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) < fCutMinDCAToVertexXY) + cuts[26] = kTRUE; + if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) < fCutMinDCAToVertexZ) + cuts[27] = kTRUE; + + for (Int_t i = 0; i < 3; i++) + cuts[28+i] = !CheckITSClusterRequirement(fCutClusterRequirementITS[i], esdTrack->HasPointOnITSLayer(i*2), esdTrack->HasPointOnITSLayer(i*2+1)); + + if(fCutRequireITSStandAlone || fCutRequireITSpureSA){ + if ((status & AliESDtrack::kITSin) == 0 || (status & AliESDtrack::kTPCin)){ + // TPC tracks + cuts[31] = kTRUE; + }else{ + // ITS standalone tracks + if(fCutRequireITSStandAlone && !fCutRequireITSpureSA){ + if(status & AliESDtrack::kITSpureSA) cuts[31] = kTRUE; + }else if(fCutRequireITSpureSA){ + if(!(status & AliESDtrack::kITSpureSA)) cuts[31] = kTRUE; + } + } + } + + if (relUncertainty1Pt > fCutMaxRel1PtUncertainty) + cuts[32] = kTRUE; + + if (!fCutAcceptSharedTPCClusters && nClustersTPCShared!=0) + cuts[33] = kTRUE; + + if (fracClustersTPCShared > fCutMaxFractionSharedTPCClusters) + cuts[34] = kTRUE; + + if(fCutRequireITSPid){ + UChar_t clumap=esdTrack->GetITSClusterMap(); + Int_t nPointsForPid=0; + for(Int_t i=2; i<6; i++){ + if(clumap&(1<Fill(extCov[9]); fhC55[id]->Fill(extCov[14]); + fhRel1PtUncertainty[id]->Fill(relUncertainty1Pt); + fhPt[id]->Fill(pt); fhEta[id]->Fill(eta); @@ -730,11 +1099,34 @@ AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) { return kTRUE; } +//____________________________________________________________________ +Bool_t AliESDtrackCuts::CheckITSClusterRequirement(ITSClusterRequirement req, Bool_t clusterL1, Bool_t clusterL2) +{ + // checks if the cluster requirement is fullfilled (in this case: return kTRUE) + + switch (req) + { + case kOff: return kTRUE; + case kNone: return !clusterL1 && !clusterL2; + case kAny: return clusterL1 || clusterL2; + case kFirst: return clusterL1; + case kOnlyFirst: return clusterL1 && !clusterL2; + case kSecond: return clusterL2; + case kOnlySecond: return clusterL2 && !clusterL1; + case kBoth: return clusterL1 && clusterL2; + } + + return kFALSE; +} + //____________________________________________________________________ AliESDtrack* AliESDtrackCuts::GetTPCOnlyTrack(AliESDEvent* esd, Int_t iTrack) { - // creates a TPC only track from the given esd track - // the track has to be deleted by the user + + // Utility function to + // create a TPC only track from the given esd track + // + // IMPORTANT: The track has to be deleted by the user // // NB. most of the functionality to get a TPC only track from an ESD track is in AliESDtrack, where it should be // there are only missing propagations here that are needed for old data @@ -745,21 +1137,15 @@ AliESDtrack* AliESDtrackCuts::GetTPCOnlyTrack(AliESDEvent* esd, Int_t iTrack) if (!esd->GetPrimaryVertexTPC()) return 0; // No TPC vertex no TPC tracks + if(!esd->GetPrimaryVertexTPC()->GetStatus()) + return 0; // TPC Vertex is created by default in AliESDEvent, do not use in this case + AliESDtrack* track = esd->GetTrack(iTrack); if (!track) return 0; AliESDtrack *tpcTrack = new AliESDtrack(); - // This should have been done during the reconstruction - // fixed by Juri in r26675 - // but recalculate for older data CKB - Float_t p[2],cov[3]; - track->GetImpactParametersTPC(p,cov); - if(p[0]==0&&p[1]==0) - track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig); - // BKC - // only true if we have a tpc track if (!track->FillTPCOnlyTrack(*tpcTrack)) { @@ -789,6 +1175,7 @@ TObjArray* AliESDtrackCuts::GetAcceptedTracks(AliESDEvent* esd,Bool_t bTPC) for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) { if(bTPC){ if(!esd->GetPrimaryVertexTPC())return acceptedTracks; // No TPC vertex no TPC tracks + if(!esd->GetPrimaryVertexTPC()->GetStatus())return acceptedTracks; // No proper TPC vertex, only the default AliESDtrack *tpcTrack = GetTPCOnlyTrack(esd, iTrack); if (!tpcTrack) @@ -874,6 +1261,8 @@ Int_t AliESDtrackCuts::CountAcceptedTracks(AliESDEvent* esd) fhC44[i] = new TH1F("covMatrixDiagonal44","",1000,0,0.1); fhC55[i] = new TH1F("covMatrixDiagonal55","",1000,0,5); + fhRel1PtUncertainty[i] = new TH1F("rel1PtUncertainty","",1000,0,5); + fhDXY[i] = new TH1F("dXY" ,"",500,-10,10); fhDZ[i] = new TH1F("dZ" ,"",500,-10,10); fhDXYDZ[i] = new TH1F("dXYDZ" ,"",500,0,10); @@ -885,7 +1274,7 @@ Int_t AliESDtrackCuts::CountAcceptedTracks(AliESDEvent* esd) fhNSigmaToVertex[i] = new TH1F("nSigmaToVertex","",500,0,10); - fhPt[i] = new TH1F("pt" ,"p_{T} distribution;p_{T} (GeV/c)",500,0.0,100.0); + fhPt[i] = new TH1F("pt" ,"p_{T} distribution;p_{T} (GeV/c)", 800, 0.0, 10.0); fhEta[i] = new TH1F("eta" ,"#eta distribution;#eta",40,-2.0,2.0); fhNClustersITS[i]->SetTitle("n ITS clusters"); @@ -899,16 +1288,18 @@ Int_t AliESDtrackCuts::CountAcceptedTracks(AliESDEvent* esd) fhC44[i]->SetTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}"); fhC55[i]->SetTitle("cov 55 : #sigma_{1/p_{T}}^{2} [(c/GeV)^2]"); - fhDXY[i]->SetTitle("transverse impact parameter"); - fhDZ[i]->SetTitle("longitudinal impact parameter"); - fhDXYDZ[i]->SetTitle("absolute impact parameter;sqrt(dXY**2 + dZ**2) in cm"); - fhDXYvsDZ[i]->SetXTitle("longitudinal impact parameter"); - fhDXYvsDZ[i]->SetYTitle("transverse impact parameter"); + fhRel1PtUncertainty[i]->SetTitle("rel. uncertainty of 1/p_{T}"); - fhDXYNormalized[i]->SetTitle("normalized trans impact par"); - fhDZNormalized[i]->SetTitle("normalized long impact par"); - fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par"); - fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par"); + fhDXY[i]->SetXTitle("transverse impact parameter (cm)"); + fhDZ[i]->SetXTitle("longitudinal impact parameter (cm)"); + fhDXYDZ[i]->SetTitle("absolute impact parameter;sqrt(dXY**2 + dZ**2) (cm)"); + fhDXYvsDZ[i]->SetXTitle("longitudinal impact parameter (cm)"); + fhDXYvsDZ[i]->SetYTitle("transverse impact parameter (cm)"); + + fhDXYNormalized[i]->SetTitle("normalized trans impact par (n#sigma)"); + fhDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)"); + fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)"); + fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par (n#sigma)"); fhNSigmaToVertex[i]->SetTitle("n #sigma to vertex"); fhNClustersITS[i]->SetLineColor(color); fhNClustersITS[i]->SetLineWidth(2); @@ -922,6 +1313,8 @@ Int_t AliESDtrackCuts::CountAcceptedTracks(AliESDEvent* esd) fhC44[i]->SetLineColor(color); fhC44[i]->SetLineWidth(2); fhC55[i]->SetLineColor(color); fhC55[i]->SetLineWidth(2); + fhRel1PtUncertainty[i]->SetLineColor(color); fhRel1PtUncertainty[i]->SetLineWidth(2); + fhDXY[i]->SetLineColor(color); fhDXY[i]->SetLineWidth(2); fhDZ[i]->SetLineColor(color); fhDZ[i]->SetLineWidth(2); fhDXYDZ[i]->SetLineColor(color); fhDXYDZ[i]->SetLineWidth(2); @@ -976,6 +1369,8 @@ Bool_t AliESDtrackCuts::LoadHistograms(const Char_t* dir) fhC44[i] = dynamic_cast (gDirectory->Get("covMatrixDiagonal44")); fhC55[i] = dynamic_cast (gDirectory->Get("covMatrixDiagonal55")); + fhRel1PtUncertainty[i] = dynamic_cast (gDirectory->Get("rel1PtUncertainty")); + fhDXY[i] = dynamic_cast (gDirectory->Get("dXY" )); fhDZ[i] = dynamic_cast (gDirectory->Get("dZ" )); fhDXYDZ[i] = dynamic_cast (gDirectory->Get("dXYDZ")); @@ -1041,6 +1436,8 @@ void AliESDtrackCuts::SaveHistograms(const Char_t* dir) { fhC44[i] ->Write(); fhC55[i] ->Write(); + fhRel1PtUncertainty[i] ->Write(); + fhDXY[i] ->Write(); fhDZ[i] ->Write(); fhDXYDZ[i] ->Write(); @@ -1111,6 +1508,11 @@ void AliESDtrackCuts::DrawHistograms() gPad->SetLogy(); fhC55[0]->Draw(); + canvas2->cd(6); + fhRel1PtUncertainty[0]->SetStats(kFALSE); + gPad->SetLogy(); + fhRel1PtUncertainty[0]->Draw(); + canvas2->SaveAs(Form("%s_%s.gif", GetName(), canvas2->GetName())); TCanvas* canvas3 = new TCanvas(Form("%s_3", GetName()), "Track Quality Results3", 1200, 800); @@ -1188,4 +1590,86 @@ void AliESDtrackCuts::DrawHistograms() fhChi2PerClusterTPC[1]->SetLineColor(2); fhChi2PerClusterTPC[1]->DrawCopy("SAME");*/ } +//-------------------------------------------------------------------------- +void AliESDtrackCuts::SetPtDepDCACuts(Double_t pt) { + // + // set the pt-dependent DCA cuts + // + + if(f1CutMaxDCAToVertexXYPtDep) { + fCutMaxDCAToVertexXY=f1CutMaxDCAToVertexXYPtDep->Eval(pt); + } + + if(f1CutMaxDCAToVertexZPtDep) { + fCutMaxDCAToVertexZ=f1CutMaxDCAToVertexZPtDep->Eval(pt); + } + + if(f1CutMinDCAToVertexXYPtDep) { + fCutMinDCAToVertexXY=f1CutMinDCAToVertexXYPtDep->Eval(pt); + } + + if(f1CutMinDCAToVertexZPtDep) { + fCutMinDCAToVertexZ=f1CutMinDCAToVertexZPtDep->Eval(pt); + } + + + return; +} + + + +//-------------------------------------------------------------------------- +Bool_t AliESDtrackCuts::CheckPtDepDCA(TString dist,Bool_t print) const { + // + // Check the correctness of the string syntax + // + Bool_t retval=kTRUE; + + if(!dist.Contains("pt")) { + if(print) printf("AliESDtrackCuts::CheckPtDepDCA(): string must contain \"pt\"\n"); + retval= kFALSE; + } + return retval; +} + void AliESDtrackCuts::SetMaxDCAToVertexXYPtDep(const char *dist){ + if(!CheckPtDepDCA(dist,kTRUE)) return; + if(f1CutMaxDCAToVertexXYPtDep)delete f1CutMaxDCAToVertexXYPtDep; + fCutMaxDCAToVertexXYPtDep = dist; + TString tmp(dist); + tmp.ReplaceAll("pt","x"); + f1CutMaxDCAToVertexXYPtDep = new TFormula("f1CutMaxDCAToVertexXYPtDep",tmp.Data()); + +} + + void AliESDtrackCuts::SetMaxDCAToVertexZPtDep(const char *dist){ + if(!CheckPtDepDCA(dist,kTRUE)) return; + if(f1CutMaxDCAToVertexZPtDep)delete f1CutMaxDCAToVertexZPtDep; + fCutMaxDCAToVertexZPtDep = dist; + TString tmp(dist); + tmp.ReplaceAll("pt","x"); + f1CutMaxDCAToVertexZPtDep = new TFormula("f1CutMaxDCAToVertexZPtDep",tmp.Data()); + + +} + + + void AliESDtrackCuts::SetMinDCAToVertexXYPtDep(const char *dist){ + if(!CheckPtDepDCA(dist,kTRUE)) return; + if(f1CutMinDCAToVertexXYPtDep)delete f1CutMinDCAToVertexXYPtDep; + fCutMinDCAToVertexXYPtDep = dist; + TString tmp(dist); + tmp.ReplaceAll("pt","x"); + f1CutMinDCAToVertexXYPtDep = new TFormula("f1CutMinDCAToVertexXYPtDep",tmp.Data()); + +} + + + void AliESDtrackCuts::SetMinDCAToVertexZPtDep(const char *dist){ + if(!CheckPtDepDCA(dist,kTRUE)) return; + if(f1CutMinDCAToVertexZPtDep)delete f1CutMinDCAToVertexZPtDep; + fCutMinDCAToVertexZPtDep = dist; + TString tmp(dist); + tmp.ReplaceAll("pt","x"); + f1CutMinDCAToVertexZPtDep = new TFormula("f1CutMinDCAToVertexZPtDep",tmp.Data()); +}