"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);
}
+//_____________________________________________________________________________
+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;
+
+ TIterator* iter = list->MakeIterator();
+ TObject* obj;
+
+
+ // collection of measured and generated histograms
+ Int_t count = 0;
+ while ((obj = iter->Next())) {
+
+ AliESDtrackCuts* entry = dynamic_cast<AliESDtrackCuts*>(obj);
+ if (entry == 0)
+ continue;
+
+ 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++;
+ }
+
+ return count+1;
+}
+
+
+//____________________________________________________________________
+Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack)
+{
+ //
+
+ 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]);
+
+ // -----------------------------------
+ // How to get to a n-sigma cut?
+ //
+ // The accumulated statistics from 0 to d is
+ //
+ // -> 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)
+ // Can this be expressed in a different way?
+ //
+ //
+ // FIX: I don't think this is correct!!! Keeping d as n_sigma for now...
+
+ 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;
+}
+
//____________________________________________________________________
-Bool_t
+Bool_t
AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) {
//
// figure out if the tracks survives all the track cuts defined
esdTrack->GetExternalCovariance(extCov);
// getting the track to vertex parameters
- 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]);
-
- // -----------------------------------
- // How to get to a n-sigma cut?
- //
- // The accumulated statistics from 0 to d is
- //
- // -> 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)
- // Can this be expressed in a different way?
- //
- //
- // 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))));
- }
+ Float_t nSigmaToVertex = GetSigmaToVertex(esdTrack);
- // getting the kinematic variables of the track
+ // 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)
cuts[13]=kTRUE;
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) {
//
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff