#include <AliESDtrack.h>
#include <AliESD.h>
#include <AliLog.h>
+#include <TTree.h>
//____________________________________________________________________
ClassImp(AliESDtrackCuts)
"trk-to-vtx",
"trk-to-vtx failed",
"kink daughters",
-
"p",
"p_{T}",
"p_{x}",
};
//____________________________________________________________________
-AliESDtrackCuts::AliESDtrackCuts()
+AliESDtrackCuts::AliESDtrackCuts() : TObject(),
+ fCutMinNClusterTPC(0),
+ fCutMinNClusterITS(0),
+ fCutMaxChi2PerClusterTPC(0),
+ fCutMaxChi2PerClusterITS(0),
+ fCutMaxC11(0),
+ fCutMaxC22(0),
+ fCutMaxC33(0),
+ fCutMaxC44(0),
+ fCutMaxC55(0),
+ fCutAcceptKinkDaughters(0),
+ fCutRequireTPCRefit(0),
+ fCutRequireITSRefit(0),
+ fCutNsigmaToVertex(0),
+ fCutSigmaToVertexRequired(0),
+ fPMin(0),
+ fPMax(0),
+ fPtMin(0),
+ fPtMax(0),
+ fPxMin(0),
+ fPxMax(0),
+ fPyMin(0),
+ fPyMax(0),
+ fPzMin(0),
+ fPzMax(0),
+ fEtaMin(0),
+ fEtaMax(0),
+ fRapMin(0),
+ fRapMax(0),
+ fHistogramsOn(0),
+ fhCutStatistics(0),
+ fhCutCorrelation(0)
{
//
// constructor
}
//_____________________________________________________________________________
-AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : TObject(c)
+AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : TObject(c),
+ fCutMinNClusterTPC(0),
+ fCutMinNClusterITS(0),
+ fCutMaxChi2PerClusterTPC(0),
+ fCutMaxChi2PerClusterITS(0),
+ fCutMaxC11(0),
+ fCutMaxC22(0),
+ fCutMaxC33(0),
+ fCutMaxC44(0),
+ fCutMaxC55(0),
+ fCutAcceptKinkDaughters(0),
+ fCutRequireTPCRefit(0),
+ fCutRequireITSRefit(0),
+ fCutNsigmaToVertex(0),
+ fCutSigmaToVertexRequired(0),
+ fPMin(0),
+ fPMax(0),
+ fPtMin(0),
+ fPtMax(0),
+ fPxMin(0),
+ fPxMax(0),
+ fPyMin(0),
+ fPyMax(0),
+ fPzMin(0),
+ fPzMax(0),
+ fEtaMin(0),
+ fEtaMax(0),
+ fRapMin(0),
+ fRapMax(0),
+ fHistogramsOn(0),
+ fhCutStatistics(0),
+ fhCutCorrelation(0)
{
//
// copy constructor
// destructor
//
- // ## TODO to be implemented
+ for (Int_t i=0; i<2; i++) {
+
+ if (fhNClustersITS[i])
+ delete fhNClustersITS[i];
+ if (fhNClustersTPC[i])
+ delete fhNClustersTPC[i];
+ if (fhChi2PerClusterITS[i])
+ delete fhChi2PerClusterITS[i];
+ if (fhChi2PerClusterTPC[i])
+ delete fhChi2PerClusterTPC[i];
+ if (fhC11[i])
+ delete fhC11[i];
+ if (fhC22[i])
+ delete fhC22[i];
+ if (fhC33[i])
+ delete fhC33[i];
+ if (fhC44[i])
+ delete fhC44[i];
+ if (fhC55[i])
+ delete fhC55[i];
+
+ if (fhDXY[i])
+ delete fhDXY[i];
+ if (fhDZ[i])
+ delete fhDZ[i];
+ if (fhDXYvsDZ[i])
+ delete fhDXYvsDZ[i];
+
+ if (fhDXYNormalized[i])
+ delete fhDXYNormalized[i];
+ if (fhDZNormalized[i])
+ delete fhDZNormalized[i];
+ if (fhDXYvsDZNormalized[i])
+ delete fhDXYvsDZNormalized[i];
+ }
+
+ if (fhCutStatistics)
+ delete fhCutStatistics;
+ if (fhCutCorrelation)
+ delete fhCutCorrelation;
}
void AliESDtrackCuts::Init()
TObject::Copy(c);
}
-//____________________________________________________________________
-Bool_t
-AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) {
- //
- // figure out if the tracks survives all the track cuts defined
- //
- // the different quality parameter and kinematic values are first
- // retrieved from the track. then it is found out what cuts the
- // track did not survive and finally the cuts are imposed.
+//_____________________________________________________________________________
+Long64_t AliESDtrackCuts::Merge(TCollection* list) {
+ // Merge a list of AliESDtrackCuts objects with this (needed for PROOF)
+ // Returns the number of merged objects (including this)
+ if (!list)
+ return 0;
+
+ if (list->IsEmpty())
+ return 1;
+ if (!fHistogramsOn)
+ return 0;
- UInt_t status = esdTrack->GetStatus();
+ TIterator* iter = list->MakeIterator();
+ TObject* obj;
- // dummy array
- Int_t fIdxInt[200];
- // getting quality parameters from the ESD track
- Int_t nClustersITS = esdTrack->GetITSclusters(fIdxInt);
- Int_t nClustersTPC = esdTrack->GetTPCclusters(fIdxInt);
-
+ // collection of measured and generated histograms
+ Int_t count = 0;
+ while ((obj = iter->Next())) {
+ AliESDtrackCuts* entry = dynamic_cast<AliESDtrackCuts*>(obj);
+ if (entry == 0)
+ continue;
- 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 (!entry->fHistogramsOn)
+ continue;
+
+ for (Int_t i=0; i<2; i++) {
+
+ fhNClustersITS[i] ->Add(entry->fhNClustersITS[i] );
+ fhNClustersTPC[i] ->Add(entry->fhNClustersTPC[i] );
+
+ fhChi2PerClusterITS[i] ->Add(entry->fhChi2PerClusterITS[i]);
+ fhChi2PerClusterTPC[i] ->Add(entry->fhChi2PerClusterTPC[i]);
+
+ fhC11[i] ->Add(entry->fhC11[i] );
+ fhC22[i] ->Add(entry->fhC22[i] );
+ fhC33[i] ->Add(entry->fhC33[i] );
+ fhC44[i] ->Add(entry->fhC44[i] );
+ fhC55[i] ->Add(entry->fhC55[i] );
+
+ fhDXY[i] ->Add(entry->fhDXY[i] );
+ fhDZ[i] ->Add(entry->fhDZ[i] );
+ fhDXYvsDZ[i] ->Add(entry->fhDXYvsDZ[i] );
+
+ fhDXYNormalized[i] ->Add(entry->fhDXYNormalized[i] );
+ fhDZNormalized[i] ->Add(entry->fhDZNormalized[i] );
+ fhDXYvsDZNormalized[i] ->Add(entry->fhDXYvsDZNormalized[i]);
+ }
+
+ fhCutStatistics ->Add(entry->fhCutStatistics);
+ fhCutCorrelation ->Add(entry->fhCutCorrelation);
+
+ count++;
+ }
- Double_t extCov[15];
- esdTrack->GetExternalCovariance(extCov);
+ return count+1;
+}
+
+
+//____________________________________________________________________
+Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack)
+{
+ //
- // getting the track to vertex parameters
Float_t b[2];
Float_t bRes[2];
Float_t bCov[3];
- esdTrack->GetImpactParameters(b,bCov);
+ esdTrack->GetImpactParameters(b,bCov);
if (bCov[0]<=0 || bCov[2]<=0) {
AliDebug(1, "Estimated b resolution lower or equal zero!");
bCov[0]=0; bCov[2]=0;
- }
+ }
bRes[0] = TMath::Sqrt(bCov[0]);
bRes[1] = TMath::Sqrt(bCov[2]);
//
// FIX: I don't think this is correct!!! Keeping d as n_sigma for now...
- Float_t nSigmaToVertex = -1;
- if (bRes[0]!=0 && bRes[1]!=0) {
- Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
- nSigmaToVertex = d;//TMath::Sqrt(2)*(TMath::ErfInverse(1 - TMath::Exp(0.5*(-d*d))));
- // JF solution: nSigmaToVertex = TMath::ErfInverse(TMath::Sqrt(2.0/TMath::Pi()) * TMath::Erf(d / TMath::Sqrt(2))) * TMath::Sqrt(2);
- }
+ if (bRes[0] == 0 || bRes[1] ==0)
+ return -1;
+
+ Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
+
+ // stupid rounding problem screws up everything:
+ // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
+ if (TMath::Exp(-d * d / 2) < 1e-10)
+ return 1000;
+
+ d = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
+ return d;
+}
+
+void AliESDtrackCuts::EnableNeededBranches(TTree* tree)
+{
+ // enables the branches needed by AcceptTrack, for a list see comment of AcceptTrack
+
+ tree->SetBranchStatus("fTracks.fFlags", 1);
+ tree->SetBranchStatus("fTracks.fITSncls", 1);
+ tree->SetBranchStatus("fTracks.fTPCncls", 1);
+ tree->SetBranchStatus("fTracks.fITSchi2", 1);
+ tree->SetBranchStatus("fTracks.fTPCchi2", 1);
+ tree->SetBranchStatus("fTracks.fC*", 1);
+ tree->SetBranchStatus("fTracks.fD", 1);
+ tree->SetBranchStatus("fTracks.fZ", 1);
+ tree->SetBranchStatus("fTracks.fCdd", 1);
+ tree->SetBranchStatus("fTracks.fCdz", 1);
+ tree->SetBranchStatus("fTracks.fCzz", 1);
+ tree->SetBranchStatus("fTracks.fP*", 1);
+ tree->SetBranchStatus("fTracks.fR*", 1);
+ tree->SetBranchStatus("fTracks.fKinkIndexes*", 1);
+}
+
+//____________________________________________________________________
+Bool_t
+AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) {
+ //
+ // figure out if the tracks survives all the track cuts defined
+ //
+ // the different quality parameter and kinematic values are first
+ // retrieved from the track. then it is found out what cuts the
+ // track did not survive and finally the cuts are imposed.
+
+ // this function needs the following branches:
+ // fTracks.fFlags
+ // fTracks.fITSncls
+ // fTracks.fTPCncls
+ // fTracks.fITSchi2
+ // fTracks.fTPCchi2
+ // fTracks.fC //GetExternalCovariance
+ // fTracks.fD //GetImpactParameters
+ // fTracks.fZ //GetImpactParameters
+ // fTracks.fCdd //GetImpactParameters
+ // fTracks.fCdz //GetImpactParameters
+ // fTracks.fCzz //GetImpactParameters
+ // fTracks.fP //GetPxPyPz
+ // fTracks.fR //GetMass
+ // fTracks.fP //GetMass
+ // fTracks.fKinkIndexes
+
+ UInt_t status = esdTrack->GetStatus();
+
+ // dummy array
+ Int_t fIdxInt[200];
- // getting the kinematic variables of the track
+ // getting quality parameters from the ESD track
+ Int_t nClustersITS = esdTrack->GetITSclusters(fIdxInt);
+ Int_t nClustersTPC = esdTrack->GetTPCclusters(fIdxInt);
+
+
+
+ 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);
+
+ Double_t extCov[15];
+ esdTrack->GetExternalCovariance(extCov);
+
+ // getting the track to vertex parameters
+ Float_t nSigmaToVertex = GetSigmaToVertex(esdTrack);
+
+ // getting the kinematic variables of the track
// (assuming the mass is known)
Double_t p[3];
esdTrack->GetPxPyPz(p);
cuts[0]=kTRUE;
if (fCutRequireITSRefit && (status&AliESDtrack::kITSrefit)==0)
cuts[1]=kTRUE;
- if (nClustersTPC<fCutMinNClusterTPC)
+ if (nClustersTPC<fCutMinNClusterTPC)
cuts[2]=kTRUE;
if (nClustersITS<fCutMinNClusterITS)
cuts[3]=kTRUE;
cuts[9]=kTRUE;
if (extCov[14] > fCutMaxC55)
cuts[10]=kTRUE;
- if (nSigmaToVertex > fCutNsigmaToVertex)
+ if (nSigmaToVertex > fCutNsigmaToVertex)
cuts[11] = kTRUE;
// if n sigma could not be calculated
- if (nSigmaToVertex<0 && fCutSigmaToVertexRequired)
+ if (nSigmaToVertex<0 && fCutSigmaToVertexRequired)
cuts[12]=kTRUE;
- if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
+ if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
cuts[13]=kTRUE;
// track kinematics cut
if((momentum < fPMin) || (momentum > fPMax))
cuts[16] = kTRUE;
if((p[1] < fPyMin) || (p[1] > fPyMax))
cuts[17] = kTRUE;
- if((p[2] < fPzMin) || (p[2] > fPzMax))
+ if((p[2] < fPzMin) || (p[2] > fPzMax))
cuts[18] = kTRUE;
if((eta < fEtaMin) || (eta > fEtaMax))
cuts[19] = kTRUE;
}
- fhNClustersITS[0]->Fill(nClustersITS);
- fhNClustersTPC[0]->Fill(nClustersTPC);
+ fhNClustersITS[0]->Fill(nClustersITS);
+ fhNClustersTPC[0]->Fill(nClustersTPC);
fhChi2PerClusterITS[0]->Fill(chi2PerClusterITS);
- fhChi2PerClusterTPC[0]->Fill(chi2PerClusterTPC);
-
- fhC11[0]->Fill(extCov[0]);
- fhC22[0]->Fill(extCov[2]);
- fhC33[0]->Fill(extCov[5]);
- fhC44[0]->Fill(extCov[9]);
- fhC55[0]->Fill(extCov[14]);
-
- fhDZ[0]->Fill(b[1]);
- fhDXY[0]->Fill(b[0]);
+ fhChi2PerClusterTPC[0]->Fill(chi2PerClusterTPC);
+
+ fhC11[0]->Fill(extCov[0]);
+ fhC22[0]->Fill(extCov[2]);
+ fhC33[0]->Fill(extCov[5]);
+ fhC44[0]->Fill(extCov[9]);
+ fhC55[0]->Fill(extCov[14]);
+
+ Float_t b[2];
+ Float_t bRes[2];
+ Float_t bCov[3];
+ esdTrack->GetImpactParameters(b,bCov);
+ if (bCov[0]<=0 || bCov[2]<=0) {
+ AliDebug(1, "Estimated b resolution lower or equal zero!");
+ bCov[0]=0; bCov[2]=0;
+ }
+ bRes[0] = TMath::Sqrt(bCov[0]);
+ bRes[1] = TMath::Sqrt(bCov[2]);
+
+ fhDZ[0]->Fill(b[1]);
+ fhDXY[0]->Fill(b[0]);
fhDXYvsDZ[0]->Fill(b[1],b[0]);
if (bRes[0]!=0 && bRes[1]!=0) {
- fhDZNormalized[0]->Fill(b[1]/bRes[1]);
- fhDXYNormalized[0]->Fill(b[0]/bRes[0]);
+ fhDZNormalized[0]->Fill(b[1]/bRes[1]);
+ fhDXYNormalized[0]->Fill(b[0]/bRes[0]);
fhDXYvsDZNormalized[0]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
}
}
- //########################################################################
+ //########################################################################
// cut the track!
if (cut) return kFALSE;
- //########################################################################
+ //########################################################################
// filling histograms after cut
if (fHistogramsOn) {
- fhNClustersITS[1]->Fill(nClustersITS);
- fhNClustersTPC[1]->Fill(nClustersTPC);
+ fhNClustersITS[1]->Fill(nClustersITS);
+ fhNClustersTPC[1]->Fill(nClustersTPC);
fhChi2PerClusterITS[1]->Fill(chi2PerClusterITS);
- fhChi2PerClusterTPC[1]->Fill(chi2PerClusterTPC);
-
- fhC11[1]->Fill(extCov[0]);
- fhC22[1]->Fill(extCov[2]);
- fhC33[1]->Fill(extCov[5]);
- fhC44[1]->Fill(extCov[9]);
- fhC55[1]->Fill(extCov[14]);
-
- fhDZ[1]->Fill(b[1]);
- fhDXY[1]->Fill(b[0]);
+ fhChi2PerClusterTPC[1]->Fill(chi2PerClusterTPC);
+
+ fhC11[1]->Fill(extCov[0]);
+ fhC22[1]->Fill(extCov[2]);
+ fhC33[1]->Fill(extCov[5]);
+ fhC44[1]->Fill(extCov[9]);
+ fhC55[1]->Fill(extCov[14]);
+
+ Float_t b[2];
+ Float_t bRes[2];
+ Float_t bCov[3];
+ esdTrack->GetImpactParameters(b,bCov);
+ if (bCov[0]<=0 || bCov[2]<=0) {
+ AliDebug(1, "Estimated b resolution lower or equal zero!");
+ bCov[0]=0; bCov[2]=0;
+ }
+ bRes[0] = TMath::Sqrt(bCov[0]);
+ bRes[1] = TMath::Sqrt(bCov[2]);
+
+ fhDZ[1]->Fill(b[1]);
+ fhDXY[1]->Fill(b[0]);
fhDXYvsDZ[1]->Fill(b[1],b[0]);
- fhDZNormalized[1]->Fill(b[1]/bRes[1]);
- fhDXYNormalized[1]->Fill(b[0]/bRes[0]);
- fhDXYvsDZNormalized[1]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
+ if (bRes[0]!=0 && bRes[1]!=0)
+ {
+ fhDZNormalized[1]->Fill(b[1]/bRes[1]);
+ fhDXYNormalized[1]->Fill(b[0]/bRes[0]);
+ fhDXYvsDZNormalized[1]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
+ }
}
-
+
return kTRUE;
}
//
TObjArray* acceptedTracks = new TObjArray();
-
+
// loop over esd tracks
for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
AliESDtrack* track = esd->GetTrack(iTrack);
-
+
if (AcceptTrack(track))
acceptedTracks->Add(track);
}
return acceptedTracks;
}
+//____________________________________________________________________
+Int_t
+AliESDtrackCuts::CountAcceptedTracks(AliESD* esd)
+{
+ //
+ // returns an the number of tracks that pass the cuts
+ //
+
+ Int_t count = 0;
+
+ // loop over esd tracks
+ for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
+ AliESDtrack* track = esd->GetTrack(iTrack);
+
+ if (AcceptTrack(track))
+ count++;
+ }
+
+ return count;
+}
+
//____________________________________________________________________
void AliESDtrackCuts::DefineHistograms(Int_t color) {
//