#include <limits.h>
#include <float.h>
+#include "TParticle.h"
+#include "AliStack.h"
#include "AliMCEvent.h"
+#include "AliESDEvent.h"
#include "AliVParticle.h"
#include "AliMCParticle.h"
#include "AliESDtrack.h"
+#include "AliMultiplicity.h"
#include "AliAODTrack.h"
#include "AliFlowTrack.h"
#include "AliFlowTrackCuts.h"
AliFlowTrackCuts::AliFlowTrackCuts():
AliFlowTrackSimpleCuts(),
fAliESDtrackCuts(new AliESDtrackCuts()),
+ fQA(kFALSE),
+ fCutMC(kFALSE),
fCutMCprocessType(kFALSE),
fMCprocessType(kPNoProcess),
fCutMCPID(kFALSE),
fMCPID(0),
+ fIgnoreSignInPID(kFALSE),
fCutMCisPrimary(kFALSE),
fMCisPrimary(kFALSE),
fRequireCharge(kFALSE),
fFakesAreOK(kTRUE),
- fParamType(kESD_Global),
+ fCutSPDtrackletDeltaPhi(kFALSE),
+ fSPDtrackletDeltaPhiMax(FLT_MAX),
+ fSPDtrackletDeltaPhiMin(-FLT_MAX),
+ fIgnoreTPCzRange(kFALSE),
+ fIgnoreTPCzRangeMax(FLT_MAX),
+ fIgnoreTPCzRangeMin(-FLT_MAX),
+ fParamType(kGlobal),
fParamMix(kPure),
- fCleanupTrack(kFALSE),
fTrack(NULL),
+ fTrackPhi(0.),
+ fTrackEta(0.),
+ fTrackWeight(0.),
fTrackLabel(INT_MIN),
fMCevent(NULL),
- fMCparticle(NULL)
+ fMCparticle(NULL),
+ fEvent(NULL),
+ fTPCtrack()
{
//constructor
}
//-----------------------------------------------------------------------
-AliFlowTrackCuts::AliFlowTrackCuts(const AliFlowTrackCuts& someCuts):
- AliFlowTrackSimpleCuts(someCuts),
- fAliESDtrackCuts(new AliESDtrackCuts(*(someCuts.fAliESDtrackCuts))),
- fCutMCprocessType(someCuts.fCutMCprocessType),
- fMCprocessType(someCuts.fMCprocessType),
- fCutMCPID(someCuts.fCutMCPID),
- fMCPID(someCuts.fMCPID),
- fCutMCisPrimary(someCuts.fCutMCisPrimary),
- fMCisPrimary(someCuts.fMCisPrimary),
- fRequireCharge(someCuts.fRequireCharge),
- fFakesAreOK(someCuts.fFakesAreOK),
- fParamType(someCuts.fParamType),
- fParamMix(someCuts.fParamMix),
- fCleanupTrack(kFALSE),
+AliFlowTrackCuts::AliFlowTrackCuts(const AliFlowTrackCuts& that):
+ AliFlowTrackSimpleCuts(that),
+ fAliESDtrackCuts(new AliESDtrackCuts(*(that.fAliESDtrackCuts))),
+ fQA(that.fQA),
+ fCutMC(that.fCutMC),
+ fCutMCprocessType(that.fCutMCprocessType),
+ fMCprocessType(that.fMCprocessType),
+ fCutMCPID(that.fCutMCPID),
+ fMCPID(that.fMCPID),
+ fIgnoreSignInPID(that.fIgnoreSignInPID),
+ fCutMCisPrimary(that.fCutMCisPrimary),
+ fMCisPrimary(that.fMCisPrimary),
+ fRequireCharge(that.fRequireCharge),
+ fFakesAreOK(that.fFakesAreOK),
+ fCutSPDtrackletDeltaPhi(that.fCutSPDtrackletDeltaPhi),
+ fSPDtrackletDeltaPhiMax(that.fSPDtrackletDeltaPhiMax),
+ fSPDtrackletDeltaPhiMin(that.fSPDtrackletDeltaPhiMin),
+ fIgnoreTPCzRange(that.fIgnoreTPCzRange),
+ fIgnoreTPCzRangeMax(that.fIgnoreTPCzRangeMax),
+ fIgnoreTPCzRangeMin(that.fIgnoreTPCzRangeMin),
+ fParamType(that.fParamType),
+ fParamMix(that.fParamMix),
fTrack(NULL),
+ fTrackPhi(0.),
+ fTrackEta(0.),
+ fTrackWeight(0.),
fTrackLabel(INT_MIN),
fMCevent(NULL),
- fMCparticle(NULL)
+ fMCparticle(NULL),
+ fEvent(NULL),
+ fTPCtrack(that.fTPCtrack)
{
//copy constructor
}
//-----------------------------------------------------------------------
-AliFlowTrackCuts& AliFlowTrackCuts::operator=(const AliFlowTrackCuts& someCuts)
+AliFlowTrackCuts& AliFlowTrackCuts::operator=(const AliFlowTrackCuts& that)
{
//assignment
- AliFlowTrackSimpleCuts::operator=(someCuts);
- *fAliESDtrackCuts=*(someCuts.fAliESDtrackCuts);
- fCutMCprocessType=someCuts.fCutMCprocessType;
- fMCprocessType=someCuts.fMCprocessType;
- fCutMCPID=someCuts.fCutMCPID;
- fMCPID=someCuts.fMCPID;
- fCutMCisPrimary=someCuts.fCutMCisPrimary;
- fMCisPrimary=someCuts.fMCisPrimary;
- fRequireCharge=someCuts.fRequireCharge;
- fFakesAreOK=someCuts.fFakesAreOK;
- fParamType=someCuts.fParamType;
- fParamMix=someCuts.fParamMix;
-
- fCleanupTrack=kFALSE;
+ AliFlowTrackSimpleCuts::operator=(that);
+ *fAliESDtrackCuts=*(that.fAliESDtrackCuts);
+ fQA=that.fQA;
+ fCutMC=that.fCutMC;
+ fCutMCprocessType=that.fCutMCprocessType;
+ fMCprocessType=that.fMCprocessType;
+ fCutMCPID=that.fCutMCPID;
+ fMCPID=that.fMCPID;
+ fIgnoreSignInPID=that.fIgnoreSignInPID,
+ fCutMCisPrimary=that.fCutMCisPrimary;
+ fMCisPrimary=that.fMCisPrimary;
+ fRequireCharge=that.fRequireCharge;
+ fFakesAreOK=that.fFakesAreOK;
+ fCutSPDtrackletDeltaPhi=that.fCutSPDtrackletDeltaPhi;
+ fSPDtrackletDeltaPhiMax=that.fSPDtrackletDeltaPhiMax;
+ fSPDtrackletDeltaPhiMin=that.fSPDtrackletDeltaPhiMin;
+ fIgnoreTPCzRange=that.fIgnoreTPCzRange;
+ fIgnoreTPCzRangeMax=that.fIgnoreTPCzRangeMax;
+ fIgnoreTPCzRangeMin=that.fIgnoreTPCzRangeMin;
+ fParamType=that.fParamType;
+ fParamMix=that.fParamMix;
+
fTrack=NULL;
+ fTrackPhi=0.;
+ fTrackPhi=0.;
+ fTrackWeight=0.;
fTrackLabel=INT_MIN;
fMCevent=NULL;
fMCparticle=NULL;
+ fEvent=NULL;
return *this;
}
AliFlowTrackCuts::~AliFlowTrackCuts()
{
//dtor
- if (fCleanupTrack) delete fTrack;
delete fAliESDtrackCuts;
}
//-----------------------------------------------------------------------
-Bool_t AliFlowTrackCuts::IsSelected(TObject* obj)
+Bool_t AliFlowTrackCuts::IsSelected(TObject* obj, Int_t id)
{
//check cuts
AliVParticle* vparticle = dynamic_cast<AliVParticle*>(obj);
if (vparticle) return PassesCuts(vparticle);
AliFlowTrackSimple* flowtrack = dynamic_cast<AliFlowTrackSimple*>(obj);
if (flowtrack) return PassesCuts(flowtrack);
+ AliMultiplicity* tracklets = dynamic_cast<AliMultiplicity*>(obj);
+ if (tracklets) return PassesCuts(tracklets,id);
+ return kFALSE; //default when passed wrong type of object
+}
+
+//-----------------------------------------------------------------------
+Bool_t AliFlowTrackCuts::IsSelectedMCtruth(TObject* obj, Int_t id)
+{
+ //check cuts
+ AliVParticle* vparticle = dynamic_cast<AliVParticle*>(obj);
+ if (vparticle)
+ {
+ return PassesMCcuts(fMCevent,vparticle->GetLabel());
+ }
+ AliMultiplicity* tracklets = dynamic_cast<AliMultiplicity*>(obj);
+ if (tracklets)
+ {
+ Int_t label0 = tracklets->GetLabel(id,0);
+ Int_t label1 = tracklets->GetLabel(id,1);
+ Int_t label = (label0==label1)?tracklets->GetLabel(id,1):-666;
+ return PassesMCcuts(fMCevent,label);
+ }
return kFALSE; //default when passed wrong type of object
}
//check cuts on a flowtracksimple
//clean up from last iteration
- if (fCleanupTrack) delete fTrack; fTrack = NULL;
+ fTrack = NULL;
return AliFlowTrackSimpleCuts::PassesCuts(track);
}
+//-----------------------------------------------------------------------
+Bool_t AliFlowTrackCuts::PassesCuts(AliMultiplicity* tracklet, Int_t id)
+{
+ //check cuts on a tracklets
+
+ //clean up from last iteration, and init label
+ fTrack = NULL;
+ fMCparticle=NULL;
+ fTrackLabel=-1;
+
+ fTrackPhi = tracklet->GetPhi(id);
+ fTrackEta = tracklet->GetEta(id);
+ fTrackWeight = 1.0;
+ if (fCutEta) {if ( fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) return kFALSE;}
+ if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) return kFALSE;}
+
+ //check MC info if available
+ //if the 2 clusters have different label track cannot be good
+ //and should therefore not pass the mc cuts
+ Int_t label0 = tracklet->GetLabel(id,0);
+ Int_t label1 = tracklet->GetLabel(id,1);
+ //if possible get label and mcparticle
+ fTrackLabel = (label0==label1)?tracklet->GetLabel(id,1):-1;
+ if (fTrackLabel>=0 && fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
+ //check MC cuts
+ if (fCutMC && !PassesMCcuts()) return kFALSE;
+ return kTRUE;
+}
+
+//-----------------------------------------------------------------------
+Bool_t AliFlowTrackCuts::PassesMCcuts(AliMCEvent* mcEvent, Int_t label)
+{
+ //check the MC info
+ if (!mcEvent) return kFALSE;
+ if (label<0) return kFALSE;//otherwise AliCMevent prints a warning before returning NULL
+ AliMCParticle* mcparticle = static_cast<AliMCParticle*>(mcEvent->GetTrack(label));
+ if (!mcparticle) {AliError("no MC track"); return kFALSE;}
+
+ if (fCutMCisPrimary)
+ {
+ if (IsPhysicalPrimary(mcEvent,label) != fMCisPrimary) return kFALSE;
+ }
+ if (fCutMCPID)
+ {
+ Int_t pdgCode = mcparticle->PdgCode();
+ if (fIgnoreSignInPID)
+ {
+ if (TMath::Abs(fMCPID) != TMath::Abs(pdgCode)) return kFALSE;
+ }
+ else
+ {
+ if (fMCPID != pdgCode) return kFALSE;
+ }
+ }
+ if ( fCutMCprocessType )
+ {
+ TParticle* particle = mcparticle->Particle();
+ Int_t processID = particle->GetUniqueID();
+ if (processID != fMCprocessType ) return kFALSE;
+ }
+ return kTRUE;
+}
+//-----------------------------------------------------------------------
+Bool_t AliFlowTrackCuts::PassesMCcuts()
+{
+ if (!fMCevent) return kFALSE;
+ if (fTrackLabel<0) return kFALSE;//otherwise AliCMevent prints a warning before returning NULL
+ fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
+ return PassesMCcuts(fMCevent,fTrackLabel);
+}
+
//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesCuts(AliVParticle* vparticle)
{
// start by preparing the track parameters to cut on //////////
////////////////////////////////////////////////////////////////
//clean up from last iteration
- if (fCleanupTrack) delete fTrack; fTrack=NULL;
+ fTrack=NULL;
//get the label and the mc particle
fTrackLabel = (fFakesAreOK)?TMath::Abs(vparticle->GetLabel()):vparticle->GetLabel();
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
- //check the common cuts for the current particle (MC,AOD,ESD)
- if (fCutPt) {if (fTrack->Pt() < fPtMin || fTrack->Pt() >= fPtMax ) return kFALSE;}
- if (fCutEta) {if (fTrack->Eta() < fEtaMin || fTrack->Eta() >= fEtaMax ) return kFALSE;}
- if (fCutPhi) {if (fTrack->Phi() < fPhiMin || fTrack->Phi() >= fPhiMax ) return kFALSE;}
- if (fRequireCharge) {if (fTrack->Charge() == 0) return kFALSE;}
- if (fCutCharge && !isMCparticle) {if (fTrack->Charge() != fCharge) return kFALSE;}
+ if (!fTrack) return kFALSE;
+ Bool_t pass=kTRUE;
+ //check the common cuts for the current particle fTrack (MC,AOD,ESD)
+ if (fCutPt) {if (fTrack->Pt() < fPtMin || fTrack->Pt() >= fPtMax ) pass=kFALSE;}
+ if (fCutEta) {if (fTrack->Eta() < fEtaMin || fTrack->Eta() >= fEtaMax ) pass=kFALSE;}
+ if (fCutPhi) {if (fTrack->Phi() < fPhiMin || fTrack->Phi() >= fPhiMax ) pass=kFALSE;}
+ if (fRequireCharge) {if (fTrack->Charge() == 0) pass=kFALSE;}
+ if (fCutCharge && !isMCparticle) {if (fTrack->Charge() != fCharge) pass=kFALSE;}
if (fCutCharge && isMCparticle)
{
//in case of an MC particle the charge is stored in units of 1/3|e|
Int_t charge = TMath::Nint(fTrack->Charge()/3.0); //mc particles have charge in units of 1/3e
return (charge==fCharge);
}
- //if(fCutPID) {if (fTrack->PID() != fPID) return kFALSE;}
+ //if(fCutPID) {if (fTrack->PID() != fPID) pass=kFALSE;}
//when additionally MC info is required
- if (fCutMCisPrimary)
- {
- if (!fMCevent) {AliError("no MC info"); return kFALSE;}
- if (fMCevent->IsPhysicalPrimary(fTrackLabel) != fMCisPrimary) return kFALSE;
- }
- if (fCutMCPID)
- {
- if (!fMCparticle) {AliError("no MC info"); return kFALSE;}
- Int_t pdgCode = fMCparticle->PdgCode();
- if (fMCPID != pdgCode) return kFALSE;
- }
- if ( fCutMCprocessType )
- {
- if (!fMCparticle) {AliError("no MC info"); return kFALSE;}
- TParticle* particle = fMCparticle->Particle();
- Int_t processID = particle->GetUniqueID();
- if (processID != fMCprocessType ) return kFALSE;
- }
+ if (fCutMC && !PassesMCcuts()) pass=kFALSE;
//check all else for ESDs using aliesdtrackcuts
- if (esdTrack && (fParamType!=kMC) ) return fAliESDtrackCuts->IsSelected(static_cast<AliESDtrack*>(fTrack));
+ if (esdTrack && (fParamType!=kMC) )
+ {
+ if (fIgnoreTPCzRange)
+ {
+ const AliExternalTrackParam* pin = esdTrack->GetOuterParam();
+ const AliExternalTrackParam* pout = esdTrack->GetInnerParam();
+ if (pin&&pout)
+ {
+ Double_t zin = pin->GetZ();
+ Double_t zout = pout->GetZ();
+ if (zin*zout<0) pass=kFALSE; //reject if cross the membrane
+ if (zin < fIgnoreTPCzRangeMin || zin > fIgnoreTPCzRangeMax) pass=kFALSE;
+ if (zout < fIgnoreTPCzRangeMin || zout > fIgnoreTPCzRangeMax) pass=kFALSE;
+ }
+ }
+ if (!fAliESDtrackCuts->IsSelected(static_cast<AliESDtrack*>(fTrack))) pass=kFALSE;
+ }
- return kTRUE; //true by default, if we didn't set any cuts
+ return pass; //true by default, if we didn't set any cuts
}
//-----------------------------------------------------------------------
//handle the general case
switch (fParamType)
{
- case kMC:
- fCleanupTrack = kFALSE;
- fTrack = fMCparticle;
- break;
default:
- fCleanupTrack = kFALSE;
fTrack = track;
}
}
//handle esd track
switch (fParamType)
{
- case kESD_Global:
+ case kGlobal:
fTrack = track;
- fCleanupTrack = kFALSE;
break;
case kESD_TPConly:
- fTrack = new AliESDtrack();
- track->FillTPCOnlyTrack(*(static_cast<AliESDtrack*>(fTrack)));
- fCleanupTrack = kTRUE;
+ if (!track->FillTPCOnlyTrack(fTPCtrack))
+ {
+ fTrack=NULL;
+ fMCparticle=NULL;
+ fTrackLabel=-1;
+ return;
+ }
+ fTrack = &fTPCtrack;
//recalculate the label and mc particle, they may differ as TPClabel != global label
fTrackLabel = (fFakesAreOK)?TMath::Abs(fTrack->GetLabel()):fTrack->GetLabel();
if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
else fMCparticle=NULL;
break;
- case kMC:
- fCleanupTrack = kFALSE;
- fTrack = fMCparticle;
- break;
default:
fTrack = track;
- fCleanupTrack = kFALSE;
}
}
cuts->SetName("standard global track cuts 2009");
delete cuts->fAliESDtrackCuts;
cuts->fAliESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(selPrimaries);
- cuts->SetParamType(kESD_Global);
+ cuts->SetParamType(kGlobal);
return cuts;
}
{
//get a flow track constructed from whatever we applied cuts on
//caller is resposible for deletion
+ //if construction fails return NULL
AliFlowTrack* flowtrack=NULL;
- switch(fParamMix)
+ TParticle *tmpTParticle=NULL;
+ AliMCParticle* tmpAliMCParticle=NULL;
+ if (fParamType==kESD_SPDtracklet)
{
- case kPure:
- flowtrack = new AliFlowTrack(fTrack);
- break;
- case kTrackWithMCkine:
- flowtrack = new AliFlowTrack(fMCparticle);
- break;
- case kTrackWithMCPID:
- flowtrack = new AliFlowTrack(fTrack);
- break;
- default:
- flowtrack = new AliFlowTrack(fTrack);
+ switch (fParamMix)
+ {
+ case kPure:
+ flowtrack = new AliFlowTrack();
+ flowtrack->SetPhi(fTrackPhi);
+ flowtrack->SetEta(fTrackEta);
+ break;
+ case kTrackWithMCkine:
+ if (!fMCparticle) return NULL;
+ flowtrack = new AliFlowTrack();
+ flowtrack->SetPhi( fMCparticle->Phi() );
+ flowtrack->SetEta( fMCparticle->Eta() );
+ flowtrack->SetPt( fMCparticle->Pt() );
+ break;
+ case kTrackWithMCpt:
+ if (!fMCparticle) return NULL;
+ flowtrack = new AliFlowTrack();
+ flowtrack->SetPhi(fTrackPhi);
+ flowtrack->SetEta(fTrackEta);
+ flowtrack->SetPt(fMCparticle->Pt());
+ break;
+ case kTrackWithPtFromFirstMother:
+ if (!fMCparticle) return NULL;
+ flowtrack = new AliFlowTrack();
+ flowtrack->SetPhi(fTrackPhi);
+ flowtrack->SetEta(fTrackEta);
+ tmpTParticle = fMCparticle->Particle();
+ tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
+ flowtrack->SetPt(tmpAliMCParticle->Pt());
+ default:
+ flowtrack = new AliFlowTrack();
+ flowtrack->SetPhi(fTrackPhi);
+ flowtrack->SetEta(fTrackEta);
+ }
+ flowtrack->SetSource(AliFlowTrack::kFromTracklet);
+ }
+ else
+ {
+ if (!fTrack) return NULL;
+ switch(fParamMix)
+ {
+ case kPure:
+ flowtrack = new AliFlowTrack(fTrack);
+ break;
+ case kTrackWithMCkine:
+ flowtrack = new AliFlowTrack(fMCparticle);
+ break;
+ case kTrackWithMCPID:
+ flowtrack = new AliFlowTrack(fTrack);
+ //flowtrack->setPID(...) from mc, when implemented
+ break;
+ case kTrackWithMCpt:
+ if (!fMCparticle) return NULL;
+ flowtrack = new AliFlowTrack(fTrack);
+ flowtrack->SetPt(fMCparticle->Pt());
+ case kTrackWithPtFromFirstMother:
+ if (!fMCparticle) return NULL;
+ flowtrack = new AliFlowTrack(fTrack);
+ tmpTParticle = fMCparticle->Particle();
+ tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
+ flowtrack->SetPt(tmpAliMCParticle->Pt());
+ default:
+ flowtrack = new AliFlowTrack(fTrack);
+ }
+ if (fParamType==kMC) flowtrack->SetSource(AliFlowTrack::kFromMC);
+ else if (dynamic_cast<AliESDtrack*>(fTrack)) flowtrack->SetSource(AliFlowTrack::kFromESD);
+ else if (dynamic_cast<AliAODTrack*>(fTrack)) flowtrack->SetSource(AliFlowTrack::kFromAOD);
+ else if (dynamic_cast<AliMCParticle*>(fTrack)) flowtrack->SetSource(AliFlowTrack::kFromMC);
}
- if (fParamType==kMC) flowtrack->SetSource(AliFlowTrack::kFromMC);
- else if (dynamic_cast<AliMCParticle*>(fTrack)) flowtrack->SetSource(AliFlowTrack::kFromMC);
- else if (dynamic_cast<AliESDtrack*>(fTrack)) flowtrack->SetSource(AliFlowTrack::kFromESD);
- else if (dynamic_cast<AliAODTrack*>(fTrack)) flowtrack->SetSource(AliFlowTrack::kFromAOD);
return flowtrack;
}
Bool_t AliFlowTrackCuts::IsPhysicalPrimary() const
{
//check if current particle is a physical primary
- return fMCevent->IsPhysicalPrimary(fTrackLabel);
+ if (!fMCevent) return kFALSE;
+ if (fTrackLabel<0) return kFALSE;
+ return IsPhysicalPrimary(fMCevent, fTrackLabel);
+}
+
+//-----------------------------------------------------------------------
+Bool_t AliFlowTrackCuts::IsPhysicalPrimary(AliMCEvent* mcEvent, Int_t label)
+{
+ //check if current particle is a physical primary
+ Bool_t physprim=mcEvent->IsPhysicalPrimary(label);
+ if (!physprim) return kFALSE;
+ AliMCParticle* track = static_cast<AliMCParticle*>(mcEvent->GetTrack(label));
+ if (!track) return kFALSE;
+ TParticle* particle = track->Particle();
+ Bool_t transported = particle->TestBit(kTransportBit);
+ //printf("prim: %s, transp: %s\n",(physprim)?"YES":"NO ",(transported)?"YES":"NO ");
+ return (physprim && transported);
+}
+
+//-----------------------------------------------------------------------
+const char* AliFlowTrackCuts::GetParamTypeName(trackParameterType type)
+{
+ //return the name of the selected parameter type
+ switch (type)
+ {
+ case kMC:
+ return "MC";
+ case kGlobal:
+ return "ESD global";
+ case kESD_TPConly:
+ return "TPC only";
+ case kESD_SPDtracklet:
+ return "SPD tracklet";
+ default:
+ return "unknown";
+ }
+ return "unknown";
+}
+
+//-----------------------------------------------------------------------
+void AliFlowTrackCuts::DefineHistograms()
+{
+}
+
+//-----------------------------------------------------------------------
+Int_t AliFlowTrackCuts::GetNumberOfInputObjects() const
+{
+ //get the number of tracks in the input event according source
+ //selection (ESD tracks, tracklets, MC particles etc.)
+ AliESDEvent* esd=NULL;
+ switch (fParamType)
+ {
+ case kESD_SPDtracklet:
+ esd = dynamic_cast<AliESDEvent*>(fEvent);
+ if (!esd) return 0;
+ return esd->GetMultiplicity()->GetNumberOfTracklets();
+ case kMC:
+ if (!fMCevent) return 0;
+ return fMCevent->GetNumberOfTracks();
+ default:
+ if (!fEvent) return 0;
+ return fEvent->GetNumberOfTracks();
+ }
+ return 0;
+}
+
+//-----------------------------------------------------------------------
+TObject* AliFlowTrackCuts::GetInputObject(Int_t i)
+{
+ //get the input object according the data source selection:
+ //(esd tracks, traclets, mc particles,etc...)
+ AliESDEvent* esd=NULL;
+ switch (fParamType)
+ {
+ case kESD_SPDtracklet:
+ esd = dynamic_cast<AliESDEvent*>(fEvent);
+ if (!esd) return NULL;
+ return const_cast<AliMultiplicity*>(esd->GetMultiplicity());
+ case kMC:
+ if (!fMCevent) return NULL;
+ return fMCevent->GetTrack(i);
+ default:
+ if (!fEvent) return NULL;
+ return fEvent->GetTrack(i);
+ }
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff