From: pulvir Date: Thu, 18 Sep 2008 06:44:43 +0000 (+0000) Subject: Package revised - New AnalysisTask's - Added more functions X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=commitdiff_plain;h=aec0ec32a633e38b7d531ea77860e12c35039ec7 Package revised - New AnalysisTask's - Added more functions --- diff --git a/PWG2/RESONANCES/AliRsnAnalysisSE.cxx b/PWG2/RESONANCES/AliRsnAnalysisSE.cxx new file mode 100644 index 00000000000..776fee03756 --- /dev/null +++ b/PWG2/RESONANCES/AliRsnAnalysisSE.cxx @@ -0,0 +1,197 @@ +// +// Class AliRsnAnalysisSE +// +// TODO +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// + +#include +#include +#include + +#include "AliLog.h" + +#include "AliAnalysisManager.h" +#include "AliRsnPairMgr.h" +#include "AliRsnEventBuffer.h" + +#include "AliMCEventHandler.h" +#include "AliESDEvent.h" + +#include "AliRsnAnalysisSE.h" + +ClassImp(AliRsnAnalysisSE) + +//________________________________________________________________________ +AliRsnAnalysisSE::AliRsnAnalysisSE(const char * name) + : AliRsnAnalysisTaskSEBase(name), + fPairMgrs(0),fOutList(0x0),fRsnEventBuffer(0x0), + fNumOfEventsInBuffer(1000) +{ +//========================================================= +// Default constructor +//========================================================= + + InitIOVars(); + DefineOutput(1, TList::Class()); +} + +//________________________________________________________________________ +AliRsnAnalysisSE::~AliRsnAnalysisSE() +{ +//========================================================= +// Destructor +//========================================================= +} + +//________________________________________________________________________ +void AliRsnAnalysisSE::InitIOVars() +{ +//========================================================= +// Init input output values +//========================================================= + + AliDebug(AliLog::kDebug, "<-"); + AliRsnAnalysisTaskSEBase::InitIOVars(); + + fRsnEventBuffer = 0; + fOutList = 0; + + AliDebug(AliLog::kDebug, "->"); +} + +//________________________________________________________________________ +void AliRsnAnalysisSE::UserCreateOutputObjects() +{ +//========================================================= +// UserCreateOutputObjects() of AliAnalysisTaskSE +//========================================================= + + AliDebug(AliLog::kDebug, "<-"); +// fPID.DumpPriors(); + OpenFile ( 0 ); + fOutList = new TList(); + fOutList->SetOwner(); + AliRsnPair *def=0; + AliRsnPairMgr *mgr=0; + TList *listTmp; + for (Int_t iMgr=0 ;iMgr< fPairMgrs.GetEntries();iMgr++) + { + mgr = (AliRsnPairMgr *) fPairMgrs.At(iMgr); + if (!mgr) continue; + listTmp = new TList(); + listTmp->SetName(mgr->GetName()); + for (Int_t i=0;i< mgr->GetPairs()->GetEntriesFast();i++) + { + def = (AliRsnPair *) mgr->GetPairs()->At(i); + if (def) + { + def->Init(); + //listTmp->Add(def->GenerateHistograms(mgr->GetName())); + def->GenerateHistograms(mgr->GetName(), listTmp); + //def->Print(); + } + } + fOutList->Add(listTmp); + } + + fRsnEventBuffer = new AliRsnEventBuffer(100); +// fRsnEventBuffer = new AliRsnEventBuffer ( 10000 ,kFALSE ); + AliDebug(AliLog::kDebug, "->"); + +} + +//________________________________________________________________________ +void AliRsnAnalysisSE::UserExec(Option_t *) +{ +//========================================================= +// UserExec() of AliAnalysisTaskSE +//========================================================= + + if (fEntry++%1000==0) + AliInfo(Form("Event %d",-1)); + + AliRsnEvent *curEvent = GetRsnEventFromInputType(); + if (!curEvent) return; + + ProcessEventAnalysis(curEvent); + PostEventProcess(); + + PostData(1, fOutList); +} + +//________________________________________________________________________ +void AliRsnAnalysisSE::Terminate(Option_t *) +{ +//========================================================= +// Terminate() of AliAnalysisTask +//========================================================= + + fOutList = dynamic_cast(GetOutputData(1)); + if (!fOutList) { AliError(" fOutList not available"); return; } + fOutList->Print(); +} + +//________________________________________________________________________ +void AliRsnAnalysisSE::ProcessEventAnalysis(AliRsnEvent *curEvent) +{ +//========================================================= +// Process of one event +//========================================================= + + + // Adds event to Event Buffer + fRsnEventBuffer->AddEvent(curEvent); + + // loop over all Pair managers + AliRsnPairMgr *mgr=0; + for (Int_t iMgr=0 ;iMgr< fPairMgrs.GetEntries();iMgr++) + { + mgr = (AliRsnPairMgr *) fPairMgrs.At(iMgr); + AliRsnPair *pair=0; + for (Int_t i=0;i< mgr->GetPairs()->GetEntriesFast();i++) + { + pair = (AliRsnPair *) mgr->GetPairs()->At(i); + pair->ProcessPair(fRsnEventBuffer); + } + } +} + +//________________________________________________________________________ +void AliRsnAnalysisSE::PostEventProcess(const Short_t & index) +{ +//========================================================= +// Post process of one event +//========================================================= + + switch (fInputType[index]) + { + case kAOD: + break; + case kESD: + break; + case kESDMC: + break; + case kMC: + break; + case kRSN: + { + if (fRsnEventBuffer->GetDeleteBufferWhenReset() == kFALSE) + { + fRSN[index] = (AliRsnEvent*) fRsnEventBuffer->GetNextEvent(); + SetBranchAddress(0 , "rsnEvents", &fRSN[index]); + } + break; + } + default: + break; + } + +} + +void AliRsnAnalysisSE::AddPairMgr(AliRsnPairMgr * pairmgr) +{ + fPairMgrs.Add(pairmgr); +} diff --git a/PWG2/RESONANCES/AliRsnAnalysisSE.h b/PWG2/RESONANCES/AliRsnAnalysisSE.h new file mode 100644 index 00000000000..d143c6ec754 --- /dev/null +++ b/PWG2/RESONANCES/AliRsnAnalysisSE.h @@ -0,0 +1,56 @@ +// +// Class AliRsnAnalysisSE +// +// TODO +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// +#ifndef ALIRSNANALYSISAT_H +#define ALIRSNANALYSISAT_H + +#include + +#include "AliRsnEventBuffer.h" +#include "AliRsnPair.h" +#include "AliRsnAnalysisTaskSEBase.h" + +class AliRsnEvent; + +class AliRsnAnalysisSE : public AliRsnAnalysisTaskSEBase +{ + public: + AliRsnAnalysisSE(const char *name = "AliRsnAnalysisSE"); + AliRsnAnalysisSE(const AliRsnAnalysisSE& copy): AliRsnAnalysisTaskSEBase(copy), + fPairMgrs(0),fOutList(0x0),fRsnEventBuffer(0x0),fNumOfEventsInBuffer(100) {} + AliRsnAnalysisSE& operator= (const AliRsnAnalysisSE&) {return *this;} + ~AliRsnAnalysisSE(); + + virtual void InitIOVars(); +// virtual void LocalInit(); +// virtual Bool_t Notify(); + virtual void UserCreateOutputObjects(); + virtual void UserExec(Option_t *option); + virtual void Terminate(Option_t *); + + void AddPairMgr(AliRsnPairMgr*pairmgr); + + void SetNumOfEventsInBuffer(const Int_t& theValue) { fNumOfEventsInBuffer = theValue; } + Int_t GetNumOfEventsInBuffer() const { return fNumOfEventsInBuffer; } + + + private: + + TObjArray fPairMgrs; + + TList *fOutList; // List of output + AliRsnEventBuffer *fRsnEventBuffer; // event buffer + Int_t fNumOfEventsInBuffer; // number of events in buffer + + void ProcessEventAnalysis(AliRsnEvent *curEvent); + void PostEventProcess(const Short_t &index=0); + + ClassDef(AliRsnAnalysisSE, 1) +}; + +#endif diff --git a/PWG2/RESONANCES/AliRsnAnalysisTask2ndStep.cxx b/PWG2/RESONANCES/AliRsnAnalysisTask2ndStep.cxx new file mode 100644 index 00000000000..6d23584fa42 --- /dev/null +++ b/PWG2/RESONANCES/AliRsnAnalysisTask2ndStep.cxx @@ -0,0 +1,177 @@ +// +// Class AliRsnAnalysisTask2ndStep +// +// TODO +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// +#include +#include +#include +#include +#include + +#include "AliLog.h" + +#include "AliAODEvent.h" +#include "AliAODInputHandler.h" +#include "AliAnalysisManager.h" +#include "AliAnalysisTaskSE.h" + +#include "AliRsnEvent.h" +#include "AliRsnPair.h" +#include "AliRsnPairMgr.h" + +#include "AliRsnAnalysisTask2ndStep.h" + +ClassImp(AliRsnAnalysisTask2ndStep) + +//_____________________________________________________________________________ +AliRsnAnalysisTask2ndStep::AliRsnAnalysisTask2ndStep(const char *name) : + AliAnalysisTaskSE(name), + fOutList(0x0), + fPairMgrs(0x0), + fEventBuffer(0x0), + fRsnHandlerAOD(0x0), + fAnalysisMgr(0x0) +{ +// +// Default constructor +// + + DefineOutput(1, TList::Class()); +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTask2ndStep::CreateHandlers(AliAnalysisManager* am) +{ +// +// Sets the handlers. +// + + fAnalysisMgr = am; + if (!fAnalysisMgr) { + AliWarning("Passed a NULL AnalysisManager!"); + return; + } + + // this task is made only for building histograms from + // a set of RSN events saved as non-standard branches in AOD tree + fRsnHandlerAOD = new AliAODInputHandler(); + if (fRsnHandlerAOD) fAnalysisMgr->SetInputEventHandler(fRsnHandlerAOD); +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTask2ndStep::UserCreateOutputObjects() +{ +// +// Creates output objects, as a TList of all histograms +// + AliInfo("--->"); + + //OpenFile (1); + if (fOutList) { + fOutList->Clear(); + delete fOutList; + } + fOutList = new TList(); + fOutList->SetOwner(); + AliRsnPairMgr *pairMgr = 0x0; + AliRsnPair *pair = 0x0; + + if (!fPairMgrs) { + AliError("No pair managers defined!"); + return; + } + + TObjArrayIter next(fPairMgrs); + while ( (pairMgr = (AliRsnPairMgr*)next()) ) { + TList *listTmp = new TList(); + listTmp->SetName(pairMgr->GetName()); + TObjArrayIter nextPair(pairMgr->GetPairs()); + while ( (pair = (AliRsnPair*)nextPair()) ) { + pair->Init(); + //pair->Print(); + pair->GenerateHistograms(pairMgr->GetName(), listTmp); + //listTmp->Add(pair->GenerateHistograms(pairMgr->GetName())); + //fOutList->Add(listTmp); + } + fOutList->Add(listTmp); + } + fEventBuffer = new AliRsnEventBuffer(1000); + + AliInfo("<---"); +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTask2ndStep::UserExec(Option_t *) +{ +// +// Executes the task +// + + if (fEntry++ % 1000 == 0) AliInfo(Form("Event %d",-1)); + + // retrieve AOD + AliAODEvent *aod = dynamic_cast(fInputEvent); + + // find RSN event + AliRsnEvent *rsn = (AliRsnEvent*)(aod->GetList()->FindObject("rsnEvents")); + + // execute analysis + ProcessEventAnalysis(rsn); + PostEventProcess(); + + PostData(1, fOutList); +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTask2ndStep::Terminate(Option_t *) +{ +// +// A simple check on the output list +// + + fOutList = dynamic_cast(GetOutputData(1)); + if (!fOutList) { AliError("--- Output list not available ---"); return; } + fOutList->Print(); +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTask2ndStep::ProcessEventAnalysis(AliRsnEvent *curEvent) +{ +// +// Process of one event +// + + // Adds event to Event Buffer + fEventBuffer->AddEvent(curEvent); + + // loop over all Pair managers + AliRsnPair *pair = 0; + AliRsnPairMgr *mgr = 0; + TObjArrayIter nextMgr(fPairMgrs); + while ( (mgr = (AliRsnPairMgr*)nextMgr()) ) { + TObjArrayIter nextPair(mgr->GetPairs()); + while ( (pair = (AliRsnPair*)nextPair()) ) { + pair->ProcessPair(fEventBuffer); + } + } +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTask2ndStep::PostEventProcess() +{ +// +// Some work done after event processing +// + +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTask2ndStep::AddPairMgr(AliRsnPairMgr *pairmgr) +{ + if (!fPairMgrs) fPairMgrs = new TObjArray; + fPairMgrs->Add(pairmgr); +} diff --git a/PWG2/RESONANCES/AliRsnAnalysisTask2ndStep.h b/PWG2/RESONANCES/AliRsnAnalysisTask2ndStep.h new file mode 100644 index 00000000000..f21720be65c --- /dev/null +++ b/PWG2/RESONANCES/AliRsnAnalysisTask2ndStep.h @@ -0,0 +1,60 @@ +// +// Class AliRsnAnalysisTask2ndStep +// +// AnalysisTask which collects an input of RSN events +// and produces histograms. +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// +#ifndef ALIRSNANALYSISTASK2NDSTEP_H +#define ALIRSNANALYSISTASK2NDSTEP_H + +#include "AliRsnDaughter.h" +#include "AliAnalysisTaskSE.h" + +class TObjArray; + +class AliAODEvent; +class AliAODInputHandler; +class AliAnalysisManager; + +class AliRsnEvent; +class AliRsnEventBuffer; +class AliRsnPairMgr; + +class AliRsnAnalysisTask2ndStep : public AliAnalysisTaskSE +{ + public: + AliRsnAnalysisTask2ndStep(const char *name = "AliRsnAnalysisTask2ndStep"); + virtual ~AliRsnAnalysisTask2ndStep() {/* Does nothing*/} + + virtual void UserCreateOutputObjects(); + virtual void UserExec(Option_t *option); + virtual void Terminate(Option_t *option); + + void AddPairMgr(AliRsnPairMgr *pairmgr); + void CreateHandlers(AliAnalysisManager *am); + void SetAnalysisMgr(AliAnalysisManager* theValue) { fAnalysisMgr = theValue; } + AliAnalysisManager* GetAnalysisMgr() const { return fAnalysisMgr; } + void ProcessEventAnalysis(AliRsnEvent *curEvent); + void PostEventProcess(); + + private: + + AliRsnAnalysisTask2ndStep(const AliRsnAnalysisTask2ndStep& copy) : + AliAnalysisTaskSE(copy),fOutList(0x0),fPairMgrs(0x0),fEventBuffer(0x0), + fRsnHandlerAOD(0x0),fAnalysisMgr(0x0) {} + AliRsnAnalysisTask2ndStep& operator= (const AliRsnAnalysisTask2ndStep&) {return *this;} + + TList *fOutList; // list of output histograms + TObjArray *fPairMgrs; // array if pair managers used + AliRsnEventBuffer *fEventBuffer; // event buffer + + AliAODInputHandler *fRsnHandlerAOD; // AOD event handler + AliAnalysisManager *fAnalysisMgr; // pointer to current AnalysisMgr + + ClassDef(AliRsnAnalysisTask2ndStep, 1) +}; + +#endif diff --git a/PWG2/RESONANCES/AliRsnAnalysisTaskSEBase.cxx b/PWG2/RESONANCES/AliRsnAnalysisTaskSEBase.cxx new file mode 100644 index 00000000000..0cf9c748314 --- /dev/null +++ b/PWG2/RESONANCES/AliRsnAnalysisTaskSEBase.cxx @@ -0,0 +1,411 @@ +// +// Class AliRsnAnalysisTaskSEBase +// +// TODO +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// +#include +#include +#include + +#include "AliLog.h" + +#include "AliAnalysisManager.h" +#include "AliAnalysisTaskSE.h" + +#include "AliESDEvent.h" +#include "AliAODEvent.h" +#include "AliRsnEvent.h" +#include "AliMCEvent.h" + +#include "AliRsnAnalysisTaskSEBase.h" + + +ClassImp(AliRsnAnalysisTaskSEBase) + +//_____________________________________________________________________________ +AliRsnAnalysisTaskSEBase::AliRsnAnalysisTaskSEBase(const char *name) : + AliAnalysisTaskSE(name), + fUseAutoHandler(kTRUE), + fReader(), + fPID(), + fAnalysisMgr(0x0) // pointer to current AnalysisMgr +{ +// +// Default constructor +// + InitIOVars(); + DefineInput(0, TChain::Class()); +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTaskSEBase::InitIOVars() +{ +// +// Initial values for constructor +// + + fUseAutoHandler = kFALSE; + + Int_t i; + for (i = 0; i < 2; i++) { + fChain[i] = 0; + fRSN[i] = 0; + fRsnESD[i] = 0; + fRsnMC[i] = 0; + fRsnAOD[i] = 0; + fRsnESDEH[i] = 0; + fRsnMCEH[i] = 0; + fRsnAODEH[i] = 0; + fInputType[i] = kRSN; + } + + fAnalysisMgr = 0; +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTaskSEBase::LocalInit() +{ +// +// LocalInit() +// + AliAnalysisTaskSE::LocalInit(); +} + +//_____________________________________________________________________________ +Bool_t AliRsnAnalysisTaskSEBase::Notify() +{ +// +// Notify() +// + + return AliAnalysisTaskSE::Notify(); +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTaskSEBase::SetInputType +(EInputType type, AliAnalysisManager* am, Bool_t autohandler, Short_t inputIndex) +{ +// +// Sets input type. +// When autohandler is kTRUE handlers are created and connected +// to the passed AliAnalysisManager if it exists. +// The internal AliAnalysisManager object is redirected to the passed one. +// + + fInputType[inputIndex] = type; + fAnalysisMgr = am; + + UseAutoHandler(autohandler); + if (!fUseAutoHandler) return; + + if (!fAnalysisMgr) { + AliWarning(Form("fAnalysisMgr is %p and fUseAutoHandler is %d", fAnalysisMgr, fUseAutoHandler)); + return; + } + + switch (fInputType[inputIndex]) { + case kAOD: + fRsnAODEH[0] = new AliAODInputHandler(); + if (fRsnAODEH[0]) fAnalysisMgr->SetInputEventHandler(fRsnAODEH[0]); + break; + case kESD: + fRsnESDEH[0] = new AliESDInputHandler(); + if (fRsnESDEH[0]) fAnalysisMgr->SetInputEventHandler(fRsnESDEH[0]); + break; + case kESDMC: + fRsnESDEH[0] = new AliESDInputHandler(); + fRsnMCEH[0] = new AliMCEventHandler(); + if ((fRsnESDEH[0]) && (fRsnMCEH[0])) { + fAnalysisMgr->SetInputEventHandler(fRsnESDEH[0]); + fAnalysisMgr->SetMCtruthEventHandler(fRsnMCEH[0]); + } + break; + case kMC: + fRsnMCEH[0] = new AliMCEventHandler(); + if (fRsnMCEH[0]) { + fAnalysisMgr->SetMCtruthEventHandler(fRsnMCEH[0]); + } + break; + case kRSN: + AliError("Not Implemented Yet ..."); + break; + default: + AliError("Type not supported ..."); + break; + } +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTaskSEBase::ConnectInputData(Option_t *) +{ +// +// ConnectInputData() for AliAnalysisTaskSE +// just define myTask->SetInputType ( AliRsnAnalysisTaskSEBase::kRSN ); for Rsn input +// just define myTask->SetInputType ( AliRsnAnalysisTaskSEBase::kESDMC ); for ESD and MC input +// just define myTask->SetInputType ( AliRsnAnalysisTaskSEBase::kAOD ); for Rsn input +// + + if (fInputType[0] != kRSN) AliAnalysisTaskSE::ConnectInputData(); + + // connects input handlers according to the type of analysis being done + ConnectInputDataByInputType(fInputType[0], 0); +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTaskSEBase::ConnectInputDataByInputType +(EInputType type, Short_t inputIndex) +{ +// +// Connect input data dependint on the input type used. +// + AliDebug(AliLog::kDebug, "<-"); + + switch (type) + { + case kAOD: + ConnectAOD(inputIndex); + break; + case kESD: + ConnectESD(inputIndex); + break; + case kESDMC: + ConnectESDMC(inputIndex); + break; + case kMC: + ConnectESDMC(inputIndex); + break; + case kRSN: + ConnectRSN(inputIndex); + break; + default: + AliError("Type not supported ..."); + break; + } + + AliDebug(AliLog::kDebug, "->"); +} +//_____________________________________________________________________________ +void AliRsnAnalysisTaskSEBase::ConnectRSN(Short_t inputIndex) +{ +// +// Connect input data by RSN input type +// + + AliDebug(AliLog::kDebug, "<-"); + + char ** address = (char **) GetBranchAddress(inputIndex, "rsnEvents"); + if (address) + { + fRSN[inputIndex] = (AliRsnEvent*)(*address); + } + else + { + fRSN[inputIndex] = 0; + SetBranchAddress(inputIndex, "rsnEvents", &fRSN[inputIndex]); + } + + AliDebug(AliLog::kDebug, "->"); +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTaskSEBase::ConnectESD(Short_t inputIndex) +{ +// +// Connect input data by ESD input type +// + + AliDebug(AliLog::kDebug, "<-"); + fRsnESD[inputIndex] = (AliESDEvent*)fInputEvent; + AliDebug(AliLog::kDebug, "->"); + +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTaskSEBase::ConnectESDMC(Short_t inputIndex) +{ +// +// Connect input data by ESDMC input type +// + + AliDebug(AliLog::kDebug, "<-"); + fRsnESD[inputIndex] = (AliESDEvent*)fInputEvent; + //fRSNMC[inputIndex] = fMCEvent; + AliDebug(AliLog::kDebug, "->"); +} + +//_____________________________________________________________________________ +void AliRsnAnalysisTaskSEBase::ConnectAOD(Short_t inputIndex) +{ +// +// Connect input data by AOD input type +// + + AliDebug(AliLog::kDebug, "<-"); + + TTree* tree = dynamic_cast(GetInputData(inputIndex)); + if (!tree) { AliError("Could not read chain from input slot 0");} + else + { + AliAODInputHandler *aodH = dynamic_cast(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if (!aodH) { AliError("Could not get AODInputHandler"); } + else fRsnAOD[inputIndex] = aodH->GetEvent(); + } + + AliDebug(AliLog::kDebug, "->"); +} + +//_____________________________________________________________________________ +AliRsnEvent * AliRsnAnalysisTaskSEBase::GetRsnEventFromInputType(const Short_t & index) +{ +// +// Gets Event from input type +// + + switch (fInputType[index]) + { + case kAOD: return GetRsnFromAOD(index); + case kESD: return GetRsnFromESD(index); + case kESDMC: return GetRsnFromESDMC(index); + case kMC: return GetRsnFromMC(index); + case kRSN: return GetRsnFromRSN(index); + default: + AliError("Type not supported ..."); + return (AliRsnEvent*) 0x0; + } + + return (AliRsnEvent*) 0x0; +} + +//_____________________________________________________________________________ +AliRsnEvent * AliRsnAnalysisTaskSEBase::GetRsnFromAOD(const Short_t & index) +{ +// +// Gets RSN event from AOD +// + + if (!fRsnAOD[index]) + { + AliError("fRsnAOD not available."); + return (AliRsnEvent *) 0x0; + } + + if (!fRSN[0]) + { + fRSN[0] = new AliRsnEvent(); + fRSN[0]->SetName("rsnEvents"); + fRSN[0]->Init(); + } + + // clear pevious event + fRSN[0]->Clear(); + if (!fReader.FillFromAOD(fRSN[0], fRsnAOD[index])) return (AliRsnEvent*) 0x0; + if (!fPID.Process(fRSN[0])) AliWarning("Failed PID"); + + return (AliRsnEvent*) fRSN[0]; +} + +//_____________________________________________________________________________ +AliRsnEvent * AliRsnAnalysisTaskSEBase::GetRsnFromESD(const Short_t & index) +{ +// +// Gets RSN event from ESD +// + + if (!fRsnESD[index]) + { + AliError("fRsnESD not available."); + return (AliRsnEvent *) 0x0; + } + + if (!fRSN[index]) + { + fRSN[index] = new AliRsnEvent(); + fRSN[index]->SetName("rsnEvents"); + fRSN[index]->Init(); + } + + // clear pevious event + fRSN[index]->Clear(); + + if (!fReader.FillFromESD(fRSN[index], fRsnESD[index])) return (AliRsnEvent*) 0x0; + + if (!fPID.Process(fRSN[index])) + { + AliWarning("Failed PID"); + return (AliRsnEvent*) 0x0; + } + + return fRSN[index]; +} + +//_____________________________________________________________________________ +AliRsnEvent * AliRsnAnalysisTaskSEBase::GetRsnFromMC(const Short_t & index) +{ +// +// Gets RSN event from ESD +// + + if (!fRSN[index]) + { + fRSN[index] = new AliRsnEvent(); + fRSN[index]->SetName("rsnEvents"); + fRSN[index]->Init(); + } + + // clear pevious event + fRSN[index]->Clear(); + fRsnMC[index] = MCEvent(); + + if (!fReader.FillFromMC(fRSN[index], fRsnMC[index])) return (AliRsnEvent*) 0x0; + fRSN[index]->FillPIDArrays(); + return fRSN[index]; +} + +//_____________________________________________________________________________ +AliRsnEvent * AliRsnAnalysisTaskSEBase::GetRsnFromESDMC(const Short_t & index) +{ +// +// Gets RSN event from ESD and MC +// + + if (!fRsnESD[index]) + { + AliError("fRsnESD not available."); + return (AliRsnEvent *) 0x0; + } + + if (!fRSN[index]) + { + fRSN[index] = new AliRsnEvent(); + fRSN[index]->SetName("rsnEvents"); + fRSN[index]->Init(); + } + + // clear pevious event + fRSN[index]->Clear(); + fRsnMC[index] = MCEvent(); + + if (!fRsnMC[index]) return (AliRsnEvent *) 0x0; + if (!fReader.FillFromESD(fRSN[index], fRsnESD[index], fRsnMC[index])) return (AliRsnEvent*) 0x0; + if (!fPID.Process(fRSN[index])) + { + AliWarning("Failed PID"); + return (AliRsnEvent*) 0x0; + } + + return fRSN[index]; +} + +//_____________________________________________________________________________ +AliRsnEvent * AliRsnAnalysisTaskSEBase::GetRsnFromRSN(const Short_t & index) +{ +// +// Gets RSN event from RSN +// not fully implemented yet +// + AliRsnEvent *event = fRSN[index]; + return event; +} diff --git a/PWG2/RESONANCES/AliRsnAnalysisTaskSEBase.h b/PWG2/RESONANCES/AliRsnAnalysisTaskSEBase.h new file mode 100644 index 00000000000..63893567a0b --- /dev/null +++ b/PWG2/RESONANCES/AliRsnAnalysisTaskSEBase.h @@ -0,0 +1,110 @@ +// +// Class AliRsnAnalysisTaskSEBase +// +// TODO +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// +#ifndef ALIRSNANALYSISTASKSEBASE_H +#define ALIRSNANALYSISTASKSEBASE_H + +#include + +#include "AliAnalysisTaskSE.h" +#include "AliRsnReader.h" + +class AliAnalysisManager; +class AliESDEvent; +class AliAODEvent; +class AliRsnEvent; +class AliMCEvent; + +#include "AliESDInputHandler.h" +#include "AliMCEventHandler.h" +#include "AliAODInputHandler.h" + +class AliRsnAnalysisTaskSEBase : public AliAnalysisTaskSE +{ + public: + AliRsnAnalysisTaskSEBase(const char *name = "AliRsnAnalysisTaskSEBase"); + AliRsnAnalysisTaskSEBase(const AliRsnAnalysisTaskSEBase& copy) : + AliAnalysisTaskSE(copy),fUseAutoHandler(kFALSE),fReader(),fPID(),fAnalysisMgr(0x0) {} + AliRsnAnalysisTaskSEBase& operator= (const AliRsnAnalysisTaskSEBase& /*copy*/) {return *this;} + virtual ~AliRsnAnalysisTaskSEBase() {/* Does nothing*/} + + enum EInputType + { + kAOD = 0, + kESD, + kESDMC, + kMC, + kRSN, + kLastIndex + }; + + virtual void InitIOVars(); + virtual void LocalInit(); + virtual Bool_t Notify(); + virtual void ConnectInputData(Option_t *); + // Implementation of interface methods + virtual void UserCreateOutputObjects() {;}; + virtual void UserExec(Option_t*) {;}; + virtual void Terminate(Option_t*) {;}; + + void SetInputType(EInputType type, AliAnalysisManager* am, Bool_t autohandler = kFALSE, Short_t inputIndex = 0); + EInputType GetInputType(Short_t inputIndex = 0) { return fInputType[inputIndex]; } + + TChain* GetChain(const Int_t& index = 0) const { return fChain[index]; } + + AliRsnEvent *GetRSNEvent(Int_t index = 0) { return fRSN[index]; } + + void SetAnalysisMgr(AliAnalysisManager* theValue) { fAnalysisMgr = theValue; } + AliAnalysisManager* GetAnalysisMgr() const { return fAnalysisMgr; } + + AliESDInputHandler* GetESDHandler(const Int_t& theValue = 0) const { return fRsnESDEH[theValue]; } + AliMCEventHandler* GetMCHandler(const Int_t& theValue = 0) const { return fRsnMCEH[theValue]; } + AliAODInputHandler* GetAODHandler(const Int_t& theValue = 0) const { return fRsnAODEH[theValue]; } + + AliRsnReader *GetReader() { return &fReader; } + AliRsnPID *GetPID() { return &fPID;} + + protected: + + TChain *fChain[2]; // input chain + EInputType fInputType[2]; // input type + Bool_t fUseAutoHandler; // flag if should create handler + + AliRsnEvent *fRSN[2]; // RSN (internal format) event + AliESDEvent *fRsnESD[2]; // ESD event + AliMCEvent *fRsnMC[2]; // ESD event + AliAODEvent *fRsnAOD[2]; // AOD event + + AliESDInputHandler *fRsnESDEH[2]; // ESD event handler + AliMCEventHandler *fRsnMCEH[2]; // ESD event handler + AliAODInputHandler *fRsnAODEH[2]; // AOD event handler + + AliRsnReader fReader; // Reader + AliRsnPID fPID; // PID + + AliAnalysisManager *fAnalysisMgr; // pointer to current AnalysisMgr + + virtual void UseAutoHandler(const Bool_t& theValue) {fUseAutoHandler = theValue;} + + virtual void ConnectInputDataByInputType(EInputType type ,Short_t inputIndex=0); + virtual void ConnectRSN(Short_t inputIndex); + virtual void ConnectESD(Short_t inputIndex); + virtual void ConnectESDMC(Short_t inputIndex); + virtual void ConnectAOD(Short_t inputIndex); + + virtual AliRsnEvent* GetRsnEventFromInputType(const Short_t &index=0); + virtual AliRsnEvent* GetRsnFromAOD(const Short_t &index=0); + virtual AliRsnEvent* GetRsnFromESD(const Short_t &index=0); + virtual AliRsnEvent* GetRsnFromESDMC(const Short_t &index=0); + virtual AliRsnEvent* GetRsnFromRSN(const Short_t &index=0); + virtual AliRsnEvent* GetRsnFromMC(const Short_t &index=0); + + ClassDef(AliRsnAnalysisTaskSEBase, 1) +}; + +#endif diff --git a/PWG2/RESONANCES/AliRsnBaseAT.cxx b/PWG2/RESONANCES/AliRsnBaseAT.cxx new file mode 100644 index 00000000000..10f13e6ff9f --- /dev/null +++ b/PWG2/RESONANCES/AliRsnBaseAT.cxx @@ -0,0 +1,478 @@ +// +// Class AliRsnBaseAT +// +// TODO +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// +#include +#include +#include + +#include "AliLog.h" + +#include "AliAnalysisManager.h" +#include "AliAnalysisTask.h" + +#include "AliESDEvent.h" +#include "AliAODEvent.h" +#include "AliRsnEvent.h" +#include "AliMCEvent.h" + +#include "AliRsnBaseAT.h" + + +ClassImp(AliRsnBaseAT) + +//________________________________________________________________________ +AliRsnBaseAT::AliRsnBaseAT(const char *name) + : AliAnalysisTask(name, ""), + fNumOfEvents(100), + fUseAutoHandler(100), + fRsnInput(), + fReader(), + fPID(), + fAnalysisMgr(0x0) +{ +//========================================================= +// Default constructor +//========================================================= + InitIOVars(); + DefineInput(0, TChain::Class()); +// DefineInput ( 1, AliRsnReader::Class() ); +// DefineInput ( 2, AliRsnPID::Class() ); +} + +//________________________________________________________________________ +void AliRsnBaseAT::InitIOVars() +{ +//========================================================= +// Initial values for constructor +//========================================================= + AliDebug(AliLog::kDebug, "<-"); + + fNumOfEvents=0; + fUseAutoHandler = kFALSE; + for (Int_t i=0;i<2;i++) + { + fChain[i] = 0; + fRSN[i] = 0; + fESD[i] = 0; + fMC[i] = 0; + fAOD[i] = 0; + fESDEH[i] = 0; + fMCEH[i] = 0; + fAODEH[i] = 0; + fInputType[i] = kRSN; + } + + fAnalysisMgr=0; + + AliDebug(AliLog::kDebug, "->"); +} + +//________________________________________________________________________ +void AliRsnBaseAT::LocalInit() +{ +//========================================================= +// LocalInit() +//========================================================= +} + +//________________________________________________________________________ +Bool_t AliRsnBaseAT::Notify() +{ +//========================================================= +// Notify() +//========================================================= + + return AliAnalysisTask::Notify(); +} + +//________________________________________________________________________ +void AliRsnBaseAT::SetInputType(EInputType type,AliAnalysisManager* am,Bool_t autohandler, Short_t inputIndex) +{ +//========================================================= +// Sets input type. +// When autohandler is kTRUE handlers are created and sets +// to AliAnalysisManager (fAnalysisMgr) if exists +//========================================================= + + AliDebug(AliLog::kDebug, "<-"); + + fInputType[inputIndex] = type; + fAnalysisMgr = am; + + UseAutoHandler(autohandler); + + if (!fUseAutoHandler) return; + + if (!fAnalysisMgr) + { + AliWarning(Form("fAnalysisMgr is %p and fUseAutoHandler is %d",fAnalysisMgr,fUseAutoHandler)); + return; + } + + switch (fInputType[inputIndex]) + { + case kAOD: + { + if (fAnalysisMgr) + { + fAODEH[0] = new AliAODInputHandler(); + if (fAODEH[0]) + fAnalysisMgr->SetInputEventHandler(fAODEH[0]); + } + break; + } + case kESD: + { + if (fAnalysisMgr) + { + fESDEH[0] = new AliESDInputHandler(); + if (fESDEH[0]) + fAnalysisMgr->SetInputEventHandler(fESDEH[0]); + } + + break; + } + case kESDMC: + { + if (fAnalysisMgr) + { + fESDEH[0] = new AliESDInputHandler(); + fMCEH[0] = new AliMCEventHandler(); + if ((fESDEH[0]) && (fMCEH[0])) + { + fAnalysisMgr->SetInputEventHandler(fESDEH[0]); + fAnalysisMgr->SetMCtruthEventHandler(fMCEH[0]); + } + } + break; + } + case kMC: + AliError("Not Implemented Yet ..."); + break; + case kRSN: + { + AliError("Not Implemented Yet ..."); + break; + } + default: + AliError("Type not supported ..."); + break; + } + AliDebug(AliLog::kDebug, "->"); +} + +//________________________________________________________________________ +void AliRsnBaseAT::ConnectInputData(Option_t *) +{ +//========================================================= +// ConectInputData() for AliAnalysisTask +// just define myTask->SetInputType ( AliRsnBaseAT::kRSN ); for Rsn input +// just define myTask->SetInputType ( AliRsnBaseAT::kESDMC ); for ESD and MC input +// just define myTask->SetInputType ( AliRsnBaseAT::kAOD ); for Rsn input +//========================================================= + + ConnectInputDataByInputType(fInputType[0],0); +} + +void AliRsnBaseAT::ConnectInputDataByInputType(EInputType type ,Short_t inputIndex) +{ +//========================================================= +// Connect input data by input type +//========================================================= + + AliDebug(AliLog::kDebug, "<-"); + + switch (type) + { + case kAOD: + { + ConnectAOD(inputIndex); + break; + } + case kESD: + { + ConnectESD(inputIndex); + break; + } + case kESDMC: + { + ConnectESDMC(inputIndex); + break; + } + case kMC: + AliError("Not Implemented Yet ..."); + break; + case kRSN: + { + ConnectRSN(inputIndex); + break; + } + default: + AliError("Type not supported ..."); + break; + } + AliDebug(AliLog::kDebug, "->"); +} +//________________________________________________________________________ +void AliRsnBaseAT::ConnectRSN(Short_t inputIndex) +{ +//========================================================= +// Connect input data by RSN input type +//========================================================= + + AliDebug(AliLog::kDebug, "<-"); + char ** address = (char **) GetBranchAddress(inputIndex, "rsnEvents"); + if (address) + { + fRSN[inputIndex] = (AliRsnEvent*)(*address); + } + else + { + fRSN[inputIndex] = 0; + SetBranchAddress(inputIndex, "rsnEvents", &fRSN[inputIndex]); + } + AliDebug(AliLog::kDebug, "->"); +} + +void AliRsnBaseAT::ConnectESD(Short_t inputIndex) +{ +//========================================================= +// Connect input data by ESD input type +//========================================================= + + AliDebug(AliLog::kDebug, "<-"); + + TTree* tree = dynamic_cast(GetInputData(inputIndex)); + if (!tree) { AliError("Could not read chain from input slot 0"); } + else + { + // Disable all branches, we want to process only MC + tree->SetBranchStatus("*", kFALSE); + tree->SetBranchStatus("fTracks.*", kTRUE); + + AliESDInputHandler *esdH = dynamic_cast(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + + if (!esdH) { AliError("Could not get ESDInputHandler"); } + else + fESD[inputIndex] = esdH->GetEvent(); + } + AliDebug(AliLog::kDebug, "->"); + +} +//________________________________________________________________________ +void AliRsnBaseAT::ConnectESDMC(Short_t inputIndex) +{ +//========================================================= +// Connect input data by ESDMC input type +//========================================================= + + AliDebug(AliLog::kDebug, "<-"); + + + TTree* tree = dynamic_cast(GetInputData(inputIndex)); + if (!tree) { AliError("Could not read chain from input slot 0"); } + else + { + // Disable all branches, we want to process only MC + tree->SetBranchStatus("*", kFALSE); + tree->SetBranchStatus("fTracks.*", kTRUE); + + AliESDInputHandler *esdH = dynamic_cast(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + + if (!esdH) { AliError("Could not get ESDInputHandler"); } + else + fESD[inputIndex] = esdH->GetEvent(); + } + AliDebug(AliLog::kDebug, "->"); + +} +//________________________________________________________________________ +void AliRsnBaseAT::ConnectAOD(Short_t inputIndex) +{ +//========================================================= +// Connect input data by AOD input type +//========================================================= + + AliDebug(AliLog::kDebug, "<-"); + + TTree* tree = dynamic_cast(GetInputData(inputIndex)); + if (!tree) { AliError("Could not read chain from input slot 0");} + else + { + AliAODInputHandler *aodH = dynamic_cast(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + + if (!aodH) { AliError("Could not get AODInputHandler"); } + else + { + fAOD[inputIndex] = aodH->GetEvent(); + } + } + AliDebug(AliLog::kDebug, "->"); +} + +//________________________________________________________________________ +AliRsnEvent * AliRsnBaseAT::GetRsnEventFromInputType(const Short_t & index) +{ +//========================================================= +// Gets Evetn from input type +//========================================================= + + switch (fInputType[index]) + { + case kAOD: + { + return GetRsnFromAOD(index); + break; + } + case kESD: + { + AliWarning("Not Implemented Yet ..."); + return GetRsnFromESD(index); + break; + } + case kESDMC: + { + return GetRsnFromESDMC(index); + break; + } + case kMC: + AliWarning("Not Implemented Yet ..."); + return (AliRsnEvent*) 0x0; + break; + case kRSN: + { + return GetRsnFromRSN(index); + break; + } + default: + AliError("Type not supported ..."); + return (AliRsnEvent*) 0x0; + break; + } + return (AliRsnEvent*) 0x0; +} + + + +//________________________________________________________________________ +AliRsnEvent * AliRsnBaseAT::GetRsnFromAOD(const Short_t & index) +{ +//========================================================= +// Gets RSN event from AOD +//========================================================= + + if (!fAOD[index]) { AliError("fAOD not available."); return (AliRsnEvent *) 0x0; } + + if (!fRSN[0]) + { + fRSN[0] = new AliRsnEvent(); + fRSN[0]->SetName("rsnEvents"); + fRSN[0]->Init(); + } + // clear pevious event + fRSN[0]->Clear(); + + if (!fReader.Fill(fRSN[0], (AliVEvent*) fAOD[index])) + { + return (AliRsnEvent*) 0x0; + }; + + if (!fPID.Process(fRSN[0])) AliWarning("Failed PID"); + + return (AliRsnEvent*) fRSN[0]; + +} +//________________________________________________________________________ +AliRsnEvent * AliRsnBaseAT::GetRsnFromESD(const Short_t & index) +{ +//========================================================= +// Gets RSN event from ESD +//========================================================= + + if (!fESD[index]) { AliError("fESD not available."); return (AliRsnEvent *) 0x0; } + + if (!fRSN[index]) + { + fRSN[index] = new AliRsnEvent(); + fRSN[index]->SetName("rsnEvents"); + fRSN[index]->Init(); + } + // clear pevious event + fRSN[index]->Clear(); + + if (!fReader.Fill(fRSN[index], (AliVEvent*) fESD[index])) + { + return (AliRsnEvent*) 0x0; + }; + + if (!fPID.Process(fRSN[index])) AliWarning("Failed PID"); + + return fRSN[index]; +} +//________________________________________________________________________ +AliRsnEvent * AliRsnBaseAT::GetRsnFromESDMC(const Short_t & index) +{ +//========================================================= +// Gets RSN event from ESD and MC +//========================================================= + + if (!fESD[index]) { AliError("fESD not available."); return (AliRsnEvent *) 0x0; } + AliMCEventHandler* mcHandler = dynamic_cast(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); + if (!mcHandler) { AliError("Could not retrieve MC event handler"); return (AliRsnEvent *) 0x0; } + + if (!fRSN[index]) + { + fRSN[index] = new AliRsnEvent(); + fRSN[index]->SetName("rsnEvents"); + fRSN[index]->Init(); + } + // clear pevious event + fRSN[index]->Clear(); + + fMC[index] = mcHandler->MCEvent(); + + if (!fMC[index]) return (AliRsnEvent *) 0x0; + + if (!fReader.Fill(fRSN[index], (AliVEvent*) fESD[index],fMC[index])) + { + return (AliRsnEvent*) 0x0; + }; + + if (!fPID.Process(fRSN[index])) + { + AliWarning("Failed PID"); + return (AliRsnEvent*) 0x0; + } + + return fRSN[index]; +} +//________________________________________________________________________ +AliRsnEvent * AliRsnBaseAT::GetRsnFromRSN(const Short_t & index) +{ +//========================================================= +// Gets RSN event from RSN +// not fully implemented yet +//========================================================= + + AliRsnEvent *event = fRSN[index]; +// if ( fRsnEventBuffer->GetDeleteBufferWhenReset() == kTRUE ) +// { +// event = ( AliRsnEvent * ) fRSN[index]->Clone(); +// } +// AliInfo ( Form ( "%p %p",event,fRSN[index] ) ); + return event; +} + +//________________________________________________________________________ +void AliRsnBaseAT::UseAutoHandler(const Bool_t & theValue) +{ +//========================================================= +// Sets should create handlers +//========================================================= + fUseAutoHandler = theValue; +} diff --git a/PWG2/RESONANCES/AliRsnBaseAT.h b/PWG2/RESONANCES/AliRsnBaseAT.h new file mode 100644 index 00000000000..afac444094c --- /dev/null +++ b/PWG2/RESONANCES/AliRsnBaseAT.h @@ -0,0 +1,115 @@ +// +// Class AliRsnBaseAT +// +// TODO +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// +#ifndef ALIRSNBASEAT_H +#define ALIRSNBASEAT_H + +#include + +#include "AliAnalysisTask.h" +#include "AliRsnReader.h" + +class AliAnalysisManager; +class AliESDEvent; +class AliAODEvent; +class AliRsnEvent; +class AliMCEvent; + +#include "AliESDInputHandler.h" +#include "AliMCEventHandler.h" +#include "AliAODInputHandler.h" + + +class AliRsnBaseAT : public AliAnalysisTask +{ + public: + AliRsnBaseAT(const char *name = "AliRsnBaseAT"); + AliRsnBaseAT(const AliRsnBaseAT& copy):AliAnalysisTask(copy), + fNumOfEvents(0),fUseAutoHandler(kTRUE), + fRsnInput(1),fReader(),fPID(),fAnalysisMgr(0x0) {} + AliRsnBaseAT& operator= (const AliRsnBaseAT&) {return *this;} + virtual ~AliRsnBaseAT() {/* Does nothing*/} + + enum EInputType + { + kAOD = 0, + kESD, + kESDMC, + kMC, + kRSN, + kLastIndex + }; + + virtual void InitIOVars(); + virtual void LocalInit(); + virtual Bool_t Notify(); + virtual void ConnectInputData(Option_t *); + virtual void CreateOutputObjects() {;} + virtual void Exec(Option_t *) {;} + virtual void Terminate(Option_t *) {;} + + void SetInputType(EInputType type,AliAnalysisManager* am,Bool_t autohandler=kFALSE, Short_t inputIndex=0); + EInputType GetInputType(Short_t inputIndex=0) { return fInputType[inputIndex]; } + + TChain* GetChain(const Int_t& index = 0) const { return fChain[index]; } + + AliRsnEvent *GetRSNEvent(Int_t index=0) { return fRSN[index]; } + + void SetAnalysisMgr(AliAnalysisManager* theValue) { fAnalysisMgr = theValue; } + AliAnalysisManager* GetAnalysisMgr() const { return fAnalysisMgr; } + + AliESDInputHandler* GetESDHandler(const Int_t& theValue=0) const { return fESDEH[theValue]; } + AliMCEventHandler* GetMCHandler(const Int_t& theValue=0) const { return fMCEH[theValue]; } + AliAODInputHandler* GetAODHandler(const Int_t& theValue=0) const { return fAODEH[theValue]; } + + AliRsnReader *GetReader() { return &fReader; } + AliRsnPID *GetPID() { return &fPID;} + + protected: + + Long64_t fNumOfEvents; // number of events + + TChain *fChain[2]; // input chain + EInputType fInputType[2]; // input type + Bool_t fUseAutoHandler; // flag if should create handler + + AliRsnEvent *fRSN[2]; // RsnMV event + AliESDEvent *fESD[2]; // ESD event + AliMCEvent *fMC[2]; // ESD event + AliAODEvent *fAOD[2]; // AOD event + + AliESDInputHandler *fESDEH[2]; // ESD event handler + AliMCEventHandler *fMCEH[2]; // ESD event handler + AliAODInputHandler *fAODEH[2]; // AOD event handler + + + TObjArray fRsnInput; // array of rsn input (reader,pid,...) + AliRsnReader fReader; // Reader + AliRsnPID fPID; // PID + + AliAnalysisManager *fAnalysisMgr; // pointer to current AnalysisMgr + + virtual void UseAutoHandler(const Bool_t& theValue); + + virtual void ConnectInputDataByInputType(EInputType type ,Short_t inputIndex=0); + virtual void ConnectRSN(Short_t inputIndex); + virtual void ConnectESD(Short_t inputIndex); + virtual void ConnectESDMC(Short_t inputIndex); + virtual void ConnectAOD(Short_t inputIndex); + + virtual AliRsnEvent* GetRsnEventFromInputType(const Short_t &index=0); + virtual AliRsnEvent* GetRsnFromAOD(const Short_t &index=0); + virtual AliRsnEvent* GetRsnFromESD(const Short_t &index=0); + virtual AliRsnEvent* GetRsnFromESDMC(const Short_t &index=0); + virtual AliRsnEvent* GetRsnFromRSN(const Short_t &index=0); + + + ClassDef(AliRsnBaseAT, 1) +}; + +#endif diff --git a/PWG2/RESONANCES/AliRsnComparisonAT.cxx b/PWG2/RESONANCES/AliRsnComparisonAT.cxx new file mode 100644 index 00000000000..99e5c702a7a --- /dev/null +++ b/PWG2/RESONANCES/AliRsnComparisonAT.cxx @@ -0,0 +1,297 @@ +// +// Class AliRsnComparisonAT +// +// TODO +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// +#include "TChain.h" +#include "TTree.h" +#include "TH1F.h" +#include "TFolder.h" +#include "TCanvas.h" +#include "TClonesArray.h" + +#include "AliLog.h" + +#include "AliESDtrack.h" +#include "AliMCEvent.h" + +#include "AliRsnMCInfo.h" +#include "AliRsnComparisonObj.h" +#include "AliRsnComparisonAT.h" + +ClassImp(AliRsnComparisonAT) + +//________________________________________________________________________ +AliRsnComparisonAT::AliRsnComparisonAT(const char*name) + : AliRsnBaseAT(name),fOutList(0x0),fMyInputNum(1),fMyPIDInputNum(0) +{ +//========================================================= +// Default constructor +//========================================================= + + InitIOVars(); + + DefineOutput(0, TList::Class()); +} + +//________________________________________________________________________ +void AliRsnComparisonAT::InitIOVars() +{ +//========================================================= +// Sets default values for input and output +//========================================================= + AliDebug(AliLog::kDebug, "<-"); + AliRsnBaseAT::InitIOVars(); + fOutList = 0; + AliDebug(AliLog::kDebug, "->"); +} + +//________________________________________________________________________ +void AliRsnComparisonAT::LocalInit() +{ +//========================================================= +// Local init +//========================================================= +} + +//________________________________________________________________________ +void AliRsnComparisonAT::CreateOutputObjects() +{ +//========================================================= +// CreateOutputObjects() +//========================================================= + AliDebug(AliLog::kDebug, "<-"); + +// AliRsnDaughter::SetPIDMethod ( AliRsnDaughter::kRealistic ); +// fReader = dynamic_cast ( GetInputData ( 1 ) ); +// fPID = dynamic_cast ( GetInputData ( 2 ) ); + + + OpenFile(0); + fOutList = new TList(); + AliRsnComparisonObj* obj; + + TList *listMainParticle,*listMainPID,*listPID,*listParticle,*listTmp; + + listMainParticle = new TList(); + listMainParticle->SetName("MCParticles"); + for (Int_t i=0;iGenerateParticleInfoHistogramList(""); + if (!listParticle) + { + AliError(Form("List not crated for i=%d",i)); + continue; + } + + listMainParticle->Add(listParticle); + } + fOutList->Add(listMainParticle); + if (fMyPIDInputNum>0) + { + listMainPID = new TList(); + listMainPID->SetName("PID"); + for (Int_t j=0;jSetName(fMyPIDInput[j].GetName()); + for (Int_t i=0;iGeneratePIDHistogramList(fMyPIDInput[j].GetName()); + if (!listTmp) + { + AliError(Form("List not crated for i=%d",i)); + continue; + } + listPID->Add(listTmp); + + } + listMainPID->Add(listPID); + } + fOutList->Add(listMainPID); +// listMainPID->Print(); + } + AliDebug(AliLog::kDebug, "->"); +} + +//________________________________________________________________________ +void AliRsnComparisonAT::Exec(Option_t *) +{ +//========================================================= +// Exec() +//========================================================= + + if (fInputType[0]==kESDMC) + { + fRSN[0] = GetRsnEventFromInputType(0); + LoopOverESDtracks(); + LoopOverMCtracks(); + } + + + if (!fRSN[0]) return; + LoopOverRSNDaughters(); + + if (fInputType[0]==kESDMC) + { + delete fRSN[0]; + fRSN[0] = 0; + } + +// fNumEventsProcessed++; + PostData(0, fOutList); +} + +//________________________________________________________________________ +void AliRsnComparisonAT::Terminate(Option_t *) +{ +//========================================================= +// Terminate() +//========================================================= + AliDebug(AliLog::kDebug, "<-"); + fOutList = dynamic_cast(GetOutputData(0)); + if (!fOutList) + { + AliError(" fOutList not available"); + return; + } + + AliDebug(AliLog::kDebug, "->"); +} + +//________________________________________________________________________ +void AliRsnComparisonAT::LoopOverESDtracks() +{ +//========================================================= +// Loop over all ESD tracks +//========================================================= + if (!fESD[0]) return; +// AliInfo(Form("%d",fESD[0]->GetNumberOfTracks())); + AliRsnComparisonObj* input=0; + for (Int_t i=0;i< fESD[0]->GetNumberOfTracks(); i++) + { + AliESDtrack *esdtrack = fESD[0]->GetTrack(i); + for (Int_t j=0;jFillPIDHistograms(esdtrack, fMC[0]); + } + } + for (Int_t j=0;jFillPIDHistograms(esdtrack, fMC[0]); + } + } + } +} + +//________________________________________________________________________ +void AliRsnComparisonAT::LoopOverMCtracks() +{ +//========================================================= +// Loop over all MC tracks +//========================================================= + + if (!fMC[0]) return; + + AliRsnComparisonObj* input=0; + AliMCParticle *mctrack; + for (Int_t i=0;iGetNumberOfTracks(); i++) + { + mctrack = fMC[0]->GetTrack(i); + if (!mctrack) {AliInfo("mctrack == null");continue;} + for (Int_t j=0;jFillHistograms(mctrack); + } + } + for (Int_t j=0;jFillPIDHistograms(mctrack); + } + } + } +} + +//________________________________________________________________________ +void AliRsnComparisonAT::LoopOverRSNDaughters() +{ +//========================================================= +// Loop over all rsn daughters +//========================================================= + + TClonesArray *tracks = (TClonesArray*) fRSN[0]->GetTracks(); + AliRsnDaughter *daughter=0; + AliRsnComparisonObj* input=0; + for (Int_t i=0;i< tracks->GetEntriesFast(); i++) + { + daughter = (AliRsnDaughter*) tracks->At(i); + for (Int_t j=0;jFillPIDHistograms(daughter); + } + } + for (Int_t j=0;jFillPIDHistograms(daughter); + } + } + } +} + +//________________________________________________________________________ +void AliRsnComparisonAT::PrintStat() +{ +//========================================================= +// Print stat +//========================================================= + AliDebug(AliLog::kDebug, "<-"); + + AliDebug(AliLog::kDebug, "->"); +} + +void AliRsnComparisonAT::AddMyInput(AliRsnComparisonObj * obj, const Int_t & index) +{ +// if ( ( index<0 ) || ( index>kMyInputNum ) ) return; + + fMyInput[index].Add(obj); +// AliInfo(Form("%d %s",fMyInput[index].GetEntries(),fMyInput[index].GetName())); +} + +void AliRsnComparisonAT::AddMyPIDInput(AliRsnComparisonObj * obj, const Int_t & index) +{ +// if ( ( index<0 ) || ( index>kMyInputNum ) ) return; + + fMyPIDInput[index].Add(obj); +// AliInfo(Form("%d %s",fMyInput[index].GetEntries(),fMyInput[index].GetName())); +} + +void AliRsnComparisonAT::SetMyPIDInputName(TString name, const Int_t & index) +{ + fMyPIDInput[index].SetName(name.Data()); +} + diff --git a/PWG2/RESONANCES/AliRsnComparisonAT.h b/PWG2/RESONANCES/AliRsnComparisonAT.h new file mode 100644 index 00000000000..101c582b11b --- /dev/null +++ b/PWG2/RESONANCES/AliRsnComparisonAT.h @@ -0,0 +1,70 @@ +// +// Class AliRsnComparisonAT +// +// TODO +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// +#ifndef ALIRSNMVCOMPARISONAT_H +#define ALIRSNMVCOMPARISONAT_H + +#include "TObjArray.h" + +#include "AliRsnDaughter.h" +#include "AliRsnEvent.h" +#include "AliRsnBaseAT.h" +#include "AliRsnCut.h" +#include "AliRsnCutSet.h" + +class AliRsnComparisonAT : public AliRsnBaseAT +{ + public: + + enum + { + kMyInputNum=1, + kMyPIDInputNum=5 + }; + + AliRsnComparisonAT(const char*name="AliRsnComparisonAT"); + + virtual ~AliRsnComparisonAT() {} + + virtual void InitIOVars(); + virtual void LocalInit(); + virtual void CreateOutputObjects(); + virtual void Exec(Option_t *option); + virtual void Terminate(Option_t *); + + void LoopOverESDtracks(); + void LoopOverMCtracks(); + void LoopOverRSNDaughters(); + void PrintStat(); + + void AddMyInput(AliRsnComparisonObj *obj,const Int_t &index=0); + void AddMyPIDInput(AliRsnComparisonObj *obj,const Int_t &index=0); + void SetMyPIDInputName(TString name="default",const Int_t &index=0); + + void SetNumberOfPIDInputs(const Int_t& theValue) { fMyPIDInputNum = theValue; } + + + private: + + AliRsnComparisonAT(const AliRsnComparisonAT&) + : AliRsnBaseAT(""),fOutList(0x0),fMyInputNum(1),fMyPIDInputNum(0) {} + AliRsnComparisonAT& operator=(const AliRsnComparisonAT&) {return *this;} + + TList *fOutList; // output list + + Int_t fMyInputNum; + TObjArray fMyInput[kMyInputNum]; + Int_t fMyPIDInputNum; + TObjArray fMyPIDInput[kMyPIDInputNum]; + + + + ClassDef(AliRsnComparisonAT, 1) +}; + +#endif diff --git a/PWG2/RESONANCES/AliRsnComparisonObj.cxx b/PWG2/RESONANCES/AliRsnComparisonObj.cxx new file mode 100644 index 00000000000..ba6c593e11c --- /dev/null +++ b/PWG2/RESONANCES/AliRsnComparisonObj.cxx @@ -0,0 +1,407 @@ +// +// *** Class AliRsnComparisonObj *** +// +// TODO +// +// authors: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it) +// M. Vala (email: martin.vala@cern.ch) +// + +#include "AliLog.h" + +#include "AliRsnDaughter.h" +#include "AliRsnMCInfo.h" + +#include "AliRsnComparisonObj.h" + +ClassImp(AliRsnComparisonObj) + +//_____________________________________________________________________________ +AliRsnComparisonObj::AliRsnComparisonObj(const char *name) + : TNamed(name,name),fCurrentComparisonType(kParticleInfo),fCurrentESDPID(kEsd), + fESDstatus(0),fITSClusters(0),fTPCClusters(0),fTRDClusters(0),fPIDDivValue(0.) +{ +//========================================================= +// Default constructor +//========================================================= + TH1::SetDefaultSumw2(); + + for (Int_t i=0;iSetName(GetName()); + + TString varname("p"); + for (Int_t i=0;ikIndent)) continue; + + fHistosPID[i][j][k]= new TH1D(Form("%s_%s_%s_%s_%s_%s",prefix.Data(),GetName(),varname.Data(),AliRsnPID::ParticleName((AliRsnPID::EType) k),GetFormatName((EFormat) i).Data(),GetHistoTypeName((EHistoType) j).Data()),Form("%s %s %s %s %s",GetName(),varname.Data(),AliRsnPID::ParticleNameLatex((AliRsnPID::EType) k),GetFormatName((EFormat) i).Data(),GetHistoTypeName((EHistoType) j).Data()),1000,0,5); + list->Add(fHistosPID[i][j][k]); + } + + return list; +} + +TList * AliRsnComparisonObj::GenerateParticleInfoHistogramList(TString prefix) +{ + TList *list = new TList(); + list->SetName(GetName()); + TString charge; + if (!prefix.IsNull()) + prefix+="_"; + + Int_t bins[] = {1000,1000,1000,1000}; + Double_t min[] = {0.0,0.0,-10.0,-10.0}; + Double_t max[] = {5.0,5.0,10.0,10.0}; + + for (Int_t i=0;i0) && (k>AliRsnPID::kSpecies-1)) continue; + charge = (j>0) ? "-":"+"; + AliInfo(Form("%s%s %d%d",AliRsnPID::ParticleName((AliRsnPID::EType) k),charge.Data(),j,k)); +// if (k>AliRsnPID::kSpecies-1) charge=""; + fHistosPartInfo[i][j][k]= new TH1D(Form("%s%s%s_%s",prefix.Data(),AliRsnPID::ParticleName((AliRsnPID::EType) k),charge.Data(),GetParameterName((EParameterType) i).Data()),Form("%s%s %s",AliRsnPID::ParticleNameLatex((AliRsnPID::EType) k),charge.Data(),GetParameterName((EParameterType) i).Data()),bins[i],min[i],max[i]); + list->Add(fHistosPartInfo[i][j][k]); + } + return list; +} + +//________________________________________________________________________ +void AliRsnComparisonObj::FillPIDHistograms(AliRsnDaughter * daughter) +{ +//========================================================= +// Fill Histograms with AliRsnDaughter info +//========================================================= + + if (!(daughter->CheckFlag(fESDstatus))) return; + + daughter->AssignRealisticPID(); + + Double_t prob; + Double_t p = daughter->P(); + Int_t indexType = (Int_t) daughter->PIDType(prob); + Int_t pdg = daughter->GetMCInfo()->PDG(); + Int_t indexTypeFromPDG = (Int_t) AliRsnPID::InternalType(pdg); + + fHistosPID[kRSN][kIndent][indexType]->Fill(p); + fHistosPID[kRSN][kTrue][indexTypeFromPDG]->Fill(p); + + if (indexType == indexTypeFromPDG) + fHistosPID[kRSN][kGood][indexType]->Fill(p); + else + fHistosPID[kRSN][kFake][indexType]->Fill(p); +} + +//________________________________________________________________________ +void AliRsnComparisonObj::FillPIDHistograms(AliESDtrack * track,AliMCEvent *mc) +{ +//========================================================= +// Fill Histograms with AliRsnDaughter info +//========================================================= + + if (fITSClusters>0) + if (track->GetITSclusters(0) < fITSClusters) return; + + if (fTPCClusters>0) + if (track->GetTPCclusters(0) < fTPCClusters) return; + + if (fTRDClusters>0) + if (track->GetTRDclusters(0) < fTRDClusters) return; + + ULong_t status = track->GetStatus(); + if (!((fESDstatus & status) == fESDstatus)) return; + + Int_t label = track->GetLabel(); + AliMCParticle *mctrack = mc->GetTrack(TMath::Abs(label)); + + Double_t p = track->P(); + Int_t pdg =0; + Int_t indexTypeFromPDG = AliRsnPID::kUnknown; + if (mctrack) + { + pdg = mctrack->Particle()->GetPdgCode(); + indexTypeFromPDG = (Int_t) AliRsnPID::InternalType(pdg); + } + Double_t pid[5]; + GetESDPID(track,pid,p); + + + if (fCurrentESDPID == kITS_TPC_TOF_SP) + if (p>0.7) + if (!track->IsOn(AliESDtrack::kTOFpid)) return; + + Int_t i; + Double_t sum = 0.0, prob[AliRsnPID::kSpecies]; + for (i = 0; i < AliRsnPID::kSpecies; i++) + { + prob[i] = fPriorProbs[i] * pid[i]; + sum += prob[i]; + } + + if (sum <= (Double_t) 0.0) + { + AliError(Form("Sum of weights = %f <= 0", sum)); + return; + } + + + // normalize + for (i = 0; i < AliRsnPID::kSpecies; i++) + { + prob[i] /= sum; + } + + Int_t indexType = 0; + Double_t pmax = prob[0]; + for (i = 1; i < AliRsnPID::kSpecies; i++) + { + if (prob[i] > pmax) + { + indexType = i; + pmax = prob[i]; + } + } + + fHistosPID[kESD][kIndent][indexType]->Fill(p); + fHistosPID[kESD][kTrue][indexTypeFromPDG]->Fill(p); + + if (indexType == indexTypeFromPDG) + fHistosPID[kESD][kGood][indexType]->Fill(p); + else + fHistosPID[kESD][kFake][indexType]->Fill(p); + +} + +//________________________________________________________________________ +void AliRsnComparisonObj::FillPIDHistograms(AliMCParticle * mctrack) +{ +//========================================================= +// Fill Histograms with mctrack info +//========================================================= + + if (!mctrack) { AliError("mctrack is null"); return;} + + Double_t p = mctrack->P(); + Int_t pdg = mctrack->Particle()->GetPdgCode(); + Int_t indexTypeFromPDG = (Int_t) AliRsnPID::InternalType(pdg); + if (indexTypeFromPDG < AliRsnPID::kSpecies) + fHistosPID[kMC][kIndent][indexTypeFromPDG]->Fill(p); +} + +void AliRsnComparisonObj::FillHistograms(AliMCParticle * mctrack) +{ + Int_t charge; + if (!mctrack) { AliError("mctrack is null"); return;} + + Int_t pdg = mctrack->Particle()->GetPdgCode(); +// if (pdg>0) charge=0; + charge = (pdg>0) ? 0 : 1; +// if (TMath::Abs(pdg) == 333 ) AliInfo(Form("%d",charge)); + if (pdg == 11) charge = 1; + if (pdg == -11) charge = 0; + + Int_t indexTypeFromPDG = (Int_t) AliRsnPID::InternalType(pdg); + for (Int_t i=0;iFill(GetParameterNameValue((EParameterType)i,mctrack)); +} + +//________________________________________________________________________ +TString AliRsnComparisonObj::GetFormatName(EFormat type) +{ +//========================================================= +// returns Format Name +//========================================================= + switch (type) + { + case kRSN : + return "RSN"; + break; + case kESD : + return "ESD"; + break; + case kMC : + return "MC"; + break; + default: + AliWarning("Unrecognized value of EOutputType argument"); + break; + } + return ""; +} + +//________________________________________________________________________ +TString AliRsnComparisonObj::GetHistoTypeName(EHistoType type) +{ +//========================================================= +// returns Histo Type Name +//========================================================= + switch (type) + { + case kIndent : + return "Ident"; + case kGood : + return "Good"; + case kFake : + return "Fake"; + case kTrue : + return "True"; + default: + AliWarning("Unrecognized value of EHistoType argument"); + break; + } + return "XXX"; +} + +void AliRsnComparisonObj::GetESDPID(AliESDtrack *track,Double_t *pid,Double_t p) +{ + Double_t ctmp[AliRsnPID::kSpecies]; + switch (fCurrentESDPID) + { + case kEsd : + track->GetESDpid(pid); + break; + case kITS : + track->GetITSpid(pid); + break; + case kTPC : + track->GetTPCpid(pid); + break; + case kTOF : + track->GetTOFpid(pid); + break; + case kITS_TPC : + track->GetITSpid(pid); + track->GetTPCpid(ctmp); + for (Int_t i=0;i<5;i++) pid[i]*=ctmp[i]; + break; + case kITS_TOF : + track->GetITSpid(pid); + track->GetTOFpid(ctmp); + for (Int_t i=0;iGetTPCpid(pid); + track->GetTOFpid(ctmp); + for (Int_t i=0;iGetITSpid(pid); + track->GetTPCpid(ctmp); + for (Int_t i=0;iGetTOFpid(ctmp); + for (Int_t i=0;iGetITSpid(pid); + track->GetTPCpid(ctmp); + for (Int_t i=0;iGetTOFpid(pid); + } + break; + default: + AliWarning("Unrecognized value of EPIDType argument"); + for (Int_t i=0;iP(); + case kPt : + return mctrack->Pt(); + case kEta : + return mctrack->Eta(); + case kY : + return mctrack->Y(); + default: + break; + } + return -10000.0; +} + diff --git a/PWG2/RESONANCES/AliRsnComparisonObj.h b/PWG2/RESONANCES/AliRsnComparisonObj.h new file mode 100644 index 00000000000..b10b9fcf1c8 --- /dev/null +++ b/PWG2/RESONANCES/AliRsnComparisonObj.h @@ -0,0 +1,120 @@ +// +// *** Class AliRsnComparisonObj *** +// +// TODO +// +// authors: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it) +// M. Vala (email: martin.vala@cern.ch) +// + +#ifndef ALIRSNCOMPARISONOBJ_H +#define ALIRSNCOMPARISONOBJ_H + +#include +#include +#include + +#include "AliMCEvent.h" +#include "AliESDtrack.h" +#include "AliMCParticle.h" + +#include "AliRsnPID.h" + +class AliRsnComparisonObj : public TNamed +{ + public: + + enum EFormat + { + kRSN=0, + kESD, + kMC, + kLastFormat + }; + + enum EComparisonType + { + kParticleInfo=0, + kPid, + kLastComparisonType + }; + + enum EParameterType + { + kP = 0, + kPt, + kEta, + kY, + kLastParameterType + }; + + enum EHistoType + { + kIndent=0, + kGood, + kFake, + kTrue, + kLastHistoType + }; + + enum EPIDType + { + kEsd=0, + kITS, + kTPC, + kTOF, + kITS_TPC, + kITS_TOF, + kTPC_TOF, + kITS_TPC_TOF, + kITS_TPC_TOF_SP, + kLastPIDType + }; + + AliRsnComparisonObj(const char*name="RSN"); + ~AliRsnComparisonObj(); + + TList *GenerateParticleInfoHistogramList(TString prefix=""); + TList *GeneratePIDHistogramList(TString prefix=""); + void FillPIDHistograms(AliRsnDaughter *daughter); + void FillPIDHistograms(AliESDtrack *track,AliMCEvent *mc=0); + void FillPIDHistograms(AliMCParticle *mctrack); + + void FillHistograms(AliMCParticle *mctrack); + + void SetCurrentESDPID(const EPIDType& type,const Double_t&divValue = 0.0); + void SetPriorProbs(Double_t* pid) { for (Int_t i=0; i<5; i++) fPriorProbs[i]=pid[i]; } + + void SetESDstatus(const ULong_t status); + void SetESDTrackQualityCuts(const Int_t& its=-1,const Int_t& tpc=-1,const Int_t& trd=-1); + private: + + AliRsnComparisonObj(const AliRsnComparisonObj& copy) + : TNamed(copy),fCurrentComparisonType(kParticleInfo),fCurrentESDPID(kEsd), + fESDstatus(0),fITSClusters(0),fTPCClusters(0),fTRDClusters(0),fPIDDivValue(0.) {} + const AliRsnComparisonObj& operator=(const AliRsnComparisonObj&) {return *this;} + + EComparisonType fCurrentComparisonType; + EPIDType fCurrentESDPID; + Double_t fPriorProbs[5]; + ULong_t fESDstatus; + Int_t fITSClusters; + Int_t fTPCClusters; + Int_t fTRDClusters; + + Double_t fPIDDivValue; + + TH1D *fHistosPartInfo[kLastParameterType][2][AliRsnPID::kSpeciesAll]; + TH1D *fHistosPID[kLastFormat][kLastHistoType][AliRsnPID::kSpecies+1]; + + TString GetFormatName(EFormat type); + TString GetHistoTypeName(EHistoType type); + + void GetESDPID(AliESDtrack *track,Double_t *pid,Double_t p=-1.0); + TString GetParameterName(EParameterType type); + Double_t GetParameterNameValue(EParameterType type,AliMCParticle * mctrack); + + ClassDef(AliRsnComparisonObj, 1) +}; + +#endif diff --git a/PWG2/RESONANCES/AliRsnCut.cxx b/PWG2/RESONANCES/AliRsnCut.cxx index c038002d05f..277d45946cf 100644 --- a/PWG2/RESONANCES/AliRsnCut.cxx +++ b/PWG2/RESONANCES/AliRsnCut.cxx @@ -29,19 +29,21 @@ const Double_t AliRsnCut::fgkDSmallNumber = 1e-100; const Double_t AliRsnCut::fgkDBigNumber = 1e10; const Int_t AliRsnCut::fgkIBigNumber = 32767; -ClassImp (AliRsnCut) +ClassImp(AliRsnCut) //________________________________________________________________________________________________________________ AliRsnCut::AliRsnCut() : - TNamed(), - fDMin(-fgkDBigNumber), - fDMax( fgkDBigNumber), - fIMin(-fgkIBigNumber), - fIMax( fgkIBigNumber), - fUIMin(0), - fUIMax(2 * (UInt_t)fgkIBigNumber), - fType (kLastCutType), - fVarType (kDouble_t) + TNamed(), + fDMin(-fgkDBigNumber), + fDMax(fgkDBigNumber), + fIMin(-fgkIBigNumber), + fIMax(fgkIBigNumber), + fUIMin(0), + fUIMax(2 * (UInt_t) fgkIBigNumber), + fULMin(0), + fULMax(2 * (ULong_t) fgkIBigNumber), + fType(kLastCutType), + fVarType(kDouble_t) { // // Constructor @@ -49,16 +51,18 @@ AliRsnCut::AliRsnCut() : } //________________________________________________________________________________________________________________ -AliRsnCut::AliRsnCut (const char *name, const char *title, EType type) : - TNamed (name,title), - fDMin(-fgkDBigNumber), - fDMax( fgkDBigNumber), - fIMin(-fgkIBigNumber), - fIMax( fgkIBigNumber), - fUIMin(0), - fUIMax(2 * (UInt_t)fgkIBigNumber), - fType (type), - fVarType (kDouble_t) +AliRsnCut::AliRsnCut(const char *name, const char *title, EType type) : + TNamed(name,title), + fDMin(-fgkDBigNumber), + fDMax(fgkDBigNumber), + fIMin(-fgkIBigNumber), + fIMax(fgkIBigNumber), + fUIMin(0), + fUIMax(2 * (UInt_t) fgkIBigNumber), + fULMin(0), + fULMax(2 * (ULong_t) fgkIBigNumber), + fType(type), + fVarType(kDouble_t) { // // Constructor with arguments but not limits @@ -66,16 +70,18 @@ AliRsnCut::AliRsnCut (const char *name, const char *title, EType type) : } //________________________________________________________________________________________________________________ -AliRsnCut::AliRsnCut (const char *name, const char *title, EType type, Double_t min, Double_t max) : - TNamed (name,title), - fDMin(min), - fDMax(max), - fIMin(-fgkIBigNumber), - fIMax( fgkIBigNumber), - fUIMin(0), - fUIMax(2 * (UInt_t)fgkIBigNumber), - fType (type), - fVarType (kDouble_t) +AliRsnCut::AliRsnCut(const char *name, const char *title, EType type, Double_t min, Double_t max) : + TNamed(name,title), + fDMin(min), + fDMax(max), + fIMin(-fgkIBigNumber), + fIMax(fgkIBigNumber), + fUIMin(0), + fUIMax(2 * (UInt_t) fgkIBigNumber), + fULMin(min), + fULMax(max), + fType(type), + fVarType(kDouble_t) { // // Constructor with arguments and limits @@ -83,16 +89,18 @@ AliRsnCut::AliRsnCut (const char *name, const char *title, EType type, Double_t } //________________________________________________________________________________________________________________ -AliRsnCut::AliRsnCut (const char * name, const char * title, EType type, Int_t min, Int_t max) : - TNamed (name,title), - fDMin(-fgkDBigNumber), - fDMax( fgkDBigNumber), - fIMin(min), - fIMax(max), - fUIMin(0), - fUIMax(2 * (UInt_t)fgkIBigNumber), - fType (type), - fVarType (kInt_t) +AliRsnCut::AliRsnCut(const char * name, const char * title, EType type, Int_t min, Int_t max) : + TNamed(name,title), + fDMin(-fgkDBigNumber), + fDMax(fgkDBigNumber), + fIMin(min), + fIMax(max), + fUIMin(0), + fUIMax(2 * (UInt_t) fgkIBigNumber), + fULMin(min), + fULMax(max), + fType(type), + fVarType(kInt_t) { // // Constructor with arguments and limits @@ -100,16 +108,37 @@ AliRsnCut::AliRsnCut (const char * name, const char * title, EType type, Int_t m } //________________________________________________________________________________________________________________ -AliRsnCut::AliRsnCut (const char * name, const char * title, EType type, UInt_t min, UInt_t max) : - TNamed (name,title), - fDMin(-fgkDBigNumber), - fDMax( fgkDBigNumber), - fIMin(-fgkIBigNumber), - fIMax( fgkIBigNumber), - fUIMin(min), - fUIMax(max), - fType (type), - fVarType (kUInt_t) +AliRsnCut::AliRsnCut(const char * name, const char * title, EType type, UInt_t min, UInt_t max) : + TNamed(name,title), + fDMin(-fgkDBigNumber), + fDMax(fgkDBigNumber), + fIMin(-fgkIBigNumber), + fIMax(fgkIBigNumber), + fUIMin(min), + fUIMax(max), + fULMin(min), + fULMax(max), + fType(type), + fVarType(kUInt_t) +{ +// +// Constructor with arguments and limits +// +} + +//________________________________________________________________________________________________________________ +AliRsnCut::AliRsnCut(const char * name, const char * title, EType type, ULong_t min, ULong_t max) : + TNamed(name,title), + fDMin(-fgkDBigNumber), + fDMax(fgkDBigNumber), + fIMin(-fgkIBigNumber), + fIMax(fgkIBigNumber), + fUIMin(min), + fUIMax(max), + fULMin(min), + fULMax(max), + fType(type), + fVarType(kUInt_t) { // // Constructor with arguments and limits @@ -126,49 +155,59 @@ AliRsnCut::~AliRsnCut() } //________________________________________________________________________________________________________________ -Bool_t AliRsnCut::IsBetween (const Double_t &theValue) +Bool_t AliRsnCut::IsBetween(const Double_t &theValue) { // // Interval check. // Question: "Is the argument included between fDMin and fDMax?" // (not implemented for integer values because usually it is not used with them) // - return ((theValue >= fDMin) && (theValue <= fDMax)); + return ((theValue >= fDMin) && (theValue <= fDMax)); } //________________________________________________________________________________________________________________ -Bool_t AliRsnCut::IsBetween (const Int_t &theValue) +Bool_t AliRsnCut::IsBetween(const Int_t &theValue) { // // Interval check. // Question: "Is the argument included between fDMin and fDMax?" // (not implemented for integer values because usually it is not used with them) // - return ((theValue >= fIMin) && (theValue <= fIMax)); + return ((theValue >= fIMin) && (theValue <= fIMax)); } //________________________________________________________________________________________________________________ -Bool_t AliRsnCut::MatchesValue (const Int_t &theValue) +Bool_t AliRsnCut::MatchesValue(const Int_t &theValue) { // // Reference check. // Question: "Is the argument equal to fIMin?" (fIMax is assumed never used) // - return (theValue == fIMin); + return (theValue == fIMin); } //________________________________________________________________________________________________________________ -Bool_t AliRsnCut::MatchesValue (const UInt_t &theValue) +Bool_t AliRsnCut::MatchesValue(const UInt_t &theValue) { // // Reference check. // Question: "Is the argument equal to fUIMin?" (fUIMax is assumed never used) // - return (theValue == fUIMin); + return (theValue == fUIMin); +} + +//________________________________________________________________________________________________________________ +Bool_t AliRsnCut::MatchesValue(const ULong_t &theValue) +{ + // +// Reference check. +// Question: "Is the argument equal to fUIMin?" (fUIMax is assumed never used) + // + return (theValue == fULMin); } //________________________________________________________________________________________________________________ -Bool_t AliRsnCut::MatchesValue (const Double_t &theValue) +Bool_t AliRsnCut::MatchesValue(const Double_t &theValue) { // // Reference check. @@ -176,40 +215,51 @@ Bool_t AliRsnCut::MatchesValue (const Double_t &theValue) // Here, "reasonably close" means that the difference is smaller than the // 'fgkSmallNumber' global static data member of this class // - return (TMath::Abs (theValue - fDMin) < fgkDSmallNumber); + return (TMath::Abs(theValue - fDMin) < fgkDSmallNumber); } //________________________________________________________________________________________________________________ -void AliRsnCut::SetCutValues (EType type, const Double_t &theValue, const Double_t &theValue2) +void AliRsnCut::SetCutValues(EType type, const Double_t &theValue, const Double_t &theValue2) { // // (Re)assignment of cut values // - fType = type; - fDMin = theValue; - fDMax = theValue2; + fType = type; + fDMin = theValue; + fDMax = theValue2; } //________________________________________________________________________________________________________________ -void AliRsnCut::SetCutValues (EType type, const Int_t &theValue, const Int_t &theValue2) +void AliRsnCut::SetCutValues(EType type, const Int_t &theValue, const Int_t &theValue2) { // // (Re)assignment of cut values // - fType = type; - fIMin = theValue; - fIMax = theValue2; + fType = type; + fIMin = theValue; + fIMax = theValue2; } //________________________________________________________________________________________________________________ -void AliRsnCut::SetCutValues (EType type, const UInt_t &theValue, const UInt_t &theValue2) +void AliRsnCut::SetCutValues(EType type, const UInt_t &theValue, const UInt_t &theValue2) { // // (Re)assignment of cut values // - fType = type; - fUIMin = theValue; - fUIMax = theValue2; + fType = type; + fUIMin = theValue; + fUIMax = theValue2; +} + +//________________________________________________________________________________________________________________ +void AliRsnCut::SetCutValues(EType type, const ULong_t &theValue, const ULong_t &theValue2) +{ + // +// (Re)assignment of cut values + // + fType = type; + fULMin = theValue; + fULMax = theValue2; } //________________________________________________________________________________________________________________ @@ -223,128 +273,132 @@ Bool_t AliRsnCut::IsSelected(ETarget type, AliRsnDaughter *daughter) // (the ones for that type of object), otherwise kTRUE is returned in order // not to act as a cleaning factor for an AND with other cuts. // - AliDebug (AliLog::kDebug, "<-"); - AliRsnMCInfo *mcinfo = daughter->GetMCInfo(); - - // check type - if (type != kParticle) { - AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnDaughter)", type, kParticle, daughter->ClassName())); - return kTRUE; - } - - // utility variables - AliRsnPID::EType pidType; - Double_t prob; - - switch (fType) { - case kMomentum: - return IsBetween (daughter->P()); - case kTransMomentum: - return IsBetween (daughter->Pt()); - case kEta: - return IsBetween (daughter->Eta()); - case kRadialImpactParam: - return IsBetween (daughter->Dr()); - case kMomentumMC: - if (mcinfo) return IsBetween (mcinfo->P()); - else return kTRUE; - case kTransMomentumMC: - if (mcinfo) return IsBetween (mcinfo->P()); - else return kTRUE; - case kStatus: - return daughter->CheckFlag(fUIMin); - case kChargePos: - return (daughter->Charge() > 0); - case kChargeNeg: - return (daughter->Charge() < 0); - case kPIDType: - case kPIDProb: - pidType = daughter->PIDType(prob); - if (fType == kPIDType) return MatchesValue((Int_t)pidType); - if (fType == kPIDProb) return IsBetween(prob); - /* - case kEtaMC: - if (mcinfo) return IsBetween (mcinfo->Eta()); - else return kTRUE; - case kMcVt: - if (mcinfo) return IsBetween (mcinfo->Vt()); - else return kTRUE; - case kEsdNSigma: - return IsBetween (daughter->GetNSigma()); - case kEsdNSigmaCalculate: - return IsBetween (daughter->GetESDInfo()->GetNSigmaCalculate()); - */ - default: - AliWarning("Requested a cut which cannot be applied to a single track"); - return kTRUE; - } + AliDebug(AliLog::kDebug, "<-"); + AliRsnMCInfo *mcinfo = daughter->GetMCInfo(); + // check type + if (type != kParticle) + { + AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnDaughter)", type, kParticle, daughter->ClassName())); return kTRUE; + } + + // utility variables + AliRsnPID::EType pidType; + Double_t prob; + + switch (fType) + { + case kMomentum: + return IsBetween(daughter->P()); + case kTransMomentum: + return IsBetween(daughter->Pt()); + case kEta: + return IsBetween(daughter->Eta()); + case kRadialImpactParam: + return IsBetween(daughter->Dr()); + case kMomentumMC: + if (mcinfo) return IsBetween(mcinfo->P()); + else return kTRUE; + case kTransMomentumMC: + if (mcinfo) return IsBetween(mcinfo->P()); + else return kTRUE; + case kStatus: + return daughter->CheckFlag(fUIMin); + case kChargePos: + return (daughter->Charge() > 0); + case kChargeNeg: + return (daughter->Charge() < 0); + case kPIDType: + case kPIDProb: + pidType = daughter->PIDType(prob); + if (fType == kPIDType) return MatchesValue((Int_t) pidType); + if (fType == kPIDProb) return IsBetween(prob); + case kEtaMC: + if (mcinfo) return IsBetween(mcinfo->Eta()); + else return kTRUE; + /* + case kEsdNSigma: + return IsBetween (daughter->GetNSigma()); + case kEsdNSigmaCalculate: + return IsBetween (daughter->GetESDInfo()->GetNSigmaCalculate()); + */ + default: + AliWarning("Requested a cut which cannot be applied to a single track"); + return kTRUE; + } + + return kTRUE; } //________________________________________________________________________________________________________________ Bool_t AliRsnCut::IsSelected(ETarget type, AliRsnPairParticle * pair) { - AliDebug (AliLog::kDebug, "<-"); - - // check type - if (type != kPair) { - AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnPairParticle)", type, kPair, pair->ClassName())); - return kTRUE; - } - - switch (fType) { - case kMomentum: - return IsBetween (pair->GetP()); - case kTransMomentum: - return IsBetween (pair->GetPt()); - /* - case kEta: - return IsBetween (daughter->Eta()); - */ - case kMomentumMC: - return IsBetween (pair->GetPMC()); - case kTransMomentumMC: - return IsBetween (pair->GetPtMC()); - case kIsLabelEqual: - return pair->IsLabelEqual(); - case kIsTruePair: - return pair->IsTruePair(fIMin); - default: - AliWarning("Requested a cut which cannot be applied to a pair"); - return kTRUE; - } + AliDebug(AliLog::kDebug, "<-"); + // check type + if (type != kPair) + { + AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnPairParticle)", type, kPair, pair->ClassName())); return kTRUE; + } + + switch (fType) + { + case kMomentum: + return IsBetween(pair->GetP()); + case kTransMomentum: + return IsBetween(pair->GetPt()); + /* + case kEta: + return IsBetween (daughter->Eta()); + */ + case kMomentumMC: + return IsBetween(pair->GetPMC()); + case kTransMomentumMC: + return IsBetween(pair->GetPtMC()); + case kIsLabelEqual: + return pair->IsLabelEqual(); + case kIsTruePair: + return pair->IsTruePair(fIMin); + default: + AliWarning("Requested a cut which cannot be applied to a pair"); + return kTRUE; + } + + return kTRUE; } //________________________________________________________________________________________________________________ Bool_t AliRsnCut::IsSelected(ETarget type, AliRsnEvent * event) { - AliDebug (AliLog::kDebug, "<-"); - - // check type - if (type != kEvent) { - AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnEvent)", type, kEvent, event->ClassName())); - return kTRUE; - } - - switch (fType) { - case kMultiplicity: - return IsBetween ((Int_t)event->GetMultiplicity()); - default: - AliWarning("Requested a cut which cannot be applied to an event"); - return kTRUE; - } + AliDebug(AliLog::kDebug, "<-"); + // check type + if (type != kEvent) + { + AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnEvent)", type, kEvent, event->ClassName())); return kTRUE; + } + + switch (fType) + { + case kMultiplicity: + return IsBetween((Int_t) event->GetMultiplicity()); + default: + AliWarning("Requested a cut which cannot be applied to an event"); + return kTRUE; + } + + return kTRUE; } //________________________________________________________________________________________________________________ void AliRsnCut::PrintAllValues() { - AliInfo (Form ("fType=%d fVarType=%d",fType,fVarType)); - AliInfo (Form ("fDMin=%.2e fDMax=%.2e",fDMin,fDMax)); - AliInfo (Form ("fIMin=%d fIMax=%d",fIMin,fIMax)); - AliInfo (Form ("fUIMin=%d fUIMax=%d",fUIMin,fUIMax)); + AliInfo(Form("fType=%d fVarType=%d",fType,fVarType)); + AliInfo(Form("fDMin=%.2e fDMax=%.2e",fDMin,fDMax)); + AliInfo(Form("fIMin=%d fIMax=%d",fIMin,fIMax)); + AliInfo(Form("fUIMin=%d fUIMax=%d",fUIMin,fUIMax)); + AliInfo(Form("fULMin=%d fULMax=%d",fULMin,fULMax)); } diff --git a/PWG2/RESONANCES/AliRsnCut.h b/PWG2/RESONANCES/AliRsnCut.h index 95c14477189..a753dbee644 100644 --- a/PWG2/RESONANCES/AliRsnCut.h +++ b/PWG2/RESONANCES/AliRsnCut.h @@ -27,91 +27,93 @@ class AliRsnEvent; class AliRsnCut : public TNamed { -public: - - // available cut types - // some ones work both for pairs and single tracks - enum EType - { - kMomentum = 0, - kTransMomentum, - kEta, - kRadialImpactParam, - kMomentumMC, - kTransMomentumMC, - kEtaMC, - kNSigma, - kNSigmaCalculate, - kStatus, - kIsLabelEqual, - kIsTruePair, - kChargePos, - kChargeNeg, - kPIDType, - kPIDProb, - kMultiplicity, - kLastCutType - }; - - // types of cut variables - enum EVarType - { - kDouble_t = 0, - kInt_t, - kUInt_t - }; - - // possible targets for a cut - enum ETarget - { - kParticle = 0, - kPair, - kEvent, - kMixEventFinderCut, - kLastCutTarget - }; - - AliRsnCut(); - AliRsnCut (const char *name, const char *title, EType type); - AliRsnCut (const char *name, const char *title, EType type, Double_t min, Double_t max = 1e-100); - AliRsnCut (const char *name, const char *title, EType type, Int_t min, Int_t max = 32767); - AliRsnCut (const char *name, const char *title, EType type, UInt_t min, UInt_t max = 65534); - - ~AliRsnCut(); - - void SetCutValues (EType type, const Double_t& theValue, const Double_t& theValue2); - void SetCutValues (EType type, const Int_t& theValue, const Int_t& theValue2); - void SetCutValues (EType type, const UInt_t& theValue, const UInt_t& theValue2); - - Bool_t IsSelected (ETarget tgt, AliRsnDaughter *daughter); - Bool_t IsSelected (ETarget tgt, AliRsnPairParticle *pair); - Bool_t IsSelected (ETarget tgt, AliRsnEvent *event); - - void PrintAllValues(); - - Bool_t IsBetween (const Double_t &theValue); - Bool_t IsBetween (const Int_t &theValue); - Bool_t MatchesValue (const Int_t &theValue); - Bool_t MatchesValue (const UInt_t &theValue); - Bool_t MatchesValue (const Double_t &theValue); - -private: - - Double_t fDMin; // min. double value - Double_t fDMax; // max. double value - Int_t fIMin; // min. int value - Int_t fIMax; // max. int value - UInt_t fUIMin; // min. uint value - UInt_t fUIMax; // max. uint value - - EType fType; // cut type - EVarType fVarType; // variable type - - static const Double_t fgkDSmallNumber; // small double value - static const Double_t fgkDBigNumber; // big double value - static const Int_t fgkIBigNumber; // big int value - - ClassDef (AliRsnCut, 1) + public: + + // available cut types + // some ones work both for pairs and single tracks + enum EType { + kMomentum = 0, + kTransMomentum, + kEta, + kRadialImpactParam, + kMomentumMC, + kTransMomentumMC, + kEtaMC, + kNSigma, + kNSigmaCalculate, + kStatus, + kIsLabelEqual, + kIsTruePair, + kChargePos, + kChargeNeg, + kPIDType, + kPIDProb, + kMultiplicity, + kLastCutType + }; + + // types of cut variables + enum EVarType { + kDouble_t = 0, + kInt_t, + kUInt_t + }; + + // possible targets for a cut + enum ETarget { + kParticle = 0, + kPair, + kEvent, + kMixEventFinderCut, + kLastCutTarget + }; + + AliRsnCut(); + AliRsnCut(const char *name, const char *title, EType type); + AliRsnCut(const char *name, const char *title, EType type, Double_t min, Double_t max = 1e-100); + AliRsnCut(const char *name, const char *title, EType type, Int_t min, Int_t max = 32767); + AliRsnCut(const char *name, const char *title, EType type, UInt_t min, UInt_t max = 65534); + AliRsnCut(const char *name, const char *title, EType type, ULong_t min, ULong_t max = 65534); + + ~AliRsnCut(); + + void SetCutValues(EType type, const Double_t& theValue, const Double_t& theValue2); + void SetCutValues(EType type, const Int_t& theValue, const Int_t& theValue2); + void SetCutValues(EType type, const UInt_t& theValue, const UInt_t& theValue2); + void SetCutValues(EType type, const ULong_t& theValue, const ULong_t& theValue2); + + Bool_t IsSelected(ETarget tgt, AliRsnDaughter *daughter); + Bool_t IsSelected(ETarget tgt, AliRsnPairParticle *pair); + Bool_t IsSelected(ETarget tgt, AliRsnEvent *event); + + void PrintAllValues(); + + Bool_t IsBetween(const Double_t &theValue); + Bool_t IsBetween(const Int_t &theValue); + Bool_t MatchesValue(const Int_t &theValue); + Bool_t MatchesValue(const UInt_t &theValue); + Bool_t MatchesValue(const ULong_t &theValue); + Bool_t MatchesValue(const Double_t &theValue); + + private: + + Double_t fDMin; // min. double value + Double_t fDMax; // max. double value + Int_t fIMin; // min. int value + Int_t fIMax; // max. int value + UInt_t fUIMin; // min. uint value + UInt_t fUIMax; // max. uint value + ULong_t fULMin; // min. ulong value + ULong_t fULMax; // max. ulong value + + EType fType; // cut type + EVarType fVarType; // variable type + + static const Double_t fgkDSmallNumber; // small double value + static const Double_t fgkDBigNumber; // big double value + static const Int_t fgkIBigNumber; // big int value + + ClassDef(AliRsnCut, 1) }; #endif diff --git a/PWG2/RESONANCES/AliRsnCutMgr.cxx b/PWG2/RESONANCES/AliRsnCutMgr.cxx index 82f55a20419..d687bb5343f 100644 --- a/PWG2/RESONANCES/AliRsnCutMgr.cxx +++ b/PWG2/RESONANCES/AliRsnCutMgr.cxx @@ -16,34 +16,36 @@ #include "AliRsnCutSet.h" #include "AliRsnCutMgr.h" -ClassImp (AliRsnCutMgr) +ClassImp(AliRsnCutMgr) //_____________________________________________________________________________ AliRsnCutMgr::AliRsnCutMgr() : - TNamed("defaultName", "defaultTitle") + TNamed("defaultName", "defaultTitle") { // // Constructor without arguments. // - Int_t i; - for (i = 0; i < AliRsnCut::kLastCutTarget; i++) { - fCutSets[i] = 0; - } + Int_t i; + for (i = 0; i < AliRsnCut::kLastCutTarget; i++) + { + fCutSets[i] = 0; + } } //_____________________________________________________________________________ -AliRsnCutMgr::AliRsnCutMgr (const char *name, const char *title) : - TNamed (name, title) +AliRsnCutMgr::AliRsnCutMgr(const char *name, const char *title) : + TNamed(name, title) { // // Constructor with name and title. // - Int_t i; - for (i = 0; i < AliRsnCut::kLastCutTarget; i++) { - fCutSets[i] = 0; - } + Int_t i; + for (i = 0; i < AliRsnCut::kLastCutTarget; i++) + { + fCutSets[i] = 0; + } } //_____________________________________________________________________________ @@ -54,51 +56,53 @@ AliRsnCutMgr::~AliRsnCutMgr() // Deletes all cut definitions. // - Int_t i; - for (i = 0; i < AliRsnCut::kLastCutTarget; i++) { - delete fCutSets[i]; - } + Int_t i; + for (i = 0; i < AliRsnCut::kLastCutTarget; i++) + { + delete fCutSets[i]; + } } //_____________________________________________________________________________ -void AliRsnCutMgr::SetCutSet (AliRsnCut::ETarget type, AliRsnCutSet* cutset) +void AliRsnCutMgr::SetCutSet(AliRsnCut::ETarget type, AliRsnCutSet* cutset) { // // Assign a cut set to a given target // - if (!fCutSets[type]) fCutSets[type] = (AliRsnCutSet*) cutset->Clone(); - AliDebug (AliLog::kDebug, Form ("DatasetName %s", fCutSets[type]->GetName())); + if (!fCutSets[type]) fCutSets[type] = (AliRsnCutSet*) cutset->Clone(); + AliDebug(AliLog::kDebug, Form("DatasetName %s", fCutSets[type]->GetName())); } //_____________________________________________________________________________ -Bool_t AliRsnCutMgr::IsSelected ( AliRsnCut::ETarget type,TObject *obj ) +Bool_t AliRsnCutMgr::IsSelected(AliRsnCut::ETarget type,TObject *obj) { // // Check if a given object passes the cuts defined for it. // The target of the check is here a TObject, in order to allo generality -// but then the kind of cut to be used is defined as first argument, and +// but then the kind of cut to be used is defined as first argument, and // in the single cut it will be checked if it is appropriate for passed target // - AliDebug (AliLog::kDebug, "<-"); - if (!fCutSets[type]) return kTRUE; - - switch (type) { - case AliRsnCut::kParticle: - return fCutSets[type]->IsSelected (type, (AliRsnDaughter*)obj); - break; - case AliRsnCut::kPair: - return fCutSets[type]->IsSelected (type, (AliRsnPairParticle*)obj); - break; - case AliRsnCut::kEvent: - return fCutSets[type]->IsSelected (type, (AliRsnEvent*)obj); - break; - default: - AliWarning ("Wrong target selected."); - return kTRUE; - break; - } - - return kTRUE; + AliDebug(AliLog::kDebug, "<-"); + if (!fCutSets[type]) return kTRUE; + + switch (type) + { + case AliRsnCut::kParticle: + return fCutSets[type]->IsSelected(type, (AliRsnDaughter*)obj); + break; + case AliRsnCut::kPair: + return fCutSets[type]->IsSelected(type, (AliRsnPairParticle*)obj); + break; + case AliRsnCut::kEvent: + return fCutSets[type]->IsSelected(type, (AliRsnEvent*)obj); + break; + default: + AliWarning("Wrong target selected."); + return kTRUE; + break; + } + + return kTRUE; } diff --git a/PWG2/RESONANCES/AliRsnCutMgr.h b/PWG2/RESONANCES/AliRsnCutMgr.h index f4dcd526f71..7c15ebbb086 100644 --- a/PWG2/RESONANCES/AliRsnCutMgr.h +++ b/PWG2/RESONANCES/AliRsnCutMgr.h @@ -39,7 +39,7 @@ class AliRsnCutMgr : public TNamed AliRsnCutSet *fCutSets[AliRsnCut::kLastCutTarget]; // cut definitions for all targets - ClassDef (AliRsnCutMgr, 1); // dictionary + ClassDef(AliRsnCutMgr, 1); // dictionary }; #endif diff --git a/PWG2/RESONANCES/AliRsnCutSet.cxx b/PWG2/RESONANCES/AliRsnCutSet.cxx index b230f9c0c72..836a231acc8 100644 --- a/PWG2/RESONANCES/AliRsnCutSet.cxx +++ b/PWG2/RESONANCES/AliRsnCutSet.cxx @@ -5,63 +5,63 @@ #include "AliRsnCutSet.h" -ClassImp (AliRsnCutSet) +ClassImp(AliRsnCutSet) //_____________________________________________________________________________ AliRsnCutSet::AliRsnCutSet() : - TNamed(), - fCuts(0), - fNumOfCuts(0), - fCutScheme (""), - fCutSchemeIndexed (""), - fBoolValues (0), - fIsScheme (kFALSE), - fExpression(0) + TNamed(), + fCuts(0), + fNumOfCuts(0), + fCutScheme(""), + fCutSchemeIndexed(""), + fBoolValues(0), + fIsScheme(kFALSE), + fExpression(0) { // // Constructor without name (not recommended) // - fBoolValues = new Bool_t[1]; - AliRsnExpression::sCutSet = this; + fBoolValues = new Bool_t[1]; + AliRsnExpression::sCutSet = this; } //_____________________________________________________________________________ -AliRsnCutSet::AliRsnCutSet (TString name) : - TNamed (name, name), - fCuts(0), - fNumOfCuts(0), - fCutScheme (""), - fCutSchemeIndexed (""), - fBoolValues (0), - fIsScheme (kFALSE), - fExpression(0) +AliRsnCutSet::AliRsnCutSet(TString name) : + TNamed(name, name), + fCuts(0), + fNumOfCuts(0), + fCutScheme(""), + fCutSchemeIndexed(""), + fBoolValues(0), + fIsScheme(kFALSE), + fExpression(0) { // // Constructor with argument name (recommended) // - fBoolValues = new Bool_t[1]; - fExpression = 0; - AliRsnExpression::sCutSet = this; + fBoolValues = new Bool_t[1]; + fExpression = 0; + AliRsnExpression::sCutSet = this; } //_____________________________________________________________________________ -AliRsnCutSet::AliRsnCutSet (const AliRsnCutSet & copy) : - TNamed ((TNamed) copy), - fCuts(copy.fCuts), - fNumOfCuts(copy.fNumOfCuts), - fCutScheme(copy.fCutScheme), - fCutSchemeIndexed (copy.fCutSchemeIndexed), - fBoolValues(0), - fIsScheme(copy.fIsScheme), - fExpression(copy.fExpression) +AliRsnCutSet::AliRsnCutSet(const AliRsnCutSet & copy) : + TNamed((TNamed) copy), + fCuts(copy.fCuts), + fNumOfCuts(copy.fNumOfCuts), + fCutScheme(copy.fCutScheme), + fCutSchemeIndexed(copy.fCutSchemeIndexed), + fBoolValues(0), + fIsScheme(copy.fIsScheme), + fExpression(copy.fExpression) { // // Copy constructor // - AliRsnExpression::sCutSet = this; + AliRsnExpression::sCutSet = this; } //_____________________________________________________________________________ @@ -71,37 +71,38 @@ AliRsnCutSet::~AliRsnCutSet() // Destructor // - delete fExpression; - delete [] fBoolValues; + delete fExpression; + delete [] fBoolValues; } //_____________________________________________________________________________ -void AliRsnCutSet::AddCut (AliRsnCut *cut) +void AliRsnCutSet::AddCut(AliRsnCut *cut) { // // Add a new cut. // This must be done for all components of the final expression // - Int_t i; - - AliDebug (AliLog::kDebug,"<-"); - fCuts.Add (cut); - fNumOfCuts++; - - if (fBoolValues) delete fBoolValues; - - fBoolValues = new Bool_t[fNumOfCuts]; - for (i = 0; i < fNumOfCuts; i++) { - fBoolValues[i] = kTRUE; - } - - AliDebug (AliLog::kDebug,Form ("%d",fCuts.GetEntriesFast())); - AliDebug (AliLog::kDebug,"->"); + Int_t i; + + AliDebug(AliLog::kDebug,"<-"); + fCuts.Add(cut); + fNumOfCuts++; + + if (fBoolValues) delete fBoolValues; + + fBoolValues = new Bool_t[fNumOfCuts]; + for (i = 0; i < fNumOfCuts; i++) + { + fBoolValues[i] = kTRUE; + } + + AliDebug(AliLog::kDebug,Form("%d",fCuts.GetEntriesFast())); + AliDebug(AliLog::kDebug,"->"); } //_____________________________________________________________________________ -void AliRsnCutSet::ShowCuts () +void AliRsnCutSet::ShowCuts() { // // Prints all cuts @@ -115,115 +116,119 @@ void AliRsnCutSet::ShowCuts () } //_____________________________________________________________________________ -Bool_t AliRsnCutSet::IsSelected (AliRsnCut::ETarget type, AliRsnDaughter *daughter) +Bool_t AliRsnCutSet::IsSelected(AliRsnCut::ETarget type, AliRsnDaughter *daughter) { // // Checks an object according to the cut expression defined here. // - Int_t i; - - if (!fNumOfCuts) return kTRUE; - - Bool_t boolReturn = kTRUE; - AliRsnCut *cut; - for (i = 0; i < fNumOfCuts; i++) { - cut = (AliRsnCut*)fCuts.At(i); - fBoolValues[i] = cut->IsSelected (type,daughter); - } - - if (fIsScheme) boolReturn = Passed(); - return boolReturn; + Int_t i; + + if (!fNumOfCuts) return kTRUE; + + Bool_t boolReturn = kTRUE; + AliRsnCut *cut; + for (i = 0; i < fNumOfCuts; i++) + { + cut = (AliRsnCut*)fCuts.At(i); + fBoolValues[i] = cut->IsSelected(type,daughter); + } + + if (fIsScheme) boolReturn = Passed(); + return boolReturn; } //_____________________________________________________________________________ -Bool_t AliRsnCutSet::IsSelected (AliRsnCut::ETarget type, AliRsnPairParticle * pair) +Bool_t AliRsnCutSet::IsSelected(AliRsnCut::ETarget type, AliRsnPairParticle * pair) { // // Checks an object according to the cut expression defined here. // - Int_t i; - - if (!fNumOfCuts) return kTRUE; - - Bool_t boolReturn = kTRUE; - AliRsnCut *cut; - for (i = 0; i < fNumOfCuts; i++) { - cut = (AliRsnCut*) fCuts.At (i); - fBoolValues[i] = cut->IsSelected (type,pair); - } - - if (fIsScheme) boolReturn = Passed(); - return boolReturn; + Int_t i; + + if (!fNumOfCuts) return kTRUE; + + Bool_t boolReturn = kTRUE; + AliRsnCut *cut; + for (i = 0; i < fNumOfCuts; i++) + { + cut = (AliRsnCut*) fCuts.At(i); + fBoolValues[i] = cut->IsSelected(type,pair); + } + + if (fIsScheme) boolReturn = Passed(); + return boolReturn; } //_____________________________________________________________________________ -Bool_t AliRsnCutSet::IsSelected (AliRsnCut::ETarget type, AliRsnEvent * event) +Bool_t AliRsnCutSet::IsSelected(AliRsnCut::ETarget type, AliRsnEvent * event) { // // Checks an object according to the cut expression defined here. // - Int_t i; - if (!fNumOfCuts) return kTRUE; - - Bool_t boolReturn = kTRUE; - AliRsnCut *cut; - for (i = 0; i < fNumOfCuts; i++) { - cut = (AliRsnCut*) fCuts.At (i); - fBoolValues[i] = cut->IsSelected (type,event); - } - - if (fIsScheme) boolReturn = Passed(); - return boolReturn; + Int_t i; + if (!fNumOfCuts) return kTRUE; + + Bool_t boolReturn = kTRUE; + AliRsnCut *cut; + for (i = 0; i < fNumOfCuts; i++) + { + cut = (AliRsnCut*) fCuts.At(i); + fBoolValues[i] = cut->IsSelected(type,event); + } + + if (fIsScheme) boolReturn = Passed(); + return boolReturn; } //_____________________________________________________________________________ -void AliRsnCutSet::SetCutScheme (const TString & theValue) +void AliRsnCutSet::SetCutScheme(const TString & theValue) { // // Define the combination of cuts with logical operators // and using the names given to all defined cuts. // - AliDebug (AliLog::kDebug,"<-"); - fCutScheme = theValue; - SetCutSchemeIndexed (theValue); - fIsScheme = kTRUE; - AliDebug (AliLog::kDebug,"->"); + AliDebug(AliLog::kDebug,"<-"); + fCutScheme = theValue; + SetCutSchemeIndexed(theValue); + fIsScheme = kTRUE; + AliDebug(AliLog::kDebug,"->"); } //_____________________________________________________________________________ -void AliRsnCutSet::SetCutSchemeIndexed (TString theValue) +void AliRsnCutSet::SetCutSchemeIndexed(TString theValue) { // // Internal method which indexes all cuts to organize their combo // - AliDebug (AliLog::kDebug,"<-"); - theValue.Append(" "); - // fCutSchemeIndexed = theValue; - fCutSchemeIndexed = GetCutSchemeIndexed(); - AliDebug (AliLog::kDebug,"->"); + AliDebug(AliLog::kDebug,"<-"); + theValue.Append(" "); + // fCutSchemeIndexed = theValue; + fCutSchemeIndexed = GetCutSchemeIndexed(); + AliDebug(AliLog::kDebug,"->"); } //_____________________________________________________________________________ -Int_t AliRsnCutSet::GetIndexByCutName (TString s) +Int_t AliRsnCutSet::GetIndexByCutName(TString s) { // // Retrieve the cut index from its name // - Int_t i; - AliRsnCut *cut; - - for (i = 0; i < fCuts.GetEntriesFast(); i++) { - cut = (AliRsnCut*) fCuts.At (i); - if (!s.CompareTo (cut->GetName())) return i; - } - - return -1; + Int_t i; + AliRsnCut *cut; + + for (i = 0; i < fCuts.GetEntriesFast(); i++) + { + cut = (AliRsnCut*) fCuts.At(i); + if (!s.CompareTo(cut->GetName())) return i; + } + + return -1; } //_____________________________________________________________________________ @@ -234,13 +239,14 @@ Bool_t AliRsnCutSet::Passed() // and gives a global response to the cut check // - AliRsnExpression::sCutSet = this; - if (!fExpression) { - fExpression = new AliRsnExpression (fCutSchemeIndexed); - AliDebug (AliLog::kDebug,"fExpression was created."); - } - - return fExpression->Value (*GetCuts()); + AliRsnExpression::sCutSet = this; + if (!fExpression) + { + fExpression = new AliRsnExpression(fCutSchemeIndexed); + AliDebug(AliLog::kDebug,"fExpression was created."); + } + + return fExpression->Value(*GetCuts()); } //_____________________________________________________________________________ @@ -250,7 +256,7 @@ Bool_t AliRsnCutSet::IsValidScheme() // Validity check on cut expression specified by user // - return (! (ShowCutScheme().Contains ("Error"))); + return (!(ShowCutScheme().Contains("Error"))); } //_____________________________________________________________________________ @@ -259,11 +265,11 @@ TString AliRsnCutSet::ShowCutScheme() // // Utility method to check validity of expression // - return fExpression->Unparse(); + return fExpression->Unparse(); } //_____________________________________________________________________________ -Int_t AliRsnCutSet::TestExpression (TString opt) +Int_t AliRsnCutSet::TestExpression(TString opt) { // AliRsnCut *cut1 = new AliRsnCut ("aaa","aaa"); @@ -282,8 +288,8 @@ Int_t AliRsnCutSet::TestExpression (TString opt) // // set->ShowCuts (); - AliDebug(1, opt.Data()); - return 0; + AliDebug(1, opt.Data()); + return 0; } //_____________________________________________________________________________ @@ -293,19 +299,20 @@ void AliRsnCutSet::PrintSetInfo() // Show data about the cut set // - Int_t i; - - AliInfo ("========== Rsn Cut Set info =============="); - AliInfo (Form ("Sheme : %s",fCutScheme.Data())); - AliInfo (Form ("Sheme : %s",fCutSchemeIndexed.Data())); - AliInfo (Form ("Num of Cuts: %d", fCuts.GetEntriesFast())); - AliInfo ("====== Cuts ======"); - AliRsnCut *cut; - for (i = 0; i < fCuts.GetEntriesFast(); i++) { - cut = (AliRsnCut*) fCuts.At (i); - if (cut) AliInfo (Form ("%d %d",i,fBoolValues[i])); - } - AliInfo ("========== END Rsn Cut Mgr info =============="); + Int_t i; + + AliInfo("========== Rsn Cut Set info =============="); + AliInfo(Form("Sheme : %s",fCutScheme.Data())); + AliInfo(Form("Sheme : %s",fCutSchemeIndexed.Data())); + AliInfo(Form("Num of Cuts: %d", fCuts.GetEntriesFast())); + AliInfo("====== Cuts ======"); + AliRsnCut *cut; + for (i = 0; i < fCuts.GetEntriesFast(); i++) + { + cut = (AliRsnCut*) fCuts.At(i); + if (cut) AliInfo(Form("%d %d",i,fBoolValues[i])); + } + AliInfo("========== END Rsn Cut Mgr info =============="); } //_____________________________________________________________________________ @@ -316,15 +323,16 @@ TString AliRsnCutSet::GetCutSchemeIndexed() // for evaluation of cut expression // - AliDebug (AliLog::kDebug,"<-"); - Int_t i; - TString str (fCutScheme); - AliDebug (AliLog::kDebug,Form ("Num of cuts %d",fCuts.GetEntriesFast())); - AliRsnCut *cut; - for (i = 0; i < fCuts.GetEntriesFast(); i++) { - cut = (AliRsnCut*) fCuts.At (i); - str.ReplaceAll (cut->GetName(),Form ("%d",i)); - } - AliDebug (AliLog::kDebug,"->"); - return str; + AliDebug(AliLog::kDebug,"<-"); + Int_t i; + TString str(fCutScheme); + AliDebug(AliLog::kDebug,Form("Num of cuts %d",fCuts.GetEntriesFast())); + AliRsnCut *cut; + for (i = 0; i < fCuts.GetEntriesFast(); i++) + { + cut = (AliRsnCut*) fCuts.At(i); + str.ReplaceAll(cut->GetName(),Form("%d",i)); + } + AliDebug(AliLog::kDebug,"->"); + return str; } diff --git a/PWG2/RESONANCES/AliRsnCutSet.h b/PWG2/RESONANCES/AliRsnCutSet.h index 64bbbd53780..315ecc5e68e 100644 --- a/PWG2/RESONANCES/AliRsnCutSet.h +++ b/PWG2/RESONANCES/AliRsnCutSet.h @@ -2,7 +2,7 @@ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * * See cxx source for full Copyright notice * **************************************************************************/ - + // // class AliRsnCutSet // Combination of simple cuts @@ -23,39 +23,39 @@ class AliRsnEvent; class AliRsnCutSet : public TNamed { -public: + public: AliRsnCutSet(); - AliRsnCutSet (TString name); - AliRsnCutSet (const AliRsnCutSet ©); + AliRsnCutSet(TString name); + AliRsnCutSet(const AliRsnCutSet ©); ~AliRsnCutSet(); - void AddCut (AliRsnCut* cut); + void AddCut(AliRsnCut* cut); void ShowCuts(); - Int_t GetIndexByCutName (TString s); + Int_t GetIndexByCutName(TString s); Bool_t Passed(); Bool_t IsValidScheme(); TString ShowCutScheme(); - Int_t TestExpression (TString opt="short"); + Int_t TestExpression(TString opt="short"); void PrintSetInfo(); - Bool_t IsSelected (AliRsnCut::ETarget type, AliRsnDaughter *daughter); - Bool_t IsSelected (AliRsnCut::ETarget type, AliRsnPairParticle *pair); - Bool_t IsSelected (AliRsnCut::ETarget type, AliRsnEvent *event); + Bool_t IsSelected(AliRsnCut::ETarget type, AliRsnDaughter *daughter); + Bool_t IsSelected(AliRsnCut::ETarget type, AliRsnPairParticle *pair); + Bool_t IsSelected(AliRsnCut::ETarget type, AliRsnEvent *event); - void SetBoolValue (Bool_t theValue,Int_t index) { fBoolValues[index] = theValue; } - Bool_t GetBoolValue (Int_t index) const { return fBoolValues[index]; } + void SetBoolValue(Bool_t theValue,Int_t index) { fBoolValues[index] = theValue; } + Bool_t GetBoolValue(Int_t index) const { return fBoolValues[index]; } - void SetCutScheme (const TString& theValue); + void SetCutScheme(const TString& theValue); TString GetCutScheme() const { return fCutScheme; } - void SetCutSchemeIndexed (TString theValue); + void SetCutSchemeIndexed(TString theValue); TString GetCutSchemeIndexed(); TObjArray *GetCuts() { return &fCuts; } -private: + private: AliRsnCutSet& operator=(const AliRsnCutSet& /*copy*/) {return (*this);} @@ -66,10 +66,10 @@ private: Bool_t *fBoolValues; //[fNumOfCuts] Bool_t fIsScheme; // is scheme - + AliRsnExpression *fExpression; // pointer to AliRsnExpression - ClassDef (AliRsnCutSet,1); // ROOT dictionary + ClassDef(AliRsnCutSet,1); // ROOT dictionary }; #endif diff --git a/PWG2/RESONANCES/AliRsnDaughter.cxx b/PWG2/RESONANCES/AliRsnDaughter.cxx index 12d86c7d6a1..bbe48e5835e 100644 --- a/PWG2/RESONANCES/AliRsnDaughter.cxx +++ b/PWG2/RESONANCES/AliRsnDaughter.cxx @@ -30,119 +30,123 @@ AliRsnDaughter::EPIDMethod AliRsnDaughter::fgPIDMethod = AliRsnDaughter::kNoPID; //_____________________________________________________________________________ AliRsnDaughter::AliRsnDaughter() : - AliVParticle(), - fIndex(-1), - fLabel(-1), - fCharge(0), - fFlags(0), - fMass(0.0), - fRealisticPID(AliRsnPID::kUnknown), - fMCInfo(0x0) + AliVParticle(), + fIndex(-1), + fLabel(-1), + fCharge(0), + fFlags(0), + fMass(0.0), + fRealisticPID(AliRsnPID::kUnknown), + fMCInfo(0x0) { // // Default constructor. // Initializes all data-members with meaningless values. // - Int_t i; - for (i = 0; i < AliRsnPID::kSpecies; i++) { - if (i < 3) { - fP[i] = 0.0; - fV[i] = 0.0; - } - fPIDWeight[i] = 0.0; - fPIDProb[i] = 0.0; + Int_t i; + for (i = 0; i < AliRsnPID::kSpecies; i++) + { + if (i < 3) + { + fP[i] = 0.0; + fV[i] = 0.0; } + fPIDWeight[i] = 0.0; + fPIDProb[i] = 0.0; + } } //_____________________________________________________________________________ AliRsnDaughter::AliRsnDaughter(const AliRsnDaughter ©) : - AliVParticle(copy), - fIndex(copy.fIndex), - fLabel(copy.fLabel), - fCharge(copy.fCharge), - fFlags(copy.fFlags), - fMass(copy.fMass), - fRealisticPID(copy.fRealisticPID), - fMCInfo(0x0) + AliVParticle(copy), + fIndex(copy.fIndex), + fLabel(copy.fLabel), + fCharge(copy.fCharge), + fFlags(copy.fFlags), + fMass(copy.fMass), + fRealisticPID(copy.fRealisticPID), + fMCInfo(0x0) { // // Copy constructor. // - Int_t i; - for (i = 0; i < AliRsnPID::kSpecies; i++) { - if (i < 3) { - fP[i] = copy.fP[i]; - fV[i] = copy.fV[i]; - } - fPIDWeight[i] = copy.fPIDWeight[i]; - fPIDProb[i] = copy.fPIDProb[i]; + Int_t i; + for (i = 0; i < AliRsnPID::kSpecies; i++) + { + if (i < 3) + { + fP[i] = copy.fP[i]; + fV[i] = copy.fV[i]; } + fPIDWeight[i] = copy.fPIDWeight[i]; + fPIDProb[i] = copy.fPIDProb[i]; + } - // initialize particle object - // only if it is present in the template object - if (copy.fMCInfo) fMCInfo = new AliRsnMCInfo(*(copy.fMCInfo)); + // initialize particle object + // only if it is present in the template object + if (copy.fMCInfo) fMCInfo = new AliRsnMCInfo(*(copy.fMCInfo)); } //_____________________________________________________________________________ AliRsnDaughter::AliRsnDaughter(AliESDtrack *track, Bool_t useTPC) : - AliVParticle(), - fIndex(-1), - fLabel(-1), - fCharge(0), - fFlags(0), - fMass(0.0), - fRealisticPID(AliRsnPID::kUnknown), - fMCInfo(0x0) + AliVParticle(), + fIndex(-1), + fLabel(-1), + fCharge(0), + fFlags(0), + fMass(0.0), + fRealisticPID(AliRsnPID::kUnknown), + fMCInfo(0x0) { // // Constructor to get data from an ESD track. // - Int_t i; - for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDProb[i] = 0.0; - Adopt(track, useTPC); + Int_t i; + for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDProb[i] = 0.0; + Adopt(track, kEsd,0.0,useTPC); } //_____________________________________________________________________________ AliRsnDaughter::AliRsnDaughter(AliAODTrack *track) : - AliVParticle(), - fIndex(-1), - fLabel(-1), - fCharge(0), - fFlags(0), - fMass(0.0), - fRealisticPID(AliRsnPID::kUnknown), - fMCInfo(0x0) + AliVParticle(), + fIndex(-1), + fLabel(-1), + fCharge(0), + fFlags(0), + fMass(0.0), + fRealisticPID(AliRsnPID::kUnknown), + fMCInfo(0x0) { // // Constructor to get data from an AOD track. // - Int_t i; - for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDProb[i] = 0.0; - Adopt(track); + Int_t i; + for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDProb[i] = 0.0; + Adopt(track); } //_____________________________________________________________________________ AliRsnDaughter::AliRsnDaughter(AliMCParticle *track) : - AliVParticle(), - fIndex(-1), - fLabel(-1), - fCharge(0), - fFlags(0), - fMass(0.0), - fRealisticPID(AliRsnPID::kUnknown), - fMCInfo(0x0) + AliVParticle(), + fIndex(-1), + fLabel(-1), + fCharge(0), + fFlags(0), + fMass(0.0), + fRealisticPID(AliRsnPID::kUnknown), + fMCInfo(0x0) { // // Constructor to get data from an MC track. // - Int_t i; - for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDProb[i] = 0.0; - Adopt(track); + Int_t i; + for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDProb[i] = 0.0; + Adopt(track); } //_____________________________________________________________________________ @@ -154,34 +158,37 @@ AliRsnDaughter& AliRsnDaughter::operator=(const AliRsnDaughter ©) // to the initialized object for which it is called. // - fIndex = copy.fIndex; - fLabel = copy.fLabel; - fCharge = copy.fCharge; - fFlags = copy.fFlags; - - Int_t i; - for (i = 0; i < AliRsnPID::kSpecies; i++) { - if (i < 3) { - fP[i] = copy.fP[i]; - fV[i] = copy.fV[i]; - } - fPIDWeight[i] = copy.fPIDWeight[i]; - fPIDProb[i] = copy.fPIDProb[i]; - } - - fMass = copy.fMass; - fRealisticPID = copy.fRealisticPID; + fIndex = copy.fIndex; + fLabel = copy.fLabel; + fCharge = copy.fCharge; + fFlags = copy.fFlags; - // initialize particle object - // only if it is present in the template object; - // otherwise, it is just cleared and not replaced with anything - if (fMCInfo) { - delete fMCInfo; - fMCInfo = 0x0; + Int_t i; + for (i = 0; i < AliRsnPID::kSpecies; i++) + { + if (i < 3) + { + fP[i] = copy.fP[i]; + fV[i] = copy.fV[i]; } - if (copy.fMCInfo) fMCInfo = new AliRsnMCInfo(*(copy.fMCInfo)); - - return (*this); + fPIDWeight[i] = copy.fPIDWeight[i]; + fPIDProb[i] = copy.fPIDProb[i]; + } + + fMass = copy.fMass; + fRealisticPID = copy.fRealisticPID; + + // initialize particle object + // only if it is present in the template object; + // otherwise, it is just cleared and not replaced with anything + if (fMCInfo) + { + delete fMCInfo; + fMCInfo = 0x0; + } + if (copy.fMCInfo) fMCInfo = new AliRsnMCInfo(*(copy.fMCInfo)); + + return (*this); } //_____________________________________________________________________________ @@ -191,10 +198,11 @@ AliRsnDaughter::~AliRsnDaughter() // Destructor // - if (fMCInfo) { - delete fMCInfo; - fMCInfo = 0; - } + if (fMCInfo) + { + delete fMCInfo; + fMCInfo = 0; + } } //_____________________________________________________________________________ @@ -205,10 +213,11 @@ void AliRsnDaughter::SetPIDWeight(Int_t i, Double_t value) // sets the i-th PID weight to 'value' // - if (i >= 0 && i < AliRsnPID::kSpecies) fPIDWeight[i] = value; - else { - AliError(Form("Cannot set a weight related to slot %d", i)); - } + if (i >= 0 && i < AliRsnPID::kSpecies) fPIDWeight[i] = value; + else + { + AliError(Form("Cannot set a weight related to slot %d", i)); + } } //_____________________________________________________________________________ @@ -218,22 +227,24 @@ void AliRsnDaughter::AssignRealisticPID() // Assign realistic PID from largest probability // - Int_t i, imax = 0; - Double_t pmax = fPIDProb[0]; - - // search for maximum - for (i = 1; i < AliRsnPID::kSpecies; i++) { - if (fPIDProb[i] > pmax) { - imax = i; - pmax = fPIDProb[i]; - } + Int_t i, imax = 0; + Double_t pmax = fPIDProb[0]; + + // search for maximum + for (i = 1; i < AliRsnPID::kSpecies; i++) + { + if (fPIDProb[i] > pmax) + { + imax = i; + pmax = fPIDProb[i]; } - - fRealisticPID = (AliRsnPID::EType)imax; + } + + fRealisticPID = (AliRsnPID::EType)imax; } //_____________________________________________________________________________ -AliRsnPID::EType AliRsnDaughter::PIDType(Double_t &prob) +AliRsnPID::EType AliRsnDaughter::PIDType(Double_t &prob) const { // // Return the PID type according to the selected method @@ -241,23 +252,26 @@ AliRsnPID::EType AliRsnDaughter::PIDType(Double_t &prob) // It will be realistic for realistic PID and 1 for perfect PID. // - switch (fgPIDMethod) { - case kNoPID: - AliWarning("Requested a PIDtype call in NoPID mode"); - return AliRsnPID::kUnknown; - case kPerfect: - if (fMCInfo) return AliRsnPID::InternalType(fMCInfo->PDG()); - else return AliRsnPID::kUnknown; - default: - if (fRealisticPID > 0 && fRealisticPID < AliRsnPID::kSpecies) { - prob = fPIDProb[fRealisticPID]; - return fRealisticPID; - } - else { - prob = 1.0; - return AliRsnPID::kUnknown; - } - } + switch (fgPIDMethod) + { + case kNoPID: + AliWarning("Requested a PIDtype call in NoPID mode"); + return AliRsnPID::kUnknown; + case kPerfect: + if (fMCInfo) return AliRsnPID::InternalType(fMCInfo->PDG()); + else return AliRsnPID::kUnknown; + default: + if (fRealisticPID > 0 && fRealisticPID < AliRsnPID::kSpecies) + { + prob = fPIDProb[fRealisticPID]; + return fRealisticPID; + } + else + { + prob = 1.0; + return AliRsnPID::kUnknown; + } + } } //_____________________________________________________________________________ @@ -268,14 +282,15 @@ void AliRsnDaughter::SetPIDProb(Int_t i, Double_t value) // sets the i-th PID probability to 'value' // - if (i >= 0 && i < AliRsnPID::kSpecies) fPIDProb[i] = value; - else { - AliError(Form("Cannot set a weight related to slot %d", i)); - } + if (i >= 0 && i < AliRsnPID::kSpecies) fPIDProb[i] = value; + else + { + AliError(Form("Cannot set a weight related to slot %d", i)); + } } //_____________________________________________________________________________ -Bool_t AliRsnDaughter::Adopt(AliESDtrack* esdTrack, Bool_t useTPCInnerParam) +Bool_t AliRsnDaughter::Adopt(AliESDtrack* esdTrack,EPIDType pidType ,Double_t divValue, Bool_t useTPCInnerParam) { // // Copies data from an AliESDtrack into "this": @@ -286,40 +301,47 @@ Bool_t AliRsnDaughter::Adopt(AliESDtrack* esdTrack, Bool_t useTPCInnerParam) // In case of errors returns kFALSE, otherwise kTRUE. // - if (!esdTrack) { - AliError("Passed NULL object: nothing done"); - return kFALSE; - } - - // copy momentum and vertex - if (!useTPCInnerParam) { - esdTrack->GetPxPyPz(fP); - esdTrack->GetXYZ(fV); - } - else { - if (!esdTrack->GetTPCInnerParam()) return kFALSE; - esdTrack->GetTPCInnerParam()->GetPxPyPz(fP); - esdTrack->GetTPCInnerParam()->GetXYZ(fV); - } - - // copy PID weights - Int_t i; - Double_t pid[5]; - if (!useTPCInnerParam) { - esdTrack->GetESDpid(pid); - } - else { - esdTrack->GetTPCpid(pid); - } - for (i = 0; i < 5; i++) fPIDWeight[i] = pid[i]; - - // copy flags - fFlags = esdTrack->GetStatus(); - - // copy charge sign - fCharge = (Short_t)esdTrack->Charge(); - - return kTRUE; + if (!esdTrack) + { + AliError("Passed NULL object: nothing done"); + return kFALSE; + } + + // copy momentum and vertex + if (!useTPCInnerParam) + { + esdTrack->GetPxPyPz(fP); + esdTrack->GetXYZ(fV); + } + else + { + if (!esdTrack->GetTPCInnerParam()) return kFALSE; + esdTrack->GetTPCInnerParam()->GetPxPyPz(fP); + esdTrack->GetTPCInnerParam()->GetXYZ(fV); + } + + Double_t p = esdTrack->P(); + // copy PID weights + Int_t i; + Double_t pid[5]; + if (!useTPCInnerParam) + { + GetESDPID(esdTrack,pid,pidType,divValue,p); + } + else + { +// fCurrentESDPID = kTPC; + GetESDPID(esdTrack,pid,kTPC,0.0,p); + } + for (i = 0; i < 5; i++) fPIDWeight[i] = pid[i]; + + // copy flags + fFlags = esdTrack->GetStatus(); + + // copy charge sign + fCharge = (Short_t)esdTrack->Charge(); + + return kTRUE; } @@ -335,30 +357,31 @@ Bool_t AliRsnDaughter::Adopt(AliAODTrack* aodTrack) // In case of errors returns kFALSE, otherwise kTRUE. // - if (!aodTrack) { - AliError("Passed NULL object: nothing done"); - return kFALSE; - } + if (!aodTrack) + { + AliError("Passed NULL object: nothing done"); + return kFALSE; + } - // copy momentum and vertex - fP[0] = aodTrack->Px(); - fP[1] = aodTrack->Py(); - fP[2] = aodTrack->Pz(); - fV[0] = aodTrack->Xv(); - fV[1] = aodTrack->Yv(); - fV[2] = aodTrack->Zv(); + // copy momentum and vertex + fP[0] = aodTrack->Px(); + fP[1] = aodTrack->Py(); + fP[2] = aodTrack->Pz(); + fV[0] = aodTrack->Xv(); + fV[1] = aodTrack->Yv(); + fV[2] = aodTrack->Zv(); - // copy PID weights - Int_t i; - for (i = 0; i < 5; i++) fPIDWeight[i] = aodTrack->PID()[i]; - - // copy flags - fFlags = aodTrack->GetStatus(); + // copy PID weights + Int_t i; + for (i = 0; i < 5; i++) fPIDWeight[i] = aodTrack->PID()[i]; + + // copy flags + fFlags = aodTrack->GetStatus(); - // copy sign - fCharge = aodTrack->Charge(); + // copy sign + fCharge = aodTrack->Charge(); - return kTRUE; + return kTRUE; } @@ -376,49 +399,54 @@ Bool_t AliRsnDaughter::Adopt(AliMCParticle *mcParticle) // In case of errors returns kFALSE, otherwise kTRUE. // - if (!mcParticle) { - AliError("Passed NULL object: nothing done"); - return kFALSE; - } - - // retrieve the TParticle object from the argument - TParticle *particle = mcParticle->Particle(); - if (!particle) { - AliError("AliMCParticle::Particle() returned NULL"); - return kFALSE; - } - - // copy momentum and vertex - fP[0] = particle->Px(); - fP[1] = particle->Py(); - fP[2] = particle->Pz(); - fV[0] = particle->Vx(); - fV[1] = particle->Vy(); - fV[2] = particle->Vz(); - - // recognize charge sign from PDG code sign - Int_t pdg = particle->GetPdgCode(); - Int_t absPDG = TMath::Abs(pdg); - if (absPDG <= 15) { - if (pdg > 0) fCharge = -1; else fCharge = 1; - } - else if (absPDG < 3000) { - if (pdg > 0) fCharge = 1; else fCharge = -1; - } - else { - fCharge = 0; - return kFALSE; - } - - // flags and PID weights make no sense with MC tracks - fFlags = 0; - for (pdg = 0; pdg < AliRsnPID::kSpecies; pdg++) fPIDWeight[pdg] = 0.0; - fPIDWeight[AliRsnPID::InternalType(absPDG)] = 1.0; - - // copy other MC info (mother PDG code cannot be retrieved here) - InitMCInfo(particle); - - return kTRUE; + if (!mcParticle) + { + AliError("Passed NULL object: nothing done"); + return kFALSE; + } + + // retrieve the TParticle object from the argument + TParticle *particle = mcParticle->Particle(); + if (!particle) + { + AliError("AliMCParticle::Particle() returned NULL"); + return kFALSE; + } + + // copy momentum and vertex + fP[0] = particle->Px(); + fP[1] = particle->Py(); + fP[2] = particle->Pz(); + fV[0] = particle->Vx(); + fV[1] = particle->Vy(); + fV[2] = particle->Vz(); + + // recognize charge sign from PDG code sign + Int_t pdg = particle->GetPdgCode(); + Int_t absPDG = TMath::Abs(pdg); + if (absPDG <= 15) + { + if (pdg > 0) fCharge = -1; else fCharge = 1; + } + else if (absPDG < 3000) + { + if (pdg > 0) fCharge = 1; else fCharge = -1; + } + else + { + fCharge = 0; + return kFALSE; + } + + // flags and PID weights make no sense with MC tracks + fFlags = 0; + for (pdg = 0; pdg < AliRsnPID::kSpecies; pdg++) fPIDWeight[pdg] = 0.0; + fPIDWeight[AliRsnPID::InternalType(absPDG)] = 1.0; + + // copy other MC info (mother PDG code cannot be retrieved here) + InitMCInfo(particle); + + return kTRUE; } //_____________________________________________________________________________ @@ -439,41 +467,57 @@ void AliRsnDaughter::Print(Option_t *option) const // Index and label are printed by default. // - TString opt(option); - opt.ToUpper(); - - if (opt.Contains("L") || opt.Contains("ALL")) { - cout << ".......Index : " << fIndex << endl; - cout << ".......Label : " << fLabel << endl; - } - if (opt.Contains("P") || opt.Contains("ALL")) { - cout << ".......Px, Py, Pz, Pt : " << Px() << ' ' << Py() << ' ' << Pz() << ' ' << Pt() << endl; - } - if (opt.Contains("V") || opt.Contains("ALL")) { - cout << ".......Vx, Vy, Vz : " << Xv() << ' ' << Yv() << ' ' << Zv() << endl; - } - if (opt.Contains("C") || opt.Contains("ALL")) { - cout << ".......Charge : " << fCharge << endl; - } - if (opt.Contains("F") || opt.Contains("ALL")) { - cout << ".......Flags : " << fFlags << endl; - } - if (opt.Contains("W") || opt.Contains("ALL")) { - cout << ".......Weights : "; - Int_t i; - for (i = 0; i < AliRsnPID::kSpecies; i++) cout << fPIDWeight[i] << ' '; - cout << endl; + TString opt(option); + opt.ToUpper(); + + if (opt.Contains("L") || opt.Contains("ALL")) + { + cout << ".......Index : " << fIndex << endl; + cout << ".......Label : " << fLabel << endl; + } + if (opt.Contains("P") || opt.Contains("ALL")) + { + cout << ".......Px, Py, Pz, Pt : " << Px() << ' ' << Py() << ' ' << Pz() << ' ' << Pt() << endl; + } + if (opt.Contains("V") || opt.Contains("ALL")) + { + cout << ".......Vx, Vy, Vz : " << Xv() << ' ' << Yv() << ' ' << Zv() << endl; + } + if (opt.Contains("I") || opt.Contains("ALL")) + { + AliRsnPID::EType type; + Double_t prob; + type = PIDType(prob); + cout << ".......PID & prob : " << AliRsnPID::ParticleName(type) << ' ' << prob << endl; + } + if (opt.Contains("C") || opt.Contains("ALL")) + { + cout << ".......Charge : " << fCharge << endl; + } + if (opt.Contains("F") || opt.Contains("ALL")) + { + cout << ".......Flags : " << fFlags << endl; + } + if (opt.Contains("W") || opt.Contains("ALL")) + { + cout << ".......Weights : "; + Int_t i; + for (i = 0; i < AliRsnPID::kSpecies; i++) cout << fPIDWeight[i] << ' '; + cout << endl; + } + if (opt.Contains("M") || opt.Contains("ALL")) + { + if (fMCInfo) + { + cout << ".......PDG code : " << fMCInfo->PDG() << endl; + cout << ".......Mother (label) : " << fMCInfo->Mother() << endl; + cout << ".......Mother (PDG code): " << fMCInfo->MotherPDG() << endl; } - if (opt.Contains("M") || opt.Contains("ALL")) { - if (fMCInfo) { - cout << ".......PDG code : " << fMCInfo->PDG() << endl; - cout << ".......Mother (label) : " << fMCInfo->Mother() << endl; - cout << ".......Mother (PDG code): " << fMCInfo->MotherPDG() << endl; - } - else { - cout << ".......MC info not present" << endl; - } + else + { + cout << ".......MC info not present" << endl; } + } } //_____________________________________________________________________________ @@ -483,7 +527,7 @@ void AliRsnDaughter::InitMCInfo() // Initializes the particle object with default constructor. // - fMCInfo = new AliRsnMCInfo; + fMCInfo = new AliRsnMCInfo; } //_____________________________________________________________________________ @@ -499,18 +543,19 @@ Bool_t AliRsnDaughter::InitMCInfo(TParticle *particle) // otherwise returns kTRUE. // - // retrieve the TParticle object pointed by this MC track - if (!particle) { - AliError("Passed NULL particle object"); - return kFALSE; - } + // retrieve the TParticle object pointed by this MC track + if (!particle) + { + AliError("Passed NULL particle object"); + return kFALSE; + } - // initialize object if not initialized yet - if (fMCInfo) delete fMCInfo; - fMCInfo = new AliRsnMCInfo; - fMCInfo->Adopt(particle); + // initialize object if not initialized yet + if (fMCInfo) delete fMCInfo; + fMCInfo = new AliRsnMCInfo; + fMCInfo->Adopt(particle); - return kTRUE; + return kTRUE; } //_____________________________________________________________________________ @@ -526,9 +571,9 @@ Bool_t AliRsnDaughter::InitMCInfo(AliMCParticle *mcParticle) // otherwise returns kTRUE. // - // retrieve the TParticle object pointed by this MC track - TParticle *particle = mcParticle->Particle(); - return InitMCInfo(particle); + // retrieve the TParticle object pointed by this MC track + TParticle *particle = mcParticle->Particle(); + return InitMCInfo(particle); } //_____________________________________________________________________________ @@ -536,13 +581,77 @@ Int_t AliRsnDaughter::Compare(const TObject* obj) const { // // Compare two tracks with respect to their transverse momentum. -// Citation from ROOT reference: -// "Must return -1 if this is smaller than obj, 0 if objects are equal +// Citation from ROOT reference: +// "Must return -1 if this is smaller than obj, 0 if objects are equal // and 1 if this is larger than obj". // - AliRsnDaughter *that = (AliRsnDaughter*)obj; - if (Pt() < that->Pt()) return 1; - else if (Pt() > that->Pt()) return -1; - else return 0; + AliRsnDaughter *that = (AliRsnDaughter*)obj; + if (Pt() < that->Pt()) return 1; + else if (Pt() > that->Pt()) return -1; + else return 0; } + +//_____________________________________________________________________________ +void AliRsnDaughter::GetESDPID(AliESDtrack * track, Double_t * pid,EPIDType pidType, Double_t divValue, Double_t val) +{ +// +// return PID from EPIDType type +// + + Double_t ctmp[AliRsnPID::kSpecies]; + switch (pidType) + { + case kEsd : + track->GetESDpid(pid); + break; + case kITS : + track->GetITSpid(pid); + break; + case kTPC : + track->GetTPCpid(pid); + break; + case kTOF : + track->GetTOFpid(pid); + break; + case kITS_TPC : + track->GetITSpid(pid); + track->GetTPCpid(ctmp); + for (Int_t i=0;i<5;i++) pid[i]*=ctmp[i]; + break; + case kITS_TOF : + track->GetITSpid(pid); + track->GetTOFpid(ctmp); + for (Int_t i=0;iGetTPCpid(pid); + track->GetTOFpid(ctmp); + for (Int_t i=0;iGetITSpid(pid); + track->GetTPCpid(ctmp); + for (Int_t i=0;iGetTOFpid(ctmp); + for (Int_t i=0;iGetITSpid(pid); + track->GetTPCpid(ctmp); + for (Int_t i=0;iGetTOFpid(pid); + } + break; + default: +// AliWarning("Unrecognized value of EPIDType argument"); + for (Int_t i=0;iBypassStreamer (kFALSE); + fTracks = new TClonesArray("AliRsnDaughter", 1); + //fTracks->BypassStreamer (kFALSE); } //_____________________________________________________________________________ -void AliRsnEvent::Clear (Option_t* /*option*/) +void AliRsnEvent::Clear(Option_t* /*option*/) { // // Empties the collections (does not delete the objects). @@ -156,27 +159,27 @@ void AliRsnEvent::Clear (Option_t* /*option*/) // "if" statement are used. // - if (fTracks) fTracks->Delete(); - delete fNoPID; - fNoPID = 0x0; - delete fPerfectPID; - fPerfectPID = 0x0; - delete fRealisticPID; - fRealisticPID = 0x0; + if (fTracks) fTracks->Delete(); + delete fNoPID; + fNoPID = 0x0; + delete fPerfectPID; + fPerfectPID = 0x0; + delete fRealisticPID; + fRealisticPID = 0x0; } //_____________________________________________________________________________ -AliRsnDaughter* AliRsnEvent::AddTrack (AliRsnDaughter track) +AliRsnDaughter* AliRsnEvent::AddTrack(AliRsnDaughter track) { // // Stores a new track into the array and returns // a reference pointer to it (which is NULL in case of errors). // - Int_t nextIndex = fTracks->GetEntriesFast(); - TClonesArray &tracks = (*fTracks); - AliRsnDaughter *copy = new (tracks[nextIndex]) AliRsnDaughter (track); - return copy; + Int_t nextIndex = fTracks->GetEntriesFast(); + TClonesArray &tracks = (*fTracks); + AliRsnDaughter *copy = new(tracks[nextIndex]) AliRsnDaughter(track); + return copy; } //_____________________________________________________________________________ @@ -186,7 +189,7 @@ AliRsnDaughter* AliRsnEvent::GetTrack(Int_t index) // Returns one track in the collection // given the absolute index in the global TClonesArray // - return (AliRsnDaughter*) fTracks->UncheckedAt (index); + return (AliRsnDaughter*) fTracks->UncheckedAt(index); } //_____________________________________________________________________________ @@ -200,25 +203,28 @@ AliRsnDaughter* AliRsnEvent::GetLeadingParticle // If one specifies "AliRsnPID::kUnknown" as second arguments, the PID check is not done. // - Double_t prob; - AliRsnPID::EType trackType; - AliRsnDaughter *track, *leading = 0x0; - TObjArrayIter iter(fTracks); - while ( (track = (AliRsnDaughter*)iter.Next()) ) { - if (track->Pt() < ptMin) continue; - if (realistic) { - AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kRealistic); - } - else { - AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kPerfect); - } - trackType = track->PIDType(prob); - if (type != AliRsnPID::kUnknown && trackType != type) continue; - ptMin = track->Pt(); - leading = track; + Double_t prob; + AliRsnPID::EType trackType; + AliRsnDaughter *track, *leading = 0x0; + TObjArrayIter iter(fTracks); + while ((track = (AliRsnDaughter*) iter.Next())) + { + if (track->Pt() < ptMin) continue; + if (realistic) + { + AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kRealistic); } - - return leading; + else + { + AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kPerfect); + } + trackType = track->PIDType(prob); + if (type != AliRsnPID::kUnknown && trackType != type) continue; + ptMin = track->Pt(); + leading = track; + } + + return leading; } //_____________________________________________________________________________ @@ -232,35 +238,38 @@ Int_t AliRsnEvent::GetLastFastTrack // When no tracks are found this way, the value "-1" is returned. // - if (realistic) { - AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kRealistic); - } - else { - AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kPerfect); - } - - Double_t prob; - Int_t i, nTracks = fTracks->GetEntries(), lastIndex = -1; - for (i = 0; i < nTracks; i++) { - AliRsnDaughter *d = (AliRsnDaughter*)fTracks->At(i); - AliRsnPID::EType trackType = d->PIDType(prob); - if (type != AliRsnPID::kUnknown && trackType != type) continue; - if (d->Pt() >= ptMin) lastIndex = i; - } - - return lastIndex; + if (realistic) + { + AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kRealistic); + } + else + { + AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kPerfect); + } + + Double_t prob; + Int_t i, nTracks = fTracks->GetEntries(), lastIndex = -1; + for (i = 0; i < nTracks; i++) + { + AliRsnDaughter *d = (AliRsnDaughter*) fTracks->At(i); + AliRsnPID::EType trackType = d->PIDType(prob); + if (type != AliRsnPID::kUnknown && trackType != type) continue; + if (d->Pt() >= ptMin) lastIndex = i; + } + + return lastIndex; } //_____________________________________________________________________________ -TArrayI* AliRsnEvent::GetCharged (Char_t sign) +TArrayI* AliRsnEvent::GetCharged(Char_t sign) { // // Returns an array with the indexes of all tracks with a given charge // (arg can be '+' or '-'), irrespective of its PID. // When the argument is wrong, a NULL pointer is returned. // - if (fNoPID) return fNoPID->GetTracksArray(sign, AliRsnPID::kUnknown); - return 0x0; + if (fNoPID) return fNoPID->GetTracksArray(sign, AliRsnPID::kUnknown); + return 0x0; } //_____________________________________________________________________________ @@ -275,23 +284,31 @@ TArrayI * AliRsnEvent::GetTracksArray // If the arguments are wrong a NULL pointer is returned. // - switch (pidtype) { - case AliRsnDaughter::kRealistic: - if (fRealisticPID) { - return fRealisticPID->GetTracksArray (sign, type); - } - break; - case AliRsnDaughter::kPerfect: - if (fPerfectPID) { - return fPerfectPID->GetTracksArray (sign, type); - } - break; - default: - AliError ("Handled PID methods here are only kPerfect and kRealistic. Nothing done."); - return 0x0; - } - - return 0x0; + switch (pidtype) + { + case AliRsnDaughter::kRealistic: + if (fRealisticPID) + { + return fRealisticPID->GetTracksArray(sign, type); + } + break; + case AliRsnDaughter::kPerfect: + if (fPerfectPID) + { + return fPerfectPID->GetTracksArray(sign, type); + } + break; + case AliRsnDaughter::kNoPID: + if (fNoPID) + { + return fNoPID->GetTracksArray(sign, AliRsnPID::kUnknown); + } + break; + default: + AliError("Handled PID methods here are only fNoPID,kPerfect and kRealistic. Nothing done."); + return 0x0; + } + return 0x0; } //_____________________________________________________________________________ @@ -303,52 +320,55 @@ void AliRsnEvent::FillPIDArrays() // This method is the unique way to do this, for safety reasons. // - if (fNoPID) delete fNoPID; - if (fPerfectPID) delete fPerfectPID; - if (fRealisticPID) delete fRealisticPID; - fNoPID = new AliRsnPIDIndex; - fPerfectPID = new AliRsnPIDIndex; - fRealisticPID = new AliRsnPIDIndex; - - // set the default type to Realistic - AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kRealistic); - - // loop on tracks and create references - Double_t prob; - Int_t i, icharge, type; - Short_t charge; - AliRsnMCInfo *mcinfo = 0; - AliRsnDaughter *track = 0; - TObjArrayIter iter(fTracks); - while ( (track = (AliRsnDaughter*) iter.Next()) ) { - charge = track->Charge(); - type = (Int_t)track->PIDType(prob); - i = fTracks->IndexOf(track); - mcinfo = track->GetMCInfo(); - if (charge > 0) icharge = 0; - else if (charge < 0) icharge = 1; - else { - AliError("Found particle with ZERO charge!!!"); - continue; - } - // add to charged array - fNoPID->AddIndex(i, icharge, (Int_t)AliRsnPID::kUnknown); - // add to realistic PID array - fRealisticPID->AddIndex (i, icharge, (Int_t)type); - // add to perfect PID array (needs MCInfo present) - if (mcinfo) { - fPerfectPID->AddIndex (i, icharge, (Int_t)AliRsnPID::InternalType(mcinfo->PDG())); - } + if (fNoPID) delete fNoPID; + if (fPerfectPID) delete fPerfectPID; + if (fRealisticPID) delete fRealisticPID; + fNoPID = new AliRsnPIDIndex(2000); + fPerfectPID = new AliRsnPIDIndex(2000); + fRealisticPID = new AliRsnPIDIndex(2000); + + // set the default type to Realistic + AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kRealistic); + + // loop on tracks and create references + Double_t prob; + Int_t i, icharge, type; + Short_t charge; + AliRsnMCInfo *mcinfo = 0; + AliRsnDaughter *track = 0; + TObjArrayIter iter(fTracks); + while ((track = (AliRsnDaughter*) iter.Next())) + { + charge = track->Charge(); + type = (Int_t) track->PIDType(prob); + i = fTracks->IndexOf(track); + mcinfo = track->GetMCInfo(); + if (charge > 0) icharge = 0; + else if (charge < 0) icharge = 1; + else + { + AliError("Found particle with ZERO charge!!!"); + continue; + } + // add to charged array + fNoPID->AddIndex(i, icharge, (Int_t) AliRsnPID::kUnknown); + // add to realistic PID array + fRealisticPID->AddIndex(i, icharge, (Int_t) type); + // add to perfect PID array (needs MCInfo present) + if (mcinfo) + { + fPerfectPID->AddIndex(i, icharge, (Int_t) AliRsnPID::InternalType(mcinfo->PDG())); } + } - // adjusts the size of arrays - if (fNoPID) fNoPID->SetCorrectIndexSize(); - if (fPerfectPID) fPerfectPID->SetCorrectIndexSize(); - if (fRealisticPID) fRealisticPID->SetCorrectIndexSize(); + // adjusts the size of arrays + if (fNoPID) fNoPID->SetCorrectIndexSize(); + if (fPerfectPID) fPerfectPID->SetCorrectIndexSize(); + if (fRealisticPID) fRealisticPID->SetCorrectIndexSize(); } //_____________________________________________________________________________ -void AliRsnEvent::Print (Option_t *option) const +void AliRsnEvent::Print(Option_t *option) const { // // Lists the details of the event, and the ones of each @@ -357,14 +377,30 @@ void AliRsnEvent::Print (Option_t *option) const // Look at that method to understand option values. // - cout << "...Multiplicity : " << fTracks->GetEntries() << endl; - cout << "...Primary vertex : " << fPVx << ' ' << fPVy << ' ' << fPVz << endl; + cout << "...Multiplicity : " << fTracks->GetEntries() << endl; + cout << "...Primary vertex : " << fPVx << ' ' << fPVy << ' ' << fPVz << endl; + + TObjArrayIter iter(fTracks); + AliRsnDaughter *d = 0; + while ((d = (AliRsnDaughter*) iter.Next())) + { + cout << "....Track #" << fTracks->IndexOf(d) << endl; + d->Print(option); + } +} - TObjArrayIter iter (fTracks); +//_____________________________________________________________________________ +void AliRsnEvent::CorrectByPrimaryVertex() +{ +// +// Corrects the X,Y,Z position of DCA vertex of all tracks +// by the amount of stored primary vertex +// + + TObjArrayIter iter(fTracks); AliRsnDaughter *d = 0; while ((d = (AliRsnDaughter*) iter.Next())) { - cout << "....Track #" << fTracks->IndexOf (d) << endl; - d->Print (option); + d->ShiftZero(fPVx, fPVy, fPVz); } } @@ -375,27 +411,27 @@ Int_t AliRsnEvent::GetMultiplicity() const // Get number of all tracks // - if (!fTracks) return 0; - return fTracks->GetEntries(); + if (!fTracks) return 0; + return fTracks->GetEntries(); } //_____________________________________________________________________________ -Int_t AliRsnEvent::GetNCharged (Char_t sign) +Int_t AliRsnEvent::GetNCharged(Char_t sign) { // // Get number of charged tracks // - Int_t icharge; - icharge = ChargeIndex (sign); - if (icharge < 0) return 0; - TArrayI *charged = GetCharged(sign); - if (!charged) return 0; - return charged->GetSize(); + Int_t icharge; + icharge = ChargeIndex(sign); + if (icharge < 0) return 0; + TArrayI *charged = GetCharged(sign); + if (!charged) return 0; + return charged->GetSize(); } //_____________________________________________________________________________ -Int_t AliRsnEvent::Fill (TObjArray *array) +Int_t AliRsnEvent::Fill(TObjArray *array) { // // Fills the data-member TClonesArray of tracks with @@ -405,37 +441,40 @@ Int_t AliRsnEvent::Fill (TObjArray *array) // while attempting to add them. Zero is the best. // - // clear the array if it is already instantiated, - // create if otherwise - if (fTracks) fTracks->Delete(); - else Init(); - - // copy argument entries into data-member - Int_t errors = 0; - AliRsnDaughter *track = 0; - TObjArrayIter iter (array); - while ((track = (AliRsnDaughter*) iter.Next())) { - AliRsnDaughter *ref = AddTrack (*track); - if (!ref) { - AliWarning (Form ("Problem occurred when copying track #%d from passed array", array->IndexOf (track))); - errors++; - } + // clear the array if it is already instantiated, + // create if otherwise + if (fTracks) fTracks->Delete(); + else Init(); + + // copy argument entries into data-member + Int_t errors = 0; + AliRsnDaughter *track = 0; + TObjArrayIter iter(array); + while ((track = (AliRsnDaughter*) iter.Next())) + { + AliRsnDaughter *ref = AddTrack(*track); + if (!ref) + { + AliWarning(Form("Problem occurred when copying track #%d from passed array", array->IndexOf(track))); + errors++; } + } - return errors; + return errors; } //_____________________________________________________________________________ -Int_t AliRsnEvent::ChargeIndex (Char_t sign) const +Int_t AliRsnEvent::ChargeIndex(Char_t sign) const // // Returns the array index corresponding to charge // 0 for positive, 1 for negative // { - if (sign == '+') return 0; - else if (sign == '-') return 1; - else { - AliError (Form ("Character '%c' not recognized as charge sign", sign)); - return -1; - } + if (sign == '+') return 0; + else if (sign == '-') return 1; + else + { + AliError(Form("Character '%c' not recognized as charge sign", sign)); + return -1; + } } diff --git a/PWG2/RESONANCES/AliRsnEvent.h b/PWG2/RESONANCES/AliRsnEvent.h index 26e7c8f4077..651681e41c6 100644 --- a/PWG2/RESONANCES/AliRsnEvent.h +++ b/PWG2/RESONANCES/AliRsnEvent.h @@ -34,42 +34,43 @@ class AliRsnEvent : public TNamed public: AliRsnEvent(); - AliRsnEvent (const AliRsnEvent& copy); + AliRsnEvent(const AliRsnEvent& copy); AliRsnEvent& operator= (const AliRsnEvent& copy); virtual ~AliRsnEvent(); // Array management void Init(); - void Clear (Option_t *option = ""); - AliRsnDaughter* AddTrack (AliRsnDaughter track); - AliRsnDaughter* GetTrack (Int_t index); + void Clear(Option_t *option = ""); + AliRsnDaughter* AddTrack(AliRsnDaughter track); + AliRsnDaughter* GetTrack(Int_t index); AliRsnDaughter* GetLeadingParticle(Double_t ptMin = 0.0, AliRsnPID::EType type = AliRsnPID::kUnknown, Bool_t realistic = kTRUE); Int_t GetLastFastTrack(Double_t ptMin, AliRsnPID::EType type = AliRsnPID::kUnknown, Bool_t realistic = kTRUE); TClonesArray* GetTracks() {return fTracks;} - TArrayI* GetCharged (Char_t sign); - TArrayI* GetTracksArray (AliRsnDaughter::EPIDMethod method, Char_t sign, AliRsnPID::EType type); + TArrayI* GetCharged(Char_t sign); + TArrayI* GetTracksArray(AliRsnDaughter::EPIDMethod method, Char_t sign, AliRsnPID::EType type); void FillPIDArrays(); void SortTracks() {fTracks->Sort();} - void Print (Option_t *option = "") const; + void Print(Option_t *option = "") const; // Primary vertex Double_t GetPrimaryVertexX() const {return fPVx;} Double_t GetPrimaryVertexY() const {return fPVy;} Double_t GetPrimaryVertexZ() const {return fPVz;} - void GetPrimaryVertex (Double_t &x, Double_t &y, Double_t &z) const {x=fPVx;y=fPVy;z=fPVz;} - void SetPrimaryVertexX (Double_t value) {fPVx = value;} - void SetPrimaryVertexY (Double_t value) {fPVy = value;} - void SetPrimaryVertexZ (Double_t value) {fPVz = value;} - void SetPrimaryVertex (Double_t x, Double_t y, Double_t z) {fPVx=x;fPVy=y;fPVz=z;} + void GetPrimaryVertex(Double_t &x, Double_t &y, Double_t &z) const {x=fPVx;y=fPVy;z=fPVz;} + void SetPrimaryVertexX(Double_t value) {fPVx = value;} + void SetPrimaryVertexY(Double_t value) {fPVy = value;} + void SetPrimaryVertexZ(Double_t value) {fPVz = value;} + void SetPrimaryVertex(Double_t x, Double_t y, Double_t z) {fPVx=x;fPVy=y;fPVz=z;} + void CorrectByPrimaryVertex(); // Multiplicity Int_t GetMultiplicity() const; - Int_t GetNCharged (Char_t sign); + Int_t GetNCharged(Char_t sign); private: - Int_t ChargeIndex (Char_t sign) const; - Int_t Fill (TObjArray *array); + Int_t ChargeIndex(Char_t sign) const; + Int_t Fill(TObjArray *array); Double_t fPVx; // position of Double_t fPVy; // primary @@ -81,7 +82,7 @@ class AliRsnEvent : public TNamed AliRsnPIDIndex *fPerfectPID; // array index for perfect PID AliRsnPIDIndex *fRealisticPID; // array index for realistic PID (largest prob) - ClassDef (AliRsnEvent, 2); + ClassDef(AliRsnEvent, 2); }; #endif diff --git a/PWG2/RESONANCES/AliRsnEventBuffer.cxx b/PWG2/RESONANCES/AliRsnEventBuffer.cxx index 1abdf0792ee..9d18c0277c4 100644 --- a/PWG2/RESONANCES/AliRsnEventBuffer.cxx +++ b/PWG2/RESONANCES/AliRsnEventBuffer.cxx @@ -26,21 +26,21 @@ #include "AliLog.h" #include "AliRsnEventBuffer.h" -ClassImp (AliRsnEventBuffer) +ClassImp(AliRsnEventBuffer) //_____________________________________________________________________________ -AliRsnEventBuffer::AliRsnEventBuffer (Int_t buffSize, Bool_t deleteBufferWhenReset) : - fDeleteBufferWhenReset (deleteBufferWhenReset), - fEventsBufferSize (buffSize), - fEventsBufferIndex (-1) +AliRsnEventBuffer::AliRsnEventBuffer(Int_t buffSize, Bool_t deleteBufferWhenReset) : + fDeleteBufferWhenReset(deleteBufferWhenReset), + fEventsBufferSize(buffSize), + fEventsBufferIndex(-1) { // // Constructor. // Initializes to NULL all AliRsnEvent pointers. // - Int_t i; - for (i = 0; i < fEventsBufferSize; i++) fEventsBuffer[i] = 0; + Int_t i; + for (i = 0; i < fEventsBufferSize; i++) fEventsBuffer[i] = 0; } //_____________________________________________________________________________ @@ -51,7 +51,7 @@ AliRsnEventBuffer::~AliRsnEventBuffer() // Actually does nothing. // - //ClearBuffer(); + //ClearBuffer(); } //_____________________________________________________________________________ @@ -61,12 +61,13 @@ void AliRsnEventBuffer::ClearBuffer() // Clears buffer, resetting all pointers. // If an event is on the HEAP, it is deleted. // - Int_t i; - for (i = 0; i < fEventsBufferSize; i++) { - AliDebug(1, Form ("Clearing slot #%p in buffer", fEventsBuffer[i])); - if (fEventsBuffer[i]->IsOnHeap()) delete fEventsBuffer[i]; - fEventsBuffer[i] = 0; - } + Int_t i; + for (i = 0; i < fEventsBufferSize; i++) + { + AliDebug(1, Form("Clearing slot #%p in buffer", fEventsBuffer[i])); + if (fEventsBuffer[i]->IsOnHeap()) delete fEventsBuffer[i]; + fEventsBuffer[i] = 0; + } } //_____________________________________________________________________________ @@ -75,12 +76,12 @@ void AliRsnEventBuffer::ResetIndex() // // Resets the index for accessing events in buffer // - fEventsBufferIndex = -1; - if (fDeleteBufferWhenReset == kTRUE) ClearBuffer(); + fEventsBufferIndex = -1; + if (fDeleteBufferWhenReset == kTRUE) ClearBuffer(); } //_____________________________________________________________________________ -void AliRsnEventBuffer::AddEvent (AliRsnEvent * event) +void AliRsnEventBuffer::AddEvent(AliRsnEvent * event) { // // Insert a new event in the buffer. @@ -88,12 +89,12 @@ void AliRsnEventBuffer::AddEvent (AliRsnEvent * event) // the new event replaces the oldest one in the buffer // - if (fEventsBufferIndex >= fEventsBufferSize - 1) ResetIndex(); - fEventsBufferIndex++; - if (fEventsBuffer[fEventsBufferIndex]) - *fEventsBuffer[fEventsBufferIndex] = *event; - else - fEventsBuffer[fEventsBufferIndex] = new AliRsnEvent(*event); + if (fEventsBufferIndex >= fEventsBufferSize - 1) ResetIndex(); + fEventsBufferIndex++; + if (fEventsBuffer[fEventsBufferIndex]) + *fEventsBuffer[fEventsBufferIndex] = *event; + else + fEventsBuffer[fEventsBufferIndex] = new AliRsnEvent(*event); } //_____________________________________________________________________________ @@ -102,7 +103,7 @@ AliRsnEvent* AliRsnEventBuffer::GetCurrentEvent() // // Returns the current event in the buffer // - return GetEvent(fEventsBufferIndex); + return GetEvent(fEventsBufferIndex); } //_____________________________________________________________________________ @@ -111,21 +112,22 @@ AliRsnEvent * AliRsnEventBuffer::GetNextEvent() // // Returns next event in the buffer w.r. to current // - if (fEventsBufferIndex == fEventsBufferSize - 1) return GetEvent (0); - else return GetEvent (fEventsBufferIndex + 1); + if (fEventsBufferIndex == fEventsBufferSize - 1) return GetEvent(0); + else return GetEvent(fEventsBufferIndex + 1); } //_____________________________________________________________________________ -AliRsnEvent * AliRsnEventBuffer::GetEvent (Int_t index) +AliRsnEvent * AliRsnEventBuffer::GetEvent(Int_t index) { // // Returns an event in the buffer, provided its index // - if (index < 0 || index >= fEventsBufferSize) { - AliError(Form("Index out of range (index = %d , size = %d)", index, fEventsBufferSize)); - return 0x0; - } - return (AliRsnEvent*)fEventsBuffer[index]; + if (index < 0 || index >= fEventsBufferSize) + { + AliDebug(AliLog::kError,Form("Index out of range (index = %d , size = %d)", index, fEventsBufferSize)); + return 0x0; + } + return (AliRsnEvent*)fEventsBuffer[index]; } //_____________________________________________________________________________ @@ -134,10 +136,11 @@ Int_t AliRsnEventBuffer::NEmptySlots() // // Tells if the buffer is completely filled or has empty slots // - Int_t i, counter = 0; - for (i = 0; i < fEventsBufferSize; i++) { - if (!fEventsBuffer[i]) counter++; - } - - return counter; + Int_t i, counter = 0; + for (i = 0; i < fEventsBufferSize; i++) + { + if (!fEventsBuffer[i]) counter++; + } + + return counter; } diff --git a/PWG2/RESONANCES/AliRsnEventBuffer.h b/PWG2/RESONANCES/AliRsnEventBuffer.h index 69e4bb98f5b..e7493bba5c8 100644 --- a/PWG2/RESONANCES/AliRsnEventBuffer.h +++ b/PWG2/RESONANCES/AliRsnEventBuffer.h @@ -20,32 +20,32 @@ class AliRsnEventBuffer : public TObject { -public: + public: - AliRsnEventBuffer (Int_t buffsize = 1000, Bool_t deleteBufferWhenReset=kTRUE); + AliRsnEventBuffer(Int_t buffsize = 1000, Bool_t deleteBufferWhenReset=kTRUE); ~AliRsnEventBuffer(); void ClearBuffer(); void ResetIndex(); - void AddEvent (AliRsnEvent *event); - AliRsnEvent *GetEvent (Int_t index) ; - AliRsnEvent *GetCurrentEvent (); - AliRsnEvent *GetNextEvent (); + void AddEvent(AliRsnEvent *event); + AliRsnEvent *GetEvent(Int_t index) ; + AliRsnEvent *GetCurrentEvent(); + AliRsnEvent *GetNextEvent(); - void SetEventsBufferSize (const Int_t& theValue) { fEventsBufferSize = theValue; } + void SetEventsBufferSize(const Int_t& theValue) { fEventsBufferSize = theValue; } Int_t GetEventsBufferSize() const { return fEventsBufferSize; } Int_t GetEventsBufferIndex() const { return fEventsBufferIndex; } - void SetDeleteBufferWhenReset (const Bool_t& theValue = kTRUE) { fDeleteBufferWhenReset = theValue; } + void SetDeleteBufferWhenReset(const Bool_t& theValue = kTRUE) { fDeleteBufferWhenReset = theValue; } Bool_t GetDeleteBufferWhenReset() const { return fDeleteBufferWhenReset; } Int_t NEmptySlots(); private: - AliRsnEventBuffer (const AliRsnEventBuffer& buf) : - TObject(buf), fDeleteBufferWhenReset(0),fEventsBufferSize(0),fEventsBufferIndex(0) {} + AliRsnEventBuffer(const AliRsnEventBuffer& buf) : + TObject(buf), fDeleteBufferWhenReset(0),fEventsBufferSize(0),fEventsBufferIndex(0) {} const AliRsnEventBuffer& operator=(const AliRsnEventBuffer& /*buf*/) {return (*this);} Bool_t fDeleteBufferWhenReset; // flag if buffer should be deleted when reset is done @@ -53,7 +53,7 @@ public: Int_t fEventsBufferIndex; // current buffer index AliRsnEvent *fEventsBuffer[10000]; // array of events - ClassDef (AliRsnEventBuffer, 1) + ClassDef(AliRsnEventBuffer, 1) }; #endif diff --git a/PWG2/RESONANCES/AliRsnExpression.cxx b/PWG2/RESONANCES/AliRsnExpression.cxx index 68a3da896ad..5eefee5ded8 100644 --- a/PWG2/RESONANCES/AliRsnExpression.cxx +++ b/PWG2/RESONANCES/AliRsnExpression.cxx @@ -9,23 +9,23 @@ #include "AliRsnCutSet.h" #include "AliRsnExpression.h" -ClassImp ( AliRsnExpression ) +ClassImp(AliRsnExpression) AliRsnCutSet *AliRsnExpression::sCutSet = 0; //______________________________________________________________________________ -AliRsnExpression::AliRsnExpression ( TString exp ) : +AliRsnExpression::AliRsnExpression(TString exp) : TObject(), - fVname ( "" ), - fArg1 ( 0x0 ), - fArg2 ( 0x0 ), - fOperator ( 0 ) + fVname(""), + fArg1(0x0), + fArg2(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; @@ -38,25 +38,25 @@ AliRsnExpression::AliRsnExpression ( TString exp ) : //______________________________________________________________________________ AliRsnExpression::~AliRsnExpression() { - if ( fArg1 ) delete fArg1; - if ( fArg2 ) delete fArg2; + if (fArg1) delete fArg1; + if (fArg2) delete fArg2; } -AliRsnExpression::AliRsnExpression ( const AliRsnExpression & exp ) : TObject ( exp ), - fVname ( exp.fVname ), - fArg1 ( exp.fArg1 ), - fArg2 ( exp.fArg2 ), - fOperator ( exp.fOperator ) +AliRsnExpression::AliRsnExpression(const AliRsnExpression & exp) : TObject(exp), + fVname(exp.fVname), + fArg1(exp.fArg1), + fArg2(exp.fArg2), + fOperator(exp.fOperator) {} //______________________________________________________________________________ -AliRsnExpression& AliRsnExpression::operator= ( const AliRsnExpression& e ) +AliRsnExpression& AliRsnExpression::operator= (const AliRsnExpression& e) { // AliRsnExpression assignment operator. - if ( this != &e ) + if (this != &e) { - TObject::operator= ( e ); + TObject::operator= (e); fArg1 = e.fArg1; fArg2 = e.fArg2; fOperator = e.fOperator; @@ -66,61 +66,61 @@ AliRsnExpression& AliRsnExpression::operator= ( const AliRsnExpression& e ) } //______________________________________________________________________________ -AliRsnExpression::AliRsnExpression ( int op, AliRsnExpression* a, AliRsnExpression* b ) : +AliRsnExpression::AliRsnExpression(int op, AliRsnExpression* a, AliRsnExpression* b) : TObject(), - fVname ( "" ), - fArg1 ( a ), - fArg2 ( b ), - fOperator ( op ) + fVname(""), + fArg1(a), + fArg2(b), + fOperator(op) { // Create a new expression } //______________________________________________________________________________ -AliRsnExpression::AliRsnExpression ( int op, AliRsnExpression* a ) : +AliRsnExpression::AliRsnExpression(int op, AliRsnExpression* a) : TObject(), - fVname ( "" ), - fArg1 ( 0 ), - fArg2 ( a ), - fOperator ( op ) + fVname(""), + fArg1(0), + fArg2(a), + fOperator(op) { // Create a unary expression. } //______________________________________________________________________________ -Bool_t AliRsnExpression::Value ( TObjArray &vars ) +Bool_t AliRsnExpression::Value(TObjArray &vars) { // Evaluate the expression - if ( fArg2 == 0 && fVname.IsNull() ) + if (fArg2 == 0 && fVname.IsNull()) { - AliError ( "Expression undefined." ); + AliError("Expression undefined."); return kFALSE; } // AliDebug(AliLog::kDebug,Form("fOperator %d",fOperator)); - switch ( fOperator ) + switch (fOperator) { case kOpOR : - return fArg1->Value ( vars ) || fArg2->Value ( vars ); + return fArg1->Value(vars) || fArg2->Value(vars); case kOpAND : - return fArg1->Value ( vars ) && fArg2->Value ( vars ); + return fArg1->Value(vars) && fArg2->Value(vars); case kOpNOT : - return ! ( fArg2->Value ( vars ) ); + return !(fArg2->Value(vars)); case 0 : { // Int_t indexx = sCutSet->GetIndexByCutName ( fVname.Data() ); AliDebug(AliLog::kDebug,Form("Vname %s",fVname.Data())); // return sCutSet->GetBoolValue ( indexx ); - return sCutSet->GetBoolValue (fVname.Atoi()); + return sCutSet->GetBoolValue(fVname.Atoi()); } default: - AliError ( "Illegal operator in expression!" ); + AliError("Illegal operator in expression!"); } return kFALSE; @@ -133,15 +133,15 @@ TString AliRsnExpression::Unparse() const // Unparse the expression TString opVals[4] = { "", "&", "|","!" }; - if ( fArg2 == 0 && fVname.IsNull() ) + if (fArg2 == 0 && fVname.IsNull()) { - AliError ( "Expression undefined." ); + AliError("Expression undefined."); return "Error"; } - if ( fArg2 == 0 && !fVname.IsNull() ) return fVname; + if (fArg2 == 0 && !fVname.IsNull()) return fVname; - if ( fArg1 == 0 && fArg2 ) + if (fArg1 == 0 && fArg2) { return opVals[fOperator]+fArg2->Unparse(); } @@ -149,64 +149,64 @@ TString AliRsnExpression::Unparse() const } //______________________________________________________________________________ -TObjArray* AliRsnExpression::Tokenize ( TString str ) const +TObjArray* AliRsnExpression::Tokenize(TString str) const { // tokenize the expression // Remove spaces TString str1; - for ( Int_t i=0; iGetEntriesFast(); TString sumval; - for ( Int_t i=0; iAt ( i ); - sumval.Append ( val->String() ); + 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; iAt ( i ); - operators.Append ( val1->String() ); + TObjString* val1 = (TObjString*) optok->At(i); + operators.Append(val1->String()); } // add more room to be safe - TObjString* blank = new TObjString ( " " ); - operators.Append ( " " ); - valtok->AddLast ( blank ); + 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 ) + while (1) { TString so = operators[io]; - int indexO = str1.Index ( so, index ); - TString val2 = ( ( TObjString* ) valtok->At ( iv ) )->String(); - int indexV = str1.Index ( val2, index ); - if ( ( indexO < indexV || indexV < 0 ) && indexO >=0 ) + int indexO = str1.Index(so, index); + 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 ) ); + tokens->AddLast(new TObjString(so)); index += so.Length(); io++; } - if ( ( indexV < indexO || indexO < 0 ) && indexV >=0 ) + if ((indexV < indexO || indexO < 0) && indexV >=0) { - tokens->AddLast ( new TObjString ( val2 ) ); + tokens->AddLast(new TObjString(val2)); index += val2.Length(); iv++; } - if ( index >= str1.Length() ) break; + if (index >= str1.Length()) break; } // // Debug -> Print the tokens @@ -226,7 +226,7 @@ TObjArray* AliRsnExpression::Tokenize ( TString str ) const //______________________________________________________________________________ -AliRsnExpression* AliRsnExpression::Element ( TObjArray &st, Int_t &i ) +AliRsnExpression* AliRsnExpression::Element(TObjArray &st, Int_t &i) { // create an element @@ -236,50 +236,50 @@ AliRsnExpression* AliRsnExpression::Element ( TObjArray &st, Int_t &i ) TString token = "@"; TObjString* valt; // next token - if ( i < nt-1 ) + if (i < nt-1) { i++; - valt = ( TObjString* ) st.At ( i ); + valt = (TObjString*) st.At(i); token = valt->String(); } // token type - char ttok = ( token[0]!='|' && token[0]!='&' && - token[0]!='!' && token[0]!='('&& token[0]!=')' ) ? 'w' : token[0]; - switch ( ttok ) + char ttok = (token[0]!='|' && token[0]!='&' && + token[0]!='!' && token[0]!='('&& token[0]!=')') ? 'w' : token[0]; + switch (ttok) { case 'w' : { - result = new AliRsnVariableExpression ( token ); + result = new AliRsnVariableExpression(token); break; } case '(' : - result = Expression ( st, i ); + result = Expression(st, i); // next token - if ( i < nt-1 ) + if (i < nt-1) { i++; - valt = ( TObjString* ) st.At ( i ); + valt = (TObjString*) st.At(i); token = valt->String(); } - if ( token[0] != ')' ) + if (token[0] != ')') { // i--; // push back - AliErrorGeneral ( "AliRsnExpression::Element", "Mismatched parenthesis." ); + AliErrorGeneral("AliRsnExpression::Element", "Mismatched parenthesis."); delete result; result = new AliRsnExpression; } break; default: i--; // push back - AliErrorGeneral ( "AliRsnExpression::Element", Form ( "Unexpected symbol on input. %s", token.Data() ) ); - if ( result ) delete result; + AliErrorGeneral("AliRsnExpression::Element", Form("Unexpected symbol on input. %s", token.Data())); + if (result) delete result; result = new AliRsnExpression; } return result; } //______________________________________________________________________________ -AliRsnExpression* AliRsnExpression::Primary ( TObjArray &st, Int_t &i ) +AliRsnExpression* AliRsnExpression::Primary(TObjArray &st, Int_t &i) { // create a primary @@ -287,25 +287,25 @@ AliRsnExpression* AliRsnExpression::Primary ( TObjArray &st, Int_t &i ) TString token = "@"; TObjString* valt; // next token - if ( i < nt-1 ) + if (i < nt-1) { i++; - valt = ( TObjString* ) st.At ( i ); + valt = (TObjString*) st.At(i); token = valt->String(); } - switch ( token[0] ) + switch (token[0]) { case '!' : - return new AliRsnExpression ( kOpNOT, Primary ( st, i ) ); + return new AliRsnExpression(kOpNOT, Primary(st, i)); default: i--; // push back - return Element ( st, i ); + return Element(st, i); } } //______________________________________________________________________________ -AliRsnExpression* AliRsnExpression::Expression ( TObjArray &st,Int_t &i ) +AliRsnExpression* AliRsnExpression::Expression(TObjArray &st,Int_t &i) { // create an expression @@ -318,23 +318,23 @@ AliRsnExpression* AliRsnExpression::Expression ( TObjArray &st,Int_t &i ) stack++; Int_t nt = st.GetEntriesFast(); - result = Primary ( st, i ); + result = Primary(st, i); // cout <<"i "<Unparse() << endl; - while ( ! done ) + while (! done) { // next token - if ( i < nt-1 ) i++; + if (i < nt-1) i++; else break; - valt = ( TObjString* ) st.At ( i ); + valt = (TObjString*) st.At(i); token = valt->String(); - switch ( token[0] ) + switch (token[0]) { case '&' : - result = new AliRsnExpression ( kOpAND, result, Primary ( st, i ) ); + result = new AliRsnExpression(kOpAND, result, Primary(st, i)); // cout <<"i "<Unparse() << endl; break; case '|' : - result = new AliRsnExpression ( kOpOR, result, Primary ( st, i ) ); + result = new AliRsnExpression(kOpOR, result, Primary(st, i)); // cout <<"i "<Unparse() << endl; break; default: @@ -344,16 +344,16 @@ AliRsnExpression* AliRsnExpression::Expression ( TObjArray &st,Int_t &i ) } } stack--; - if ( stack == 0 && !token.IsNull() && token[0] == ')' ) + if (stack == 0 && !token.IsNull() && token[0] == ')') { - AliErrorGeneral ( "AliRsnExpression::Expression", "To many closing parenthesis." ); + AliErrorGeneral("AliRsnExpression::Expression", "To many closing parenthesis."); delete result; result = new AliRsnExpression; } else - if ( stack == 0 && i< nt-1 ) + if (stack == 0 && i< nt-1) { - AliErrorGeneral ( "AliRsnExpression::Expression", Form ( "Unexpected symbol on input. %s", token.Data() ) ); + AliErrorGeneral("AliRsnExpression::Expression", Form("Unexpected symbol on input. %s", token.Data())); delete result; result = new AliRsnExpression; } @@ -362,16 +362,16 @@ AliRsnExpression* AliRsnExpression::Expression ( TObjArray &st,Int_t &i ) //////////////////////////////////////////////////////////////////////////////// -ClassImp ( AliRsnVariableExpression ) +ClassImp(AliRsnVariableExpression) //______________________________________________________________________________ -Bool_t AliRsnVariableExpression::Value ( TObjArray& /*pgm*/) +Bool_t AliRsnVariableExpression::Value(TObjArray& /*pgm*/) { // Int_t indexx = sCutSet->GetIndexByCutName ( fVname.Data() ); AliDebug(AliLog::kDebug,Form("Vname %s",fVname.Data())); // return sCutSet->GetBoolValue ( indexx ); - return sCutSet->GetBoolValue ( fVname.Atoi() ); + return sCutSet->GetBoolValue(fVname.Atoi()); } diff --git a/PWG2/RESONANCES/AliRsnExpression.h b/PWG2/RESONANCES/AliRsnExpression.h index fb926727e80..c0796dc09fa 100644 --- a/PWG2/RESONANCES/AliRsnExpression.h +++ b/PWG2/RESONANCES/AliRsnExpression.h @@ -18,25 +18,25 @@ class AliRsnExpression : public TObject { public: - - // operators for complex cut expressions + + // operators for complex cut expressions enum ECutOp { - kOpAND=1, // AND '&' - kOpOR, // OR '|' - kOpNOT // Unary negation '!' + kOpAND=1, // AND '&' + kOpOR, // OR '|' + kOpNOT // Unary negation '!' }; - - AliRsnExpression() : fVname ( 0 ), fArg1 ( 0 ), fArg2 ( 0 ), fOperator ( 0 ) {} - AliRsnExpression ( TString exp ); + + 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* theValue ) { sCutSet = theValue; } + void SetCutSet(AliRsnCutSet* theValue) { sCutSet = theValue; } AliRsnCutSet* GetCutSet() const { return sCutSet; } @@ -48,15 +48,15 @@ class AliRsnExpression : public TObject 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 + ClassDef(AliRsnExpression, 1); // Class to evaluate an expression }; @@ -65,12 +65,12 @@ class AliRsnExpression : public TObject class AliRsnVariableExpression: public AliRsnExpression { public: - AliRsnVariableExpression ( TString a) : AliRsnExpression() { fVname = a; }; + 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 + ClassDef(AliRsnVariableExpression, 1); // Class to define a variable expression }; #endif diff --git a/PWG2/RESONANCES/AliRsnHistoDef.cxx b/PWG2/RESONANCES/AliRsnHistoDef.cxx index d87f7e7be3d..431f397b4ba 100644 --- a/PWG2/RESONANCES/AliRsnHistoDef.cxx +++ b/PWG2/RESONANCES/AliRsnHistoDef.cxx @@ -10,17 +10,17 @@ // #include -#include #include "AliLog.h" - #include "AliRsnHistoDef.h" ClassImp(AliRsnHistoDef) //_____________________________________________________________________________ AliRsnHistoDef::AliRsnHistoDef() : - fNDim(0) + fNBins(0), + fMin(0.0), + fMax(0.0) { // // Default constructor @@ -30,59 +30,25 @@ AliRsnHistoDef::AliRsnHistoDef() : //_____________________________________________________________________________ AliRsnHistoDef::AliRsnHistoDef (Int_t nbins, Double_t min, Double_t max) : - fNDim(1) + fNBins(0), + fMin(0.0), + fMax(0.0) { // // 1D histo definition. // - SetBins(nbins, min, max); } -//_____________________________________________________________________________ -AliRsnHistoDef::AliRsnHistoDef -(Int_t nbinsX, Double_t minX, Double_t maxX, Int_t nbinsY, Double_t minY, Double_t maxY): - fNDim(2) -{ -// -// 1D histo definition. -// - - SetBins(nbinsX, minX, maxX, nbinsY, minY, maxY); -} //_____________________________________________________________________________ void AliRsnHistoDef::SetBins(Int_t n, Double_t min, Double_t max) { // -// Binning for 1D histograms. -// - - fNDim = 1; - - fNBins[0] = n; - fMin[0] = min; - fMax[0] = max; - - CheckEdges(); -} - -//_____________________________________________________________________________ -void AliRsnHistoDef::SetBins -(Int_t nx, Double_t minx, Double_t maxx, Int_t ny, Double_t miny, Double_t maxy) -{ -// -// Binning for 1D histograms. +// Binning for histogram. // - - fNDim = 2; - - fNBins[0] = nx; - fMin[0] = minx; - fMax[0] = maxx; - - fNBins[1] = ny; - fMin[1] = miny; - fMax[1] = maxy; + fNBins = n; + fMin = min; + fMax = max; CheckEdges(); } @@ -95,45 +61,21 @@ void AliRsnHistoDef::CheckEdges() // otherwise swaps them. // - Int_t i; - for (i = 0; i < fNDim; i++) { - if (fMin[i] > fMax[i]) { - AliWarning(Form("min = %f -- max = %f --> swapping", fMin, fMax)); - Double_t temp = fMin[i]; - fMin[i] = fMax[i]; - fMax[i] = temp; - } - } -} - -//_____________________________________________________________________________ -TH1D* AliRsnHistoDef::Create1DHistogram(const char *name, const char *title) -{ -// -// Create 1D histogram, if the configuration is appropriate for this. -// - - if (fNDim != 1) { - AliError("Number of dimension not set to 1!"); - return 0x0; + if (fMin > fMax) { + AliWarning(Form("min = %f -- max = %f --> swapping", fMin, fMax)); + Double_t temp = fMin; + fMin = fMax; + fMax = temp; } - - TH1D *histo = new TH1D(name, title, fNBins[0], fMin[0], fMax[0]); - return histo; } //_____________________________________________________________________________ -TH2D* AliRsnHistoDef::Create2DHistogram(const char *name, const char *title) +TH1D* AliRsnHistoDef::CreateHistogram(const char *name, const char *title) { // -// Create 2D histogram, if the configuration is appropriate for this. +// Create a histogram with given name and title, +// whose binning is specified according to this class members. // - - if (fNDim != 2) { - AliError("Number of dimension not set to 2!"); - return 0x0; - } - - TH2D *histo = new TH2D(name, title, fNBins[0], fMin[0], fMax[0], fNBins[1], fMin[1], fMax[1]); + TH1D *histo = new TH1D(name, title, fNBins, fMin, fMax); return histo; } diff --git a/PWG2/RESONANCES/AliRsnHistoDef.h b/PWG2/RESONANCES/AliRsnHistoDef.h index 5cd6cbbc30b..bd1b9e41f32 100644 --- a/PWG2/RESONANCES/AliRsnHistoDef.h +++ b/PWG2/RESONANCES/AliRsnHistoDef.h @@ -1,50 +1,40 @@ // // Class AliRsnHistoDef // -// Definition for a histogram type. -// Since one could do an analysis which is not an invariant mass -// the histogram definition should be more flexible, and it is stored -// separately in a new class. -// This class considers the possibility of a 1D or 2D histograms -// with its related binning, and can create a new histo from his definitions +// Histogram definition. +// Contains required informations to create a histogram +// with fixed bin size: number of bins, minimum and maximum. +// Variable bin sizes are not considered because they are +// not used as typical output of analysis in this package. // -#ifndef AliRsnHistoDef_H -#define AliRsnHistoDef_H +#ifndef ALIRSNHISTODEF_H +#define ALIRSNHISTODEF_H -class TH1; class TH1D; -class TH2D; class AliRsnHistoDef : public TObject { -public: + public: AliRsnHistoDef(); AliRsnHistoDef(Int_t n, Double_t min, Double_t max); - AliRsnHistoDef(Int_t nX, Double_t minX, Double_t maxX, Int_t nY, Double_t minY, Double_t maxY); virtual ~AliRsnHistoDef() { } - Int_t GetNDimensions() const {return fNDim;} - Int_t GetNBins(Int_t axis=0) const {return (axis==0)?fNBins[0]:fNBins[1];} - Double_t GetMin(Int_t axis=0) const {return (axis==0)?fMin[0]:fMin[1];} - Double_t GetMax(Int_t axis=0) const {return (axis==0)?fMax[0]:fMax[1];} + Int_t GetNBins() const {return fNBins;} + Double_t GetMin() const {return fMin;} + Double_t GetMax() const {return fMax;} void SetBins(Int_t n, Double_t min, Double_t max); - void SetBins(Int_t nX, Double_t minX, Double_t maxX, Int_t nY, Double_t minY, Double_t maxY); + TH1D* CreateHistogram(const char *name, const char *title); + void CheckEdges(); - TH1D* Create1DHistogram(const char *name, const char *title); - TH2D* Create2DHistogram(const char *name, const char *title); + private: -private: + Int_t fNBins; // number of bins + Double_t fMin; // lower edge + Double_t fMax; // upper edge - void CheckEdges(); - - Int_t fNDim; // number of dimensions - Int_t fNBins[2]; // number of bins - Double_t fMin[2]; // lower edge - Double_t fMax[2]; // upper edge - // ROOT dictionary ClassDef(AliRsnHistoDef, 1) }; diff --git a/PWG2/RESONANCES/AliRsnMCInfo.cxx b/PWG2/RESONANCES/AliRsnMCInfo.cxx index 5781539d51a..de84229bb01 100644 --- a/PWG2/RESONANCES/AliRsnMCInfo.cxx +++ b/PWG2/RESONANCES/AliRsnMCInfo.cxx @@ -2,36 +2,36 @@ #include "AliRsnMCInfo.h" -ClassImp ( AliRsnMCInfo ) +ClassImp(AliRsnMCInfo) //_____________________________________________________________________________ AliRsnMCInfo::AliRsnMCInfo() : TObject(), - fEnergy ( 0 ), - fPDG ( 0 ), - fMother ( -1 ), - fMotherPDG ( 0 ) + fEnergy(0), + fPDG(0), + fMother(-1), + fMotherPDG(0) { // // Default constructor. // Initializes all data-members with meaningless values. // - for ( Int_t i = 0; i < 3; i++ ) fP[i] = 0.0; + for (Int_t i = 0; i < 3; i++) fP[i] = 0.0; } //_____________________________________________________________________________ -AliRsnMCInfo::AliRsnMCInfo ( const AliRsnMCInfo & copy ) : TObject ( copy ), - fEnergy ( copy.fEnergy ), - fPDG ( copy.fPDG ), - fMother ( copy.fMother ), - fMotherPDG ( copy.fMotherPDG ) +AliRsnMCInfo::AliRsnMCInfo(const AliRsnMCInfo & copy) : TObject(copy), + fEnergy(copy.fEnergy), + fPDG(copy.fPDG), + fMother(copy.fMother), + fMotherPDG(copy.fMotherPDG) { // // Copy constructor. // Initializes all data-members with meaningless values. // - - for ( Int_t i = 0; i < 3; i++ ) fP[i] = copy.fP[i]; - + + for (Int_t i = 0; i < 3; i++) fP[i] = copy.fP[i]; + } //_____________________________________________________________________________ @@ -40,7 +40,7 @@ AliRsnMCInfo::~AliRsnMCInfo() } //_____________________________________________________________________________ -void AliRsnMCInfo::Adopt ( TParticle * particle ) +void AliRsnMCInfo::Adopt(TParticle * particle) { // // Copies data from a TParticle into "this": @@ -50,18 +50,19 @@ void AliRsnMCInfo::Adopt ( TParticle * particle ) // is given by the method. // - if (!particle) { - AliError ( "NULL argument passed. Nothing done." ); - return; - } - - fP[0] = particle->Px(); - fP[1] = particle->Py(); - fP[2] = particle->Pz(); - - fEnergy = particle->Energy(); - - fPDG = particle->GetPdgCode(); - fMother = particle->GetFirstMother(); - fMotherPDG = ( Short_t ) 0; + if (!particle) + { + AliError("NULL argument passed. Nothing done."); + return; + } + + fP[0] = particle->Px(); + fP[1] = particle->Py(); + fP[2] = particle->Pz(); + + fEnergy = particle->Energy(); + + fPDG = particle->GetPdgCode(); + fMother = particle->GetFirstMother(); + fMotherPDG = (Short_t) 0; } diff --git a/PWG2/RESONANCES/AliRsnMCInfo.h b/PWG2/RESONANCES/AliRsnMCInfo.h index 556613cf06d..b70eca5176a 100644 --- a/PWG2/RESONANCES/AliRsnMCInfo.h +++ b/PWG2/RESONANCES/AliRsnMCInfo.h @@ -7,39 +7,45 @@ class AliRsnMCInfo : public TObject { -public: + public: AliRsnMCInfo(); - AliRsnMCInfo ( const AliRsnMCInfo © ); + AliRsnMCInfo(const AliRsnMCInfo ©); ~AliRsnMCInfo(); - void Adopt ( TParticle *part ); + void Adopt(TParticle *part); // 4-momentum virtual Double_t E() const {return fEnergy;} virtual Double_t E(Double_t mass) {return TMath::Sqrt(mass*mass + P2());} - virtual Double_t M() const {return TMath::Sqrt (fEnergy*fEnergy - P2());} + virtual Double_t M() const {return TMath::Sqrt(fEnergy*fEnergy - P2());} virtual Double_t P2() const {return Px()*Px() + Py()*Py() + Pz()*Pz();} - virtual Double_t P() const {return TMath::Sqrt ( P2() );} + virtual Double_t P() const {return TMath::Sqrt(P2());} virtual Double_t Px() const {return fP[0];} virtual Double_t Py() const {return fP[1];} virtual Double_t Pz() const {return fP[2];} - virtual Double_t Pt() const {return TMath::Sqrt ( Px() *Px() + Py() *Py() );} + virtual Double_t Pt() const {return TMath::Sqrt(Px() *Px() + Py() *Py());} virtual Double_t OneOverPt() const {return 1.0 / Pt();} - virtual Bool_t PxPyPz ( Double_t p[3] ) const {p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE;} - void SetPx ( Double_t value ) {fP[0] = value;} - void SetPy ( Double_t value ) {fP[1] = value;} - void SetPz ( Double_t value ) {fP[2] = value;} - void SetP ( Double_t px, Double_t py, Double_t pz ) {SetPx ( px ); SetPy ( py ); SetPz ( pz );} - void SetE ( Double_t e ) {fEnergy = e;} + virtual Bool_t PxPyPz(Double_t p[3]) const {p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE;} + + virtual Double_t Phi() const {return TMath::ATan2(Py(), Px());} + virtual Double_t Theta() const {return TMath::ATan2(Pt(), Pz());} + virtual Double_t Eta() const {return -TMath::Log(TMath::Tan(0.5*Theta()));} + virtual Double_t Y() const {return TMath::Log((E() + Pz()) / (E() - Pz()));} + + void SetPx(Double_t value) {fP[0] = value;} + void SetPy(Double_t value) {fP[1] = value;} + void SetPz(Double_t value) {fP[2] = value;} + void SetP(Double_t px, Double_t py, Double_t pz) {SetPx(px); SetPy(py); SetPz(pz);} + void SetE(Double_t e) {fEnergy = e;} Int_t PDG() const {return fPDG;} Int_t Mother() const {return fMother;} Short_t MotherPDG() const {return fMotherPDG;} - void SetPDG ( Int_t pdg ) {fPDG = pdg;} - void SetMother ( Int_t mlabel ) {fMother = mlabel;} - void SetMotherPDG ( Int_t pdg ) {fMotherPDG = ( Short_t ) pdg;} + void SetPDG(Int_t pdg) {fPDG = pdg;} + void SetMother(Int_t mlabel) {fMother = mlabel;} + void SetMotherPDG(Int_t pdg) {fMotherPDG = (Short_t) pdg;} -private: + private: Double_t fP[3]; // MC momentum Double_t fEnergy; // MC energy @@ -47,7 +53,7 @@ private: Int_t fMother; // GEANT label of mother particle Short_t fMotherPDG; // PDG code of mother particle - ClassDef ( AliRsnMCInfo,1 ); + ClassDef(AliRsnMCInfo,1) }; #endif diff --git a/PWG2/RESONANCES/AliRsnPID.cxx b/PWG2/RESONANCES/AliRsnPID.cxx index 0d6f901ecdd..2e53130cb80 100644 --- a/PWG2/RESONANCES/AliRsnPID.cxx +++ b/PWG2/RESONANCES/AliRsnPID.cxx @@ -34,175 +34,198 @@ #include "AliRsnPID.h" -ClassImp(AliRsnPID) +ClassImp ( AliRsnPID ) -const Double_t AliRsnPID::fgkParticleMass[AliRsnPID::kSpecies + 1] = + const Double_t AliRsnPID::fgkParticleMass[AliRsnPID::kSpeciesAll + 1] = { 0.00051099892, // electron 0.105658369, // muon 0.13957018, // pion 0.493677, // kaon 0.93827203, // proton - 0.0 // nothing + 0.0, // nothing + 1.019413, // phi + 3.09693 // jpsi }; -const char* AliRsnPID::fgkParticleNameLong[AliRsnPID::kSpecies + 1] = +const char* AliRsnPID::fgkParticleNameLong[AliRsnPID::kSpeciesAll + 1] = { "electron", "muon", "pion", "kaon", "proton", - "unknown" + "unknown", + "phi", + "jpsi" }; -const char* AliRsnPID::fgkParticleNameShort[AliRsnPID::kSpecies + 1] = +const char* AliRsnPID::fgkParticleNameShort[AliRsnPID::kSpeciesAll + 1] = { "e", "mu", "pi", "K", "p", - "unk" + "unk", + "phi", + "jpsi" }; -const char* AliRsnPID::fgkParticleNameLatex[AliRsnPID::kSpecies + 1] = +const char* AliRsnPID::fgkParticleNameLatex[AliRsnPID::kSpeciesAll + 1] = { "e", "#mu", "#pi", "K", "p", - "?" + "?", + "#phi", + "J/#psi" }; -const Int_t AliRsnPID::fgkParticlePDG[AliRsnPID::kSpecies + 1] = +const Int_t AliRsnPID::fgkParticlePDG[AliRsnPID::kSpeciesAll + 1] = { - 11, - 13, - 211, - 321, - 2212, - 0 + 11, + 13, + 211, + 321, + 2212, + 0, + 333, + 443 }; //_____________________________________________________________________________ AliRsnPID::AliRsnPID() : - TNamed("RsnPID", ""), - fMaxPt(100.0), - fMinProb(0.0) + TNamed ( "RsnPID", "" ), + fMaxPt ( 100.0 ), + fMinProb ( 0.0 ) { // // Constructor. // Adds also the object in the default directory of the session. // - Int_t i; - for (i = 0; i < kSpecies; i++) fPrior[i] = 0.0; - - gDirectory->Append(this, kTRUE); + Int_t i; + for ( i = 0; i < kSpecies; i++ ) fPrior[i] = 0.0; + +// gDirectory->Append(this, kTRUE); } //_____________________________________________________________________________ -AliRsnPID::EType AliRsnPID::InternalType(Int_t pdg) +AliRsnPID::EType AliRsnPID::InternalType ( Int_t pdg ) // // Return the internal enum value corresponding to the PDG // code passed as argument, if possible. // Otherwise, returns 'kUnknown' by default. // { - EType value; - Int_t absPDG = TMath::Abs(pdg); - - switch (absPDG) { - case 11: - value = kElectron; - break; - case 13: - value = kMuon; - break; - case 211: - value = kPion; - break; - case 321: - value = kKaon; - break; - case 2212: - value = kProton; - break; - default: - value = kUnknown; - } - return value; + EType value; + Int_t absPDG = TMath::Abs ( pdg ); + + switch ( absPDG ) + { + case 11: + value = kElectron; + break; + case 13: + value = kMuon; + break; + case 211: + value = kPion; + break; + case 321: + value = kKaon; + break; + case 2212: + value = kProton; + break; + case 333: + value = kPhi; + break; + case 443: + value = kJPsi; + break; + default: + value = kUnknown; + } + return value; } //_____________________________________________________________________________ -Int_t AliRsnPID::PDGCode(EType type) +Int_t AliRsnPID::PDGCode ( EType type ) { // // Returns the PDG code of the particle type // specified as argument (w.r. to the internal enum) // - if (type >= kElectron && type <= kUnknown) { - return fgkParticlePDG[type]; - } - else { - return 0; - } + if ( type >= kElectron && type <= kUnknown ) + { + return fgkParticlePDG[type]; + } + else + { + return 0; + } } //_____________________________________________________________________________ -const char* AliRsnPID::ParticleName(EType type, Bool_t shortName) +const char* AliRsnPID::ParticleName ( EType type, Bool_t shortName ) { // // Returns the name of the particle type // specified as argument (w.r. to the internal enum) // - if (type >= kElectron && type <= kUnknown) { - return shortName ? fgkParticleNameShort[type] : fgkParticleNameLong[type]; - } - else { - return shortName ? "unk" : "unknown"; - } + if ( type >= kElectron && type <= kSpeciesAll ) + { + return shortName ? fgkParticleNameShort[type] : fgkParticleNameLong[type]; + } + else + { + return shortName ? "unk" : "unknown"; + } } //_____________________________________________________________________________ -const char* AliRsnPID::ParticleNameLatex(EType type) +const char* AliRsnPID::ParticleNameLatex ( EType type ) { // // Returns the name of the particle type // specified as argument (w.r. to the internal enum) // - if (type >= kElectron && type <= kUnknown) { - return fgkParticleNameLatex[type]; - } - else { - return "?"; - } + if ( type >= kElectron && type <= kSpeciesAll ) + { + return fgkParticleNameLatex[type]; + } + else + { + return "?"; + } } //_____________________________________________________________________________ -Double_t AliRsnPID::ParticleMass(EType type) +Double_t AliRsnPID::ParticleMass ( EType type ) { // // Returns the mass corresponding to the particle type // specified as argument (w.r. to the internal enum) // - /* - TDatabasePDG *db = TDatabasePDG::Instance(); - Int_t pdg = PDGCode(type); - return db->GetParticle(pdg)->Mass(); - */ - if (type >= kElectron && type < kSpecies) return fgkParticleMass[type]; - return 0.0; + /* + TDatabasePDG *db = TDatabasePDG::Instance(); + Int_t pdg = PDGCode(type); + return db->GetParticle(pdg)->Mass(); + */ + if ( type >= kElectron && type < kSpeciesAll ) return fgkParticleMass[type]; + return 0.0; } //_____________________________________________________________________________ -Bool_t AliRsnPID::ComputeProbs(AliRsnDaughter *daughter) +Bool_t AliRsnPID::ComputeProbs ( AliRsnDaughter *daughter ) { // // Uses the Bayesian combination of prior probabilities @@ -220,32 +243,41 @@ Bool_t AliRsnPID::ComputeProbs(AliRsnDaughter *daughter) // the return value will be "FALSE", otherwise it is "TRUE". // - // reset all PID probabilities to 0.0 - Int_t i; - for (i = 0; i < kSpecies; i++) daughter->SetPIDProb(i, 1.0 / (Double_t)kSpecies); - - // multiply weights and priors - Double_t sum = 0.0, prob[kSpecies]; - for (i = 0; i < kSpecies; i++) { - prob[i] = fPrior[i] * daughter->PID()[i]; - sum += prob[i]; - } - if (sum <= (Double_t)0.) { - AliError(Form("Sum of weights = %f <= 0", sum)); - return kFALSE; - } - - // normalize - for (i = 0; i < kSpecies; i++) { - prob[i] /= sum; - daughter->SetPIDProb(i, prob[i]); - } - - return kTRUE; + // reset all PID probabilities to 0.0 + Int_t i; + for ( i = 0; i < kSpecies; i++ ) daughter->SetPIDProb ( i, 1.0 / ( Double_t ) kSpecies ); + + // multiply weights and priors + Double_t sum = 0.0, prob[kSpecies]; + for ( i = 0; i < kSpecies; i++ ) + { + prob[i] = fPrior[i] * daughter->PID() [i]; + sum += prob[i]; + } + if ( sum <= ( Double_t ) 0. ) + { + AliError ( Form ( "Sum of weights = %f <= 0", sum ) ); + return kFALSE; + } + + // normalize + for ( i = 0; i < kSpecies; i++ ) + { + prob[i] /= sum; + daughter->SetPIDProb ( i, prob[i] ); + } + + daughter->AssignRealisticPID(); + Double_t assprob; + AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kRealistic); + AliRsnPID::EType type = daughter->PIDType(assprob); + AliDebug(5, Form("Assigned PID: %s [%.2f %]", AliRsnPID::ParticleName(type), assprob*100.)); + + return kTRUE; } //_____________________________________________________________________________ -Bool_t AliRsnPID::IdentifiedAs(AliRsnDaughter *d, EType type, Short_t charge) +Bool_t AliRsnPID::IdentifiedAs ( AliRsnDaughter *d, EType type, Short_t charge ) { // // Tells if a particle has can be identified to be of a given tipe and charge. @@ -256,71 +288,76 @@ Bool_t AliRsnPID::IdentifiedAs(AliRsnDaughter *d, EType type, Short_t charge) // is kFALSE even when the type and charge are matched. // - EType dType = TrackType(d); - if (dType != type) return kFALSE; - if (charge == 0) { - return kTRUE; - } - else if (charge > 0) { - return (d->Charge() > 0); - } - else { - return (d->Charge() < 0); - } + EType dType = TrackType ( d ); + if ( dType != type ) return kFALSE; + if ( charge == 0 ) + { + return kTRUE; + } + else if ( charge > 0 ) + { + return ( d->Charge() > 0 ); + } + else + { + return ( d->Charge() < 0 ); + } } //_____________________________________________________________________________ -AliRsnPID::EType AliRsnPID::TrackType(AliRsnDaughter *d) +AliRsnPID::EType AliRsnPID::TrackType ( AliRsnDaughter *d ) { // // Returns the track type according to the object settings // and to the static settings in the AliRsnDaughter object. // - Double_t prob; - EType type = d->PIDType(prob); - - if (d->Pt() > fMaxPt) return kUnknown; - if (prob < fMinProb) return kUnknown; - - return type; + Double_t prob; + EType type = d->PIDType ( prob ); + + if ( d->Pt() > fMaxPt ) return kUnknown; + if ( prob < fMinProb ) return kUnknown; + + return type; } //_____________________________________________________________________________ -Bool_t AliRsnPID::Process(AliRsnEvent *event) +Bool_t AliRsnPID::Process ( AliRsnEvent *event ) { // // Performs identification for all tracks in a given event. // Returns the logical AND of all PID operations. // - Bool_t check = kTRUE; - if (!event) return check; - if (!event->GetTracks()) return check; - if (event->GetTracks()->IsEmpty()) return check; + Bool_t check = kTRUE; + if ( !event ) return check; + if ( !event->GetTracks() ) return check; + if ( event->GetTracks()->IsEmpty() ) return check; - AliRsnDaughter *daughter = 0; - TObjArrayIter iter(event->GetTracks()); - while ( (daughter = (AliRsnDaughter*)iter.Next()) ) { - check = check && ComputeProbs(daughter); - } - event->FillPIDArrays(); + AliRsnDaughter *daughter = 0; + TObjArrayIter iter ( event->GetTracks() ); + while ( ( daughter = ( AliRsnDaughter* ) iter.Next() ) ) + { + check = check && ComputeProbs ( daughter ); + } + event->FillPIDArrays(); - return check; + return check; } //_____________________________________________________________________________ -void AliRsnPID::SetPriorProbability(EType type, Double_t p) +void AliRsnPID::SetPriorProbability ( EType type, Double_t p ) { // // Sets the prior probability for Realistic PID, for a // given particle species. // - if (type >= kElectron && type < kSpecies) { - fPrior[type] = p; - } + if ( type >= kElectron && type < kSpecies ) + { + fPrior[type] = p; + } } //_____________________________________________________________________________ @@ -330,11 +367,12 @@ void AliRsnPID::DumpPriors() // Print all prior probabilities // - Int_t i; - Char_t msg[200]; - - for (i = 0; i < kSpecies; i++) { - sprintf(msg, "Prior probability for '%s' = %3.5f", fgkParticleNameLong[i], fPrior[i]); - AliInfo(msg); - } + Int_t i; + Char_t msg[200]; + + for ( i = 0; i < kSpecies; i++ ) + { + sprintf ( msg, "Prior probability for '%s' = %3.5f", fgkParticleNameLong[i], fPrior[i] ); + AliInfo ( msg ); + } } diff --git a/PWG2/RESONANCES/AliRsnPID.h b/PWG2/RESONANCES/AliRsnPID.h index 1e160176249..41e64fd25af 100644 --- a/PWG2/RESONANCES/AliRsnPID.h +++ b/PWG2/RESONANCES/AliRsnPID.h @@ -22,17 +22,21 @@ class AliRsnEvent; class AliRsnPID : public TNamed { -public: + public: // types enum - enum EType { - kElectron = 0, - kMuon, - kPion, - kKaon, - kProton, - kUnknown, - kSpecies = 5 + enum EType + { + kElectron = 0, + kMuon, + kPion, + kKaon, + kProton, + kUnknown, + kSpecies = 5, + kPhi=6, + kJPsi, + kSpeciesAll = 8 }; AliRsnPID(); @@ -40,7 +44,7 @@ public: // conversions from PDG code to local type static EType InternalType(Int_t pdgCode); - + // retrieve particle informations from internal type static Int_t PDGCode(EType pid); static const char* ParticleName(EType pid, Bool_t shortName = kTRUE); @@ -64,17 +68,17 @@ public: // other void DumpPriors(); -private: + private: Double_t fPrior[kSpecies]; // prior probabilities Double_t fMaxPt; // pt threshold for realistic PID Double_t fMinProb; // threshold on acceptable largest probability - static const Double_t fgkParticleMass[kSpecies + 1]; // PDG particle mass - static const char* fgkParticleNameShort[kSpecies + 1]; // short particle name - static const char* fgkParticleNameLong[kSpecies + 1]; // long particle name - static const char* fgkParticleNameLatex[kSpecies + 1]; // latex particle name - static const Int_t fgkParticlePDG[kSpecies + 1]; // PDG code of particle + static const Double_t fgkParticleMass[kSpeciesAll + 1]; // PDG particle mass + static const char* fgkParticleNameShort[kSpeciesAll + 1]; // short particle name + static const char* fgkParticleNameLong[kSpeciesAll + 1]; // long particle name + static const char* fgkParticleNameLatex[kSpeciesAll + 1]; // latex particle name + static const Int_t fgkParticlePDG[kSpeciesAll + 1]; // PDG code of particle ClassDef(AliRsnPID,1); }; diff --git a/PWG2/RESONANCES/AliRsnPIDIndex.cxx b/PWG2/RESONANCES/AliRsnPIDIndex.cxx index ef3a7787c5b..741443a5511 100644 --- a/PWG2/RESONANCES/AliRsnPIDIndex.cxx +++ b/PWG2/RESONANCES/AliRsnPIDIndex.cxx @@ -28,27 +28,29 @@ #include "AliRsnPIDIndex.h" -ClassImp (AliRsnPIDIndex) +ClassImp(AliRsnPIDIndex) //_____________________________________________________________________________ -AliRsnPIDIndex::AliRsnPIDIndex (Int_t num) +AliRsnPIDIndex::AliRsnPIDIndex(Int_t num) { // // Default constructor // - Int_t i, j, k; - for (i = 0; i < 2; i++) { - for (j = 0; j < AliRsnPID::kSpecies+1; j++) { - fNumOfIndex[i][j] = 0; - fIndex[i][j].Set(num); - for (k = 0; k < num; k++) fIndex[i][j].AddAt(-1, k); - } + Int_t i, j, k; + for (i = 0; i < 2; i++) + { + for (j = 0; j < AliRsnPID::kSpecies+1; j++) + { + fNumOfIndex[i][j] = 0; + fIndex[i][j].Set(num); + for (k = 0; k < num; k++) fIndex[i][j].AddAt(-1, k); } + } } //_____________________________________________________________________________ -AliRsnPIDIndex::AliRsnPIDIndex (const AliRsnPIDIndex & copy) - : TObject (copy) +AliRsnPIDIndex::AliRsnPIDIndex(const AliRsnPIDIndex & copy) + : TObject(copy) { // // Copy constructor. @@ -56,17 +58,20 @@ AliRsnPIDIndex::AliRsnPIDIndex (const AliRsnPIDIndex & copy) // to store a copy of all objects. // - Int_t i, j, k, size; - for (i = 0; i < 2; i++) { - for (j = 0; j < AliRsnPID::kSpecies+1; j++) { - fNumOfIndex[i][j] = copy.fNumOfIndex[i][j]; - size = copy.fIndex[i][j].GetSize(); - fIndex[i][j].Set(size); - for (k = 0; k < size; k++) { - fIndex[i][j].AddAt(copy.fIndex[i][j].At(k), k); - } - } + Int_t i, j, k, size; + for (i = 0; i < 2; i++) + { + for (j = 0; j < AliRsnPID::kSpecies+1; j++) + { + fNumOfIndex[i][j] = copy.fNumOfIndex[i][j]; + size = copy.fIndex[i][j].GetSize(); + fIndex[i][j].Set(size); + for (k = 0; k < size; k++) + { + fIndex[i][j].AddAt(copy.fIndex[i][j].At(k), k); + } } + } } //_____________________________________________________________________________ @@ -78,20 +83,23 @@ AliRsnPIDIndex& AliRsnPIDIndex::operator= (const AliRsnPIDIndex & copy) // to store a copy of all objects. // - Int_t i, j, k, size; - for (i = 0; i < 2; i++) { - for (j = 0; j < AliRsnPID::kSpecies+1; j++) { - fNumOfIndex[i][j] = copy.fNumOfIndex[i][j]; - size = copy.fIndex[i][j].GetSize(); - fIndex[i][j].Set(size); - for (k = 0; k < size; k++) { - fIndex[i][j].AddAt(copy.fIndex[i][j].At(k), k); - } - } + Int_t i, j, k, size; + for (i = 0; i < 2; i++) + { + for (j = 0; j < AliRsnPID::kSpecies+1; j++) + { + fNumOfIndex[i][j] = copy.fNumOfIndex[i][j]; + size = copy.fIndex[i][j].GetSize(); + fIndex[i][j].Set(size); + for (k = 0; k < size; k++) + { + fIndex[i][j].AddAt(copy.fIndex[i][j].At(k), k); + } } + } - // return this object - return (*this); + // return this object + return (*this); } AliRsnPIDIndex::~AliRsnPIDIndex() @@ -103,29 +111,31 @@ AliRsnPIDIndex::~AliRsnPIDIndex() } //_____________________________________________________________________________ -void AliRsnPIDIndex::Print (Option_t* /*option*/) const +void AliRsnPIDIndex::Print(Option_t* /*option*/) const { // // Prints AliRsnPIDIndex info // - Int_t i, j; - for (i = 0; i < 2; i++) { - for (j = 0; j < AliRsnPID::kSpecies + 1; j++) { - AliInfo (Form (" [%d][%d] %d %d", i, j, fIndex[i][j].GetSize(), fNumOfIndex[i][j])); - } + Int_t i, j; + for (i = 0; i < 2; i++) + { + for (j = 0; j < AliRsnPID::kSpecies + 1; j++) + { + AliInfo(Form(" [%d][%d] %d %d", i, j, fIndex[i][j].GetSize(), fNumOfIndex[i][j])); } + } } //_____________________________________________________________________________ -void AliRsnPIDIndex::AddIndex (const Int_t index, Char_t sign, AliRsnPID::EType type) +void AliRsnPIDIndex::AddIndex(const Int_t index, Char_t sign, AliRsnPID::EType type) { // // Adds index to corresponding TArrayI // - Int_t iCharge = ChargeIndex(sign); - Int_t iType = (Int_t)type; - fIndex[iCharge][iType].AddAt(index, fNumOfIndex[iCharge][iType]); - fNumOfIndex[iCharge][iType]++; + Int_t iCharge = ChargeIndex(sign); + Int_t iType = (Int_t)type; + fIndex[iCharge][iType].AddAt(index, fNumOfIndex[iCharge][iType]); + fNumOfIndex[iCharge][iType]++; } //_____________________________________________________________________________ @@ -135,8 +145,8 @@ void AliRsnPIDIndex::AddIndex(const Int_t index, Short_t sign, Int_t type) // Adds index to corresponding TArrayI // - fIndex[sign][type].AddAt (index, fNumOfIndex[sign][type]); - fNumOfIndex[sign][type]++; + fIndex[sign][type].AddAt(index, fNumOfIndex[sign][type]); + fNumOfIndex[sign][type]++; } //_____________________________________________________________________________ @@ -146,16 +156,18 @@ void AliRsnPIDIndex::SetCorrectIndexSize() // Sets Correct sizes to all TArrayI // - Int_t i, j; - for (i = 0; i < 2; i++) { - for (j = 0; j < AliRsnPID::kSpecies + 1; j++) { - fIndex[i][j].Set(fNumOfIndex[i][j]); - } + Int_t i, j; + for (i = 0; i < 2; i++) + { + for (j = 0; j < AliRsnPID::kSpecies + 1; j++) + { + fIndex[i][j].Set(fNumOfIndex[i][j]); } + } } //_____________________________________________________________________________ -TArrayI* AliRsnPIDIndex::GetTracksArray (Char_t sign, AliRsnPID::EType type) +TArrayI* AliRsnPIDIndex::GetTracksArray(Char_t sign, AliRsnPID::EType type) { // // Returns the array of indexes of tracks whose charge @@ -165,18 +177,19 @@ TArrayI* AliRsnPIDIndex::GetTracksArray (Char_t sign, AliRsnPID::EType type) // Otherwise returns null pointer. // - Int_t icharge = ChargeIndex (sign); - if (icharge < 0) return (TArrayI *) 0x0; - if (type < AliRsnPID::kElectron || type > AliRsnPID::kSpecies) { - AliError (Form ("Index %d out of range", type)); - return (TArrayI *) 0x0; - } + Int_t icharge = ChargeIndex(sign); + if (icharge < 0) return (TArrayI *) 0x0; + if (type < AliRsnPID::kElectron || type > AliRsnPID::kSpecies) + { + AliError(Form("Index %d out of range", type)); + return (TArrayI *) 0x0; + } - return &fIndex[icharge][type]; + return &fIndex[icharge][type]; } //_____________________________________________________________________________ -TArrayI* AliRsnPIDIndex::GetCharged (Char_t sign) +TArrayI* AliRsnPIDIndex::GetCharged(Char_t sign) { // // Returns the array of indexes of tracks whose charge @@ -184,38 +197,41 @@ TArrayI* AliRsnPIDIndex::GetCharged (Char_t sign) // Otherwise returns a null pointer. // - // check that argument is meaningful - Int_t icharge = ChargeIndex (sign); - if (icharge < 0) return (TArrayI *)0x0; + // check that argument is meaningful + Int_t icharge = ChargeIndex(sign); + if (icharge < 0) return (TArrayI *)0x0; - // count total number of tracks with that charge - // and create output object of appropriate size - Int_t i, total = 0; - for (i = 0; i <= AliRsnPID::kSpecies; i++) total += fIndex[icharge][i].GetSize(); - TArrayI *output = new TArrayI(total); + // count total number of tracks with that charge + // and create output object of appropriate size + Int_t i, total = 0; + for (i = 0; i <= AliRsnPID::kSpecies; i++) total += fIndex[icharge][i].GetSize(); + TArrayI *output = new TArrayI(total); - // add all indexes - Int_t j, counter = 0; - for (i = 0; i <= AliRsnPID::kSpecies; i++) { - for (j = 0; j < fIndex[icharge][i].GetSize(); j++) { - output->AddAt (fIndex[icharge][i].At(j), counter++); - } + // add all indexes + Int_t j, counter = 0; + for (i = 0; i <= AliRsnPID::kSpecies; i++) + { + for (j = 0; j < fIndex[icharge][i].GetSize(); j++) + { + output->AddAt(fIndex[icharge][i].At(j), counter++); } + } - return output; + return output; } //_____________________________________________________________________________ -Int_t AliRsnPIDIndex::ChargeIndex (Char_t sign) const +Int_t AliRsnPIDIndex::ChargeIndex(Char_t sign) const { // // Returns the array index corresponding to charge // - if (sign == '+') return 0; - else if (sign == '-') return 1; - else { - AliError (Form ("Character '%c' not recognized as charge sign", sign)); - return -1; - } + if (sign == '+') return 0; + else if (sign == '-') return 1; + else + { + AliError(Form("Character '%c' not recognized as charge sign", sign)); + return -1; + } } diff --git a/PWG2/RESONANCES/AliRsnPIDIndex.h b/PWG2/RESONANCES/AliRsnPIDIndex.h index 488494d53f6..1c4dfba51b4 100644 --- a/PWG2/RESONANCES/AliRsnPIDIndex.h +++ b/PWG2/RESONANCES/AliRsnPIDIndex.h @@ -20,10 +20,10 @@ class AliRsnPIDIndex : public TObject { -public: + public: - AliRsnPIDIndex (Int_t num = 1000); - AliRsnPIDIndex (const AliRsnPIDIndex ©); + AliRsnPIDIndex(Int_t num = 2000); + AliRsnPIDIndex(const AliRsnPIDIndex ©); AliRsnPIDIndex& operator= (const AliRsnPIDIndex& copy); virtual ~AliRsnPIDIndex(); @@ -34,17 +34,17 @@ public: void AddIndex(const Int_t index, Short_t sign, Int_t type); void SetCorrectIndexSize(); - TArrayI* GetTracksArray (Char_t sign, AliRsnPID::EType type); - TArrayI* GetCharged (Char_t sign); + TArrayI* GetTracksArray(Char_t sign, AliRsnPID::EType type); + TArrayI* GetCharged(Char_t sign); -private: + private: - Int_t ChargeIndex (Char_t sign) const; + Int_t ChargeIndex(Char_t sign) const; TArrayI fIndex[2][AliRsnPID::kSpecies+1]; // index arrays of pos/neg particles of each PID Int_t fNumOfIndex[2][AliRsnPID::kSpecies+1]; //! array size - ClassDef (AliRsnPIDIndex, 1); + ClassDef(AliRsnPIDIndex, 1); }; #endif diff --git a/PWG2/RESONANCES/AliRsnPIDWeightsMgr.cxx b/PWG2/RESONANCES/AliRsnPIDWeightsMgr.cxx index 7d0778e23e6..694881c6920 100644 --- a/PWG2/RESONANCES/AliRsnPIDWeightsMgr.cxx +++ b/PWG2/RESONANCES/AliRsnPIDWeightsMgr.cxx @@ -12,7 +12,7 @@ * about the suitability of this software for any purpose. It is * * provided "as is" without express or implied warranty. * **************************************************************************/ - + //------------------------------------------------------------------------- // Class AliRsnPIDWeightsMgr // ------------------- @@ -20,7 +20,7 @@ // selected from an ESD event // to be used for analysis. // ......................................... -// +// // author: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it) //------------------------------------------------------------------------- @@ -35,18 +35,19 @@ ClassImp(AliRsnPIDWeightsMgr) //_____________________________________________________________________________ -AliRsnPIDWeightsMgr::AliRsnPIDWeightsMgr() +AliRsnPIDWeightsMgr::AliRsnPIDWeightsMgr() { // // Default and unique constructor which initializes arrays // - Int_t i, j; - for (i = 0; i < kDetectors; i++) { - for (j = 0; j < AliRsnPID::kSpecies; j++) fWeights[i][j] = 0.0; - fDetPtMin[i] = 0.0; - fDetPtMax[i] = 1E25; - fUseDet[i] = kTRUE; - } + Int_t i, j; + for (i = 0; i < kDetectors; i++) + { + for (j = 0; j < AliRsnPID::kSpecies; j++) fWeights[i][j] = 0.0; + fDetPtMin[i] = 0.0; + fDetPtMax[i] = 1E25; + fUseDet[i] = kTRUE; + } } //_____________________________________________________________________________ @@ -56,9 +57,9 @@ void AliRsnPIDWeightsMgr::SetDetectorWeights(EDetector det, Double_t *weights) // Copy into the array the PID weights of a detector // - Int_t i; - if (!CheckBounds(det)) return; - for (i = 0; i < AliRsnPID::kSpecies; i++) fWeights[det][i] = weights[i]; + Int_t i; + if (!CheckBounds(det)) return; + for (i = 0; i < AliRsnPID::kSpecies; i++) fWeights[det][i] = weights[i]; } //_____________________________________________________________________________ @@ -70,17 +71,18 @@ void AliRsnPIDWeightsMgr::SetAcceptanceRange(EDetector det, Double_t ptmin, Doub // did not accept to use the global ESD pid. // - if (!CheckBounds(det)) return; - - // swap values if necessary - if (ptmin > ptmax) { - AliWarning("Values passed in wrong order. Swapping"); - Double_t temp = ptmin; - ptmin = ptmax; - ptmax = temp; - } - fDetPtMin[det] = ptmin; - fDetPtMax[det] = ptmax; + if (!CheckBounds(det)) return; + + // swap values if necessary + if (ptmin > ptmax) + { + AliWarning("Values passed in wrong order. Swapping"); + Double_t temp = ptmin; + ptmin = ptmax; + ptmax = temp; + } + fDetPtMin[det] = ptmin; + fDetPtMax[det] = ptmax; } //_____________________________________________________________________________ @@ -90,21 +92,23 @@ Double_t AliRsnPIDWeightsMgr::GetWeight(AliRsnPID::EType type, Double_t pt) // Computes the global PID weights using the given ranges // - if (type < 0 or type >= AliRsnPID::kSpecies) { - AliError("Index out of range"); - return kFALSE; - } - - Int_t i; - Double_t prob = 1.0; - for (i = 0; i < kDetectors; i++) { - //AliInfo(Form("weights[%d] = %f %f %f %f %f", i, fWeights[i][0], fWeights[i][1], fWeights[i][2], fWeights[i][3], fWeights[i][4], fWeights[i][5])); - if (!fUseDet[i]) continue; - if (pt < fDetPtMin[i] || pt > fDetPtMax[i]) continue; - prob *= fWeights[i][type]; - } - - return prob; + if (type < 0 or type >= AliRsnPID::kSpecies) + { + AliError("Index out of range"); + return kFALSE; + } + + Int_t i; + Double_t prob = 1.0; + for (i = 0; i < kDetectors; i++) + { + //AliInfo(Form("weights[%d] = %f %f %f %f %f", i, fWeights[i][0], fWeights[i][1], fWeights[i][2], fWeights[i][3], fWeights[i][4], fWeights[i][5])); + if (!fUseDet[i]) continue; + if (pt < fDetPtMin[i] || pt > fDetPtMax[i]) continue; + prob *= fWeights[i][type]; + } + + return prob; } //_____________________________________________________________________________ @@ -113,11 +117,12 @@ Bool_t AliRsnPIDWeightsMgr::CheckBounds(EDetector det) // // Bounds checker // - - if (det < 0 or det >= kDetectors) { - AliError("Index out of range"); - return kFALSE; - } - - return kTRUE; + + if (det < 0 or det >= kDetectors) + { + AliError("Index out of range"); + return kFALSE; + } + + return kTRUE; } diff --git a/PWG2/RESONANCES/AliRsnPIDWeightsMgr.h b/PWG2/RESONANCES/AliRsnPIDWeightsMgr.h index f1db9d3b1b3..13b4d656fea 100644 --- a/PWG2/RESONANCES/AliRsnPIDWeightsMgr.h +++ b/PWG2/RESONANCES/AliRsnPIDWeightsMgr.h @@ -8,7 +8,7 @@ //------------------------------------------------------------------------- // Class AliRsnPIDWeightsMgr // Simple collection of reconstructed tracks, selected from an ESD event -// +// // author: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it) //------------------------------------------------------------------------- @@ -19,28 +19,29 @@ class AliRsnPIDWeightsMgr : public TObject { -public: + public: // detectors for customizing PID weights - enum EDetector { - kITS, - kTPC, - kTRD, - kTOF, - kHMPID, - kDetectors + enum EDetector + { + kITS, + kTPC, + kTRD, + kTOF, + kHMPID, + kDetectors }; - + AliRsnPIDWeightsMgr(); virtual ~AliRsnPIDWeightsMgr() {} - + void UseDetector(EDetector det, Bool_t use) {if (CheckBounds(det)) fUseDet[det] = use;} void SetDetectorWeights(EDetector det, Double_t *weights); void SetAcceptanceRange(EDetector det, Double_t ptmin, Double_t ptmax); Double_t GetWeight(AliRsnPID::EType type, Double_t pt); Double_t* GetWeightArray(EDetector det) {if (CheckBounds(det)) return fWeights[det]; else return 0x0;} - -private: + + private: Bool_t CheckBounds(EDetector det); diff --git a/PWG2/RESONANCES/AliRsnPair.cxx b/PWG2/RESONANCES/AliRsnPair.cxx new file mode 100644 index 00000000000..0f40b8e18ad --- /dev/null +++ b/PWG2/RESONANCES/AliRsnPair.cxx @@ -0,0 +1,418 @@ +// +// *** Class AliRsnPair *** +// +// "Core" method for defining the work on a pari of particles. +// For one analysis, one must setup one of this for each pair he wants to analyze, +// adding to it all analysis which he desires to do. +// Here he defines the cuts, and the particle types and charges, and can add +// functions which do different operations on the same pair, and some binning +// with respect to some kinematic variables (eta, momentum) +// +// authors: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it) +// M. Vala (email: martin.vala@cern.ch) +// + +#include "TObjArray.h" + +#include "AliLog.h" + +#include "AliRsnFunction.h" +#include "AliRsnPairParticle.h" + +#include "AliRsnPair.h" + +ClassImp(AliRsnPair) + +//_____________________________________________________________________________ +AliRsnPair::AliRsnPair +(EPairType type, AliRsnPairDef *def, Int_t mixNum) : + TObject(), + fIsMixed(kFALSE), + fUseMC(kFALSE), + fIsLikeSign(kFALSE), + fMixNum(mixNum), + fPairDef(def), + fPairType(type), + fTypePID(AliRsnDaughter::kRealistic), + fCutMgr(0), + fFunctions("AliRsnFunction", 0) +{ +// +// Default constructor +// + + SetUp(type); +} +//_____________________________________________________________________________ +AliRsnPair::~AliRsnPair() +{ +// +// Destructor +// +} + +//_____________________________________________________________________________ +void AliRsnPair::SetUp(EPairType type) +{ +// +// Sets up flag values by the pair types +// + + switch (type) + { + case kNoPID: + SetAllFlags(AliRsnDaughter::kNoPID, kFALSE, kFALSE); + break; + case kNoPIDMix: + SetAllFlags(AliRsnDaughter::kNoPID, kTRUE, kFALSE); + break; + case kRealisticPID: + SetAllFlags(AliRsnDaughter::kRealistic, kFALSE, kFALSE); + break; + case kRealisticPIDMix: + SetAllFlags(AliRsnDaughter::kRealistic, kTRUE, kFALSE); + break; + case kPerfectPID: + // SetAllFlags (AliRsnDaughter::kPerfect, kFALSE, kFALSE); + SetAllFlags(AliRsnDaughter::kPerfect, kFALSE, kTRUE); + break; + case kPerfectPIDMix: + // SetAllFlags (AliRsnDaughter::kPerfect, kTRUE, kFALSE); + SetAllFlags(AliRsnDaughter::kPerfect, kTRUE, kTRUE); + break; + default : + AliWarning("Wrong type selected: setting up for kRealisticPID."); + SetAllFlags(AliRsnDaughter::kRealistic, kFALSE, kFALSE); + break; + } +} + +//_____________________________________________________________________________ +void AliRsnPair::SetAllFlags(AliRsnDaughter::EPIDMethod pidType, Bool_t isMix, Bool_t useMC) +{ +// +// Sets up all flags values +// + + fTypePID = pidType; + fIsMixed = isMix; + fUseMC = useMC; +} + +//_____________________________________________________________________________ +void AliRsnPair::Init() +{ +// +// Init pair +// + + fIsLikeSign = fPairDef->IsLikeSign(); + Print(); +} + +//_____________________________________________________________________________ +void AliRsnPair::Print() +{ +// +// Prints info about pair +// + AliInfo(Form("%s", GetPairHistTitle(0x0).Data())); + AliInfo(Form("PDG %d %d", AliRsnPID::PDGCode(fPairDef->GetType(0)), + AliRsnPID::PDGCode(fPairDef->GetType(1)))); + AliInfo(Form("Masses %f %f", fPairDef->GetMass(0), fPairDef->GetMass(1))); + AliInfo(Form("Number of functions %d", fFunctions.GetEntries())); + switch(fTypePID) { + case AliRsnDaughter::kNoPID: + AliInfo("PID method: none"); + break; + case AliRsnDaughter::kRealistic: + AliInfo("PID method: realistic"); + break; + case AliRsnDaughter::kPerfect: + AliInfo("PID method: perfect"); + break; + default: + AliInfo("PID method: undefined"); + } +} + +//_____________________________________________________________________________ +void AliRsnPair::ProcessPair(AliRsnEventBuffer *buf) +{ +// +// Process one event in this pair +// + + AliRsnEvent *e1 = buf->GetCurrentEvent(); + if (!e1) return; + if (e1->GetMultiplicity() < 1) return; + TArrayI* array1 = e1->GetTracksArray(fTypePID, fPairDef->GetCharge(0), fPairDef->GetType(0)); + + Int_t i = 0; + Int_t numMixed = 0; + Int_t lastOkEvent = 1; + TArrayI* array2 = 0; + for (i = 0; i < fMixNum; i++) + { + // find other event by event cut + AliRsnEvent *e2 = FindEventByEventCut(buf, lastOkEvent); + if (!e2) return; + if (e2->GetMultiplicity() < 1) return; + array2 = e2->GetTracksArray(fTypePID, fPairDef->GetCharge(1), fPairDef->GetType(1)); + LoopPair(e1, array1, e2, array2); + numMixed++; + } +// if (fIsMixed) AliInfo (Form ("NumMixed = %d",numMixed)); +} + +//_____________________________________________________________________________ +AliRsnEvent * AliRsnPair::FindEventByEventCut(AliRsnEventBuffer *buf, Int_t& num) +{ +// +// For now it just returns num events before current event +// in buffer (buf) +// TODO event cut selection +// + + AliRsnEvent *returnEvent = 0x0; + + if (fIsMixed) + { + returnEvent = buf->GetEvent(buf->GetEventsBufferIndex() - num); + } + else + { + returnEvent = buf->GetCurrentEvent(); + } + + return returnEvent; +} + +//_____________________________________________________________________________ +void AliRsnPair::LoopPair +(AliRsnEvent * ev1, TArrayI * a1, AliRsnEvent * ev2, TArrayI * a2) +{ +// +// Loop on all pairs of tracks of the defined types/charges, +// using the arrays of indexes and the events containing them. +// + + if (!a1) {AliError("No TArrayI 1 from currentEvent->GetTracksArray(...)"); return;} + if (!a2) {AliError("No TArrayI 2 from currentEvent->GetTracksArray(...)"); return;} + + AliRsnDaughter::SetPIDMethod(fTypePID); + AliRsnDaughter *daughter1 = 0; + AliRsnDaughter *daughter2 = 0; + AliRsnFunction *fcn = 0; + Int_t j, startj = 0; + for (Int_t i = 0; i < a1->GetSize(); i++) + { + // get track #1 + daughter1 = (AliRsnDaughter *) ev1->GetTrack(a1->At(i)); + if (!daughter1) continue; + // cuts on track #1 + if (!CutPass(daughter1)) continue; + // get track #2 + daughter2 = 0; + // check starting index for searching the event: + // for like-sign pairs we avoid duplicating the pairs + if (fIsLikeSign) startj = i+1; else startj = 0; + // AliInfo(Form("%d",startj)); + // loop on event for all track #2 to be combined with the found track #1 + for (j = startj; j < a2->GetSize(); j++) + { + daughter2 = (AliRsnDaughter *) ev2->GetTrack(a2->At(j)); + if (!daughter2) continue; + // cuts on track #2 + if (!CutPass(daughter2)) continue; + // make pair + AliRsnPairParticle pairParticle; + pairParticle.SetPair(daughter1, daughter2); + // cuts on pair + if (!CutPass(&pairParticle)) continue; + // fill all histograms + TObjArrayIter nextFcn(&fFunctions); + while ( (fcn = (AliRsnFunction*)nextFcn()) ) { + fcn->Fill(&pairParticle, fPairDef); + } + } + } +} + +//_____________________________________________________________________________ +TList * AliRsnPair::GenerateHistograms(TString prefix) +{ +// +// Generates needed histograms +// + + TList *list = new TList(); + list->SetName(GetPairHistName(0x0).Data()); + + Char_t hName[255], hTitle[255]; + AliRsnFunction *fcn = 0; + for (Int_t i=0;i< fFunctions.GetEntries();i++) + { + fcn = (AliRsnFunction*)fFunctions.At(i); + sprintf(hName, "%s_%s", prefix.Data(), GetPairHistName(fcn).Data()); + sprintf(hTitle, "%s", GetPairHistTitle(fcn).Data()); + TList *histos = fcn->Init(hName, hTitle); + histos->Print(); + list->Add(histos); + } + + return list; +} + +//_____________________________________________________________________________ +void AliRsnPair::GenerateHistograms(TString prefix, TList *tgt) +{ +// +// Generates needed histograms +// + + if (!tgt) { + AliError("NULL target list!"); + return; + } + + Char_t hName[255], hTitle[255]; + AliRsnFunction *fcn = 0; + for (Int_t i=0;i< fFunctions.GetEntries();i++) + { + fcn = (AliRsnFunction*)fFunctions.At(i); + sprintf(hName, "%s_%s", prefix.Data(), GetPairHistName(fcn).Data()); + sprintf(hTitle, "%s", GetPairHistTitle(fcn).Data()); + fcn->Init(hName, hTitle, tgt); + } +} + +//_____________________________________________________________________________ +TString AliRsnPair::GetPairTypeName(EPairType type) +{ +// +// Returns type name, made with particle names ant chosen PID +// + switch (type) + { + case kNoPID : return ("NOPID_");break; + case kNoPIDMix : return ("NOPIDMIX_");break; + case kRealisticPID : return ("REALISTIC_");break; + case kRealisticPIDMix : return ("REALISTICMIX_");break; + case kPerfectPID : return ("PERFECT_");break; + case kPerfectPIDMix : return ("PERFECTMIX_");break; + case kTruePairs : return ("TRUEPAIRS_"); break; + default: + AliWarning("Unrecognized value of EPairTypeName argument"); + break; + } + + return "NOTYPE"; +} + +//_____________________________________________________________________________ +TString AliRsnPair::GetPairName() +{ +// +// Retruns pair name +// + TString sName; + sName += GetPairTypeName(fPairType); + sName += fPairDef->GetPairName(); + + return sName; +} + +//_____________________________________________________________________________ +TString AliRsnPair::GetPairHistName(AliRsnFunction *fcn, TString text) +{ +// +// Returns eff. mass histogram name +// + + TString sName; + if (fcn) + { + sName = fcn->GetFcnName(); + sName += "_"; + } + sName += GetPairName(); + sName += "_"; + if (fCutMgr) sName += fCutMgr->GetName(); + sName += text; + + return sName; +} + +//_____________________________________________________________________________ +TString AliRsnPair::GetPairHistTitle(AliRsnFunction *fcn, TString text) +{ +// +// Returns eff. mass histogram title +// + + TString sTitle; + if (fcn) + { + sTitle = fcn->GetFcnTitle(); + sTitle += " "; + } + sTitle += GetPairName(); + sTitle +=" "; + if (fCutMgr) sTitle += fCutMgr->GetTitle(); + sTitle += text; + + return sTitle; +} + +//_____________________________________________________________________________ +void AliRsnPair::AddFunction(AliRsnFunction *fcn) +{ +// +// Adds a new computing function +// +// if (!fFunctions) fFunctions = new TList; + //fFunctions.Add((AliRsnFunction *)fcn->Clone()); + Int_t size = fFunctions.GetEntries(); + new(fFunctions[size]) AliRsnFunction(*fcn); + //fFunctions.AddLast(fcopy); +} + +//________________________________________________________________________________________ +Bool_t AliRsnPair::CutPass(AliRsnDaughter *d) +{ +// +// Check if the AliRsnDaughter argument pass its cuts. +// If the cut data member is not initialized for it, returns kTRUE. +// + if (!fCutMgr) return kTRUE; + else return fCutMgr->IsSelected(AliRsnCut::kParticle, d); +} + +//________________________________________________________________________________________ +Bool_t AliRsnPair::CutPass(AliRsnPairParticle *p) +{ +// +// Check if the AliRsnPairParticle argument pass its cuts. +// If the cut data member is not initialized for it, returns kTRUE. +// In this case, another separate check which could be necessary +// concerns the possibility that the two tracks are a "true pair" of +// daughters of the same resonance. If the corresponding flag is set, +// this further check is done, and the method returns kTRUE only +// when also this check is passed. +// + + if (!fCutMgr) return kTRUE; + else return fCutMgr->IsSelected(AliRsnCut::kPair, p); +} + +//________________________________________________________________________________________ +Bool_t AliRsnPair::CutPass(AliRsnEvent *e) +{ +// +// Check if the AliRsnEvent argument pass its cuts. +// If the cut data member is not initialized for it, returns kTRUE. +// + if (!fCutMgr) return kTRUE; + else return fCutMgr->IsSelected(AliRsnCut::kEvent, e); +} diff --git a/PWG2/RESONANCES/AliRsnPair.h b/PWG2/RESONANCES/AliRsnPair.h new file mode 100644 index 00000000000..8323a2cccd8 --- /dev/null +++ b/PWG2/RESONANCES/AliRsnPair.h @@ -0,0 +1,103 @@ +// +// *** Class AliRsnPair *** +// +// TODO +// +// authors: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it) +// M. Vala (email: martin.vala@cern.ch) +// + +#ifndef ALIRSNPAIR_H +#define ALIRSNPAIR_H + +#include "TH1.h" +#include "TH2.h" +#include "TList.h" + +#include "AliRsnDaughter.h" +#include "AliRsnPairDef.h" +#include "AliRsnEventBuffer.h" +#include "AliRsnEvent.h" +#include "AliRsnCutMgr.h" +#include "AliRsnHistoDef.h" + +class AliRsnFunction; + +class AliRsnPair : public TObject +{ + public: + + enum EPairType + { + kNoPID = 0, kNoPIDMix, + kRealisticPID, kRealisticPIDMix, + kPerfectPID, kPerfectPIDMix, + kTruePairs, + kPairTypes + }; + + enum EOutputType + { + kInvMass = 0, + kInvMassResolution, + kOutputTypes + }; + + + AliRsnPair (EPairType type = kRealisticPID, AliRsnPairDef *def = 0, Int_t mixNum = 1); + ~AliRsnPair(); + + void Init(); + void Print(); + void ProcessPair(AliRsnEventBuffer *buf); + void SetCutMgr(AliRsnCutMgr* theValue) { fCutMgr = theValue; } + void AddFunction(AliRsnFunction *fcn); + TList* GenerateHistograms(TString prefix = ""); + void GenerateHistograms(TString prefix, TList *tgt); + + TString GetPairTypeName(EPairType type); + TString GetPairName(); + TString GetPairHistName(AliRsnFunction *fcn, TString text = ""); + TString GetPairHistTitle(AliRsnFunction *fcn, TString text=""); + + private: + + AliRsnPair (const AliRsnPair ©) : TObject(copy), + fIsMixed(kFALSE),fUseMC(kFALSE),fIsLikeSign(kFALSE),fMixNum(1), + fPairDef(0x0),fPairType(kPairTypes),fTypePID(AliRsnDaughter::kRealistic), + fCutMgr(0x0),fFunctions("AliRsnFunction",0) {} + AliRsnPair& operator=(const AliRsnPair&) {return *this;} + + void SetUp(EPairType type); // sets up all flags + void SetAllFlags(AliRsnDaughter::EPIDMethod pidType,Bool_t isMix, Bool_t useMC); + AliRsnEvent* FindEventByEventCut(AliRsnEventBuffer *buf,Int_t & num); + void LoopPair(AliRsnEvent *ev1,TArrayI *a1,AliRsnEvent *ev2,TArrayI *a2); + + void FillHistogram(EOutputType type,AliRsnPairParticle*pairPart); + void FillEffMass(EOutputType type,AliRsnPairParticle*pairPart); + void FillResolution(EOutputType type,AliRsnPairParticle*pairPart); + + TString GetOutputTypeName(EOutputType type); + TString GetOutputTypeTitle(EOutputType type); + + Bool_t CutPass(AliRsnDaughter *d); + Bool_t CutPass(AliRsnPairParticle *p); + Bool_t CutPass(AliRsnEvent *e); + + // flags & integer data + Bool_t fIsMixed; // doing event-mixing ? + Bool_t fUseMC; // using MC inv. mass ? + Bool_t fIsLikeSign; // is a like-sign pair ? + Int_t fMixNum; // number of mixed events + + // work management + AliRsnPairDef *fPairDef; // pair definition (particles, charges) + EPairType fPairType; // pair type (PID + mixing or not) + AliRsnDaughter::EPIDMethod fTypePID; // pid type variable for single track + AliRsnCutMgr *fCutMgr; // cut manager + TClonesArray fFunctions; // functions + + ClassDef (AliRsnPair, 1) +}; + +#endif diff --git a/PWG2/RESONANCES/AliRsnPairDef.cxx b/PWG2/RESONANCES/AliRsnPairDef.cxx index 42308e8f2bd..59e38989e2e 100644 --- a/PWG2/RESONANCES/AliRsnPairDef.cxx +++ b/PWG2/RESONANCES/AliRsnPairDef.cxx @@ -16,8 +16,7 @@ ClassImp(AliRsnPairDef) //_____________________________________________________________________________ -AliRsnPairDef::AliRsnPairDef() : - fMotherPDG(0) +AliRsnPairDef::AliRsnPairDef() : fMotherPDG(0) { // // Empty constructor. @@ -39,7 +38,7 @@ AliRsnPairDef::AliRsnPairDef() : //_____________________________________________________________________________ AliRsnPairDef::AliRsnPairDef (Char_t sign1, AliRsnPID::EType type1, Char_t sign2, AliRsnPID::EType type2, Int_t motherPDG) : - fMotherPDG(motherPDG) + fMotherPDG(motherPDG) { // // Constructor with arguments. @@ -49,10 +48,24 @@ AliRsnPairDef::AliRsnPairDef SetPair(sign1, type1, sign2, type2); } +//_____________________________________________________________________________ +AliRsnPairDef::AliRsnPairDef +(AliRsnPID::EType type1, Char_t sign1, AliRsnPID::EType type2, Char_t sign2, Int_t motherPDG) : + fMotherPDG(motherPDG) +{ +// +// Constructor with arguments. +// This constructor allows to define all the working parameters. +// + + SetPair(sign1, type1, sign2, type2); +} + + //_____________________________________________________________________________ AliRsnPairDef::AliRsnPairDef(const AliRsnPairDef ©) : - TObject(copy), - fMotherPDG(copy.fMotherPDG) + TObject(copy), + fMotherPDG(copy.fMotherPDG) { // // Copy constructor with standard behavior @@ -96,6 +109,7 @@ Bool_t AliRsnPairDef::SetPairElement(Int_t i, Char_t charge, AliRsnPID::EType ty fCharge[i] = charge; fType[i] = type; fMass[i] = AliRsnPID::ParticleMass(type); + return kTRUE; } @@ -107,9 +121,9 @@ Bool_t AliRsnPairDef::SetPair // Set both elements of the pair, // returning logical AND of check for each one. // - Bool_t part1 = SetPairElement(0, charge1, type1); Bool_t part2 = SetPairElement(1, charge2, type2); + return (part1 && part2); } @@ -128,3 +142,20 @@ Double_t AliRsnPairDef::ComputeWeight(AliRsnDaughter *d0, AliRsnDaughter *d1) return prob0*prob1; } + +//_____________________________________________________________________________ +TString AliRsnPairDef::GetPairName() +{ +// +// Returns a compact string with the name of the pair, +// to be used for naming objects related to it. +// + + TString sName; + sName += AliRsnPID::ParticleName(fType[0]); + sName += fCharge[0]; + sName += AliRsnPID::ParticleName(fType[1]); + sName += fCharge[1]; + + return sName; +} diff --git a/PWG2/RESONANCES/AliRsnPairDef.h b/PWG2/RESONANCES/AliRsnPairDef.h index db9a54c39cc..76ee8cd0c79 100644 --- a/PWG2/RESONANCES/AliRsnPairDef.h +++ b/PWG2/RESONANCES/AliRsnPairDef.h @@ -12,19 +12,23 @@ #ifndef ALIRSNPAIRDEF_H #define ALIRSNPAIRDEF_H +#include + #include "AliRsnPID.h" class AliRsnDaughter; class AliRsnPairDef : public TObject { -public: + public: AliRsnPairDef(); - AliRsnPairDef(Char_t ch1, AliRsnPID::EType pid1, - Char_t ch2, AliRsnPID::EType pid2, Int_t motherPDG = 0); + AliRsnPairDef(Char_t sign1, AliRsnPID::EType type1, + Char_t sign2, AliRsnPID::EType type2, Int_t motherPDG = 0); + AliRsnPairDef(AliRsnPID::EType type1, Char_t sign1, + AliRsnPID::EType type2, Char_t sign2, Int_t motherPDG = 0); AliRsnPairDef(const AliRsnPairDef ©); - const AliRsnPairDef& operator=(const AliRsnPairDef ©); + const AliRsnPairDef& operator= (const AliRsnPairDef ©); virtual ~AliRsnPairDef() { } // getters @@ -32,6 +36,7 @@ public: AliRsnPID::EType GetType(Int_t i) const {if (i>=0&&i<2) return fType[i]; else return AliRsnPID::kUnknown;} Double_t GetMass(Int_t i) const {if (i>=0&&i<2) return fMass[i]; else return 0.0;} Int_t GetMotherPDG() const {return fMotherPDG;} + TString GetPairName(); // setters Bool_t SetPairElement(Int_t i, Char_t charge, AliRsnPID::EType pid); @@ -45,7 +50,7 @@ public: // working routines Double_t ComputeWeight(AliRsnDaughter *d0, AliRsnDaughter *d1); -private: + private: // pair parameters Int_t fMotherPDG; // PDG code of true mother (if known) diff --git a/PWG2/RESONANCES/AliRsnPairMgr.cxx b/PWG2/RESONANCES/AliRsnPairMgr.cxx new file mode 100644 index 00000000000..db78cfc4692 --- /dev/null +++ b/PWG2/RESONANCES/AliRsnPairMgr.cxx @@ -0,0 +1,71 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ +// +// *** Class AliRsnPairMgr *** +// +// TODO +// +// authors: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it) +// M. Vala (email: martin.vala@cern.ch) +// + +#include "AliLog.h" + +#include "AliRsnPairMgr.h" + +ClassImp ( AliRsnPairMgr ) + +//_____________________________________________________________________________ +AliRsnPairMgr::AliRsnPairMgr ( const char*name ) + : TNamed ( name,name),fPairs(0) +{ +//========================================================= +// Default constructor +//========================================================= + +} + +//_____________________________________________________________________________ +AliRsnPairMgr::~AliRsnPairMgr() +{ +//========================================================= +// Destructor +//========================================================= + +} + +//_____________________________________________________________________________ +void AliRsnPairMgr::AddPair ( AliRsnPair * pair ) +{ +//========================================================= +// Adds pair +//========================================================= + + fPairs.Add ( ( AliRsnPair * ) pair ); +} + +//_____________________________________________________________________________ +void AliRsnPairMgr::PrintPairs() +{ +//========================================================= +// Prints all pairs +//========================================================= + AliRsnPair * pair=0; + for ( Int_t i=0;iPrint(); + } +} diff --git a/PWG2/RESONANCES/AliRsnPairMgr.h b/PWG2/RESONANCES/AliRsnPairMgr.h new file mode 100644 index 00000000000..2b02a49fbd4 --- /dev/null +++ b/PWG2/RESONANCES/AliRsnPairMgr.h @@ -0,0 +1,33 @@ +// +// *** Class AliRsnPairMgr *** +// +// TODO +// +// authors: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it) +// M. Vala (email: martin.vala@cern.ch) +// + +#ifndef ALIRSNMVPAIRMGR_H +#define ALIRSNMVPAIRMGR_H + +#include "AliRsnPair.h" + +class AliRsnPairMgr : public TNamed +{ + public: + AliRsnPairMgr(const char*name="default"); + + ~AliRsnPairMgr(); + + void AddPair ( AliRsnPair *pair ); + TObjArray *GetPairs() { return &fPairs; } + void PrintPairs(); + + private: + + TObjArray fPairs; // array of pairs + + ClassDef ( AliRsnPairMgr, 1 ) +}; + +#endif diff --git a/PWG2/RESONANCES/AliRsnPairParticle.cxx b/PWG2/RESONANCES/AliRsnPairParticle.cxx index ab9999e0a7a..8dc04936d9a 100644 --- a/PWG2/RESONANCES/AliRsnPairParticle.cxx +++ b/PWG2/RESONANCES/AliRsnPairParticle.cxx @@ -28,7 +28,7 @@ #include "AliRsnPairParticle.h" -ClassImp (AliRsnPairParticle) +ClassImp(AliRsnPairParticle) //_____________________________________________________________________________ AliRsnPairParticle::AliRsnPairParticle() @@ -38,26 +38,29 @@ AliRsnPairParticle::AliRsnPairParticle() // Initializes all variables to meaningless values. // - Int_t i, j; - - for (i = 0; i < 3; i++) { - fPTot[i] = 0.0; - fPTotMC[i] = 0.0; - if (i < 2) { - fMotherLabel[i] = -1; - fMotherPDG[i] = 0; - fDaughter[i] = 0x0; - } - for (j = 0; j < 2; j++) { - fPTrack[j][i] = 0.0; - fPTrackMC[j][i] = 0.0; - } + Int_t i, j; + + for (i = 0; i < 3; i++) + { + fPTot[i] = 0.0; + fPTotMC[i] = 0.0; + if (i < 2) + { + fMotherLabel[i] = -1; + fMotherPDG[i] = 0; + fDaughter[i] = 0x0; } + for (j = 0; j < 2; j++) + { + fPTrack[j][i] = 0.0; + fPTrackMC[j][i] = 0.0; + } + } } //_____________________________________________________________________________ AliRsnPairParticle::AliRsnPairParticle(const AliRsnPairParticle &obj) : - TObject(obj) + TObject(obj) { // // Copy constructor. @@ -65,20 +68,23 @@ AliRsnPairParticle::AliRsnPairParticle(const AliRsnPairParticle &obj) : // Does not duplicate pointers. // - Int_t i, j; - for (i = 0; i < 3; i++) { - fPTot[i] = obj.fPTot[i]; - fPTotMC[i] = obj.fPTotMC[i]; - if (i < 2) { - fMotherLabel[i] = obj.fMotherLabel[i]; - fMotherPDG[i] = obj.fMotherPDG[i]; - fDaughter[i] = obj.fDaughter[i]; - } - for (j = 0; j < 2; j++) { - fPTrack[j][i] = obj.fPTrack[j][i]; - fPTrackMC[j][i] = obj.fPTrackMC[j][i]; - } + Int_t i, j; + for (i = 0; i < 3; i++) + { + fPTot[i] = obj.fPTot[i]; + fPTotMC[i] = obj.fPTotMC[i]; + if (i < 2) + { + fMotherLabel[i] = obj.fMotherLabel[i]; + fMotherPDG[i] = obj.fMotherPDG[i]; + fDaughter[i] = obj.fDaughter[i]; + } + for (j = 0; j < 2; j++) + { + fPTrack[j][i] = obj.fPTrack[j][i]; + fPTrackMC[j][i] = obj.fPTrackMC[j][i]; } + } } //_____________________________________________________________________________ @@ -90,22 +96,25 @@ AliRsnPairParticle& AliRsnPairParticle::operator=(const AliRsnPairParticle &obj) // Does not duplicate pointers. // - Int_t i, j; - for (i = 0; i < 3; i++) { - fPTot[i] = obj.fPTot[i]; - fPTotMC[i] = obj.fPTotMC[i]; - if (i < 2) { - fMotherLabel[i] = obj.fMotherLabel[i]; - fMotherPDG[i] = obj.fMotherPDG[i]; - fDaughter[i] = obj.fDaughter[i]; - } - for (j = 0; j < 2; j++) { - fPTrack[j][i] = obj.fPTrack[j][i]; - fPTrackMC[j][i] = obj.fPTrackMC[j][i]; - } + Int_t i, j; + for (i = 0; i < 3; i++) + { + fPTot[i] = obj.fPTot[i]; + fPTotMC[i] = obj.fPTotMC[i]; + if (i < 2) + { + fMotherLabel[i] = obj.fMotherLabel[i]; + fMotherPDG[i] = obj.fMotherPDG[i]; + fDaughter[i] = obj.fDaughter[i]; + } + for (j = 0; j < 2; j++) + { + fPTrack[j][i] = obj.fPTrack[j][i]; + fPTrackMC[j][i] = obj.fPTrackMC[j][i]; } + } - return (*this); + return (*this); } //_____________________________________________________________________________ @@ -128,18 +137,19 @@ Double_t AliRsnPairParticle::GetInvMass(Double_t mass0, Double_t mass1) // and the sum of their energies as they result from assigned masses. // - if (!fDaughter[0] || !fDaughter[1]) { - AliError("One of the two tracks is NULL in this pair!"); - return -1000.0; - } + if (!fDaughter[0] || !fDaughter[1]) + { + AliError("One of the two tracks is NULL in this pair!"); + return -1000.0; + } - // compute track energies using the shortcut method defined in AliRsnDaughter - Double_t etot = 0.0; - etot += fDaughter[0]->E(mass0); - etot += fDaughter[1]->E(mass1); + // compute track energies using the shortcut method defined in AliRsnDaughter + Double_t etot = 0.0; + etot += fDaughter[0]->E(mass0); + etot += fDaughter[1]->E(mass1); - // compute & return invariant mass - return TMath::Sqrt (etot * etot - GetP2()); + // compute & return invariant mass + return TMath::Sqrt(etot * etot - GetP2()); } //_____________________________________________________________________________ @@ -153,22 +163,52 @@ Double_t AliRsnPairParticle::GetInvMassMC(Double_t mass0, Double_t mass1) // and the sum of their energies as they result from assigned masses. // - if (!fDaughter[0] || !fDaughter[1]) { - AliError("One of the two tracks is NULL in this pair!"); - return -1000.0; - } - if (!fDaughter[0]->GetMCInfo() || !fDaughter[1]->GetMCInfo()) { - AliError("One of the two tracks has a NULL MCInfo in this pair!"); - return -1000.0; - } + if (!fDaughter[0] || !fDaughter[1]) + { + AliError("One of the two tracks is NULL in this pair!"); + return -1000.0; + } + if (!fDaughter[0]->GetMCInfo() || !fDaughter[1]->GetMCInfo()) + { + AliError("One of the two tracks has a NULL MCInfo in this pair!"); + return -1000.0; + } + + // compute track energies using the shortcut method defined in AliRsnDaughter + Double_t etot = 0.0; + etot += fDaughter[0]->GetMCInfo()->E(mass0); + etot += fDaughter[1]->GetMCInfo()->E(mass1); + + // compute & return invariant mass + return TMath::Sqrt(etot * etot - GetP2()); +} + +//_____________________________________________________________________________ +Double_t AliRsnPairParticle::GetEtot(Double_t mass0, Double_t mass1) const +{ +// +// Compute total pair energy from the sum of single track energies +// with a necessary mass hypothesis (rec. values). +// + Double_t etot = 0.0; + etot += fDaughter[0]->E(mass0); + etot += fDaughter[1]->E(mass1); + + return etot; +} - // compute track energies using the shortcut method defined in AliRsnDaughter +//_____________________________________________________________________________ +Double_t AliRsnPairParticle::GetEtotMC(Double_t mass0, Double_t mass1) const +{ +// +// Compute total pair energy from the sum of single track energies +// with a necessary mass hypothesis (MC values). +// Double_t etot = 0.0; etot += fDaughter[0]->GetMCInfo()->E(mass0); etot += fDaughter[1]->GetMCInfo()->E(mass1); - - // compute & return invariant mass - return TMath::Sqrt (etot * etot - GetP2()); + + return etot; } //_____________________________________________________________________________ @@ -179,14 +219,14 @@ Double_t AliRsnPairParticle::GetAngle() const // Return value is in DEGREES. // - Double_t dotProd = 0.0; - dotProd += fDaughter[0]->Px() * fDaughter[1]->Px(); - dotProd += fDaughter[0]->Py() * fDaughter[1]->Pz(); - dotProd += fDaughter[0]->Pz() * fDaughter[1]->Pz(); - - Double_t cosAngle = dotProd / (fDaughter[0]->P() * fDaughter[1]->P()); - - return TMath::ACos(cosAngle) * TMath::RadToDeg(); + Double_t dotProd = 0.0; + dotProd += fDaughter[0]->Px() * fDaughter[1]->Px(); + dotProd += fDaughter[0]->Py() * fDaughter[1]->Pz(); + dotProd += fDaughter[0]->Pz() * fDaughter[1]->Pz(); + + Double_t cosAngle = dotProd / (fDaughter[0]->P() * fDaughter[1]->P()); + + return TMath::ACos(cosAngle) * TMath::RadToDeg(); } //_____________________________________________________________________________ @@ -201,21 +241,24 @@ Bool_t AliRsnPairParticle::IsTruePair(Int_t refPDG) // if the mother is the same and its PDG code is equal to the argument. // - // if MC info is not available, the pairs is not true by default - if (!fDaughter[0]->GetMCInfo() || !fDaughter[1]->GetMCInfo()) { - return kFALSE; - } - - // check that labels are the same - if (fDaughter[0]->GetMCInfo()->Mother() != fDaughter[1]->GetMCInfo()->Mother()) { - return kFALSE; - } - - // if we reach this point, the two tracks have the same mother - // let's check now the PDG code of this common mother - Int_t motherPDG = TMath::Abs(fDaughter[0]->GetMCInfo()->MotherPDG()); - if (refPDG == 0) return kTRUE; - else return (motherPDG == refPDG); + // if MC info is not available, the pairs is not true by default + if (!fDaughter[0]->GetMCInfo() || !fDaughter[1]->GetMCInfo()) + { + AliInfo("Cannot know if the pairs is true or not because MC Info is not present"); + return kFALSE; + } + + // check that labels are the same + if (fDaughter[0]->GetMCInfo()->Mother() != fDaughter[1]->GetMCInfo()->Mother()) + { + return kFALSE; + } + + // if we reach this point, the two tracks have the same mother + // let's check now the PDG code of this common mother + Int_t motherPDG = TMath::Abs(fDaughter[0]->GetMCInfo()->MotherPDG()); + if (refPDG == 0) return kTRUE; + else return (motherPDG == refPDG); } //_____________________________________________________________________________ @@ -227,43 +270,46 @@ void AliRsnPairParticle::SetPair(AliRsnDaughter *daughter1, AliRsnDaughter *daug // and computes the total momentum for REC data and MC if available // - Int_t i; + Int_t i; - fDaughter[0] = daughter1; - fDaughter[1] = daughter2; - - // copy MC info (if available) - if (fDaughter[0]->GetMCInfo() && fDaughter[1]->GetMCInfo()) { - for (i = 0; i < 2; i++) { - fPTrackMC[i][0] = fDaughter[i]->GetMCInfo()->Px(); - fPTrackMC[i][1] = fDaughter[i]->GetMCInfo()->Py(); - fPTrackMC[i][2] = fDaughter[i]->GetMCInfo()->Pz(); - fMotherPDG[i] = fDaughter[i]->GetMCInfo()->MotherPDG(); - } - for (i = 0; i < 3; i++) fPTotMC[i] = fPTrackMC[0][i] + fPTrackMC[1][i]; - } + fDaughter[0] = daughter1; + fDaughter[1] = daughter2; - // copy reconstructed info (always available) - for (i = 0; i < 2; i++) { - fPTrack[i][0] = fDaughter[i]->Px(); - fPTrack[i][1] = fDaughter[i]->Py(); - fPTrack[i][2] = fDaughter[i]->Pz(); + // copy MC info (if available) + if (fDaughter[0]->GetMCInfo() && fDaughter[1]->GetMCInfo()) + { + for (i = 0; i < 2; i++) + { + fPTrackMC[i][0] = fDaughter[i]->GetMCInfo()->Px(); + fPTrackMC[i][1] = fDaughter[i]->GetMCInfo()->Py(); + fPTrackMC[i][2] = fDaughter[i]->GetMCInfo()->Pz(); + fMotherPDG[i] = fDaughter[i]->GetMCInfo()->MotherPDG(); } - for (i = 0; i < 3; i++) fPTot[i] = fPTrack[0][i] + fPTrack[1][i]; + for (i = 0; i < 3; i++) fPTotMC[i] = fPTrackMC[0][i] + fPTrackMC[1][i]; + } + + // copy reconstructed info (always available) + for (i = 0; i < 2; i++) + { + fPTrack[i][0] = fDaughter[i]->Px(); + fPTrack[i][1] = fDaughter[i]->Py(); + fPTrack[i][2] = fDaughter[i]->Pz(); + } + for (i = 0; i < 3; i++) fPTot[i] = fPTrack[0][i] + fPTrack[1][i]; } //_____________________________________________________________________________ -void AliRsnPairParticle::PrintInfo (const Option_t *option) +void AliRsnPairParticle::PrintInfo(const Option_t *option) { // -// Print some info of the pair. +// Print some info of the pair. // The options are passed to the AliRsnDaughter::Print() method // - AliInfo("======== BEGIN PAIR INFO ==========="); - AliInfo("Track #1"); - fDaughter[0]->Print(option); - AliInfo("Track #2"); - fDaughter[1]->Print(option); - AliInfo ("========= END PAIR INFO ==========="); + AliInfo("======== BEGIN PAIR INFO ==========="); + AliInfo("Track #1"); + fDaughter[0]->Print(option); + AliInfo("Track #2"); + fDaughter[1]->Print(option); + AliInfo("========= END PAIR INFO ==========="); } diff --git a/PWG2/RESONANCES/AliRsnPairParticle.h b/PWG2/RESONANCES/AliRsnPairParticle.h index 26cf0017030..07753220e9a 100644 --- a/PWG2/RESONANCES/AliRsnPairParticle.h +++ b/PWG2/RESONANCES/AliRsnPairParticle.h @@ -24,16 +24,17 @@ class AliRsnPairParticle : public TObject { -public: + public: AliRsnPairParticle(); AliRsnPairParticle(const AliRsnPairParticle &obj); AliRsnPairParticle& operator=(const AliRsnPairParticle &obj); virtual ~AliRsnPairParticle(); - Double_t GetInvMass (Double_t m1, Double_t m2); - Double_t GetInvMassMC (Double_t m1 = -1.0, Double_t m2 = -1.0); - + Double_t GetInvMass(Double_t m1, Double_t m2); + Double_t GetInvMassMC(Double_t m1, Double_t m2); + + Double_t GetEtot(Double_t m1, Double_t m2) const; Double_t GetP2() const {return (fPTot[0]*fPTot[0] + fPTot[1]*fPTot[1] + fPTot[2]*fPTot[2]);} Double_t GetPt2() const {return (fPTot[0]*fPTot[0] + fPTot[1]*fPTot[1]);} Double_t GetP() const {return TMath::Sqrt(GetP2());} @@ -41,7 +42,12 @@ public: Double_t GetPy() const {return fPTot[1];} Double_t GetPz() const {return fPTot[2];} Double_t GetPt() const {return TMath::Sqrt(GetPt2());} + Double_t GetPhi() const {return TMath::Pi() + TMath::ATan2(-fPTot[1], -fPTot[0]);} + Double_t GetTheta() const {if(fPTot[2]==0.0){return TMath::PiOver2();}else{return TMath::ACos(fPTot[2]/GetP());}} + Double_t GetEta() const {return -TMath::Log(TMath::ATan(0.5*GetTheta()));} + Double_t GetY(Double_t m1, Double_t m2) const {return 0.5*TMath::Log((GetEtot(m1,m2)+fPTot[2])/(GetEtot(m1,m2)-fPTot[2]));} + Double_t GetEtotMC(Double_t m1, Double_t m2) const; Double_t GetP2MC() const {return (fPTotMC[0]*fPTotMC[0] + fPTotMC[1]*fPTotMC[1] + fPTotMC[2]*fPTotMC[2]);} Double_t GetPt2MC() const {return (fPTotMC[0]*fPTotMC[0] + fPTotMC[1]*fPTotMC[1]);} Double_t GetPMC() const {return TMath::Sqrt(GetP2MC());} @@ -49,7 +55,11 @@ public: Double_t GetPyMC() const {return fPTotMC[1];} Double_t GetPzMC() const {return fPTotMC[2];} Double_t GetPtMC() const {return TMath::Sqrt(GetPt2MC());} - + Double_t GetPhiMC() const {return TMath::Pi() + TMath::ATan2(-fPTotMC[1], -fPTotMC[0]);} + Double_t GetThetaMC() const {if(fPTotMC[2]==0.0){return TMath::PiOver2();}else{return TMath::ACos(fPTotMC[2]/GetPMC());}} + Double_t GetEtaMC() const {return -TMath::Log(TMath::ATan(0.5*GetThetaMC()));} + Double_t GetYMC(Double_t m1, Double_t m2) const {return 0.5*TMath::Log((GetEtotMC(m1,m2)+fPTotMC[2])/(GetEtotMC(m1,m2)-fPTotMC[2]));} + Double_t GetAngle() const; AliRsnDaughter* GetDaughter(const Int_t &index) const {return fDaughter[index];} @@ -59,9 +69,9 @@ public: Bool_t IsTruePair(Int_t refPDG = 0); void SetPair(AliRsnDaughter *daughter1, AliRsnDaughter *daughter2); - void PrintInfo (const Option_t *option = ""); + void PrintInfo(const Option_t *option = ""); -private: + private: Double_t fPTot[3]; // total momentum computed with rec. values Double_t fPTotMC[3]; // total momentum computed with MC values @@ -73,7 +83,7 @@ private: AliRsnDaughter *fDaughter[2]; // elements of the pair - ClassDef (AliRsnPairParticle,1) + ClassDef(AliRsnPairParticle,1) }; #endif diff --git a/PWG2/RESONANCES/AliRsnReader.cxx b/PWG2/RESONANCES/AliRsnReader.cxx index c3dddf6cd3e..c4c128f4eb9 100644 --- a/PWG2/RESONANCES/AliRsnReader.cxx +++ b/PWG2/RESONANCES/AliRsnReader.cxx @@ -2,7 +2,7 @@ // Class AliRsnReader // // This is the universal converter from any kind of source event -// (i.e. ESD, standard AOD, MC) into the internal non-standard +// (i.e. ESD, standard AOD, MC) into the internal non-standard // AOD format used by RSN package. // --- // This class reads all tracks in an input event and converts them @@ -18,7 +18,6 @@ // #include -#include #include "AliLog.h" @@ -41,27 +40,31 @@ #include "AliRsnDaughter.h" #include "AliRsnEvent.h" #include "AliRsnPIDWeightsMgr.h" + #include "AliRsnReader.h" ClassImp(AliRsnReader) //_____________________________________________________________________________ -AliRsnReader::AliRsnReader(ESource source, AliRsnPIDWeightsMgr *mgr) : - TNamed("RsnReader", ""), - fSource(source), - fCheckSplit(kFALSE), - fRejectFakes(kFALSE), - fWeightsMgr(mgr) +AliRsnReader::AliRsnReader(AliRsnPIDWeightsMgr *mgr) : + TNamed("RsnReader", ""), + fCheckSplit(kFALSE), + fRejectFakes(kFALSE), + fWeightsMgr(mgr), + fCurrentPIDtype(AliRsnDaughter::kEsd), + fPIDDivValue(0.0), + fITSClusters(0), + fTPCClusters(0), + fTRDClusters(0) { // // Constructor. -// Adds also this object to global directory. // - gDirectory->Append(this, kTRUE); } //_____________________________________________________________________________ -Bool_t AliRsnReader::Fill(AliRsnEvent *rsn, AliVEvent *event, AliMCEvent *mc) +Bool_t AliRsnReader::Fill +(AliRsnEvent *rsn, AliVEvent *event, AliMCEvent *mc, Bool_t useTPCOnly) { // // According to the class type of event and the selected source @@ -72,42 +75,25 @@ Bool_t AliRsnReader::Fill(AliRsnEvent *rsn, AliVEvent *event, AliMCEvent *mc) Bool_t success = kFALSE; TString str(event->ClassName()); - switch (fSource) { - case kESD: - if (!str.Contains("AliESDEvent")) { - AliError(Form("Source class mismatch [expected: 'AliESDEvent' -- passed: '%s'", str.Data())); - return kFALSE; - } - success = FillFromESD(rsn, (AliESDEvent*)event, mc); - break; - case kESDTPC: - if (!str.Contains("AliESDEvent")) { - AliError(Form("Source class mismatch [expected: 'AliESDEvent' -- passed: '%s'", str.Data())); - return kFALSE; - } - success = FillFromESD(rsn, (AliESDEvent*)event, mc, kTRUE); - break; - case kAOD: - if (!str.Contains("AliAODEvent")) { - AliError(Form("Source class mismatch [expected: 'AliAODEvent' -- passed: '%s'", str.Data())); - return kFALSE; - } - success = FillFromAOD(rsn, (AliAODEvent*)event, mc); - break; - case kMC: - if (!str.Contains("AliMCEvent")) { - AliError(Form("Source class mismatch [expected: 'AliMCEvent' -- passed: '%s'", str.Data())); - return kFALSE; - } - success = FillFromMC(rsn, (AliMCEvent*)event); - break; - default: - return kFALSE; + if (!str.CompareTo("AliESDEvent")) { + AliDebug(1, "Reading an ESD event"); + success = FillFromESD(rsn, (AliESDEvent*)event, mc, useTPCOnly); } - + else if (!str.CompareTo("AliAODEvent")) { + AliDebug(1, "Reading an AOD event"); + success = FillFromAOD(rsn, (AliAODEvent*)event, mc); + } + else if (!str.CompareTo("AliMCEvent")) { + AliDebug(1, "Reading an MC event"); + success = FillFromMC(rsn, (AliMCEvent*)event); + } + else { + AliError(Form("ClassName '%s' not recognized as possible source data: aborting.", str.Data())); + return kFALSE; + } + // sort tracks w.r. to Pt (from largest to smallest) rsn->SortTracks(); - return success; } @@ -120,7 +106,7 @@ Bool_t AliRsnReader::FillFromESD // Stores all tracks (if a filter is defined, it will store // only the ones which survive the cuts). // If a reference MC event is provided, it is used to store -// the MC informations for each track (true PDG code, +// the MC informations for each track (true PDG code, // GEANT label of mother, PDG code of mother, if any). // When this is used, the 'source' flag of the output // AliRsnEvent object will be set to 'kESD'. @@ -140,20 +126,26 @@ Bool_t AliRsnReader::FillFromESD Int_t i1, i2, lab1, lab2; Bool_t *accept = new Bool_t[ntracks]; for (i1 = 0; i1 < ntracks; i1++) accept[i1] = kTRUE; - if (fCheckSplit) { - for (i1 = 0; i1 < ntracks; i1++) { + if (fCheckSplit) + { + for (i1 = 0; i1 < ntracks; i1++) + { AliESDtrack *trk1 = esd->GetTrack(i1); lab1 = TMath::Abs(trk1->GetLabel()); - for (i2 = i1+1; i2 < ntracks; i2++) { + for (i2 = i1+1; i2 < ntracks; i2++) + { AliESDtrack *trk2 = esd->GetTrack(i2); lab2 = TMath::Abs(trk2->GetLabel()); // check if labels are equal - if (lab1 == lab2) { - if (trk1->GetConstrainedChi2() < trk2->GetConstrainedChi2()) { + if (lab1 == lab2) + { + if (trk1->GetConstrainedChi2() < trk2->GetConstrainedChi2()) + { accept[i1] = kTRUE; accept[i2] = kFALSE; } - else { + else + { accept[i1] = kFALSE; accept[i2] = kTRUE; } @@ -164,12 +156,14 @@ Bool_t AliRsnReader::FillFromESD // get primary vertex Double_t vertex[3]; - if (!useTPCOnly) { + if (!useTPCOnly) + { vertex[0] = esd->GetVertex()->GetXv(); vertex[1] = esd->GetVertex()->GetYv(); vertex[2] = esd->GetVertex()->GetZv(); } - else { + else + { vertex[0] = esd->GetPrimaryVertexTPC()->GetXv(); vertex[1] = esd->GetPrimaryVertexTPC()->GetYv(); vertex[2] = esd->GetPrimaryVertexTPC()->GetZv(); @@ -177,12 +171,14 @@ Bool_t AliRsnReader::FillFromESD rsn->SetPrimaryVertex(vertex[0], vertex[1], vertex[2]); // store tracks from ESD - Int_t i, index, label, labmum; + Int_t i, index, label, labmum; Bool_t check; AliRsnDaughter temp; - for (index = 0; index < ntracks; index++) { + for (index = 0; index < ntracks; index++) + { // skip track recognized as the worse one in a splitted pair - if (!accept[index]) { + if (!accept[index]) + { AliInfo(Form("Rejecting split track #%d in this event", index)); continue; } @@ -192,12 +188,24 @@ Bool_t AliRsnReader::FillFromESD if (fRejectFakes && (label < 0)) continue; // copy ESD track data into RsnDaughter // if unsuccessful, this track is skipped - check = temp.Adopt(esdTrack, useTPCOnly); +// temp.SetCurrentESDPID(fCurrentPIDtype); + + if (fITSClusters>0) + if (esdTrack->GetITSclusters(0) < fITSClusters) continue; + + if (fTPCClusters>0) + if (esdTrack->GetTPCclusters(0) < fTPCClusters) continue; + + if (fTRDClusters>0) + if (esdTrack->GetTRDclusters(0) < fTRDClusters) continue; + + check = temp.Adopt(esdTrack,fCurrentPIDtype,fPIDDivValue, useTPCOnly); if (!check) continue; // if the AliRsnWeightsMgr object is initialized // this means that ESD PID weights are not used // and they are computed according to the Weight manager - if (fWeightsMgr) { + if (fWeightsMgr) + { //AliInfo("Using customized weights"); //AliInfo(Form("ESD weights = %f %f %f %f %f", temp.PID()[0], temp.PID()[1], temp.PID()[2], temp.PID()[3], temp.PID()[4], temp.PID()[5])); esdTrack->GetITSpid(fWeightsMgr->GetWeightArray(AliRsnPIDWeightsMgr::kITS)); @@ -205,22 +213,27 @@ Bool_t AliRsnReader::FillFromESD esdTrack->GetTRDpid(fWeightsMgr->GetWeightArray(AliRsnPIDWeightsMgr::kTRD)); esdTrack->GetTOFpid(fWeightsMgr->GetWeightArray(AliRsnPIDWeightsMgr::kTOF)); esdTrack->GetHMPIDpid(fWeightsMgr->GetWeightArray(AliRsnPIDWeightsMgr::kHMPID)); - for (i = 0; i < AliRsnPID::kSpecies; i++) { + for (i = 0; i < AliRsnPID::kSpecies; i++) + { temp.SetPIDWeight(i, fWeightsMgr->GetWeight((AliRsnPID::EType)i, temp.Pt())); } //AliInfo(Form("Used weights = %f %f %f %f %f", temp.PID()[0], temp.PID()[1], temp.PID()[2], temp.PID()[3], temp.PID()[4], temp.PID()[5])); } - else { + else + { //AliInfo("Using standard ESD weights"); } // if stack is present, copy MC info - if (stack) { + if (stack) + { TParticle *part = stack->Particle(TMath::Abs(label)); - if (part) { + if (part) + { temp.InitMCInfo(part); labmum = part->GetFirstMother(); - if (labmum >= 0) { + if (labmum >= 0) + { TParticle *mum = stack->Particle(labmum); temp.GetMCInfo()->SetMotherPDG(mum->GetPdgCode()); } @@ -235,8 +248,9 @@ Bool_t AliRsnReader::FillFromESD } // compute total multiplicity - if (rsn->GetMultiplicity() <= 0) { - AliWarning("Zero Multiplicity in this event"); + if (rsn->GetMultiplicity() <= 0) + { + AliDebug(1, "Zero Multiplicity in this event"); return kFALSE; } @@ -251,7 +265,7 @@ Bool_t AliRsnReader::FillFromAOD(AliRsnEvent *rsn, AliAODEvent *aod, AliMCEvent // Stores all tracks (if a filter is defined, it will store // only the ones which survive the cuts). // If a reference MC event is provided, it is used to store -// the MC informations for each track (true PDG code, +// the MC informations for each track (true PDG code, // GEANT label of mother, PDG code of mother, if any). // When this is used, the 'source' flag of the output // AliRsnEvent object will be set to 'kAOD'. @@ -263,9 +277,10 @@ Bool_t AliRsnReader::FillFromAOD(AliRsnEvent *rsn, AliAODEvent *aod, AliMCEvent // get number of tracks Int_t ntracks = aod->GetNTracks(); - if (!ntracks) { - AliWarning("No tracks in this event"); - return kFALSE; + if (!ntracks) + { + AliWarning("No tracks in this event"); + return kFALSE; } // get primary vertex @@ -276,12 +291,13 @@ Bool_t AliRsnReader::FillFromAOD(AliRsnEvent *rsn, AliAODEvent *aod, AliMCEvent rsn->SetPrimaryVertex(vertex[0], vertex[1], vertex[2]); // store tracks from ESD - Int_t index, label, labmum; + Int_t index, label, labmum; Bool_t check; AliAODTrack *aodTrack = 0; AliRsnDaughter temp; TObjArrayIter iter(aod->GetTracks()); - while ( (aodTrack = (AliAODTrack*)iter.Next()) ) { + while ((aodTrack = (AliAODTrack*)iter.Next())) + { // retrieve index index = aod->GetTracks()->IndexOf(aodTrack); label = aodTrack->GetLabel(); @@ -291,12 +307,15 @@ Bool_t AliRsnReader::FillFromAOD(AliRsnEvent *rsn, AliAODEvent *aod, AliMCEvent check = temp.Adopt(aodTrack); if (!check) continue; // if stack is present, copy MC info - if (stack) { + if (stack) + { TParticle *part = stack->Particle(TMath::Abs(label)); - if (part) { + if (part) + { temp.InitMCInfo(part); labmum = part->GetFirstMother(); - if (labmum >= 0) { + if (labmum >= 0) + { TParticle *mum = stack->Particle(labmum); temp.GetMCInfo()->SetMotherPDG(mum->GetPdgCode()); } @@ -311,8 +330,9 @@ Bool_t AliRsnReader::FillFromAOD(AliRsnEvent *rsn, AliAODEvent *aod, AliMCEvent } // compute total multiplicity - if (rsn->GetMultiplicity() <= 0) { - AliWarning("Zero multiplicity in this event"); + if (rsn->GetMultiplicity() <= 0) + { + AliDebug(1, "Zero multiplicity in this event"); return kFALSE; } @@ -324,9 +344,9 @@ Bool_t AliRsnReader::FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc) { // // Filler from an ESD event. -// Stores all tracks which generate at least one +// Stores all tracks which generate at least one // TrackReference (a point in a sensitive volume). -// In this case, the MC info is stored by default and +// In this case, the MC info is stored by default and // perfect particle identification is the unique available. // When this is used, the 'source' flag of the output // AliRsnEvent object will be set to 'kMC'. @@ -334,9 +354,10 @@ Bool_t AliRsnReader::FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc) // get number of tracks Int_t ntracks = mc->GetNumberOfTracks(); - if (!ntracks) { - AliWarning("No tracks in this event"); - return kFALSE; + if (!ntracks) + { + AliWarning("No tracks in this event"); + return kFALSE; } AliStack *stack = mc->Stack(); @@ -351,10 +372,11 @@ Bool_t AliRsnReader::FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc) rsn->SetPrimaryVertex(vertex[0], vertex[1], vertex[2]); // store tracks from MC - Int_t index, labmum; + Int_t index, labmum; Bool_t check; AliRsnDaughter temp; - for (index = 0; index < ntracks; index++) { + for (index = 0; index < ntracks; index++) + { // get and check MC track AliMCParticle *mcTrack = mc->GetTrack(index); // if particle has no track references, it is rejected @@ -363,7 +385,8 @@ Bool_t AliRsnReader::FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc) check = temp.Adopt(mcTrack); if (!check) continue; labmum = temp.GetMCInfo()->Mother(); - if (labmum >= 0) { + if (labmum >= 0) + { TParticle *mum = stack->Particle(labmum); temp.GetMCInfo()->SetMotherPDG(mum->GetPdgCode()); } @@ -376,10 +399,25 @@ Bool_t AliRsnReader::FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc) } // compute total multiplicity - if (rsn->GetMultiplicity() <= 0) { - AliWarning("Zero multiplicity in this event"); + if (rsn->GetMultiplicity() <= 0) + { + AliDebug(1, "Zero multiplicity in this event"); return kFALSE; } return kTRUE; } + +void AliRsnReader::SetPIDtype(const AliRsnDaughter::EPIDType & theValue, Double_t divValue) +{ + fCurrentPIDtype = theValue; + fPIDDivValue = divValue; +} + + +void AliRsnReader::SetITSTPCTRDSectors(const Int_t & its, const Int_t & tpc, const Int_t & trd) +{ + fITSClusters = its; + fTPCClusters = tpc; + fTRDClusters = trd; +} diff --git a/PWG2/RESONANCES/AliRsnReader.h b/PWG2/RESONANCES/AliRsnReader.h index 96ce1b2517b..070eecd5686 100644 --- a/PWG2/RESONANCES/AliRsnReader.h +++ b/PWG2/RESONANCES/AliRsnReader.h @@ -2,7 +2,7 @@ // Class AliRsnReader // // This is the universal converter from any kind of source event -// (i.e. ESD, standard AOD, MC) into the internal non-standard +// (i.e. ESD, standard AOD, MC) into the internal non-standard // AOD format used by RSN package. // --- // This class reads all tracks in an input event and converts them @@ -21,6 +21,7 @@ #define ALIRSNREADER_H #include +#include "AliRsnDaughter.h" class AliVEvent; class AliESDEvent; @@ -31,47 +32,50 @@ class AliRsnPIDWeightsMgr; class AliRsnReader : public TNamed { -public: + public: - enum ESource { - kESD = 0, - kESDTPC, - kAOD, - kMC, - kSources - }; - - AliRsnReader(ESource source = kESD, AliRsnPIDWeightsMgr *mgr = 0x0); + AliRsnReader(AliRsnPIDWeightsMgr *mgr = 0x0); virtual ~AliRsnReader() {} - - void SetSource(ESource source) {fSource = source;} + void SetWeightsMgr(AliRsnPIDWeightsMgr *mgr) {fWeightsMgr = mgr;} void SetCheckSplit(Bool_t doit = kTRUE) {fCheckSplit = doit;} void SetRejectFakes(Bool_t doit = kTRUE) {fRejectFakes = doit;} - - ESource GetSource() {return fSource;} + Bool_t CheckSplit() {return fCheckSplit;} Bool_t RejectFakes() {return fRejectFakes;} - Bool_t Fill(AliRsnEvent *rsn, AliVEvent *event, AliMCEvent *refMC = 0); - -protected: + + Bool_t Fill(AliRsnEvent *rsn, AliVEvent *event, AliMCEvent *refMC = 0, Bool_t useTPCOnly = kFALSE); + Bool_t FillFromESD(AliRsnEvent *rsn, AliESDEvent *event, AliMCEvent *refMC = 0, Bool_t useTPCOnly = kFALSE); + Bool_t FillFromAOD(AliRsnEvent *rsn, AliAODEvent *event, AliMCEvent *refMC = 0); + Bool_t FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc); + + // sets PID TYPE + void SetPIDtype(const AliRsnDaughter::EPIDType& theValue = AliRsnDaughter::kEsd, Double_t divValue = 0.0); + AliRsnDaughter::EPIDType GetPIDtype() const { return fCurrentPIDtype; } + + // sets Sectors cut + void SetITSTPCTRDSectors(const Int_t& its = -1, const Int_t& tpc = -1, const Int_t& trd = -1); + + protected: // dummy copy methods AliRsnReader(const AliRsnReader ©) : TNamed(copy), - fSource(kESD),fCheckSplit(0),fRejectFakes(0),fWeightsMgr(0x0) { /*nothing*/ } + fCheckSplit(0),fRejectFakes(0),fWeightsMgr(0x0),fCurrentPIDtype(AliRsnDaughter::kEsd), + fPIDDivValue(0.),fITSClusters(0),fTPCClusters(0),fTRDClusters(0) { /*nothing*/ } AliRsnReader& operator=(const AliRsnReader&) {return (*this);} - Bool_t FillFromESD(AliRsnEvent *rsn, AliESDEvent *event, AliMCEvent *refMC = 0, Bool_t useTPCOnly = kFALSE); - Bool_t FillFromAOD(AliRsnEvent *rsn, AliAODEvent *event, AliMCEvent *refMC = 0); - Bool_t FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc); + Bool_t fCheckSplit; // flag to check and remove split tracks + Bool_t fRejectFakes; // flag to reject fake tracks (negative label) + + AliRsnPIDWeightsMgr *fWeightsMgr; // manager for alternative PID weights + AliRsnDaughter::EPIDType fCurrentPIDtype; // PID type + Double_t fPIDDivValue; // PID div Value + Int_t fITSClusters; // + Int_t fTPCClusters; // + Int_t fTRDClusters; // - ESource fSource; // flag to choose what kind of data to be read - Bool_t fCheckSplit; // flag to check and remove split tracks - Bool_t fRejectFakes; // flag to reject fake tracks (negative label) - AliRsnPIDWeightsMgr *fWeightsMgr; // manager for alternative PID weights + private: -private: - ClassDef(AliRsnReader, 1); }; diff --git a/PWG2/RESONANCES/AliRsnReaderTask.cxx b/PWG2/RESONANCES/AliRsnReaderTask.cxx new file mode 100644 index 00000000000..208baf4a446 --- /dev/null +++ b/PWG2/RESONANCES/AliRsnReaderTask.cxx @@ -0,0 +1,141 @@ +// +// Class AliRsnReaderTask +// +// An AnalysisTask object to convert any kind of source event type (ESD/AOD/MC) +// into the RSN internal format (AliRsnEvent). +// The output of this task is a TTree with converted events, which is saved in a file +// and can then be processed as many times as desired, to build invariant mass spectra. +// --- +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// + +#include "AliLog.h" + +#include "AliAnalysisManager.h" +#include "AliMCEventHandler.h" +#include "AliMCEvent.h" +#include "AliESDInputHandler.h" +#include "AliAODInputHandler.h" +#include "AliAODHandler.h" + +#include "AliRsnEvent.h" +#include "AliRsnReader.h" +#include "AliRsnPID.h" +#include "AliRsnReaderTask.h" + +ClassImp(AliRsnReaderTask) + +//_____________________________________________________________________________ +AliRsnReaderTask::AliRsnReaderTask() : + AliRsnBaseAT(), + fRsnTree(0x0) +{ +//========================================================= +// Default constructor (not recommended) +//========================================================= +} + +//_____________________________________________________________________________ +AliRsnReaderTask::AliRsnReaderTask(const char *name) : + AliRsnBaseAT(name), + fRsnTree(0x0) +{ +//========================================================= +// Working constructor (recommended) +//========================================================= + InitIOVars(); + DefineOutput(0, TTree::Class()); +} + +//_____________________________________________________________________________ +AliRsnReaderTask::AliRsnReaderTask(const AliRsnReaderTask& obj) : + AliRsnBaseAT(obj), + fRsnTree(0x0) +{ +//========================================================= +// Copy constructor (not recommended) +//========================================================= +} + +//_____________________________________________________________________________ +AliRsnReaderTask& AliRsnReaderTask::operator= (const AliRsnReaderTask& /*obj*/) +{ +//========================================================= +// Assignment operator (not recommended) +//========================================================= + + AliInfo("Not implemented. Avoid using the assignment operator"); + return *this; +} + +//_____________________________________________________________________________ +void AliRsnReaderTask::InitIOVars() +{ +//========================================================= +// Init values for input and output data +//========================================================= + AliDebug(AliLog::kDebug, "<-"); + AliRsnBaseAT::InitIOVars(); + AliDebug(AliLog::kDebug, "->"); +} + +//_____________________________________________________________________________ +void AliRsnReaderTask::CreateOutputObjects() +{ +//========================================================= +// Create the output container +//========================================================= + + AliDebug(1, "Creating output objects"); + OpenFile(0); + fRsnTree = new TTree("aodTree", "AliRsnEvents"); + + fRSN[0] = new AliRsnEvent(); + fRSN[0]->SetName("rsnEvents"); + fRSN[0]->Init(); + fRsnTree->Branch("rsnEvents","AliRsnEvent",&fRSN[0]); +// AddAODBranch("AliRsnEvent", &fRsnEvent); +} + +//_____________________________________________________________________________ +void AliRsnReaderTask::LocalInit() +{ +//========================================================= +// Initialization +//========================================================= + + AliDebug(1, "Initializing"); +} + +Bool_t AliRsnReaderTask::Notify() +{ + return kTRUE; +} + +//_____________________________________________________________________________ +void AliRsnReaderTask::Exec(Option_t */*option*/) +{ +//========================================================= +// Loops on input container to store data of all tracks. +// Uses the AliRsnReader methods to save them in the output. +//========================================================= + + fRSN[0] = GetRsnEventFromInputType(0); + if (!fRSN[0]) return; + AliInfo(Form("Collected %d tracks", fRSN[0]->GetMultiplicity())); + + fRsnTree->Fill(); + PostData(0, fRsnTree); +} + +//_____________________________________________________________________________ +void AliRsnReaderTask::Terminate(Option_t */*option*/) +{ +//========================================================= +// Terminate analysis +//========================================================= + + AliDebug(1, "Terminating"); +} + diff --git a/PWG2/RESONANCES/AliRsnReaderTask.h b/PWG2/RESONANCES/AliRsnReaderTask.h new file mode 100644 index 00000000000..68f787e9c31 --- /dev/null +++ b/PWG2/RESONANCES/AliRsnReaderTask.h @@ -0,0 +1,43 @@ +// +// Class AliRsnReaderTask +// +// TODO +// +// authors: Martin Vala (martin.vala@cern.ch) +// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it) +// +#ifndef ALIRSNREADERTASK_H +#define ALIRSNREADERTASK_H + +#include "AliRsnBaseAT.h" + +class AliRsnPID; +class AliRsnReader; + +class AliRsnReaderTask : public AliRsnBaseAT +{ + public: + + AliRsnReaderTask(); + AliRsnReaderTask(const char *name); + virtual ~AliRsnReaderTask() {} + + // Implementation of interface methods + virtual void InitIOVars(); + virtual void LocalInit(); + virtual Bool_t Notify(); + virtual void CreateOutputObjects(); + virtual void Exec(Option_t *option); + virtual void Terminate(Option_t *); + + private: + + AliRsnReaderTask(const AliRsnReaderTask&); + AliRsnReaderTask& operator= (const AliRsnReaderTask&); + + TTree* fRsnTree; // output tree + + ClassDef(AliRsnReaderTask, 0) // implementation of RsnReader as AnalysisTask +}; + +#endif diff --git a/PWG2/RESONANCES/AliRsnReaderTaskSE.cxx b/PWG2/RESONANCES/AliRsnReaderTaskSE.cxx index 64894270ae0..7e2b1ba8f96 100644 --- a/PWG2/RESONANCES/AliRsnReaderTaskSE.cxx +++ b/PWG2/RESONANCES/AliRsnReaderTaskSE.cxx @@ -30,10 +30,8 @@ ClassImp(AliRsnReaderTaskSE) //_____________________________________________________________________________ AliRsnReaderTaskSE::AliRsnReaderTaskSE() : - AliAnalysisTaskSE(), - fReader(0x0), - fPID(0x0), - fRsnEvent(0x0) + AliRsnAnalysisTaskSEBase(), + fRsnEvent(0x0) { // // Default constructor (not recommended) @@ -42,10 +40,8 @@ AliRsnReaderTaskSE::AliRsnReaderTaskSE() : //_____________________________________________________________________________ AliRsnReaderTaskSE::AliRsnReaderTaskSE(const char *name) : - AliAnalysisTaskSE(name), - fReader(0x0), - fPID(0x0), - fRsnEvent(0x0) + AliRsnAnalysisTaskSEBase(name), + fRsnEvent(0x0) { // // Working constructor (recommended) @@ -63,19 +59,10 @@ void AliRsnReaderTaskSE::UserCreateOutputObjects() // raises a fatal error which breaks the AliRoot session. // - if (!fReader) { - AliFatal("Event reader not initialized. Impossible to continue"); - return; - } - if (!fPID) { - AliFatal("PID not initialized. Impossible to continue"); - return; - } - - fRsnEvent = new AliRsnEvent(); - fRsnEvent->SetName("rsnEvents"); - fRsnEvent->Init(); - AddAODBranch("AliRsnEvent", &fRsnEvent); + fRsnEvent = new AliRsnEvent(); + fRsnEvent->SetName("rsnEvents"); + fRsnEvent->Init(); + AddAODBranch("AliRsnEvent", &fRsnEvent); } //_____________________________________________________________________________ @@ -96,19 +83,47 @@ void AliRsnReaderTaskSE::UserExec(Option_t */*option*/) // and store them in the output AOD event, with all required computations. // - AliInfo(Form("Reading event %d", ++fEntry)); - - // before adding new data, the ones from previous event - // must be cleared explicitly - fRsnEvent->Clear(); - - // step 1: conversion - if (!fReader->Fill(fRsnEvent, fInputEvent, fMCEvent)) AliWarning("Failed reading"); + AliInfo(Form("Reading event %d", ++fEntry)); + + // before adding new data, the ones from previous event + // must be cleared explicitly + fRsnEvent->Clear(); + + + // step 1: conversion + Bool_t ok = kFALSE; + switch (fInputType[0]) + { + case kAOD: + AliDebug(5, "Reading AOD event..."); + ok = fReader.FillFromAOD(fRsnEvent, (AliAODEvent*)fInputEvent, fMCEvent); + AliDebug(5, "...done"); + break; + case kESD: + AliDebug(5, "Reading ESD event..."); + ok = fReader.FillFromESD(fRsnEvent, (AliESDEvent*)fInputEvent, fMCEvent); + AliDebug(5, "...done"); + break; + case kESDMC: + AliDebug(5, "Reading ESD event with MC..."); + ok = fReader.FillFromESD(fRsnEvent, (AliESDEvent*)fInputEvent, fMCEvent); + AliDebug(5, "...done"); + break; + case kMC: + AliDebug(5, "Reading MC only event..."); + ok = fReader.FillFromMC(fRsnEvent, fMCEvent); + AliDebug(5, "...done"); + break; + default: + AliError("Type not supported ..."); + return; + } + if (!ok) AliWarning("Failed reading"); - // step 2: PID probability computation - if (!fPID->Process(fRsnEvent)) AliWarning("Failed PID"); + // step 2: PID probability computation + if (!fPID.Process(fRsnEvent)) AliWarning("Failed PID"); - AliInfo(Form("Collected %d tracks", fRsnEvent->GetMultiplicity())); + AliInfo(Form("Collected %d tracks", fRsnEvent->GetMultiplicity())); } //_____________________________________________________________________________ diff --git a/PWG2/RESONANCES/AliRsnReaderTaskSE.h b/PWG2/RESONANCES/AliRsnReaderTaskSE.h index 9f55418ce97..9cb0e0dc469 100644 --- a/PWG2/RESONANCES/AliRsnReaderTaskSE.h +++ b/PWG2/RESONANCES/AliRsnReaderTaskSE.h @@ -13,13 +13,13 @@ #ifndef AliRsnReaderTaskSE_H #define AliRsnReaderTaskSE_H -#include "AliAnalysisTaskSE.h" +#include "AliRsnAnalysisTaskSEBase.h" class AliRsnPID; class AliESDEvent; class AliRsnReader; -class AliRsnReaderTaskSE : public AliAnalysisTaskSE +class AliRsnReaderTaskSE : public AliRsnAnalysisTaskSEBase { public: @@ -34,21 +34,19 @@ public: virtual void UserExec(Option_t *option); virtual void Terminate(Option_t *option); - void SetReader(AliRsnReader *reader) {fReader = reader;} - void SetPID(AliRsnPID *pid) {fPID = pid;} - AliRsnReader* GetReader() {return fReader;} - AliRsnPID* GetPID() {return fPID;} +// void SetReader(AliRsnReader *reader) {fReader = reader;} +// void SetPID(AliRsnPID *pid) {fPID = pid;} +// AliRsnReader* GetReader() {return fReader;} +// AliRsnPID* GetPID() {return fPID;} AliRsnEvent* GetCurrentEvent() {return fRsnEvent;} private: AliRsnReaderTaskSE(const AliRsnReaderTaskSE ©) : - AliAnalysisTaskSE(copy),fReader(0x0),fPID(0x0),fRsnEvent(0x0) { /*nothing*/ } + AliRsnAnalysisTaskSEBase(copy),fRsnEvent(0x0) { /*nothing*/ } AliRsnReaderTaskSE& operator=(const AliRsnReaderTaskSE&) { /*nothing*/ return (*this); } - AliRsnReader *fReader; // read manager - AliRsnPID *fPID; // PID manager AliRsnEvent *fRsnEvent; // output events in the AliRsnEvent format ClassDef(AliRsnReaderTaskSE, 1); // implementation of RsnReader as AnalysisTaskSE diff --git a/PWG2/RESONANCES/AliRsnSimpleAnalysis.cxx b/PWG2/RESONANCES/AliRsnSimpleAnalysis.cxx index 89d3feb1412..7bcd74f1593 100644 --- a/PWG2/RESONANCES/AliRsnSimpleAnalysis.cxx +++ b/PWG2/RESONANCES/AliRsnSimpleAnalysis.cxx @@ -53,19 +53,19 @@ ClassImp(AliRsnSimpleAnalysis) //_____________________________________________________________________________ AliRsnSimpleAnalysis::AliRsnSimpleAnalysis(AliRsnSimpleAnalyzer *ana, AliRsnPID *pid) : - TObject(), - fInitialized(kFALSE), - fStep(1000), - fTree(0x0), - fPID(pid), - fAnalyzer(ana) + TObject(), + fInitialized(kFALSE), + fStep(1000), + fTree(0x0), + fPID(pid), + fAnalyzer(ana) { // // Constructor // Initializes all pointers and collections to NULL. // - strcpy(fFileName, "default.root"); + strcpy(fFileName, "default.root"); } @@ -85,8 +85,8 @@ void AliRsnSimpleAnalysis::SetEventsTree(TTree *tree) // Counts also the number of events and stores it in a private datamember. // This can avoid the time-wasting entries count in a long TChain. // - fTree = tree; - AliInfo(Form("Total number of events to be processed: %d", fTree->GetEntries())); + fTree = tree; + AliInfo(Form("Total number of events to be processed: %d", fTree->GetEntries())); } //_____________________________________________________________________________ @@ -95,19 +95,20 @@ Bool_t AliRsnSimpleAnalysis::Initialize() // // Various initialization processes // - // check process objects - if (!fAnalyzer) { - AliError("Analyzer not initialized"); - return kFALSE; - } + // check process objects + if (!fAnalyzer) + { + AliError("Analyzer not initialized"); + return kFALSE; + } - // initialize analyzer - fAnalyzer->Init(); + // initialize analyzer + fAnalyzer->Init(); - // at the end, update flag for initialization - fInitialized = kTRUE; + // at the end, update flag for initialization + fInitialized = kTRUE; - return kTRUE; + return kTRUE; } //_____________________________________________________________________________ @@ -118,32 +119,34 @@ Stat_t AliRsnSimpleAnalysis::Process() // Depending on the kind of background evaluation method, computes also this one. // - // check initialization - if (!fInitialized) { - AliError("Analysis not initialized. Use method 'Initialize()'"); - return 0.0; - } - - // set cursor object - AliRsnEvent *event = 0x0; - fTree->SetBranchAddress("rsnEvents", &event); - - // output counter - Stat_t nPairs = 0.0; - - // loop on events - Int_t i, nEvents = (Int_t)fTree->GetEntries(); - for (i = 0; i < nEvents; i++) { - // message - if ((i % fStep) == 0) AliInfo(Form("Processing event %d", i)); - // get entry - fTree->GetEntry(i); - if (!event) continue; - fPID->Process(event); - fAnalyzer->Process(event); - } - - return nPairs; + // check initialization + if (!fInitialized) + { + AliError("Analysis not initialized. Use method 'Initialize()'"); + return 0.0; + } + + // set cursor object + AliRsnEvent *event = 0x0; + fTree->SetBranchAddress("rsnEvents", &event); + + // output counter + Stat_t nPairs = 0.0; + + // loop on events + Int_t i, nEvents = (Int_t)fTree->GetEntries(); + for (i = 0; i < nEvents; i++) + { + // message + if ((i % fStep) == 0) AliInfo(Form("Processing event %d", i)); + // get entry + fTree->GetEntry(i); + if (!event) continue; + fPID->Process(event); + fAnalyzer->Process(event); + } + + return nPairs; } //_____________________________________________________________________________ @@ -152,25 +155,28 @@ void AliRsnSimpleAnalysis::SaveOutput() const // // Writes histograms in current directory // - TFile *file = TFile::Open(fFileName, "RECREATE"); - AliRsnSimpleFunction *pair = 0; - TH1D *h1D = 0; - TH2D *h2D = 0; - TObjArrayIter pairIterator(fAnalyzer->GetSingle()); - while ( (pair = (AliRsnSimpleFunction*)pairIterator.Next()) ) { - h1D = pair->GetHistogram1D(); - h2D = pair->GetHistogram2D(); - if (h1D) h1D->Write(); - if (h2D) h2D->Write(); + TFile *file = TFile::Open(fFileName, "RECREATE"); + AliRsnSimpleFunction *pair = 0; + TH1D *h1D = 0; + TH2D *h2D = 0; + TObjArrayIter pairIterator(fAnalyzer->GetSingle()); + while ((pair = (AliRsnSimpleFunction*)pairIterator.Next())) + { + h1D = pair->GetHistogram1D(); + h2D = pair->GetHistogram2D(); + if (h1D) h1D->Write(); + if (h2D) h2D->Write(); + } + if (fAnalyzer->GetMix() && !fAnalyzer->GetMix()->IsEmpty()) + { + TObjArrayIter mixIterator(fAnalyzer->GetMix()); + while ((pair = (AliRsnSimpleFunction*)mixIterator.Next())) + { + h1D = pair->GetHistogram1D(); + h2D = pair->GetHistogram2D(); + if (h1D) h1D->Write(); + if (h2D) h2D->Write(); } - if (fAnalyzer->GetMix() && !fAnalyzer->GetMix()->IsEmpty()) { - TObjArrayIter mixIterator(fAnalyzer->GetMix()); - while ( (pair = (AliRsnSimpleFunction*)mixIterator.Next()) ) { - h1D = pair->GetHistogram1D(); - h2D = pair->GetHistogram2D(); - if (h1D) h1D->Write(); - if (h2D) h2D->Write(); - } - } - file->Close(); + } + file->Close(); } diff --git a/PWG2/RESONANCES/AliRsnSimpleAnalysis.h b/PWG2/RESONANCES/AliRsnSimpleAnalysis.h index 307d4e19883..a56f6335644 100644 --- a/PWG2/RESONANCES/AliRsnSimpleAnalysis.h +++ b/PWG2/RESONANCES/AliRsnSimpleAnalysis.h @@ -23,7 +23,7 @@ class AliRsnSimpleAnalyzer; class AliRsnSimpleAnalysis : public TObject { -public: + public: AliRsnSimpleAnalysis(AliRsnSimpleAnalyzer *ana = 0x0, AliRsnPID *pid = 0x0); virtual ~AliRsnSimpleAnalysis() {Clear();} @@ -39,12 +39,12 @@ public: Stat_t Process(); void SaveOutput() const; -private: + private: AliRsnSimpleAnalysis(const AliRsnSimpleAnalysis ©) : - TObject(copy),fInitialized(kFALSE),fStep(1000),fTree(0x0),fPID(0x0),fAnalyzer(0x0) { } - AliRsnSimpleAnalysis& operator=(const AliRsnSimpleAnalysis & /*copy*/) - { return (*this); } + TObject(copy),fInitialized(kFALSE),fStep(1000),fTree(0x0),fPID(0x0),fAnalyzer(0x0) { } + AliRsnSimpleAnalysis& operator=(const AliRsnSimpleAnalysis & /*copy*/) + { return (*this); } Bool_t fInitialized; // flag to check initialization Int_t fStep; // progress step diff --git a/PWG2/RESONANCES/AliRsnSimpleAnalysisTaskSE.cxx b/PWG2/RESONANCES/AliRsnSimpleAnalysisTaskSE.cxx index 65882d25650..4772fc2ff67 100644 --- a/PWG2/RESONANCES/AliRsnSimpleAnalysisTaskSE.cxx +++ b/PWG2/RESONANCES/AliRsnSimpleAnalysisTaskSE.cxx @@ -51,12 +51,12 @@ ClassImp(AliRsnSimpleAnalysisTaskSE) //_____________________________________________________________________________ AliRsnSimpleAnalysisTaskSE::AliRsnSimpleAnalysisTaskSE() : - AliAnalysisTaskSE(), - fReader(0x0), - fPID(0x0), - fAnalyzer(0x0), - fRsnEvent(0x0), - fHistograms(0x0) + AliAnalysisTaskSE(), + fReader(0x0), + fPID(0x0), + fAnalyzer(0x0), + fRsnEvent(0x0), + fHistograms(0x0) { // // Default constructor (not recommended) @@ -65,18 +65,18 @@ AliRsnSimpleAnalysisTaskSE::AliRsnSimpleAnalysisTaskSE() : //_____________________________________________________________________________ AliRsnSimpleAnalysisTaskSE::AliRsnSimpleAnalysisTaskSE(const char *name) : - AliAnalysisTaskSE(name), - fReader(0x0), - fPID(0x0), - fAnalyzer(0x0), - fRsnEvent(0x0), - fHistograms(0x0) + AliAnalysisTaskSE(name), + fReader(0x0), + fPID(0x0), + fAnalyzer(0x0), + fRsnEvent(0x0), + fHistograms(0x0) { // // Working constructor (recommended) // - DefineOutput (1, TList::Class()); + DefineOutput(1, TList::Class()); } //_____________________________________________________________________________ @@ -86,57 +86,66 @@ void AliRsnSimpleAnalysisTaskSE::UserCreateOutputObjects() // Create the output container // - // check for presence of NECESSARY data-members - if (!fReader) { - AliFatal("Event reader not initialized. Impossible to continue. Aborting with fatal error."); - return; - } - if (!fPID) { - AliFatal("PID manager not initialized. Impossible to continue. Aborting with fatal error."); - return; - } - if (!fAnalyzer) { - AliFatal("Analysis manager not initialized. Impossible to continue. Aborting with fatal error."); - return; - } + // check for presence of NECESSARY data-members + if (!fReader) + { + AliFatal("Event reader not initialized. Impossible to continue. Aborting with fatal error."); + return; + } + if (!fPID) + { + AliFatal("PID manager not initialized. Impossible to continue. Aborting with fatal error."); + return; + } + if (!fAnalyzer) + { + AliFatal("Analysis manager not initialized. Impossible to continue. Aborting with fatal error."); + return; + } + + // output histogram list + fHistograms = new TList; + + // initialize analyzer + fAnalyzer->Init(); + + // store all histograms in the functions into the list + TObjArray *array = fAnalyzer->GetSingle(); + AliRsnSimpleFunction *fcn; + TH1D *h1D; + TH2D *h2D; + if (array) + { + TObjArrayIter iter(array); + while ((fcn = (AliRsnSimpleFunction*)iter.Next())) + { + h1D = fcn->GetHistogram1D(); + h2D = fcn->GetHistogram2D(); + if (h1D) fHistograms->AddLast(h1D); + if (h2D) fHistograms->AddLast(h2D); - // output histogram list - fHistograms = new TList; - - // initialize analyzer - fAnalyzer->Init(); - - // store all histograms in the functions into the list - TObjArray *array = fAnalyzer->GetSingle(); - AliRsnSimpleFunction *fcn; - TH1D *h1D; - TH2D *h2D; - if (array) { - TObjArrayIter iter(array); - while ( (fcn = (AliRsnSimpleFunction*)iter.Next()) ) { - h1D = fcn->GetHistogram1D(); - h2D = fcn->GetHistogram2D(); - if (h1D) fHistograms->AddLast(h1D); - if (h2D) fHistograms->AddLast(h2D); - - } - } - else { - AliWarning("No single-event functions in analyzer"); - } - array = fAnalyzer->GetMix(); - if (array) { - TObjArrayIter iter(array); - while ( (fcn = (AliRsnSimpleFunction*)iter.Next()) ) { - h1D = fcn->GetHistogram1D(); - h2D = fcn->GetHistogram2D(); - if (h1D) fHistograms->AddLast(h1D); - if (h2D) fHistograms->AddLast(h2D); - } } - else { - AliWarning("No mixing functions in analyzer"); + } + else + { + AliWarning("No single-event functions in analyzer"); + } + array = fAnalyzer->GetMix(); + if (array) + { + TObjArrayIter iter(array); + while ((fcn = (AliRsnSimpleFunction*)iter.Next())) + { + h1D = fcn->GetHistogram1D(); + h2D = fcn->GetHistogram2D(); + if (h1D) fHistograms->AddLast(h1D); + if (h2D) fHistograms->AddLast(h2D); } + } + else + { + AliWarning("No mixing functions in analyzer"); + } } //_____________________________________________________________________________ @@ -147,25 +156,26 @@ void AliRsnSimpleAnalysisTaskSE::UserExec(Option_t */*option*/) // Uses the AliRsnReader methods to save them in the output. // - // clear previous event - if (!fRsnEvent) { - fRsnEvent = new AliRsnEvent; - fRsnEvent->Init(); - } - else fRsnEvent->Clear(); - - // read event - if (!fReader->Fill(fRsnEvent, fInputEvent, fMCEvent)) AliWarning("Failed reading"); - AliInfo(Form("Collected %d tracks", fRsnEvent->GetMultiplicity())); - - // identify event if the class is available - if (fPID) fPID->Process(fRsnEvent); - - // process event with analyzer - fAnalyzer->Process(fRsnEvent); - - // post histograms in slot #1 - PostData(1, fHistograms); + // clear previous event + if (!fRsnEvent) + { + fRsnEvent = new AliRsnEvent; + fRsnEvent->Init(); + } + else fRsnEvent->Clear(); + + // read event + if (!fReader->Fill(fRsnEvent, fInputEvent, fMCEvent)) AliWarning("Failed reading"); + AliInfo(Form("Collected %d tracks", fRsnEvent->GetMultiplicity())); + + // identify event if the class is available + if (fPID) fPID->Process(fRsnEvent); + + // process event with analyzer + fAnalyzer->Process(fRsnEvent); + + // post histograms in slot #1 + PostData(1, fHistograms); } //_____________________________________________________________________________ @@ -177,28 +187,31 @@ Bool_t AliRsnSimpleAnalysisTaskSE::Configure(const char *configFile) // Returns kFALSE if not all the required objects were created. // - gROOT->LoadMacro(configFile); - gROOT->ProcessLine("RsnConfig()"); - - fReader = (AliRsnReader*)gDirectory->Get("RsnReader"); - fPID = (AliRsnPID*)gDirectory->Get("RsnPID"); - fAnalyzer = (AliRsnSimpleAnalyzer*)gDirectory->Get("RsnSimpleAnalyzer"); - - // check for presence of NECESSARY data-members - if (!fReader) { - AliError("Event reader not initialized. Impossible to continue. Aborting with fatal error."); - return kFALSE; - } - if (!fPID) { - AliError("PID manager not initialized. Impossible to continue. Aborting with fatal error."); - return kFALSE; - } - if (!fAnalyzer) { - AliError("Analysis manager not initialized. Impossible to continue. Aborting with fatal error."); - return kFALSE; - } - - return kTRUE; + gROOT->LoadMacro(configFile); + gROOT->ProcessLine("RsnConfig()"); + + fReader = (AliRsnReader*)gDirectory->Get("RsnReader"); + fPID = (AliRsnPID*)gDirectory->Get("RsnPID"); + fAnalyzer = (AliRsnSimpleAnalyzer*)gDirectory->Get("RsnSimpleAnalyzer"); + + // check for presence of NECESSARY data-members + if (!fReader) + { + AliError("Event reader not initialized. Impossible to continue. Aborting with fatal error."); + return kFALSE; + } + if (!fPID) + { + AliError("PID manager not initialized. Impossible to continue. Aborting with fatal error."); + return kFALSE; + } + if (!fAnalyzer) + { + AliError("Analysis manager not initialized. Impossible to continue. Aborting with fatal error."); + return kFALSE; + } + + return kTRUE; } //_____________________________________________________________________________ @@ -208,53 +221,58 @@ void AliRsnSimpleAnalysisTaskSE::PrintSettings() // Print analysis settings // - AliInfo("==== ANALYSIS TASK INFO ======================================================="); - - // reader - AliInfo(Form("Reader address, name: %x %s", fReader, fReader->GetName())); - switch (fReader->GetSource()) { - case AliRsnReader::kESD: - AliInfo("Reader source: kESD"); - break; - case AliRsnReader::kESDTPC: - AliInfo("Reader source: kESDTPC"); - break; - case AliRsnReader::kAOD: - AliInfo("Reader source: kAOD"); - break; - case AliRsnReader::kMC: - AliInfo("Reader source: kMC"); - break; - default: - AliInfo("Reader source not properly set"); - } - AliInfo(Form("Reader->CheckSplit = %s", (fReader->CheckSplit() ? "true" : "false"))); - AliInfo(Form("Reader->RejectFakes = %s", (fReader->RejectFakes() ? "true" : "false"))); - - // PID - Int_t i; - AliRsnPID::EType type; - AliInfo(Form("PID address, name: %x", fPID, fPID->GetName())); - for (i = 0; i < AliRsnPID::kSpecies; i++) { - type = (AliRsnPID::EType)i; - AliInfo(Form("Prior probability [%d] = %f (%s)", i, fPID->GetPriorProbability(type), AliRsnPID::ParticleName(type))); - } - AliInfo(Form("PID momentum threshold = %f", fPID->GetMaxPt())); - AliInfo(Form("PID probability threshold = %f", fPID->GetMinProb())); - - // analyzer - AliRsnSimpleFunction *fcn; - AliInfo(Form("Analyzer address, name: %x", fAnalyzer, fAnalyzer->GetName())); - TObjArrayIter iter1(fAnalyzer->GetSingle()); - while ( (fcn = (AliRsnSimpleFunction*)iter1.Next()) ) { - AliInfo(Form("Single-event function: %s [%s]", fcn->GetName(), fcn->ClassName())); - } - if (fAnalyzer->GetMix()) { - TObjArrayIter iter2(fAnalyzer->GetMix()); - while ( (fcn = (AliRsnSimpleFunction*)iter2.Next()) ) { - AliInfo(Form("Mix function: %s [%s]", fcn->GetName(), fcn->ClassName())); - } + AliInfo("==== ANALYSIS TASK INFO ======================================================="); + + // reader + AliInfo(Form("Reader address, name: %x %s", fReader, fReader->GetName())); + switch (fReader->GetSource()) + { + case AliRsnReader::kESD: + AliInfo("Reader source: kESD"); + break; + case AliRsnReader::kESDTPC: + AliInfo("Reader source: kESDTPC"); + break; + case AliRsnReader::kAOD: + AliInfo("Reader source: kAOD"); + break; + case AliRsnReader::kMC: + AliInfo("Reader source: kMC"); + break; + default: + AliInfo("Reader source not properly set"); + } + AliInfo(Form("Reader->CheckSplit = %s", (fReader->CheckSplit() ? "true" : "false"))); + AliInfo(Form("Reader->RejectFakes = %s", (fReader->RejectFakes() ? "true" : "false"))); + + // PID + Int_t i; + AliRsnPID::EType type; + AliInfo(Form("PID address, name: %x", fPID, fPID->GetName())); + for (i = 0; i < AliRsnPID::kSpecies; i++) + { + type = (AliRsnPID::EType)i; + AliInfo(Form("Prior probability [%d] = %f (%s)", i, fPID->GetPriorProbability(type), AliRsnPID::ParticleName(type))); + } + AliInfo(Form("PID momentum threshold = %f", fPID->GetMaxPt())); + AliInfo(Form("PID probability threshold = %f", fPID->GetMinProb())); + + // analyzer + AliRsnSimpleFunction *fcn; + AliInfo(Form("Analyzer address, name: %x", fAnalyzer, fAnalyzer->GetName())); + TObjArrayIter iter1(fAnalyzer->GetSingle()); + while ((fcn = (AliRsnSimpleFunction*)iter1.Next())) + { + AliInfo(Form("Single-event function: %s [%s]", fcn->GetName(), fcn->ClassName())); + } + if (fAnalyzer->GetMix()) + { + TObjArrayIter iter2(fAnalyzer->GetMix()); + while ((fcn = (AliRsnSimpleFunction*)iter2.Next())) + { + AliInfo(Form("Mix function: %s [%s]", fcn->GetName(), fcn->ClassName())); } + } - AliInfo("==============================================================================="); + AliInfo("==============================================================================="); } diff --git a/PWG2/RESONANCES/AliRsnSimpleAnalysisTaskSE.h b/PWG2/RESONANCES/AliRsnSimpleAnalysisTaskSE.h index d1d09e15ae4..579bc2d29d7 100644 --- a/PWG2/RESONANCES/AliRsnSimpleAnalysisTaskSE.h +++ b/PWG2/RESONANCES/AliRsnSimpleAnalysisTaskSE.h @@ -29,30 +29,30 @@ class AliRsnSimpleAnalyzer; class AliRsnSimpleAnalysisTaskSE : public AliAnalysisTaskSE { -public: + public: AliRsnSimpleAnalysisTaskSE(); AliRsnSimpleAnalysisTaskSE(const char *name); virtual ~AliRsnSimpleAnalysisTaskSE() { } - + // Implementation of interface methods virtual void UserCreateOutputObjects(); virtual void UserExec(Option_t *option); - + // setters Bool_t Configure(const char *configFile = "RsnConfig.C"); void SetReader(AliRsnReader *reader) {fReader = reader;} void SetPID(AliRsnPID *pid) {fPID = pid;} void SetAnalyzer(AliRsnSimpleAnalyzer *analyzer) {fAnalyzer = analyzer;} void PrintSettings(); - -private: + + private: AliRsnSimpleAnalysisTaskSE(const AliRsnSimpleAnalysisTaskSE&) : - AliAnalysisTaskSE(),fReader(0x0),fPID(0x0),fAnalyzer(0x0),fRsnEvent(0x0),fHistograms(0x0) - { /*nothing*/ } + AliAnalysisTaskSE(),fReader(0x0),fPID(0x0),fAnalyzer(0x0),fRsnEvent(0x0),fHistograms(0x0) + { /*nothing*/ } AliRsnSimpleAnalysisTaskSE& operator=(const AliRsnSimpleAnalysisTaskSE&) - { /*nothing*/ return (*this); } + { /*nothing*/ return (*this); } AliRsnReader* fReader; // read manager AliRsnPID* fPID; // PID manager diff --git a/PWG2/RESONANCES/AliRsnSimpleAnalyzer.cxx b/PWG2/RESONANCES/AliRsnSimpleAnalyzer.cxx index 8e53fcd80ec..faa78a77458 100644 --- a/PWG2/RESONANCES/AliRsnSimpleAnalyzer.cxx +++ b/PWG2/RESONANCES/AliRsnSimpleAnalyzer.cxx @@ -41,21 +41,21 @@ ClassImp(AliRsnSimpleAnalyzer) //_____________________________________________________________________________ AliRsnSimpleAnalyzer::AliRsnSimpleAnalyzer(Int_t bufferSize) : - TNamed("RsnSimpleAnalyzer", ""), - fBufferSize(bufferSize), - fMixMultCut(10), - fMixVzCut(0.5), - fNMix(10), - fSingle(0x0), - fMix(0x0), - fBuffer(0x0) + TNamed("RsnSimpleAnalyzer", ""), + fBufferSize(bufferSize), + fMixMultCut(10), + fMixVzCut(0.5), + fNMix(10), + fSingle(0x0), + fMix(0x0), + fBuffer(0x0) { // // Constructor // Initializes all pointers and collections to NULL. // Adds this object to the global Directory. // - gDirectory->Append(this, kTRUE); + gDirectory->Append(this, kTRUE); } @@ -66,10 +66,10 @@ void AliRsnSimpleAnalyzer::Clear(Option_t *option) // Clear heap // - fSingle->Clear(option); - fMix->Clear(option); - delete fBuffer; - fBuffer = 0; + fSingle->Clear(option); + fMix->Clear(option); + delete fBuffer; + fBuffer = 0; } //_____________________________________________________________________________ @@ -80,10 +80,10 @@ void AliRsnSimpleAnalyzer::Add(AliRsnSimpleFunction *fcn) // Second argument tells if the added object is for event mixing. // - Bool_t mixing = fcn->MixFlag(); - TObjArray* &target = mixing ? fMix : fSingle; - if (!target) target = new TObjArray(0); - target->AddLast(fcn); + Bool_t mixing = fcn->MixFlag(); + TObjArray* &target = mixing ? fMix : fSingle; + if (!target) target = new TObjArray(0); + target->AddLast(fcn); } //_____________________________________________________________________________ @@ -93,23 +93,27 @@ void AliRsnSimpleAnalyzer::Init() // Initialize what needs to. // - // buffer - fBuffer = new AliRsnEventBuffer(fBufferSize, kFALSE); - - // histograms - AliRsnSimpleFunction *fcn = 0; - if (fSingle) { - TObjArrayIter iter(fSingle); - while ( (fcn = (AliRsnSimpleFunction*)iter.Next()) ) { - fcn->Init(); - } + // buffer + fBuffer = new AliRsnEventBuffer(fBufferSize, kFALSE); + + // histograms + AliRsnSimpleFunction *fcn = 0; + if (fSingle) + { + TObjArrayIter iter(fSingle); + while ((fcn = (AliRsnSimpleFunction*)iter.Next())) + { + fcn->Init(); } - if (fMix) { - TObjArrayIter iter(fMix); - while ( (fcn = (AliRsnSimpleFunction*)iter.Next()) ) { - fcn->Init(); - } + } + if (fMix) + { + TObjArrayIter iter(fMix); + while ((fcn = (AliRsnSimpleFunction*)iter.Next())) + { + fcn->Init(); } + } } //_____________________________________________________________________________ @@ -120,38 +124,42 @@ void AliRsnSimpleAnalyzer::Process(AliRsnEvent *event) // Depending on the kind of background evaluation method, computes also this one. // - // loop over the collection of pair defs - ProcessEvents(fSingle, event, 0x0); - - if (fMix) { - // variables for mixing - Int_t mult1, mult2, i, j, count = 0; - Double_t vz1, vz2; - // add this event to buffer - fBuffer->AddEvent(event); - // event mixing - vz1 = event->GetPrimaryVertexZ(); - mult1 = event->GetMultiplicity(); - if (!fBuffer->NEmptySlots()) { - i = fBuffer->GetEventsBufferIndex(); - j = i+1; - for (;;j++) { - if (count >= fNMix) break; - if (j == fBufferSize) j = 0; - if (j == i) break; - AliRsnEvent *evmix = fBuffer->GetEvent(j); - if (!evmix) continue; - vz2 = evmix->GetPrimaryVertexZ(); - mult2 = evmix->GetMultiplicity(); - if (TMath::Abs(vz1 - vz2) <= fMixVzCut && TMath::Abs(mult1- mult2) <= fMixMultCut) { - // loop over the collection of pair defs - ProcessEvents(fMix, event, evmix); - ProcessEvents(fMix, evmix, event); - count++; - } - } + // loop over the collection of pair defs + ProcessEvents(fSingle, event, 0x0); + + if (fMix) + { + // variables for mixing + Int_t mult1, mult2, i, j, count = 0; + Double_t vz1, vz2; + // add this event to buffer + fBuffer->AddEvent(event); + // event mixing + vz1 = event->GetPrimaryVertexZ(); + mult1 = event->GetMultiplicity(); + if (!fBuffer->NEmptySlots()) + { + i = fBuffer->GetEventsBufferIndex(); + j = i+1; + for (;;j++) + { + if (count >= fNMix) break; + if (j == fBufferSize) j = 0; + if (j == i) break; + AliRsnEvent *evmix = fBuffer->GetEvent(j); + if (!evmix) continue; + vz2 = evmix->GetPrimaryVertexZ(); + mult2 = evmix->GetMultiplicity(); + if (TMath::Abs(vz1 - vz2) <= fMixVzCut && TMath::Abs(mult1- mult2) <= fMixMultCut) + { + // loop over the collection of pair defs + ProcessEvents(fMix, event, evmix); + ProcessEvents(fMix, evmix, event); + count++; } + } } + } } //_____________________________________________________________________________ @@ -164,12 +172,13 @@ void AliRsnSimpleAnalyzer::ProcessEvents // If the array is NULL nothing is done // - if (!array) return; + if (!array) return; - AliRsnSimpleFunction *fcn = 0; - TObjArrayIter iter(array); - while ( (fcn = (AliRsnSimpleFunction*)iter.Next()) ) { - if (event2) fcn->ProcessTwo(event1, event2); - else fcn->ProcessOne(event1); - } + AliRsnSimpleFunction *fcn = 0; + TObjArrayIter iter(array); + while ((fcn = (AliRsnSimpleFunction*)iter.Next())) + { + if (event2) fcn->ProcessTwo(event1, event2); + else fcn->ProcessOne(event1); + } } diff --git a/PWG2/RESONANCES/AliRsnSimpleAnalyzer.h b/PWG2/RESONANCES/AliRsnSimpleAnalyzer.h index 764d27e77f6..f896f8b1ae8 100644 --- a/PWG2/RESONANCES/AliRsnSimpleAnalyzer.h +++ b/PWG2/RESONANCES/AliRsnSimpleAnalyzer.h @@ -23,7 +23,7 @@ class AliRsnEventBuffer; class AliRsnSimpleAnalyzer : public TNamed { -public: + public: AliRsnSimpleAnalyzer(Int_t bufferSize = 1000); virtual ~AliRsnSimpleAnalyzer() {Clear();} @@ -44,12 +44,12 @@ public: void Add(AliRsnSimpleFunction *pair); void Process(AliRsnEvent *event); -private: + private: AliRsnSimpleAnalyzer(const AliRsnSimpleAnalyzer ©) : - TNamed(copy),fBufferSize(1000), - fMixMultCut(10),fMixVzCut(0.5),fNMix(10), - fSingle(0x0),fMix(0x0),fBuffer(0x0) { } + TNamed(copy),fBufferSize(1000), + fMixMultCut(10),fMixVzCut(0.5),fNMix(10), + fSingle(0x0),fMix(0x0),fBuffer(0x0) { } AliRsnSimpleAnalyzer& operator=(const AliRsnSimpleAnalyzer & /*copy*/) { return (*this); } void ProcessEvents(TObjArray *pairs, AliRsnEvent *event1, AliRsnEvent *event2 = 0x0); diff --git a/PWG2/RESONANCES/AliRsnSimpleFcnResolution.cxx b/PWG2/RESONANCES/AliRsnSimpleFcnResolution.cxx index a1e0b0f8f23..46103f92802 100644 --- a/PWG2/RESONANCES/AliRsnSimpleFcnResolution.cxx +++ b/PWG2/RESONANCES/AliRsnSimpleFcnResolution.cxx @@ -19,30 +19,30 @@ ClassImp(AliRsnSimpleFcnResolution) //________________________________________________________________________________________ AliRsnSimpleFcnResolution::AliRsnSimpleFcnResolution() : - AliRsnSimpleFunction() + AliRsnSimpleFunction() { // // Constructor. // Only default initializations. // - fTrueFlag = kTRUE; - fMixFlag = kFALSE; + fTrueFlag = kTRUE; + fMixFlag = kFALSE; } //________________________________________________________________________________________ AliRsnSimpleFcnResolution::AliRsnSimpleFcnResolution -(const char *name, AliRsnPairDef *pd, +(const char *name, AliRsnPairDef *pd, AliRsnHistoDef *hd, AliRsnCutMgr *cuts, Option_t *option) : - AliRsnSimpleFunction(name, pd, hd, cuts, option) + AliRsnSimpleFunction(name, pd, hd, cuts, option) { // // Constructor. // Only default initializations. // - fTrueFlag = kTRUE; - fMixFlag = kFALSE; + fTrueFlag = kTRUE; + fMixFlag = kFALSE; } //________________________________________________________________________________________ @@ -54,43 +54,46 @@ Bool_t AliRsnSimpleFcnResolution::ProcessOne(AliRsnEvent* event) // This class uses always the perfect PID. // - if (!event) { - AliError("Argument cannot be NULL."); - return kFALSE; - } - - // check event cut - if (!CutPass(event)) return kFALSE; - - // assign pointers to the list of indexes to be used - AliRsnDaughter::EPIDMethod mtd = AliRsnDaughter::kPerfect; - TArrayI *plist1 = event->GetTracksArray(mtd, fPairDef->GetCharge(0), fPairDef->GetType(0)); - TArrayI *plist2 = event->GetTracksArray(mtd, fPairDef->GetCharge(1), fPairDef->GetType(1)); - if (!plist1 || !plist2) return 0.0; - TArrayI &list1 = *plist1; - TArrayI &list2 = *plist2; - - Stat_t count = 0; - Int_t i1, i2, start2; - AliRsnDaughter *track1 = 0x0, *track2 = 0x0; - - // loop on particle of type 1 - for (i1 = 0; i1 < list1.GetSize(); i1++) { - track1 = event->GetTrack(list1[i1]); - if (!CutPass(track1)) continue; - // loop on particle of type 2 - // in case we are building a like-sign histogram with particles - // of the same type, we must avoid that each pair is used twice - start2 = 0; - if (plist1 == plist2) start2 = i1 + 1; - for (i2 = start2; i2 < list2.GetSize(); i2++) { - track2 = event->GetTrack(list2[i2]); - if (!CutPass(track2)) continue; - if (Add(track1, track2)) count++; - } + if (!event) + { + AliError("Argument cannot be NULL."); + return kFALSE; + } + + // check event cut + if (!CutPass(event)) return kFALSE; + + // assign pointers to the list of indexes to be used + AliRsnDaughter::EPIDMethod mtd = AliRsnDaughter::kPerfect; + TArrayI *plist1 = event->GetTracksArray(mtd, fPairDef->GetCharge(0), fPairDef->GetType(0)); + TArrayI *plist2 = event->GetTracksArray(mtd, fPairDef->GetCharge(1), fPairDef->GetType(1)); + if (!plist1 || !plist2) return 0.0; + TArrayI &list1 = *plist1; + TArrayI &list2 = *plist2; + + Stat_t count = 0; + Int_t i1, i2, start2; + AliRsnDaughter *track1 = 0x0, *track2 = 0x0; + + // loop on particle of type 1 + for (i1 = 0; i1 < list1.GetSize(); i1++) + { + track1 = event->GetTrack(list1[i1]); + if (!CutPass(track1)) continue; + // loop on particle of type 2 + // in case we are building a like-sign histogram with particles + // of the same type, we must avoid that each pair is used twice + start2 = 0; + if (plist1 == plist2) start2 = i1 + 1; + for (i2 = start2; i2 < list2.GetSize(); i2++) + { + track2 = event->GetTrack(list2[i2]); + if (!CutPass(track2)) continue; + if (Add(track1, track2)) count++; } + } - return (count > (Stat_t)0); + return (count > (Stat_t)0); } //________________________________________________________________________________________ @@ -104,21 +107,21 @@ Bool_t AliRsnSimpleFcnResolution::Add // In case the study is done only for true pairs, this is checked automatically. // - // setup pair and check pair cuts - fPair.SetPair(track1, track2); - if (!CutPass(&fPair)) return kFALSE; - - // computation variables - Double_t mass1 = fPairDef->GetMass(0); - Double_t mass2 = fPairDef->GetMass(1); - - // make computation - Double_t invmass = fPair.GetInvMass(mass1, mass2); - Double_t invmassMC = fPair.GetInvMassMC(mass1, mass2); - Double_t res = (invmassMC - invmass) / invmassMC; - - // fill - fHisto1D->Fill(res); - - return kTRUE; + // setup pair and check pair cuts + fPair.SetPair(track1, track2); + if (!CutPass(&fPair)) return kFALSE; + + // computation variables + Double_t mass1 = fPairDef->GetMass(0); + Double_t mass2 = fPairDef->GetMass(1); + + // make computation + Double_t invmass = fPair.GetInvMass(mass1, mass2); + Double_t invmassMC = fPair.GetInvMassMC(mass1, mass2); + Double_t res = (invmassMC - invmass) / invmassMC; + + // fill + fHisto1D->Fill(res); + + return kTRUE; } diff --git a/PWG2/RESONANCES/AliRsnSimpleFcnResolution.h b/PWG2/RESONANCES/AliRsnSimpleFcnResolution.h index d3263560231..540adff132f 100644 --- a/PWG2/RESONANCES/AliRsnSimpleFcnResolution.h +++ b/PWG2/RESONANCES/AliRsnSimpleFcnResolution.h @@ -13,24 +13,24 @@ class AliRsnSimpleFcnResolution : public AliRsnSimpleFunction { -public: + public: AliRsnSimpleFcnResolution(); AliRsnSimpleFcnResolution - (const char* name, AliRsnPairDef *pd, - AliRsnHistoDef *hd, AliRsnCutMgr *cuts=0, Option_t *option=""); + (const char* name, AliRsnPairDef *pd, + AliRsnHistoDef *hd, AliRsnCutMgr *cuts=0, Option_t *option=""); // virtual working routines virtual Bool_t ProcessOne(AliRsnEvent *event); -private: + private: // dummy required methods AliRsnSimpleFcnResolution(const AliRsnSimpleFcnResolution ©) : - AliRsnSimpleFunction(copy) { /*nothing */ } + AliRsnSimpleFunction(copy) { /*nothing */ } AliRsnSimpleFcnResolution& operator=(const AliRsnSimpleFcnResolution& /*copy*/) - { /* nothing */ return (*this); } - + { /* nothing */ return (*this); } + // utility methods Bool_t Add(AliRsnDaughter *t1, AliRsnDaughter *t2); diff --git a/PWG2/RESONANCES/AliRsnSimpleFunction.cxx b/PWG2/RESONANCES/AliRsnSimpleFunction.cxx index ce746c8ff70..2045095217f 100644 --- a/PWG2/RESONANCES/AliRsnSimpleFunction.cxx +++ b/PWG2/RESONANCES/AliRsnSimpleFunction.cxx @@ -136,17 +136,8 @@ Bool_t AliRsnSimpleFunction::Init() Char_t name[200]; sprintf(name, "h_%s", GetName()); - switch (fHistoDef->GetNDimensions()) { - case 1: - fHisto1D = (TH1D*)fHistoDef->Create1DHistogram(name, ""); - return kTRUE; - case 2: - fHisto2D = (TH2D*)fHistoDef->Create1DHistogram(name, ""); - return kTRUE; - default: - AliError("Number of dimensions not properly set."); - return kFALSE; - } + fHisto1D = (TH1D*)fHistoDef->CreateHistogram(name, ""); + return kTRUE; } //________________________________________________________________________________________