Package revised - New AnalysisTask's - Added more functions
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Sep 2008 06:44:43 +0000 (06:44 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Sep 2008 06:44:43 +0000 (06:44 +0000)
59 files changed:
PWG2/RESONANCES/AliRsnAnalysisSE.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisSE.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisTask2ndStep.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisTask2ndStep.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisTaskSEBase.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisTaskSEBase.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnBaseAT.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnBaseAT.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnComparisonAT.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnComparisonAT.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnComparisonObj.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnComparisonObj.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCut.cxx
PWG2/RESONANCES/AliRsnCut.h
PWG2/RESONANCES/AliRsnCutMgr.cxx
PWG2/RESONANCES/AliRsnCutMgr.h
PWG2/RESONANCES/AliRsnCutSet.cxx
PWG2/RESONANCES/AliRsnCutSet.h
PWG2/RESONANCES/AliRsnDaughter.cxx
PWG2/RESONANCES/AliRsnDaughter.h
PWG2/RESONANCES/AliRsnEvent.cxx
PWG2/RESONANCES/AliRsnEvent.h
PWG2/RESONANCES/AliRsnEventBuffer.cxx
PWG2/RESONANCES/AliRsnEventBuffer.h
PWG2/RESONANCES/AliRsnExpression.cxx
PWG2/RESONANCES/AliRsnExpression.h
PWG2/RESONANCES/AliRsnHistoDef.cxx
PWG2/RESONANCES/AliRsnHistoDef.h
PWG2/RESONANCES/AliRsnMCInfo.cxx
PWG2/RESONANCES/AliRsnMCInfo.h
PWG2/RESONANCES/AliRsnPID.cxx
PWG2/RESONANCES/AliRsnPID.h
PWG2/RESONANCES/AliRsnPIDIndex.cxx
PWG2/RESONANCES/AliRsnPIDIndex.h
PWG2/RESONANCES/AliRsnPIDWeightsMgr.cxx
PWG2/RESONANCES/AliRsnPIDWeightsMgr.h
PWG2/RESONANCES/AliRsnPair.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPair.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairDef.cxx
PWG2/RESONANCES/AliRsnPairDef.h
PWG2/RESONANCES/AliRsnPairMgr.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairMgr.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairParticle.cxx
PWG2/RESONANCES/AliRsnPairParticle.h
PWG2/RESONANCES/AliRsnReader.cxx
PWG2/RESONANCES/AliRsnReader.h
PWG2/RESONANCES/AliRsnReaderTask.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnReaderTask.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnReaderTaskSE.cxx
PWG2/RESONANCES/AliRsnReaderTaskSE.h
PWG2/RESONANCES/AliRsnSimpleAnalysis.cxx
PWG2/RESONANCES/AliRsnSimpleAnalysis.h
PWG2/RESONANCES/AliRsnSimpleAnalysisTaskSE.cxx
PWG2/RESONANCES/AliRsnSimpleAnalysisTaskSE.h
PWG2/RESONANCES/AliRsnSimpleAnalyzer.cxx
PWG2/RESONANCES/AliRsnSimpleAnalyzer.h
PWG2/RESONANCES/AliRsnSimpleFcnResolution.cxx
PWG2/RESONANCES/AliRsnSimpleFcnResolution.h
PWG2/RESONANCES/AliRsnSimpleFunction.cxx

diff --git a/PWG2/RESONANCES/AliRsnAnalysisSE.cxx b/PWG2/RESONANCES/AliRsnAnalysisSE.cxx
new file mode 100644 (file)
index 0000000..776fee0
--- /dev/null
@@ -0,0 +1,197 @@
+//
+// Class AliRsnAnalysisSE
+//
+// TODO
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#include <TSystem.h>
+#include <TFile.h>
+#include <TFolder.h>
+
+#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<TList*>(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 (file)
index 0000000..d143c6e
--- /dev/null
@@ -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 <TH1.h>
+
+#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 (file)
index 0000000..6d23584
--- /dev/null
@@ -0,0 +1,177 @@
+//
+// Class AliRsnAnalysisTask2ndStep
+//
+// TODO
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+#include <TTree.h>
+#include <TChain.h>
+#include <TH1F.h>
+#include <TList.h>
+#include <TObjArray.h>
+
+#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<AliAODEvent*>(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<TList*>(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 (file)
index 0000000..f21720b
--- /dev/null
@@ -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 (file)
index 0000000..0cf9c74
--- /dev/null
@@ -0,0 +1,411 @@
+//
+// Class AliRsnAnalysisTaskSEBase
+//
+// TODO
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+#include <TTree.h>
+#include <TH1F.h>
+#include <TCanvas.h>
+
+#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<TTree*>(GetInputData(inputIndex));
+    if (!tree) { AliError("Could not read chain from input slot 0");}
+    else
+    {
+        AliAODInputHandler *aodH = dynamic_cast<AliAODInputHandler*>(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 (file)
index 0000000..6389356
--- /dev/null
@@ -0,0 +1,110 @@
+//\r
+// Class AliRsnAnalysisTaskSEBase\r
+//\r
+// TODO\r
+//\r
+// authors: Martin Vala (martin.vala@cern.ch)\r
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)\r
+//\r
+#ifndef ALIRSNANALYSISTASKSEBASE_H\r
+#define ALIRSNANALYSISTASKSEBASE_H\r
+\r
+#include <TChain.h>\r
+\r
+#include "AliAnalysisTaskSE.h"\r
+#include "AliRsnReader.h"\r
+\r
+class AliAnalysisManager;\r
+class AliESDEvent;\r
+class AliAODEvent;\r
+class AliRsnEvent;\r
+class AliMCEvent;\r
+\r
+#include "AliESDInputHandler.h"\r
+#include "AliMCEventHandler.h"\r
+#include "AliAODInputHandler.h"\r
+\r
+class AliRsnAnalysisTaskSEBase : public AliAnalysisTaskSE\r
+{\r
+  public:\r
+    AliRsnAnalysisTaskSEBase(const char *name = "AliRsnAnalysisTaskSEBase");\r
+    AliRsnAnalysisTaskSEBase(const AliRsnAnalysisTaskSEBase& copy) :\r
+        AliAnalysisTaskSE(copy),fUseAutoHandler(kFALSE),fReader(),fPID(),fAnalysisMgr(0x0) {}\r
+    AliRsnAnalysisTaskSEBase& operator= (const AliRsnAnalysisTaskSEBase& /*copy*/) {return *this;}\r
+    virtual ~AliRsnAnalysisTaskSEBase() {/* Does nothing*/}\r
+\r
+    enum EInputType\r
+    {\r
+        kAOD = 0,\r
+        kESD,\r
+        kESDMC,\r
+        kMC,\r
+        kRSN,\r
+        kLastIndex\r
+    };\r
+\r
+    virtual void   InitIOVars();\r
+    virtual void   LocalInit();\r
+    virtual Bool_t Notify();\r
+    virtual void   ConnectInputData(Option_t *);\r
+    // Implementation of interface methods\r
+    virtual void   UserCreateOutputObjects() {;};\r
+    virtual void   UserExec(Option_t*) {;};\r
+    virtual void   Terminate(Option_t*) {;};\r
+\r
+    void SetInputType(EInputType type, AliAnalysisManager* am, Bool_t autohandler = kFALSE, Short_t inputIndex = 0);\r
+    EInputType GetInputType(Short_t inputIndex = 0) { return fInputType[inputIndex]; }\r
+\r
+    TChain* GetChain(const Int_t& index = 0) const { return fChain[index]; }\r
+\r
+    AliRsnEvent *GetRSNEvent(Int_t index = 0) { return fRSN[index]; }\r
+\r
+    void SetAnalysisMgr(AliAnalysisManager* theValue) { fAnalysisMgr = theValue; }\r
+    AliAnalysisManager* GetAnalysisMgr() const { return fAnalysisMgr; }\r
+\r
+    AliESDInputHandler* GetESDHandler(const Int_t& theValue = 0) const { return fRsnESDEH[theValue]; }\r
+    AliMCEventHandler* GetMCHandler(const Int_t& theValue = 0) const { return fRsnMCEH[theValue]; }\r
+    AliAODInputHandler* GetAODHandler(const Int_t& theValue = 0) const { return fRsnAODEH[theValue]; }\r
+\r
+    AliRsnReader *GetReader() { return &fReader; }\r
+    AliRsnPID *GetPID() { return &fPID;}\r
+\r
+  protected:\r
+\r
+    TChain       *fChain[2];          // input chain\r
+    EInputType    fInputType[2];      // input type\r
+    Bool_t        fUseAutoHandler;    // flag if should create handler\r
+\r
+    AliRsnEvent   *fRSN[2];           // RSN (internal format) event\r
+    AliESDEvent   *fRsnESD[2];        // ESD event\r
+    AliMCEvent    *fRsnMC[2];         // ESD event\r
+    AliAODEvent   *fRsnAOD[2];        // AOD event\r
+\r
+    AliESDInputHandler   *fRsnESDEH[2];  // ESD event handler\r
+    AliMCEventHandler    *fRsnMCEH[2];   // ESD event handler\r
+    AliAODInputHandler   *fRsnAODEH[2];  // AOD event handler\r
+\r
+    AliRsnReader  fReader;               // Reader\r
+    AliRsnPID     fPID;                  // PID\r
+\r
+    AliAnalysisManager *fAnalysisMgr; // pointer to current AnalysisMgr\r
+\r
+    virtual void  UseAutoHandler(const Bool_t& theValue) {fUseAutoHandler = theValue;}\r
+\r
+    virtual void  ConnectInputDataByInputType(EInputType type ,Short_t inputIndex=0);\r
+    virtual void  ConnectRSN(Short_t inputIndex);\r
+    virtual void  ConnectESD(Short_t inputIndex);\r
+    virtual void  ConnectESDMC(Short_t inputIndex);\r
+    virtual void  ConnectAOD(Short_t inputIndex);\r
+\r
+    virtual AliRsnEvent*  GetRsnEventFromInputType(const Short_t &index=0);\r
+    virtual AliRsnEvent*  GetRsnFromAOD(const Short_t &index=0);\r
+    virtual AliRsnEvent*  GetRsnFromESD(const Short_t &index=0);\r
+    virtual AliRsnEvent*  GetRsnFromESDMC(const Short_t &index=0);\r
+    virtual AliRsnEvent*  GetRsnFromRSN(const Short_t &index=0);\r
+    virtual AliRsnEvent*  GetRsnFromMC(const Short_t &index=0);\r
+\r
+    ClassDef(AliRsnAnalysisTaskSEBase, 1)\r
+};\r
+\r
+#endif\r
diff --git a/PWG2/RESONANCES/AliRsnBaseAT.cxx b/PWG2/RESONANCES/AliRsnBaseAT.cxx
new file mode 100644 (file)
index 0000000..10f13e6
--- /dev/null
@@ -0,0 +1,478 @@
+//
+// Class AliRsnBaseAT
+//
+// TODO
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+#include <TTree.h>
+#include <TH1F.h>
+#include <TCanvas.h>
+
+#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<TTree*>(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<AliESDInputHandler*>(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<TTree*>(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<AliESDInputHandler*>(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<TTree*>(GetInputData(inputIndex));
+  if (!tree) { AliError("Could not read chain from input slot 0");}
+  else
+  {
+    AliAODInputHandler *aodH = dynamic_cast<AliAODInputHandler*>(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<AliMCEventHandler*>(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 (file)
index 0000000..afac444
--- /dev/null
@@ -0,0 +1,115 @@
+//\r
+// Class AliRsnBaseAT\r
+//\r
+// TODO\r
+//\r
+// authors: Martin Vala (martin.vala@cern.ch)\r
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)\r
+//\r
+#ifndef ALIRSNBASEAT_H\r
+#define ALIRSNBASEAT_H\r
+\r
+#include <TChain.h>\r
+\r
+#include "AliAnalysisTask.h"\r
+#include "AliRsnReader.h"\r
+\r
+class AliAnalysisManager;\r
+class AliESDEvent;\r
+class AliAODEvent;\r
+class AliRsnEvent;\r
+class AliMCEvent;\r
+\r
+#include "AliESDInputHandler.h"\r
+#include "AliMCEventHandler.h"\r
+#include "AliAODInputHandler.h"\r
+\r
+\r
+class AliRsnBaseAT : public AliAnalysisTask\r
+{\r
+  public:\r
+    AliRsnBaseAT(const char *name = "AliRsnBaseAT");\r
+    AliRsnBaseAT(const AliRsnBaseAT& copy):AliAnalysisTask(copy),\r
+       fNumOfEvents(0),fUseAutoHandler(kTRUE),\r
+       fRsnInput(1),fReader(),fPID(),fAnalysisMgr(0x0) {}\r
+    AliRsnBaseAT& operator= (const AliRsnBaseAT&) {return *this;}\r
+    virtual ~AliRsnBaseAT() {/* Does nothing*/}\r
+\r
+    enum EInputType\r
+    {\r
+      kAOD = 0,\r
+      kESD,\r
+      kESDMC,\r
+      kMC,\r
+      kRSN,\r
+      kLastIndex\r
+    };\r
+\r
+    virtual void   InitIOVars();\r
+    virtual void   LocalInit();\r
+    virtual Bool_t Notify();\r
+    virtual void   ConnectInputData(Option_t *);\r
+    virtual void   CreateOutputObjects() {;}\r
+    virtual void   Exec(Option_t *) {;}\r
+    virtual void   Terminate(Option_t *) {;}\r
+\r
+    void SetInputType(EInputType type,AliAnalysisManager* am,Bool_t autohandler=kFALSE, Short_t inputIndex=0);\r
+    EInputType GetInputType(Short_t inputIndex=0) { return fInputType[inputIndex]; }\r
+\r
+    TChain* GetChain(const Int_t& index = 0) const { return fChain[index]; }\r
+\r
+    AliRsnEvent *GetRSNEvent(Int_t index=0) { return fRSN[index]; }\r
+\r
+    void SetAnalysisMgr(AliAnalysisManager* theValue) { fAnalysisMgr = theValue; }\r
+    AliAnalysisManager* GetAnalysisMgr() const { return fAnalysisMgr; }\r
+\r
+    AliESDInputHandler* GetESDHandler(const Int_t& theValue=0) const { return fESDEH[theValue]; }\r
+    AliMCEventHandler* GetMCHandler(const Int_t& theValue=0) const { return fMCEH[theValue]; }\r
+    AliAODInputHandler* GetAODHandler(const Int_t& theValue=0) const { return fAODEH[theValue]; }\r
+\r
+    AliRsnReader *GetReader() { return &fReader; }\r
+    AliRsnPID *GetPID() { return &fPID;}\r
+    \r
+  protected:\r
+\r
+    Long64_t      fNumOfEvents;       // number of events\r
+\r
+    TChain        *fChain[2];         // input chain\r
+    EInputType    fInputType[2];      // input type\r
+    Bool_t        fUseAutoHandler;    // flag if should create handler\r
+\r
+    AliRsnEvent   *fRSN[2];           // RsnMV event\r
+    AliESDEvent   *fESD[2];           // ESD event\r
+    AliMCEvent    *fMC[2];            // ESD event\r
+    AliAODEvent   *fAOD[2];           // AOD event\r
+\r
+    AliESDInputHandler   *fESDEH[2];  // ESD event handler\r
+    AliMCEventHandler    *fMCEH[2];   // ESD event handler\r
+    AliAODInputHandler   *fAODEH[2];  // AOD event handler\r
+\r
+\r
+    TObjArray     fRsnInput;          // array of rsn input (reader,pid,...)\r
+    AliRsnReader  fReader;            // Reader\r
+    AliRsnPID     fPID;               // PID\r
+\r
+    AliAnalysisManager *fAnalysisMgr; // pointer to current AnalysisMgr\r
+\r
+    virtual void  UseAutoHandler(const Bool_t& theValue);\r
+\r
+    virtual void  ConnectInputDataByInputType(EInputType type ,Short_t inputIndex=0);\r
+    virtual void  ConnectRSN(Short_t inputIndex);\r
+    virtual void  ConnectESD(Short_t inputIndex);\r
+    virtual void  ConnectESDMC(Short_t inputIndex);\r
+    virtual void  ConnectAOD(Short_t inputIndex);\r
+\r
+    virtual AliRsnEvent*  GetRsnEventFromInputType(const Short_t &index=0);\r
+    virtual AliRsnEvent*  GetRsnFromAOD(const Short_t &index=0);\r
+    virtual AliRsnEvent*  GetRsnFromESD(const Short_t &index=0);\r
+    virtual AliRsnEvent*  GetRsnFromESDMC(const Short_t &index=0);\r
+    virtual AliRsnEvent*  GetRsnFromRSN(const Short_t &index=0);\r
+\r
+\r
+    ClassDef(AliRsnBaseAT, 1)\r
+};\r
+\r
+#endif\r
diff --git a/PWG2/RESONANCES/AliRsnComparisonAT.cxx b/PWG2/RESONANCES/AliRsnComparisonAT.cxx
new file mode 100644 (file)
index 0000000..99e5c70
--- /dev/null
@@ -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<AliRsnReader*> ( GetInputData ( 1 ) );
+//   fPID = dynamic_cast<AliRsnPID*> ( 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;i<fMyInput[0].GetEntries();i++)
+  {
+    obj = (AliRsnComparisonObj*) fMyInput[0].At(i);
+    if (!obj) continue;
+    listParticle = obj->GenerateParticleInfoHistogramList("");
+    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;j<fMyPIDInputNum;j++)
+    {
+      listPID = new TList();
+      listPID->SetName(fMyPIDInput[j].GetName());
+      for (Int_t i=0;i<fMyPIDInput[j].GetEntries();i++)
+      {
+        obj = (AliRsnComparisonObj*) fMyPIDInput[j].At(i);
+        if (!obj) continue;
+        listTmp = obj->GeneratePIDHistogramList(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<TList*>(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;j<fMyInputNum;j++)
+    {
+      for (Int_t i=0;i<fMyInput[j].GetEntries();i++)
+      {
+        input = (AliRsnComparisonObj*) fMyInput[j].At(i);
+//         input->FillPIDHistograms(esdtrack, fMC[0]);
+      }
+    }
+    for (Int_t j=0;j<fMyPIDInputNum;j++)
+    {
+      for (Int_t i=0;i<fMyPIDInput[j].GetEntries();i++)
+      {
+        input = (AliRsnComparisonObj*) fMyPIDInput[j].At(i);
+        input->FillPIDHistograms(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;i<fMC[0]->GetNumberOfTracks(); i++)
+  {
+    mctrack = fMC[0]->GetTrack(i);
+    if (!mctrack) {AliInfo("mctrack == null");continue;}
+    for (Int_t j=0;j<fMyInputNum;j++)
+    {
+      for (Int_t i=0;i<fMyInput[j].GetEntries();i++)
+      {
+        input = (AliRsnComparisonObj*) fMyInput[j].At(i);
+        input->FillHistograms(mctrack);
+      }
+    }
+    for (Int_t j=0;j<fMyPIDInputNum;j++)
+    {
+      for (Int_t i=0;i<fMyPIDInput[j].GetEntries();i++)
+      {
+        input = (AliRsnComparisonObj*) fMyPIDInput[j].At(i);
+        input->FillPIDHistograms(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;j<fMyInputNum;j++)
+    {
+      for (Int_t i=0;i<fMyInput[j].GetEntries();i++)
+      {
+        input = (AliRsnComparisonObj*) fMyInput[j].At(i);
+//         input->FillPIDHistograms(daughter);
+      }
+    }
+    for (Int_t j=0;j<fMyPIDInputNum;j++)
+    {
+      for (Int_t i=0;i<fMyPIDInput[j].GetEntries();i++)
+      {
+        input = (AliRsnComparisonObj*) fMyPIDInput[j].At(i);
+        input->FillPIDHistograms(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 (file)
index 0000000..101c582
--- /dev/null
@@ -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 (file)
index 0000000..ba6c593
--- /dev/null
@@ -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;i<kLastFormat;i++)
+    for (Int_t j=0;j<kLastHistoType;j++)
+      for (Int_t k=0;k<AliRsnPID::kSpecies+1;k++)
+        fHistosPID[i][j][k] = 0;
+
+  for (Int_t i=0;i<kLastParameterType;i++)
+    for (Int_t j=0;j<2;j++)
+      for (Int_t k=0;k<AliRsnPID::kSpeciesAll;k++)
+        fHistosPartInfo[i][j][k] = 0;
+
+  fPriorProbs[0]=0.02;
+  fPriorProbs[1]=0.02;
+  fPriorProbs[2]=0.83;
+  fPriorProbs[3]=0.07;
+  fPriorProbs[4]=0.06;
+  fITSClusters = -1;
+  fTPCClusters = -1;
+  fTRDClusters = -1;
+  fPIDDivValue = 0.0;
+
+}
+//_____________________________________________________________________________
+AliRsnComparisonObj::~AliRsnComparisonObj()
+{
+//=========================================================
+// Destructor
+//=========================================================
+}
+
+//________________________________________________________________________
+TList * AliRsnComparisonObj::GeneratePIDHistogramList(TString prefix)
+{
+//=========================================================
+// Generate histograms
+//=========================================================
+
+  TList *list = new TList();
+  list->SetName(GetName());
+
+  TString varname("p");
+  for (Int_t i=0;i<kLastFormat;i++)
+    for (Int_t j=0;j<kLastHistoType;j++)
+      for (Int_t k=0;k<AliRsnPID::kSpecies+1;k++)
+      {
+        if ((i == kMC) && (j>kIndent)) 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;i<kLastParameterType;i++)
+    for (Int_t j=0;j<2;j++)
+      for (Int_t k=0;k<AliRsnPID::kSpeciesAll;k++)
+      {
+//         if (k == AliRsnPID::kUnknown) continue;
+//         if ((j>0) && (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;i<kLastParameterType;i++)
+    fHistosPartInfo[i][charge][indexTypeFromPDG]->Fill(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;i<AliRsnPID::kSpecies;i++) pid[i]*=ctmp[i];
+      break;
+    case kTPC_TOF :
+      track->GetTPCpid(pid);
+      track->GetTOFpid(ctmp);
+      for (Int_t i=0;i<AliRsnPID::kSpecies;i++) pid[i]*=ctmp[i];
+      break;
+    case kITS_TPC_TOF :
+      track->GetITSpid(pid);
+      track->GetTPCpid(ctmp);
+      for (Int_t i=0;i<AliRsnPID::kSpecies;i++) pid[i]*=ctmp[i];
+      track->GetTOFpid(ctmp);
+      for (Int_t i=0;i<AliRsnPID::kSpecies;i++) pid[i]*=ctmp[i];
+      break;
+    case kITS_TPC_TOF_SP :
+
+      if (p<fPIDDivValue)
+      {
+        track->GetITSpid(pid);
+        track->GetTPCpid(ctmp);
+        for (Int_t i=0;i<AliRsnPID::kSpecies;i++) pid[i]*=ctmp[i];
+      }
+      else
+      {
+        track->GetTOFpid(pid);
+      }
+      break;
+    default:
+      AliWarning("Unrecognized value of EPIDType argument");
+      for (Int_t i=0;i<AliRsnPID::kSpecies;i++) pid[i]=1.0;
+      break;
+  }
+}
+
+void AliRsnComparisonObj::SetESDTrackQualityCuts(const Int_t & its, const Int_t & tpc, const Int_t & trd)
+{
+  fITSClusters = its;
+  fTPCClusters = tpc;
+  fTRDClusters = trd;
+}
+
+void AliRsnComparisonObj::SetESDstatus(const ULong_t status)
+{
+  fESDstatus = status;
+}
+
+void AliRsnComparisonObj::SetCurrentESDPID(const EPIDType & type, const Double_t & divValue)
+{
+  fCurrentESDPID = type;
+  fPIDDivValue = divValue;
+}
+
+TString AliRsnComparisonObj::GetParameterName(EParameterType type)
+{
+  switch (type)
+  {
+    case kP :
+      return "p";
+    case kPt :
+      return "pt";
+    case kEta :
+      return "eta";
+    case kY :
+      return "y";
+    default:
+      break;
+  }
+  return "?";
+}
+
+Double_t AliRsnComparisonObj::GetParameterNameValue(EParameterType type,AliMCParticle * mctrack)
+{
+  switch (type)
+  {
+    case kP :
+      return mctrack->P();
+    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 (file)
index 0000000..b10b9fc
--- /dev/null
@@ -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 <TNamed.h>
+#include <TList.h>
+#include <TH1.h>
+
+#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
index c038002..277d459 100644 (file)
@@ -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));
 }
index 95c1447..a753dbe 100644 (file)
@@ -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
index 82f55a2..d687bb5 100644 (file)
 #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;
 }
index f4dcd52..7c15ebb 100644 (file)
@@ -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
index b230f9c..836a231 100644 (file)
@@ -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;
 }
index 64bbbd5..315ecc5 100644 (file)
@@ -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 &copy);
+    AliRsnCutSet(TString name);
+    AliRsnCutSet(const AliRsnCutSet &copy);
     ~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
index 12d86c7..bbe48e5 100644 (file)
@@ -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 &copy) :
-  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 &copy)
 // 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;i<AliRsnPID::kSpecies;i++) pid[i]*=ctmp[i];
+      break;
+    case kTPC_TOF :
+      track->GetTPCpid(pid);
+      track->GetTOFpid(ctmp);
+      for (Int_t i=0;i<AliRsnPID::kSpecies;i++) pid[i]*=ctmp[i];
+      break;
+    case kITS_TPC_TOF :
+      track->GetITSpid(pid);
+      track->GetTPCpid(ctmp);
+      for (Int_t i=0;i<AliRsnPID::kSpecies;i++) pid[i]*=ctmp[i];
+      track->GetTOFpid(ctmp);
+      for (Int_t i=0;i<AliRsnPID::kSpecies;i++) pid[i]*=ctmp[i];
+      break;
+    case kITS_TPC_TOF_SP :
+      if (val<divValue)
+      {
+        track->GetITSpid(pid);
+        track->GetTPCpid(ctmp);
+        for (Int_t i=0;i<AliRsnPID::kSpecies;i++) pid[i]*=ctmp[i];
+      }
+      else
+      {
+        track->GetTOFpid(pid);
+      }
+      break;
+    default:
+//       AliWarning("Unrecognized value of EPIDType argument");
+      for (Int_t i=0;i<AliRsnPID::kSpecies;i++) pid[i]=1.0;
+      break;
+  }
+}
+
index 593dcc5..25ac4df 100644 (file)
@@ -27,95 +27,112 @@ class AliRsnMCInfo;
 class AliRsnDaughter : public AliVParticle
 {
   public:
-  
-    enum EPIDMethod {
-        kNoPID = 0,
-        kRealistic,
-        kWeighted,
-        kPerfect,
-        kMethods
+
+    enum EPIDMethod
+    {
+      kNoPID = 0,
+      kRealistic,
+      kWeighted,
+      kPerfect,
+      kMethods
+    };
+
+    enum EPIDType
+    {
+      kEsd=0,
+      kITS,
+      kTPC,
+      kTOF,
+      kITS_TPC,
+      kITS_TOF,
+      kTPC_TOF,
+      kITS_TPC_TOF,
+      kITS_TPC_TOF_SP,
+      kLastPIDType
     };
 
+
     AliRsnDaughter();
-    AliRsnDaughter (const AliRsnDaughter &copy);
-    AliRsnDaughter (AliESDtrack *track, Bool_t useTPCInnerParam = kFALSE);
-    AliRsnDaughter (AliAODTrack *track);
-    AliRsnDaughter (AliMCParticle *track);
+    AliRsnDaughter(const AliRsnDaughter &copy);
+    AliRsnDaughter(AliESDtrack *track, Bool_t useTPCInnerParam = kFALSE);
+    AliRsnDaughter(AliAODTrack *track);
+    AliRsnDaughter(AliMCParticle *track);
     virtual ~AliRsnDaughter();
     AliRsnDaughter& operator= (const AliRsnDaughter& copy);
 
     // 4-momentum
-    virtual Double_t E()  const {return TMath::Sqrt (fMass*fMass + P2());}
+    virtual Double_t E()  const {return TMath::Sqrt(fMass*fMass + P2());}
     virtual Double_t E(Double_t mass) {SetM(mass); return E();}
     virtual Double_t M()  const {return fMass;}
     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             SetM (Double_t m) {fMass = m;}
+    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             SetM(Double_t m) {fMass = m;}
 
     // DCA vertex
     virtual Double_t Xv() const {return fV[0];}
     virtual Double_t Yv() const {return fV[1];}
     virtual Double_t Zv() const {return fV[2];}
-    virtual Double_t Dr() const {return TMath::Sqrt (Xv()*Xv() + Yv()*Yv());}
-    virtual Bool_t   XvYvZv (Double_t x[3]) const {x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE;}
-    void             SetVx (Double_t value) {fV[0] = value;}
-    void             SetVy (Double_t value) {fV[1] = value;}
-    void             SetVz (Double_t value) {fV[2] = value;}
-    void             SetV (Double_t vx, Double_t vy, Double_t vz) {SetVx (vx); SetVy (vy); SetVz (vz);}
+    virtual Double_t Dr() const {return TMath::Sqrt(Xv()*Xv() + Yv()*Yv());}
+    virtual Bool_t   XvYvZv(Double_t x[3]) const {x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE;}
+    void             SetVx(Double_t value) {fV[0] = value;}
+    void             SetVy(Double_t value) {fV[1] = value;}
+    void             SetVz(Double_t value) {fV[2] = value;}
+    void             SetV(Double_t vx, Double_t vy, Double_t vz) {SetVx(vx); SetVy(vy); SetVz(vz);}
+    void             ShiftZero(Double_t x, Double_t y, Double_t z){fV[0]-=x;fV[1]-=y;fV[2]-=z;}
 
     // Orientation
-    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()));}
+    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()));}
 
     // Charge
     virtual Short_t Charge() const {return fCharge;}
-    void            SetCharge (Short_t value) {fCharge = value;}
+    void            SetCharge(Short_t value) {fCharge = value;}
 
     // PID
     virtual const Double_t* PID() const {return fPIDWeight;}
     const Double_t*         PIDProb() const {return fPIDProb;}
-    void                    SetPIDProb (Int_t i, Double_t value);
-    void                    SetPIDWeight (Int_t i, Double_t value);
+    void                    SetPIDProb(Int_t i, Double_t value);
+    void                    SetPIDWeight(Int_t i, Double_t value);
     static void             SetPIDMethod(EPIDMethod method) {fgPIDMethod = method;}
     void                    AssignRealisticPID();
-    AliRsnPID::EType        PIDType(Double_t &prob);
+    AliRsnPID::EType        PIDType(Double_t &prob) const;
 
     // check that contains a given ESD flag
-    Bool_t  CheckFlag (ULong_t flag) {return (fFlags & flag);}
+    Bool_t  CheckFlag(ULong_t flag) {return ((fFlags & flag) == flag);}
 
     // information getters from objects
-    Bool_t  Adopt (AliESDtrack *track, Bool_t useTPCInnerParam = kFALSE);
-    Bool_t  Adopt (AliAODTrack *track);
-    Bool_t  Adopt (AliMCParticle *track);
+    Bool_t  Adopt(AliESDtrack *track, EPIDType pidType = kEsd,Double_t divValue = 0.0,Bool_t useTPCInnerParam = kFALSE);
+    Bool_t  Adopt(AliAODTrack *track);
+    Bool_t  Adopt(AliMCParticle *track);
 
     // position in stack/array
     Int_t   Index() const {return fIndex;}
     Int_t   Label() const {return fLabel;}
     Int_t   GetLabel() const {return -1;}
-    void    SetIndex (Int_t value) {fIndex = value;}
-    void    SetLabel (Int_t value) {fLabel = value;}
+    void    SetIndex(Int_t value) {fIndex = value;}
+    void    SetLabel(Int_t value) {fLabel = value;}
 
     // Utilities
-    void    Print (Option_t *option = "ALL") const;
+    void    Print(Option_t *option = "ALL") const;
     void    InitMCInfo();
-    Bool_t  InitMCInfo (TParticle *particle);
-    Bool_t  InitMCInfo (AliMCParticle *mcParticle);
+    Bool_t  InitMCInfo(TParticle *particle);
+    Bool_t  InitMCInfo(AliMCParticle *mcParticle);
 
     // MC info
     AliRsnMCInfo* GetMCInfo() const { return fMCInfo; }
-    
+
     // sorting (with respect to Pt)
     virtual Bool_t IsSortable() const {return kTRUE;}
     virtual Int_t  Compare(const TObject* obj) const;
@@ -137,9 +154,12 @@ class AliRsnDaughter : public AliVParticle
     Double_t           fPIDWeight[AliRsnPID::kSpecies]; // PID weights
 
     AliRsnMCInfo      *fMCInfo;     // reference to particle object (if any)
+
     static EPIDMethod  fgPIDMethod; // flag to define how the PID is computed for this object
 
-    ClassDef (AliRsnDaughter, 4);
+    static void        GetESDPID(AliESDtrack *track,Double_t *pid,EPIDType pidType = kEsd,Double_t divValue=-1.0,Double_t val=-1.0);
+
+    ClassDef(AliRsnDaughter, 4);
 };
 
 #endif
index fab29c6..ec1c8a9 100644 (file)
 #include "AliRsnEvent.h"
 #include "AliRsnMCInfo.h"
 
-ClassImp (AliRsnEvent)
+ClassImp(AliRsnEvent)
 
 //_____________________________________________________________________________
 AliRsnEvent::AliRsnEvent() :
-    TNamed ("rsnEvent", ""),
-    fPVx (0.0),
-    fPVy (0.0),
-    fPVz (0.0),
-    fTracks (0x0),
+    TNamed("rsnEvent", ""),
+    fPVx(0.0),
+    fPVy(0.0),
+    fPVz(0.0),
+    fTracks(0x0),
     fNoPID(0x0),
-    fPerfectPID (0x0),
-    fRealisticPID (0x0)
+    fPerfectPID(0x0),
+    fRealisticPID(0x0)
 {
 //
 // Default constructor
@@ -54,15 +54,15 @@ AliRsnEvent::AliRsnEvent() :
 }
 
 //_____________________________________________________________________________
-AliRsnEvent::AliRsnEvent (const AliRsnEvent &event) :
-    TNamed (event),
-    fPVx (event.fPVx),
-    fPVy (event.fPVy),
-    fPVz (event.fPVz),
-    fTracks (0x0),
+AliRsnEvent::AliRsnEvent(const AliRsnEvent &event) :
+    TNamed(event),
+    fPVx(event.fPVx),
+    fPVy(event.fPVy),
+    fPVz(event.fPVz),
+    fTracks(0x0),
     fNoPID(0x0),
-    fPerfectPID (0x0),
-    fRealisticPID (0x0)
+    fPerfectPID(0x0),
+    fRealisticPID(0x0)
 {
 //
 // Copy constructor.
@@ -71,16 +71,16 @@ AliRsnEvent::AliRsnEvent (const AliRsnEvent &event) :
 // trusting on the PID informations in the copied tracks.
 //
 
-    // during track copy, counts how many faults happen
-    Int_t errors = Fill (event.fTracks);
-    if (errors) AliWarning (Form ("%d errors occurred in copy", errors));
+  // during track copy, counts how many faults happen
+  Int_t errors = Fill(event.fTracks);
+  if (errors) AliWarning(Form("%d errors occurred in copy", errors));
 
-    // fill PID index arrays
-    // FillPIDArrays();
+  // fill PID index arrays
+  // FillPIDArrays();
 
-    if (event.fNoPID) fNoPID = new AliRsnPIDIndex(*(event.fNoPID));
-    if (event.fPerfectPID) fPerfectPID = new AliRsnPIDIndex(*(event.fPerfectPID));
-    if (event.fRealisticPID) fRealisticPID = new AliRsnPIDIndex(*(event.fRealisticPID));
+  if (event.fNoPID) fNoPID = new AliRsnPIDIndex(* (event.fNoPID));
+  if (event.fPerfectPID) fPerfectPID = new AliRsnPIDIndex(* (event.fPerfectPID));
+  if (event.fRealisticPID) fRealisticPID = new AliRsnPIDIndex(* (event.fRealisticPID));
 }
 
 //_____________________________________________________________________________
@@ -89,36 +89,39 @@ AliRsnEvent& AliRsnEvent::operator= (const AliRsnEvent &event)
 //
 // Works in the same way as the copy constructor.
 //
-    // copy name and title
-    SetName (event.GetName());
-    SetTitle (event.GetTitle());
-
-    // copy primary vertex and initialize track counter to 0
-    fPVx = event.fPVx;
-    fPVy = event.fPVy;
-    fPVz = event.fPVz;
-
-    // add tracks from array of argument
-    Int_t errors = Fill (event.fTracks);
-    if (errors) AliWarning (Form ("%d errors occurred in copy", errors));
-
-    // fill PID arrays
-    // FillPIDArrays();
-    if (event.fNoPID) {
-        if (!fNoPID) fNoPID = new AliRsnPIDIndex(*(event.fNoPID));
-        else (*fNoPID) = *(event.fNoPID);
-    }
-    if (event.fPerfectPID) {
-        if (!fPerfectPID) fPerfectPID = new AliRsnPIDIndex(*(event.fPerfectPID));
-        else (*fPerfectPID) = *(event.fPerfectPID);
-    }
-    if (event.fRealisticPID) {
-        if (!fRealisticPID) fRealisticPID = new AliRsnPIDIndex(*(event.fRealisticPID));
-        else (*fRealisticPID) = *(event.fRealisticPID);
-    }
-
-    // return this object
-    return (*this);
+  // copy name and title
+  SetName(event.GetName());
+  SetTitle(event.GetTitle());
+
+  // copy primary vertex and initialize track counter to 0
+  fPVx = event.fPVx;
+  fPVy = event.fPVy;
+  fPVz = event.fPVz;
+
+  // add tracks from array of argument
+  Int_t errors = Fill(event.fTracks);
+  if (errors) AliWarning(Form("%d errors occurred in copy", errors));
+
+  // fill PID arrays
+  // FillPIDArrays();
+  if (event.fNoPID)
+  {
+    if (!fNoPID) fNoPID = new AliRsnPIDIndex(* (event.fNoPID));
+    else (*fNoPID) = * (event.fNoPID);
+  }
+  if (event.fPerfectPID)
+  {
+    if (!fPerfectPID) fPerfectPID = new AliRsnPIDIndex(* (event.fPerfectPID));
+    else (*fPerfectPID) = * (event.fPerfectPID);
+  }
+  if (event.fRealisticPID)
+  {
+    if (!fRealisticPID) fRealisticPID = new AliRsnPIDIndex(* (event.fRealisticPID));
+    else (*fRealisticPID) = * (event.fRealisticPID);
+  }
+
+  // return this object
+  return (*this);
 }
 
 //_____________________________________________________________________________
@@ -131,8 +134,8 @@ AliRsnEvent::~AliRsnEvent()
 // destructor, which is automatically called from here.
 //
 
-    Clear();
-    if (fTracks) delete fTracks;
+  Clear();
+  if (fTracks) delete fTracks;
 }
 
 //_____________________________________________________________________________
@@ -142,12 +145,12 @@ void AliRsnEvent::Init()
 // Initialize TClonesArray data-member.
 //
 
-    fTracks = new TClonesArray ("AliRsnDaughter", 1);
-    //fTracks->BypassStreamer (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;
+  }
 }
index 26e7c8f..651681e 100644 (file)
@@ -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
index 1abdf07..9d18c02 100644 (file)
 #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;
 }
index 69e4bb9..e7493bb 100644 (file)
 
 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
index 68a3da8..5eefee5 100644 (file)
@@ -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; i<str.Length(); i++ )
+  for (Int_t i=0; i<str.Length(); i++)
   {
-    if ( str[i] == ' ' ) continue;
-    str1.Append ( str[i] );
+    if (str[i] == ' ') continue;
+    str1.Append(str[i]);
   }
   // get variable tokens
-  TObjArray* valtok = str1.Tokenize ( "!&|()" );
+  TObjArray* valtok = str1.Tokenize("!&|()");
   // put all variables together
   Int_t nvt = valtok->GetEntriesFast();
   TString sumval;
-  for ( Int_t i=0; i<nvt; i++ )
+  for (Int_t i=0; i<nvt; i++)
   {
-    TObjString* val = ( TObjString* ) valtok->At ( 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; i<nopt; i++ )
+  for (Int_t i=0; i<nopt; i++)
   {
-    TObjString* val1 = ( TObjString* ) optok->At ( 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 "<<i<< "Primary " << result->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 "<<i<< " Expression AND " << result->Unparse() << endl;
         break;
       case '|' :
-        result = new AliRsnExpression ( kOpOR, result, Primary ( st, i ) );
+        result = new AliRsnExpression(kOpOR, result, Primary(st, i));
 //   cout <<"i "<<i<< " Expression OR " << result->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());
 }
 
index fb92672..c0796dc 100644 (file)
@@ -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
index d87f7e7..431f397 100644 (file)
 //
 
 #include <TH1.h>
-#include <TH2.h>
 
 #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;
 }
index 5cd6cbb..bd1b9e4 100644 (file)
@@ -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)
 };
index 5781539..de84229 100644 (file)
@@ -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;
 }
index 556613c..b70eca5 100644 (file)
@@ -7,39 +7,45 @@
 
 class AliRsnMCInfo : public TObject
 {
-public:
+  public:
     AliRsnMCInfo();
-    AliRsnMCInfo ( const AliRsnMCInfo &copy );
+    AliRsnMCInfo(const AliRsnMCInfo &copy);
 
     ~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
index 0d6f901..2e53130 100644 (file)
 
 #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 );
+  }
 }
index 1e16017..41e64fd 100644 (file)
@@ -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);
 };
index ef3a778..741443a 100644 (file)
 
 #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;
+  }
 }
index 488494d..1c4dfba 100644 (file)
 
 class AliRsnPIDIndex : public TObject
 {
-public:
+  public:
 
-    AliRsnPIDIndex (Int_t num = 1000);
-    AliRsnPIDIndex (const AliRsnPIDIndex &copy);
+    AliRsnPIDIndex(Int_t num = 2000);
+    AliRsnPIDIndex(const AliRsnPIDIndex &copy);
     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
index 7d0778e..694881c 100644 (file)
@@ -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)
 //-------------------------------------------------------------------------
 
 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;
 }
index f1db9d3..13b4d65 100644 (file)
@@ -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)
 //-------------------------------------------------------------------------
 
 
 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 (file)
index 0000000..0f40b8e
--- /dev/null
@@ -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 (file)
index 0000000..8323a2c
--- /dev/null
@@ -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 &copy) : 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
index 42308e8..59e3898 100644 (file)
@@ -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.
@@ -50,9 +49,23 @@ AliRsnPairDef::AliRsnPairDef
 }
 
 //_____________________________________________________________________________
+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 &copy) :
-  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;
+}
index db9a54c..76ee8cd 100644 (file)
 #ifndef ALIRSNPAIRDEF_H
 #define ALIRSNPAIRDEF_H
 
+#include <TString.h>
+
 #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 &copy);
-    const AliRsnPairDef& operator=(const AliRsnPairDef &copy);
+    const AliRsnPairDef& operator= (const AliRsnPairDef &copy);
     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 (file)
index 0000000..db78cfc
--- /dev/null
@@ -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;i<fPairs.GetEntriesFast() ;i++ )
+  {
+    pair = ( AliRsnPair * ) fPairs.At ( i );
+    pair->Print();
+  }
+}
diff --git a/PWG2/RESONANCES/AliRsnPairMgr.h b/PWG2/RESONANCES/AliRsnPairMgr.h
new file mode 100644 (file)
index 0000000..2b02a49
--- /dev/null
@@ -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
index ab9999e..8dc0493 100644 (file)
@@ -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 ===========");
 }
index 26cf001..0775322 100644 (file)
 
 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
index c3dddf6..c4c128f 100644 (file)
@@ -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 <TString.h>
-#include <TDirectory.h>
 
 #include "AliLog.h"
 
 #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;
+}
index 96ce1b2..070eecd 100644 (file)
@@ -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 <TNamed.h>
+#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 &copy) : 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 (file)
index 0000000..208baf4
--- /dev/null
@@ -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 (file)
index 0000000..68f787e
--- /dev/null
@@ -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
index 6489427..7e2b1ba 100644 (file)
@@ -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()));
 }
 
 //_____________________________________________________________________________
index 9f55418..9cb0e0d 100644 (file)
 #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 &copy) :
-      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
index 89d3feb..7bcd74f 100644 (file)
@@ -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");
-