}
//__________________________________________________________________________________________________
-AliRsnAnalysisTask::AliRsnAnalysisTask(const AliRsnAnalysisTask& copy) :
+AliRsnAnalysisTask::AliRsnAnalysisTask(const AliRsnAnalysisTask ©) :
AliAnalysisTaskSE(copy),
fOutput(0),
fRsnObjects(copy.fRsnObjects),
}
//__________________________________________________________________________________________________
-AliRsnAnalysisTask& AliRsnAnalysisTask::operator=(const AliRsnAnalysisTask& copy)
+AliRsnAnalysisTask &AliRsnAnalysisTask::operator=(const AliRsnAnalysisTask ©)
{
//
// Assignment operator.
//
AliAnalysisTaskSE::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fRsnObjects = copy.fRsnObjects;
fInputEHMain = copy.fInputEHMain;
fInputEHMix = copy.fInputEHMix;
fBigOutput = copy.fBigOutput;
-
+
return (*this);
}
AliRsnAnalysisTask::~AliRsnAnalysisTask()
{
//
-// Destructor.
+// Destructor.
// Clean-up the output list, but not the histograms that are put inside
// (the list is owner and will clean-up these histograms). Protect in PROOF case.
//
if (fBigOutput) OpenFile(1);
fOutput = new TList();
fOutput->SetOwner();
-
+
// loop on computators and initialize all their outputs
TObjArrayIter next(&fRsnObjects);
- AliRsnLoop *obj = 0x0;
- while ( (obj = (AliRsnLoop*)next()) ) {
- obj->Init(GetName(), fOutput);
+ AliRsnLoop *objLoop = 0x0;
+ while ( (objLoop = (AliRsnLoop *)next()) ) {
+ objLoop->Init(GetName(), fOutput);
}
+ if (fInputEHMain) {
+ TObjArrayIter nextIH(fInputEHMain->InputEventHandlers());
+ TObject *obj = 0x0;
+ while ( (obj = nextIH()) ) {
+ if (obj->IsA() == AliRsnInputHandler::Class()) {
+ AliRsnInputHandler *rsnIH = (AliRsnInputHandler *) obj;
+ AliRsnDaughterSelector *s = rsnIH->GetSelector();
+ TClonesArray *c = s->GetCutSetC();
+ for (Int_t is = 0; is < c->GetEntries(); is++) {
+ AliRsnCutSet *cuts = (AliRsnCutSet *)c->At(is);
+ cuts->Init(fOutput);
+ }
+ }
+ }
+ }
+
+
// post data for ALL output slots >0 here, to get at least an empty histogram
PostData(1, fOutput);
}
TObject *obj = 0x0;
while ( (obj = next()) ) {
if (obj->IsA() == AliRsnInputHandler::Class()) {
- rsnIH = (AliRsnInputHandler*)obj;
+ rsnIH = (AliRsnInputHandler *)obj;
//AliInfo(Form("Found object '%s' which is RSN input handler", obj->GetName()));
evMain = rsnIH->GetRsnEvent();
break;
}
}
}
-
+
if (!evMain) return;
TObjArrayIter next(&fRsnObjects);
AliRsnLoop *obj = 0x0;
- while ( (obj = (AliRsnLoop*)next()) ) {
+ while ( (obj = (AliRsnLoop *)next()) ) {
if (obj->IsMixed()) continue;
obj->DoLoop(evMain, rsnIH->GetSelector());
}
-
+
PostData(1, fOutput);
}
//__________________________________________________________________________________________________
-void AliRsnAnalysisTask::UserExecMix(Option_t*)
+void AliRsnAnalysisTask::UserExecMix(Option_t *)
{
//
// Main loop for event-mixing computations
TObject *obj = 0x0;
while ( (obj = next()) ) {
if (obj->IsA() == AliRsnInputHandler::Class()) {
- rsnIH = (AliRsnInputHandler*)obj;
+ rsnIH = (AliRsnInputHandler *)obj;
//AliInfo(Form("Found object '%s' which is RSN input handler", obj->GetName()));
evMain = rsnIH->GetRsnEvent();
id = fInputEHMain->InputEventHandlers()->IndexOf(obj);
}
}
}
-
+
if (!evMain) return;
// gets first input handler form mixing buffer
- AliMultiInputEventHandler *ihMultiMix = dynamic_cast<AliMultiInputEventHandler*>(fInputEHMix->InputEventHandler(0));
+ AliMultiInputEventHandler *ihMultiMix = dynamic_cast<AliMultiInputEventHandler *>(fInputEHMix->InputEventHandler(0));
if (ihMultiMix) {
- rsnMixIH = dynamic_cast<AliRsnInputHandler*>(ihMultiMix->InputEventHandler(id));
+ rsnMixIH = dynamic_cast<AliRsnInputHandler *>(ihMultiMix->InputEventHandler(id));
if (rsnMixIH) {
evMix = rsnMixIH->GetRsnEvent();
if (!evMix) return;
TObjArrayIter next(&fRsnObjects);
AliRsnLoop *obj = 0x0;
- while ( (obj = (AliRsnLoop*)next()) ) {
+ while ( (obj = (AliRsnLoop *)next()) ) {
if (!obj->IsMixed()) continue;
obj->DoLoop(evMain, rsnIH->GetSelector(), evMix, rsnMixIH->GetSelector());
}
}
}
-
+
PostData(1, fOutput);
}
// Called once at the end of the query
//
- fOutput = dynamic_cast<TList*>(GetOutputData(1));
+ fOutput = dynamic_cast<TList *>(GetOutputData(1));
if (!fOutput) { AliError("Could not retrieve TList fOutput"); return; }
}
AliRsnAnalysisTask();
AliRsnAnalysisTask(const char *name);
- AliRsnAnalysisTask(const AliRsnAnalysisTask&);
- AliRsnAnalysisTask& operator=(const AliRsnAnalysisTask&);
+ AliRsnAnalysisTask(const AliRsnAnalysisTask &);
+ AliRsnAnalysisTask &operator=(const AliRsnAnalysisTask &);
virtual ~AliRsnAnalysisTask();
virtual void UserCreateOutputObjects();
virtual void UserExec(Option_t *option);
- virtual void UserExecMix(Option_t*);
+ virtual void UserExecMix(Option_t *);
virtual void Terminate(Option_t *);
-
+
void AddLoop(AliRsnLoop *object);
void InitInputHandlers();
void UseBigOutput(Bool_t b=kTRUE) { fBigOutput = b; }
Bool_t IsBigOutput() { return fBigOutput; }
-
+
private:
TList *fOutput; // output list
}
//______________________________________________________________________________
-AliRsnCut::AliRsnCut(const AliRsnCut& copy) :
+AliRsnCut::AliRsnCut(const AliRsnCut ©) :
AliRsnTarget(copy),
fMinI(copy.fMinI),
fMaxI(copy.fMaxI),
}
//______________________________________________________________________________
-AliRsnCut& AliRsnCut::operator=(const AliRsnCut& copy)
+AliRsnCut &AliRsnCut::operator=(const AliRsnCut ©)
{
//
// Assignment operator.
// Don't duplicate memory occupancy for pointer
//
- AliRsnTarget::operator=(copy);
+ AliRsnTarget::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fMinI = copy.fMinI;
fMaxI = copy.fMaxI;
}
//______________________________________________________________________________
-void AliRsnCut::Print(Option_t*) const
+void AliRsnCut::Print(Option_t *) const
{
//
// Override TObject::Print() method,
AliRsnCut(const char *name = "dummy", RSNTARGET target = AliRsnTarget::kTargetTypes);
AliRsnCut(const char *name, RSNTARGET target, Int_t imin, Int_t imax = 0 , Double_t dmin = 0., Double_t dmax = 0.);
AliRsnCut(const char *name, RSNTARGET target, Double_t dmin, Double_t dmax = 0., Int_t imin = 0 , Int_t imax = 0);
- AliRsnCut(const AliRsnCut& copy);
- AliRsnCut& operator=(const AliRsnCut& copy);
+ AliRsnCut(const AliRsnCut ©);
+ AliRsnCut &operator=(const AliRsnCut ©);
virtual ~AliRsnCut() { };
Int_t GetMinI() const {return fMinI;}
// coherence check
if (!TargetOK(obj)) return kFALSE;
-
+
// check track
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
if (!track) return kFALSE;
-
+
// check flags
if ((track->GetStatus() & AliESDtrack::kTPCin ) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) return kFALSE;
-
+
// quality
if (!fCutQuality.IsSelected(obj)) return kFALSE;
-
+
// if no PID is required, accept
if (fNoPID) return kTRUE;
-
+
// check initialization of PID object
AliPIDResponse *pid = fEvent->GetPIDResponse();
if (!pid) {
AliFatal("NULL PID response");
return kFALSE;
}
-
+
// check if TOF is matched
// and computes all values used in the PID cut
Bool_t isTOF = MatchTOF(track);
Double_t nsTOF = isTOF ? TMath::Abs(pid->NumberOfSigmasTOF(track, fPID)) : 1E20;
Double_t maxTPC = 1E20;
Double_t maxTOF = 1E20;
-
+
// applies the cut differently depending on the PID and the momentum
if (isTOF) {
// TPC: 5sigma cut for all
if (p < 1.5) maxTOF = 3.0; else maxTOF = 2.0;
return (nsTOF <= maxTOF);
} else {
- // TPC:
+ // TPC:
// all below 350 MeV: 5sigma
// all between 350 and 500 MeV: 3sigma
// pions above 500 MeV: 2sigma
// kaons between 500 and 700 MeV: 2sigma
// kaons above 700 MeV: rejected
- if (pTPC <= 0.35)
+ if (pTPC <= 0.35)
maxTPC = 5.0;
else if (pTPC > 0.35 && pTPC <= 0.5)
maxTPC = 3.0;
- else {
- if (fPID == AliPID::kPion)
+ else {
+ if (fPID == AliPID::kPion)
maxTPC = 2.0;
else if (fPID == AliPID::kKaon) {
if (pTPC <= 0.7)
AliRsnCutDaughterKStar2010PP(const char *name = "", AliPID::EParticleType pid = AliPID::kPion);
virtual ~AliRsnCutDaughterKStar2010PP() { }
-
+
void SetNoPID(Bool_t yn = kTRUE) {fNoPID = yn;}
-
+
void SetPID(AliPID::EParticleType type) {fPID = type;}
AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
Bool_t MatchTOF(const AliVTrack *vtrack);
private:
Bool_t fNoPID; // flag to switch off PID check
-
+
AliPID::EParticleType fPID; // PID for track
AliRsnCutTrackQuality fCutQuality; // track quality cut
// coherence check
if (!TargetOK(obj)) return kFALSE;
-
+
// check track
AliVTrack *track = fDaughter->Ref2Vtrack();
if (!track) {
if (!fDaughter->GetRef()) AliWarning("NULL ref");
return kFALSE;
}
-
+
// check flags
if ((track->GetStatus() & AliESDtrack::kTPCin ) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) return kFALSE;
-
+
// quality
if (!fCutQuality.IsSelected(obj)) return kFALSE;
-
+
// check initialization of PID object
AliPIDResponse *pid = fEvent->GetPIDResponse();
if (!pid) {
AliFatal("NULL PID response");
return kFALSE;
}
-
+
// check if TOF is matched
// and computes all values used in the PID cut
Bool_t isTOF = MatchTOF(track);
Double_t nsTOF = TMath::Abs(pid->NumberOfSigmasTOF(track, fPID));
Double_t maxTPC = 1E20;
Double_t maxTOF = 1E20;
-
+
// applies the cut differently depending on the PID and the momentum
if (isTOF) {
// TPC: 5sigma cut for all
if (p < 1.5) maxTOF = 3.0; else maxTOF = 2.0;
return (nsTOF <= maxTOF);
} else {
- // TPC:
+ // TPC:
// below 350 MeV: 5sigma
// between 350 and 500 MeV: 3sigma
// pions above 500 MeV: 2sigma
// kaons between 500 and 700 MeV: 2sigma
// kaons above 700 MeV: rejected
// protons above 1200 MeV: rejected
- if (pTPC <= 0.35)
+ if (pTPC <= 0.35)
maxTPC = 5.0;
else if (pTPC <= 0.5)
maxTPC = 3.0;
AliRsnCutDaughterLStar2010(const char *name = "", AliPID::EParticleType pid = AliPID::kKaon);
virtual ~AliRsnCutDaughterLStar2010() { }
-
+
void SetPID(AliPID::EParticleType type) {fPID = type;}
AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
Bool_t MatchTOF(const AliVTrack *vtrack);
// coherence check
if (!TargetOK(obj)) return kFALSE;
-
+
// check track
AliVTrack *track = fDaughter->Ref2Vtrack();
if (!track) {
if (!fDaughter->GetRef()) AliWarning("NULL ref");
return kFALSE;
}
-
+
// check flags
if ((track->GetStatus() & AliESDtrack::kTPCin ) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) return kFALSE;
-
+
// quality
if (!fCutQuality.IsSelected(obj)) return kFALSE;
-
+
// check initialization of PID object
AliPIDResponse *pid = fEvent->GetPIDResponse();
if (!pid) {
AliFatal("NULL PID response");
return kFALSE;
}
-
+
// check if TOF is matched
// and computes all values used in the PID cut
//Bool_t isTOF = MatchTOF(track);
//Double_t nsTOF = TMath::Abs(pid->NumberOfSigmasTOF(track, fPID));
//*Double_t maxTPC = 1E20;
//Double_t maxTOF = 1E20;
-
+
// applies the cut differently depending on the PID and the momentum
//if (isTOF) {
- // TPC: 5sigma cut for all
- //if (nsTPC > 5.0) return kFALSE;
- // TOF: 3sigma below 1.5 GeV, 2sigma above
- //if (p < 1.5) maxTOF = 3.0; else maxTOF = 2.0;
- //return (nsTOF <= maxTOF);
+ // TPC: 5sigma cut for all
+ //if (nsTPC > 5.0) return kFALSE;
+ // TOF: 3sigma below 1.5 GeV, 2sigma above
+ //if (p < 1.5) maxTOF = 3.0; else maxTOF = 2.0;
+ //return (nsTOF <= maxTOF);
//} else {
-
+
//For the moment TOF is not used - PID ONLY WITH TPC - 3 sigmas in the whole range
-
- // TPC:
- // below 350 MeV: 5sigma
- // between 350 and 500 MeV: 3sigma
- // pions above 500 MeV: 2sigma
- // kaons between 500 and 700 MeV: 2sigma
- // kaons above 700 MeV: rejected
- /*if (pTPC <= 0.35)
- maxTPC = 5.0;
- else if (pTPC <= 0.5)
- maxTPC = 3.0;
- else if (pTPC > 0.5 && fPID == AliPID::kPion)
- maxTPC = 2.0;
- else if (pTPC > 0.5 && pTPC <= 0.7 && fPID == AliPID::kKaon)
- maxTPC = 2.0;
- else
- return kFALSE;*/
- //* maxTPC = 3.0;
- //*return (nsTPC <= maxTPC);
-
+
+ // TPC:
+ // below 350 MeV: 5sigma
+ // between 350 and 500 MeV: 3sigma
+ // pions above 500 MeV: 2sigma
+ // kaons between 500 and 700 MeV: 2sigma
+ // kaons above 700 MeV: rejected
+ /*if (pTPC <= 0.35)
+ maxTPC = 5.0;
+ else if (pTPC <= 0.5)
+ maxTPC = 3.0;
+ else if (pTPC > 0.5 && fPID == AliPID::kPion)
+ maxTPC = 2.0;
+ else if (pTPC > 0.5 && pTPC <= 0.7 && fPID == AliPID::kKaon)
+ maxTPC = 2.0;
+ else
+ return kFALSE;*/
+ //* maxTPC = 3.0;
+ //*return (nsTPC <= maxTPC);
+
AliDebugClass(2, "Good Pion (hallelujah)");
return kTRUE;
- }
+}
AliRsnCutDaughterSigmaStar2010PP(const char *name = "", AliPID::EParticleType pid = AliPID::kPion);
virtual ~AliRsnCutDaughterSigmaStar2010PP() { }
-
+
void SetPID(AliPID::EParticleType type) {fPID = type;}
AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
Bool_t MatchTOF(const AliVTrack *vtrack);
ClassImp(AliRsnCutKaon)
-const char* AliRsnCutKaon::fgkCutName[AliRsnCutKaon::kNkaonCuts]={
- "kQuality_Std2010",
- "kTOFMatch_Std2010",
- "kFastTPCpid_Nsigma",
- "kFastTPCpid_1point5sigma",
- "kFastTPCpid_2sigma",
- "kFastTPCpid_3sigma",
- "kFastTOFpid_Nsigma",
- "kFastTOFpid_1point5sigma",
- "kFastTOFpid_2sigma",
- "kFastTOFpid_3sigma",
- "kTPCTOFpid_DefaultKstarPP2010"
+const char *AliRsnCutKaon::fgkCutName[AliRsnCutKaon::kNkaonCuts]= {
+ "kQuality_Std2010",
+ "kTOFMatch_Std2010",
+ "kFastTPCpid_Nsigma",
+ "kFastTPCpid_1point5sigma",
+ "kFastTPCpid_2sigma",
+ "kFastTPCpid_3sigma",
+ "kFastTOFpid_Nsigma",
+ "kFastTOFpid_1point5sigma",
+ "kFastTOFpid_2sigma",
+ "kFastTOFpid_3sigma",
+ "kTPCTOFpid_DefaultKstarPP2010"
};
//__________________________________________________________________________________________________
AliRsnCutKaon::AliRsnCutKaon(const char *name, AliRsnCutKaon::ERsnKaonCut cutID, AliPID::EParticleType pid) :
- AliRsnCut(name, AliRsnTarget::kDaughter),
- fNoPID(kFALSE),
- fPID(pid),
- fCutQuality(Form("%sQuality", name)),
- fAppliedCutID(cutID),
- fNsigmaCutTPC(1E6),
- fNsigmaCutTOF(1E6)
+ AliRsnCut(name, AliRsnTarget::kDaughter),
+ fNoPID(kFALSE),
+ fPID(pid),
+ fCutQuality(Form("%sQuality", name)),
+ fAppliedCutID(cutID),
+ fNsigmaCutTPC(1E6),
+ fNsigmaCutTOF(1E6)
{
- //
- // Constructor
- // Initialize track quality cuts to 2010 defaults
- //
- fCutQuality.SetPtRange(0.15, 1E+20);
- fCutQuality.SetEtaRange(-0.8, 0.8);
- fCutQuality.SetDCARPtFormula("0.0182+0.0350/pt^1.01");
- fCutQuality.SetDCAZmax(2.0);
- fCutQuality.SetSPDminNClusters(1);
- fCutQuality.SetITSminNClusters(0);
- fCutQuality.SetITSmaxChi2(1E+20);
- fCutQuality.SetTPCminNClusters(70);
- fCutQuality.SetTPCmaxChi2(4.0);
- fCutQuality.SetRejectKinkDaughters();
- fCutQuality.SetAODTestFilterBit(5);
- AliInfo(Form("Applied cut on kaon candidate: %s", AliRsnCutKaon::fgkCutName[fAppliedCutID]));
+ //
+ // Constructor
+ // Initialize track quality cuts to 2010 defaults
+ //
+ fCutQuality.SetPtRange(0.15, 1E+20);
+ fCutQuality.SetEtaRange(-0.8, 0.8);
+ fCutQuality.SetDCARPtFormula("0.0182+0.0350/pt^1.01");
+ fCutQuality.SetDCAZmax(2.0);
+ fCutQuality.SetSPDminNClusters(1);
+ fCutQuality.SetITSminNClusters(0);
+ fCutQuality.SetITSmaxChi2(1E+20);
+ fCutQuality.SetTPCminNClusters(70);
+ fCutQuality.SetTPCmaxChi2(4.0);
+ fCutQuality.SetRejectKinkDaughters();
+ fCutQuality.SetAODTestFilterBit(5);
+ AliInfo(Form("Applied cut on kaon candidate: %s", AliRsnCutKaon::fgkCutName[fAppliedCutID]));
}
//__________________________________________________________________________________________________
//
// coherence check
if (!TargetOK(obj)) return kFALSE;
-
+
// check track
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
if (!track) return kFALSE;
-
+
Bool_t isSelected=kFALSE;
switch (fAppliedCutID)
- {
- case AliRsnCutKaon::kQualityStd2010:
- isSelected=IsSelectedByQualityStd2010(obj, 1, 1, 1);
- break;
-
- case AliRsnCutKaon::kTOFMatchStd2010:
- isSelected=IsSelectedByTOFMatchStd2010(obj);
- break;
-
- case AliRsnCutKaon::kFastTPCpidNsigma:
- isSelected=IsSelectedByFastTPCpidNsigma(obj,fNsigmaCutTPC);
- break;
-
- case AliRsnCutKaon::kFastTPCpid1point5sigma:
- isSelected=IsSelectedByFastTPCpid1point5sigma(obj);
- break;
-
- case AliRsnCutKaon::kFastTPCpid2sigma:
- isSelected=IsSelectedByFastTPCpid2sigma(obj);
- break;
-
- case AliRsnCutKaon::kFastTPCpid3sigma:
- isSelected=IsSelectedByFastTPCpid3sigma(obj);
- break;
-
- case AliRsnCutKaon::kFastTOFpidNsigma:
- isSelected=IsSelectedByFastTOFpidNsigma(obj,fNsigmaCutTOF);
- break;
-
- case AliRsnCutKaon::kFastTOFpid1point5sigma:
- isSelected=IsSelectedByFastTOFpid1point5sigma(obj);
- break;
-
- case AliRsnCutKaon::kFastTOFpid2sigma:
- isSelected=IsSelectedByFastTOFpid2sigma(obj);
- break;
-
- case AliRsnCutKaon::kFastTOFpid3sigma:
- isSelected=IsSelectedByFastTOFpid3sigma(obj);
- break;
-
- case AliRsnCutKaon::kTPCTOFpidDefaultKstarPP2010:
- isSelected=IsSelectedByTPCTOFpidDefaultKstarPP2010(obj);
- break;
-
- default :
- break;
- }
-
+ {
+ case AliRsnCutKaon::kQualityStd2010:
+ isSelected=IsSelectedByQualityStd2010(obj, 1, 1, 1);
+ break;
+
+ case AliRsnCutKaon::kTOFMatchStd2010:
+ isSelected=IsSelectedByTOFMatchStd2010(obj);
+ break;
+
+ case AliRsnCutKaon::kFastTPCpidNsigma:
+ isSelected=IsSelectedByFastTPCpidNsigma(obj,fNsigmaCutTPC);
+ break;
+
+ case AliRsnCutKaon::kFastTPCpid1point5sigma:
+ isSelected=IsSelectedByFastTPCpid1point5sigma(obj);
+ break;
+
+ case AliRsnCutKaon::kFastTPCpid2sigma:
+ isSelected=IsSelectedByFastTPCpid2sigma(obj);
+ break;
+
+ case AliRsnCutKaon::kFastTPCpid3sigma:
+ isSelected=IsSelectedByFastTPCpid3sigma(obj);
+ break;
+
+ case AliRsnCutKaon::kFastTOFpidNsigma:
+ isSelected=IsSelectedByFastTOFpidNsigma(obj,fNsigmaCutTOF);
+ break;
+
+ case AliRsnCutKaon::kFastTOFpid1point5sigma:
+ isSelected=IsSelectedByFastTOFpid1point5sigma(obj);
+ break;
+
+ case AliRsnCutKaon::kFastTOFpid2sigma:
+ isSelected=IsSelectedByFastTOFpid2sigma(obj);
+ break;
+
+ case AliRsnCutKaon::kFastTOFpid3sigma:
+ isSelected=IsSelectedByFastTOFpid3sigma(obj);
+ break;
+
+ case AliRsnCutKaon::kTPCTOFpidDefaultKstarPP2010:
+ isSelected=IsSelectedByTPCTOFpidDefaultKstarPP2010(obj);
+ break;
+
+ default :
+ break;
+ }
+
return isSelected;
}
//-----------------------------------------------------------
Bool_t AliRsnCutKaon::IsSelectedByQualityStd2010(TObject *obj, Bool_t requireTPCin=kTRUE, Bool_t requireTPCrefit=kTRUE, Bool_t requireITSrefit=kTRUE)
{
- //Checks if track passes the standard quality cuts
- //defined for analysis in 2010 pp and PbPb data
-
- if (!obj) {
- AliError("Invalid track object passed to function. Please check!");
- return kFALSE;
- }
-
- fAppliedCutID= AliRsnCutKaon::kQualityStd2010;
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
+ //Checks if track passes the standard quality cuts
+ //defined for analysis in 2010 pp and PbPb data
+
+ if (!obj) {
+ AliError("Invalid track object passed to function. Please check!");
+ return kFALSE;
+ }
+
+ fAppliedCutID= AliRsnCutKaon::kQualityStd2010;
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
if (!track) return kFALSE;
-
- //optionally check refit flags (to be used for Phi and kStar analysis)
- if (requireTPCin && ((track->GetStatus() & AliESDtrack::kTPCin) == 0) ) return kFALSE;
- if (requireTPCrefit && ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) ) return kFALSE;
- if (requireITSrefit && ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) ) return kFALSE;
-
- // quality
- if (!fCutQuality.IsSelected(obj)) return kFALSE;
- return kTRUE;
+
+ //optionally check refit flags (to be used for Phi and kStar analysis)
+ if (requireTPCin && ((track->GetStatus() & AliESDtrack::kTPCin) == 0) ) return kFALSE;
+ if (requireTPCrefit && ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) ) return kFALSE;
+ if (requireITSrefit && ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) ) return kFALSE;
+
+ // quality
+ if (!fCutQuality.IsSelected(obj)) return kFALSE;
+ return kTRUE;
}
//-----------------------------------------------------------
Bool_t AliRsnCutKaon::IsSelectedByTOFMatchStd2010(TObject *obj)
{
- /*
- fbellini@cern.ch, 05.dec.2011
- definition of TOF match: quality cuts 2010 + kTOFout + kTIME
- (optionally) L > 350. cm cut can be added
- */
+ /*
+ fbellini@cern.ch, 05.dec.2011
+ definition of TOF match: quality cuts 2010 + kTOFout + kTIME
+ (optionally) L > 350. cm cut can be added
+ */
if (!obj) {
- AliError("Invalid track object passed to function. Please check!");
- return kFALSE;
+ AliError("Invalid track object passed to function. Please check!");
+ return kFALSE;
}
fAppliedCutID=AliRsnCutKaon::kTOFMatchStd2010;
-
+
if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE))
- return kFALSE;
-
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
+ return kFALSE;
+
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
if (!track) return kFALSE;
return MatchTOF(track);
}
//-----------------------------------------------------------
Bool_t AliRsnCutKaon::IsSelectedByFastTPCpidNsigma(TObject *obj,Float_t nSigmaCut=10.)
{
- /*
- fbellini@cern.ch, 05.dec.2011 Double_t pTPC = track->GetTPCmomentum();
- definition of fast TPC pid N-sigma: quality cuts 2010 + sigma cut on dE/dx without p dependence
- */
- if (!obj) {
- AliError("Invalid track object passed to function. Please check!");
- return kFALSE;
- }
- fAppliedCutID=AliRsnCutKaon::kFastTPCpidNsigma;
-
- // check initialization of PID object
- AliPIDResponse *pid = fEvent->GetPIDResponse();
- if (!pid) {
- AliFatal("NULL PID response");
- return kFALSE;
- }
-
- if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE))
- return kFALSE;
-
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
- if (!track) return kFALSE;
-
- Double_t nsTPC = TMath::Abs(pid->NumberOfSigmasTPC(track,fPID));
- return (nsTPC <= nSigmaCut);
+ /*
+ fbellini@cern.ch, 05.dec.2011 Double_t pTPC = track->GetTPCmomentum();
+ definition of fast TPC pid N-sigma: quality cuts 2010 + sigma cut on dE/dx without p dependence
+ */
+ if (!obj) {
+ AliError("Invalid track object passed to function. Please check!");
+ return kFALSE;
+ }
+ fAppliedCutID=AliRsnCutKaon::kFastTPCpidNsigma;
+
+ // check initialization of PID object
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ if (!pid) {
+ AliFatal("NULL PID response");
+ return kFALSE;
+ }
+
+ if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE))
+ return kFALSE;
+
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
+ if (!track) return kFALSE;
+
+ Double_t nsTPC = TMath::Abs(pid->NumberOfSigmasTPC(track,fPID));
+ return (nsTPC <= nSigmaCut);
}
//-----------------------------------------------------------
Bool_t AliRsnCutKaon::IsSelectedByFastTOFpidNsigma(TObject *obj,Float_t nSigmaCut=10.)
{
- /*
- fbellini@cern.ch, 05.dec.2011
- definition of fast TOF pid N-sigma: quality cuts 2010 + sigma cut on t-t_0-t_exp without p dependence
- */
- if (!obj) {
- AliError("Invalid track object passed to function. Please check!");
- return kFALSE;
- }
-
- fAppliedCutID=AliRsnCutKaon::kFastTOFpidNsigma;
-
- // check initialization of PID object
- AliPIDResponse *pid = fEvent->GetPIDResponse();
- if (!pid) {
- AliFatal("NULL PID response");
- return kFALSE;
- }
-
- if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE))
- return kFALSE;
-
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
- if (!track) return kFALSE;
- Bool_t isTOF = MatchTOF(track);
- Double_t nsTOF = isTOF ? TMath::Abs(pid->NumberOfSigmasTOF(track, fPID)) : 1E20;
-
- return (nsTOF <= nSigmaCut);
+ /*
+ fbellini@cern.ch, 05.dec.2011
+ definition of fast TOF pid N-sigma: quality cuts 2010 + sigma cut on t-t_0-t_exp without p dependence
+ */
+ if (!obj) {
+ AliError("Invalid track object passed to function. Please check!");
+ return kFALSE;
+ }
+
+ fAppliedCutID=AliRsnCutKaon::kFastTOFpidNsigma;
+
+ // check initialization of PID object
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ if (!pid) {
+ AliFatal("NULL PID response");
+ return kFALSE;
+ }
+
+ if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE))
+ return kFALSE;
+
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
+ if (!track) return kFALSE;
+ Bool_t isTOF = MatchTOF(track);
+ Double_t nsTOF = isTOF ? TMath::Abs(pid->NumberOfSigmasTOF(track, fPID)) : 1E20;
+
+ return (nsTOF <= nSigmaCut);
}
//-----------------------------------------------------------
Bool_t AliRsnCutKaon::IsSelectedByTPCTOFpidDefaultKstarPP2010(TObject *obj)
{
- /*
- fbellini@cern.ch, 05.dec.2011
- definition of TPC-TOF pid for pp phi and Kstar analysis on 2010 data:
- quality cuts 2010 + sigma cut on dE/dx with pTPC dependence + sigma cut on t-t_0-t_exp with p dependence
- */
-
- if (!obj) {
- AliError("Invalid track object passed to function. Please check!");
- return kFALSE;
- }
- fAppliedCutID=AliRsnCutKaon::kTPCTOFpidDefaultKstarPP2010;
-
- // check initialization of PID object
- AliPIDResponse *pid = fEvent->GetPIDResponse();
- if (!pid) {
- AliFatal("NULL PID response");
- return kFALSE;
- }
-
- if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE)) //require ITS+TPCrefit and TPCin
- return kFALSE;
-
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
- if (!track) return kFALSE;
-
- Bool_t isTOF = MatchTOF(track);
- Double_t pTPC = track->GetTPCmomentum();
- Double_t p = track->P();
- Double_t nsTPC = TMath::Abs(pid->NumberOfSigmasTPC(track, fPID));
- Double_t nsTOF = isTOF ? TMath::Abs(pid->NumberOfSigmasTOF(track, fPID)) : 1E20;
- Double_t maxTPC = 1E20;
- Double_t maxTOF = 1E20;
-
- if (isTOF) {
- // TPC: 5sigma cut for all
- if (nsTPC > 5.0) return kFALSE;
- // TOF: 3sigma below 1.5 GeV, 2sigma above
- if (p < 1.5) maxTOF = 3.0; else maxTOF = 2.0;
- return (nsTOF <= maxTOF);
- } else {
- // TPC:
- // all below 350 MeV: 5sigma
- // all between 350 and 500 MeV: 3sigma
- // pios above 500 MeV: 2sigma
- // kaons between 500 and 700 MeV: 2sigma
- // kaons above 700 MeV: rejected
- if (pTPC <= 0.35)
- maxTPC = 5.0;
- else if (pTPC > 0.35 && pTPC <= 0.5)
- maxTPC = 3.0;
- else {
- if (pTPC <= 0.7) maxTPC = 2.0;
- else
- return kFALSE;
- }
- return (nsTPC <= maxTPC);
- }
+ /*
+ fbellini@cern.ch, 05.dec.2011
+ definition of TPC-TOF pid for pp phi and Kstar analysis on 2010 data:
+ quality cuts 2010 + sigma cut on dE/dx with pTPC dependence + sigma cut on t-t_0-t_exp with p dependence
+ */
+
+ if (!obj) {
+ AliError("Invalid track object passed to function. Please check!");
+ return kFALSE;
+ }
+ fAppliedCutID=AliRsnCutKaon::kTPCTOFpidDefaultKstarPP2010;
+
+ // check initialization of PID object
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ if (!pid) {
+ AliFatal("NULL PID response");
+ return kFALSE;
+ }
+
+ if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE)) //require ITS+TPCrefit and TPCin
+ return kFALSE;
+
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
+ if (!track) return kFALSE;
+
+ Bool_t isTOF = MatchTOF(track);
+ Double_t pTPC = track->GetTPCmomentum();
+ Double_t p = track->P();
+ Double_t nsTPC = TMath::Abs(pid->NumberOfSigmasTPC(track, fPID));
+ Double_t nsTOF = isTOF ? TMath::Abs(pid->NumberOfSigmasTOF(track, fPID)) : 1E20;
+ Double_t maxTPC = 1E20;
+ Double_t maxTOF = 1E20;
+
+ if (isTOF) {
+ // TPC: 5sigma cut for all
+ if (nsTPC > 5.0) return kFALSE;
+ // TOF: 3sigma below 1.5 GeV, 2sigma above
+ if (p < 1.5) maxTOF = 3.0; else maxTOF = 2.0;
+ return (nsTOF <= maxTOF);
+ } else {
+ // TPC:
+ // all below 350 MeV: 5sigma
+ // all between 350 and 500 MeV: 3sigma
+ // pios above 500 MeV: 2sigma
+ // kaons between 500 and 700 MeV: 2sigma
+ // kaons above 700 MeV: rejected
+ if (pTPC <= 0.35)
+ maxTPC = 5.0;
+ else if (pTPC > 0.35 && pTPC <= 0.5)
+ maxTPC = 3.0;
+ else {
+ if (pTPC <= 0.7) maxTPC = 2.0;
+ else
+ return kFALSE;
+ }
+ return (nsTPC <= maxTPC);
+ }
}
class AliRsnCutKaon : public AliRsnCut {
public:
- enum ERsnKaonCut {
- kQualityStd2010,
- kTOFMatchStd2010,
- kFastTPCpidNsigma,
- kFastTPCpid1point5sigma,
- kFastTPCpid2sigma,
- kFastTPCpid3sigma,
- kFastTOFpidNsigma,
- kFastTOFpid1point5sigma,
- kFastTOFpid2sigma,
- kFastTOFpid3sigma,
- kTPCTOFpidDefaultKstarPP2010,
- kNkaonCuts
- };
-
- AliRsnCutKaon(const char *name = "", AliRsnCutKaon::ERsnKaonCut cutID = AliRsnCutKaon::kQualityStd2010 , AliPID::EParticleType pid = AliPID::kKaon);
- virtual ~AliRsnCutKaon() { }
-
- void SetNoPID(Bool_t yn = kTRUE) {fNoPID = yn;}
- AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
- Bool_t MatchTOF(const AliVTrack *vtrack);
-
- Bool_t IsSelected(TObject *obj);
-
- Bool_t IsSelectedByQualityStd2010(TObject *obj, Bool_t requireTPCin, Bool_t requireTPCrefit, Bool_t requireITSrefit );
- Bool_t IsSelectedByTOFMatchStd2010(TObject *obj);
-
- Bool_t IsSelectedByFastTPCpidNsigma(TObject *obj,Float_t nSigmaCut);
- Bool_t IsSelectedByFastTPCpid1point5sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 1.5);}
- Bool_t IsSelectedByFastTPCpid2sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 2.0);}
- Bool_t IsSelectedByFastTPCpid3sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 3.0);}
-
- Bool_t IsSelectedByFastTOFpidNsigma(TObject *obj,Float_t nSigmaCut);
- Bool_t IsSelectedByFastTOFpid1point5sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 1.5);}
- Bool_t IsSelectedByFastTOFpid2sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 2.0);}
- Bool_t IsSelectedByFastTOFpid3sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 3.0);}
-
- Bool_t IsSelectedByTPCTOFpidDefaultKstarPP2010(TObject *obj);
-
- //setters
- void SetNsigmaCutTPC(Float_t nMaxSigmaCut=1E6){fNsigmaCutTPC=nMaxSigmaCut; return;}
- void SetNsigmaCutTOF(Float_t nMaxSigmaCut=1E6){fNsigmaCutTOF=nMaxSigmaCut; return;}
-
- //getters
- const char * GetAppliedKaonCutName() { if (fAppliedCutID>0){ return fgkCutName[fAppliedCutID];} else {return "none";}}
- Int_t GetAppliedKaonCutId() { return fAppliedCutID;}
- const char * GetKaonCutName(const AliRsnCutKaon::ERsnKaonCut cutID) { return fgkCutName[cutID];}
-
- private:
-
- Bool_t fNoPID; // flag to switch off PID check
- AliPID::EParticleType fPID; // PID for track
- AliRsnCutTrackQuality fCutQuality; // track quality cut
- Int_t fAppliedCutID; // ID of applied cut
- static const char* fgkCutName[kNkaonCuts]; //array with cuts names
- Float_t fNsigmaCutTPC; // max sigma for TPC dE/dx fast cut
- Float_t fNsigmaCutTOF; // max sigma for TOF t-t0-t_exp fast cut
-
- ClassDef(AliRsnCutKaon, 1) // cut definitions for K*
-
+ enum ERsnKaonCut {
+ kQualityStd2010,
+ kTOFMatchStd2010,
+ kFastTPCpidNsigma,
+ kFastTPCpid1point5sigma,
+ kFastTPCpid2sigma,
+ kFastTPCpid3sigma,
+ kFastTOFpidNsigma,
+ kFastTOFpid1point5sigma,
+ kFastTOFpid2sigma,
+ kFastTOFpid3sigma,
+ kTPCTOFpidDefaultKstarPP2010,
+ kNkaonCuts
+ };
+
+ AliRsnCutKaon(const char *name = "", AliRsnCutKaon::ERsnKaonCut cutID = AliRsnCutKaon::kQualityStd2010 , AliPID::EParticleType pid = AliPID::kKaon);
+ virtual ~AliRsnCutKaon() { }
+
+ void SetNoPID(Bool_t yn = kTRUE) {fNoPID = yn;}
+ AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
+ Bool_t MatchTOF(const AliVTrack *vtrack);
+
+ Bool_t IsSelected(TObject *obj);
+
+ Bool_t IsSelectedByQualityStd2010(TObject *obj, Bool_t requireTPCin, Bool_t requireTPCrefit, Bool_t requireITSrefit );
+ Bool_t IsSelectedByTOFMatchStd2010(TObject *obj);
+
+ Bool_t IsSelectedByFastTPCpidNsigma(TObject *obj,Float_t nSigmaCut);
+ Bool_t IsSelectedByFastTPCpid1point5sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 1.5);}
+ Bool_t IsSelectedByFastTPCpid2sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 2.0);}
+ Bool_t IsSelectedByFastTPCpid3sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 3.0);}
+
+ Bool_t IsSelectedByFastTOFpidNsigma(TObject *obj,Float_t nSigmaCut);
+ Bool_t IsSelectedByFastTOFpid1point5sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 1.5);}
+ Bool_t IsSelectedByFastTOFpid2sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 2.0);}
+ Bool_t IsSelectedByFastTOFpid3sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 3.0);}
+
+ Bool_t IsSelectedByTPCTOFpidDefaultKstarPP2010(TObject *obj);
+
+ //setters
+ void SetNsigmaCutTPC(Float_t nMaxSigmaCut=1E6) {fNsigmaCutTPC=nMaxSigmaCut; return;}
+ void SetNsigmaCutTOF(Float_t nMaxSigmaCut=1E6) {fNsigmaCutTOF=nMaxSigmaCut; return;}
+
+ //getters
+ const char *GetAppliedKaonCutName() { if (fAppliedCutID>0) { return fgkCutName[fAppliedCutID];} else {return "none";}}
+ Int_t GetAppliedKaonCutId() { return fAppliedCutID;}
+ const char *GetKaonCutName(const AliRsnCutKaon::ERsnKaonCut cutID) { return fgkCutName[cutID];}
+
+private:
+
+ Bool_t fNoPID; // flag to switch off PID check
+ AliPID::EParticleType fPID; // PID for track
+ AliRsnCutTrackQuality fCutQuality; // track quality cut
+ Int_t fAppliedCutID; // ID of applied cut
+ static const char *fgkCutName[kNkaonCuts]; //array with cuts names
+ Float_t fNsigmaCutTPC; // max sigma for TPC dE/dx fast cut
+ Float_t fNsigmaCutTOF; // max sigma for TOF t-t0-t_exp fast cut
+
+ ClassDef(AliRsnCutKaon, 1) // cut definitions for K*
+
};
#endif
//
// This cut implements all the checks done to accept a track as a Kaon
-// for the PbPb analysis using 2010 runs.
+// for the PbPb analysis using 2010 runs.
// It is based on standard cuts on track quality and nsigma cuts
// with respect to the TPC and TOF signals for the PID.
//
}
//__________________________________________________________________________________________________
-AliRsnCutKaonForPhi2010& AliRsnCutKaonForPhi2010::operator=(const AliRsnCutKaonForPhi2010 ©)
+AliRsnCutKaonForPhi2010 &AliRsnCutKaonForPhi2010::operator=(const AliRsnCutKaonForPhi2010 ©)
{
//
// Assignment operator
AliRsnCut::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fMode = copy.fMode;
fCutTPC = copy.fCutTPC;
fCutTOF = copy.fCutTOF;
fTOFthreshold = copy.fTOFthreshold;
fMyPID = copy.fMyPID;
fCutQuality = copy.fCutQuality;
-
+
return *this;
}
// Initialize manual PID object
//
- if (isESD)
+ if (isESD)
fMyPID = new AliESDpid(isMC);
else
fMyPID = new AliAODpidUtil(isMC);
// coherence check
if (!TargetOK(obj)) return kFALSE;
-
+
// check track
AliVTrack *track = fDaughter->Ref2Vtrack();
if (!track) {
if (!fDaughter->GetRef()) AliWarning("NULL ref");
return kFALSE;
}
-
+
// check flags
if ((track->GetStatus() & AliESDtrack::kTPCin ) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) return kFALSE;
-
+
// check quality and reject always bad quality tracks
if (!fCutQuality.IsSelected(obj)) {
AliDebugClass(1, Form("[%s] Track quality is bad", GetName()));
return kFALSE;
}
-
+
// initialize check variables
Bool_t accept = kFALSE;
Bool_t isTOF = MatchTOF(track);
Double_t nsTPC = 1E20;
Double_t nsTOF = 1E20;
-
+
// if PID is required, compute it check initialization of PID object
if (fMode >= kOnlyTPC && fMode <= kDefaultPID) {
AliPIDResponse *pid = fEvent->GetPIDResponse();
return kFALSE;
}
// TPC PID
- if (fMyPID)
+ if (fMyPID)
nsTPC = TMath::Abs(fMyPID->NumberOfSigmasTPC(track, AliPID::kKaon));
else
nsTPC = TMath::Abs(pid->NumberOfSigmasTPC(track, AliPID::kKaon));
// TOF PID
nsTOF = TMath::Abs(pid->NumberOfSigmasTOF(track, AliPID::kKaon));
}
-
+
// decide cut result depending on mode
switch (fMode) {
case kQuality:
AliDebugClass(1, Form("[%s] Wrong mode", GetName()));
accept = kFALSE;
}
-
+
AliDebugClass(1, Form("[%s] Track %s", GetName(), (accept ? "accepted" : "rejected")));
return accept;
}
//
// This cut implements all the checks done to accept a track as a Kaon
-// for the PbPb analysis using 2010 runs.
+// for the PbPb analysis using 2010 runs.
// It is based on standard cuts on track quality and nsigma cuts
// with respect to the TPC and TOF signals for the PID.
//
AliRsnCutKaonForPhi2010(const char *name = "", Double_t nSigmaTPC = 3.0, Double_t nSigmaTOF = 3.0, Double_t tofLimit = 0.8);
AliRsnCutKaonForPhi2010(const AliRsnCutKaonForPhi2010 ©);
- AliRsnCutKaonForPhi2010& operator=(const AliRsnCutKaonForPhi2010 ©);
+ AliRsnCutKaonForPhi2010 &operator=(const AliRsnCutKaonForPhi2010 ©);
virtual ~AliRsnCutKaonForPhi2010() { }
-
+
virtual Bool_t IsSelected(TObject *obj);
-
+
AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
Double_t GetTOFthreshold() const {return fTOFthreshold;}
AliPIDResponse *MyPID() {return fMyPID;}
-
+
void SetMode(ECutMode mode) {fMode = mode;}
void SetCutTPC(Double_t cut) {fCutTPC = cut;}
void SetCutTOF(Double_t cut) {fCutTOF = cut;}
void SetTOFthreshold(Double_t value) {fTOFthreshold = value;}
-
+
void InitMyPID(Bool_t isMC, Bool_t isESD);
Bool_t MatchTOF(const AliVTrack *vtrack);
//
// This cut implements all the checks done to accept a track as a Kaon
-// for the pp analysis using 2010 runs.
+// for the pp analysis using 2010 runs.
// It is based on standard cuts on track quality and nsigma cuts
// with respect to the TPC and TOF signals for the PID.
//
}
//__________________________________________________________________________________________________
-AliRsnCutKaonForPhi2010PP& AliRsnCutKaonForPhi2010PP::operator=(const AliRsnCutKaonForPhi2010PP ©)
+AliRsnCutKaonForPhi2010PP &AliRsnCutKaonForPhi2010PP::operator=(const AliRsnCutKaonForPhi2010PP ©)
{
//
// Assignment operator
AliRsnCut::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fNSigmaTPCLow = copy.fNSigmaTPCLow;
fNSigmaTPCHigh = copy.fNSigmaTPCHigh;
fLimitTPC = copy.fLimitTPC;
fNSigmaTOF = copy.fNSigmaTOF;
fMyPID = copy.fMyPID;
fCutQuality = copy.fCutQuality;
-
+
return *this;
}
// Initialize manual PID object
//
- if (isESD)
+ if (isESD)
fMyPID = new AliESDpid(isMC);
else
fMyPID = new AliAODpidUtil(isMC);
// coherence check
if (!TargetOK(obj)) return kFALSE;
-
+
// check track
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
if (!track) return kFALSE;
-
+
// check flags
if ((track->GetStatus() & AliESDtrack::kTPCin ) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) return kFALSE;
-
+
// quality
if (!fCutQuality.IsSelected(obj)) return kFALSE;
-
+
// check initialization of PID object
AliPIDResponse *pid = fEvent->GetPIDResponse();
if (!pid) {
AliFatal("NULL PID response");
return kFALSE;
}
-
+
// PID TPC :
// depends on momentum
// and if local PID object is initialized, it is used instead of that got from manager
Double_t mom = track->GetTPCmomentum();
mom = TMath::Abs(mom);
- if (mom < fLimitTPC)
+ if (mom < fLimitTPC)
SetRangeD(0.0, fNSigmaTPCLow);
else
SetRangeD(0.0, fNSigmaTPCHigh);
- if (fMyPID)
+ if (fMyPID)
fCutValueD = TMath::Abs(fMyPID->NumberOfSigmasTPC(track, AliPID::kKaon));
else
fCutValueD = TMath::Abs(pid->NumberOfSigmasTPC(track, AliPID::kKaon));
if (!OkRangeD()) return kFALSE;
-
+
// if TOF is not matched, end here
// otherwise check TOF
- if (!MatchTOF(track))
+ if (!MatchTOF(track))
return kTRUE;
else {
SetRangeD(0.0, fNSigmaTOF);
//
// This cut implements all the checks done to accept a track as a Kaon
-// for the pp analysis using 2010 runs.
+// for the pp analysis using 2010 runs.
// It is based on standard cuts on track quality and nsigma cuts
// with respect to the TPC and TOF signals for the PID.
//
AliRsnCutKaonForPhi2010PP(const char *name = "");
AliRsnCutKaonForPhi2010PP(const AliRsnCutKaonForPhi2010PP ©);
- AliRsnCutKaonForPhi2010PP& operator=(const AliRsnCutKaonForPhi2010PP ©);
+ AliRsnCutKaonForPhi2010PP &operator=(const AliRsnCutKaonForPhi2010PP ©);
virtual ~AliRsnCutKaonForPhi2010PP() { }
-
+
void SetTPCNSigmaLow (Double_t v) {fNSigmaTPCLow = v;}
void SetTPCNSigmaHigh(Double_t v) {fNSigmaTPCHigh = v;}
void SetTPCLimit(Double_t v) {fLimitTPC = v;}
void SetTOFNSigma(Double_t v) {fNSigmaTOF = v;}
-
+
virtual Bool_t IsSelected(TObject *obj);
void InitMyPID(Bool_t isMC, Bool_t isESD);
-
+
AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
AliPIDResponse *MyPID() {return fMyPID;}
private:
Bool_t MatchTOF(const AliVTrack *vtrack);
-
+
Double_t fNSigmaTPCLow; // TPC: nsigma cut below limit
Double_t fNSigmaTPCHigh; // TPC: nsigma cut above limit
- Double_t fLimitTPC; // TPC: momentum limit
+ Double_t fLimitTPC; // TPC: momentum limit
Double_t fNSigmaTOF; // TOF: nsigma cut (unique)
AliPIDResponse *fMyPID; // PID response object to be configured manyally
}
//_____________________________________________________________________________
-AliRsnCutManager& AliRsnCutManager::operator=(const AliRsnCutManager &cut)
+AliRsnCutManager &AliRsnCutManager::operator=(const AliRsnCutManager &cut)
{
//
// Assign operator
//
- if (this == &cut)
- return *this;
+ if (this == &cut)
+ return *this;
SetName(cut.GetName());
SetTitle(cut.GetTitle());
public:
AliRsnCutManager();
- AliRsnCutManager(const char *name, const char* title = "");
+ AliRsnCutManager(const char *name, const char *title = "");
AliRsnCutManager(const AliRsnCutManager &cut);
- AliRsnCutManager& operator=(const AliRsnCutManager& cut);
+ AliRsnCutManager &operator=(const AliRsnCutManager &cut);
~AliRsnCutManager();
- AliRsnCutSet* GetCommonDaughterCuts() {return &fDaughterCutsCommon;}
- AliRsnCutSet* GetDaughter1Cuts() {return &fDaughterCuts1;}
- AliRsnCutSet* GetDaughter2Cuts() {return &fDaughterCuts2;}
- AliRsnCutSet* GetMotherCuts() {return &fMotherCuts;}
+ AliRsnCutSet *GetCommonDaughterCuts() {return &fDaughterCutsCommon;}
+ AliRsnCutSet *GetDaughter1Cuts() {return &fDaughterCuts1;}
+ AliRsnCutSet *GetDaughter2Cuts() {return &fDaughterCuts2;}
+ AliRsnCutSet *GetMotherCuts() {return &fMotherCuts;}
Bool_t IsSelected(TObject *object);
Bool_t PassCommonDaughterCuts(AliRsnDaughter *daughter) {return fDaughterCutsCommon.IsSelected(daughter);}
//
if (object->InheritsFrom(AliRsnDaughter::Class())) {
- return PassCommonDaughterCuts((AliRsnDaughter*)object);
+ return PassCommonDaughterCuts((AliRsnDaughter *)object);
} else if (object->InheritsFrom(AliRsnMother::Class())) {
- AliRsnMother *mother = (AliRsnMother*)object;
+ AliRsnMother *mother = (AliRsnMother *)object;
if (!PassCommonDaughterCuts(mother->GetDaughter(0))) return kFALSE;
if (!PassCommonDaughterCuts(mother->GetDaughter(1))) return kFALSE;
if (!PassDaughter1Cuts(mother->GetDaughter(0))) return kFALSE;
// Global check
//
- AliRsnMiniPair *pair = dynamic_cast<AliRsnMiniPair*>(obj);
+ AliRsnMiniPair *pair = dynamic_cast<AliRsnMiniPair *>(obj);
if (!pair) {
AliError("This cut applies only to mini-pairs");
return kFALSE;
}
-
+
switch (fType) {
case kRapidityRange:
fCutValueD = pair->Y(0);
AliRsnCutMiniPair(const char *name = "cut", EType type = kTypes);
virtual ~AliRsnCutMiniPair() { }
-
+
virtual Bool_t IsSelected(TObject *obj);
private:
}
//_________________________________________________________________________________________________
-AliRsnCutMomentumComparison::AliRsnCutMomentumComparison(const AliRsnCutMomentumComparison& copy) :
+AliRsnCutMomentumComparison::AliRsnCutMomentumComparison(const AliRsnCutMomentumComparison ©) :
AliRsnCut(copy),
fMode(copy.fMode)
{
}
//_________________________________________________________________________________________________
-AliRsnCutMomentumComparison& AliRsnCutMomentumComparison::operator=(const AliRsnCutMomentumComparison& copy)
+AliRsnCutMomentumComparison &AliRsnCutMomentumComparison::operator=(const AliRsnCutMomentumComparison ©)
{
//
// Assignment operator
AliRsnCut::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fMode = copy.fMode;
-
+
return (*this);
}
Double_t p2 = fMother->GetDaughter(1)->GetRef()->P();
Double_t pt1 = fMother->GetDaughter(0)->GetRef()->Pt();
Double_t pt2 = fMother->GetDaughter(1)->GetRef()->Pt();
-
+
switch (fMode)
{
case kFirstLargerP : return (p1 > p2);
};
AliRsnCutMomentumComparison(const char *name = "cutMomComparison", EMode mode = kFirstLargerPt);
- AliRsnCutMomentumComparison(const AliRsnCutMomentumComparison& copy);
- AliRsnCutMomentumComparison& operator=(const AliRsnCutMomentumComparison& copy);
+ AliRsnCutMomentumComparison(const AliRsnCutMomentumComparison ©);
+ AliRsnCutMomentumComparison &operator=(const AliRsnCutMomentumComparison ©);
virtual ~AliRsnCutMomentumComparison() {;};
virtual Bool_t IsSelected(TObject *object);
}
//_________________________________________________________________________________________________
-Int_t AliRsnCutPID::RealisticPID(AliRsnDaughter * const daughter, Double_t &prob)
+Int_t AliRsnCutPID::RealisticPID(AliRsnDaughter *const daughter, Double_t &prob)
{
//
// Combines the weights collected from chosen detectors with the priors
}
//_________________________________________________________________________________________________
-Int_t AliRsnCutPID::PerfectPID(AliRsnDaughter * const daughter)
+Int_t AliRsnCutPID::PerfectPID(AliRsnDaughter *const daughter)
{
//
// If MC is present, retrieve the particle corresponding to the used track
void ExcludeDetector(EDetector det) {if (CheckBounds(det)) fUseDetector[det] = kFALSE;}
Bool_t ComputeWeights(AliRsnDaughter *daughter);
- Int_t RealisticPID(AliRsnDaughter * const daughter, Double_t &prob);
- Int_t PerfectPID(AliRsnDaughter * const daughter);
+ Int_t RealisticPID(AliRsnDaughter *const daughter, Double_t &prob);
+ Int_t PerfectPID(AliRsnDaughter *const daughter);
Double_t GetWeight(Int_t i) const {if (i >= 0 && i < AliPID::kSPECIES) return fWeight[i]; return 0.0;}
virtual Bool_t IsSelected(TObject *object);
//_________________________________________________________________________________________________
AliRsnCutPIDITS::AliRsnCutPIDITS
-(const AliRsnCutPIDITS& copy) :
+(const AliRsnCutPIDITS ©) :
AliRsnCut(copy),
fIsMC(copy.fIsMC),
fRejectOutside(copy.fRejectOutside),
}
//_________________________________________________________________________________________________
-AliRsnCutPIDITS& AliRsnCutPIDITS::operator=(const AliRsnCutPIDITS& copy)
+AliRsnCutPIDITS &AliRsnCutPIDITS::operator=(const AliRsnCutPIDITS ©)
{
//
// Assignment operator
//
AliRsnCut::operator=(copy);
- if (this == ©)
- return *this;
+ if (this == ©)
+ return *this;
fIsMC = copy.fIsMC;
fRejectOutside = copy.fRejectOutside;
Double_t nSigmaMax = 3.,
Bool_t rejectOutside = kTRUE);
- AliRsnCutPIDITS(const AliRsnCutPIDITS& copy);
- AliRsnCutPIDITS& operator=(const AliRsnCutPIDITS& copy);
+ AliRsnCutPIDITS(const AliRsnCutPIDITS ©);
+ AliRsnCutPIDITS &operator=(const AliRsnCutPIDITS ©);
virtual ~AliRsnCutPIDITS() { }
- AliESDpid* ESDpid() {return fESDpid;}
- AliAODpidUtil* AODpid() {return fAODpid;}
+ AliESDpid *ESDpid() {return fESDpid;}
+ AliAODpidUtil *AODpid() {return fAODpid;}
void SetMC(Bool_t mc = kTRUE) {fIsMC = mc;}
void SetRejectOutside(Bool_t yn = kTRUE) {fRejectOutside = yn;}
ClassImp(AliRsnCutPIDNSigma)
//_________________________________________________________________________________________________
-AliRsnCutPIDNSigma::AliRsnCutPIDNSigma() :
+AliRsnCutPIDNSigma::AliRsnCutPIDNSigma() :
AliRsnCut("cut", AliRsnTarget::kDaughter),
fSpecies(AliPID::kUnknown),
fDetector(kDetectors),
//_________________________________________________________________________________________________
AliRsnCutPIDNSigma::AliRsnCutPIDNSigma
-(const AliRsnCutPIDNSigma& copy) :
+(const AliRsnCutPIDNSigma ©) :
AliRsnCut(copy),
fSpecies(copy.fSpecies),
fDetector(copy.fDetector),
}
//_________________________________________________________________________________________________
-AliRsnCutPIDNSigma& AliRsnCutPIDNSigma::operator=(const AliRsnCutPIDNSigma& copy)
+AliRsnCutPIDNSigma &AliRsnCutPIDNSigma::operator=(const AliRsnCutPIDNSigma ©)
{
//
// Assignment operator
AliRsnCut::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fSpecies = copy.fSpecies;
fDetector = copy.fDetector;
fRejectUnmatched = copy.fRejectUnmatched;
// Initialize manual PID object
//
- if (isESD)
+ if (isESD)
fMyPID = new AliESDpid(isMC);
else
fMyPID = new AliAODpidUtil(isMC);
// coherence check
if (!TargetOK(object)) return kFALSE;
-
+
// check initialization of PID object
// if manual PID is used, use that, otherwise get from source event
AliPIDResponse *pid = 0x0;
- if (fMyPID)
- pid = fMyPID;
- else
+ if (fMyPID)
+ pid = fMyPID;
+ else
pid = fEvent->GetPIDResponse();
if (!pid) {
AliFatal("NULL PID response");
AliDebugClass(2, "Referenced daughter is not a track");
return kFALSE;
}
-
+
// check matching, if required
// a) if detector is not matched and matching is required, reject the track
// b) if detector is not matched and matching is not required, accept blindly the track
AliDebugClass(2, Form("Detector not matched. fRejectUnmatched = %s --> track is %s", (fRejectUnmatched ? "true" : "false"), (fRejectUnmatched ? "rejected" : "accepted")));
return (!fRejectUnmatched);
}
-
+
// get reference momentum
fTrackMom = (fDetector == kTPC) ? vtrack->GetTPCmomentum() : vtrack->P();
-
+
// get number of sigmas
switch (fDetector) {
case kITS:
AliError("Bad detector chosen. Rejecting track");
return kFALSE;
}
-
+
// loop on all ranges, and use the one which contains this momentum
// if none is found, the cut is not passed
Bool_t accept = kFALSE;
Int_t i, goodRange = -1, nRanges = fRanges.GetEntriesFast();
for (i = 0; i < nRanges; i++) {
- AliRsnPIDRange *range = (AliRsnPIDRange*)fRanges[i];
+ AliRsnPIDRange *range = (AliRsnPIDRange *)fRanges[i];
if (!range) continue;
if (!range->IsInRange(fTrackMom)) continue;
else {
//
Char_t mom[200], det[100], match[200];
-
+
if (fRejectUnmatched)
snprintf(match, 200, "Unmatched tracks are rejected");
else
snprintf(match, 200, "No check on track matching");
-
+
switch (fDetector) {
case kITS: snprintf(det, 3, "ITS"); break;
case kTPC: snprintf(det, 3, "TPC"); break;
AliInfo(Form("Cut name : %s", GetName()));
AliInfo(Form("--> PID detector : %s", det));
AliInfo(Form("--> match criteria: %s", match));
- AliInfo(Form("--> momentum range: %s", mom));
+ AliInfo(Form("--> momentum range: %s", mom));
}
kTOF,
kDetectors
};
-
+
//
// This allows to define several intervals
//
class AliRsnPIDRange : public TObject {
public:
-
+
AliRsnPIDRange(Double_t nsigma, Double_t pmin, Double_t pmax)
: fPMin(pmin), fPMax(pmax), fNSigmaCut(nsigma) { }
-
- Double_t& PMin() {return fPMin;}
- Double_t& PMax() {return fPMax;}
- Double_t& NSigmaCut() {return fNSigmaCut;}
-
+
+ Double_t &PMin() {return fPMin;}
+ Double_t &PMax() {return fPMax;}
+ Double_t &NSigmaCut() {return fNSigmaCut;}
+
Bool_t IsInRange(Double_t mom) {return (mom >= fPMin && mom <= fPMax);}
Bool_t CutPass(Double_t nsigma) {return (nsigma <= fNSigmaCut);}
-
+
private:
-
+
Double_t fPMin; // lower bound of momentum range
Double_t fPMax; // upper bound of momentum range
Double_t fNSigmaCut; // cut in number of sigmas
-
+
ClassDef(AliRsnCutPIDNSigma::AliRsnPIDRange,1)
};
AliRsnCutPIDNSigma();
AliRsnCutPIDNSigma(const char *name, AliPID::EParticleType species, EDetector det);
- AliRsnCutPIDNSigma(const AliRsnCutPIDNSigma& copy);
- AliRsnCutPIDNSigma& operator=(const AliRsnCutPIDNSigma& copy);
+ AliRsnCutPIDNSigma(const AliRsnCutPIDNSigma ©);
+ AliRsnCutPIDNSigma &operator=(const AliRsnCutPIDNSigma ©);
virtual ~AliRsnCutPIDNSigma() { }
void SetSpecies(AliPID::EParticleType type) {fSpecies = type;}
void SetDetector(EDetector det) {fDetector = det;}
void SetRejectUnmatched(Bool_t yn = kTRUE) {fRejectUnmatched = yn;}
-
+
AliPIDResponse *MyPID() {return fMyPID;}
void InitMyPID(Bool_t isMC, Bool_t isESD);
-
+
void SinglePIDRange(Double_t nsigma);
void AddPIDRange(Double_t nsigma, Double_t pmin = 0.0, Double_t pmax = 1E20);
-
+
Bool_t MatchITS(const AliVTrack *vtrack) const;
Bool_t MatchTPC(const AliVTrack *vtrack) const;
Bool_t MatchTOF(const AliVTrack *vtrack) const;
Bool_t MatchDetector(const AliVTrack *vtrack) const;
-
+
virtual Bool_t IsSelected(TObject *object);
virtual void Print(const Option_t *option = "") const;
//
if ((vtrack->GetStatus() & AliESDtrack::kTPCin) == 0) return kFALSE;
-
+
return kTRUE;
}
//
Int_t n = fRanges.GetEntries();
-
+
new (fRanges[n]) AliRsnPIDRange(nsigma, pmin, pmax);
}
//
fRanges.Delete();
-
+
new (fRanges[0]) AliRsnPIDRange(nsigma, 0.0, 1E20);
}
}
//_________________________________________________________________________________________________
-AliRsnCutPIDTOF::AliRsnCutPIDTOF(const AliRsnCutPIDTOF& copy) :
+AliRsnCutPIDTOF::AliRsnCutPIDTOF(const AliRsnCutPIDTOF ©) :
AliRsnCut(copy),
fRejectUnmatched(copy.fRejectUnmatched),
fRefType(AliPID::kUnknown),
}
//_________________________________________________________________________________________________
-AliRsnCutPIDTOF& AliRsnCutPIDTOF::operator=(const AliRsnCutPIDTOF& copy)
+AliRsnCutPIDTOF &AliRsnCutPIDTOF::operator=(const AliRsnCutPIDTOF ©)
{
//
// Assignment operator.
// To set the reference PID type, calls the SetRefType method,
// which sets the mass accordingly and coherently.
//
- if (this == ©)
- return *this;
+ if (this == ©)
+ return *this;
fRejectUnmatched = copy.fRejectUnmatched;
fESDpid = copy.fESDpid;
Double_t nSigmaMax = 3.,
Bool_t rejectUnmatched = kFALSE);
- AliRsnCutPIDTOF(const AliRsnCutPIDTOF& copy);
- AliRsnCutPIDTOF& operator=(const AliRsnCutPIDTOF& copy);
+ AliRsnCutPIDTOF(const AliRsnCutPIDTOF ©);
+ AliRsnCutPIDTOF &operator=(const AliRsnCutPIDTOF ©);
virtual ~AliRsnCutPIDTOF() { }
- AliESDpid* ESDpid() {return fESDpid;}
- AliAODpidUtil* AODpid() {return fAODpid;}
+ AliESDpid *ESDpid() {return fESDpid;}
+ AliAODpidUtil *AODpid() {return fAODpid;}
void SetRejectUnmatched(Bool_t yn = kTRUE) {fRejectUnmatched = yn;}
void SetNSigmaRange(Double_t min, Double_t max) {fMinD = min; fMaxD = max;}
if (!isTOFout || !isTIME) return kFALSE;
// do an additional check on integrated length for ESD tracks
- AliESDtrack *esdTrack = dynamic_cast<AliESDtrack*>(vtrack);
+ AliESDtrack *esdTrack = dynamic_cast<AliESDtrack *>(vtrack);
if (esdTrack) if (esdTrack->GetIntegratedLength() < 350.) return kFALSE;
// if we are here, flags are OK and length also
//_________________________________________________________________________________________________
AliRsnCutPIDTPC::AliRsnCutPIDTPC
-(const AliRsnCutPIDTPC& copy) :
+(const AliRsnCutPIDTPC ©) :
AliRsnCut(copy),
fRejectOutside(copy.fRejectOutside),
fMomMin(copy.fMomMin),
}
//_________________________________________________________________________________________________
-AliRsnCutPIDTPC& AliRsnCutPIDTPC::operator=(const AliRsnCutPIDTPC& copy)
+AliRsnCutPIDTPC &AliRsnCutPIDTPC::operator=(const AliRsnCutPIDTPC ©)
{
//
// Assignment operator
AliRsnCut::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fRejectOutside = copy.fRejectOutside;
fMomMin = copy.fMomMin;
fRefType = copy.fRefType;
fESDpid = copy.fESDpid;
fAODpid = copy.fAODpid;
-
+
Int_t i;
for (i = 0; i < 5; i++) fBB[i] = copy.fBB[i];
Double_t nSigmaMax = 3.,
Bool_t rejectOutside = kTRUE);
- AliRsnCutPIDTPC(const AliRsnCutPIDTPC& copy);
- AliRsnCutPIDTPC& operator=(const AliRsnCutPIDTPC& copy);
+ AliRsnCutPIDTPC(const AliRsnCutPIDTPC ©);
+ AliRsnCutPIDTPC &operator=(const AliRsnCutPIDTPC ©);
virtual ~AliRsnCutPIDTPC() { }
- AliESDpid* ESDpid() {return fESDpid;}
- AliAODpidUtil* AODpid() {return fAODpid;}
+ AliESDpid *ESDpid() {return fESDpid;}
+ AliAODpidUtil *AODpid() {return fAODpid;}
void SetRejectOutside(Bool_t yn = kTRUE) {fRejectOutside = yn;}
void SetMomentumRange(Double_t min, Double_t max) {fMomMin = min; fMomMax = max;}
AliESDpid *fESDpid; //! ESD PID object
AliAODpidUtil *fAODpid; //! AOD PID object
Double_t fBB[5]; // Bethe-Bloch parameters
-
+
ClassDef(AliRsnCutPIDTPC, 1)
};
ClassImp(AliRsnCutPion)
-const char* AliRsnCutPion::fgkCutName[AliRsnCutPion::kNpionCuts]={
- "kQuality_Std2010",
- "kTOFMatch_Std2010",
- "kFastTPCpid_Nsigma",
- "kFastTPCpid_1point5sigma",
- "kFastTPCpid_2sigma",
- "kFastTPCpid_3sigma",
- "kFastTOFpid_Nsigma",
- "kFastTOFpid_1point5sigma",
- "kFastTOFpid_2sigma",
- "kFastTOFpid_3sigma",
- "kTPCTOFpid_DefaultKstarPP2010"
+const char *AliRsnCutPion::fgkCutName[AliRsnCutPion::kNpionCuts]= {
+ "kQuality_Std2010",
+ "kTOFMatch_Std2010",
+ "kFastTPCpid_Nsigma",
+ "kFastTPCpid_1point5sigma",
+ "kFastTPCpid_2sigma",
+ "kFastTPCpid_3sigma",
+ "kFastTOFpid_Nsigma",
+ "kFastTOFpid_1point5sigma",
+ "kFastTOFpid_2sigma",
+ "kFastTOFpid_3sigma",
+ "kTPCTOFpid_DefaultKstarPP2010"
};
//__________________________________________________________________________________________________
AliRsnCutPion::AliRsnCutPion(const char *name, AliRsnCutPion::ERsnPionCut cutID, AliPID::EParticleType pid) :
- AliRsnCut(name, AliRsnTarget::kDaughter),
- fNoPID(kFALSE),
- fPID(pid),
- fCutQuality(Form("%sQuality", name)),
- fAppliedCutID(cutID),
- fNsigmaCutTPC(1E6),
- fNsigmaCutTOF(1E6)
+ AliRsnCut(name, AliRsnTarget::kDaughter),
+ fNoPID(kFALSE),
+ fPID(pid),
+ fCutQuality(Form("%sQuality", name)),
+ fAppliedCutID(cutID),
+ fNsigmaCutTPC(1E6),
+ fNsigmaCutTOF(1E6)
{
- //
- // Constructor
- // Initialize track quality cuts to 2010 defaults
- //
- fCutQuality.SetPtRange(0.15, 1E+20);
- fCutQuality.SetEtaRange(-0.8, 0.8);
- fCutQuality.SetDCARPtFormula("0.0182+0.0350/pt^1.01");
- fCutQuality.SetDCAZmax(2.0);
- fCutQuality.SetSPDminNClusters(1);
- fCutQuality.SetITSminNClusters(0);
- fCutQuality.SetITSmaxChi2(1E+20);
- fCutQuality.SetTPCminNClusters(70);
- fCutQuality.SetTPCmaxChi2(4.0);
- fCutQuality.SetRejectKinkDaughters();
- fCutQuality.SetAODTestFilterBit(5);
- AliInfo(Form("Applied cut on pion candidate: %s", AliRsnCutPion::fgkCutName[fAppliedCutID]));
+ //
+ // Constructor
+ // Initialize track quality cuts to 2010 defaults
+ //
+ fCutQuality.SetPtRange(0.15, 1E+20);
+ fCutQuality.SetEtaRange(-0.8, 0.8);
+ fCutQuality.SetDCARPtFormula("0.0182+0.0350/pt^1.01");
+ fCutQuality.SetDCAZmax(2.0);
+ fCutQuality.SetSPDminNClusters(1);
+ fCutQuality.SetITSminNClusters(0);
+ fCutQuality.SetITSmaxChi2(1E+20);
+ fCutQuality.SetTPCminNClusters(70);
+ fCutQuality.SetTPCmaxChi2(4.0);
+ fCutQuality.SetRejectKinkDaughters();
+ fCutQuality.SetAODTestFilterBit(5);
+ AliInfo(Form("Applied cut on pion candidate: %s", AliRsnCutPion::fgkCutName[fAppliedCutID]));
}
//__________________________________________________________________________________________________
//
// coherence check
if (!TargetOK(obj)) return kFALSE;
-
+
// check track
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
if (!track) return kFALSE;
-
+
Bool_t isSelected=kFALSE;
switch (fAppliedCutID)
- {
- case AliRsnCutPion::kQualityStd2010:
- isSelected=IsSelectedByQualityStd2010(obj, 1, 1, 1);
- break;
-
- case AliRsnCutPion::kTOFMatchStd2010:
- isSelected=IsSelectedByTOFMatchStd2010(obj);
- break;
-
- case AliRsnCutPion::kFastTPCpidNsigma:
- isSelected=IsSelectedByFastTPCpidNsigma(obj,fNsigmaCutTPC);
- break;
-
- case AliRsnCutPion::kFastTPCpid1point5sigma:
- isSelected=IsSelectedByFastTPCpid1point5sigma(obj);
- break;
-
- case AliRsnCutPion::kFastTPCpid2sigma:
- isSelected=IsSelectedByFastTPCpid2sigma(obj);
- break;
-
- case AliRsnCutPion::kFastTPCpid3sigma:
- isSelected=IsSelectedByFastTPCpid3sigma(obj);
- break;
-
- case AliRsnCutPion::kFastTOFpidNsigma:
- isSelected=IsSelectedByFastTOFpidNsigma(obj,fNsigmaCutTOF);
- break;
-
- case AliRsnCutPion::kFastTOFpid1point5sigma:
- isSelected=IsSelectedByFastTOFpid1point5sigma(obj);
- break;
-
- case AliRsnCutPion::kFastTOFpid2sigma:
- isSelected=IsSelectedByFastTOFpid2sigma(obj);
- break;
-
- case AliRsnCutPion::kFastTOFpid3sigma:
- isSelected=IsSelectedByFastTOFpid3sigma(obj);
- break;
-
- case AliRsnCutPion::kTPCTOFpidDefaultKstarPP2010:
- isSelected=IsSelectedByTPCTOFpidDefaultKstarPP2010(obj);
- break;
-
- default :
- break;
- }
-
+ {
+ case AliRsnCutPion::kQualityStd2010:
+ isSelected=IsSelectedByQualityStd2010(obj, 1, 1, 1);
+ break;
+
+ case AliRsnCutPion::kTOFMatchStd2010:
+ isSelected=IsSelectedByTOFMatchStd2010(obj);
+ break;
+
+ case AliRsnCutPion::kFastTPCpidNsigma:
+ isSelected=IsSelectedByFastTPCpidNsigma(obj,fNsigmaCutTPC);
+ break;
+
+ case AliRsnCutPion::kFastTPCpid1point5sigma:
+ isSelected=IsSelectedByFastTPCpid1point5sigma(obj);
+ break;
+
+ case AliRsnCutPion::kFastTPCpid2sigma:
+ isSelected=IsSelectedByFastTPCpid2sigma(obj);
+ break;
+
+ case AliRsnCutPion::kFastTPCpid3sigma:
+ isSelected=IsSelectedByFastTPCpid3sigma(obj);
+ break;
+
+ case AliRsnCutPion::kFastTOFpidNsigma:
+ isSelected=IsSelectedByFastTOFpidNsigma(obj,fNsigmaCutTOF);
+ break;
+
+ case AliRsnCutPion::kFastTOFpid1point5sigma:
+ isSelected=IsSelectedByFastTOFpid1point5sigma(obj);
+ break;
+
+ case AliRsnCutPion::kFastTOFpid2sigma:
+ isSelected=IsSelectedByFastTOFpid2sigma(obj);
+ break;
+
+ case AliRsnCutPion::kFastTOFpid3sigma:
+ isSelected=IsSelectedByFastTOFpid3sigma(obj);
+ break;
+
+ case AliRsnCutPion::kTPCTOFpidDefaultKstarPP2010:
+ isSelected=IsSelectedByTPCTOFpidDefaultKstarPP2010(obj);
+ break;
+
+ default :
+ break;
+ }
+
return isSelected;
}
//-----------------------------------------------------------
Bool_t AliRsnCutPion::IsSelectedByQualityStd2010(TObject *obj, Bool_t requireTPCin=kTRUE, Bool_t requireTPCrefit=kTRUE, Bool_t requireITSrefit=kTRUE)
{
- //Checks if track passes the standard quality cuts
- //defined for analysis in 2010 pp and PbPb data
-
- if (!obj) {
- AliError("Invalid track object passed to function. Please check!");
- return kFALSE;
- }
-
- fAppliedCutID=AliRsnCutPion::kQualityStd2010;
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
- if (!track) return kFALSE;
-
- //optionally check refit flags (to be used for Phi and kStar analysis)
- if (requireTPCin && ((track->GetStatus() & AliESDtrack::kTPCin) == 0) ) return kFALSE;
- if (requireTPCrefit && ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) ) return kFALSE;
- if (requireITSrefit && ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) ) return kFALSE;
-
- // quality
- if (!fCutQuality.IsSelected(obj)) return kFALSE;
- return kTRUE;
+ //Checks if track passes the standard quality cuts
+ //defined for analysis in 2010 pp and PbPb data
+
+ if (!obj) {
+ AliError("Invalid track object passed to function. Please check!");
+ return kFALSE;
+ }
+
+ fAppliedCutID=AliRsnCutPion::kQualityStd2010;
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
+ if (!track) return kFALSE;
+
+ //optionally check refit flags (to be used for Phi and kStar analysis)
+ if (requireTPCin && ((track->GetStatus() & AliESDtrack::kTPCin) == 0) ) return kFALSE;
+ if (requireTPCrefit && ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) ) return kFALSE;
+ if (requireITSrefit && ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) ) return kFALSE;
+
+ // quality
+ if (!fCutQuality.IsSelected(obj)) return kFALSE;
+ return kTRUE;
}
//-----------------------------------------------------------
Bool_t AliRsnCutPion::IsSelectedByTOFMatchStd2010(TObject *obj)
{
- /*
- fbellini@cern.ch, 05.dec.2011
- definition of TOF match: quality cuts 2010 + kTOFout + kTIME
- (optionally) L > 350. cm cut can be added
- */
+ /*
+ fbellini@cern.ch, 05.dec.2011
+ definition of TOF match: quality cuts 2010 + kTOFout + kTIME
+ (optionally) L > 350. cm cut can be added
+ */
if (!obj) {
- AliError("Invalid track object passed to function. Please check!");
- return kFALSE;
+ AliError("Invalid track object passed to function. Please check!");
+ return kFALSE;
}
fAppliedCutID=AliRsnCutPion::kTOFMatchStd2010;
-
+
if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE))
- return kFALSE;
-
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
+ return kFALSE;
+
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
if (!track) return kFALSE;
return MatchTOF(track);
}
//-----------------------------------------------------------
Bool_t AliRsnCutPion::IsSelectedByFastTPCpidNsigma(TObject *obj,Float_t nSigmaCut=10.)
{
- /*
- fbellini@cern.ch, 05.dec.2011 Double_t pTPC = track->GetTPCmomentum();
- definition of fast TPC pid N-sigma: quality cuts 2010 + sigma cut on dE/dx without p dependence
- */
- if (!obj) {
- AliError("Invalid track object passed to function. Please check!");
- return kFALSE;
- }
- fAppliedCutID=AliRsnCutPion::kFastTPCpidNsigma;
-
- // check initialization of PID object
- AliPIDResponse *pid = fEvent->GetPIDResponse();
- if (!pid) {
- AliFatal("NULL PID response");
- return kFALSE;
- }
-
- if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE))
- return kFALSE;
-
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
- if (!track) return kFALSE;
-
- Double_t nsTPC = TMath::Abs(pid->NumberOfSigmasTPC(track,fPID));
- return (nsTPC <= nSigmaCut);
+ /*
+ fbellini@cern.ch, 05.dec.2011 Double_t pTPC = track->GetTPCmomentum();
+ definition of fast TPC pid N-sigma: quality cuts 2010 + sigma cut on dE/dx without p dependence
+ */
+ if (!obj) {
+ AliError("Invalid track object passed to function. Please check!");
+ return kFALSE;
+ }
+ fAppliedCutID=AliRsnCutPion::kFastTPCpidNsigma;
+
+ // check initialization of PID object
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ if (!pid) {
+ AliFatal("NULL PID response");
+ return kFALSE;
+ }
+
+ if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE))
+ return kFALSE;
+
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
+ if (!track) return kFALSE;
+
+ Double_t nsTPC = TMath::Abs(pid->NumberOfSigmasTPC(track,fPID));
+ return (nsTPC <= nSigmaCut);
}
//-----------------------------------------------------------
Bool_t AliRsnCutPion::IsSelectedByFastTOFpidNsigma(TObject *obj,Float_t nSigmaCut=10.)
{
- /*
- fbellini@cern.ch, 05.dec.2011
- definition of fast TOF pid N-sigma: quality cuts 2010 + sigma cut on t-t_0-t_exp without p dependence
- */
- if (!obj) {
- AliError("Invalid track object passed to function. Please check!");
- return kFALSE;
- }
-
- fAppliedCutID=AliRsnCutPion::kFastTOFpidNsigma;
-
- // check initialization of PID object
- AliPIDResponse *pid = fEvent->GetPIDResponse();
- if (!pid) {
- AliFatal("NULL PID response");
- return kFALSE;
- }
-
- if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE))
- return kFALSE;
-
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
- if (!track) return kFALSE;
- Bool_t isTOF = MatchTOF(track);
- Double_t nsTOF = isTOF ? TMath::Abs(pid->NumberOfSigmasTOF(track, fPID)) : 1E20;
-
- return (nsTOF <= nSigmaCut);
+ /*
+ fbellini@cern.ch, 05.dec.2011
+ definition of fast TOF pid N-sigma: quality cuts 2010 + sigma cut on t-t_0-t_exp without p dependence
+ */
+ if (!obj) {
+ AliError("Invalid track object passed to function. Please check!");
+ return kFALSE;
+ }
+
+ fAppliedCutID=AliRsnCutPion::kFastTOFpidNsigma;
+
+ // check initialization of PID object
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ if (!pid) {
+ AliFatal("NULL PID response");
+ return kFALSE;
+ }
+
+ if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE))
+ return kFALSE;
+
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
+ if (!track) return kFALSE;
+ Bool_t isTOF = MatchTOF(track);
+ Double_t nsTOF = isTOF ? TMath::Abs(pid->NumberOfSigmasTOF(track, fPID)) : 1E20;
+
+ return (nsTOF <= nSigmaCut);
}
//-----------------------------------------------------------
Bool_t AliRsnCutPion::IsSelectedByTPCTOFpidDefaultKstarPP2010(TObject *obj)
{
- /*
- fbellini@cern.ch, 05.dec.2011
- definition of TPC-TOF pid for pp phi and Kstar analysis on 2010 data:
- quality cuts 2010 + sigma cut on dE/dx with pTPC dependence + sigma cut on t-t_0-t_exp with p dependence
- */
-
- if (!obj) {
- AliError("Invalid track object passed to function. Please check!");
- return kFALSE;
- }
- fAppliedCutID=AliRsnCutPion::kTPCTOFpidDefaultKstarPP2010;
-
- // check initialization of PID object
- AliPIDResponse *pid = fEvent->GetPIDResponse();
- if (!pid) {
- AliFatal("NULL PID response");
- return kFALSE;
- }
-
- if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE)) //require ITS+TPCrefit and TPCin
- return kFALSE;
-
- AliVTrack *track = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
- if (!track) return kFALSE;
-
- Bool_t isTOF = MatchTOF(track);
- Double_t pTPC = track->GetTPCmomentum();
- Double_t p = track->P();
- Double_t nsTPC = TMath::Abs(pid->NumberOfSigmasTPC(track, fPID));
- Double_t nsTOF = isTOF ? TMath::Abs(pid->NumberOfSigmasTOF(track, fPID)) : 1E20;
- Double_t maxTPC = 1E20;
- Double_t maxTOF = 1E20;
-
- if (isTOF) {
- // TPC: 5sigma cut for all
- if (nsTPC > 5.0) return kFALSE;
- // TOF: 3sigma below 1.5 GeV, 2sigma above
- if (p < 1.5) maxTOF = 3.0; else maxTOF = 2.0;
- return (nsTOF <= maxTOF);
- } else {
- // TPC:
- // all below 350 MeV: 5sigma
- // all between 350 and 500 MeV: 3sigma
- // pions above 500 MeV: 2sigma
- if (pTPC <= 0.35)
- maxTPC = 5.0;
- else
- if (pTPC > 0.35 && pTPC <= 0.5)
- maxTPC = 3.0;
+ /*
+ fbellini@cern.ch, 05.dec.2011
+ definition of TPC-TOF pid for pp phi and Kstar analysis on 2010 data:
+ quality cuts 2010 + sigma cut on dE/dx with pTPC dependence + sigma cut on t-t_0-t_exp with p dependence
+ */
+
+ if (!obj) {
+ AliError("Invalid track object passed to function. Please check!");
+ return kFALSE;
+ }
+ fAppliedCutID=AliRsnCutPion::kTPCTOFpidDefaultKstarPP2010;
+
+ // check initialization of PID object
+ AliPIDResponse *pid = fEvent->GetPIDResponse();
+ if (!pid) {
+ AliFatal("NULL PID response");
+ return kFALSE;
+ }
+
+ if (!IsSelectedByQualityStd2010(obj, kTRUE, kTRUE, kTRUE)) //require ITS+TPCrefit and TPCin
+ return kFALSE;
+
+ AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
+ if (!track) return kFALSE;
+
+ Bool_t isTOF = MatchTOF(track);
+ Double_t pTPC = track->GetTPCmomentum();
+ Double_t p = track->P();
+ Double_t nsTPC = TMath::Abs(pid->NumberOfSigmasTPC(track, fPID));
+ Double_t nsTOF = isTOF ? TMath::Abs(pid->NumberOfSigmasTOF(track, fPID)) : 1E20;
+ Double_t maxTPC = 1E20;
+ Double_t maxTOF = 1E20;
+
+ if (isTOF) {
+ // TPC: 5sigma cut for all
+ if (nsTPC > 5.0) return kFALSE;
+ // TOF: 3sigma below 1.5 GeV, 2sigma above
+ if (p < 1.5) maxTOF = 3.0; else maxTOF = 2.0;
+ return (nsTOF <= maxTOF);
+ } else {
+ // TPC:
+ // all below 350 MeV: 5sigma
+ // all between 350 and 500 MeV: 3sigma
+ // pions above 500 MeV: 2sigma
+ if (pTPC <= 0.35)
+ maxTPC = 5.0;
+ else if (pTPC > 0.35 && pTPC <= 0.5)
+ maxTPC = 3.0;
else
- maxTPC = 2.0;
-
- return (nsTPC <= maxTPC);
- }
+ maxTPC = 2.0;
+
+ return (nsTPC <= maxTPC);
+ }
}
class AliRsnCutPion : public AliRsnCut {
public:
- enum ERsnPionCut {
- kQualityStd2010,
- kTOFMatchStd2010,
- kFastTPCpidNsigma,
- kFastTPCpid1point5sigma,
- kFastTPCpid2sigma,
- kFastTPCpid3sigma,
- kFastTOFpidNsigma,
- kFastTOFpid1point5sigma,
- kFastTOFpid2sigma,
- kFastTOFpid3sigma,
- kTPCTOFpidDefaultKstarPP2010,
- kNpionCuts
- };
-
- AliRsnCutPion(const char *name = "", AliRsnCutPion::ERsnPionCut cutID = AliRsnCutPion::kQualityStd2010, AliPID::EParticleType pid = AliPID::kPion);
- virtual ~AliRsnCutPion() { }
-
- void SetNoPID(Bool_t yn = kTRUE) {fNoPID = yn;}
- AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
- Bool_t MatchTOF(const AliVTrack *vtrack);
-
- Bool_t IsSelected(TObject *obj);
-
- Bool_t IsSelectedByQualityStd2010(TObject *obj, Bool_t requireTPCin, Bool_t requireTPCrefit, Bool_t requireITSrefit );
- Bool_t IsSelectedByTOFMatchStd2010(TObject *obj);
-
- Bool_t IsSelectedByFastTPCpidNsigma(TObject *obj,Float_t nSigmaCut);
- Bool_t IsSelectedByFastTPCpid1point5sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 1.5);}
- Bool_t IsSelectedByFastTPCpid2sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 2.0);}
- Bool_t IsSelectedByFastTPCpid3sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 3.0);}
-
- Bool_t IsSelectedByFastTOFpidNsigma(TObject *obj,Float_t nSigmaCut);
- Bool_t IsSelectedByFastTOFpid1point5sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 1.5);}
- Bool_t IsSelectedByFastTOFpid2sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 2.0);}
- Bool_t IsSelectedByFastTOFpid3sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 3.0);}
-
- Bool_t IsSelectedByTPCTOFpidDefaultKstarPP2010(TObject *obj);
-
- //setters
- void SetNsigmaCutTPC(Float_t nMaxSigmaCut=1E6){fNsigmaCutTPC=nMaxSigmaCut; return;}
- void SetNsigmaCutTOF(Float_t nMaxSigmaCut=1E6){fNsigmaCutTOF=nMaxSigmaCut; return;}
-
- //getters
- const char * GetAppliedPionCutName() {if (fAppliedCutID>0){ return fgkCutName[fAppliedCutID];} else {return "none";}}
- Int_t GetAppliedPionCutId() { return fAppliedCutID;}
- const char * GetPionCutName(AliRsnCutPion::ERsnPionCut cutID) { return fgkCutName[cutID];}
-
- private:
-
- Bool_t fNoPID; // flag to switch off PID check
- AliPID::EParticleType fPID; // PID for track
- AliRsnCutTrackQuality fCutQuality; // track quality cut
- Int_t fAppliedCutID; // ID of applied cut
- static const char* fgkCutName[kNpionCuts]; //array with cuts names
- Float_t fNsigmaCutTPC; // max sigma for TPC dE/dx fast cut
- Float_t fNsigmaCutTOF; // max sigma for TOF t-t0-t_exp fast cut
-
- ClassDef(AliRsnCutPion,1) // cut definitions for K*
-
+ enum ERsnPionCut {
+ kQualityStd2010,
+ kTOFMatchStd2010,
+ kFastTPCpidNsigma,
+ kFastTPCpid1point5sigma,
+ kFastTPCpid2sigma,
+ kFastTPCpid3sigma,
+ kFastTOFpidNsigma,
+ kFastTOFpid1point5sigma,
+ kFastTOFpid2sigma,
+ kFastTOFpid3sigma,
+ kTPCTOFpidDefaultKstarPP2010,
+ kNpionCuts
+ };
+
+ AliRsnCutPion(const char *name = "", AliRsnCutPion::ERsnPionCut cutID = AliRsnCutPion::kQualityStd2010, AliPID::EParticleType pid = AliPID::kPion);
+ virtual ~AliRsnCutPion() { }
+
+ void SetNoPID(Bool_t yn = kTRUE) {fNoPID = yn;}
+ AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
+ Bool_t MatchTOF(const AliVTrack *vtrack);
+
+ Bool_t IsSelected(TObject *obj);
+
+ Bool_t IsSelectedByQualityStd2010(TObject *obj, Bool_t requireTPCin, Bool_t requireTPCrefit, Bool_t requireITSrefit );
+ Bool_t IsSelectedByTOFMatchStd2010(TObject *obj);
+
+ Bool_t IsSelectedByFastTPCpidNsigma(TObject *obj,Float_t nSigmaCut);
+ Bool_t IsSelectedByFastTPCpid1point5sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 1.5);}
+ Bool_t IsSelectedByFastTPCpid2sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 2.0);}
+ Bool_t IsSelectedByFastTPCpid3sigma(TObject *obj) {return IsSelectedByFastTPCpidNsigma(obj, 3.0);}
+
+ Bool_t IsSelectedByFastTOFpidNsigma(TObject *obj,Float_t nSigmaCut);
+ Bool_t IsSelectedByFastTOFpid1point5sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 1.5);}
+ Bool_t IsSelectedByFastTOFpid2sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 2.0);}
+ Bool_t IsSelectedByFastTOFpid3sigma(TObject *obj) {return IsSelectedByFastTOFpidNsigma(obj, 3.0);}
+
+ Bool_t IsSelectedByTPCTOFpidDefaultKstarPP2010(TObject *obj);
+
+ //setters
+ void SetNsigmaCutTPC(Float_t nMaxSigmaCut=1E6) {fNsigmaCutTPC=nMaxSigmaCut; return;}
+ void SetNsigmaCutTOF(Float_t nMaxSigmaCut=1E6) {fNsigmaCutTOF=nMaxSigmaCut; return;}
+
+ //getters
+ const char *GetAppliedPionCutName() {if (fAppliedCutID>0) { return fgkCutName[fAppliedCutID];} else {return "none";}}
+ Int_t GetAppliedPionCutId() { return fAppliedCutID;}
+ const char *GetPionCutName(AliRsnCutPion::ERsnPionCut cutID) { return fgkCutName[cutID];}
+
+private:
+
+ Bool_t fNoPID; // flag to switch off PID check
+ AliPID::EParticleType fPID; // PID for track
+ AliRsnCutTrackQuality fCutQuality; // track quality cut
+ Int_t fAppliedCutID; // ID of applied cut
+ static const char *fgkCutName[kNpionCuts]; //array with cuts names
+ Float_t fNsigmaCutTPC; // max sigma for TPC dE/dx fast cut
+ Float_t fNsigmaCutTOF; // max sigma for TOF t-t0-t_exp fast cut
+
+ ClassDef(AliRsnCutPion,1) // cut definitions for K*
+
};
#endif
// coherence check
if (!TargetOK(obj)) return kFALSE;
-
+
// check track
AliVTrack *track = fDaughter->Ref2Vtrack();
if (!track) {
if (!fDaughter->GetRef()) AliWarning("NULL ref");
return kFALSE;
}
-
+
// check flags
if ((track->GetStatus() & AliESDtrack::kTPCin ) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) return kFALSE;
-
+
// quality
if (!fCutQuality.IsSelected(obj)) return kFALSE;
-
+
// check initialization of PID object
AliPIDResponse *pid = fEvent->GetPIDResponse();
if (!pid) {
AliFatal("NULL PID response");
return kFALSE;
}
-
+
// PID ITS :
// depends on momentum
//SetRangeD(0.0, 4.0);
//fCutValueD = TMath::Abs(pid->NumberOfSigmasITS(track, AliPID::kPion));
//if (!OkRangeD()) return kFALSE;
-
+
// PID TPC :
// depends on momentum
SetRangeD(0.0, 3.0);
if (track->GetTPCmomentum() < 0.350) SetRangeD(0.0, 5.0);
fCutValueD = TMath::Abs(pid->NumberOfSigmasTPC(track, AliPID::kPion));
if (!OkRangeD()) return kFALSE;
-
+
// if TOF is not matched, end here
// otherwise check TOF
- if (!MatchTOF(track))
+ if (!MatchTOF(track))
return kTRUE;
else {
//SetRangeD(0.0, 3.0);
AliRsnCutPion2010PP(const char *name = "");
virtual ~AliRsnCutPion2010PP() { }
-
+
virtual Bool_t IsSelected(TObject *obj);
-
+
AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
private:
if (!TargetOK(object)) return kFALSE;
// retrieve ESD event
- AliESDEvent *esd = dynamic_cast<AliESDEvent*>(fEvent->GetRef());
- AliAODEvent *aod = dynamic_cast<AliAODEvent*>(fEvent->GetRef());
+ AliESDEvent *esd = dynamic_cast<AliESDEvent *>(fEvent->GetRef());
+ AliAODEvent *aod = dynamic_cast<AliAODEvent *>(fEvent->GetRef());
if (esd) {
// pile-up check
return kFALSE;
}
// now check primary vertex
- aodv = (AliAODVertex*)aod->GetPrimaryVertex();
+ aodv = (AliAODVertex *)aod->GetPrimaryVertex();
if (CheckVertex(aodv)) {
AliDebugClass(1, "Vertex TRK is OK");
fCutValueD = aodv->GetZ();
// least one contributor
//
- if (!vertex) return kFALSE;
+ if (!vertex) return kFALSE;
if (vertex->GetNContributors() < 1) return kFALSE;
return kTRUE;
}
// coherence check
if (!TargetOK(obj)) return kFALSE;
-
+
// check track
AliVTrack *track = fDaughter->Ref2Vtrack();
if (!track) {
if (!fDaughter->GetRef()) AliWarning("NULL ref");
return kFALSE;
}
-
+
// check flags
if ((track->GetStatus() & AliESDtrack::kTPCin ) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) return kFALSE;
if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) return kFALSE;
-
+
// quality
if (!fCutQuality.IsSelected(obj)) return kFALSE;
-
+
// check initialization of PID object
AliPIDResponse *pid = fEvent->GetPIDResponse();
if (!pid) {
AliFatal("NULL PID response");
return kFALSE;
}
-
+
// PID ITS :
// depends on momentum
//SetRangeD(0.0, 4.0);
//fCutValueD = TMath::Abs(pid->NumberOfSigmasITS(track, AliPID::kProton));
//if (!OkRangeD()) return kFALSE;
-
+
// PID TPC :
// depends on momentum
SetRangeD(0.0, 3.0);
if (track->GetTPCmomentum() < 0.350) SetRangeD(0.0, 5.0);
fCutValueD = TMath::Abs(pid->NumberOfSigmasTPC(track, AliPID::kProton));
if (!OkRangeD()) return kFALSE;
-
+
// if TOF is not matched, end here
// otherwise check TOF
- if (!MatchTOF(track))
+ if (!MatchTOF(track))
return kTRUE;
else {
//SetRangeD(0.0, 3.0);
AliRsnCutProton2010PP(const char *name = "");
virtual ~AliRsnCutProton2010PP() { }
-
+
virtual Bool_t IsSelected(TObject *obj);
-
+
AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
private:
fCutSchemeIndexed(""),
fBoolValues(0),
fIsScheme(kFALSE),
- fExpression(0)
+ fExpression(0),
+ fMonitors(0)
{
//
// Constructor without name (not recommended)
fCutSchemeIndexed(""),
fBoolValues(0),
fIsScheme(kFALSE),
- fExpression(0)
+ fExpression(0),
+ fMonitors(0)
{
//
// Constructor with argument name (recommended)
}
//_____________________________________________________________________________
-AliRsnCutSet::AliRsnCutSet(const AliRsnCutSet & copy) :
+AliRsnCutSet::AliRsnCutSet(const AliRsnCutSet ©) :
AliRsnTarget(copy),
fCuts(copy.fCuts),
fNumOfCuts(copy.fNumOfCuts),
fCutSchemeIndexed(copy.fCutSchemeIndexed),
fBoolValues(0),
fIsScheme(copy.fIsScheme),
- fExpression(copy.fExpression)
+ fExpression(copy.fExpression),
+ fMonitors(copy.fMonitors)
{
//
// Copy constructor
}
//_____________________________________________________________________________
-AliRsnCutSet& AliRsnCutSet::operator=(const AliRsnCutSet & copy)
+AliRsnCutSet &AliRsnCutSet::operator=(const AliRsnCutSet ©)
{
//
// Assignment operator.
AliRsnTarget::operator=(copy);
if (this == ©)
- return *this;
-
+ return *this;
+
fCuts = copy.fCuts;
fNumOfCuts = copy.fNumOfCuts;
fCutScheme = copy.fCutScheme;
fCutSchemeIndexed = copy.fCutSchemeIndexed;
fIsScheme = copy.fIsScheme;
fExpression = copy.fExpression;
+ fMonitors = copy.fMonitors;
if (fBoolValues) delete [] fBoolValues;
delete fExpression;
delete [] fBoolValues;
+ delete fMonitors;
}
//_____________________________________________________________________________
AliRsnCut *cut;
for (Int_t i = 0; i < fCuts.GetEntriesFast() ; i++) {
- cut = (AliRsnCut*)fCuts.At(i);
+ cut = (AliRsnCut *)fCuts.At(i);
cut->Print();
}
}
Bool_t boolReturn = kTRUE;
AliRsnCut *cut;
for (i = 0; i < fNumOfCuts; i++) {
- cut = (AliRsnCut*)fCuts.At(i);
+ cut = (AliRsnCut *)fCuts.At(i);
fBoolValues[i] = cut->IsSelected(object);
}
if (fIsScheme) boolReturn = Passed();
+
+ // fill monitoring info
+ if (boolReturn && fMonitors) {
+ if (TargetOK(object)) {
+ TIter next(fMonitors);
+ AliRsnListOutput *mo;
+ while ((mo = (AliRsnListOutput *) next())) {
+ mo->Fill(fEvent,fDaughter);
+ }
+ }
+ }
+
return boolReturn;
}
AliRsnCut *cut;
for (i = 0; i < fCuts.GetEntriesFast(); i++) {
- cut = (AliRsnCut*) fCuts.At(i);
+ cut = (AliRsnCut *) fCuts.At(i);
if (!s.CompareTo(cut->GetName())) return i;
}
TString str(fCutScheme);
AliRsnCut *cut;
for (Int_t i = 0; i < fNumOfCuts; i++) {
- cut = (AliRsnCut*)fCuts.At(i);
+ cut = (AliRsnCut *)fCuts.At(i);
str.ReplaceAll(cut->GetName(), "");
}
str.ReplaceAll("&", "");
AliInfo("====== Cuts ======");
AliRsnCut *cut;
for (i = 0; i < fCuts.GetEntriesFast(); i++) {
- cut = (AliRsnCut*) fCuts.At(i);
+ cut = (AliRsnCut *) fCuts.At(i);
if (cut) AliInfo(Form("%d %d", i, fBoolValues[i]));
}
AliInfo("========== END Rsn Cut Mgr info ==============");
AliDebug(AliLog::kDebug, Form("Num of cuts %d", fCuts.GetEntriesFast()));
AliRsnCut *cut;
for (i = 0; i < fCuts.GetEntriesFast(); i++) {
- cut = (AliRsnCut*) fCuts.At(i);
+ cut = (AliRsnCut *) fCuts.At(i);
str.ReplaceAll(cut->GetName(), Form("%d", i));
}
AliDebug(AliLog::kDebug, "->");
return str;
}
+
+Bool_t AliRsnCutSet::Init(TList *list)
+{
+ if (!fMonitors) return kTRUE;
+
+ TIter next(fMonitors);
+ AliRsnListOutput *mo;
+ while ((mo = (AliRsnListOutput *) next())) {
+ mo->Init(GetName(),list);
+ }
+
+
+ return kTRUE;
+}
+
+void AliRsnCutSet::AddMonitor(AliRsnListOutput *mon)
+{
+ if (!fMonitors) fMonitors = new TObjArray();
+ fMonitors->Add(mon);
+}
+
#include <TObjArray.h>
#include "AliRsnTarget.h"
+#include "AliRsnListOutput.h"
class AliRsnCut;
class AliRsnDaughter;
AliRsnCutSet();
AliRsnCutSet(const char *name, RSNTARGET target);
AliRsnCutSet(const AliRsnCutSet ©);
- AliRsnCutSet& operator=(const AliRsnCutSet& copy);
+ AliRsnCutSet &operator=(const AliRsnCutSet ©);
~AliRsnCutSet();
- void AddCut(AliRsnCut* cut);
+ void AddCut(AliRsnCut *cut);
+ Bool_t Init(TList *list);
void ShowCuts() const;
Int_t GetIndexByCutName(TString s);
TObjArray *GetCuts() { return &fCuts; }
-private:
+ void AddMonitor(AliRsnListOutput *mon);
+ TObjArray *GetMonitorOutput() { return fMonitors; }
+ void SetMonitorOutput(TObjArray *monitors) { fMonitors = monitors; }
- TObjArray fCuts; // array of cuts
- Int_t fNumOfCuts; // number of cuts
- TString fCutScheme; // cut scheme
- TString fCutSchemeIndexed; // cut scheme indexed
+private:
- Bool_t *fBoolValues; //[fNumOfCuts]
- Bool_t fIsScheme; // is scheme
+ TObjArray fCuts; // array of cuts
+ Int_t fNumOfCuts; // number of cuts
+ TString fCutScheme; // cut scheme
+ TString fCutSchemeIndexed; // cut scheme indexed
- AliRsnExpression *fExpression; // pointer to AliRsnExpression
+ Bool_t *fBoolValues; //[fNumOfCuts]
+ Bool_t fIsScheme; // is scheme
- ClassDef(AliRsnCutSet, 1) // ROOT dictionary
+ AliRsnExpression *fExpression; // pointer to AliRsnExpression
+ TObjArray *fMonitors; // array of monitor object
+ ClassDef(AliRsnCutSet, 2) // ROOT dictionary
};
#endif
}
//_________________________________________________________________________________________________
-AliRsnCutTrackQuality& AliRsnCutTrackQuality::operator=(const AliRsnCutTrackQuality ©)
+AliRsnCutTrackQuality &AliRsnCutTrackQuality::operator=(const AliRsnCutTrackQuality ©)
{
//
// Assignment operator.
// Just copy all data member values.
//
- if (this == ©)
- return *this;
-
+ if (this == ©)
+ return *this;
+
fFlagsOn = copy.fFlagsOn;
fFlagsOff = copy.fFlagsOff;
fRejectKinkDaughters = copy.fRejectKinkDaughters;
if (fAODTestFilterBit >= 0) {
UInt_t bit = 1 << fAODTestFilterBit;
AliDebugClass(2, Form("Required a test filter bit for AOD check: %u (result: %s)", bit, (track->TestFilterBit(bit) ? "accept" : "reject")));
- if (!track->TestFilterBit(bit))
+ if (!track->TestFilterBit(bit))
return kFALSE;
else {
if (track->Pt() < fPt[0] || track->Pt() > fPt[1]) return kFALSE;
return kTRUE;
}
}
-
+
// try to retrieve the reference AOD event
AliAODEvent *aodEvent = 0x0;
if (fEvent) aodEvent = fEvent->GetRefAOD();
public:
AliRsnCutTrackQuality(const char *name = "AliRsncutTrackQuality");
- AliRsnCutTrackQuality(const AliRsnCutTrackQuality& copy);
- AliRsnCutTrackQuality& operator=(const AliRsnCutTrackQuality& copy);
+ AliRsnCutTrackQuality(const AliRsnCutTrackQuality ©);
+ AliRsnCutTrackQuality &operator=(const AliRsnCutTrackQuality ©);
virtual ~AliRsnCutTrackQuality() { }
void DisableAll();
void SetTPCmaxChi2(Double_t value) {fTPCmaxChi2 = value;}
void SetRejectKinkDaughters(Bool_t yn = kTRUE) {fRejectKinkDaughters = yn;}
-
+
void SetAODTestFilterBit(Int_t value) {fAODTestFilterBit = value;}
-
+
void SetDefaults2010();
virtual Bool_t IsSelected(TObject *obj);
Bool_t CheckESD(AliESDtrack *track);
Bool_t CheckAOD(AliAODTrack *track);
- const char* Binary(UInt_t number);
+ const char *Binary(UInt_t number);
ULong_t fFlagsOn; // status flags which must be ON (used AliESDtrack ones, connected with '|')
ULong_t fFlagsOff; // status flags which must be OFF (used AliESDtrack ones, connected with '|')
};
//__________________________________________________________________________________________________
-inline const char * AliRsnCutTrackQuality::Binary(UInt_t number)
+inline const char *AliRsnCutTrackQuality::Binary(UInt_t number)
{
//
// Convert an integer in binary
//
- static char b[50];
- b[0] = '\0';
+ static char b[50];
+ b[0] = '\0';
- UInt_t z;
- for (z = 512; z > 0; z >>= 1)
- strncat(b, ((number & z) == z) ? "1" : "0", 1);
+ UInt_t z;
+ for (z = 512; z > 0; z >>= 1)
+ strncat(b, ((number & z) == z) ? "1" : "0", 1);
- return b;
+ return b;
}
//__________________________________________________________________________________________________
}
//__________________________________________________________________________________________________
-AliRsnCutTrue& AliRsnCutTrue::operator=(const AliRsnCutTrue ©)
+AliRsnCutTrue &AliRsnCutTrue::operator=(const AliRsnCutTrue ©)
{
//
// Assignment operator
// convert target
if (!TargetOK(obj)) return kFALSE;
-
+
// check if MC is present
if (!fDaughter->GetRefMC()) {
AliError("Cannot check cut 'AliRsnCutTrue' without MC information");
return kFALSE;
}
-
+
// compare PDG
fCutValueI = fDaughter->GetPDGAbs();
return OkValueI();
}
-
-
+
+
#include "AliRsnCut.h"
class AliRsnCutTrue : public AliRsnCut {
-
+
public:
AliRsnCutTrue(const char *name, Int_t pdg);
AliRsnCutTrue(const char *name, AliRsnDaughter::ESpecies species);
- AliRsnCutTrue(const AliRsnCutTrue& copy);
- AliRsnCutTrue& operator=(const AliRsnCutTrue ©);
+ AliRsnCutTrue(const AliRsnCutTrue ©);
+ AliRsnCutTrue &operator=(const AliRsnCutTrue ©);
virtual ~AliRsnCutTrue() { }
-
+
virtual Bool_t IsSelected(TObject *obj);
-
+
private:
ClassDef(AliRsnCutTrue,1) // AliRsnCutTrue class
}
//_________________________________________________________________________________________________
-AliRsnCutV0& AliRsnCutV0::operator=(const AliRsnCutV0 ©)
+AliRsnCutV0 &AliRsnCutV0::operator=(const AliRsnCutV0 ©)
{
//
// Assignment operator.
// Just copy all data member values.
//
- if (this == ©)
- return *this;
-
- fHypothesis = copy.fHypothesis;
- fMass = copy.fMass;
- fTolerance = copy.fTolerance;
- fMaxDCAVertex = copy.fMaxDCAVertex;
- fMinCosPointAngle = copy.fMinCosPointAngle;
- fMaxDaughtersDCA = copy.fMaxDaughtersDCA;
- fESDtrackCuts = copy.fESDtrackCuts;
-
+ if (this == ©)
+ return *this;
+
+ fHypothesis = copy.fHypothesis;
+ fMass = copy.fMass;
+ fTolerance = copy.fTolerance;
+ fMaxDCAVertex = copy.fMaxDCAVertex;
+ fMinCosPointAngle = copy.fMinCosPointAngle;
+ fMaxDaughtersDCA = copy.fMaxDaughtersDCA;
+ fESDtrackCuts = copy.fESDtrackCuts;
+
return (*this);
}
// coherence check
if (!TargetOK(object)) return kFALSE;
-
+
// check cast
AliESDv0 *v0esd = fDaughter->Ref2ESDv0();
AliAODv0 *v0aod = fDaughter->Ref2AODv0();
//cout << fDaughter->GetRef()->ClassName() << ' ' << v0esd << ' ' << v0aod << endl;
-
+
// operate depending on cast
if (v0esd) {
return CheckESD(v0esd);
AliDebugClass(1, "Rejecting V0 in 'on fly' status");
return kFALSE; // if kTRUE, then this V0 is recontructed
}
-
+
// retrieve pointer to owner event
AliESDEvent *lESDEvent = fEvent->GetRefESD();
Double_t xPrimaryVertex = lESDEvent->GetPrimaryVertex()->GetX();
Double_t yPrimaryVertex = lESDEvent->GetPrimaryVertex()->GetY();
Double_t zPrimaryVertex = lESDEvent->GetPrimaryVertex()->GetZ();
AliDebugClass(2, Form("Primary vertex: %f %f %f", xPrimaryVertex, yPrimaryVertex, zPrimaryVertex));
-
+
// retrieve the V0 daughters
UInt_t lIdxPos = (UInt_t) TMath::Abs(v0->GetPindex());
UInt_t lIdxNeg = (UInt_t) TMath::Abs(v0->GetNindex());
AliESDtrack *pTrack = lESDEvent->GetTrack(lIdxPos);
AliESDtrack *nTrack = lESDEvent->GetTrack(lIdxNeg);
-
+
// check quality cuts
if (fESDtrackCuts) {
AliDebugClass(2, "Checking quality cuts");
return kFALSE;
}
}
-
+
// filter like-sign V0
//if ((TMath::Abs(pTrack->GetSign()) - TMath::Abs(nTrack->GetSign()) ) < 0.1) {
// AliDebugClass(2, "Failed like-sign V0 check");
// return kFALSE;
//}
-
+
// check compatibility with expected species hypothesis
v0->ChangeMassHypothesis(fHypothesis);
if ((TMath::Abs(v0->GetEffMass() - fMass)) > fTolerance) {
AliDebugClass(2, "V0 is not in the expected inv mass range");
return kFALSE;
}
-
+
// topological checks
if (TMath::Abs(v0->GetD(xPrimaryVertex, yPrimaryVertex, zPrimaryVertex)) > fMaxDCAVertex) {
AliDebugClass(2, "Failed check on DCA to primary vertes");
AliDebugClass(2, "Failed check on DCA between daughters");
return kFALSE;
}
-
+
// if we reach this point, all checks were successful
AliDebugClass(2, "Good V0 (hallelujah)");
- return kTRUE;
+ return kTRUE;
}
//_________________________________________________________________________________________________
//
AliWarning("Cuts is not yet implemented for AOD");
-
+
return kTRUE;
}
public:
AliRsnCutV0(const char *name = "AliRsnCutV0", Int_t hypothesis = kLambda0);
- AliRsnCutV0(const AliRsnCutV0& copy);
- AliRsnCutV0& operator=(const AliRsnCutV0& copy);
+ AliRsnCutV0(const AliRsnCutV0 ©);
+ AliRsnCutV0 &operator=(const AliRsnCutV0 ©);
virtual ~AliRsnCutV0() { }
-
+
void SetESDtrackCuts(AliESDtrackCuts *cuts) {fESDtrackCuts = cuts;}
void SetHypothesis(Int_t code);
void SetTolerance(Double_t value) {fTolerance = value;}
Bool_t CheckESD(AliESDv0 *track);
Bool_t CheckAOD(AliAODv0 *track);
-
+
Int_t fHypothesis; // PDG code corresponding to expected V0 hypothesis
Double_t fMass; // mass corresponding to hypothesis
Double_t fTolerance; // tolerance in the difference between computed and expected mass
//
fHypothesis = code;
-
+
switch (fHypothesis) {
case kLambda0:
case kLambda0Bar:
}
//_________________________________________________________________________________________________
-AliRsnCutValue::AliRsnCutValue(const AliRsnCutValue& copy) :
+AliRsnCutValue::AliRsnCutValue(const AliRsnCutValue ©) :
AliRsnCut(copy),
fValue(copy.fValue)
{
}
//_________________________________________________________________________________________________
-AliRsnCutValue& AliRsnCutValue::operator=(const AliRsnCutValue& copy)
+AliRsnCutValue &AliRsnCutValue::operator=(const AliRsnCutValue ©)
{
//
// Assignment operator.
// Does not duplicate memory allocation.
//
- AliRsnCut::operator=(copy);
- if (this == ©)
- return *this;
-
- fValue = copy.fValue;
-
- return (*this);
+ AliRsnCut::operator=(copy);
+ if (this == ©)
+ return *this;
+
+ fValue = copy.fValue;
+
+ return (*this);
}
//_________________________________________________________________________________________________
// skip cut if value is not initialized
if (!fValue) return kTRUE;
-
+
// match target types
SetTargetType(fValue->GetTargetType());
AliRsnCutValue();
AliRsnCutValue(const char *name, Double_t min, Double_t max);
- AliRsnCutValue(const AliRsnCutValue& copy);
- AliRsnCutValue& operator=(const AliRsnCutValue& copy);
+ AliRsnCutValue(const AliRsnCutValue ©);
+ AliRsnCutValue &operator=(const AliRsnCutValue ©);
virtual ~AliRsnCutValue() { }
Double_t GetComputedValue() {if (fValue) return fValue->GetComputedValue(); return -1E20;}
- AliRsnValue* GetValueObj() {return fValue;}
+ AliRsnValue *GetValueObj() {return fValue;}
void SetValueObj(AliRsnValue *value) {fValue = value; SetTargetType(value->GetTargetType());}
virtual Bool_t IsSelected(TObject *object);
// need to be accessed from ESD or AOD objects, usually in different ways.
// When MC is available, AliRsnDaughter matches each reconstructed object with
// its corresponding MC particle.
-//
+//
// Currently, this interface can point to all kinds of single-particle object
-// which one can have in the reconstructed event: charged tracks, V0s and
+// which one can have in the reconstructed event: charged tracks, V0s and
// cascades. It is care of the user to treat each of them in the correct way,
// regarding cuts, functions to be computed, etc.
//
}
//_____________________________________________________________________________
-AliRsnDaughter& AliRsnDaughter::operator=(const AliRsnDaughter ©)
+AliRsnDaughter &AliRsnDaughter::operator=(const AliRsnDaughter ©)
{
//
// Assignment operator.
// Pointers are NOT duplicated, since they don't come from a 'new'
// statement, but from just referencing something in the data source.
//
- if (this == ©)
- return *this;
+ if (this == ©)
+ return *this;
fOK = copy.fOK;
fLabel = copy.fLabel;
fLabel = -1;
fMotherPDG = 0;
fRsnID = -1;
-
+
fPsim.SetXYZT(0.0, 0.0, 0.0, 0.0);
fPrec.SetXYZT(0.0, 0.0, 0.0, 0.0);
//
if (Match(fRefMC, AliMCParticle::Class()))
- return ((AliMCParticle*)fRefMC)->Particle()->GetPdgCode();
+ return ((AliMCParticle *)fRefMC)->Particle()->GetPdgCode();
else if (Match(fRefMC, AliAODMCParticle::Class()))
- return ((AliAODMCParticle*)fRefMC)->GetPdgCode();
+ return ((AliAODMCParticle *)fRefMC)->GetPdgCode();
else {
AliWarning("Cannot retrieve PDG");
return 0;
if (!fRefMC) return -1;
if (fRefMC->InheritsFrom(AliMCParticle::Class())) {
- AliMCParticle *mc = (AliMCParticle*)fRefMC;
+ AliMCParticle *mc = (AliMCParticle *)fRefMC;
return mc->Particle()->GetFirstMother();
} else if (fRefMC->InheritsFrom(AliAODMCParticle::Class())) {
- AliAODMCParticle *mc = (AliAODMCParticle*)fRefMC;
+ AliAODMCParticle *mc = (AliAODMCParticle *)fRefMC;
return mc->GetMother();
}
else
return -1;
}
-
-
+
+
//______________________________________________________________________________
void AliRsnDaughter::Print(Option_t *) const
}
//______________________________________________________________________________
-const char* AliRsnDaughter::SpeciesName(ESpecies species)
+const char *AliRsnDaughter::SpeciesName(ESpecies species)
{
//
// Return a string with the short name of the particle
TDatabasePDG *db = TDatabasePDG::Instance();
TParticlePDG *part = 0x0;
-
+
Int_t pdg = SpeciesPDG(species);
if (pdg) {
part = db->GetParticle(pdg);
kCascade,
kNoType
};
-
+
enum ESpecies {
kElectron,
kMuon,
};
AliRsnDaughter() : fOK(kFALSE), fLabel(-1), fMotherPDG(0), fRsnID(-1),
- fPrec(), fPsim(), fRef(0x0), fRefMC(0x0), fOwnerEvent(0x0) { }
+ fPrec(), fPsim(), fRef(0x0), fRefMC(0x0), fOwnerEvent(0x0) { }
AliRsnDaughter(const AliRsnDaughter ©);
- AliRsnDaughter& operator= (const AliRsnDaughter& copy);
+ AliRsnDaughter &operator= (const AliRsnDaughter ©);
virtual ~AliRsnDaughter() { /*empty, since pointers must not be deleted*/ }
// basic getters
Int_t GetLabel() const {return fLabel;}
Int_t GetMotherPDG() const {return fMotherPDG;}
Int_t GetRsnID() const {return fRsnID;}
- AliVParticle* GetRef() {return fRef;}
- AliVParticle* GetRefMC() {return fRefMC;}
- AliRsnEvent* GetOwnerEvent() {return fOwnerEvent;}
- TLorentzVector& P(Bool_t mc) {return (mc ? fPsim : fPrec);}
- TLorentzVector& Prec() {return fPrec;}
- TLorentzVector& Psim() {return fPsim;}
+ AliVParticle *GetRef() {return fRef;}
+ AliVParticle *GetRefMC() {return fRefMC;}
+ AliRsnEvent *GetOwnerEvent() {return fOwnerEvent;}
+ TLorentzVector &P(Bool_t mc) {return (mc ? fPsim : fPrec);}
+ TLorentzVector &Prec() {return fPrec;}
+ TLorentzVector &Psim() {return fPsim;}
Int_t GetPDG();
Int_t GetPDGAbs() {return TMath::Abs(GetPDG());}
Int_t GetID();
void SetRef(AliVParticle *p) {fRef = p;}
void SetRefMC(AliVParticle *p) {fRefMC = p;}
void SetOwnerEvent(AliRsnEvent *e) {fOwnerEvent = e;}
-
+
// additional functions
void FillP(Double_t mass);
void Print(Option_t *o = "") const;
-
+
// getters related to charge
Bool_t IsPos() const {if (fRef) return (fRef->Charge() > 0); return kFALSE;}
Bool_t IsNeg() const {if (fRef) return (fRef->Charge() < 0); return kFALSE;}
Bool_t IsNeutral() const {if (fRef) return (!IsCharged()); return kFALSE;}
Short_t ChargeS() const {if (IsPos()) return 1 ; else if (IsNeg()) return -1 ; else return 0 ;}
Char_t ChargeC() const {if (IsPos()) return '+'; else if (IsNeg()) return '-'; else return '0';}
-
- // getters which automatically convert refs into allowed types
+
+ // getters which automatically convert refs into allowed types
static Bool_t Match(AliVParticle *p, TClass *ref) {if (p) return (p->InheritsFrom(ref)); return kFALSE;}
Bool_t MatchRef(TClass *ref) {return Match(fRef, ref);}
Bool_t MatchRefMC(TClass *ref) {return Match(fRefMC, ref);}
Bool_t IsESD();
Bool_t IsAOD();
- AliVTrack* Ref2Vtrack() {if (Match(fRef, AliVTrack ::Class())) return static_cast<AliVTrack*> (fRef); return 0x0;}
- AliESDtrack* Ref2ESDtrack() {if (Match(fRef, AliESDtrack ::Class())) return static_cast<AliESDtrack*> (fRef); return 0x0;}
- AliAODTrack* Ref2AODtrack() {if (Match(fRef, AliAODTrack ::Class())) return static_cast<AliAODTrack*> (fRef); return 0x0;}
- AliMCParticle* Ref2MCparticle() {if (Match(fRef, AliMCParticle::Class())) return static_cast<AliMCParticle*> (fRef); return 0x0;}
- AliAODMCParticle* Ref2AODMCparticle() {if (Match(fRef, AliMCParticle::Class())) return static_cast<AliAODMCParticle*>(fRef); return 0x0;}
-
- AliESDv0* Ref2ESDv0() {if (Match(fRef, AliESDv0 ::Class())) return static_cast<AliESDv0*>(fRef); return 0x0;}
- AliAODv0* Ref2AODv0() {if (Match(fRef, AliAODv0 ::Class())) return static_cast<AliAODv0*>(fRef); return 0x0;}
-
- AliESDcascade* Ref2ESDcascade() {if (Match(fRef, AliESDcascade::Class())) return static_cast<AliESDcascade*>(fRef); return 0x0;}
- AliAODcascade* Ref2AODcascade() {if (Match(fRef, AliAODcascade::Class())) return static_cast<AliAODcascade*>(fRef); return 0x0;}
-
- AliMCParticle* RefMC2ESD() {if (Match(fRefMC, AliMCParticle ::Class())) return static_cast<AliMCParticle*> (fRef) ; return 0x0;}
- AliAODMCParticle* RefMC2AOD() {if (Match(fRefMC, AliAODMCParticle::Class())) return static_cast<AliAODMCParticle*>(fRefMC); return 0x0;}
-
+ AliVTrack *Ref2Vtrack() {if (Match(fRef, AliVTrack ::Class())) return static_cast<AliVTrack *> (fRef); return 0x0;}
+ AliESDtrack *Ref2ESDtrack() {if (Match(fRef, AliESDtrack ::Class())) return static_cast<AliESDtrack *> (fRef); return 0x0;}
+ AliAODTrack *Ref2AODtrack() {if (Match(fRef, AliAODTrack ::Class())) return static_cast<AliAODTrack *> (fRef); return 0x0;}
+ AliMCParticle *Ref2MCparticle() {if (Match(fRef, AliMCParticle::Class())) return static_cast<AliMCParticle *> (fRef); return 0x0;}
+ AliAODMCParticle *Ref2AODMCparticle() {if (Match(fRef, AliMCParticle::Class())) return static_cast<AliAODMCParticle *>(fRef); return 0x0;}
+
+ AliESDv0 *Ref2ESDv0() {if (Match(fRef, AliESDv0 ::Class())) return static_cast<AliESDv0 *>(fRef); return 0x0;}
+ AliAODv0 *Ref2AODv0() {if (Match(fRef, AliAODv0 ::Class())) return static_cast<AliAODv0 *>(fRef); return 0x0;}
+
+ AliESDcascade *Ref2ESDcascade() {if (Match(fRef, AliESDcascade::Class())) return static_cast<AliESDcascade *>(fRef); return 0x0;}
+ AliAODcascade *Ref2AODcascade() {if (Match(fRef, AliAODcascade::Class())) return static_cast<AliAODcascade *>(fRef); return 0x0;}
+
+ AliMCParticle *RefMC2ESD() {if (Match(fRefMC, AliMCParticle ::Class())) return static_cast<AliMCParticle *> (fRef) ; return 0x0;}
+ AliAODMCParticle *RefMC2AOD() {if (Match(fRefMC, AliAODMCParticle::Class())) return static_cast<AliAODMCParticle *>(fRefMC); return 0x0;}
+
// static functions related to internal ESpecies enum
static ERefType RefType(ESpecies species);
static Bool_t IsCharged(ESpecies species) {return (species <= kProton);}
- static const char* SpeciesName(ESpecies species);
+ static const char *SpeciesName(ESpecies species);
static Int_t SpeciesPDG(ESpecies species);
static Double_t SpeciesMass(ESpecies species);
static EPARTYPE ToAliPID(ESpecies species);
Int_t fLabel; // index of MC particle
Int_t fMotherPDG; // PDG code of mother (makes sense only if fRefMC is defined)
Int_t fRsnID; // internal ID for monitoring purposes
-
+
TLorentzVector fPrec; // 4-momentum for rec
TLorentzVector fPsim; // 4-momentum for MC
if (Match(fRef, AliAODv0 ::Class())) return kV0;
if (Match(fRef, AliAODcascade::Class())) return kCascade;
if (Match(fRef, AliMCParticle::Class())) return kTrack;
-
+
return kNoType;
}
{
//
// Tells if the object pointed by fRef data member is ESD
-// NOTE: it is true even when fRef is the MC corresponding
+// NOTE: it is true even when fRef is the MC corresponding
// object (= AliMCParticle)
//
if (Match(fRef, AliESDv0 ::Class())) return kTRUE;
if (Match(fRef, AliESDcascade::Class())) return kTRUE;
if (Match(fRef, AliMCParticle::Class())) return kTRUE;
-
+
return kFALSE;
}
{
//
// Tells if the object pointed by fRef data member is AOD
-// NOTE: it is true even when fRef is the MC corresponding
+// NOTE: it is true even when fRef is the MC corresponding
// object (= AliAODMCParticle)
//
if (Match(fRef, AliAODv0 ::Class())) return kTRUE;
if (Match(fRef, AliAODcascade ::Class())) return kTRUE;
if (Match(fRef, AliAODMCParticle::Class())) return kTRUE;
-
+
return kFALSE;
}
// -- defines the mass to be assigned to this object, for any purpose
// (e.g.: to compute its 4-momentum to be used for a resonance mass)
//
-// -- track charge, which can be '+', '-', '0',
+// -- track charge, which can be '+', '-', '0',
// -- any other char leaves this undefined (use only in daughter monitor loops)
// -- when doing resonance analysis, or when RSN Input handler needs to be used,
// this must always be defined
-//
+//
// -- object type (track/V0/cascade)
// -- could be needed to select tracks when particle species is not specified
// -- works only in single daughter loops
}
//_____________________________________________________________________________
-AliRsnDaughterDef& AliRsnDaughterDef::operator=(const AliRsnDaughterDef ©)
+AliRsnDaughterDef &AliRsnDaughterDef::operator=(const AliRsnDaughterDef ©)
{
//
// Assignment operator has standard behavior.
//
- if (this == ©)
- return *this;
-
+ if (this == ©)
+ return *this;
+
fMass = copy.fMass;
fCharge = copy.fCharge;
fPID = copy.fPID;
// -- defines the mass to be assigned to this object, for any purpose
// (e.g.: to compute its 4-momentum to be used for a resonance mass)
//
-// -- track charge, which can be '+', '-', '0',
+// -- track charge, which can be '+', '-', '0',
// -- any other char leaves this undefined (use only in daughter monitor loops)
// -- when doing resonance analysis, or when RSN Input handler needs to be used,
// this must always be defined
-//
+//
// -- object type (track/V0/cascade)
// -- could be needed to select tracks when particle species is not specified
// -- works only in single daughter loops
-//
+//
#include "AliRsnDaughter.h"
AliRsnDaughterDef(AliRsnDaughter::ESpecies type, Char_t charge = 0);
AliRsnDaughterDef(AliRsnDaughter::ERefType refType, Char_t charge = 0);
AliRsnDaughterDef(const AliRsnDaughterDef ©);
- AliRsnDaughterDef& operator= (const AliRsnDaughterDef ©);
+ AliRsnDaughterDef &operator= (const AliRsnDaughterDef ©);
virtual ~AliRsnDaughterDef() { }
AliRsnDaughter::ESpecies GetPID() const {return fPID;}
Char_t GetChargeC() const {return fCharge;}
Short_t GetChargeS() const {if (fCharge == '+') return 1; else if (fCharge == '-') return -1; else return 0;}
AliRsnDaughter::ERefType GetRefType() const {return fRefType;}
- virtual const char* GetName() const {return Form("%s%c", AliRsnDaughter::SpeciesName(fPID), fCharge);}
+ virtual const char *GetName() const {return Form("%s%c", AliRsnDaughter::SpeciesName(fPID), fCharge);}
Bool_t IsChargeDefined() const {return (fCharge == '+' || fCharge == '-' || fCharge == '0');}
-
+
void SetPID(AliRsnDaughter::ESpecies pid) {fPID = pid; fRefType = AliRsnDaughter::RefType(pid); fMass = AliRsnDaughter::SpeciesMass(pid);}
void SetCharge(Char_t charge) {fCharge = charge;}
void SetRefType(AliRsnDaughter::ERefType type) {fRefType = type;}
-
+
Bool_t MatchesPID(AliRsnDaughter *daughter);
Bool_t MatchesCharge(AliRsnDaughter *daughter) const;
Bool_t MatchesRefType(AliRsnDaughter *daughter) const;
inline Bool_t AliRsnDaughterDef::MatchesPID(AliRsnDaughter *daughter)
{
//
-// Checks if the passed daughter true particle type
+// Checks if the passed daughter true particle type
// matches the species defined in fPID data member,
// by comparing the corresponding PDG codes of both in absolute value.
// Returns kTRUE when the two codes match, and kFALSE when:
AliError("The passed argument has NULL MC pointer: cannot check PDG matching with this DaughterDef");
return kFALSE;
}
-
+
return MatchesPDG(daughter->GetPDGAbs());
}
-
+
//__________________________________________________________________________________________________
inline Bool_t AliRsnDaughterDef::MatchesCharge(AliRsnDaughter *daughter) const
{
//
AliRsnDaughter::ERefType type = daughter->RefType();
-
- if (fRefType != AliRsnDaughter::kNoType)
+
+ if (fRefType != AliRsnDaughter::kNoType)
return (type == fRefType);
else
return kTRUE;
ClassImp(AliRsnDaughterSelector)
//__________________________________________________________________________________________________
-AliRsnDaughterSelector::AliRsnDaughterSelector(const char *name, const char *title) :
+AliRsnDaughterSelector::AliRsnDaughterSelector(const char *name, const char *title) :
TNamed(name, title),
fCutSetsN("AliRsnCutSet", 0),
fCutSetsC("AliRsnCutSet", 0),
}
//__________________________________________________________________________________________________
-AliRsnDaughterSelector::AliRsnDaughterSelector(const AliRsnDaughterSelector& copy) :
+AliRsnDaughterSelector::AliRsnDaughterSelector(const AliRsnDaughterSelector ©) :
TNamed(copy),
fCutSetsN(copy.fCutSetsN),
fCutSetsC(copy.fCutSetsC),
}
//__________________________________________________________________________________________________
-AliRsnDaughterSelector& AliRsnDaughterSelector::operator=(const AliRsnDaughterSelector& copy)
+AliRsnDaughterSelector &AliRsnDaughterSelector::operator=(const AliRsnDaughterSelector ©)
{
//
// Copy constructor.
TNamed::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fCutSetsN = copy.fCutSetsN;
fCutSetsC = copy.fCutSetsC;
fEntryListsN = copy.fEntryListsN;
fEntryListsM = copy.fEntryListsM;
AliDebug(AliLog::kDebug + 10, "->");
-
+
return (*this);
}
//
AliDebug(AliLog::kDebug + 10, "<-");
-
+
fCutSetsN.Delete();
fCutSetsC.Delete();
fEntryListsN.Delete();
fEntryListsP.Delete();
fEntryListsM.Delete();
-
+
AliDebug(AliLog::kDebug + 10, "->");
}
//__________________________________________________________________________________________________
-void AliRsnDaughterSelector::Print(Option_t* option) const
+void AliRsnDaughterSelector::Print(Option_t *option) const
{
//
// Override TObject::Print()
//
TNamed::Print(option);
-
+
Int_t i, nSets;
AliRsnCutSet *set = 0x0;
TEntryList *list = 0x0;
-
+
// neutral
nSets = fCutSetsN.GetEntries();
for (i = 0; i < nSets; i++) {
- set = (AliRsnCutSet*)fCutSetsN[i];
- list = (TEntryList*)fEntryListsN[i];
+ set = (AliRsnCutSet *)fCutSetsN[i];
+ list = (TEntryList *)fEntryListsN[i];
AliInfo(Form("Neutral entry list for cut set '%s' has %d entries", set->GetName(), (Int_t)list->GetN()));
}
-
+
// charged
nSets = fCutSetsC.GetEntries();
for (i = 0; i < nSets; i++) {
- set = (AliRsnCutSet*)fCutSetsC[i];
- list = (TEntryList*)fEntryListsP[i];
+ set = (AliRsnCutSet *)fCutSetsC[i];
+ list = (TEntryList *)fEntryListsP[i];
AliInfo(Form("Positive entry list for cut set '%s' has %d entries", set->GetName(), (Int_t)list->GetN()));
- list = (TEntryList*)fEntryListsM[i];
+ list = (TEntryList *)fEntryListsM[i];
AliInfo(Form("Negative entry list for cut set '%s' has %d entries", set->GetName(), (Int_t)list->GetN()));
}
}
// of the corresponding arrays of cut sets.
// If they are not empty, they are cleared.
//
-
+
Int_t i, nSets;
-
+
// neutral
nSets = fCutSetsN.GetEntries();
if (!fEntryListsN.IsEmpty()) fEntryListsN.Delete();
for (i = 0; i < nSets; i++) {
- AliRsnCutSet *set = (AliRsnCutSet*)fCutSetsN[i];
+ AliRsnCutSet *set = (AliRsnCutSet *)fCutSetsN[i];
new (fEntryListsN[i]) TEntryList;
AliInfo(Form("Adding 1 entry list for neutrals --> cut set '%s' [scheme = '%s']", set->GetName(), set->GetCutScheme().Data()));
}
-
+
// charged
nSets = fCutSetsC.GetEntries();
if (!fEntryListsP.IsEmpty()) fEntryListsP.Delete();
if (!fEntryListsM.IsEmpty()) fEntryListsM.Delete();
for (i = 0; i < nSets; i++) {
- AliRsnCutSet *set = (AliRsnCutSet*)fCutSetsC[i];
+ AliRsnCutSet *set = (AliRsnCutSet *)fCutSetsC[i];
new (fEntryListsP[i]) TEntryList;
new (fEntryListsM[i]) TEntryList;
AliInfo(Form("Adding 2 entry lists for charged --> cut set '%s' [scheme = '%s']", set->GetName(), set->GetCutScheme().Data()));
{
TEntryList *el;
Int_t i, nSets;
-
+
// N
nSets = fCutSetsN.GetEntries();
for (i = 0; i < nSets; i++) {
- el = (TEntryList*)fEntryListsN.At(i);
+ el = (TEntryList *)fEntryListsN.At(i);
el->Reset();
}
-
+
// charged
nSets = fCutSetsC.GetEntries();
for (i = 0; i < nSets; i++) {
- el = (TEntryList*)fEntryListsP.At(i);
+ el = (TEntryList *)fEntryListsP.At(i);
el->Reset();
- el = (TEntryList*)fEntryListsM.At(i);
+ el = (TEntryList *)fEntryListsM.At(i);
el->Reset();
}
}
//
Int_t n = 0;
-
+
if (!charged) {
n = fCutSetsN.GetEntries();
new (fCutSetsN[n]) AliRsnCutSet(*cuts);
n = fCutSetsC.GetEntries();
new (fCutSetsC[n]) AliRsnCutSet(*cuts);
}
-
+
return n;
}
//
AliRsnCutSet *cuts;
-
+
if (!charged) {
- cuts = (AliRsnCutSet*)fCutSetsN.FindObject(name);
+ cuts = (AliRsnCutSet *)fCutSetsN.FindObject(name);
if (cuts) return fCutSetsN.IndexOf(cuts);
} else {
- cuts = (AliRsnCutSet*)fCutSetsC.FindObject(name);
+ cuts = (AliRsnCutSet *)fCutSetsC.FindObject(name);
if (cuts) return fCutSetsC.IndexOf(cuts);
}
-
+
return -1;
}
//__________________________________________________________________________________________________
-TEntryList* AliRsnDaughterSelector::GetSelected(Int_t i, Char_t charge)
+TEntryList *AliRsnDaughterSelector::GetSelected(Int_t i, Char_t charge)
{
//
// Retrieve a given entry list (needs charge specified as a char)
//
if (charge == '+')
- return (TEntryList*)fEntryListsP.At(i);
+ return (TEntryList *)fEntryListsP.At(i);
else if (charge == '-')
- return (TEntryList*)fEntryListsM.At(i);
+ return (TEntryList *)fEntryListsM.At(i);
else
- return (TEntryList*)fEntryListsN.At(i);
+ return (TEntryList *)fEntryListsN.At(i);
}
//__________________________________________________________________________________________________
-TEntryList* AliRsnDaughterSelector::GetSelected(Int_t i, Short_t charge)
+TEntryList *AliRsnDaughterSelector::GetSelected(Int_t i, Short_t charge)
{
//
// Retrieve a given entry list passing charge as short
//
if (charge > 0)
- return (TEntryList*)fEntryListsP.At(i);
+ return (TEntryList *)fEntryListsP.At(i);
else if (charge < 0)
- return (TEntryList*)fEntryListsM.At(i);
+ return (TEntryList *)fEntryListsM.At(i);
else
- return (TEntryList*)fEntryListsN.At(i);
+ return (TEntryList *)fEntryListsN.At(i);
}
//__________________________________________________________________________________________________
-void AliRsnDaughterSelector::ScanEvent(AliRsnEvent* ev)
+void AliRsnDaughterSelector::ScanEvent(AliRsnEvent *ev)
{
//
// Loop over event and fill all entry lists
Int_t nSel, nTot = ev->GetAbsoluteSum();
AliRsnDaughter check;
TClonesArray *cutsArray = 0x0, *entryArray = 0x0;
-
+
for (id = 0; id < nTot; id++) {
ev->SetDaughter(check, id);
// some checks
// check with all cuts in that charge
nSel = cutsArray->GetEntries();
for (is = 0; is < nSel; is++) {
- AliRsnCutSet *cuts = (AliRsnCutSet*)cutsArray->At(is);
+ AliRsnCutSet *cuts = (AliRsnCutSet *)cutsArray->At(is);
if (cuts->IsSelected(&check)) {
- TEntryList *el = (TEntryList*)entryArray->At(is);
+ TEntryList *el = (TEntryList *)entryArray->At(is);
el->Enter(id);
}
}
}
-
+
//Print();
}
public:
AliRsnDaughterSelector(const char *name = "name", const char *title = "title");
- AliRsnDaughterSelector(const AliRsnDaughterSelector& copy);
+ AliRsnDaughterSelector(const AliRsnDaughterSelector ©);
AliRsnDaughterSelector &operator=(const AliRsnDaughterSelector ©);
virtual ~AliRsnDaughterSelector();
void Reset();
Int_t Add(AliRsnCutSet *cuts, Bool_t charged);
Int_t GetID(const char *cutSetName, Bool_t charged);
- TEntryList* GetSelected(Int_t i, Char_t charge);
- TEntryList* GetSelected(Int_t i, Short_t charge);
+ TEntryList *GetSelected(Int_t i, Char_t charge);
+ TEntryList *GetSelected(Int_t i, Short_t charge);
void ScanEvent(AliRsnEvent *ev);
-
- virtual void Print(Option_t* option = "") const;
+
+ virtual void Print(Option_t *option = "") const;
+
+ TClonesArray *GetCutSetC() {return &fCutSetsC;}
+ TClonesArray *GetCutSetN() {return &fCutSetsN;}
private:
TClonesArray fCutSetsN; // cuts for neutral daughters
TClonesArray fCutSetsC; // cuts for charged daughters (usually, the same)
-
+
TClonesArray fEntryListsN; // entry lists for neutrals
TClonesArray fEntryListsP; // entry lists for charged (one per sign)
TClonesArray fEntryListsM; // entry lists for charged (one per sign)
// which could be needed during analysis, which are not in AliVEvent but
// need to be accessed from ESD or AOD objects, usually in different ways.
// When MC is available, it is properly taken into account.
-//
+//
// authors: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
// M. Vala (martin.vala@cern.ch)
//
}
//_____________________________________________________________________________
-AliRsnEvent& AliRsnEvent::operator= (const AliRsnEvent & event)
+AliRsnEvent &AliRsnEvent::operator= (const AliRsnEvent &event)
{
//
// Works in the same way as the copy constructor.
//
TObject::operator=(event);
- if (this == &event)
- return *this;
+ if (this == &event)
+ return *this;
fRef = event.fRef;
fRefMC = event.fRefMC;
fLeading = event.fLeading;
out.Reset();
out.SetRsnID(index);
out.SetOwnerEvent(this);
-
+
// check input type
if (!InputOK()) return;
Bool_t inputESD = IsESD();
-
- Int_t trueIndex;
- AliRsnDaughter::ERefType type;
- if (!ConvertAbsoluteIndex(index, trueIndex, type)) {
- AliError(Form("Failed to convert absolute index %d", index));
+
+ Int_t trueIndex;
+ AliRsnDaughter::ERefType type;
+ if (!ConvertAbsoluteIndex(index, trueIndex, type)) {
+ AliError(Form("Failed to convert absolute index %d", index));
+ return;
+ }
+ switch (type) {
+ case AliRsnDaughter::kTrack:
+ if (inputESD) {
+ SetDaughterESDtrack(out, trueIndex);
+
+ } else {
+ SetDaughterAODtrack(out, trueIndex);
+ }
+ break;
+ case AliRsnDaughter::kV0:
+ if (inputESD) SetDaughterESDv0(out, trueIndex); else SetDaughterAODv0(out, trueIndex);
+ break;
+ case AliRsnDaughter::kCascade:
+ if (inputESD) SetDaughterESDcascade(out, trueIndex); else SetDaughterAODcascade(out, trueIndex);
+ break;
+ default:
+ AliError("Unrecognized daughter type");
return;
- }
- switch (type) {
- case AliRsnDaughter::kTrack:
- if (inputESD) {
- SetDaughterESDtrack(out, trueIndex);
-
- } else {
- SetDaughterAODtrack(out, trueIndex);
- }
- break;
- case AliRsnDaughter::kV0:
- if (inputESD) SetDaughterESDv0(out, trueIndex); else SetDaughterAODv0(out, trueIndex);
- break;
- case AliRsnDaughter::kCascade:
- if (inputESD) SetDaughterESDcascade(out, trueIndex); else SetDaughterAODcascade(out, trueIndex);
- break;
- default:
- AliError("Unrecognized daughter type");
- return;
- }
+ }
// if it is pure MC, the index tells what particle
// to be read in the stack of MC particles, otherwise
// Version #1: ESD tracks
//
- AliESDEvent *esd = (AliESDEvent*)fRef;
-
+ AliESDEvent *esd = (AliESDEvent *)fRef;
+
if (i >= 0 && i < esd->GetNumberOfTracks()) {
AliESDtrack *track = esd->GetTrack(i);
if (track) {
// Version #2: AOD tracks
//
- AliAODEvent *aod = (AliAODEvent*)fRef;
+ AliAODEvent *aod = (AliAODEvent *)fRef;
if (i >= 0 && i < aod->GetNumberOfTracks()) {
AliAODTrack *track = aod->GetTrack(i);
out.SetGood();
// if MC is present, retrieve the label of V0 from those of daughters
if (fRefMC) {
- AliMCEvent *mc = (AliMCEvent*)fRefMC;
+ AliMCEvent *mc = (AliMCEvent *)fRefMC;
AliESDtrack *tp = ev->GetTrack(v0->GetPindex());
AliESDtrack *tn = ev->GetTrack(v0->GetNindex());
if (mc && tp && tn) {
//
if (i >= 0 && i < fRef->GetNumberOfV0s()) {
- AliAODEvent *ev = (AliAODEvent*)fRef;
+ AliAODEvent *ev = (AliAODEvent *)fRef;
AliAODv0 *v0 = ev->GetV0(i);
if (v0) {
out.SetRef(v0);
out.SetGood();
if (fRefMC) {
- AliAODEvent *mc = (AliAODEvent*)fRefMC;
- TClonesArray *mcArray = (TClonesArray*)mc->GetList()->FindObject(AliAODMCParticle::StdBranchName());
- AliAODTrack *tp = (AliAODTrack*)v0->GetDaughter(0);
- AliAODTrack *tn = (AliAODTrack*)v0->GetDaughter(1);
+ AliAODEvent *mc = (AliAODEvent *)fRefMC;
+ TClonesArray *mcArray = (TClonesArray *)mc->GetList()->FindObject(AliAODMCParticle::StdBranchName());
+ AliAODTrack *tp = (AliAODTrack *)v0->GetDaughter(0);
+ AliAODTrack *tn = (AliAODTrack *)v0->GetDaughter(1);
if (mcArray && tp && tn) {
Int_t lp = TMath::Abs(tp->GetLabel());
Int_t ln = TMath::Abs(tn->GetLabel());
- AliAODMCParticle *pp = (AliAODMCParticle*)mcArray->At(lp);
- AliAODMCParticle *pn = (AliAODMCParticle*)mcArray->At(ln);
+ AliAODMCParticle *pp = (AliAODMCParticle *)mcArray->At(lp);
+ AliAODMCParticle *pn = (AliAODMCParticle *)mcArray->At(ln);
if (pp && pn) {
// if their first mothers are the same, the V0 is true
// otherwise label remains '-1' --> fake V0
out.SetRef(casc);
out.SetGood();
if (fRefMC) {
-
+
}
}
}
out.SetRef(casc);
out.SetGood();
if (fRefMC) {
-
+
}
}
}
// if label makes no sense --> failed
Int_t label = out.GetLabel();
if (label < 0 || !fRefMC) return kFALSE;
-
+
// get number of particles
Int_t nMC = fRefMC->GetNumberOfTracks();
-
+
// if label too large --> failed
if (label >= nMC) {
AliWarning(Form("Stack overflow: track label = %d -- stack maximum = %d", label, nMC));
}
// retrieve particle
- AliMCEvent *mc = (AliMCEvent*)fRefMC;
- AliMCParticle *mcPart = (AliMCParticle*)mc->GetTrack(label);
-
+ AliMCEvent *mc = (AliMCEvent *)fRefMC;
+ AliMCParticle *mcPart = (AliMCParticle *)mc->GetTrack(label);
+
// if particle = NULL --> failed
if (!mcPart) {
AliWarning(Form("Stack discontinuity: label %d refers to a NULL object", label));
// if the particle is not primary, find the mother and get its PDG
Int_t imum = mcPart->Particle()->GetFirstMother();
if (imum >= 0 && imum < nMC) {
- AliMCParticle *mcMother = (AliMCParticle*)mc->GetTrack(imum);
+ AliMCParticle *mcMother = (AliMCParticle *)mc->GetTrack(imum);
if (mcMother) {
out.SetMotherPDG(TMath::Abs(mcMother->Particle()->GetPdgCode()));
} else {
// if label makes no sense --> failed
Int_t label = out.GetLabel();
if (label < 0 || !fRefMC) return kFALSE;
-
+
// retrieve particle
- AliAODEvent *mc = (AliAODEvent*)fRefMC;
- TClonesArray *mcArray = (TClonesArray*)mc->GetList()->FindObject(AliAODMCParticle::StdBranchName());
-
+ AliAODEvent *mc = (AliAODEvent *)fRefMC;
+ TClonesArray *mcArray = (TClonesArray *)mc->GetList()->FindObject(AliAODMCParticle::StdBranchName());
+
// get number of particles
Int_t nMC = mcArray->GetEntriesFast();
-
+
// if label too large --> failed
if (label >= nMC) {
AliWarning(Form("Stack overflow: track label = %d -- stack maximum = %d", label, nMC));
return kFALSE;
}
-
+
// if particle = NULL --> failed
- AliAODMCParticle *mcPart = (AliAODMCParticle*)mcArray->At(label);
+ AliAODMCParticle *mcPart = (AliAODMCParticle *)mcArray->At(label);
if (!mcPart) {
AliWarning(Form("Stack discontinuity: label %d refers to a NULL object", label));
return kFALSE;
// if the particle is not primary, find the mother and get its PDG
Int_t imum = mcPart->GetMother();
if (imum >= 0 && imum < nMC) {
- AliAODMCParticle *mcMother = (AliAODMCParticle*)mcArray->At(imum);
+ AliAODMCParticle *mcMother = (AliAODMCParticle *)mcArray->At(imum);
if (mcMother) {
out.SetMotherPDG(TMath::Abs(mcMother->GetPdgCode()));
} else {
Double_t ptMax = 0.0;
Int_t i, nTracks = fRef->GetNumberOfTracks();
-
+
fLeading = -1;
AliRsnDaughter leading;
fLeading = i;
}
}
-
+
return fLeading;
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
+
////////////////////////////////////////////////////////////////////////////////
//
// Interface to full event.
public:
AliRsnEvent(AliVEvent *ref = 0, AliVEvent *refMC = 0);
- AliRsnEvent(const AliRsnEvent& copy);
- AliRsnEvent& operator= (const AliRsnEvent& copy);
+ AliRsnEvent(const AliRsnEvent ©);
+ AliRsnEvent &operator= (const AliRsnEvent ©);
virtual ~AliRsnEvent();
// basic setters/getters
void SetRef(AliVEvent *ref) {fRef = ref;}
void SetRefMC(AliVEvent *refmc);
void SetPIDResponse(AliPIDResponse *pid) {fPID = pid;}
- AliVEvent* GetRef() {return fRef;}
- AliVEvent* GetRefMC() {return fRefMC;}
+ AliVEvent *GetRef() {return fRef;}
+ AliVEvent *GetRefMC() {return fRefMC;}
Int_t GetLeadingIndex() const {return fLeading;}
- AliPIDResponse* GetPIDResponse() {return fPID;}
+ AliPIDResponse *GetPIDResponse() {return fPID;}
// getters which convert into allowed input types
Bool_t Match(AliVEvent *ev, TClass *ref) {if (ev) return (ev->InheritsFrom(ref)); return kFALSE;}
Bool_t IsESD() {return (Match(fRef, AliESDEvent::Class()));}
Bool_t IsAOD() {return (Match(fRef, AliAODEvent::Class()));}
- Bool_t InputOK();
- AliESDEvent* GetRefESD() {if (IsESD()) return (AliESDEvent*)fRef; return 0x0;}
- AliMCEvent* GetRefMCESD() {if (IsESD()) return (AliMCEvent *)fRefMC; return 0x0;}
- AliAODEvent* GetRefAOD() {if (IsAOD()) return (AliAODEvent*)fRef; return 0x0;}
- AliAODEvent* GetRefMCAOD() {if (IsAOD()) return (AliAODEvent*)fRefMC; return 0x0;}
- TClonesArray* GetAODList() {return fAODList;}
+ Bool_t InputOK();
+ AliESDEvent *GetRefESD() {if (IsESD()) return (AliESDEvent *)fRef; return 0x0;}
+ AliMCEvent *GetRefMCESD() {if (IsESD()) return (AliMCEvent *)fRefMC; return 0x0;}
+ AliAODEvent *GetRefAOD() {if (IsAOD()) return (AliAODEvent *)fRef; return 0x0;}
+ AliAODEvent *GetRefMCAOD() {if (IsAOD()) return (AliAODEvent *)fRefMC; return 0x0;}
+ TClonesArray *GetAODList() {return fAODList;}
Bool_t HasMC() {if (IsESD()) return (fRefMC != 0x0); else if (IsAOD()) return (fRefMC != 0x0 && fAODList != 0x0); return kFALSE;}
// setters for a daughter
void SetDaughterAODMCtrack(AliRsnDaughter &target, Int_t index);
Bool_t SetMCInfoESD (AliRsnDaughter &target);
Bool_t SetMCInfoAOD (AliRsnDaughter &target);
-
+
// counters/converters of candidates
Int_t GetAbsoluteSum() {if (fRef) return (fRef->GetNumberOfTracks() + fRef->GetNumberOfV0s() + fRef->GetNumberOfCascades()); return 0;}
Bool_t ConvertAbsoluteIndex(Int_t index, Int_t &realIndex, AliRsnDaughter::ERefType &type);
// leading particle stuff
void SetLeadingParticle(AliRsnDaughter &leading) {if (fLeading >= 0) SetDaughter(leading, fLeading, kFALSE);}
Int_t SelectLeadingParticle(AliRsnCutSet *cuts = 0x0);
-
+
private:
AliVEvent *fRef; // pointer to input event
}
}
-inline void AliRsnEvent::SetRefMC(AliVEvent *mc)
+inline void AliRsnEvent::SetRefMC(AliVEvent *mc)
{
//
// Assign pointer to MC event.
fRefMC = mc;
fAODList = 0x0;
if (fRefMC->InheritsFrom(AliAODEvent::Class())) {
- AliAODEvent *aod = (AliAODEvent*)mc;
- fAODList = (TClonesArray*)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
+ AliAODEvent *aod = (AliAODEvent *)mc;
+ fAODList = (TClonesArray *)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
if (!fAODList) fRefMC = 0x0;
}
}
fOperator(0)
{
// Default constructor
- TObjArray* tokens = Tokenize(exp);
+ TObjArray *tokens = Tokenize(exp);
Int_t i = -1;
- AliRsnExpression* e = Expression(*tokens, i);
+ AliRsnExpression *e = Expression(*tokens, i);
// Copy !!!
fArg1 = e->fArg1; e->fArg1 = 0;
fArg2 = e->fArg2; e->fArg2 = 0;
if (fArg2) delete fArg2;
}
-AliRsnExpression::AliRsnExpression(const AliRsnExpression & exp) : TObject(exp),
+AliRsnExpression::AliRsnExpression(const AliRsnExpression &exp) : TObject(exp),
fVname(exp.fVname),
fArg1(exp.fArg1),
fArg2(exp.fArg2),
{}
//______________________________________________________________________________
-AliRsnExpression& AliRsnExpression::operator= (const AliRsnExpression& e)
+AliRsnExpression &AliRsnExpression::operator= (const AliRsnExpression &e)
{
// AliRsnExpression assignment operator.
}
//______________________________________________________________________________
-AliRsnExpression::AliRsnExpression(int op, AliRsnExpression* a, AliRsnExpression* b) :
+AliRsnExpression::AliRsnExpression(int op, AliRsnExpression *a, AliRsnExpression *b) :
TObject(),
fVname(""),
fArg1(a),
}
//______________________________________________________________________________
-AliRsnExpression::AliRsnExpression(int op, AliRsnExpression* a) :
+AliRsnExpression::AliRsnExpression(int op, AliRsnExpression *a) :
TObject(),
fVname(""),
fArg1(0),
}
//______________________________________________________________________________
-TObjArray* AliRsnExpression::Tokenize(TString str) const
+TObjArray *AliRsnExpression::Tokenize(TString str) const
{
// tokenize the expression
str1.Append(str[i]);
}
// get variable tokens
- TObjArray* valtok = str1.Tokenize("!&|()");
+ TObjArray *valtok = str1.Tokenize("!&|()");
// put all variables together
Int_t nvt = valtok->GetEntriesFast();
TString sumval;
for (Int_t i = 0; i < nvt; i++) {
- TObjString* val = (TObjString*) valtok->At(i);
+ TObjString *val = (TObjString *) valtok->At(i);
sumval.Append(val->String());
}
// get the operator tokens
- TObjArray* optok = str1.Tokenize(sumval.Data());
+ TObjArray *optok = str1.Tokenize(sumval.Data());
// put all operator in one string
TString operators;
Int_t nopt = optok->GetEntriesFast();
for (Int_t i = 0; i < nopt; i++) {
- TObjString* val1 = (TObjString*) optok->At(i);
+ TObjString *val1 = (TObjString *) optok->At(i);
operators.Append(val1->String());
}
// add more room to be safe
- TObjString* blank = new TObjString(" ");
+ TObjString *blank = new TObjString(" ");
operators.Append(" ");
valtok->AddLast(blank);
// Now put var. and oper. together
- TObjArray* tokens = new TObjArray(valtok->GetEntriesFast() + operators.Length());
+ TObjArray *tokens = new TObjArray(valtok->GetEntriesFast() + operators.Length());
int io = 0, iv = 0;
int index = 0;
while (1) {
TString so = operators[io];
int indexO = str1.Index(so, index);
- TString val2 = ((TObjString*) valtok->At(iv))->String();
+ TString val2 = ((TObjString *) valtok->At(iv))->String();
int indexV = str1.Index(val2, index);
if ((indexO < indexV || indexV < 0) && indexO >= 0) {
tokens->AddLast(new TObjString(so));
//______________________________________________________________________________
-AliRsnExpression* AliRsnExpression::Element(TObjArray &st, Int_t &i)
+AliRsnExpression *AliRsnExpression::Element(TObjArray &st, Int_t &i)
{
// create an element
- AliRsnExpression* result = 0;
+ AliRsnExpression *result = 0;
Int_t nt = st.GetEntriesFast();
TString token = "@";
- TObjString* valt;
+ TObjString *valt;
// next token
if (i < nt - 1) {
i++;
- valt = (TObjString*) st.At(i);
+ valt = (TObjString *) st.At(i);
token = valt->String();
}
// token type
// next token
if (i < nt - 1) {
i++;
- valt = (TObjString*) st.At(i);
+ valt = (TObjString *) st.At(i);
token = valt->String();
}
if (token[0] != ')') {
}
//______________________________________________________________________________
-AliRsnExpression* AliRsnExpression::Primary(TObjArray &st, Int_t &i)
+AliRsnExpression *AliRsnExpression::Primary(TObjArray &st, Int_t &i)
{
// create a primary
Int_t nt = st.GetEntriesFast();
TString token = "@";
- TObjString* valt;
+ TObjString *valt;
// next token
if (i < nt - 1) {
i++;
- valt = (TObjString*) st.At(i);
+ valt = (TObjString *) st.At(i);
token = valt->String();
}
}
//______________________________________________________________________________
-AliRsnExpression* AliRsnExpression::Expression(TObjArray &st, Int_t &i)
+AliRsnExpression *AliRsnExpression::Expression(TObjArray &st, Int_t &i)
{
// create an expression
- AliRsnExpression* result = 0;
+ AliRsnExpression *result = 0;
Bool_t done = kFALSE;
TString token;
- TObjString* valt;
+ TObjString *valt;
static int stack = 0;
stack++;
// next token
if (i < nt - 1) i++;
else break;
- valt = (TObjString*) st.At(i);
+ valt = (TObjString *) st.At(i);
token = valt->String();
switch (token[0]) {
case '&' :
AliRsnExpression() : fVname(0), fArg1(0), fArg2(0), fOperator(0) {}
AliRsnExpression(TString exp);
virtual ~AliRsnExpression();
- AliRsnExpression(const AliRsnExpression& exp);
- AliRsnExpression& operator= (const AliRsnExpression& exp);
+ AliRsnExpression(const AliRsnExpression &exp);
+ AliRsnExpression &operator= (const AliRsnExpression &exp);
- virtual Bool_t Value(TObjArray & vars);
+ virtual Bool_t Value(TObjArray &vars);
virtual TString Unparse() const;
- void SetCutSet(AliRsnCutSet* const theValue) { fgCutSet = theValue; }
- AliRsnCutSet* GetCutSet() const { return fgCutSet; }
+ void SetCutSet(AliRsnCutSet *const theValue) { fgCutSet = theValue; }
+ AliRsnCutSet *GetCutSet() const { return fgCutSet; }
TString fVname; // Variable name
static AliRsnCutSet *fgCutSet; // global cutset
private:
- AliRsnExpression* fArg1; // left argument
- AliRsnExpression* fArg2; // right argument
+ AliRsnExpression *fArg1; // left argument
+ AliRsnExpression *fArg2; // right argument
Int_t fOperator; // operator
- AliRsnExpression(int op, AliRsnExpression* a);
- AliRsnExpression(int op, AliRsnExpression* a, AliRsnExpression* b);
+ AliRsnExpression(int op, AliRsnExpression *a);
+ AliRsnExpression(int op, AliRsnExpression *a, AliRsnExpression *b);
- TObjArray* Tokenize(TString str) const;
- static AliRsnExpression* Element(TObjArray &st, Int_t &i);
- static AliRsnExpression* Primary(TObjArray &st, Int_t &i);
- static AliRsnExpression* Expression(TObjArray &st, Int_t &i);
+ TObjArray *Tokenize(TString str) const;
+ static AliRsnExpression *Element(TObjArray &st, Int_t &i);
+ static AliRsnExpression *Primary(TObjArray &st, Int_t &i);
+ static AliRsnExpression *Expression(TObjArray &st, Int_t &i);
ClassDef(AliRsnExpression, 1); // Class to evaluate an expression
};
}
//_____________________________________________________________________________
-AliRsnInputHandler& AliRsnInputHandler::operator=(const AliRsnInputHandler ©)
+AliRsnInputHandler &AliRsnInputHandler::operator=(const AliRsnInputHandler ©)
{
//
// Default constructor.
//
- if (this == ©)
- return *this;
+ if (this == ©)
+ return *this;
fRsnEventCuts = copy.fRsnEventCuts;
return *this;
}
if (fParentHandler) {
TString tmp = "";
AliInputEventHandler *ih = 0;
- AliMultiInputEventHandler *multiIH = dynamic_cast<AliMultiInputEventHandler*>(fParentHandler);
+ AliMultiInputEventHandler *multiIH = dynamic_cast<AliMultiInputEventHandler *>(fParentHandler);
if (multiIH) {
ih = multiIH->GetFirstInputEventHandler();
if (ih) {
if (mcH) fRsnEvent->SetRefMC(mcH->MCEvent());
} else if (fRsnEvent->GetRefAOD()) {
AliAODEvent *aod = fRsnEvent->GetRefAOD();
- TClonesArray *listAOD = (TClonesArray*)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
+ TClonesArray *listAOD = (TClonesArray *)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
if (listAOD) fRsnEvent->SetRefMC(fRsnEvent->GetRefAOD());
}
if (fParentHandler->ParentHandler()) tmp = "MIX";
//fRsnPIDManager.ApplyCuts(fRsnEvent);
fRsnSelector.Reset();
-
+
// reject event if needed
if (fRsnEventCuts) if (!fRsnEventCuts->IsSelected(fRsnEvent)) return kTRUE;
fRsnSelector.ScanEvent(fRsnEvent);
public:
AliRsnInputHandler(const char *name = "rsnInputHandler");
- AliRsnInputHandler(const AliRsnInputHandler& handler);
+ AliRsnInputHandler(const AliRsnInputHandler &handler);
AliRsnInputHandler &operator=(const AliRsnInputHandler &handler);
virtual ~AliRsnInputHandler();
//
#include <Riostream.h>
+#include <TList.h>
+#include <TCollection.h>
#include "AliLog.h"
#include "AliCFContainer.h"
#include "AliRsnValue.h"
+#include "AliRsnValueDaughter.h"
+#include "AliRsnValueEvent.h"
#include "AliRsnLoop.h"
#include "AliRsnListOutput.h"
+
ClassImp(AliRsnListOutput)
//________________________________________________________________________________________
}
//________________________________________________________________________________________
-AliRsnListOutput& AliRsnListOutput::operator=(const AliRsnListOutput& copy)
+AliRsnListOutput &AliRsnListOutput::operator=(const AliRsnListOutput ©)
{
//
// Assignment operator.
// they are anyway reset.
//
- TNamed::operator=(copy);
- if (this == ©)
- return *this;
- fSkipFailed = copy.fSkipFailed;
- fType = copy.fType;
- fSteps = copy.fSteps;
- fValues = copy.fValues;
- fNValues = copy.fNValues;
- fList = copy.fList;
- fIndex = copy.fIndex;
- fArray = copy.fArray;
-
+ TNamed::operator=(copy);
+ if (this == ©)
+ return *this;
+ fSkipFailed = copy.fSkipFailed;
+ fType = copy.fType;
+ fSteps = copy.fSteps;
+ fValues = copy.fValues;
+ fNValues = copy.fNValues;
+ fList = copy.fList;
+ fIndex = copy.fIndex;
+ fArray = copy.fArray;
+
Reset();
return (*this);
AliInfo(Form("NValues = %d > 3 --> cannot use a normal histogram, need to use a sparse", fNValues));
fType = kHistoSparse;
}
-
+
// resize the output array
fArray.Set(fNValues);
name += '_';
name += val->GetName();
}
-
+
// allowed objects
TObject *object = 0x0;
default:
AliWarning("Wrong type output or initialization failure");
}
-
+
if (object) {
//AliInfo(Form("[%s]: initializing output '%s' (obj name = '%s') with %d values and format %d [%s]", GetName(), name.Data(), object->GetName(), fNValues, fType, object->ClassName()));
fList = list;
}
//________________________________________________________________________________________
-TH1* AliRsnListOutput::CreateHistogram(const char *name)
+TH1 *AliRsnListOutput::CreateHistogram(const char *name)
{
//
// Initialize the 'default' TH1 output object.
nbins[i] = GetValue(i)->GetArray().GetSize() - 1;
array[i] = GetValue(i)->GetArray();
}
-
+
TH1 *hist = 0x0;
// create histogram depending on the number of axes
}
//________________________________________________________________________________________
-THnSparseF* AliRsnListOutput::CreateHistogramSparse(const char *name)
+THnSparseF *AliRsnListOutput::CreateHistogramSparse(const char *name)
{
//
// Initialize the THnSparse output object.
}
//________________________________________________________________________________________
-AliCFContainer* AliRsnListOutput::CreateCFContainer(const char *name)
+AliCFContainer *AliRsnListOutput::CreateCFContainer(const char *name)
{
//
// Initialize the AliCFContainer output object.
fArray[i] = (Double_t)val->GetComputedValue();
}
if (!globalOK && fSkipFailed) return kFALSE;
-
+
// retrieve object
if (!fList || fIndex < 0) {
AliError("List not initialized");
AliError("Null pointer");
return kFALSE;
}
-
+
// check
//AliInfo(Form("[%s] Object index, name, type = %d, %s (%s)", GetName(), fIndex, obj->GetName(), obj->ClassName()));
// fill output
if (obj->IsA() == TH1F::Class()) {
- TH1F *h = (TH1F*)obj;
+ TH1F *h = (TH1F *)obj;
h->Fill(fArray[0]);
return kTRUE;
} else if (obj->IsA() == TH2F::Class()) {
- TH2F *h = (TH2F*)obj;
+ TH2F *h = (TH2F *)obj;
h->Fill(fArray[0], fArray[1]);
return kTRUE;
} else if (obj->IsA() == TH3F::Class()) {
- TH3F *h = (TH3F*)obj;
+ TH3F *h = (TH3F *)obj;
h->Fill(fArray[0], fArray[1], fArray[2]);
return kTRUE;
} else if (obj->InheritsFrom(THnSparse::Class())) {
- THnSparseF *h = (THnSparseF*)obj;
+ THnSparseF *h = (THnSparseF *)obj;
h->Fill(fArray.GetArray());
return kTRUE;
} else if (obj->InheritsFrom(AliCFContainer::Class())) {
- AliCFContainer *c = (AliCFContainer*)obj;
+ AliCFContainer *c = (AliCFContainer *)obj;
c->Fill(fArray.GetArray(), step);
return kTRUE;
} else {
return kFALSE;
}
}
+
+//________________________________________________________________________________________
+Bool_t AliRsnListOutput::Fill(AliRsnEvent *ev, AliRsnDaughter *d)
+{
+//
+// Uses the passed argument to compute all values.
+// If all computations were successful, fill the output
+// Return value is the AND of all computation successes.
+//
+
+ // retrieve object
+ if (!fList || fIndex < 0) {
+ AliError("List not initialized");
+ return kFALSE;
+ }
+ TObject *obj = fList->At(fIndex);
+ if (!obj) {
+ AliError("Null pointer");
+ return kFALSE;
+ }
+
+
+ TIter next(&fValues);
+ AliRsnValue *val;
+ Int_t i=0;
+ Bool_t globalOK = kTRUE;
+ Double_t values[fValues.GetEntries()];
+ while ((val = (AliRsnValue *)next())) {
+ if (val->InheritsFrom(AliRsnValueDaughter::Class())) {
+ if (!d && fSkipFailed) return kFALSE;
+ globalOK = globalOK && val->Eval(d);
+ } else if (val->InheritsFrom(AliRsnValueEvent::Class())) {
+ if (!ev && fSkipFailed) return kFALSE;
+ globalOK = globalOK && val->Eval(ev);
+ }
+ values[i] = (Double_t)val->GetComputedValue();
+ if (!globalOK && fSkipFailed) return kFALSE;
+ i++;
+ }
+
+ // fill output
+ if (obj->IsA() == TH1F::Class()) {
+ TH1F *h = (TH1F *)obj;
+ h->Fill(values[0]);
+ return kTRUE;
+ } else if (obj->IsA() == TH2F::Class()) {
+ TH2F *h = (TH2F *)obj;
+ h->Fill(values[0], values[1]);
+ return kTRUE;
+ } else if (obj->IsA() == TH3F::Class()) {
+ TH3F *h = (TH3F *)obj;
+ h->Fill(values[0], values[1], values[2]);
+ return kTRUE;
+ } else if (obj->InheritsFrom(THnSparse::Class())) {
+ THnSparseF *h = (THnSparseF *)obj;
+ h->Fill(values);
+ return kTRUE;
+ } else {
+ AliError(Form("Not handled class '%s'", obj->ClassName()));
+ return kFALSE;
+ }
+}
class AliCFContainer;
class AliRsnValue;
-
+class AliRsnDaughter;
+class AliRsnEvent;
class AliRsnListOutput : public TNamed {
public:
AliRsnListOutput(const char *name = "", EOut type = kHistoDefault);
AliRsnListOutput(const AliRsnListOutput ©);
- AliRsnListOutput& operator=(const AliRsnListOutput ©);
+ AliRsnListOutput &operator=(const AliRsnListOutput ©);
virtual ~AliRsnListOutput();
EOut GetType() const {return fType;}
Int_t GetSteps() const {return fSteps;}
- TObjArray* GetValues() {return &fValues;}
+ TObjArray *GetValues() {return &fValues;}
Int_t GetNValues() {return (fNValues = fValues.GetEntries());}
- AliRsnValue* GetValue(Int_t i) const {return (AliRsnValue*)fValues[i];}
+ AliRsnValue *GetValue(Int_t i) const {return (AliRsnValue *)fValues[i];}
Int_t GetIndex() const {return fIndex;}
void SetType(EOut type) {fType = type;}
void SetSteps(Int_t n) {fSteps = n;}
virtual void Reset();
virtual Bool_t Init(const char *prefix, TList *list);
virtual Bool_t Fill(TObject *target, Int_t step = 0);
+ virtual Bool_t Fill(AliRsnEvent *ev,AliRsnDaughter *d);
private:
- TH1* CreateHistogram(const char *name);
- THnSparseF* CreateHistogramSparse(const char *name);
- AliCFContainer* CreateCFContainer(const char *name);
+ TH1 *CreateHistogram(const char *name);
+ THnSparseF *CreateHistogramSparse(const char *name);
+ AliCFContainer *CreateCFContainer(const char *name);
Bool_t fSkipFailed; // tell to skip fills when one computation fails
EOut fType; // output format among allowed ones
Int_t fNValues; //! number of values (internal use)
TList *fList; //! list containing the output
Int_t fIndex; // index of object in the list
-
+
TArrayD fArray; //! temp array of computed values
ClassDef(AliRsnListOutput, 1) // AliRsnListOutput class
//
// Base class to implement any computation within the RSN package.
-// It contains only an array of output objects which must derive
+// It contains only an array of output objects which must derive
// from AliRsnOutput.
-// Its core functions ar Init() and DoLoop() which must be
+// Its core functions ar Init() and DoLoop() which must be
// overloaded by any class which inherits from this.
//
}
//_____________________________________________________________________________
-AliRsnLoop::AliRsnLoop(const AliRsnLoop& copy) :
+AliRsnLoop::AliRsnLoop(const AliRsnLoop ©) :
TNamed(copy),
fIsMixed(copy.fIsMixed),
fEventCuts(copy.fEventCuts),
}
//_____________________________________________________________________________
-AliRsnLoop& AliRsnLoop::operator=(const AliRsnLoop& copy)
+AliRsnLoop &AliRsnLoop::operator=(const AliRsnLoop ©)
{
//
// Assignment operator
//
- if (this == ©)
- return *this;
- fIsMixed = copy.fIsMixed;
- fEventCuts = copy.fEventCuts;
- fOutputs = copy.fOutputs;
- return (*this);
+ if (this == ©)
+ return *this;
+ fIsMixed = copy.fIsMixed;
+ fEventCuts = copy.fEventCuts;
+ fOutputs = copy.fOutputs;
+ return (*this);
}
//_____________________________________________________________________________
//
//fOutputs.AddLast(out);
- AliRsnListOutput *out = (AliRsnListOutput*)object;
+ AliRsnListOutput *out = (AliRsnListOutput *)object;
Int_t n = fOutputs.GetEntries();
new (fOutputs[n]) AliRsnListOutput(*out);
}
//_____________________________________________________________________________
-void AliRsnLoop::Print(Option_t*) const
+void AliRsnLoop::Print(Option_t *) const
{
//
// Prints info about pair
//
-
+
TObjArrayIter next(&fOutputs);
AliRsnListOutput *out = 0x0;
-
- while ( (out = (AliRsnListOutput*)next()) ) {
+
+ while ( (out = (AliRsnListOutput *)next()) ) {
out->Print();
}
}
// If event cuts are defined, check event against them
//
- if (fEventCuts)
+ if (fEventCuts)
return fEventCuts->IsSelected(rsn);
else
return kTRUE;
TObjArrayIter next(&fOutputs);
AliRsnListOutput *out;
Bool_t globalOK = kTRUE;
-
- while ( (out = (AliRsnListOutput*)next()) ) {
+
+ while ( (out = (AliRsnListOutput *)next()) ) {
globalOK = globalOK && out->Init(prefix, list);
}
-
+
AliInfo(Form("[%s] Object initialization: %s", GetName(), (globalOK ? "successful" : "failed")));
return globalOK;
}
//
// Base class to implement any computation within the RSN package.
-// It contains only an array of output objects which must derive
+// It contains only an array of output objects which must derive
// from AliRsnOutput.
-// Its core functions ar Init() and DoLoop() which must be
+// Its core functions ar Init() and DoLoop() which must be
// overloaded by any class which inherits from this.
//
AliRsnLoop(const char *name = "default", Bool_t isMixed = kFALSE);
AliRsnLoop(const AliRsnLoop ©);
- AliRsnLoop& operator=(const AliRsnLoop ©);
+ AliRsnLoop &operator=(const AliRsnLoop ©);
~AliRsnLoop();
-
+
void SetMixed(Bool_t yn = kTRUE) {fIsMixed = yn;}
void SetEventCuts(AliRsnCutSet *set) {fEventCuts = set;}
Bool_t IsMixed() const {return fIsMixed;}
- AliRsnCutSet* GetEventCuts() {return fEventCuts;}
+ AliRsnCutSet *GetEventCuts() {return fEventCuts;}
Bool_t OkEvent(AliRsnEvent *rsn);
-
+
virtual void AddOutput(TObject *output);
virtual void Print(Option_t *option = "") const;
virtual Bool_t Init(const char *prefix, TList *list);
}
//_____________________________________________________________________________
-AliRsnLoopDaughter::AliRsnLoopDaughter(const AliRsnLoopDaughter& copy) :
+AliRsnLoopDaughter::AliRsnLoopDaughter(const AliRsnLoopDaughter ©) :
AliRsnLoop(copy),
fTrueMC(copy.fTrueMC),
fOnlyTrue(copy.fOnlyTrue),
}
//_____________________________________________________________________________
-AliRsnLoopDaughter& AliRsnLoopDaughter::operator=(const AliRsnLoopDaughter& copy)
+AliRsnLoopDaughter &AliRsnLoopDaughter::operator=(const AliRsnLoopDaughter ©)
{
//
// Assignment operator
AliRsnLoop::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fTrueMC = copy.fTrueMC;
fOnlyTrue = copy.fOnlyTrue;
fUseMCRef = copy.fUseMCRef;
Int_t i, il, nadd = 0, nlist = 0;
TEntryList *list[2] = {0, 0};
-
+
if (fDef->IsChargeDefined()) {
list[0] = selMain->GetSelected(fListID, fDef->GetChargeC());
list[1] = 0x0;
nlist = 1;
}
}
-
+
// if it is required to loop over True MC, do this here and skip the rest of the method
if (fTrueMC) return LoopTrueMC(evMain);
-
+
TObjArrayIter next(&fOutputs);
AliRsnListOutput *out = 0x0;
-
+
for (il = 0; il < nlist; il++) {
if (!list[il]) {
AliError(Form("List #%d is null", il));
// fill outputs
nadd++;
next.Reset();
- while ( (out = (AliRsnListOutput*)next()) ) {
+ while ( (out = (AliRsnListOutput *)next()) ) {
out->Fill(&fDaughter);
}
}
}
-
+
return nadd;
}
AliError("Need a MC to compute efficiency");
return 0;
}
-
+
// check event type:
// must be ESD or AOD, and then use a bool to know in the rest
if (!rsn->IsESD() && !rsn->IsAOD()) {
AliError("Need to process ESD or AOD input");
return 0;
}
-
+
// retrieve the MC primary vertex position
// and do some additional coherence checks
Int_t npart = 0;
npart = rsn->GetRefMCESD()->GetNumberOfTracks();
} else {
AliAODEvent *aod = rsn->GetRefMCAOD();
- listAOD = (TClonesArray*)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
+ listAOD = (TClonesArray *)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
if (listAOD) npart = listAOD->GetEntries();
}
-
+
// check number of particles
if (!npart) {
AliInfo("Empty event");
return 0;
}
-
+
// utility variables
Int_t ipart, count = 0;
TObjArrayIter next(&fOutputs);
AliRsnListOutput *out = 0x0;
Int_t pdg = AliRsnDaughter::SpeciesPDG(fDef->GetPID());
-
-
+
+
// loop over particles
for (ipart = 0; ipart < npart; ipart++) {
// check i-th particle
if (rsn->IsESD()) {
if (!rsn->GetRefMCESD()->Stack()->IsPhysicalPrimary(ipart)) continue;
- AliMCParticle *part = (AliMCParticle*)rsn->GetRefMCESD()->GetTrack(ipart);
+ AliMCParticle *part = (AliMCParticle *)rsn->GetRefMCESD()->GetTrack(ipart);
if (TMath::Abs(part->Particle()->GetPdgCode()) != pdg) continue;
fDaughter.SetRef (rsn->GetRefMCESD()->GetTrack(ipart));
fDaughter.SetRefMC(rsn->GetRefMCESD()->GetTrack(ipart));
} else {
- AliAODMCParticle *part = (AliAODMCParticle*)listAOD->At(ipart);
+ AliAODMCParticle *part = (AliAODMCParticle *)listAOD->At(ipart);
if (!part->IsPhysicalPrimary()) continue;
if (TMath::Abs(part->GetPdgCode()) != pdg) continue;
- fDaughter.SetRef ((AliAODMCParticle*)listAOD->At(ipart));
- fDaughter.SetRefMC((AliAODMCParticle*)listAOD->At(ipart));
+ fDaughter.SetRef ((AliAODMCParticle *)listAOD->At(ipart));
+ fDaughter.SetRefMC((AliAODMCParticle *)listAOD->At(ipart));
}
//if (fDaughter.GetPDG() != AliRsnDaughter::SpeciesPDG(fDef->GetPID())) continue;
fDaughter.FillP(fDef->GetMass());
// fill outputs
count++;
next.Reset();
- while ( (out = (AliRsnListOutput*)next()) ) {
+ while ( (out = (AliRsnListOutput *)next()) ) {
out->Fill(&fDaughter);
}
}
-
+
return count;
}
AliRsnLoopDaughter(const char *name = "default", Int_t listID = 0, AliRsnDaughterDef *def = 0);
AliRsnLoopDaughter(const AliRsnLoopDaughter ©);
- AliRsnLoopDaughter& operator=(const AliRsnLoopDaughter ©);
+ AliRsnLoopDaughter &operator=(const AliRsnLoopDaughter ©);
~AliRsnLoopDaughter();
-
+
Int_t GetListID() const {return fListID;}
- AliRsnDaughterDef* GetDef() {return fDef;}
- AliRsnDaughter* GetDaughter() {return &fDaughter;}
+ AliRsnDaughterDef *GetDef() {return fDef;}
+ AliRsnDaughter *GetDaughter() {return &fDaughter;}
void SetTrueMC(Bool_t yn = kTRUE) {fTrueMC = yn;}
void SetOnlyTrue(Bool_t yn = kTRUE) {fOnlyTrue = yn;}
- void SetMCRefInfo(Bool_t b = kTRUE) {fUseMCRef = b;}
+ void SetMCRefInfo(Bool_t b = kTRUE) {fUseMCRef = b;}
void SetListID(Int_t i) {fListID = i;}
void SetDef(AliRsnDaughterDef *def) {fDef = def;}
-
+
virtual void Print(Option_t *opt = "") const;
virtual Bool_t Init(const char *prefix, TList *list);
virtual Int_t DoLoop(AliRsnEvent *main, AliRsnDaughterSelector *smain, AliRsnEvent *mix = 0, AliRsnDaughterSelector *smix = 0);
}
//_____________________________________________________________________________
-AliRsnLoopEff::AliRsnLoopEff(const AliRsnLoopEff& copy) :
+AliRsnLoopEff::AliRsnLoopEff(const AliRsnLoopEff ©) :
AliRsnLoop(copy),
fAddSteps(copy.fAddSteps),
fSteps(copy.fSteps),
}
//_____________________________________________________________________________
-AliRsnLoopEff& AliRsnLoopEff::operator=(const AliRsnLoopEff& copy)
+AliRsnLoopEff &AliRsnLoopEff::operator=(const AliRsnLoopEff ©)
{
//
// Assignment operator
AliRsnLoop::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fAddSteps = copy.fAddSteps;
fSteps = copy.fSteps;
fOutput = copy.fOutput;
AliInfo("Clearing container of this efficiency loop.");
fOutputs.Delete();
}
-
+
Int_t nSteps = (Int_t)fSteps.GetEntries();
nSteps += fAddSteps;
fOutput->SetSteps(nSteps);
fOutput->SetSkipFailed(kFALSE);
AliRsnLoop::AddOutput(fOutput);
-
+
if (AliRsnLoop::Init(Form("%s_%s", prefix, GetName()), list)) {
- fOutput = (AliRsnListOutput*)fOutputs[0];
+ fOutput = (AliRsnListOutput *)fOutputs[0];
return kTRUE;
} else {
fOutput = 0x0;
if (TMath::Abs(track->GetLabel()) != label) continue;
return i;
}
-
+
return -1;
}
//
if (!event) return -1;
-
+
AliRsnDaughter out;
-
+
Int_t i, imax = event->GetAbsoluteSum();
for (i = 0; i < imax; i++) {
event->SetDaughter(out, i);
if (out.IsOK() && out.GetLabel() == label) return i;
}
-
+
return -1;
}
x -= fVertex[0];
y -= fVertex[1];
z -= fVertex[2];
-
+
return TMath::Sqrt(x*x + y*y + z*z);
}
-
+
AliRsnLoopEff(const char *name = "default", Int_t nSteps = 0, Double_t maxDistPV = 1E-2);
AliRsnLoopEff(const AliRsnLoopEff ©);
- AliRsnLoopEff& operator=(const AliRsnLoopEff ©);
+ AliRsnLoopEff &operator=(const AliRsnLoopEff ©);
~AliRsnLoopEff();
- AliRsnListOutput* GetOutput() {return fOutput;}
+ AliRsnListOutput *GetOutput() {return fOutput;}
void CreateOutput();
- void AddStep(TObject *set);
+ void AddStep(TObject *set);
void SetMaxDistanceFromPV(Double_t value) {fMaxDistPV = value;}
virtual void AddOutput(TObject *) {AliWarning("In loops for efficiency it is not allowed to add outputs externally");}
virtual Bool_t Init(const char *prefix, TList *list);
}
//_____________________________________________________________________________
-AliRsnLoopEffPair::AliRsnLoopEffPair(const AliRsnLoopEffPair& copy) :
+AliRsnLoopEffPair::AliRsnLoopEffPair(const AliRsnLoopEffPair ©) :
AliRsnLoopEff(copy),
fDef(copy.fDef),
fMother(copy.fMother)
}
//_____________________________________________________________________________
-AliRsnLoopEffPair& AliRsnLoopEffPair::operator=(const AliRsnLoopEffPair& copy)
+AliRsnLoopEffPair &AliRsnLoopEffPair::operator=(const AliRsnLoopEffPair ©)
{
//
// Assignment operator.
AliRsnLoopEff::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fDef = copy.fDef;
return (*this);
AliMCEvent *mc = rsnEvent->GetRefMCESD();
AliStack *stack = mc->Stack();
- AliMCParticle *mother = (AliMCParticle*)mc->GetTrack(ipart);
+ AliMCParticle *mother = (AliMCParticle *)mc->GetTrack(ipart);
TParticle *motherP = mother->Particle();
Int_t ntracks = stack->GetNtrack();
-
+
// check PDG code and exit if it is wrong
if (TMath::Abs(motherP->GetPdgCode()) != fDef->GetMotherPDG()) return kFALSE;
-
+
// check number of daughters and exit if it is not 2
if (motherP->GetNDaughters() < 2) return kFALSE;
-
+
// check distance from primary vertex
TLorentzVector vprod;
motherP->ProductionVertex(vprod);
AliDebugClass(1, "Distant production vertex");
return kFALSE;
}
-
+
// get the daughters and check their PDG code and charge:
- // if they match one of the pair daughter definitions,
+ // if they match one of the pair daughter definitions,
// assign them as MC reference of the 'fDaughter' objects
fDaughter[0].Reset();
fDaughter[1].Reset();
return kFALSE;
}
// get daughter and its PDG and charge
- daughter = (AliMCParticle*)mc->GetTrack(index[i]);
+ daughter = (AliMCParticle *)mc->GetTrack(index[i]);
pdg = TMath::Abs(daughter->Particle()->GetPdgCode());
charge = (Short_t)(daughter->Particle()->GetPDG()->Charge() / 3);
// check if it matches one definition
fDaughter[1].SetLabel(index[i]);
}
}
-
+
// return success if both daughters were assigned
if (fDaughter[0].IsOK() && fDaughter[1].IsOK()) {
return kTRUE;
//
AliAODEvent *aod = rsnEvent->GetRefAOD();
- TClonesArray *listAOD = (TClonesArray*)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
- AliAODMCParticle *mother = (AliAODMCParticle*)listAOD->At(ipart);
+ TClonesArray *listAOD = (TClonesArray *)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
+ AliAODMCParticle *mother = (AliAODMCParticle *)listAOD->At(ipart);
Int_t ntracks = listAOD->GetEntries();
-
+
// check PDG code and exit if it is wrong
if (TMath::Abs(mother->GetPdgCode()) != fDef->GetMotherPDG()) return kFALSE;
-
+
// check number of daughters and exit if it is not 2
if (mother->GetNDaughters() < 2) return kFALSE;
-
+
// check distance from primary vertex
Double_t vprod[3] = {(Double_t)mother->Xv(), (Double_t)mother->Yv(), (Double_t)mother->Zv()};
Double_t dv = DistanceFromPV(vprod[0], vprod[1], vprod[2]);
AliDebugClass(1, "Distant production vertex");
return kFALSE;
}
-
+
// get the daughters and check their PDG code and charge:
- // if they match one of the pair daughter definitions,
+ // if they match one of the pair daughter definitions,
// assign them as MC reference of the 'fDaughter' objects
fDaughter[0].Reset();
fDaughter[1].Reset();
return kFALSE;
}
// get daughter and its PDG and charge
- daughter = (AliAODMCParticle*)listAOD->At(index[i]);
+ daughter = (AliAODMCParticle *)listAOD->At(index[i]);
pdg = TMath::Abs(daughter->GetPdgCode());
charge = (Short_t)(daughter->Charge() / 3);
// check if it matches one definition
fDaughter[1].SetLabel(index[i]);
}
}
-
+
// return success if both daughters were assigned
if (fDaughter[0].IsOK() && fDaughter[1].IsOK()) {
return kTRUE;
}
//_____________________________________________________________________________
-Int_t AliRsnLoopEffPair::DoLoop(AliRsnEvent *rsn, AliRsnDaughterSelector*, AliRsnEvent*, AliRsnDaughterSelector*)
+Int_t AliRsnLoopEffPair::DoLoop(AliRsnEvent *rsn, AliRsnDaughterSelector *, AliRsnEvent *, AliRsnDaughterSelector *)
{
//
// Loop on event and fill containers
// check event cuts
if (!OkEvent(rsn)) return 0;
-
+
// retrieve output
- fOutput = (AliRsnListOutput*)fOutputs[0];
-
+ fOutput = (AliRsnListOutput *)fOutputs[0];
+
// check presence of MC reference
if (!rsn->GetRefMC()) {
AliError("Need a MC to compute efficiency");
return 0;
}
-
+
// check presence of event
if (!rsn->GetRef()) {
AliError("Need an event to compute efficiency");
return 0;
}
-
+
// check event type:
// must be ESD or AOD, and then use a bool to know in the rest
if (!rsn->IsESD() && !rsn->IsAOD()) {
AliError("Need to process ESD or AOD input");
return 0;
}
-
+
// retrieve the MC primary vertex position
// and do some additional coherence checks
Int_t i, npart = 0;
} else {
for (i = 0; i < 3; i++) fVertex[i] = 0.0;
AliAODEvent *aod = rsn->GetRefMCAOD();
- TClonesArray *listAOD = (TClonesArray*)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
+ TClonesArray *listAOD = (TClonesArray *)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
if (listAOD) npart = listAOD->GetEntries();
- AliAODMCHeader *mcH = static_cast<AliAODMCHeader*>(aod->FindListObject(AliAODMCHeader::StdBranchName()));
+ AliAODMCHeader *mcH = static_cast<AliAODMCHeader *>(aod->FindListObject(AliAODMCHeader::StdBranchName()));
if (mcH) mcH->GetVertex(fVertex);
}
-
+
// check number of particles
if (!npart) {
AliInfo("Empty event");
return 0;
}
-
+
// utility variables
Int_t ipart, istep, count = 0, nsteps = fSteps.GetEntries();
Int_t ntracks = rsn->GetAbsoluteSum();
AliRsnDaughter check;
-
+
// loop over particles
for (ipart = 0; ipart < npart; ipart++) {
// check i-th particle
count++;
// for each further step, try to find two tracks which pass the related cuts
for (istep = 0; istep < nsteps; istep++) {
- AliRsnCutManager *cuts = (AliRsnCutManager*)fSteps[istep];
+ AliRsnCutManager *cuts = (AliRsnCutManager *)fSteps[istep];
fDaughter[0].SetBad();
fDaughter[1].SetBad();
for (i = 0; i < ntracks; i++) {
}
}
}
-
+
return count;
}
public:
AliRsnLoopEffPair(const char *name = "default", AliRsnPairDef *def = 0x0);
- AliRsnLoopEffPair(const AliRsnLoopEffPair& copy);
- AliRsnLoopEffPair& operator=(const AliRsnLoopEffPair& copy);
+ AliRsnLoopEffPair(const AliRsnLoopEffPair ©);
+ AliRsnLoopEffPair &operator=(const AliRsnLoopEffPair ©);
virtual ~AliRsnLoopEffPair() {;}
- AliRsnPairDef* GetDef() {return fDef;}
+ AliRsnPairDef *GetDef() {return fDef;}
void SetDef(AliRsnPairDef *def) {fDef = def;}
virtual Int_t DoLoop(AliRsnEvent *main, AliRsnDaughterSelector *smain = 0, AliRsnEvent *mix = 0, AliRsnDaughterSelector *smix = 0);
-
+
Bool_t AssignMotherAndDaughters (AliRsnEvent *event, Int_t ipart);
Bool_t AssignMotherAndDaughtersESD(AliRsnEvent *event, Int_t ipart);
Bool_t AssignMotherAndDaughtersAOD(AliRsnEvent *event, Int_t ipart);
}
//_____________________________________________________________________________
-AliRsnLoopEvent::AliRsnLoopEvent(const AliRsnLoopEvent& copy) :
+AliRsnLoopEvent::AliRsnLoopEvent(const AliRsnLoopEvent ©) :
AliRsnLoop(copy)
{
//
}
//_____________________________________________________________________________
-AliRsnLoopEvent& AliRsnLoopEvent::operator=(const AliRsnLoopEvent& copy)
+AliRsnLoopEvent &AliRsnLoopEvent::operator=(const AliRsnLoopEvent ©)
{
//
// Assignment operator
//
- AliRsnLoop::operator=(copy);
- return (*this);
+ AliRsnLoop::operator=(copy);
+ return (*this);
}
//_____________________________________________________________________________
TObjArrayIter next(&fOutputs);
AliRsnListOutput *out = 0x0;
-
+
// check cuts
if (!OkEvent(evMain)) return 0;
-
- while ( (out = (AliRsnListOutput*)next()) ) {
+
+ while ( (out = (AliRsnListOutput *)next()) ) {
out->Fill(evMain);
}
-
+
return 1;
}
//
// Computator for events.
-// The simplest loop,
+// The simplest loop,
// which is filled once per event.
//
AliRsnLoopEvent(const char *name = "default");
AliRsnLoopEvent(const AliRsnLoopEvent ©);
- AliRsnLoopEvent& operator=(const AliRsnLoopEvent ©);
+ AliRsnLoopEvent &operator=(const AliRsnLoopEvent ©);
~AliRsnLoopEvent();
-
+
virtual void Print(Option_t *opt = "") const;
virtual Bool_t Init(const char *prefix, TList *list);
virtual Int_t DoLoop(AliRsnEvent *main, AliRsnDaughterSelector *smain = 0, AliRsnEvent *mix = 0, AliRsnDaughterSelector *smix = 0);
AliRsnLoop::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fTrueMC = copy.fTrueMC;
fOnlyTrue = copy.fOnlyTrue;
fUseMCRef = copy.fUseMCRef;
if (!fIsMixed && list0 == list1) start = i0 + 1;
for (i1 = start; i1 < list1->GetN(); i1++) {
iEntry2 = list1->GetEntry(i1);
- if (iEntry1 == iEntry2) continue;
+ if (iEntry1 == iEntry2) continue;
AliDebugClass(4, Form("Checking entries pair: %d (%lld) with %d (%lld)", i0, iEntry1, i1, iEntry2));
evMix->SetDaughter(fDaughter[1], iEntry2,fUseMCRef);
fDaughter[1].FillP(fPairDef->GetDef2().GetMass());
AliRsnLoopPair(const char *name = "default", AliRsnPairDef *def = 0, Bool_t isMixed = kFALSE);
AliRsnLoopPair(const AliRsnLoopPair ©);
- AliRsnLoopPair& operator=(const AliRsnLoopPair ©);
+ AliRsnLoopPair &operator=(const AliRsnLoopPair ©);
~AliRsnLoopPair();
// getters
Bool_t IsTrueMC() const {return fTrueMC;}
Bool_t IsOnlyTrue() const {return fOnlyTrue;}
Bool_t IsCheckDecay() const {return fCheckDecay;}
- AliRsnPairDef* GetPairDef() {return fPairDef;}
- AliRsnCutSet* GetPairCuts() {return fPairCuts;}
- AliRsnMother* GetMother() {return &fMother;}
+ AliRsnPairDef *GetPairDef() {return fPairDef;}
+ AliRsnCutSet *GetPairCuts() {return fPairCuts;}
+ AliRsnMother *GetMother() {return &fMother;}
// setters (not for all members)
void SetPairCuts(AliRsnCutSet *cuts) {fPairCuts = cuts;}
void SetTrueMC(Bool_t yn = kTRUE) {fTrueMC = yn;}
void SetOnlyTrue(Bool_t onlyTrue = kTRUE) {fOnlyTrue = onlyTrue;}
- void SetMCRefInfo(Bool_t b = kTRUE) {fUseMCRef = b;}
+ void SetMCRefInfo(Bool_t b = kTRUE) {fUseMCRef = b;}
void SetCheckDecay(Bool_t check = kTRUE) {fCheckDecay = check;}
void SetListID(Int_t i, Int_t val) {if (i==0||i==1) fListID[i] = val;}
void SetRangeY(Double_t range) {fRangeY = range;}
fTriggerAna(0x0),
fESDtrackCuts(0x0),
fMiniEvent(0x0),
- fBigOutput(kFALSE)
+ fBigOutput(kFALSE),
+ fMixPrintRefresh(-1)
{
//
// Dummy constructor ALWAYS needed for I/O.
fTriggerAna(0x0),
fESDtrackCuts(0x0),
fMiniEvent(0x0),
- fBigOutput(kFALSE)
+ fBigOutput(kFALSE),
+ fMixPrintRefresh(-1)
{
//
// Default constructor.
fTriggerAna(copy.fTriggerAna),
fESDtrackCuts(copy.fESDtrackCuts),
fMiniEvent(0x0),
- fBigOutput(copy.fBigOutput)
+ fBigOutput(copy.fBigOutput),
+ fMixPrintRefresh(copy.fMixPrintRefresh)
{
//
// Copy constructor.
AliAnalysisTaskSE::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fUseMC = copy.fUseMC;
fUseCentrality = copy.fUseCentrality;
fCentralityType = copy.fCentralityType;
fTriggerAna = copy.fTriggerAna;
fESDtrackCuts = copy.fESDtrackCuts;
fBigOutput = copy.fBigOutput;
-
+ fMixPrintRefresh = copy.fMixPrintRefresh;
return (*this);
}
fHEventStat->GetXaxis()->SetBinLabel(4, "Accepted");
fOutput->Add(fHEventStat);
+ TIter next(&fTrackCuts);
+ AliRsnCutSet *cs;
+ while ((cs = (AliRsnCutSet *) next())) {
+ cs->Init(fOutput);
+ }
+
// create temporary tree for filtered events
if (fMiniEvent) delete fMiniEvent;
fEvBuffer = new TTree("EventBuffer", "Temporary buffer for mini events");
AliRsnMiniOutput *def = 0x0;
AliRsnMiniOutput::EComputation compType;
- Int_t printNum = 0;
- if (nEvents>1e5) printNum=nEvents/100;
- if (nEvents>1e4) printNum=nEvents/10;
-
+ Int_t printNum = fMixPrintRefresh;
+ if (printNum < 0) {
+ if (nEvents>1e5) printNum=nEvents/100;
+ else if (nEvents>1e4) printNum=nEvents/10;
+ else printNum = 0;
+ }
+
// loop on events, and for each one fill all outputs
// using the appropriate procedure depending on its type
// only mother-related histograms are filled in UserExec,
fEvBuffer->GetEntry(ievt);
if (printNum&&(ievt%printNum==0)) {
AliInfo(Form("[%s] Std.Event %d/%d",GetName(), ievt,nEvents));
- timer.Stop(); timer.Print();fflush(stdout); timer.Start(kFALSE);
+ timer.Stop(); timer.Print(); fflush(stdout); timer.Start(kFALSE);
}
// fill
for (idef = 0; idef < nDefs; idef++) {
smatched[ievt] = "|";
nmatched[ievt] = 0;
}
-
-
+
+
AliInfo(Form("[%s] Std.Event %d/%d",GetName(), nEvents,nEvents));
- timer.Stop(); timer.Print(); timer.Start();fflush(stdout);
+ timer.Stop(); timer.Print(); timer.Start(); fflush(stdout);
// search for good matchings
for (ievt = 0; ievt < nEvents; ievt++) {
}
AliDebugClass(1, Form("Matches for event %5d = %d [%s] (missing are declared above)", evMain.ID(), nmatched[ievt], smatched[ievt].Data()));
}
-
+
AliInfo(Form("[%s] EventMixing searching %d/%d",GetName(),nEvents,nEvents));
- timer.Stop(); timer.Print();fflush(stdout); timer.Start();
+ timer.Stop(); timer.Print(); fflush(stdout); timer.Start();
// perform mixing
TObjArray *list = 0x0;
delete [] smatched;
AliInfo(Form("[%s] EventMixing %d/%d",GetName(),nEvents,nEvents));
- timer.Stop();timer.Print();fflush(stdout);
+ timer.Stop(); timer.Print(); fflush(stdout);
/*
OLD
AliRsnMiniAnalysisTask();
AliRsnMiniAnalysisTask(const char *name, Bool_t isMC = kFALSE);
AliRsnMiniAnalysisTask(const AliRsnMiniAnalysisTask ©);
- AliRsnMiniAnalysisTask& operator=(const AliRsnMiniAnalysisTask ©);
+ AliRsnMiniAnalysisTask &operator=(const AliRsnMiniAnalysisTask ©);
virtual ~AliRsnMiniAnalysisTask();
- void UseMC(Bool_t yn = kTRUE) {fUseMC = yn;}
+ void UseMC(Bool_t yn = kTRUE) {fUseMC = yn;}
void UseCentrality(const char *type) {fUseCentrality = kTRUE; fCentralityType = type; fCentralityType.ToUpper();}
void UseMultiplicity(const char *type) {fUseCentrality = kFALSE; fCentralityType = type; fCentralityType.ToUpper();}
void UseContinuousMix() {fContinuousMix = kTRUE;}
void SetMaxDiffVz (Double_t val) {fMaxDiffVz = val;}
void SetMaxDiffAngle(Double_t val) {fMaxDiffAngle = val;}
void SetEventCuts(AliRsnCutSet *cuts) {fEventCuts = cuts;}
+ void SetMixPrintRefresh(Int_t n) {fMixPrintRefresh = n;}
Int_t AddTrackCuts(AliRsnCutSet *cuts);
TClonesArray *Outputs() {return &fHistograms;}
TClonesArray *Values() {return &fValues;}
-
+
virtual void UserCreateOutputObjects();
- virtual void UserExec(Option_t*);
- virtual void Terminate(Option_t*);
+ virtual void UserExec(Option_t *);
+ virtual void Terminate(Option_t *);
virtual void FinishTaskOutput();
-
+
Int_t ValueID(AliRsnMiniValue::EType type, Bool_t useMC = kFALSE);
- Int_t CreateValue(AliRsnMiniValue::EType type, Bool_t useMC = kFALSE);
+ Int_t CreateValue(AliRsnMiniValue::EType type, Bool_t useMC = kFALSE);
AliRsnMiniOutput *CreateOutput(const char *name, AliRsnMiniOutput::EOutputType type, AliRsnMiniOutput::EComputation src);
AliRsnMiniOutput *CreateOutput(const char *name, const char *outType, const char *compType);
-
+
private:
Char_t CheckCurrentEvent();
Int_t fEvNum; //! absolute event counter
Bool_t fUseCentrality; // if true, use centrality for event, otherwise use multiplicity
TString fCentralityType; // definition used to choose what centrality or multiplicity to use
-
+
Bool_t fContinuousMix; // mixing --> technique chosen (continuous or binned)
Int_t fNMix; // mixing --> required number of mixes
Double_t fMaxDiffMult; // mixing --> max difference in multiplicity
Double_t fMaxDiffVz; // mixing --> max difference in Vz of prim vert
Double_t fMaxDiffAngle; // mixing --> max difference in reaction plane angle
-
+
TList *fOutput; // output list
TClonesArray fHistograms; // list of histogram definitions
TClonesArray fValues; // list of values to be computed
TH1F *fHEventStat; // histogram of event statistics
-
+
AliRsnCutSet *fEventCuts; // cuts on events
TObjArray fTrackCuts; // list of single track cuts
AliRsnEvent fRsnEvent; //! interface object to the event
AliESDtrackCuts *fESDtrackCuts; //! quality cut for ESD tracks
AliRsnMiniEvent *fMiniEvent; //! mini-event cursor
Bool_t fBigOutput; // flag if open file for output list
+ Int_t fMixPrintRefresh; // how often info in mixing part is printed
- ClassDef(AliRsnMiniAnalysisTask, 2); // AliRsnMiniAnalysisTask
+ ClassDef(AliRsnMiniAnalysisTask, 3); // AliRsnMiniAnalysisTask
};
inline Int_t AliRsnMiniAnalysisTask::CreateValue(AliRsnMiniValue::EType type, Bool_t useMC)
AliInfo(Form("Creating value '%s' in slot #%d", AliRsnMiniValue::ValueName(type, useMC), valID));
new (fValues[valID]) AliRsnMiniValue(type, useMC);
}
-
+
return valID;
}
const char *name = AliRsnMiniValue::ValueName(type, useMC);
TObject *obj = fValues.FindObject(name);
- if (obj)
- return fValues.IndexOf(obj);
+ if (obj)
+ return fValues.IndexOf(obj);
else
return -1;
}
-inline AliRsnMiniOutput* AliRsnMiniAnalysisTask::CreateOutput
+inline AliRsnMiniOutput *AliRsnMiniAnalysisTask::CreateOutput
(const char *name, AliRsnMiniOutput::EOutputType type, AliRsnMiniOutput::EComputation src)
{
//
// which is then returned to the user for its configuration
//
- Int_t n = fHistograms.GetEntries();
+ Int_t n = fHistograms.GetEntries();
AliRsnMiniOutput *newDef = new (fHistograms[n]) AliRsnMiniOutput(name, type, src);
-
+
return newDef;
}
-inline AliRsnMiniOutput* AliRsnMiniAnalysisTask::CreateOutput
+inline AliRsnMiniOutput *AliRsnMiniAnalysisTask::CreateOutput
(const char *name, const char *outType, const char *compType)
{
//
// which is then returned to the user for its configuration
//
- Int_t n = fHistograms.GetEntries();
+ Int_t n = fHistograms.GetEntries();
AliRsnMiniOutput *newDef = new (fHistograms[n]) AliRsnMiniOutput(name, outType, compType);
-
+
return newDef;
}
#endif
AliRsnMiniAxis(Int_t valID, Int_t nbins, Double_t min, Double_t max) : fValueID(valID), fBins(0) {Set(nbins, min, max);}
AliRsnMiniAxis(Int_t valID, Double_t min, Double_t max, Double_t step) : fValueID(valID), fBins(0) {Set(min, max, step);}
AliRsnMiniAxis(Int_t valID, Int_t nbins, Double_t *bins) : fValueID(valID), fBins(0) {Set(nbins, bins);}
- AliRsnMiniAxis(const AliRsnMiniAxis& copy) : TObject(copy), fValueID(copy.fValueID), fBins(copy.fBins) { }
- AliRsnMiniAxis& operator=(const AliRsnMiniAxis& copy) {if (this==©) return *this; fValueID = copy.fValueID; fBins = copy.fBins; return (*this);}
-
+ AliRsnMiniAxis(const AliRsnMiniAxis ©) : TObject(copy), fValueID(copy.fValueID), fBins(copy.fBins) { }
+ AliRsnMiniAxis &operator=(const AliRsnMiniAxis ©) {if (this==©) return *this; fValueID = copy.fValueID; fBins = copy.fBins; return (*this);}
+
void SetValueID(Int_t id) {fValueID = id;}
Int_t GetValueID() const {return fValueID;}
-
+
Int_t NBins() {return fBins.GetSize() - 1;}
TArrayD *Bins() {return &fBins;}
Double_t *BinArray() {return fBins.GetArray();}
-
+
void Set(Int_t nbins, Double_t min, Double_t max);
void Set(Int_t nbins, Double_t *bins);
void Set(Double_t min, Double_t max, Double_t step);
-
+
private:
Int_t fValueID; // index of used value in task collection
TArrayD fBins; // bins
-
+
ClassDef(AliRsnMiniAxis,1)
};
}
//__________________________________________________________________________________________________
-AliRsnMiniParticle* AliRsnMiniEvent::GetParticle(Int_t i)
+AliRsnMiniParticle *AliRsnMiniEvent::GetParticle(Int_t i)
{
//
// Return the leading particle
//
if (i < 0 || i > fParticles.GetEntriesFast()) return 0x0;
-
- return (AliRsnMiniParticle*)fParticles[i];
+
+ return (AliRsnMiniParticle *)fParticles[i];
}
//__________________________________________________________________________________________________
-AliRsnMiniParticle* AliRsnMiniEvent::LeadingParticle()
+AliRsnMiniParticle *AliRsnMiniEvent::LeadingParticle()
{
//
// Return the leading particle
if (fLeading < 0) return 0x0;
if (fLeading >= fParticles.GetEntriesFast()) return 0x0;
-
- return (AliRsnMiniParticle*)fParticles[fLeading];
+
+ return (AliRsnMiniParticle *)fParticles[fLeading];
}
//__________________________________________________________________________________________________
Int_t i, npart = fParticles.GetEntriesFast();
Int_t count = 0;
AliRsnMiniParticle *part = 0x0;
-
+
found.Set(npart);
-
+
for (i = 0; i < npart; i++) {
- part = (AliRsnMiniParticle*)fParticles[i];
+ part = (AliRsnMiniParticle *)fParticles[i];
if (charge == '+' || charge == '-' || charge == '0') {
if (part->Charge() != charge) continue;
}
found[count] = i;
count++;
}
-
+
found.Set(count);
return count;
}
AliRsnMiniEvent() : fID(-1), fVz(0.0), fMult(0.0), fAngle(0.0), fLeading(-1), fParticles("AliRsnMiniParticle", 0) {}
~AliRsnMiniEvent() {fParticles.Delete();}
-
- Int_t& ID() {return fID;}
- Float_t& Vz() {return fVz;}
- Float_t& Mult() {return fMult;}
- Float_t& Angle() {return fAngle;}
- TClonesArray& Particles() {return fParticles;}
+
+ Int_t &ID() {return fID;}
+ Float_t &Vz() {return fVz;}
+ Float_t &Mult() {return fMult;}
+ Float_t &Angle() {return fAngle;}
+ TClonesArray &Particles() {return fParticles;}
Bool_t IsEmpty() {return fParticles.IsEmpty();}
-
+
Int_t CountParticles(TArrayI &found, Char_t charge = 0, Int_t cutID = -1);
- AliRsnMiniParticle* GetParticle(Int_t i);
- AliRsnMiniParticle* LeadingParticle();
+ AliRsnMiniParticle *GetParticle(Int_t i);
+ AliRsnMiniParticle *LeadingParticle();
void AddParticle(AliRsnMiniParticle copy);
-
+
private:
-
+
Int_t fID; // ID number
Float_t fVz; // z-position of vertex
Float_t fMult; // multiplicity or centrality
Float_t fAngle; // angle of reaction plane to main reference frame
-
+
Int_t fLeading; // index of leading particle
TClonesArray fParticles; // list of selected particles
-
+
ClassDef(AliRsnMiniEvent,2)
};
//__________________________________________________________________________________________________
AliRsnMiniMonitor::AliRsnMiniMonitor() :
- TNamed(),
- fType(kTypes),
- fCutID(-1),
+ TNamed(),
+ fType(kTypes),
+ fCutID(-1),
fCharge(0),
- fListID(-1),
+ fListID(-1),
fList(0x0)
{
//
//__________________________________________________________________________________________________
AliRsnMiniMonitor::AliRsnMiniMonitor(const char *name, EType type, Int_t cutID) :
- TNamed(name, ""),
- fType(type),
- fCutID(cutID),
+ TNamed(name, ""),
+ fType(type),
+ fCutID(cutID),
fCharge(0),
- fListID(-1),
+ fListID(-1),
fList(0x0)
{
//
// Default constructor
//
}
-
+
//__________________________________________________________________________________________________
-AliRsnMiniMonitor::AliRsnMiniMonitor(const AliRsnMiniMonitor& copy) :
- TNamed(copy),
- fType(copy.fType),
- fCutID(copy.fCutID),
+AliRsnMiniMonitor::AliRsnMiniMonitor(const AliRsnMiniMonitor ©) :
+ TNamed(copy),
+ fType(copy.fType),
+ fCutID(copy.fCutID),
fCharge(copy.fCharge),
- fListID(copy.fListID),
+ fListID(copy.fListID),
fList(copy.fList)
{
//
// Copy constructor
//
}
-
+
//__________________________________________________________________________________________________
-AliRsnMiniMonitor& AliRsnMiniMonitor::operator=(const AliRsnMiniMonitor& copy)
+AliRsnMiniMonitor &AliRsnMiniMonitor::operator=(const AliRsnMiniMonitor ©)
{
//
// Assignment operator
//
-
- TNamed::operator=(copy);
+
+ TNamed::operator=(copy);
if (this == ©)
- return *this;
- fType = copy.fType;
- fCutID = copy.fCutID;
+ return *this;
+ fType = copy.fType;
+ fCutID = copy.fCutID;
fCharge = copy.fCharge;
- fListID = copy.fListID;
- fList = copy.fList;
-
- return (*this);
+ fListID = copy.fListID;
+ fList = copy.fList;
+
+ return (*this);
}
//__________________________________________________________________________________________________
TString sname(name);
sname += '_';
sname += GetName();
-
+
// check list
fList = list;
if (!list) {
AliError("No list!");
return kFALSE;
}
-
+
// reset histogram
TH1 *histogram = 0x0;
sname += fCutID;
histogram = new TH1F(sname.Data(), "", 100, 0.0, 10.0);
break;
- case kdEdxTPCvsP:
+ case kdEdxTPCvsP:
sname += "_TPCsignal";
histogram = new TH2F(sname.Data(), "", 500, 0.0, 5.0, 1000, 0.0, 1000.0);
break;
AliError("Wrong enum type");
return kFALSE;
}
-
+
// add to list
if (histogram && fList) {
histogram->Sumw2();
AliInfo(Form("Histogram '%s' added to list in slot #%d", histogram->GetName(), fListID));
return kTRUE;
}
-
+
return kFALSE;
}
Double_t valueX, valueY;
AliVTrack *vtrack = track->Ref2Vtrack();
-
+
AliPIDResponse *pid = event->GetPIDResponse();
switch (fType) {
- case kTrackPt:
+ case kTrackPt:
if (!vtrack) {
AliWarning("Required vtrack for this value");
return kFALSE;
if (fCharge == '-' && vtrack->Charge() >= 0) return kFALSE;
if (fCharge == '0' && vtrack->Charge() != 0) return kFALSE;
valueX = vtrack->Pt();
- ((TH1F*)obj)->Fill(valueX);
+ ((TH1F *)obj)->Fill(valueX);
return kTRUE;
- case kdEdxTPCvsP:
+ case kdEdxTPCvsP:
if (!vtrack) {
AliWarning("Required vtrack for this value");
return kFALSE;
}
valueX = vtrack->GetTPCmomentum();
valueY = vtrack->GetTPCsignal();
- ((TH2F*)obj)->Fill(valueX, valueY);
+ ((TH2F *)obj)->Fill(valueX, valueY);
return kTRUE;
case ktimeTOFvsPPion:
if (!vtrack) {
//valueY = vtrack->GetTOFsignal();
valueY = 1E20;
if (pid) valueY = pid->NumberOfSigmasTOF(vtrack, AliPID::kPion);
- ((TH2F*)obj)->Fill(valueX, valueY);
+ ((TH2F *)obj)->Fill(valueX, valueY);
return kTRUE;
case ktimeTOFvsPKaon:
if (!vtrack) {
//valueY = vtrack->GetTOFsignal();
valueY = 1E20;
if (pid) valueY = pid->NumberOfSigmasTOF(vtrack, AliPID::kKaon);
- ((TH2F*)obj)->Fill(valueX, valueY);
+ ((TH2F *)obj)->Fill(valueX, valueY);
return kTRUE;
case ktimeTOFvsPProton:
if (!vtrack) {
//valueY = vtrack->GetTOFsignal();
valueY = 1E20;
if (pid) valueY = pid->NumberOfSigmasTOF(vtrack, AliPID::kProton);
- ((TH2F*)obj)->Fill(valueX, valueY);
+ ((TH2F *)obj)->Fill(valueX, valueY);
return kTRUE;
default:
AliError("Invalid value type");
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
+
////////////////////////////////////////////////////////////////////////////////
//
// Monitors
AliRsnMiniMonitor();
AliRsnMiniMonitor(const char *name, EType type, Int_t cutID);
- AliRsnMiniMonitor(const AliRsnMiniMonitor& copy);
- AliRsnMiniMonitor& operator=(const AliRsnMiniMonitor& copy);
+ AliRsnMiniMonitor(const AliRsnMiniMonitor ©);
+ AliRsnMiniMonitor &operator=(const AliRsnMiniMonitor ©);
virtual ~AliRsnMiniMonitor() { }
EType GetType() {return fType;}
Int_t GetCutID() {return fCutID;}
Char_t GetCharge() {return fCharge;}
Int_t GetListID() {return fListID;}
-
+
void SetType(EType type) {fType = type;}
void SetCutID(Int_t id) {fCutID = id;}
void SetCharge(Char_t ch) {fCharge = ch;}
- static const char* Label(EType type);
+ static const char *Label(EType type);
Bool_t Init(const char *name, TList *list);
Bool_t Fill(AliRsnDaughter *track, AliRsnEvent *event);
Char_t fCharge; // charge to be used
Int_t fListID; // histogram ID in the list
TList *fList; //! global output list
-
+
ClassDef(AliRsnMiniMonitor, 1) // AliRsnMiniMonitor class
};
-inline const char* AliRsnMiniMonitor::Label(EType type)
+inline const char *AliRsnMiniMonitor::Label(EType type)
{
switch (type) {
case kdEdxTPCvsP : return "TPCsignal";
}
//__________________________________________________________________________________________________
-AliRsnMiniMonitorTask::AliRsnMiniMonitorTask(const AliRsnMiniMonitorTask& copy) :
+AliRsnMiniMonitorTask::AliRsnMiniMonitorTask(const AliRsnMiniMonitorTask ©) :
AliAnalysisTaskSE(copy),
fUseMC(copy.fUseMC),
fEvNum(0),
}
//__________________________________________________________________________________________________
-AliRsnMiniMonitorTask& AliRsnMiniMonitorTask::operator=(const AliRsnMiniMonitorTask& copy)
+AliRsnMiniMonitorTask &AliRsnMiniMonitorTask::operator=(const AliRsnMiniMonitorTask ©)
{
//
// Assignment operator.
//
AliAnalysisTaskSE::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fUseMC = copy.fUseMC;
fUseCentrality = copy.fUseCentrality;
fCentralityType = copy.fCentralityType;
fEventCuts = copy.fEventCuts;
fTrackCuts = copy.fTrackCuts;
fBigOutput = copy.fBigOutput;
-
+
return (*this);
}
AliRsnMiniMonitorTask::~AliRsnMiniMonitorTask()
{
//
-// Destructor.
+// Destructor.
// Clean-up the output list, but not the histograms that are put inside
// (the list is owner and will clean-up these histograms). Protect in PROOF case.
//
//
TObject *obj = fTrackCuts.FindObject(cuts->GetName());
-
+
if (obj) {
AliInfo(Form("A cut set named '%s' already exists", cuts->GetName()));
return fTrackCuts.IndexOf(obj);
// reset counter
fEvNum = 0;
-
+
// message
AliInfo(Form("Selected event characterization: %s (%s)", (fUseCentrality ? "centrality" : "multiplicity"), fCentralityType.Data()));
-
+
// create list and set it as owner of its content (MANDATORY)
if (fBigOutput) OpenFile(1);
fOutput = new TList();
fOutput->SetOwner();
-
+
// create one histogram per each stored definition (event histograms)
Int_t i, ndef = fHistograms.GetEntries();
AliRsnMiniMonitor *def = 0x0;
for (i = 0; i < ndef; i++) {
- def = (AliRsnMiniMonitor*)fHistograms[i];
+ def = (AliRsnMiniMonitor *)fHistograms[i];
if (!def) continue;
if (!def->Init(GetName(), fOutput)) {
AliError(Form("Def '%s': failed initialization", def->GetName()));
continue;
}
}
-
+
// post data for ALL output slots >0 here, to get at least an empty histogram
PostData(1, fOutput);
}
// event counter
fEvNum++;
-
+
// check current event
Char_t check = CheckCurrentEvent();
if (!check) return;
-
+
// setup PID response
- AliAnalysisManager *man = AliAnalysisManager::GetAnalysisManager();
- AliInputEventHandler *inputHandler = (AliInputEventHandler*)man->GetInputEventHandler();
- fRsnEvent.SetPIDResponse(inputHandler->GetPIDResponse());
-
+ AliAnalysisManager *man = AliAnalysisManager::GetAnalysisManager();
+ AliInputEventHandler *inputHandler = (AliInputEventHandler *)man->GetInputEventHandler();
+ fRsnEvent.SetPIDResponse(inputHandler->GetPIDResponse());
+
// loop on monitors and fill them
Int_t it, icut, nTracks = fRsnEvent.GetAbsoluteSum(), nCuts = fTrackCuts.GetEntriesFast();
AliRsnDaughter cursor;
for (it = 0; it < nTracks; it++) {
fRsnEvent.SetDaughter(cursor, it, fUseMC);
next.Reset();
- while ( (mon = (AliRsnMiniMonitor*)next()) ) {
+ while ( (mon = (AliRsnMiniMonitor *)next()) ) {
icut = mon->GetCutID();
if (icut >= 0 && icut < nCuts) {
- cut = (AliRsnCutSet*)fTrackCuts[icut];
+ cut = (AliRsnCutSet *)fTrackCuts[icut];
if (!cut) {
AliError("Cut not found");
continue;
mon->Fill(&cursor, &fRsnEvent);
}
}
-
+
// post data for computed stuff
PostData(1, fOutput);
}
// Called once at the end of the query
//
- fOutput = dynamic_cast<TList*>(GetOutputData(1));
- if (!fOutput) {
- AliError("Could not retrieve TList fOutput");
- return;
+ fOutput = dynamic_cast<TList *>(GetOutputData(1));
+ if (!fOutput) {
+ AliError("Could not retrieve TList fOutput");
+ return;
}
}
// string to sum messages
TString msg("");
-
+
// check input type
// exit points are provided in all cases an event is bad
// if this block is passed, an event can be rejected only
output = 'E';
// ESD specific check: Physics Selection
// --> if this is failed, the event is rejected
- isSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB);
+ isSelected = (((AliInputEventHandler *)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB);
if (!isSelected) {
AliDebugClass(2, "Event does not pass physics selections");
fRsnEvent.SetRef(0x0);
fRsnEvent.SetRef(fInputEvent);
// add MC if requested and available
if (fUseMC) {
- if (fMCEvent)
+ if (fMCEvent)
fRsnEvent.SetRefMC(fMCEvent);
else {
AliWarning("MC event requested but not available");
fRsnEvent.SetRefMC(0x0);
return 0;
}
-
+
// if event cuts are defined, they are checked here
// final decision on the event depends on this
isSelected = kTRUE;
msg += " -- Local cuts = NONE";
isSelected = kTRUE;
}
-
+
// if the above exit point is not taken, the event is accepted
AliDebugClass(2, Form("Stats for event %d: %s", fEvNum, msg.Data()));
if (isSelected) {
return fInputEvent->GetNumberOfTracks();
else if (!fCentralityType.CompareTo("QUALITY"))
if (isESD)
- return AliESDtrackCuts::GetReferenceMultiplicity((AliESDEvent*)fInputEvent, kTRUE);
+ return AliESDtrackCuts::GetReferenceMultiplicity((AliESDEvent *)fInputEvent, kTRUE);
else {
Double_t count = 0.;
Int_t iTrack, ntracksLoop = fInputEvent->GetNumberOfTracks();
- for (iTrack = 0; iTrack < ntracksLoop; iTrack++) {
- AliVTrack *track = (AliVTrack*)fInputEvent->GetTrack(iTrack);
- AliAODTrack *aodt = dynamic_cast<AliAODTrack*>(track);
+ for (iTrack = 0; iTrack < ntracksLoop; iTrack++) {
+ AliVTrack *track = (AliVTrack *)fInputEvent->GetTrack(iTrack);
+ AliAODTrack *aodt = dynamic_cast<AliAODTrack *>(track);
if (!aodt) continue;
if (!aodt->TestFilterBit(5)) continue;
count++;
}
else if (!fCentralityType.CompareTo("TRACKLETS")) {
if (isESD) {
- const AliMultiplicity *mult = ((AliESDEvent*)fInputEvent)->GetMultiplicity();
+ const AliMultiplicity *mult = ((AliESDEvent *)fInputEvent)->GetMultiplicity();
Float_t nClusters[6] = {0.0,0.0,0.0,0.0,0.0,0.0};
for(Int_t ilay = 0; ilay < 6; ilay++) nClusters[ilay] = (Float_t)mult->GetNumberOfITSClusters(ilay);
return AliESDUtils::GetCorrSPD2(nClusters[1], fInputEvent->GetPrimaryVertex()->GetZ());
AliRsnMiniMonitorTask();
AliRsnMiniMonitorTask(const char *name, Bool_t isMC = kFALSE);
AliRsnMiniMonitorTask(const AliRsnMiniMonitorTask ©);
- AliRsnMiniMonitorTask& operator=(const AliRsnMiniMonitorTask ©);
+ AliRsnMiniMonitorTask &operator=(const AliRsnMiniMonitorTask ©);
virtual ~AliRsnMiniMonitorTask();
- void UseMC(Bool_t yn = kTRUE) {fUseMC = yn;}
+ void UseMC(Bool_t yn = kTRUE) {fUseMC = yn;}
void UseCentrality(const char *type) {fUseCentrality = kTRUE; fCentralityType = type; fCentralityType.ToUpper();}
void UseMultiplicity(const char *type) {fUseCentrality = kFALSE; fCentralityType = type; fCentralityType.ToUpper();}
void SetEventCuts(AliRsnCutSet *cuts) {fEventCuts = cuts;}
Int_t AddTrackCuts(AliRsnCutSet *cuts);
TClonesArray *Outputs() {return &fHistograms;}
-
+
virtual void UserCreateOutputObjects();
- virtual void UserExec(Option_t*);
- virtual void Terminate(Option_t*);
-
+ virtual void UserExec(Option_t *);
+ virtual void Terminate(Option_t *);
+
AliRsnMiniMonitor *CreateMonitor(const char *name, AliRsnMiniMonitor::EType type, Int_t cutID);
-
+
private:
Char_t CheckCurrentEvent();
Int_t fEvNum; //! absolute event counter
Bool_t fUseCentrality; // if true, use centrality for event, otherwise use multiplicity
TString fCentralityType; // definition used to choose what centrality or multiplicity to use
-
+
TList *fOutput; // output list
TClonesArray fHistograms; // list of histogram definitions
-
+
AliRsnCutSet *fEventCuts; // cuts on events
TObjArray fTrackCuts; // list of single track cuts
AliRsnEvent fRsnEvent; //! interface object to the event
ClassDef(AliRsnMiniMonitorTask, 1); // AliRsnMiniMonitorTask
};
-inline AliRsnMiniMonitor* AliRsnMiniMonitorTask::CreateMonitor
+inline AliRsnMiniMonitor *AliRsnMiniMonitorTask::CreateMonitor
(const char *name, AliRsnMiniMonitor::EType type, Int_t cutID)
{
//
// which is then returned to the user for its configuration
//
- Int_t n = fHistograms.GetEntries();
+ Int_t n = fHistograms.GetEntries();
AliRsnMiniMonitor *newDef = new (fHistograms[n]) AliRsnMiniMonitor(name, type, cutID);
-
+
return newDef;
}
// -- properties of resonance (mass, PDG code if needed)
// -- properties of daughters (assigned mass, charges)
// -- definition of output histogram
-//
+//
#include "Riostream.h"
// Output:
// -- "HIST" --> common histogram (up to 3 dimensions)
// -- "SPARSE" --> sparse histogram
-//
-// Computation:
+//
+// Computation:
// -- "EVENT" --> event-only computations
// -- "PAIR" --> track pair computations (default)
// -- "MIX" --> event mixing (like track pair, but different events)
//
TString input;
-
+
// understand output type
input = outType;
input.ToUpper();
fOutputType = kHistogramSparse;
else
AliWarning(Form("String '%s' does not define a meaningful output type", outType));
-
+
// understand computation type
input = compType;
input.ToUpper();
fComputation = kMother;
else
AliWarning(Form("String '%s' does not define a meaningful computation type", compType));
-
+
fCutID[0] = fCutID[1] = -1;
fDaughter[0] = fDaughter[1] = AliRsnDaughter::kUnknown;
fCharge[0] = fCharge[1] = 0;
}
//__________________________________________________________________________________________________
-AliRsnMiniOutput& AliRsnMiniOutput::operator=(const AliRsnMiniOutput ©)
+AliRsnMiniOutput &AliRsnMiniOutput::operator=(const AliRsnMiniOutput ©)
{
//
// Assignment operator
//
- if (this == ©)
- return *this;
- fOutputType = copy.fOutputType;
- fComputation = copy.fComputation;
- fMotherPDG = copy.fMotherPDG;
- fMotherMass = copy.fMotherMass;
- fPairCuts = copy.fPairCuts;
- fOutputID = copy.fOutputID;
- fAxes = copy.fAxes;
- fComputed = copy.fComputed;
- fList = copy.fList;
-
- Int_t i;
- for (i = 0; i < 2; i++) {
- fCutID[i] = copy.fCutID[i];
- fDaughter[i] = copy.fDaughter[i];
- fCharge[i] = copy.fCharge[i];
- }
-
- fSel1.Set(0);
- fSel2.Set(0);
-
+ if (this == ©)
+ return *this;
+ fOutputType = copy.fOutputType;
+ fComputation = copy.fComputation;
+ fMotherPDG = copy.fMotherPDG;
+ fMotherMass = copy.fMotherMass;
+ fPairCuts = copy.fPairCuts;
+ fOutputID = copy.fOutputID;
+ fAxes = copy.fAxes;
+ fComputed = copy.fComputed;
+ fList = copy.fList;
+
+ Int_t i;
+ for (i = 0; i < 2; i++) {
+ fCutID[i] = copy.fCutID[i];
+ fDaughter[i] = copy.fDaughter[i];
+ fCharge[i] = copy.fCharge[i];
+ }
+
+ fSel1.Set(0);
+ fSel2.Set(0);
+
return (*this);
}
// Create a new axis reference
//
- Int_t size = fAxes.GetEntries();
+ Int_t size = fAxes.GetEntries();
new (fAxes[size]) AliRsnMiniAxis(i, nbins, min, max);
}
// Create a new axis reference
//
- Int_t size = fAxes.GetEntries();
+ Int_t size = fAxes.GetEntries();
new (fAxes[size]) AliRsnMiniAxis(i, min, max, step);
}
// Create a new axis reference
//
- Int_t size = fAxes.GetEntries();
+ Int_t size = fAxes.GetEntries();
new (fAxes[size]) AliRsnMiniAxis(i, nbins, values);
}
AliError("Required an output list");
return kFALSE;
}
-
+
fList = list;
Int_t size = fAxes.GetEntries();
if (size < 1) {
// we expect to have maximum 3 axes in this case
AliRsnMiniAxis *xAxis = 0x0, *yAxis = 0x0, *zAxis = 0x0;
- if (size >= 1) xAxis = (AliRsnMiniAxis*)fAxes[0];
- if (size >= 2) yAxis = (AliRsnMiniAxis*)fAxes[1];
- if (size >= 3) zAxis = (AliRsnMiniAxis*)fAxes[2];
-
+ if (size >= 1) xAxis = (AliRsnMiniAxis *)fAxes[0];
+ if (size >= 2) yAxis = (AliRsnMiniAxis *)fAxes[1];
+ if (size >= 3) zAxis = (AliRsnMiniAxis *)fAxes[2];
+
// create histogram depending on the number of axes
TH1 *h1 = 0x0;
if (xAxis && yAxis && zAxis) {
AliError("No axis was initialized");
return;
}
-
+
// switch the correct computation of errors
if (h1 && fList) {
h1->Sumw2();
Int_t size = fAxes.GetEntries();
AliInfo(Form("Sparse histogram name = '%s', with %d axes", name, size));
-
+
// retrieve binnings and sizes of all axes
// since the check for null values is done in Init(),
// we assume that here they must all be well defined
Int_t i, *nbins = new Int_t[size];
for (i = 0; i < size; i++) {
- AliRsnMiniAxis *axis = (AliRsnMiniAxis*)fAxes[i];
+ AliRsnMiniAxis *axis = (AliRsnMiniAxis *)fAxes[i];
nbins[i] = axis->NBins();
}
// update the various axes using the definitions given in the array of axes here
for (i = 0; i < size; i++) {
- AliRsnMiniAxis *axis = (AliRsnMiniAxis*)fAxes[i];
+ AliRsnMiniAxis *axis = (AliRsnMiniAxis *)fAxes[i];
h1->GetAxis(i)->Set(nbins[i], axis->BinArray());
}
// clear heap
delete [] nbins;
-
+
// add to list
if (h1 && fList) {
h1->Sumw2();
AliError("This method can be called only for mother-based computations");
return kFALSE;
}
-
+
// copy passed pair info
fPair = (*pair);
-
+
// check pair against cuts
if (fPairCuts) if (!fPairCuts->IsSelected(&fPair)) return kFALSE;
AliError(Form("[%s] This method can be called only for pair-based computations", GetName()));
return kFALSE;
}
-
+
// loop variables
Int_t i1, i2, start, nadded = 0;
AliRsnMiniParticle *p1, *p2;
-
+
// it is necessary to know if criteria for the two daughters are the same
// and if the two events are the same or not (mixing)
//Bool_t sameCriteria = ((fCharge[0] == fCharge[1]) && (fCutID[0] == fCutID[1]));
Bool_t sameCriteria = ((fCharge[0] == fCharge[1]) && (fDaughter[0] == fDaughter[1]));
Bool_t sameEvent = (event1->ID() == event2->ID());
-
+
TString selList1 = "";
TString selList2 = "";
Int_t n1 = event1->CountParticles(fSel1, fCharge[0], fCutID[0]);
AliDebugClass(1, "No pairs to mix");
return 0;
}
-
+
// external loop
for (i1 = 0; i1 < n1; i1++) {
p1 = event1->GetParticle(fSel1[i1]);
}
// get computed values & fill histogram
nadded++;
- if (refFirst) ComputeValues(event1, valueList); else ComputeValues(event2, valueList);
+ if (refFirst) ComputeValues(event1, valueList); else ComputeValues(event2, valueList);
FillHistogram();
} // end internal loop
} // end external loop
-
+
AliDebugClass(1, Form("Pairs added in total = %4d", nadded));
return nadded;
}
if (fComputed.GetSize() != size) fComputed.Set(size);
Int_t i, ival, nval = valueList->GetEntries();
-
+
for (i = 0; i < size; i++) {
fComputed[i] = 1E20;
- AliRsnMiniAxis *axis = (AliRsnMiniAxis*)fAxes[i];
+ AliRsnMiniAxis *axis = (AliRsnMiniAxis *)fAxes[i];
if (!axis) {
AliError("Null axis");
continue;
AliError(Form("Required value #%d, while maximum is %d", ival, nval));
continue;
}
- AliRsnMiniValue *val = (AliRsnMiniValue*)valueList->At(ival);
+ AliRsnMiniValue *val = (AliRsnMiniValue *)valueList->At(ival);
if (!val) {
AliError(Form("Value in position #%d is NULL", ival));
continue;
- }
+ }
// if none of the above exit points is taken, compute value
fComputed[i] = val->Eval(&fPair, event);
}
TObject *obj = fList->At(fOutputID);
if (obj->InheritsFrom(TH1F::Class())) {
- ((TH1F*)obj)->Fill(fComputed[0]);
+ ((TH1F *)obj)->Fill(fComputed[0]);
} else if (obj->InheritsFrom(TH2F::Class())) {
- ((TH2F*)obj)->Fill(fComputed[0], fComputed[1]);
+ ((TH2F *)obj)->Fill(fComputed[0], fComputed[1]);
} else if (obj->InheritsFrom(TH3F::Class())) {
- ((TH3F*)obj)->Fill(fComputed[0], fComputed[1], fComputed[2]);
+ ((TH3F *)obj)->Fill(fComputed[0], fComputed[1], fComputed[2]);
} else if (obj->InheritsFrom(THnSparseF::Class())) {
- ((THnSparseF*)obj)->Fill(fComputed.GetArray());
+ ((THnSparseF *)obj)->Fill(fComputed.GetArray());
} else {
AliError("No output initialized");
}
// -- properties of resonance (mass, PDG code if needed)
// -- properties of daughters (assigned mass, charges)
// -- definition of output histogram
-//
+//
#include "AliRsnDaughter.h"
#include "AliRsnMiniParticle.h"
kHistogramSparse,
kTypes
};
-
+
enum EComputation {
kEventOnly,
kTrackPair,
kMother,
kComputations
};
-
+
AliRsnMiniOutput();
AliRsnMiniOutput(const char *name, EOutputType type, EComputation src = kTrackPair);
AliRsnMiniOutput(const char *name, const char *outType, const char *compType);
AliRsnMiniOutput(const AliRsnMiniOutput ©);
- AliRsnMiniOutput& operator=(const AliRsnMiniOutput ©);
-
+ AliRsnMiniOutput &operator=(const AliRsnMiniOutput ©);
+
Bool_t IsEventOnly() const {return (fComputation == kEventOnly);}
Bool_t IsTrackPair() const {return (fComputation == kTrackPair);}
Bool_t IsTrackPairMix() const {return (fComputation == kTrackPairMix);}
Bool_t IsSameDaughter() const {return (fDaughter[0] == fDaughter[1]);}
//Bool_t IsSymmetric() const {return (IsLikeSign() && IsSameCut());}
Bool_t IsSymmetric() const {return (IsLikeSign() && IsSameDaughter());}
-
+
EOutputType GetOutputType() const {return fOutputType;}
EComputation GetComputation() const {return fComputation;}
Int_t GetCutID(Int_t i) const {if (i <= 0) return fCutID [0]; else return fCutID [1];}
Int_t GetCharge(Int_t i) const {if (i <= 0) return fCharge[0]; else return fCharge[1];}
Int_t GetMotherPDG() const {return fMotherPDG;}
Double_t GetMotherMass() const {return fMotherMass;}
-
+
void SetOutputType(EOutputType type) {fOutputType = type;}
void SetComputation(EComputation src) {fComputation = src;}
void SetCutID(Int_t i, Int_t value) {if (i <= 0) fCutID [0] = value; else fCutID [1] = value;}
void SetMotherPDG(Int_t pdg) {fMotherPDG = pdg;}
void SetMotherMass(Double_t mass) {fMotherMass = mass;}
void SetPairCuts(AliRsnCutSet *set) {fPairCuts = set;}
-
+
void AddAxis(Int_t id, Int_t nbins, Double_t min, Double_t max);
void AddAxis(Int_t id, Double_t min, Double_t max, Double_t step);
void AddAxis(Int_t id, Int_t nbins, Double_t *values);
- AliRsnMiniAxis* GetAxis(Int_t i) {if (i >= 0 && i < fAxes.GetEntries()) return (AliRsnMiniAxis*)fAxes[i]; return 0x0;}
- Double_t* GetAllComputed() {return fComputed.GetArray();}
-
- AliRsnMiniPair& Pair() {return fPair;}
+ AliRsnMiniAxis *GetAxis(Int_t i) {if (i >= 0 && i < fAxes.GetEntries()) return (AliRsnMiniAxis *)fAxes[i]; return 0x0;}
+ Double_t *GetAllComputed() {return fComputed.GetArray();}
+
+ AliRsnMiniPair &Pair() {return fPair;}
Bool_t Init(const char *prefix, TList *list);
Bool_t FillMother(const AliRsnMiniPair *pair, AliRsnMiniEvent *event, TClonesArray *valueList);
Bool_t FillEvent(AliRsnMiniEvent *event, TClonesArray *valueList);
Int_t FillPair(AliRsnMiniEvent *event1, AliRsnMiniEvent *event2, TClonesArray *valueList, Bool_t refFirst = kTRUE);
-
+
private:
void CreateHistogram(const char *name);
Int_t fMotherPDG; // PDG code of resonance
Double_t fMotherMass; // nominal resonance mass
AliRsnCutSet *fPairCuts; // cuts on the pair
-
+
Int_t fOutputID; // index of output object in container list
TClonesArray fAxes; // definitions for the axes of each value
TArrayD fComputed; //! temporary container for all computed values
TList *fList; //! pointer to the TList containing the output
TArrayI fSel1; //! list of selected particles for definition 1
TArrayI fSel2; //! list of selected particles for definition 2
-
+
ClassDef(AliRsnMiniOutput,1) // AliRsnMiniOutput class
};
p2->Set4Vector(fP2[0], m2, kFALSE);
p1->Set4Vector(fP1[1], m1, kTRUE );
p2->Set4Vector(fP2[1], m2, kTRUE );
-
+
fMother = -1;
if (p1->Mother() == p2->Mother()) {
fMother = p1->Mother();
fMotherPDG = p1->MotherPDG();
}
-
+
Int_t i;
for (i = 0; i < 2; i++) {
fSum[i] = fP1[i] + fP2[i];
//
// Return cosine of angle of one daughter to the resonance momentum in its rest frame
//
-
+
TLorentzVector &mother = fSum[ID(useMC)];
TLorentzVector &daughter0 = fP1[ID(useMC)];
TLorentzVector &daughter1 = fP2[ID(useMC)];
//
// This object is used as lightweight temporary container
-// of all information needed from any input object and
+// of all information needed from any input object and
// useful for resonance analysis.
-//
+//
#include <TObject.h>
#include <TLorentzVector.h>
AliRsnMiniPair() : fMother(-1), fMotherPDG(0) { }
- Int_t& Mother() {return fMother;}
- Int_t& MotherPDG() {return fMotherPDG;}
+ Int_t &Mother() {return fMother;}
+ Int_t &MotherPDG() {return fMotherPDG;}
void Fill(AliRsnMiniParticle *p1, AliRsnMiniParticle *p2, Double_t m1, Double_t m2, Double_t refMass);
void FillRef(Double_t mass);
void InvertP(Bool_t first);
-
+
Int_t ID(Bool_t mc) const {if (mc) return 1; else return 0;}
-
- TLorentzVector& P1 (Bool_t mc) {return fP1 [ID(mc)];}
- TLorentzVector& P2 (Bool_t mc) {return fP2 [ID(mc)];}
- TLorentzVector& Sum(Bool_t mc) {return fSum[ID(mc)];}
- TLorentzVector& Ref(Bool_t mc) {return fRef[ID(mc)];}
-
+
+ TLorentzVector &P1 (Bool_t mc) {return fP1 [ID(mc)];}
+ TLorentzVector &P2 (Bool_t mc) {return fP2 [ID(mc)];}
+ TLorentzVector &Sum(Bool_t mc) {return fSum[ID(mc)];}
+ TLorentzVector &Ref(Bool_t mc) {return fRef[ID(mc)];}
+
Double_t Pt(Bool_t mc) const {return fSum[ID(mc)].Pt();}
Double_t Pz(Bool_t mc) const {return fSum[ID(mc)].Pz();}
Double_t Eta(Bool_t mc) const {return fSum[ID(mc)].Eta();}
Double_t InvMass(Bool_t mc) const {return fSum[ID(mc)].M();}
- Double_t InvMassRes() const;
- Double_t InvMassDiff() const;
+ Double_t InvMassRes() const;
+ Double_t InvMassDiff() const;
Double_t Mt(Bool_t mc) const {return fRef[ID(mc)].Mt();}
Double_t Y(Bool_t mc) const {return fRef[ID(mc)].Rapidity();}
Double_t PtRatio(Bool_t mc) const;
TLorentzVector fP2 [2]; // 2nd daughter momentum
TLorentzVector fSum[2]; // sum of momenta
TLorentzVector fRef[2]; // same as 'fSum' but with nominal resonance mass
-
+
Int_t fMother; // label of mothers (when common)
Int_t fMotherPDG; // PDG code of mother (when common)
-
+
ClassDef(AliRsnMiniPair,1)
};
//
if (fSum[1].M() <= 0.0) return 1E20;
-
+
return (fSum[0].M() - fSum[1].M()) / fSum[1].M();
}
//
if (fSum[1].M() <= 0.0) return 1E20;
-
+
return (fSum[0].M() - fSum[1].M());
}
Double_t num = TMath::Abs(fP1[ID(mc)].Perp() - fP2[ID(mc)].Perp());
Double_t den = TMath::Abs(fP1[ID(mc)].Perp() + fP2[ID(mc)].Perp());
-
+
if (den <= 0.0) return 1E20;
-
+
return num / den;
}
const TLorentzVector &p1 = fP1[ID(mc)];
const TLorentzVector &p2 = fP2[ID(mc)];
-
+
return ((p1.Perp() * p2.Perp() + p1.Z() * p2.Z()) / p1.Mag() / p2.Mag());
}
//
// This object is used as lightweight temporary container
-// of all information needed from any input object and
+// of all information needed from any input object and
// useful for resonance analysis.
// Lists of such objects are stored in a buffer, in order
// to allow an event mixing.
fCharge = '-';
else
fCharge = '0';
-
+
// rec info
if (daughter->GetRef()) {
fPrec[0] = daughter->GetRef()->Px();
fPrec[1] = daughter->GetRef()->Py();
fPrec[2] = daughter->GetRef()->Pz();
}
-
+
// MC info
if (daughter->GetRefMC()) {
fPsim[0] = daughter->GetRefMC()->Px();
//
// This object is used as lightweight temporary container
-// of all information needed from any input object and
+// of all information needed from any input object and
// useful for resonance analysis.
-//
+//
#include <TMath.h>
#include <TObject.h>
AliRsnMiniParticle() : fIndex(-1), fCharge(0), fPDG(0), fMother(0), fMotherPDG(0), fCutBits(0x0) {Int_t i = 3; while (i--) fPsim[i] = fPrec[i] = 0.0;}
- Int_t& Index() {return fIndex;}
- Char_t& Charge() {return fCharge;}
- Float_t& PsimX() {return fPsim[0];}
- Float_t& PsimY() {return fPsim[1];}
- Float_t& PsimZ() {return fPsim[2];}
- Float_t& PrecX() {return fPrec[0];}
- Float_t& PrecY() {return fPrec[1];}
- Float_t& PrecZ() {return fPrec[2];}
- Float_t& Px(Bool_t mc) {return (mc ? fPsim[0] : fPrec[0]);}
- Float_t& Py(Bool_t mc) {return (mc ? fPsim[1] : fPrec[1]);}
- Float_t& Pz(Bool_t mc) {return (mc ? fPsim[2] : fPrec[2]);}
- Short_t& PDG() {return fPDG;}
+ Int_t &Index() {return fIndex;}
+ Char_t &Charge() {return fCharge;}
+ Float_t &PsimX() {return fPsim[0];}
+ Float_t &PsimY() {return fPsim[1];}
+ Float_t &PsimZ() {return fPsim[2];}
+ Float_t &PrecX() {return fPrec[0];}
+ Float_t &PrecY() {return fPrec[1];}
+ Float_t &PrecZ() {return fPrec[2];}
+ Float_t &Px(Bool_t mc) {return (mc ? fPsim[0] : fPrec[0]);}
+ Float_t &Py(Bool_t mc) {return (mc ? fPsim[1] : fPrec[1]);}
+ Float_t &Pz(Bool_t mc) {return (mc ? fPsim[2] : fPrec[2]);}
+ Short_t &PDG() {return fPDG;}
Short_t PDGAbs() {return TMath::Abs(fPDG);}
- Short_t& Mother() {return fMother;}
- Short_t& MotherPDG() {return fMotherPDG;}
- UShort_t& CutBits() {return fCutBits;}
+ Short_t &Mother() {return fMother;}
+ Short_t &MotherPDG() {return fMotherPDG;}
+ UShort_t &CutBits() {return fCutBits;}
Bool_t HasCutBit(Int_t i) {UShort_t bit = 1 << i; return ((fCutBits & bit) != 0);}
void SetCutBit(Int_t i) {UShort_t bit = 1 << i; fCutBits |= bit;}
void ClearCutBit(Int_t i) {UShort_t bit = 1 << i; fCutBits &= (~bit);}
-
+
void Set4Vector(TLorentzVector &v, Float_t mass, Bool_t mc) {v.SetXYZM(Px(mc), Py(mc), Pz(mc), mass);}
void CopyDaughter(AliRsnDaughter *daughter);
Short_t fMother; // index of mother in its container
Short_t fMotherPDG; // PDG code of mother
UShort_t fCutBits; // list of bits used to know what cuts were passed by this track
-
+
ClassDef(AliRsnMiniParticle,2)
};
}
//_____________________________________________________________________________
-AliRsnMiniValue::AliRsnMiniValue(const AliRsnMiniValue& copy) :
+AliRsnMiniValue::AliRsnMiniValue(const AliRsnMiniValue ©) :
TNamed(copy),
fType(copy.fType),
fUseMCInfo(copy.fUseMCInfo)
}
//_____________________________________________________________________________
-AliRsnMiniValue& AliRsnMiniValue::operator=(const AliRsnMiniValue& copy)
+AliRsnMiniValue &AliRsnMiniValue::operator=(const AliRsnMiniValue ©)
{
//
// Assignment operator.
//
TNamed::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fType = copy.fType;
fUseMCInfo = copy.fUseMCInfo;
}
//_____________________________________________________________________________
-const char* AliRsnMiniValue::TypeName(EType type)
+const char *AliRsnMiniValue::TypeName(EType type)
{
//
// This method returns a string to give a name to each possible
AliError("Null pair passed!");
return 1E20;
}
-
+
// compute value depending on types in the enumeration
// if the type does not match any available choice, or if
// the computation is not doable due to any problem
// (not initialized support object, wrong values, risk of floating point errors)
// the method returng kFALSE and sets the computed value to a meaningless number
switch (fType) {
- // ---- event values -------------------------------------------------------------------------
+ // ---- event values -------------------------------------------------------------------------
case kVz:
return event->Vz();
case kMult:
return event->Angle();
case kLeadingPt:
return 0.0;
- // ---- pair values --------------------------------------------------------------------------
- case kPt:
+ // ---- pair values --------------------------------------------------------------------------
+ case kPt:
return pair->Pt(fUseMCInfo);
case kInvMass:
return pair->InvMass(fUseMCInfo);
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
+
////////////////////////////////////////////////////////////////////////////////
//
// Values which depend on 4-momentum of the pair.
};
AliRsnMiniValue(EType type = kTypes, Bool_t useMC = kFALSE);
- AliRsnMiniValue(const AliRsnMiniValue& copy);
- AliRsnMiniValue& operator=(const AliRsnMiniValue& copy);
+ AliRsnMiniValue(const AliRsnMiniValue ©);
+ AliRsnMiniValue &operator=(const AliRsnMiniValue ©);
virtual ~AliRsnMiniValue() { }
void SetType(EType type) {fType = type;}
EType GetType() const {return fType;}
- const char* GetTypeName() const {return TypeName(fType);}
+ const char *GetTypeName() const {return TypeName(fType);}
Bool_t IsEventValue() const {return (fType < kEventCuts);}
-
+
Float_t Eval(AliRsnMiniPair *pair, AliRsnMiniEvent *event = 0x0);
-
- static const char* TypeName(EType type);
- static const char* ValueName(EType type, Bool_t useMC);
+
+ static const char *TypeName(EType type);
+ static const char *ValueName(EType type, Bool_t useMC);
protected:
EType fType; // type from enumeration
Bool_t fUseMCInfo; // switch to use rec/sim momentum
-
+
ClassDef(AliRsnMiniValue, 1) // AliRsnMiniValue class
};
-inline const char* AliRsnMiniValue::ValueName(EType type, Bool_t useMC)
+inline const char *AliRsnMiniValue::ValueName(EType type, Bool_t useMC)
{
//
// Define a criterion to name these object.
// They are not managed by the user, since each object is a singleton
//
- if (useMC)
+ if (useMC)
return Form("MC_%s", TypeName(type));
else
return TypeName(type);
}
//__________________________________________________________________________________________________
-AliRsnMother& AliRsnMother::operator=(const AliRsnMother &obj)
+AliRsnMother &AliRsnMother::operator=(const AliRsnMother &obj)
{
//
// Assignment operator.
// Does not duplicate pointers.
//
- if (this == &obj)
- return *this;
-
- fSum = obj.fSum;
- fRef = obj.fRef;
- fSumMC = obj.fSumMC;
- fRefMC = obj.fRefMC;
- fRefEvent = obj.fRefEvent;
- fDaughter[0] = obj.fDaughter[0];
- fDaughter[1] = obj.fDaughter[1];
-
- return (*this);
+ if (this == &obj)
+ return *this;
+
+ fSum = obj.fSum;
+ fRef = obj.fRef;
+ fSumMC = obj.fSumMC;
+ fRefMC = obj.fRefMC;
+ fRefEvent = obj.fRefEvent;
+ fDaughter[0] = obj.fDaughter[0];
+ fDaughter[1] = obj.fDaughter[1];
+
+ return (*this);
}
//__________________________________________________________________________________________________
// If the mother label is the same, the function returns the PDG code of mother,
// otherwise it returns 0.
// The two arguments passed by reference contain the GEANT labels of the mother
-// of the two particles to which the two daughters point. This is for being able
+// of the two particles to which the two daughters point. This is for being able
// to check if they are really coming from a resonance (indexes >= 0) or not.
//
Int_t m1 = fDaughter[0]->GetMother();
Int_t m2 = fDaughter[1]->GetMother();
Int_t out = 0;
-
+
// a true mother makes sense only if both mothers
// are not-negative and equal
if (m1 >= 0 && m2 >= 0 && m1 == m2) {
out = TMath::Abs(fDaughter[0]->GetMotherPDG());
AliDebugClass(1, Form("Mothers are: %d %d --> EQUAL (PDG = %d)", m1, m2, out));
- }
-
+ }
+
return out;
}
success = kFALSE;
return -99.0;
}
-
+
Int_t id1 = fDaughter[0]->GetID();
Int_t id2 = fDaughter[1]->GetID();
Int_t idL = fRefEvent->GetLeadingIndex();
-
+
if (id1 == idL || id2 == idL) {
success = kFALSE;
return -99.0;
}
-
+
AliRsnDaughter leading = fRefEvent->GetDaughter(idL, kFALSE);
AliVParticle *ref = leading.GetRef();
Double_t angle = ref->Phi() - fSum.Phi();
-
+
//return angle w.r.t. leading particle in the range -pi/2, 3/2pi
while (angle >= 1.5 * TMath::Pi()) angle -= 2 * TMath::Pi();
while (angle < -0.5 * TMath::Pi()) angle += 2 * TMath::Pi();
success = kTRUE;
-
+
return angle;
}
// sum
fSum = fDaughter[0]->Prec() + fDaughter[1]->Prec();
fSumMC = fDaughter[0]->Psim() + fDaughter[1]->Psim();
-
+
// reference
fRef.SetXYZM(fSum.X(), fSum.Y(), fSum.Z(), motherMass);
fRefMC.SetXYZM(fSumMC.X(), fSumMC.Y(), fSumMC.Z(), motherMass);
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
+
////////////////////////////////////////////////////////////////////////////////
//
// Interface to candidate resonance decaying into 2 bodies.
AliRsnMother() : fRefEvent(0), fSum(), fSumMC(), fRef(), fRefMC() {fDaughter[0] = fDaughter[1] = 0;}
AliRsnMother(const AliRsnMother &obj);
- AliRsnMother& operator=(const AliRsnMother &obj);
+ AliRsnMother &operator=(const AliRsnMother &obj);
virtual ~AliRsnMother();
// setters (4-vectors cannot be set)
void Reset();
void SetDaughter(Int_t i, AliRsnDaughter *d) {fDaughter[CkID(i)] = d;}
void SetRefEvent(AliRsnEvent *event) {fRefEvent = event;}
-
+
// getters
- AliRsnEvent* GetRefEvent() {return fRefEvent;}
- AliRsnDaughter* GetDaughter(const Int_t &i) {return fDaughter[CkID(i)];}
- TLorentzVector& Sum(Bool_t mc) {return (mc ? fSumMC : fSum);}
- TLorentzVector& Ref(Bool_t mc) {return (mc ? fRefMC : fRef);}
+ AliRsnEvent *GetRefEvent() {return fRefEvent;}
+ AliRsnDaughter *GetDaughter(const Int_t &i) {return fDaughter[CkID(i)];}
+ TLorentzVector &Sum(Bool_t mc) {return (mc ? fSumMC : fSum);}
+ TLorentzVector &Ref(Bool_t mc) {return (mc ? fRefMC : fRef);}
Bool_t GetResolution(Double_t &value);
Double_t Rapidity(Bool_t mc) {if (mc) return fRefMC.Rapidity(); else return fRef.Rapidity();}
-
+
// checks
Bool_t IsLabelEqual() const {return TMath::Abs(fDaughter[0]->GetLabel()) == TMath::Abs(fDaughter[1]->GetLabel());}
Bool_t IsIndexEqual() const {return (fDaughter[0]->GetID() == fDaughter[1]->GetID());}
Bool_t IsOwnerEqual() const {return (fDaughter[0]->GetOwnerEvent() == fDaughter[1]->GetOwnerEvent());}
Int_t CommonMother() const;
-
+
// angles
Double_t AngleTo(AliRsnDaughter *track, Bool_t mc = kFALSE) {return track->P(mc).Angle(Sum(mc).Vect());}
Double_t AngleToLeading(Bool_t &success);
-
+
// computations
void ComputeSum(Double_t mass1, Double_t mass2, Double_t motherMass);
- Double_t CosThetaStar(Bool_t first = kTRUE, Bool_t useMC = kFALSE);
+ Double_t CosThetaStar(Bool_t first = kTRUE, Bool_t useMC = kFALSE);
void PrintInfo(const Option_t *option = "ALL") const;
Bool_t CheckPair(Bool_t checkMC = kFALSE) const;
// This object contains two AliRsnDaughterDef which define a model for each
// of the two expected daughters (see also AliRsnDaughterDef class) plus a
// mass hypothesis for the resonance, which is used for computin quantities
-// which need it (like rapidity or Mt), and a PDG code, which is used to
+// which need it (like rapidity or Mt), and a PDG code, which is used to
// check for true pairs, when needed. In all other cases, these two additional
// values can be left to their default (meaningless) value.
// Since this object must define a decay channel, the only provided constructor
//_____________________________________________________________________________
AliRsnPairDef::AliRsnPairDef() :
- fMotherMass(0.0),
- fMotherPDG(0),
- fDef1(),
+ fMotherMass(0.0),
+ fMotherPDG(0),
+ fDef1(),
fDef2()
{
//
//_____________________________________________________________________________
AliRsnPairDef::AliRsnPairDef
(EPARTYPE type1, Char_t ch1, EPARTYPE type2, Char_t ch2, Int_t pdg, Double_t mass) :
- fMotherMass(mass),
- fMotherPDG(pdg),
- fDef1(type1, ch1),
+ fMotherMass(mass),
+ fMotherPDG(pdg),
+ fDef1(type1, ch1),
fDef2(type2, ch2)
{
//
//_____________________________________________________________________________
AliRsnPairDef::AliRsnPairDef
(AliRsnDaughter::ESpecies type1, Char_t ch1, AliRsnDaughter::ESpecies type2, Char_t ch2, Int_t pdg, Double_t mass) :
- fMotherMass(mass),
- fMotherPDG(pdg),
- fDef1(type1, ch1),
+ fMotherMass(mass),
+ fMotherPDG(pdg),
+ fDef1(type1, ch1),
fDef2(type2, ch2)
{
//
// If the two pointers are well initialized, they are used to init the members.
//
}
-
+
//_____________________________________________________________________________
AliRsnPairDef::AliRsnPairDef(const AliRsnPairDef ©) :
TObject(copy),
}
//_____________________________________________________________________________
-AliRsnPairDef& AliRsnPairDef::operator=(const AliRsnPairDef ©)
+AliRsnPairDef &AliRsnPairDef::operator=(const AliRsnPairDef ©)
{
//
// Assignment operator with standard behavior.
//
- if (this == ©)
- return *this;
- fMotherMass = copy.fMotherMass;
- fMotherPDG = copy.fMotherPDG;
- fDef1 = copy.fDef1;
- fDef2 = copy.fDef2;
-
+ if (this == ©)
+ return *this;
+ fMotherMass = copy.fMotherMass;
+ fMotherPDG = copy.fMotherPDG;
+ fDef1 = copy.fDef1;
+ fDef2 = copy.fDef2;
+
return (*this);
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
+
////////////////////////////////////////////////////////////////////////////////
//
// Resonance decay tree definition.
AliRsnPairDef(EPARTYPE type1, Char_t ch1, EPARTYPE type2, Char_t ch2, Int_t motherPDG = 0, Double_t motherMass = 0.0);
AliRsnPairDef(AliRsnDaughter::ESpecies type1, Char_t ch1, AliRsnDaughter::ESpecies type2, Char_t ch2, Int_t motherPDG = 0, Double_t motherMass = 0.0);
AliRsnPairDef(const AliRsnPairDef ©);
- AliRsnPairDef& operator= (const AliRsnPairDef ©);
+ AliRsnPairDef &operator= (const AliRsnPairDef ©);
virtual ~AliRsnPairDef() { }
- virtual const char* GetName() const {return Form("%s_%s", fDef1.GetName(), fDef2.GetName());}
+ virtual const char *GetName() const {return Form("%s_%s", fDef1.GetName(), fDef2.GetName());}
Int_t GetMotherPDG() const {return fMotherPDG;}
Double_t GetMotherMass() const {return fMotherMass;}
- AliRsnDaughterDef& GetDef1() {return fDef1;}
- AliRsnDaughterDef& GetDef2() {return fDef2;}
- AliRsnDaughterDef& GetDef(Int_t i) {if (i<1) return GetDef1(); else return GetDef2();}
+ AliRsnDaughterDef &GetDef1() {return fDef1;}
+ AliRsnDaughterDef &GetDef2() {return fDef2;}
+ AliRsnDaughterDef &GetDef(Int_t i) {if (i<1) return GetDef1(); else return GetDef2();}
void SetMotherPDG(Int_t pdg) {fMotherPDG = pdg;}
void SetMotherMass(Double_t mass) {fMotherMass = mass;}
////////////////////////////////////////////////////////////////////////////////
//
// Base class used wherever it is needed to check the class type of
-// an object w.r. to the RSN framework analysis (daughter, mother, event)
+// an object w.r. to the RSN framework analysis (daughter, mother, event)
// which could be used for cut checking or value computing.
// Since most of these operation are implemented into classes that
// operate on any of such objects, then this class helps in making sure
// 1) check if the object class matches the required target type
// 2) if (1) is successful, set the built-in pointer data member
// in order to point to it, after being casted accordingly
-// 3) if the target is a daughter or a mother, adjust the pointer
+// 3) if the target is a daughter or a mother, adjust the pointer
// to reference event accordingly
//
AliError("Passed a NULL object");
return kFALSE;
}
-
+
// checks matching between argument type and expected object type
// the passed object is also casted into the appropriate pointer
// when a daughter or mother is passed and the target type expects
// and event, the check is yes successful and the owner event is used
if (object->IsA() == AliRsnDaughter::Class() && (fTargetType == kDaughter || fTargetType == kEvent)) {
- fDaughter = static_cast<AliRsnDaughter*>(object);
+ fDaughter = static_cast<AliRsnDaughter *>(object);
fEvent = fDaughter->GetOwnerEvent();
return kTRUE;
}
else if (object->IsA() == AliRsnMother::Class() && (fTargetType == kMother || fTargetType == kEvent)) {
- fMother = static_cast<AliRsnMother*>(object);
+ fMother = static_cast<AliRsnMother *>(object);
fEvent = fMother->GetRefEvent();
return kTRUE;
}
else if (object->IsA() == AliRsnEvent::Class() && fTargetType == kEvent) {
- fEvent = static_cast<AliRsnEvent*>(object);
+ fEvent = static_cast<AliRsnEvent *>(object);
return kTRUE;
}
else {
}
//______________________________________________________________________________
-const char* AliRsnTarget::GetTargetTypeName() const
+const char *AliRsnTarget::GetTargetTypeName() const
{
//
// Returns a string with the name of the cut target type-
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
+
////////////////////////////////////////////////////////////////////////////////
//
// General class for cut/computation target objects (daughter/pair/event).
AliRsnTarget() : fTargetType(kTargetTypes), fDaughter(0x0), fMother(0x0), fEvent(0x0) { /*nothing*/ }
AliRsnTarget(const char *name, ETargetType type = kTargetTypes) : TNamed(name, ""), fTargetType(type), fDaughter(0x0), fMother(0x0), fEvent(0x0) { /*nothing*/ }
- AliRsnTarget(const AliRsnTarget& copy) : TNamed(copy), fTargetType(copy.fTargetType), fDaughter(0x0), fMother(0x0), fEvent(0x0) { /*nothing*/ }
- AliRsnTarget& operator=(const AliRsnTarget& copy) { TNamed::operator=(copy); if (this==©) return *this; fTargetType = copy.fTargetType; return (*this); }
+ AliRsnTarget(const AliRsnTarget ©) : TNamed(copy), fTargetType(copy.fTargetType), fDaughter(0x0), fMother(0x0), fEvent(0x0) { /*nothing*/ }
+ AliRsnTarget &operator=(const AliRsnTarget ©) { TNamed::operator=(copy); if (this==©) return *this; fTargetType = copy.fTargetType; return (*this); }
virtual ~AliRsnTarget() { /*nothing*/ }
Bool_t IsAllNull() const {return (!fDaughter && !fMother && !fEvent);}
Bool_t IsTarget(ETargetType targetType) const {return (fTargetType == targetType);}
Bool_t TargetOK(TObject *object);
-
+
void SetTargetType(ETargetType type) {fTargetType = type;}
ETargetType GetTargetType() const {return fTargetType;}
- Char_t GetTargetTypeChar() const;
- const char* GetTargetTypeName() const;
-
- AliRsnDaughter* GetTargetDaughter() {return fDaughter;}
- AliRsnMother* GetTargetMother() {return fMother;}
- AliRsnEvent* GetTargetEvent() {return fEvent;}
+ Char_t GetTargetTypeChar() const;
+ const char *GetTargetTypeName() const;
+
+ AliRsnDaughter *GetTargetDaughter() {return fDaughter;}
+ AliRsnMother *GetTargetMother() {return fMother;}
+ AliRsnEvent *GetTargetEvent() {return fEvent;}
protected:
}
//_____________________________________________________________________________
-AliRsnValue::AliRsnValue(const AliRsnValue& copy) :
+AliRsnValue::AliRsnValue(const AliRsnValue ©) :
AliRsnTarget(copy),
fUseMCInfo(copy.fUseMCInfo),
fComputedValue(copy.fComputedValue),
}
//_____________________________________________________________________________
-AliRsnValue& AliRsnValue::operator=(const AliRsnValue& copy)
+AliRsnValue &AliRsnValue::operator=(const AliRsnValue ©)
{
//
// Assignment operator.
AliRsnTarget::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fUseMCInfo = copy.fUseMCInfo;
fComputedValue = copy.fComputedValue;
fBinArray = copy.fBinArray;
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
+
////////////////////////////////////////////////////////////////////////////////
//
// Collection of all values which can be computed within the package
public:
AliRsnValue(const char *name = "", AliRsnTarget::ETargetType type = AliRsnTarget::kTargetTypes);
- AliRsnValue(const AliRsnValue& copy);
- AliRsnValue& operator=(const AliRsnValue& copy);
+ AliRsnValue(const AliRsnValue ©);
+ AliRsnValue &operator=(const AliRsnValue ©);
virtual ~AliRsnValue() { }
- TArrayD& GetArray() {return fBinArray;}
- const Double_t* GetArrayValues() const {return fBinArray.GetArray();}
+ TArrayD &GetArray() {return fBinArray;}
+ const Double_t *GetArrayValues() const {return fBinArray.GetArray();}
Double_t GetComputedValue() const {return fComputedValue;}
void SetUseMCInfo(Bool_t yn = kTRUE) {fUseMCInfo = yn;}
}
//_____________________________________________________________________________
-AliRsnValueDaughter::AliRsnValueDaughter(const AliRsnValueDaughter& copy) :
+AliRsnValueDaughter::AliRsnValueDaughter(const AliRsnValueDaughter ©) :
AliRsnValue(copy),
fType(copy.fType)
{
}
//_____________________________________________________________________________
-AliRsnValueDaughter& AliRsnValueDaughter::operator=(const AliRsnValueDaughter& copy)
+AliRsnValueDaughter &AliRsnValueDaughter::operator=(const AliRsnValueDaughter ©)
{
//
// Assignment operator.
AliRsnValue::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fType = copy.fType;
-
+
return (*this);
}
//_____________________________________________________________________________
-const char* AliRsnValueDaughter::GetTypeName() const
+const char *AliRsnValueDaughter::GetTypeName() const
{
//
// This method returns a string to give a name to each possible
// The output of the function tells if computing was successful,
// and the values must be taken with GetValue().
//
-
- // coherence check, which also casts object
+
+ // coherence check, which also casts object
// to AliRsnTarget data members and returns kFALSE
// in case the object is NULL
if (!TargetOK(object)) return kFALSE;
AliError("No DATA");
return kFALSE;
}
-
+
// compute value depending on types in the enumeration
// if the type does not match any available choice, or if
// the computation is not doable due to any problem
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
+
////////////////////////////////////////////////////////////////////////////////
//
// Values which depend on 4-momentum of the daughters.
};
AliRsnValueDaughter(const char *name = "valDaughter", EType type = kTypes);
- AliRsnValueDaughter(const AliRsnValueDaughter& copy);
- AliRsnValueDaughter& operator=(const AliRsnValueDaughter& copy);
+ AliRsnValueDaughter(const AliRsnValueDaughter ©);
+ AliRsnValueDaughter &operator=(const AliRsnValueDaughter ©);
virtual ~AliRsnValueDaughter() { }
void SetType(EType type) {fType = type;}
EType GetType() const {return fType;}
- const char* GetTypeName() const;
+ const char *GetTypeName() const;
virtual Bool_t Eval(TObject *object);
}
//_____________________________________________________________________________
-AliRsnValueEvent::AliRsnValueEvent(const AliRsnValueEvent& copy) :
+AliRsnValueEvent::AliRsnValueEvent(const AliRsnValueEvent ©) :
AliRsnValue(copy),
fType(copy.fType)
{
}
//_____________________________________________________________________________
-AliRsnValueEvent& AliRsnValueEvent::operator=(const AliRsnValueEvent& copy)
+AliRsnValueEvent &AliRsnValueEvent::operator=(const AliRsnValueEvent ©)
{
//
// Assignment operator.
// Works like copy constructor.
//
- AliRsnValue::operator=(copy);
- if (this == ©)
- return *this;
- fType = copy.fType;
-
- return (*this);
+ AliRsnValue::operator=(copy);
+ if (this == ©)
+ return *this;
+ fType = copy.fType;
+
+ return (*this);
}
//_____________________________________________________________________________
-const char* AliRsnValueEvent::GetTypeName() const
+const char *AliRsnValueEvent::GetTypeName() const
{
//
// This method returns a string to give a name to each possible
// In this implementation, fills the member 4-vectors with data
// coming from the object passed as argument, and then returns the value
//
-
- // coherence check, which also casts object
+
+ // coherence check, which also casts object
// to AliRsnTarget data members and returns kFALSE
// in case the object is NULL
if (!TargetOK(object)) return kFALSE;
AliWarning("NULL ref");
return kFALSE;
}
-
+
// declare support variables
AliCentrality *centrality = fEvent->GetRef()->GetCentrality();
-
+
// compute value depending on types in the enumeration
// if the type does not match any available choice, or if
// the computation is not doable due to any problem
case kMultMC:
fComputedValue = -999.0;
if (fEvent->GetRefMC()) {
- if (fEvent->IsESD())
+ if (fEvent->IsESD())
fComputedValue = (Double_t)fEvent->GetRefMC()->GetNumberOfTracks();
else {
- AliAODEvent *aod = (AliAODEvent*)fEvent->GetRefMC();
- TClonesArray *mcArray = (TClonesArray*)aod->GetList()->FindObject(AliAODMCParticle::StdBranchName());
+ AliAODEvent *aod = (AliAODEvent *)fEvent->GetRefMC();
+ TClonesArray *mcArray = (TClonesArray *)aod->GetList()->FindObject(AliAODMCParticle::StdBranchName());
if (mcArray) fComputedValue = (Double_t)mcArray->GetEntries();
}
}
return kFALSE;
}
return (fComputedValue >= 0);
- case kLeadingPt:
+ case kLeadingPt:
if (fEvent->GetLeadingIndex() >= 0) {
AliRsnDaughter leadingPart;
fEvent->SetLeadingParticle(leadingPart);
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
+
////////////////////////////////////////////////////////////////////////////////
//
// Values which depend on 4-momentum of the pair.
kCentralityV0, // event centrality (V0 method)
kCentralityTrack, // event centrality (tracks method)
kCentralityCL1, // event centrality (CL1 method)
- kTypes
+ kTypes
};
AliRsnValueEvent(const char *name = "valEvent", EType type = kTypes);
- AliRsnValueEvent(const AliRsnValueEvent& copy);
- AliRsnValueEvent& operator=(const AliRsnValueEvent& copy);
+ AliRsnValueEvent(const AliRsnValueEvent ©);
+ AliRsnValueEvent &operator=(const AliRsnValueEvent ©);
virtual ~AliRsnValueEvent() { }
void SetType(EType type) {fType = type;}
EType GetType() const {return fType;}
- const char* GetTypeName() const;
+ const char *GetTypeName() const;
virtual Bool_t Eval(TObject *object);
}
//_____________________________________________________________________________
-AliRsnValuePair::AliRsnValuePair(const AliRsnValuePair& copy) :
+AliRsnValuePair::AliRsnValuePair(const AliRsnValuePair ©) :
AliRsnValue(copy),
fType(copy.fType)
{
}
//_____________________________________________________________________________
-AliRsnValuePair& AliRsnValuePair::operator=(const AliRsnValuePair& copy)
+AliRsnValuePair &AliRsnValuePair::operator=(const AliRsnValuePair ©)
{
//
// Assignment operator.
AliRsnValue::operator=(copy);
if (this == ©)
- return *this;
+ return *this;
fType = copy.fType;
return (*this);
}
//_____________________________________________________________________________
-const char* AliRsnValuePair::GetTypeName() const
+const char *AliRsnValuePair::GetTypeName() const
{
//
// This method returns a string to give a name to each possible
// coming from the object passed as argument, and then returns the value
//
- // coherence check, which also casts object
+ // coherence check, which also casts object
// to AliRsnTarget data members and returns kFALSE
// in case the object is NULL
if (!TargetOK(object)) return kFALSE;
-
+
// set a reference to the mother momentum
TLorentzVector &sum = fMother->Sum(fUseMCInfo);
TLorentzVector &ref = fMother->Ref(fUseMCInfo);
TLorentzVector &p1 = fMother->GetDaughter(0)->P(fUseMCInfo);
TLorentzVector &p2 = fMother->GetDaughter(1)->P(fUseMCInfo);
-
+
// utility variables
Bool_t success;
-
+
// compute value depending on types in the enumeration
// if the type does not match any available choice, or if
// the computation is not doable due to any problem
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
+
////////////////////////////////////////////////////////////////////////////////
//
// Values which depend on 4-momentum of the pair.
};
AliRsnValuePair(const char *name = "valPair", EType type = kTypes);
- AliRsnValuePair(const AliRsnValuePair& copy);
- AliRsnValuePair& operator=(const AliRsnValuePair& copy);
+ AliRsnValuePair(const AliRsnValuePair ©);
+ AliRsnValuePair &operator=(const AliRsnValuePair ©);
virtual ~AliRsnValuePair() { }
void SetType(EType type) {fType = type;}
EType GetType() const {return fType;}
- const char* GetTypeName() const;
+ const char *GetTypeName() const;
virtual Bool_t Eval(TObject *object);
public:
AliRsnVariableExpression(TString a) : AliRsnExpression() { fVname = a; };
~AliRsnVariableExpression() {}
- virtual Bool_t Value(TObjArray& pgm);
+ virtual Bool_t Value(TObjArray &pgm);
virtual TString Unparse() const { return fVname; }
ClassDef(AliRsnVariableExpression, 1); // Class to define a variable expression
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff