Major upgrade to the package, in order to speed-up the execution and remove some...
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 31 Jul 2010 17:05:47 +0000 (17:05 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 31 Jul 2010 17:05:47 +0000 (17:05 +0000)
Added some new cuts used for current analysis, and some monitor analysis task in order to check some quality cuts to tune them properly.

AliRsnDaughter:
- added a TLorentzVector datamember which will contain all kinematic informations
  (one for default input and another for MC if necessary)
  >> removed most of the kinematic-like getters
  >> access to kinematics of the track through the getter which returns this object
  >> eases a lot the procedure of summing up without errors
  NOTE: now the AliRsnDaughter should be able to deal also with V0s, in order to
        search for *charged* resonances (this is under test, but it is basically implemented)

AliRsnPairParticle --> renamed into AliRsnMother
- added two TLorentzVector which are set from two AliRsnDaughters and two masses
  assigned to them

The AliRsnCutManager (renamed class) has been reviewes as follows:
- removed the slot related to cuts on events, because it is redundant
  if repeated on all AliRsnPair objects, it has been moved at the level
  of the AnalysisManager
- added the possibility to specify some cuts only for the first or second daughter
  so there are three different slots: common (checked for both), first and second (checked for one only)

AliRsnFunctionAxis was renamed as AliRsnValue for meaning reasons.

AliRsn Analysis tasks will contain only one analysis manager,
since the use of them in the train (which should be the default)
stores all outputs into a single file, so there is no reason to have
different analysis manager, which cause confusion when configuring the task.

AliRsnPair becam a virtual base classe for different output systems
the 'old' version which stores histograms is now AliRsnPairFunctions, and works like before.
A new possibility was added to save output as a TNtuple, with the class AliRsnPairNtuple,
which needs to be initialized just defining what values it has to store for each entry,
which are defined using the same class AliRsnValue which is used to create the AliRsnFunctions
which are used as the output for the previous version of this class.
There is the possibility to implement new output formats using this base class.

REMOVED CLASSES:
- AliRsnVManager (not needed any longer)
- AliRsnHistoDef (obsolete, not used since long time)
- AliRsnPairManager (unnecessary step more in configuration)
- AliRsnPIDDefESD (replaced by a dedicated AliRsnCut for PID)
- AliRsnAnalysisTrackEffSE (never used)
- AliRsnCutESDTrigger (better to use AliPhysicsSelection)

90 files changed:
PWG2/PWG2resonancesLinkDef.h
PWG2/RESONANCES/AliRsnAnalysisEffSE.cxx
PWG2/RESONANCES/AliRsnAnalysisEffSE.h
PWG2/RESONANCES/AliRsnAnalysisME.cxx
PWG2/RESONANCES/AliRsnAnalysisME.h
PWG2/RESONANCES/AliRsnAnalysisManager.cxx
PWG2/RESONANCES/AliRsnAnalysisManager.h
PWG2/RESONANCES/AliRsnAnalysisPhi7TeVNoPID.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisPhi7TeVNoPID.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisSE.cxx
PWG2/RESONANCES/AliRsnAnalysisSE.h
PWG2/RESONANCES/AliRsnAnalysisTrackEffSE.cxx [deleted file]
PWG2/RESONANCES/AliRsnAnalysisTrackEffSE.h [deleted file]
PWG2/RESONANCES/AliRsnCut.cxx
PWG2/RESONANCES/AliRsnCut.h
PWG2/RESONANCES/AliRsnCutBetheBloch.cxx
PWG2/RESONANCES/AliRsnCutBetheBloch.h
PWG2/RESONANCES/AliRsnCutDaughterType.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutDaughterType.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutESD2010.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutESD2010.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutESDPrimary.cxx
PWG2/RESONANCES/AliRsnCutESDPrimary.h
PWG2/RESONANCES/AliRsnCutESDTrigger.cxx [deleted file]
PWG2/RESONANCES/AliRsnCutESDTrigger.h [deleted file]
PWG2/RESONANCES/AliRsnCutManager.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutManager.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutMgr.cxx [deleted file]
PWG2/RESONANCES/AliRsnCutMgr.h [deleted file]
PWG2/RESONANCES/AliRsnCutPID.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutPID.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutPrimaryVertex.cxx
PWG2/RESONANCES/AliRsnCutPrimaryVertex.h
PWG2/RESONANCES/AliRsnCutSet.cxx
PWG2/RESONANCES/AliRsnCutSet.h
PWG2/RESONANCES/AliRsnCutStd.cxx
PWG2/RESONANCES/AliRsnCutStd.h
PWG2/RESONANCES/AliRsnDaughter.cxx
PWG2/RESONANCES/AliRsnDaughter.h
PWG2/RESONANCES/AliRsnEvent.cxx
PWG2/RESONANCES/AliRsnEvent.h
PWG2/RESONANCES/AliRsnFunction.cxx
PWG2/RESONANCES/AliRsnFunction.h
PWG2/RESONANCES/AliRsnFunctionAxis.cxx [deleted file]
PWG2/RESONANCES/AliRsnFunctionAxis.h [deleted file]
PWG2/RESONANCES/AliRsnHistoDef.cxx [deleted file]
PWG2/RESONANCES/AliRsnHistoDef.h [deleted file]
PWG2/RESONANCES/AliRsnMother.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnMother.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPIDDefESD.cxx [deleted file]
PWG2/RESONANCES/AliRsnPIDDefESD.h [deleted file]
PWG2/RESONANCES/AliRsnPIDIndex.cxx [deleted file]
PWG2/RESONANCES/AliRsnPIDIndex.h [deleted file]
PWG2/RESONANCES/AliRsnPair.cxx
PWG2/RESONANCES/AliRsnPair.h
PWG2/RESONANCES/AliRsnPairDef.cxx
PWG2/RESONANCES/AliRsnPairDef.h
PWG2/RESONANCES/AliRsnPairFunctions.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairFunctions.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairManager.cxx [deleted file]
PWG2/RESONANCES/AliRsnPairManager.h [deleted file]
PWG2/RESONANCES/AliRsnPairNtuple.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairNtuple.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairParticle.cxx [deleted file]
PWG2/RESONANCES/AliRsnPairParticle.h [deleted file]
PWG2/RESONANCES/AliRsnVATProcessInfo.cxx
PWG2/RESONANCES/AliRsnVAnalysisTaskME.cxx
PWG2/RESONANCES/AliRsnVAnalysisTaskME.h
PWG2/RESONANCES/AliRsnVAnalysisTaskSE.cxx
PWG2/RESONANCES/AliRsnVAnalysisTaskSE.h
PWG2/RESONANCES/AliRsnVManager.cxx [deleted file]
PWG2/RESONANCES/AliRsnVManager.h [deleted file]
PWG2/RESONANCES/AliRsnValue.cxx
PWG2/RESONANCES/AliRsnValue.h
PWG2/RESONANCES/AliRsnValueList.cxx [deleted file]
PWG2/RESONANCES/AliRsnValueList.h [deleted file]
PWG2/RESONANCES/macros/test/AddAnalysisTaskRsnTest.C [new file with mode: 0644]
PWG2/RESONANCES/macros/test/AliRsnAnalysis.C [deleted file]
PWG2/RESONANCES/macros/test/AliRsnTrain.C [deleted file]
PWG2/RESONANCES/macros/test/ConfigTaskRsn2010.C [new file with mode: 0644]
PWG2/RESONANCES/macros/test/ConfigTaskRsnTest.C [new file with mode: 0644]
PWG2/RESONANCES/macros/test/PWG2resonancesUtils.C [deleted file]
PWG2/RESONANCES/macros/test/ProcessConfig.C [deleted file]
PWG2/RESONANCES/macros/test/runESDMCFilter.C [deleted file]
PWG2/RESONANCES/macros/test/runLocal.C [new file with mode: 0644]
PWG2/RESONANCES/macros/test/runProcess.C [deleted file]
PWG2/RESONANCES/macros/test/runProof.C [new file with mode: 0644]
PWG2/RESONANCES/macros/test/runRsnAnalysisSE.C [deleted file]
PWG2/RESONANCES/macros/test/test.xml [new file with mode: 0644]
PWG2/libPWG2resonances.pkg

index 1b1bbf90a739c6dcc74d199b00fce12e7ea3a96c..417ebdf29a1cfd90627032283a7008b99201d736 100644 (file)
@@ -1,49 +1,45 @@
 #ifdef __CINT__
 
 #pragma link C++ class AliRsnDaughter+;
-#pragma link C++ class AliRsnPairParticle+;
+#pragma link C++ class AliRsnMother+;
+#pragma link C++ class AliRsnEvent+;
 
 #pragma link C++ class AliRsnExpression+;
 #pragma link C++ class AliRsnVariableExpression+;
 #pragma link C++ class AliRsnCut+;
 #pragma link C++ class AliRsnCutStd+;
+#pragma link C++ class AliRsnCutPID+;
 #pragma link C++ class AliRsnCutBetheBloch+;
 #pragma link C++ class AliRsnCutESDPrimary+;
-#pragma link C++ class AliRsnCutESDTrigger+;
 #pragma link C++ class AliRsnCutPrimaryVertex+;
-#pragma link C++ class AliRsnCutSet+;
-#pragma link C++ class AliRsnCutMgr+;
-
-
-#pragma link C++ class AliRsnPIDIndex+;
-#pragma link C++ class AliRsnPIDDefESD+;
-
-#pragma link C++ class AliRsnEvent+;
+#pragma link C++ class AliRsnCutDaughterType+;
+#pragma link C++ class AliRsnCutESD2010+;
 
-#pragma link C++ class AliRsnPairDef+;
+#pragma link C++ class AliRsnCutSet+;
+#pragma link C++ class AliRsnCutManager+;
 
 #pragma link C++ class AliRsnValue+;
-#pragma link C++ class AliRsnValueList+;
 #pragma link C++ class AliRsnFunction+;
-#pragma link C++ class AliRsnFunctionAxis+;
 
+#pragma link C++ class AliRsnPairDef+;
 #pragma link C++ class AliRsnPair+;
+#pragma link C++ class AliRsnPairFunctions+;
+#pragma link C++ class AliRsnPairNtuple+;
+
+#pragma link C++ class AliRsnAnalysisManager+;
 
 #pragma link C++ class AliRsnVATProcessInfo+;
 #pragma link C++ class AliRsnVAnalysisTaskSE+;
 #pragma link C++ class AliRsnVAnalysisTaskME+;
-#pragma link C++ class AliRsnVManager+;
 
-#pragma link C++ class AliRsnPairManager+;
-#pragma link C++ class AliRsnAnalysisManager+;
 #pragma link C++ class AliRsnAnalysisSE+;
 #pragma link C++ class AliRsnAnalysisME+;
-#pragma link C++ class AliRsnAnalysisEffSE+;
-#pragma link C++ class AliRsnAnalysisTrackEffSE+;
+//#pragma link C++ class AliRsnAnalysisEffSE+;
 
 #pragma link C++ class AliRsnTOFT0maker+;
 #pragma link C++ class AliRsnAnalysisPhi900GeV+;
 #pragma link C++ class AliRsnAnalysisPhi7TeV+;
+#pragma link C++ class AliRsnAnalysisPhi7TeVNoPID+;
 
 #pragma link C++ class AliRsnMonitorTrack+;
 #pragma link C++ class AliRsnAnalysisMonitorTask+;
index 7b660f137e86e297c9ab42bf92fbeb08f949bb94..3e06fdac0b4b0e94f4e38957e286fef07cf95fcd 100644 (file)
@@ -13,8 +13,8 @@
 #include "AliMCEvent.h"
 
 #include "AliCFContainer.h"
-#include "AliRsnCutMgr.h"
-#include "AliRsnFunctionAxis.h"
+#include "AliRsnCutManager.h"
+#include "AliRsnValue.h"
 #include "AliRsnAnalysisEffSE.h"
 #include "AliRsnPairDef.h"
 #include "AliRsnCutSet.h"
@@ -94,7 +94,7 @@ void AliRsnAnalysisEffSE::RsnUserCreateOutputObjects()
   Int_t   *nBins     = new Int_t[nAxes];
   TArrayD *binLimits = new TArrayD[nAxes];
   for (iaxis = 0; iaxis < nAxes; iaxis++) {
-    AliRsnFunctionAxis *fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(iaxis);
+    AliRsnValue *fcnAxis = (AliRsnValue*)fAxisList.At(iaxis);
     binLimits[iaxis] = fcnAxis->GetArray();
     nBins[iaxis] = binLimits[iaxis].GetSize() - 1;
   }
@@ -122,6 +122,8 @@ void AliRsnAnalysisEffSE::RsnUserCreateOutputObjects()
 
   fOutList[1]->Add(fContainerList);
 
+  PostData(2, fOutList[1]);
+
   AliDebug(AliLog::kDebug+2,"->");
 }
 
@@ -245,7 +247,7 @@ void AliRsnAnalysisEffSE::ProcessEventMC(AliRsnPairDef *pairDef)
     if (fDaughter[0].PerfectPID() != pairDef->GetType(0)) continue;
     if (fDaughter[1].PerfectPID() != pairDef->GetType(1)) continue;
 
-    fPair.SetPair(&fDaughter[0], &fDaughter[1]);
+    fPair.SetDaughters(&fDaughter[0], &fDaughter[1]);
 
     // create pair
     FillContainer(cont, &fStepListMC, pairDef, 0);
@@ -266,10 +268,6 @@ void AliRsnAnalysisEffSE::ProcessEventESD(AliRsnPairDef *pairDef)
   AliCFContainer *cont = (AliCFContainer*)fContainerList->FindObject(pairDef->GetPairName().Data());
   if (!cont) return;
 
-  // get arrays of all charged tracks
-  TArrayI *a0 = fRsnPIDIndex.GetTracksArray(AliRsnDaughter::kPerfect, pairDef->GetCharge(0), pairDef->GetType(0));
-  TArrayI *a1 = fRsnPIDIndex.GetTracksArray(AliRsnDaughter::kPerfect, pairDef->GetCharge(1), pairDef->GetType(1));
-
   // external loop on tracks
   for (i0 = 0; i0 < a0->GetSize(); i0++) {
     // connect interface
@@ -304,12 +302,12 @@ void AliRsnAnalysisEffSE::FillContainer(AliCFContainer *cont, const TObjArray *s
 
   // compute values for all axes
   for (iaxis = 0; iaxis < nAxes; iaxis++) {
-    AliRsnFunctionAxis *fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(iaxis);
+    AliRsnValue *fcnAxis = (AliRsnValue*)fAxisList.At(iaxis);
     switch (fcnAxis->GetAxisObject()) {
-    case AliRsnFunctionAxis::kPair:
+    case AliRsnValue::kPair:
       fVar[iaxis] = (Double_t)fcnAxis->Eval(&fPair, pd);
       break;
-    case AliRsnFunctionAxis::kEvent:
+    case AliRsnValue::kEvent:
       fVar[iaxis] = (Double_t)fcnAxis->Eval(&fRsnEvent);
       break;
     default:
@@ -319,7 +317,7 @@ void AliRsnAnalysisEffSE::FillContainer(AliCFContainer *cont, const TObjArray *s
 
   // fill all steps
   for (istep = 0; istep < nSteps; istep++) {
-    AliRsnCutMgr *cutMgr = (AliRsnCutMgr*)stepList->At(istep);
+    AliRsnCutManager *cutMgr = (AliRsnCutManager*)stepList->At(istep);
     if (!cutMgr->IsSelected(AliRsnCut::kParticle, &fDaughter[0])) break;
     if (!cutMgr->IsSelected(AliRsnCut::kParticle, &fDaughter[1])) break;
     if (!cutMgr->IsSelected(AliRsnCut::kPair,     &fPair)) break;
@@ -347,3 +345,4 @@ void AliRsnAnalysisEffSE::AddPairDef(AliRsnPairDef* pairDef)
 //
   fPairDefList.AddLast(pairDef);
 }
+
index ab6b88b83063683d22f9f5652e7cedef7a4255c6..7d730f7e634e5aa8988f30da2b75911891ebf74d 100644 (file)
@@ -14,7 +14,7 @@
 
 #include "AliRsnVAnalysisTaskSE.h"
 #include "AliRsnEvent.h"
-#include "AliRsnPairParticle.h"
+#include "AliRsnMother.h"
 #include "AliRsnPIDIndex.h"
 
 class AliPID;
@@ -25,8 +25,8 @@ class AliRsnPairDef;
 class AliRsnPIDIndex;
 class AliRsnPIDDefESD;
 class AliRsnCutSet;
-class AliRsnCutMgr;
-class AliRsnFunctionAxis;
+class AliRsnCutManager;
+class AliRsnValue;
 
 class AliRsnAnalysisManager;
 class AliRsnAnalysisEffSE : public AliRsnVAnalysisTaskSE
@@ -45,9 +45,9 @@ class AliRsnAnalysisEffSE : public AliRsnVAnalysisTaskSE
     // settings
     void            SetEventCuts(AliRsnCutSet *const cuts) {fEventCuts = cuts;}
     void            AddPairDef(AliRsnPairDef *pairDef);
-    void            AddStepMC(AliRsnCutMgr *mgr) {fStepListMC.AddLast(mgr);}
-    void            AddStepESD(AliRsnCutMgr *mgr) {fStepListESD.AddLast(mgr);}
-    void            AddAxis(AliRsnFunctionAxis *axis) {fAxisList.AddLast(axis);}
+    void            AddStepMC(AliRsnCutManager *mgr) {fStepListMC.AddLast(mgr);}
+    void            AddStepESD(AliRsnCutManager *mgr) {fStepListESD.AddLast(mgr);}
+    void            AddAxis(AliRsnValue *axis) {fAxisList.AddLast(axis);}
 
   private:
 
@@ -63,7 +63,7 @@ class AliRsnAnalysisEffSE : public AliRsnVAnalysisTaskSE
     TObjArray             fPairDefList;             // decay channels
     TList                *fContainerList;           // list of CF containers
     TArrayD               fVar;                     // list of variables of the container
-    AliRsnPairParticle    fPair;                    // interface to pair
+    AliRsnMother          fPair;                    // interface to pair
     AliRsnDaughter        fDaughter[2];             // interface to tracks
 
     ClassDef(AliRsnAnalysisEffSE, 1)
index eef1d4f6a31fc1d077fb88110678f6b2de67e532..e8aea7bb4cb1d7ec151111c46085d9e6058e4e6e 100644 (file)
 ClassImp(AliRsnAnalysisME)
 
 //_____________________________________________________________________________
-AliRsnAnalysisME::AliRsnAnalysisME(const char *name, Int_t numOfOutputs) :
-    AliRsnVAnalysisTaskME(name, numOfOutputs),
+AliRsnAnalysisME::AliRsnAnalysisME(const char *name) :
+    AliRsnVAnalysisTaskME(name),
     fRsnAnalysisManager(),
-    fPIDIndex(0),
-    fPIDIndexMix(0),
     fEvent(),
-    fEventMix()
+    fEventMix(),
+    fOutList(0x0)
 {
 //
 // Default constructor
 //
   AliDebug(AliLog::kDebug+2, "<-");
-  Int_t i = 0;
-  for (i = 0;i < fNumberOfOutputs;i++) {
-    DefineOutput(i + 2, TList::Class());
-  }
+
+  DefineOutput(2, TList::Class());
   AliDebug(AliLog::kDebug+2,"->");
 }
 
 AliRsnAnalysisME::AliRsnAnalysisME(const AliRsnAnalysisME& copy) : AliRsnVAnalysisTaskME(copy),
     fRsnAnalysisManager(copy.fRsnAnalysisManager),
-    fPIDIndex(copy.fPIDIndex),
-    fPIDIndexMix(copy.fPIDIndexMix),
     fEvent(copy.fEvent),
-    fEventMix(copy.fEvent)
+    fEventMix(copy.fEvent),
+    fOutList(0x0)
 {
   AliDebug(AliLog::kDebug+2, "<-");
   AliDebug(AliLog::kDebug+2,"->");
@@ -60,16 +56,12 @@ void AliRsnAnalysisME::RsnUserCreateOutputObjects()
 
   AliDebug(AliLog::kDebug+2, "<-");
 
-  Int_t i;
-  for (i = 1; i < kMaxNumberOfOutputs + 1; i++) {
-    if (i <= fNumberOfOutputs + 1) OpenFile(i/* + 1*/);
-    fOutList[i] = new TList();
-    fOutList[i]->SetOwner();
-  }
+  fOutList = new TList();
+  fOutList->SetOwner();
 
-  for (i = 0; i < fNumberOfOutputs; i++) {
-    fRsnAnalysisManager[i].InitAllPairMgrs(fOutList[i+1]);
-  }
+  fRsnAnalysisManager.InitAllPairs(fOutList);
+
+  PostData(2, fOutList);
 
   AliDebug(AliLog::kDebug+2,"->");
 }
@@ -92,12 +84,7 @@ void AliRsnAnalysisME::RsnUserExec(Option_t*)
   // update the task info...
   fTaskInfo.SetEventUsed(kTRUE);
 
-  // the virtual class has already sorted tracks in the PID index
-  // so we need here just to call the execution of analysis
-  for (Int_t i = 0; i < fNumberOfOutputs; i++) {
-//     fRsnAnalysisManager[i].ProcessAllPairMgrs(&fRsnPIDIndex, &fRsnEvent);
-    PostData(i + 2, fOutList[i+1]);
-  }
+  PostData(2, fOutList);
 
   AliDebug(AliLog::kDebug+2,"->");
 }
@@ -154,21 +141,9 @@ void AliRsnAnalysisME::DoAODMixing(AliAODEvent* aod1, AliAODEvent* aod2)
   if (fEvent.GetMultiplicity() < 2) return;
   if (fEventMix.GetMultiplicity() < 2) return;
 
-  // sort tracks w.r. to PID
-  fPIDIndex.ResetAll(fEvent.GetMultiplicity());
-  fEvent.SetPriorProbability(fPrior);
-  fPIDIndex.FillFromEvent(&fEvent);
-  fPIDIndex.SetCorrectIndexSize();
-
-  fPIDIndexMix.ResetAll(fEventMix.GetMultiplicity());
-  fEventMix.SetPriorProbability(fPrior);
-  fPIDIndexMix.FillFromEvent(&fEventMix);
-  fPIDIndexMix.SetCorrectIndexSize();
+  fRsnAnalysisManager.ProcessAllPairs(&fEvent, &fEventMix);
+  PostData(2, fOutList);
 
-  for (Int_t i = 0; i < fNumberOfOutputs; i++) {
-    fRsnAnalysisManager[i].ProcessAllPairMgrs(&fPIDIndex, &fEvent, &fPIDIndexMix, &fEventMix);
-    PostData(i + 2, fOutList[i+1]);
-  }
   AliDebug(AliLog::kDebug, Form("AOD tracks %d", aod1->GetNumberOfTracks()));
   AliDebug(AliLog::kDebug, Form("AOD tracks %d", aod2->GetNumberOfTracks()));
 
@@ -199,21 +174,6 @@ void AliRsnAnalysisME::RsnTerminate(Option_t*)
   AliDebug(AliLog::kDebug+2,"->");
 }
 
-//_____________________________________________________________________________
-AliRsnAnalysisManager* AliRsnAnalysisME::GetAnalysisManager(Int_t index, TString name)
-{
-//
-// Recovery the analysis manager
-//
-
-  if (!name.IsNull()) {
-    SetAnalysisManagerName(name.Data(), index);
-  }
-
-  return &fRsnAnalysisManager[index];
-}
-
-
 //_____________________________________________________________________________
 void AliRsnAnalysisME::SetPriorProbability(AliPID::EParticleType type, Double_t p)
 {
@@ -253,3 +213,5 @@ void AliRsnAnalysisME::GetPriorProbability(Double_t *out) const
     out[i] = fPrior[i];
   }
 }
+
+
index 67a827017e245686cb78f21e0862c01738effa66..70072b720ce7c3f3e79690d969d2517f9cecc89e 100644 (file)
@@ -15,7 +15,6 @@
 #include "AliRsnVAnalysisTaskME.h"
 #include "AliRsnAnalysisManager.h"
 #include "AliRsnEvent.h"
-#include "AliRsnPIDIndex.h"
 
 class AliPID;
 class AliESDtrackCuts;
@@ -23,7 +22,7 @@ class AliRsnAnalysisME : public AliRsnVAnalysisTaskME
 {
 
   public:
-    AliRsnAnalysisME(const char *name = "AliRsnAnalysisME", Int_t numOfOutputs = 1);
+    AliRsnAnalysisME(const char *name = "AliRsnAnalysisME");
     AliRsnAnalysisME(const AliRsnAnalysisME& copy);
     virtual ~AliRsnAnalysisME() { ; };
 
@@ -32,8 +31,8 @@ class AliRsnAnalysisME : public AliRsnVAnalysisTaskME
     virtual void    RsnUserExec(Option_t*);
     virtual void    RsnTerminate(Option_t*);
 
-    AliRsnAnalysisManager *GetAnalysisManager(Int_t index = 0, TString name = "");
-    void SetAnalysisManagerName(const char *name, Int_t index = 0) { fRsnAnalysisManager[index].SetName(name); };
+    AliRsnAnalysisManager *GetAnalysisManager() {return &fRsnAnalysisManager;}
+    void SetAnalysisManagerName(const char *name) {fRsnAnalysisManager.SetName(name); };
 
     // Prior probs
     void            SetPriorProbability(AliPID::EParticleType type, Double_t p);
@@ -44,11 +43,10 @@ class AliRsnAnalysisME : public AliRsnVAnalysisTaskME
 
     AliRsnAnalysisME& operator=(const AliRsnAnalysisME& /*copy*/) { return *this; }
 
-    AliRsnAnalysisManager fRsnAnalysisManager[kMaxNumberOfOutputs];      // analysis main engine
-    AliRsnPIDIndex        fPIDIndex;                // utility --> PID sorter
-    AliRsnPIDIndex        fPIDIndexMix;             // utility --> PID sorter (mixed event)
+    AliRsnAnalysisManager fRsnAnalysisManager;      // analysis main engine
     AliRsnEvent           fEvent;                   // utility --> event interface
     AliRsnEvent           fEventMix;                // utility --> event interface (mixed event)
+    TList                *fOutList;                 // outputs
 
     Double_t              fPrior[AliPID::kSPECIES]; // prior probabilities
 
index f1cc9f781dbc15dbc4155dd793dbe73fef300442..04f5193f662b7978c7f8b7b6d511890e542d4b83 100644 (file)
 // revised by : A. Pulvirenti [alberto.pulvirenti@ct.infn.it]
 //
 
+#include <Riostream.h>
 #include <TROOT.h>
 
 #include "AliLog.h"
-#include "AliRsnPIDIndex.h"
+#include "AliVEvent.h"
 #include "AliRsnEvent.h"
-#include "AliRsnPairManager.h"
 #include "AliRsnPair.h"
 #include "AliRsnAnalysisManager.h"
 
@@ -30,7 +30,8 @@ ClassImp(AliRsnAnalysisManager)
 
 //_____________________________________________________________________________
 AliRsnAnalysisManager::AliRsnAnalysisManager(const char*name) :
-    AliRsnVManager(name)
+  TNamed(name, ""),
+  fPairs(0)
 {
 //
 // Default constructor
@@ -41,29 +42,25 @@ AliRsnAnalysisManager::AliRsnAnalysisManager(const char*name) :
 }
 
 //_____________________________________________________________________________
-//void AliRsnAnalysisManager::Add(AliRsnPairManager *pair)
-void AliRsnAnalysisManager::Add(TObject *objPairMgr)
+void AliRsnAnalysisManager::Add(AliRsnPair *pair)
 {
 //
 // Adds a new pair manager to the list.
 //
 
   AliDebug(AliLog::kDebug+2,"<-");
-  AliRsnPairManager *pair = dynamic_cast<AliRsnPairManager*>(objPairMgr);
 
   if (!pair) {
     AliWarning(Form("AliRsnPairManager is %p. Skipping ...", pair));
     return;
   }
 
-  AliDebug(AliLog::kDebug+1, Form("Adding %s [%d]...", pair->GetName(), fArray.GetEntries()));
-  fArray.Add((AliRsnPairManager*)pair);
+  AliDebug(AliLog::kDebug+1, Form("Adding %s [%d]...", pair->GetName(), fPairs.GetEntries()));
+  fPairs.Add((AliRsnPair*)pair);
 
   AliDebug(AliLog::kDebug+2,"->");
 }
 
-
-
 //_____________________________________________________________________________
 void AliRsnAnalysisManager::Print(Option_t* /*dummy*/) const
 {
@@ -84,15 +81,15 @@ void AliRsnAnalysisManager::PrintArray() const
 
   AliDebug(AliLog::kDebug+2,"<-");
 
-  AliRsnPairManager *mgr = 0;
-  TObjArrayIter next(&fArray);
-  while ((mgr = (AliRsnPairManager*)next())) mgr->Print();
+  AliRsnPair *pair = 0;
+  TObjArrayIter next(&fPairs);
+  while ((pair = (AliRsnPair*)next())) pair->Print();
 
   AliDebug(AliLog::kDebug+2,"->");
 }
 
 //_____________________________________________________________________________
-void AliRsnAnalysisManager::InitAllPairMgrs(TList *list)
+void AliRsnAnalysisManager::InitAllPairs(TList *list)
 {
 //
 // Initialize all pair managers, and put all the TList of histograms
@@ -105,60 +102,80 @@ void AliRsnAnalysisManager::InitAllPairMgrs(TList *list)
 //   list->SetName(GetName());
 //   list->SetOwner();
 
-  AliRsnPairManager *pairMgr = 0;
-  TObjArrayIter next(&fArray);
+  AliRsnPair   *pair = 0;
+  TObjArrayIter next(&fPairs);
   Int_t i = 0;
-  while ((pairMgr = (AliRsnPairManager*)next())) {
-    AliDebug(AliLog::kDebug+1, Form("InitAllPairs of the AnalysisManager(%s) [%d] ...", pairMgr->GetName(), i++));
-//     list->Add();
-    pairMgr->InitAllPairs(list);
+  while ((pair = (AliRsnPair*)next())) 
+  {
+    if (!pair) continue;
+    AliDebug(AliLog::kDebug+1, Form("InitAllPairs of the PairManager(%s) [%d] ...", pair->GetName(), i++));
+    pair->Init("", list);
   }
   AliDebug(AliLog::kDebug+2, "->");
 //   return list;
 }
 
 //_____________________________________________________________________________
-void AliRsnAnalysisManager::ProcessAllPairMgrs
-(AliRsnPIDIndex *pidIndexes1, AliRsnEvent *ev1, AliRsnPIDIndex *pidIndexes2, AliRsnEvent *ev2)
+void AliRsnAnalysisManager::ProcessAllPairs(AliRsnEvent *ev0, AliRsnEvent *ev1)
 {
 //
 // Process one or two events for all pair managers.
 //
 
   AliDebug(AliLog::kDebug+2,"<-");
-
-  AliRsnPairManager *pairMgr = 0;
-  TObjArrayIter next(&fArray);
-
-  Int_t i = 0;
-  while ((pairMgr = (AliRsnPairManager*)next())) {
-    AliDebug(AliLog::kDebug+1, Form("ProcessAllPairMgrs of the AnalysisManager(%s) [%d] ...", pairMgr->GetName(), i++));
-    pairMgr->ProcessAllPairs(pidIndexes1, ev1, pidIndexes2, ev2);
+  
+  if (!ev1) ev1 = ev0;
+  
+  Int_t nTracks[2], nV0[2], nTot[2];
+  nTracks[0] = ev0->GetRef()->GetNumberOfTracks();
+  nV0[0]     = ev0->GetRef()->GetNumberOfV0s();
+  nTracks[1] = ev1->GetRef()->GetNumberOfTracks();
+  nV0[1]     = ev1->GetRef()->GetNumberOfV0s();
+  nTot[0]    = nTracks[0] + nV0[0];
+  nTot[1]    = nTracks[1] + nV0[1];
+  
+  // external loop
+  // joins the loop on tracks and v0s, by looping the indexes from 0
+  // to the sum of them, and checking what to take depending of its value
+  Int_t          i0, i1, i;
+  AliRsnDaughter daughter0, daughter1;
+  AliRsnPair    *pair = 0x0;
+  TObjArrayIter  next(&fPairs);
+  
+  for (i0 = 0; i0 < nTot[0]; i0++)
+  {
+    // assign first track
+    if (i0 < nTracks[0]) ev0->SetDaughter(daughter0, i0, AliRsnDaughter::kTrack);
+    else ev0->SetDaughter(daughter0, i0 - nTracks[0], AliRsnDaughter::kV0);
+        
+    // internal loop (same criterion)
+    for (i1 = 0; i1 < nTot[1]; i1++)
+    {
+      // if looking same event, skip the case when the two indexes are equal
+      if (ev0 == ev1 && i0 == i1) continue;
+      
+      // assign second track
+      if (i1 < nTracks[1]) ev1->SetDaughter(daughter1, i1, AliRsnDaughter::kTrack);
+      else ev1->SetDaughter(daughter1, i1 - nTracks[1], AliRsnDaughter::kV0);
+      
+      // loop over all pairs and make computations
+      next.Reset();
+      i = 0;
+      while ((pair = (AliRsnPair*)next())) 
+      {
+        AliDebug(AliLog::kDebug+1, Form("ProcessAllPairs of the AnalysisManager(%s) [%d] ...", pair->GetName(), i++));
+        
+        // if the pair is a like-sign, skip the case when i1 < i0,
+        // in order not to double count each like-sign pair
+        // (equivalent to looping from i0+1 to ntracks)
+        if (pair->GetPairDef()->IsLikeSign() && i1 < i0) continue;
+                
+        // process the two tracks
+        if (!pair->Fill(&daughter0, &daughter1, ev0, ev1)) continue;
+        pair->Compute();
+      }
+    }
   }
 
   AliDebug(AliLog::kDebug+2,"->");
 }
-
-//_____________________________________________________________________________
-void AliRsnAnalysisManager::AddConfig
-(TString config,TString prefix,TString functionName)
-{
-//
-// Adds a new AliRsnPair generated according to a configuration macro
-// which is called interactively and executed from a ROOT session
-//
-
-  AliDebug(AliLog::kDebug+2,"<-");
-
-  gROOT->LoadMacro(config.Data());
-
-  config.ReplaceAll(".C","");
-  prefix.ReplaceAll("_","-");
-
-  if (!functionName.IsNull()) config = functionName;
-
-  AliRsnPairManager *pairMgr = (AliRsnPairManager*)gROOT->ProcessLine(Form("%s(\"%s\");", config.Data(), prefix.Data()));
-  Add(pairMgr);
-
-  AliDebug(AliLog::kDebug+2,"->");
-}
index 55c5fe96ec811ffc03b6521974ed773dad530345..e628cdfc16ba92a03c8b8b46c4f219d5cb9a642a 100644 (file)
 #ifndef ALIRSNANALYSISMANAGER_H
 #define ALIRSNANALYSISMANAGER_H
 
-// #include <TROOT.h>
-
-#include "AliRsnVManager.h"
-// #include "AliRsnPairManager.h"
 class TROOT;
-class AliRsnPIDIndex;
+
 class AliRsnEvent;
-class AliRsnPairManager;
-class AliRsnAnalysisManager : public AliRsnVManager
+class AliRsnPair;
+
+class AliRsnAnalysisManager : public TNamed
 {
   public:
 
     AliRsnAnalysisManager(const char*name = "defaultAnalysisMgr");
     virtual ~AliRsnAnalysisManager() {;};
 
-    //virtual void   Add(AliRsnPairManager *pair);
-    virtual void   Add(TObject *pair);
-    virtual void   AddConfig(TString config, TString prefix, TString functionName = "");
+    virtual void   Add(AliRsnPair *pair);
     virtual void   PrintArray() const;
     virtual void   Print(Option_t *option = "") const;
 
-    void           InitAllPairMgrs(TList*list);
-    void           ProcessAllPairMgrs(AliRsnPIDIndex *pidIndexes1, AliRsnEvent *ev1, AliRsnPIDIndex *pidIndexes2 = 0, AliRsnEvent *ev2 = 0);
+    void           InitAllPairs(TList*list);
+    void           ProcessAllPairs(AliRsnEvent *ev0, AliRsnEvent *ev1);
 
   private:
+  
+    TObjArray   fPairs;
 
     ClassDef(AliRsnAnalysisManager, 1)
 };
diff --git a/PWG2/RESONANCES/AliRsnAnalysisPhi7TeVNoPID.cxx b/PWG2/RESONANCES/AliRsnAnalysisPhi7TeVNoPID.cxx
new file mode 100644 (file)
index 0000000..279ebb3
--- /dev/null
@@ -0,0 +1,786 @@
+//
+// Implementation file for implementation of data analysis aft 900 GeV
+//
+// Author: A. Pulvirenti
+//
+
+#include "Riostream.h"
+#include <iomanip>
+
+#include "TH1.h"
+#include "TTree.h"
+#include "TParticle.h"
+#include "TRandom.h"
+#include "TLorentzVector.h"
+
+#include "AliLog.h"
+#include "AliESDpid.h"
+#include "AliESDEvent.h"
+#include "AliESDVertex.h"
+#include "AliESDtrack.h"
+#include "AliStack.h"
+#include "AliMCEvent.h"
+#include "AliTOFT0maker.h"
+#include "AliTOFcalib.h"
+#include "AliCDBManager.h"
+#include "AliITSPIDResponse.h"
+
+#include "AliRsnAnalysisPhi7TeVNoPID.h"
+
+//__________________________________________________________________________________________________
+AliRsnAnalysisPhi7TeVNoPID::AliRsnAnalysisPhi7TeVNoPID(const char *name) :
+  AliAnalysisTaskSE(name),
+  fUseMC(kFALSE),
+  fPDG(0),
+  fCh(0),
+  fIM(0.0),
+  fPt(0.0),
+  fY(0.0),
+  fEta(0.0),
+  fMaxVz(1E6),
+  fMaxITSband(1E6),
+  fTPCpLimit(0.35),
+  fMinTPCband(-1E6),
+  fMaxTPCband( 1E6),
+  fRsnTreeComp(0x0),
+  fRsnTreeTrue(0x0),
+  fOutList(0x0),
+  fHEvents(0x0),
+  fESDtrackCutsTPC(),
+  fESDtrackCutsITS(),
+  fESDpid(0x0),
+  fTOFmaker(0x0),
+  fTOFcalib(0x0),
+  fTOFcalibrateESD(kFALSE),
+  fTOFcorrectTExp(kFALSE),
+  fTOFuseT0(kFALSE),
+  fTOFtuneMC(kFALSE),
+  fTOFresolution(0.0)
+  
+{
+//
+// Constructor
+//
+
+  DefineOutput(1, TTree::Class());
+  DefineOutput(2, TTree::Class());
+  DefineOutput(3, TList::Class());
+}
+
+//__________________________________________________________________________________________________
+AliRsnAnalysisPhi7TeVNoPID::AliRsnAnalysisPhi7TeVNoPID(const AliRsnAnalysisPhi7TeVNoPID& copy) :
+  AliAnalysisTaskSE(copy),
+  fUseMC(copy.fUseMC),
+  fPDG(0),
+  fCh(0),
+  fIM(0.0),
+  fPt(0.0),
+  fY(0.0),
+  fEta(0.0),
+  fMaxVz(copy.fMaxVz),
+  fMaxITSband(copy.fMaxITSband),
+  fTPCpLimit(copy.fTPCpLimit),
+  fMinTPCband(copy.fMinTPCband),
+  fMaxTPCband(copy.fMaxTPCband),
+  fRsnTreeComp(0x0),
+  fRsnTreeTrue(0x0),
+  fOutList(0x0),
+  fHEvents(0x0),
+  fESDtrackCutsTPC(copy.fESDtrackCutsTPC),
+  fESDtrackCutsITS(copy.fESDtrackCutsITS),
+  fESDpid(0x0),
+  fTOFmaker(0x0),
+  fTOFcalib(0x0),
+  fTOFcalibrateESD(kFALSE),
+  fTOFcorrectTExp(kFALSE),
+  fTOFuseT0(kFALSE),
+  fTOFtuneMC(kFALSE),
+  fTOFresolution(0.0)
+{
+//
+// Copy constructor
+//
+}
+
+//__________________________________________________________________________________________________
+AliRsnAnalysisPhi7TeVNoPID& AliRsnAnalysisPhi7TeVNoPID::operator=(const AliRsnAnalysisPhi7TeVNoPID& copy)
+{
+//
+// Assignment operator
+//
+
+  fUseMC = copy.fUseMC;
+
+  fMaxVz   = copy.fMaxVz;
+  fMaxITSband = copy.fMaxITSband;
+  
+  fTPCpLimit  = copy.fTPCpLimit;
+  fMinTPCband = copy.fMinTPCband;
+  fMaxTPCband = copy.fMaxTPCband;
+  
+  fESDtrackCutsTPC = copy.fESDtrackCutsTPC;
+  fESDtrackCutsITS = copy.fESDtrackCutsITS;
+  
+  fTOFcalibrateESD = copy.fTOFcalibrateESD;
+  fTOFcorrectTExp = copy.fTOFcorrectTExp;
+  fTOFuseT0 = copy.fTOFuseT0;
+  fTOFtuneMC = copy.fTOFtuneMC;
+  fTOFresolution = copy.fTOFresolution;
+
+  return (*this);
+}
+
+//__________________________________________________________________________________________________
+AliRsnAnalysisPhi7TeVNoPID::~AliRsnAnalysisPhi7TeVNoPID()
+{
+//
+// Destructor
+//
+
+  if (fRsnTreeComp) delete fRsnTreeComp;
+  if (fRsnTreeTrue) delete fRsnTreeTrue;
+  if (fHEvents)     delete fHEvents;
+  if (fESDpid)      delete fESDpid;
+}
+
+//__________________________________________________________________________________________________
+void AliRsnAnalysisPhi7TeVNoPID::UserCreateOutputObjects()
+{
+//
+// Create the output data container
+//
+
+  // setup TPC response
+  fESDpid = new AliESDpid;
+  fESDpid->GetTPCResponse().SetBetheBlochParameters(fTPCpar[0],fTPCpar[1],fTPCpar[2],fTPCpar[3],fTPCpar[4]);
+
+  // setup TOF maker & calibration
+  fTOFcalib = new AliTOFcalib;
+  fTOFmaker = new AliTOFT0maker(fESDpid, fTOFcalib);
+  fTOFmaker->SetTimeResolution(fTOFresolution);
+  
+  // initialize random
+  gRandom->SetSeed(0);
+
+  // create output trees
+  OpenFile(1);
+  fRsnTreeComp = new TTree("rsnTree", "Pairs");
+
+  fRsnTreeComp->Branch("pdg", &fPDG, "pdg/S"   );
+  fRsnTreeComp->Branch("ch" , &fCh , "ch/S"    );
+  fRsnTreeComp->Branch("im" , &fIM , "im/F"    );
+  fRsnTreeComp->Branch("y"  , &fY  , "y/F"     );
+  fRsnTreeComp->Branch("pt" , &fPt , "pt/F"    );
+  fRsnTreeComp->Branch("eta", &fEta, "eta/F"   );
+  fRsnTreeComp->Branch("its", &fITS, "its[2]/S");
+  
+  fRsnTreeComp->Branch("p"     , &fP        , "p[2]/F");
+  fRsnTreeComp->Branch("ptpc"  , &fPTPC     , "ptpc[2]/F");
+  fRsnTreeComp->Branch("tpcpid", &fTPCnsigma, "tpcpid[2]/F");
+  fRsnTreeComp->Branch("itspid", &fITSnsigma, "itspid[2]/F");
+  fRsnTreeComp->Branch("tofpid", &fTOFdiff  , "tofpid[2]/F");
+
+  OpenFile(2);
+  fRsnTreeTrue = new TTree("rsnTrue", "True pairs");
+
+  fRsnTreeTrue->Branch("im" , &fIM , "im/F" );
+  fRsnTreeTrue->Branch("y"  , &fY  , "y/F"  );
+  fRsnTreeTrue->Branch("pt" , &fPt , "pt/F" );
+  fRsnTreeTrue->Branch("eta", &fEta, "eta/F");
+
+  OpenFile(3);
+  fOutList    = new TList;
+  fHEvents    = new TH1I("hEvents", "Event details", 5, 0, 5);
+  fVertexX[0] = new TH1F("hVertexTracksX", "X position of primary vertex (tracks)", 200,  -2,  2);
+  fVertexY[0] = new TH1F("hVertexTracksY", "Y position of primary vertex (tracks)", 200,  -2,  2);
+  fVertexZ[0] = new TH1F("hVertexTracksZ", "Z position of primary vertex (tracks)", 400, -40, 40);
+  fVertexX[1] = new TH1F("hVertexSPDX", "X position of primary vertex (SPD)", 200,  -2,  2);
+  fVertexY[1] = new TH1F("hVertexSPDY", "Y position of primary vertex (SPD)", 200,  -2,  2);
+  fVertexZ[1] = new TH1F("hVertexSPDZ", "Z position of primary vertex (SPD)", 400, -40, 40);
+  
+  fHEvents->GetXaxis()->SetBinLabel(1, "Good vertex with tracks");
+  fHEvents->GetXaxis()->SetBinLabel(2, "Good vertex with SPD");
+  fHEvents->GetXaxis()->SetBinLabel(3, "Far vertex with tracks");
+  fHEvents->GetXaxis()->SetBinLabel(4, "Far vertex with SPD");
+  fHEvents->GetXaxis()->SetBinLabel(5, "No good vertex");
+
+  fOutList->Add(fHEvents);
+  fOutList->Add(fVertexX[0]);
+  fOutList->Add(fVertexY[0]);
+  fOutList->Add(fVertexZ[0]);
+  fOutList->Add(fVertexX[1]);
+  fOutList->Add(fVertexY[1]);
+  fOutList->Add(fVertexZ[1]);
+}
+
+//__________________________________________________________________________________________________
+void AliRsnAnalysisPhi7TeVNoPID::UserExec(Option_t *)
+{
+//
+// Main execution function.
+// Fills the fHEvents data member with the following legenda:
+// 0 -- event OK, prim vertex with tracks
+// 1 -- event OK, prim vertex with SPD
+// 2 -- event OK but vz large
+// 3 -- event bad
+//
+
+  static Int_t evNum = 0;
+  evNum++;
+
+  // retrieve ESD event and related stack (if available)
+  AliESDEvent *esd   = dynamic_cast<AliESDEvent*>(fInputEvent);
+  AliStack    *stack = (fMCEvent ? fMCEvent->Stack() : 0x0);
+  
+  // check the event
+  Int_t eval = EventEval(esd);
+  fHEvents->Fill(eval);
+  
+  // if the event is good for analysis, process it
+  if (eval == kGoodTracksPrimaryVertex || eval == kGoodSPDPrimaryVertex)
+  {
+    ProcessESD(esd, stack);
+    ProcessMC(stack);
+  }
+  
+  // update histogram container
+  PostData(3, fOutList);
+}
+
+//__________________________________________________________________________________________________
+void AliRsnAnalysisPhi7TeVNoPID::Terminate(Option_t *)
+{
+//
+// Terminate
+//
+}
+
+//__________________________________________________________________________________________________
+Int_t AliRsnAnalysisPhi7TeVNoPID::EventEval(AliESDEvent *esd)
+{
+//
+// Checks if the event is good for analysis.
+// Returns one of the flag values defined in the header
+//
+
+  static Int_t evNum = 0;
+  evNum++;
+
+  // debug message
+  AliDebug(AliLog::kDebug + 1, Form("Event %d -- number of tracks = %d", evNum, esd->GetNumberOfTracks()));
+  
+  // get the best primary vertex:
+  // first try the one with tracks
+  const AliESDVertex *vTrk  = esd->GetPrimaryVertexTracks();
+  const AliESDVertex *vSPD  = esd->GetPrimaryVertexSPD();
+  Double_t            vzTrk = 1000.0;
+  Double_t            vzSPD = 1000.0;
+  if (vTrk) vzTrk = TMath::Abs(vTrk->GetZv());
+  if (vSPD) vzSPD = TMath::Abs(vSPD->GetZv());
+  AliDebug(AliLog::kDebug + 1, Form("Event %d -- vertex with tracks: contributors = %d, abs(vz) = %f", evNum, vTrk->GetNContributors(), vzTrk));
+  AliDebug(AliLog::kDebug + 1, Form("Event %d -- vertex with SPD,    contributors = %d, abs(vz) = %f", evNum, vSPD->GetNContributors(), vzSPD));
+  if(vTrk->GetNContributors() > 0)
+  {
+    // fill the histograms
+    fVertexX[0]->Fill(vTrk->GetXv());
+    fVertexY[0]->Fill(vTrk->GetYv());
+    fVertexZ[0]->Fill(vTrk->GetZv());
+    
+    // check VZ position
+    if (vzTrk <= fMaxVz)
+      return kGoodTracksPrimaryVertex;
+    else
+      return kFarTracksPrimaryVertex;
+  }
+  else if (vSPD->GetNContributors() > 0)
+  {
+    // fill the histograms
+    fVertexX[1]->Fill(vSPD->GetXv());
+    fVertexY[1]->Fill(vSPD->GetYv());
+    fVertexZ[1]->Fill(vSPD->GetZv());
+    
+    // check VZ position
+    if (vzSPD <= fMaxVz)
+      return kGoodSPDPrimaryVertex;
+    else
+      return kFarSPDPrimaryVertex;
+  }
+  else
+    return kNoGoodPrimaryVertex;
+}
+
+//__________________________________________________________________________________________________
+void AliRsnAnalysisPhi7TeVNoPID::ProcessESD
+(AliESDEvent *esd, AliStack *stack)
+{
+//
+// This function works with the ESD object
+//
+
+  // ITS stuff #1 create the response function
+  Bool_t isMC = (stack != 0x0);
+  AliITSPIDResponse itsrsp(isMC);
+
+  // TOF stuff #1: init OCDB
+  Int_t run = esd->GetRunNumber();
+  AliCDBManager *cdb = AliCDBManager::Instance();
+  cdb->SetDefaultStorage("raw://");
+  cdb->SetRun(run);
+  // TOF stuff #2: init calibration
+  fTOFcalib->SetCorrectTExp(fTOFcorrectTExp);
+  fTOFcalib->Init();
+  // TOF stuff #3: calibrate
+  if (fTOFcalibrateESD) fTOFcalib->CalibrateESD(esd);
+  if (fTOFtuneMC) fTOFmaker->TuneForMC(esd);
+  if (fTOFuseT0) 
+  {
+    fTOFmaker->ComputeT0TOF(esd);
+    fTOFmaker->ApplyT0TOF(esd);
+    fESDpid->MakePID(esd, kFALSE, 0.);
+  }
+
+  // prepare to look on all tracks to select the ones
+  // which pass all the cuts
+  Int_t   ntracks = esd->GetNumberOfTracks();
+  TArrayI pos(ntracks);
+  TArrayI neg(ntracks);
+  TArrayI itspos(ntracks);
+  TArrayI itsneg(ntracks);
+  
+  // loop on all tracks
+  ULong_t  status;
+  Int_t    i, k, charge, npos = 0, nneg = 0, nITS;
+  Double_t times[10], itsSignal, mom, tofTime, tofRef;
+  Bool_t   isTPC, isITSSA;
+  UChar_t  itsCluMap;
+  for (i = 0; i < ntracks; i++)
+  {
+    AliESDtrack *track = esd->GetTrack(i);
+    if (!track) continue;
+    
+    // get commonly used variables
+    status  = (ULong_t)track->GetStatus();
+    mom     = track->P();
+    isTPC   = ((status & AliESDtrack::kTPCin)  != 0);
+    isITSSA = ((status & AliESDtrack::kTPCin)  == 0 && (status & AliESDtrack::kITSrefit) != 0 && (status & AliESDtrack::kITSpureSA) == 0 && (status & AliESDtrack::kITSpid) != 0);
+    
+    // accept only tracks which are TPC+ITS or ITS standalone
+    if (!isTPC && !isITSSA) continue;
+    
+    // check specific cuts for TPC and ITS-SA tracks
+    if (isTPC)
+    {
+      if (!fESDtrackCutsTPC.IsSelected(track)) continue;
+    }
+    else
+    {
+       if (!fESDtrackCutsITS.IsSelected(track)) continue;
+       itsCluMap = track->GetITSClusterMap();
+       nITS      = 0;
+       for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
+       if (nITS < 3) continue;
+    }
+
+    // if all checks are passed, add the track index in one of the
+    // charged tracks arrays
+    charge = (Int_t)track->Charge();
+    if (charge > 0)
+    {
+      pos[npos] = i;
+      if (isITSSA) itspos[npos] = 1; else itspos[npos] = 0;
+      npos++;
+    }
+    else if (charge < 0)
+    {
+      neg[nneg] = i;
+      if (isITSSA) itsneg[nneg] = 1; else itsneg[nneg] = 0;
+      nneg++;
+    }
+  }
+  
+  // resize arrays accordingly
+  pos.Set(npos);
+  neg.Set(nneg);
+  itspos.Set(npos);
+  itsneg.Set(nneg);
+
+  // loop on unlike-sign pairs to compute invariant mass signal
+  Int_t           ip, in, lp, ln;
+  AliPID          pid;
+  Double_t        kmass = pid.ParticleMass(AliPID::kKaon);
+  Double_t        phimass = 1.019455;
+  TParticle      *partp = 0x0, *partn = 0x0;
+  AliESDtrack    *tp = 0x0, *tn = 0x0;
+  TLorentzVector  vp, vn, vsum, vref;
+  for (ip = 0; ip < npos; ip++)
+  {
+    tp = esd->GetTrack(pos[ip]);
+    lp = TMath::Abs(tp->GetLabel());
+    if (stack) partp = stack->Particle(lp);
+
+    for (in = 0; in < nneg; in++)
+    {
+      if (pos[ip] == neg[in]) 
+      {
+        AliError("POS = NEG");
+        continue;
+      }
+      tn = esd->GetTrack(neg[in]);
+      ln = TMath::Abs(tn->GetLabel());
+      if (stack) partn = stack->Particle(ln);
+
+      fPDG = 0;
+      if (partp && partn)
+      {
+        if (partp->GetFirstMother() == partn->GetFirstMother())
+        {
+          if (partp->GetFirstMother() > 0)
+          {
+            TParticle *mum = stack->Particle(partp->GetFirstMother());
+            fPDG = mum->GetPdgCode();
+          }
+        }
+      }
+      fPDG = TMath::Abs(fPDG);
+
+      vp.SetXYZM(tp->Px(), tp->Py(), tp->Pz(), kmass);
+      vn.SetXYZM(tn->Px(), tn->Py(), tn->Pz(), kmass);
+      vsum = vp + vn;
+      vref.SetXYZM(vsum.X(), vsum.Y(), vsum.Z(), phimass);
+
+      fCh     = 0;
+      fIM     = (Float_t)vsum.M();
+      fPt     = (Float_t)vsum.Perp();
+      fEta    = (Float_t)vsum.Eta();
+      fY      = (Float_t)vref.Rapidity();
+      fITS[0] = itspos[ip];
+      fITS[1] = itsneg[in];
+
+      if (fIM < 0.9 || fIM >  5.0) continue;
+      if (fPt < 0.0 || fPt > 20.0) continue;
+      
+      // PID signal for track #1
+      // here it is enough to check if it is a TPC track
+      // since we excluded the case that it is neither a TPC+ITS nor an ITS-SA
+      if ((tp->GetStatus() & AliESDtrack::kTPCin) != 0)
+      {
+        fP        [0] = tp->P();
+        fPTPC     [0] = tp->GetInnerParam()->P();
+        fTPCnsigma[0] = TMath::Abs(fESDpid->NumberOfSigmasTPC(tp, AliPID::kKaon));
+        fITSnsigma[0] = 1E6;
+        fTOFdiff  [0] = 1E6;
+        // check TOF (only if momentum is large than function asymptote and flags are OK)
+        if (((tp->GetStatus() & AliESDtrack::kTOFout) != 0) && ((tp->GetStatus() & AliESDtrack::kTIME) != 0))
+        {
+          tp->GetIntegratedTimes(times);
+          tofTime  = (Double_t)tp->GetTOFsignal();
+          tofRef   = times[AliPID::kKaon];
+          if (tofRef > 0.0) fTOFdiff[0] = (tofTime - tofRef) / tofRef;
+        }
+      }
+      else
+      {
+        fP        [0] = tp->P();
+        fPTPC     [0] = 1E6;
+        fTPCnsigma[0] = 1E6;
+        fTOFdiff  [0] = 1E6;
+        // check dE/dx
+        itsSignal = tp->GetITSsignal();
+        itsCluMap = tp->GetITSClusterMap();
+        nITS      = 0;
+        for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
+        fITSnsigma[0] = itsrsp.GetNumberOfSigmas(fP[0], itsSignal, AliPID::kKaon, nITS, kTRUE);
+      }
+      
+      // PID signal for track #2
+      // here it is enough to check if it is a TPC track
+      // since we excluded the case that it is neither a TPC+ITS nor an ITS-SA
+      if ((tp->GetStatus() & AliESDtrack::kTPCin) != 0)
+      {
+        fP        [1] = tn->P();
+        fPTPC     [1] = tn->GetInnerParam()->P();
+        fTPCnsigma[1] = TMath::Abs(fESDpid->NumberOfSigmasTPC(tn, AliPID::kKaon));
+        fITSnsigma[1] = 1E6;
+        fTOFdiff  [1] = 1E6;
+        // check TOF (only if momentum is large than function asymptote and flags are OK)
+        if (((tn->GetStatus() & AliESDtrack::kTOFout) != 0) && ((tn->GetStatus() & AliESDtrack::kTIME) != 0))
+        {
+          tn->GetIntegratedTimes(times);
+          tofTime  = (Double_t)tn->GetTOFsignal();
+          tofRef   = times[AliPID::kKaon];
+          if (tofRef > 0.0) fTOFdiff[1] = (tofTime - tofRef) / tofRef;
+        }
+      }
+      else
+      {
+        fP        [1] = tn->P();
+        fPTPC     [1] = 1E6;
+        fTPCnsigma[1] = 1E6;
+        fTOFdiff  [1] = 1E6;
+        // check dE/dx
+        itsSignal = tn->GetITSsignal();
+        itsCluMap = tn->GetITSClusterMap();
+        nITS      = 0;
+        for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
+        fITSnsigma[1] = itsrsp.GetNumberOfSigmas(fP[1], itsSignal, AliPID::kKaon, nITS, kTRUE);
+      }
+      
+      fRsnTreeComp->Fill();
+    }
+  }
+  
+  // loop on like-sign pairs to compute invariant mass background
+  Int_t           i1, i2;
+  AliESDtrack    *t1 = 0x0, *t2 = 0x0;
+  TLorentzVector  v1, v2;
+  
+  // pos-pos
+  for (i1 = 0; i1 < npos; i1++)
+  {
+    t1 = esd->GetTrack(pos[i1]);
+
+    for (i2 = i1+1; i2 < npos; i2++)
+    {
+      t2 = esd->GetTrack(pos[i2]);
+
+      v1.SetXYZM(t1->Px(), t1->Py(), t1->Pz(), kmass);
+      v2.SetXYZM(t2->Px(), t2->Py(), t2->Pz(), kmass);
+      vsum = v1 + v2;
+      vref.SetXYZM(vsum.X(), vsum.Y(), vsum.Z(), phimass);
+
+      fPDG    = 0;
+      fCh     = 1;
+      fIM     = (Float_t)vsum.M();
+      fPt     = (Float_t)vsum.Perp();
+      fEta    = (Float_t)vsum.Eta();
+      fY      = (Float_t)vref.Rapidity();
+      fITS[0] = itspos[i1];
+      fITS[1] = itspos[i2];
+
+      if (fIM < 0.9 || fIM >  5.0) continue;
+      if (fPt < 0.0 || fPt > 20.0) continue;
+      
+      // PID signal for track #1
+      // here it is enough to check if it is a TPC track
+      // since we excluded the case that it is neither a TPC+ITS nor an ITS-SA
+      if ((t1->GetStatus() & AliESDtrack::kTPCin) != 0)
+      {
+        fP        [0] = t1->P();
+        fPTPC     [0] = t1->GetInnerParam()->P();
+        fTPCnsigma[0] = TMath::Abs(fESDpid->NumberOfSigmasTPC(t1, AliPID::kKaon));
+        fITSnsigma[0] = 1E6;
+        fTOFdiff  [0] = 1E6;
+        // check TOF (only if momentum is large than function asymptote and flags are OK)
+        if (((t1->GetStatus() & AliESDtrack::kTOFout) != 0) && ((t1->GetStatus() & AliESDtrack::kTIME) != 0))
+        {
+          t1->GetIntegratedTimes(times);
+          tofTime  = (Double_t)t1->GetTOFsignal();
+          tofRef   = times[AliPID::kKaon];
+          if (tofRef > 0.0) fTOFdiff[0] = (tofTime - tofRef) / tofRef;
+        }
+      }
+      else
+      {
+        fP        [0] = t1->P();
+        fPTPC     [0] = 1E6;
+        fTPCnsigma[0] = 1E6;
+        fTOFdiff  [0] = 1E6;
+        // check dE/dx
+        itsSignal = t1->GetITSsignal();
+        itsCluMap = t1->GetITSClusterMap();
+        nITS      = 0;
+        for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
+        fITSnsigma[0] = itsrsp.GetNumberOfSigmas(fP[0], itsSignal, AliPID::kKaon, nITS, kTRUE);
+      }
+      
+      // PID signal for track #2
+      // here it is enough to check if it is a TPC track
+      // since we excluded the case that it is neither a TPC+ITS nor an ITS-SA
+      if ((t1->GetStatus() & AliESDtrack::kTPCin) != 0)
+      {
+        fP        [1] = t2->P();
+        fPTPC     [1] = t2->GetInnerParam()->P();
+        fTPCnsigma[1] = TMath::Abs(fESDpid->NumberOfSigmasTPC(t2, AliPID::kKaon));
+        fITSnsigma[1] = 1E6;
+        fTOFdiff  [1] = 1E6;
+        // check TOF (only if momentum is large than function asymptote and flags are OK)
+        if (((t2->GetStatus() & AliESDtrack::kTOFout) != 0) && ((t2->GetStatus() & AliESDtrack::kTIME) != 0))
+        {
+          t2->GetIntegratedTimes(times);
+          tofTime  = (Double_t)t2->GetTOFsignal();
+          tofRef   = times[AliPID::kKaon];
+          if (tofRef > 0.0) fTOFdiff[1] = (tofTime - tofRef) / tofRef;
+        }
+      }
+      else
+      {
+        fP        [1] = t2->P();
+        fPTPC     [1] = 1E6;
+        fTPCnsigma[1] = 1E6;
+        fTOFdiff  [1] = 1E6;
+        // check dE/dx
+        itsSignal = t2->GetITSsignal();
+        itsCluMap = t2->GetITSClusterMap();
+        nITS      = 0;
+        for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
+        fITSnsigma[1] = itsrsp.GetNumberOfSigmas(fP[1], itsSignal, AliPID::kKaon, nITS, kTRUE);
+      }
+      
+      //fRsnTreeComp->Fill();
+    }
+  }
+  // neg-neg
+  for (i1 = 0; i1 < nneg; i1++)
+  {
+    t1 = esd->GetTrack(neg[i1]);
+
+    for (i2 = i1+1; i2 < nneg; i2++)
+    {
+      t2 = esd->GetTrack(neg[i2]);
+
+      v1.SetXYZM(t1->Px(), t1->Py(), t1->Pz(), kmass);
+      v2.SetXYZM(t2->Px(), t2->Py(), t2->Pz(), kmass);
+      vsum = v1 + v2;
+      vref.SetXYZM(vsum.X(), vsum.Y(), vsum.Z(), phimass);
+
+      fPDG    = 0;
+      fCh     = -1;
+      fIM     = (Float_t)vsum.M();
+      fPt     = (Float_t)vsum.Perp();
+      fEta    = (Float_t)vsum.Eta();
+      fY      = (Float_t)vref.Rapidity();
+      fITS[0] = itsneg[i1];
+      fITS[1] = itsneg[i2];
+
+      if (fIM < 0.9 || fIM >  5.0) continue;
+      if (fPt < 0.0 || fPt > 20.0) continue;
+      
+      // PID signal for track #1
+      // here it is enough to check if it is a TPC track
+      // since we excluded the case that it is neither a TPC+ITS nor an ITS-SA
+      if ((t1->GetStatus() & AliESDtrack::kTPCin) != 0)
+      {
+        fP        [0] = t1->P();
+        fPTPC     [0] = t1->GetInnerParam()->P();
+        fTPCnsigma[0] = TMath::Abs(fESDpid->NumberOfSigmasTPC(t1, AliPID::kKaon));
+        fITSnsigma[0] = 1E6;
+        fTOFdiff  [0] = 1E6;
+        // check TOF (only if momentum is large than function asymptote and flags are OK)
+        if (((t1->GetStatus() & AliESDtrack::kTOFout) != 0) && ((t1->GetStatus() & AliESDtrack::kTIME) != 0))
+        {
+          t1->GetIntegratedTimes(times);
+          tofTime  = (Double_t)t1->GetTOFsignal();
+          tofRef   = times[AliPID::kKaon];
+          if (tofRef > 0.0) fTOFdiff[0] = (tofTime - tofRef) / tofRef;
+        }
+      }
+      else
+      {
+        fP        [0] = t1->P();
+        fPTPC     [0] = 1E6;
+        fTPCnsigma[0] = 1E6;
+        fTOFdiff  [0] = 1E6;
+        // check dE/dx
+        itsSignal = t1->GetITSsignal();
+        itsCluMap = t1->GetITSClusterMap();
+        nITS      = 0;
+        for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
+        fITSnsigma[0] = itsrsp.GetNumberOfSigmas(fP[0], itsSignal, AliPID::kKaon, nITS, kTRUE);
+      }
+      
+      // PID signal for track #2
+      // here it is enough to check if it is a TPC track
+      // since we excluded the case that it is neither a TPC+ITS nor an ITS-SA
+      if ((t1->GetStatus() & AliESDtrack::kTPCin) != 0)
+      {
+        fP        [1] = t2->P();
+        fPTPC     [1] = t2->GetInnerParam()->P();
+        fTPCnsigma[1] = TMath::Abs(fESDpid->NumberOfSigmasTPC(t2, AliPID::kKaon));
+        fITSnsigma[1] = 1E6;
+        fTOFdiff  [1] = 1E6;
+        // check TOF (only if momentum is large than function asymptote and flags are OK)
+        if (((t2->GetStatus() & AliESDtrack::kTOFout) != 0) && ((t2->GetStatus() & AliESDtrack::kTIME) != 0))
+        {
+          t2->GetIntegratedTimes(times);
+          tofTime  = (Double_t)t2->GetTOFsignal();
+          tofRef   = times[AliPID::kKaon];
+          if (tofRef > 0.0) fTOFdiff[1] = (tofTime - tofRef) / tofRef;
+        }
+      }
+      else
+      {
+        fP        [1] = t2->P();
+        fPTPC     [1] = 1E6;
+        fTPCnsigma[1] = 1E6;
+        fTOFdiff  [1] = 1E6;
+        // check dE/dx
+        itsSignal = t2->GetITSsignal();
+        itsCluMap = t2->GetITSClusterMap();
+        nITS      = 0;
+        for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
+        fITSnsigma[1] = itsrsp.GetNumberOfSigmas(fP[1], itsSignal, AliPID::kKaon, nITS, kTRUE);
+      }
+      
+      //fRsnTreeComp->Fill();
+    }
+  }
+
+  PostData(1, fRsnTreeComp);
+}
+
+//__________________________________________________________________________________________________
+void AliRsnAnalysisPhi7TeVNoPID::ProcessMC(AliStack *stack)
+{
+//
+// Function to process stack only
+//
+
+  if (!stack) return;
+  Int_t nPart = stack->GetNtrack();
+
+  // loop to compute invariant mass
+  Int_t           ip, in;
+  AliPID          pid;
+  Double_t        kmass = pid.ParticleMass(AliPID::kKaon);
+  Double_t        phimass = 1.019455;
+  TParticle      *partp = 0x0, *partn = 0x0;
+  TLorentzVector  vp, vn, vsum, vref;
+
+  for (ip = 0; ip < nPart; ip++)
+  {
+    partp = stack->Particle(ip);
+    if (partp->GetPdgCode() != 321) continue;
+
+    for (in = 0; in < nPart; in++)
+    {
+      partn = stack->Particle(in);
+      if (partn->GetPdgCode() != -321) continue;
+
+      fPDG = 0;
+      if (partp->GetFirstMother() == partn->GetFirstMother())
+      {
+        if (partp->GetFirstMother() > 0)
+        {
+          TParticle *mum = stack->Particle(partp->GetFirstMother());
+          fPDG = mum->GetPdgCode();
+        }
+      }
+      fPDG = TMath::Abs(fPDG);
+      if (fPDG != 333) continue;
+
+      vp.SetXYZM(partp->Px(), partp->Py(), partp->Pz(), kmass);
+      vn.SetXYZM(partn->Px(), partn->Py(), partn->Pz(), kmass);
+      vsum = vp + vn;
+      vref.SetXYZM(vsum.X(), vsum.Y(), vsum.Z(), phimass);
+
+      fIM  = (Float_t)vsum.M();
+      fPt  = (Float_t)vsum.Perp();
+      fEta = (Float_t)vsum.Eta();
+      fY   = (Float_t)vref.Rapidity();
+
+      fRsnTreeTrue->Fill();
+    }
+  }
+
+  PostData(2, fRsnTreeTrue);
+}
diff --git a/PWG2/RESONANCES/AliRsnAnalysisPhi7TeVNoPID.h b/PWG2/RESONANCES/AliRsnAnalysisPhi7TeVNoPID.h
new file mode 100644 (file)
index 0000000..bf70bf1
--- /dev/null
@@ -0,0 +1,121 @@
+//
+// Header file for implementation of data analysis aft 900 GeV
+//
+// Author: A. Pulvirenti
+//
+
+#ifndef ALIRSNANALYSISPHI7TEVNOPID_H
+#define ALIRSNANALYSISPHI7TEVNOPID_H
+
+#include "AliAnalysisTaskSE.h"
+#include "AliRsnTOFT0maker.h"
+#include "AliESDtrackCuts.h"
+
+class TH1I;
+class TH1F;
+class TTree;
+
+class AliStack;
+class AliESDEvent;
+class AliESDVertex;
+class AliESDpid;
+class AliTOFT0maker;
+class AliTOFcalib;
+
+class AliRsnAnalysisPhi7TeVNoPID : public AliAnalysisTaskSE
+{
+  public:
+  
+    enum
+    {
+      kGoodTracksPrimaryVertex = 0,
+      kGoodSPDPrimaryVertex    = 1,
+      kFarTracksPrimaryVertex  = 2,
+      kFarSPDPrimaryVertex     = 3,
+      kNoGoodPrimaryVertex     = 4,
+      kEvaluations             = 5
+    };
+
+    AliRsnAnalysisPhi7TeVNoPID(const char *name = "Phi7TeVNoPID");
+    AliRsnAnalysisPhi7TeVNoPID(const AliRsnAnalysisPhi7TeVNoPID& copy);
+    AliRsnAnalysisPhi7TeVNoPID& operator=(const AliRsnAnalysisPhi7TeVNoPID& copy);
+    virtual ~AliRsnAnalysisPhi7TeVNoPID();
+
+    void             SetUseMC(Bool_t yn = kTRUE) {fUseMC = yn;}
+    
+    void             SetMaxVz(Double_t v)   {fMaxVz = v;}
+    
+    void             SetITSband(Double_t v) {fMaxITSband = v;}
+    
+    void             SetTPCpLimit(Double_t v) {fTPCpLimit = v;}
+    void             SetTPCrange(Double_t min, Double_t max) {fMinTPCband = min; fMaxTPCband = max;}
+    void             SetTPCpar(Double_t p0, Double_t p1, Double_t p2, Double_t p3, Double_t p4)
+                       {fTPCpar[0]=p0;fTPCpar[1]=p1;fTPCpar[2]=p2;fTPCpar[3]=p3;fTPCpar[4]=p4;}
+
+    void             SetTOFcalibrateESD(Bool_t yn = kTRUE)  {fTOFcalibrateESD = yn;}
+    void             SetTOFcorrectTExp (Bool_t yn = kTRUE)  {fTOFcorrectTExp = yn;}
+    void             SetTOFuseT0       (Bool_t yn = kTRUE)  {fTOFuseT0 = yn;}
+    void             SetTOFtuneMC      (Bool_t yn = kTRUE)  {fTOFtuneMC = yn;}
+    void             SetTOFresolution  (Double_t v = 100.0) {fTOFresolution = v;}
+
+    virtual void     UserCreateOutputObjects();
+    virtual void     UserExec(Option_t *option = "");
+    virtual void     Terminate(Option_t *option = "");
+    
+    Int_t            EventEval(AliESDEvent *esd);
+    AliESDtrackCuts* GetCutsTPC() {return &fESDtrackCutsTPC;}
+    AliESDtrackCuts* GetCutsITS() {return &fESDtrackCutsITS;}
+
+  private:
+
+    void     ProcessESD(AliESDEvent *esd, AliStack *stack);
+    void     ProcessMC(AliStack *stack);
+
+    Bool_t   fUseMC;        // use MC or data?
+    
+    Short_t  fPDG;          // PDG code
+    Short_t  fCh;           // control flag for like/unlike sign
+    Short_t  fITS[2];       // check flag to know if one or both candidates are ITS standalone
+    Float_t  fIM;           // inv mass
+    Float_t  fPt;           // transv momentum
+    Float_t  fY;            // rapidity
+    Float_t  fEta;          // pseudo-rapidity
+    Float_t  fTPCnsigma[2]; // number of sigma in TPC
+    Float_t  fITSnsigma[2]; // number of sigma in ITS
+    Float_t  fTOFdiff[2];   // relative PID signal in TOF
+    Float_t  fP[2];         // total momentum at vertex
+    Float_t  fPTPC[2];      // total momentum at inner TPC wall
+    
+    Double_t fMaxVz;      // range in Z of primary vertex w.r. to origin
+    
+    Double_t fMaxITSband; // range for ITS de/dx band
+
+    Double_t fTPCpLimit;  // limit to choose what band to apply
+    Double_t fTPCpar[5];  // parameters for TPC bethe-Bloch
+    Double_t fMinTPCband; // range for TPC de/dx band - min
+    Double_t fMaxTPCband; // range for TPC de/dx band - max
+
+    TTree     *fRsnTreeComp;    // output tree of computed pairs
+    TTree     *fRsnTreeTrue;    // output tree of true pairs
+    TList     *fOutList;        // list for monitoring histograms
+    TH1I      *fHEvents;        // histogram of event types
+    TH1F      *fVertexX[2];     // histogram of X coordinate of primary vertex ([0] = tracks, [1] = SPD)
+    TH1F      *fVertexY[2];     // histogram of Y coordinate of primary vertex ([0] = tracks, [1] = SPD)
+    TH1F      *fVertexZ[2];     // histogram of Z coordinate of primary vertex ([0] = tracks, [1] = SPD)
+    
+    AliESDtrackCuts  fESDtrackCutsTPC;  //  ESD standard defined track cuts for TPC tracks
+    AliESDtrackCuts  fESDtrackCutsITS;  //  ESD standard defined track cuts for ITS-SA tracks
+    AliESDpid       *fESDpid;           //! PID manager
+    AliTOFT0maker   *fTOFmaker;         //! TOF time0 computator
+    AliTOFcalib     *fTOFcalib;         //! TOF calibration
+    Bool_t           fTOFcalibrateESD;  //  TOF settings
+    Bool_t           fTOFcorrectTExp;   //  TOF settings
+    Bool_t           fTOFuseT0;         //  TOF settings
+    Bool_t           fTOFtuneMC;        //  TOF settings
+    Double_t         fTOFresolution;    //  TOF settings
+
+    // ROOT dictionary
+    ClassDef(AliRsnAnalysisPhi7TeVNoPID,1)
+};
+
+#endif
index 54aebc22e68aa1edbb1be919742f2bf865c0728f..cce2d73c6ca85ab112706d2ec2bde5bc61f6d25e 100644 (file)
@@ -9,6 +9,7 @@
 //
 
 #include <Riostream.h>
+#include <TList.h>
 #include "AliESDEvent.h"
 #include "AliMCEvent.h"
 #include "AliAODEvent.h"
 ClassImp(AliRsnAnalysisSE)
 
 //_____________________________________________________________________________
-AliRsnAnalysisSE::AliRsnAnalysisSE(const char *name,Int_t numOfOutputs,Bool_t useKine) :
-    AliRsnVAnalysisTaskSE(name,numOfOutputs,useKine),
-    fRsnAnalysisManager(),
-    fEventCuts(0x0),
-    fZeroEventPercentWarning(50),
-    fUseZeroEventWarning(kTRUE)
+AliRsnAnalysisSE::AliRsnAnalysisSE(const char *name, Bool_t useKine) :
+  AliRsnVAnalysisTaskSE(name, useKine),
+  fRsnAnalysisManager(),
+  fEventCuts(0x0),
+  fOutList(0x0),
+  fZeroEventPercentWarning(50),
+  fUseZeroEventWarning(kTRUE)
 {
 //
 // Default constructor.
 //
 
-  AliDebug(AliLog::kDebug+2,"<-");
-  for (Int_t i=0;i<fNumberOfOutputs;i++) {
-    DefineOutput(i+2, TList::Class());
-  }
+  DefineOutput(2, TList::Class());
   AliDebug(AliLog::kDebug+2,"->");
 }
 
@@ -43,6 +42,7 @@ AliRsnAnalysisSE::AliRsnAnalysisSE(const AliRsnAnalysisSE& copy) :
   AliRsnVAnalysisTaskSE(copy),
   fRsnAnalysisManager(copy.fRsnAnalysisManager),
   fEventCuts(copy.fEventCuts),
+  fOutList(0x0),
   fZeroEventPercentWarning(copy.fZeroEventPercentWarning),
   fUseZeroEventWarning(copy.fUseZeroEventWarning)
 {
@@ -66,18 +66,13 @@ void AliRsnAnalysisSE::RsnUserCreateOutputObjects()
 
   AliDebug(AliLog::kDebug+2,"<-");
 
-  Int_t i;
-  for (i = 1; i < kMaxNumberOfOutputs + 1; i++)
-  {
-    // this line makes trouble with PROOF ---> if (i <= fNumberOfOutputs + 1) OpenFile(i);
-    fOutList[i] = new TList();
-    fOutList[i]->SetOwner();
-  }
+  fOutList = new TList;
+  fRsnAnalysisManager.InitAllPairs(fOutList);
+  
+  AliError("\n\n***LIST***\n\n");
+  fOutList->Print();
 
-  for (i = 0; i < fNumberOfOutputs; i++)
-  {
-    fRsnAnalysisManager[i].InitAllPairMgrs(fOutList[i+1]);
-  }
+  PostData(2, fOutList);
 
   AliDebug(AliLog::kDebug+2,"->");
 }
@@ -117,7 +112,7 @@ void AliRsnAnalysisSE::RsnUserExec(Option_t*)
     fTaskInfo.SetEventUsed(kFALSE);
     if (fUseZeroEventWarning)
     {
-      TH1I *hist = (TH1I*)fOutList[0]->FindObject(fTaskInfo.GetEventHistogramName());
+      TH1I *hist = (TH1I*)fInfoList->FindObject(fTaskInfo.GetEventHistogramName());
       if (!hist) return;
       Double_t zeroEventPercent = 0.0;
       if (hist->Integral() > 1) zeroEventPercent = (Double_t)hist->GetBinContent(1) / hist->Integral() * 100;
@@ -132,7 +127,7 @@ void AliRsnAnalysisSE::RsnUserExec(Option_t*)
   // if the event does not pass them, it is skipped and ProcessInfo
   // is updated accordingly
   if (fEventCuts) {
-    if (!fEventCuts->IsSelected(AliRsnCut::kEvent, &fRsnEvent)) {
+    if (!fEventCuts->IsSelected(&fRsnEvent)) {
       fTaskInfo.SetEventUsed(kFALSE);
       return;
     }
@@ -144,11 +139,9 @@ void AliRsnAnalysisSE::RsnUserExec(Option_t*)
 
   // the virtual class has already sorted tracks in the PID index
   // so we need here just to call the execution of analysis
-  for (Int_t i = 0; i < fNumberOfOutputs; i++)
-  {
-    fRsnAnalysisManager[i].ProcessAllPairMgrs(&fRsnPIDIndex, &fRsnEvent);
-    PostData(i+2, fOutList[i+1]);
-  }
+  fRsnAnalysisManager.ProcessAllPairs(&fRsnEvent, &fRsnEvent);
+  PostData(2, fOutList);
+
   AliDebug(AliLog::kDebug+2,"->");
 }
 
@@ -165,17 +158,3 @@ void AliRsnAnalysisSE::RsnTerminate(Option_t*)
   AliDebug(AliLog::kDebug+2,"->");
 }
 
-//_____________________________________________________________________________
-AliRsnAnalysisManager* AliRsnAnalysisSE::GetAnalysisManager(Int_t index, TString name)
-{
-//
-// Recovery the analysis manager
-//
-
-  if (!name.IsNull())
-  {
-    SetAnalysisManagerName(name.Data(), index);
-  }
-
-  return &fRsnAnalysisManager[index];
-}
index 95d8e8af959b1eeab823575a6a3ee79d95563cd2..a914092fa838a9017ace85bcca9fb11259fb7d65 100644 (file)
@@ -13,7 +13,6 @@
 #include "AliPID.h"
 #include "AliRsnVAnalysisTaskSE.h"
 #include "AliRsnAnalysisManager.h"
-#include "AliRsnPIDIndex.h"
 #include "AliRsnEvent.h"
 
 class AliRsnPIDDefESD;
@@ -23,7 +22,7 @@ class AliRsnAnalysisSE : public AliRsnVAnalysisTaskSE
 {
 
   public:
-    AliRsnAnalysisSE(const char *name = "AliRsnAnalysisSE",Int_t numOfOutputs=1,Bool_t useKine=kFALSE);
+    AliRsnAnalysisSE(const char *name = "AliRsnAnalysisSE", Bool_t useKine = kFALSE);
     AliRsnAnalysisSE(const AliRsnAnalysisSE& copy);
     virtual ~AliRsnAnalysisSE() {;};
 
@@ -32,23 +31,23 @@ class AliRsnAnalysisSE : public AliRsnVAnalysisTaskSE
     virtual void    RsnUserExec(Option_t*);
     virtual void    RsnTerminate(Option_t*);
 
-    AliRsnAnalysisManager *GetAnalysisManager(Int_t index = 0, TString name = "");
-    void                   SetAnalysisManagerName(const char *name, Int_t index = 0)
-                            {fRsnAnalysisManager[index].SetName(name);}
+    AliRsnAnalysisManager *GetAnalysisManager() {return &fRsnAnalysisManager;}
+    void                   SetAnalysisManagerName(const char *name) {fRsnAnalysisManager.SetName(name);}
 
     AliRsnCutSet* GetEventCuts() const {return fEventCuts;}
     void          SetEventCuts(AliRsnCutSet *const cuts) {fEventCuts = cuts;}
 
-    Double_t GetZeroEventPercentWarning() const { return fZeroEventPercentWarning;}
-    void     SetZeroEventPercentWarning(Double_t val = 50) { fZeroEventPercentWarning = val;}
-    void     UseZeroEventWarning(Bool_t b = true) { fUseZeroEventWarning = b;}
+    Double_t GetZeroEventPercentWarning() const {return fZeroEventPercentWarning;}
+    void     SetZeroEventPercentWarning(Double_t val = 50) {fZeroEventPercentWarning = val;}
+    void     UseZeroEventWarning(Bool_t b = true) {fUseZeroEventWarning = b;}
 
   private:
 
     AliRsnAnalysisSE& operator=(const AliRsnAnalysisSE& /*copy*/) {return *this;}
 
-    AliRsnAnalysisManager fRsnAnalysisManager[kMaxNumberOfOutputs];  // analysis main engine
-    AliRsnCutSet         *fEventCuts;               // event cuts
+    AliRsnAnalysisManager fRsnAnalysisManager;  // analysis main engine
+    AliRsnCutSet         *fEventCuts;           // event cuts
+    TList                *fOutList;             // list of output events
 
     Double_t              fZeroEventPercentWarning; //! Percent Number for Zero Event Warning
     Bool_t                fUseZeroEventWarning;     //! flag if Zero Event Warning is used (default is true)
diff --git a/PWG2/RESONANCES/AliRsnAnalysisTrackEffSE.cxx b/PWG2/RESONANCES/AliRsnAnalysisTrackEffSE.cxx
deleted file mode 100644 (file)
index 5ca17b8..0000000
+++ /dev/null
@@ -1,288 +0,0 @@
-//
-// Class AliRsnAnalysisTrackEffSE
-//
-// TODO
-// TODO
-//
-// authors: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
-//          Martin Vala (martin.vala@cern.ch)
-//
-#include <Riostream.h>
-#include "AliStack.h"
-#include "AliESDEvent.h"
-#include "AliMCEvent.h"
-
-#include "AliCFContainer.h"
-#include "AliRsnCutSet.h"
-#include "AliRsnFunctionAxis.h"
-#include "AliRsnAnalysisTrackEffSE.h"
-#include "AliRsnCutSet.h"
-
-ClassImp(AliRsnAnalysisTrackEffSE)
-
-//_____________________________________________________________________________
-AliRsnAnalysisTrackEffSE::AliRsnAnalysisTrackEffSE(const char *name) :
-  AliRsnVAnalysisTaskSE(name),
-  fEventCuts(0x0),
-  fStepListMC(0),
-  fStepListESD(0),
-  fAxisList(0),
-  fVar(0),
-  fDaughter()
-{
-//
-// Default constructor.
-//
-
-  AliDebug(AliLog::kDebug+2,"<-");
-
-  DefineOutput(2, TList::Class());
-
-  Int_t i;
-  for (i = 0; i <= AliPID::kSPECIES; i++) fContainer[i] = 0x0;
-
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-//_____________________________________________________________________________
-AliRsnAnalysisTrackEffSE::AliRsnAnalysisTrackEffSE(const AliRsnAnalysisTrackEffSE& copy) :
-  AliRsnVAnalysisTaskSE(copy),
-  fEventCuts(copy.fEventCuts),
-  fStepListMC(copy.fStepListMC),
-  fStepListESD(copy.fStepListESD),
-  fAxisList(copy.fAxisList),
-  fVar(0),
-  fDaughter()
-{
-//
-// Copy constrtuctor
-//
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisTrackEffSE::RsnUserCreateOutputObjects()
-{
-//
-// Creation of output objects.
-// These are created through the utility methods in the analysis manager,
-// which produces a list of histograms for each specified set of pairs.
-// Each of these lists is added to the main list of this task.
-//
-
-  AliDebug(AliLog::kDebug+2,"<-");
-
-  // get number of steps and axes
-  Int_t iaxis;
-  Int_t nAxes  = fAxisList.GetEntries();
-  Int_t nSteps = (Int_t)fStepListMC.GetEntries() + (Int_t)fStepListESD.GetEntries();
-
-  if (!nSteps) {
-    AliError("No steps defined");
-    return;
-  }
-  if (!nAxes) {
-    AliError("No axes defined");
-    return;
-  }
-
-  // initialize variable list
-  fVar.Set(nAxes);
-
-  // retrieve number of bins for each axis
-  Int_t   *nBins     = new Int_t[nAxes];
-  TArrayD *binLimits = new TArrayD[nAxes];
-  for (iaxis = 0; iaxis < nAxes; iaxis++) {
-    AliRsnFunctionAxis *fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(iaxis);
-    binLimits[iaxis] = fcnAxis->GetArray();
-    nBins[iaxis] = binLimits[iaxis].GetSize() - 1;
-  }
-
-  // initialize output list
-  OpenFile(2);
-  fOutList[1] = new TList();
-  fOutList[1]->SetOwner();
-
-  // create the containers
-  Int_t i;
-  for (i = 0; i <= AliPID::kSPECIES; i++)
-  {
-    if (i < AliPID::kSPECIES) fContainer[i] = new AliCFContainer(Form("%s", AliPID::ParticleName((AliPID::EParticleType)i)), "", nSteps, nAxes, nBins);
-    else fContainer[i] = new AliCFContainer("all", "", nSteps, nAxes, nBins);
-    // set the bin limits for each axis
-    for (iaxis = 0; iaxis < nAxes; iaxis++) fContainer[i]->SetBinLimits(iaxis, binLimits[iaxis].GetArray());
-    // add the container to output list
-    fOutList[1]->Add(fContainer[i]);
-  }
-
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisTrackEffSE::RsnUserExec(Option_t*)
-{
-//
-// Execution of the analysis task.
-// Recovers the input event and processes it with all included pair objects.
-// In this case, we NEED to have ESD and MC, otherwise we cannod do anything.
-//
-
-  AliDebug(AliLog::kDebug+2,"<-");
-  if (!fESDEvent || !fMCEvent) {
-    AliError("This task can process only ESD + MC events");
-    return;
-  }
-  fRsnEvent.SetRef(fESDEvent, fMCEvent);
-
-  // if general event cuts are added to the task (recommended)
-  // they are checked here on the RSN event interface and,
-  // if the event does not pass them, it is skipped and ProcessInfo
-  // is updated accordingly
-  if (fEventCuts) {
-    if (!fEventCuts->IsSelected(AliRsnCut::kEvent, &fRsnEvent)) {
-      fTaskInfo.SetEventUsed(kFALSE);
-      return;
-    }
-  }
-
-  // if cuts are passed or not cuts were defined,
-  // update the task info before processing the event
-  fTaskInfo.SetEventUsed(kTRUE);
-
-  // process first MC steps and then ESD steps
-  ProcessEventMC();
-  ProcessEventESD();
-
-  // Post the data
-  PostData(2, fOutList[1]);
-
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisTrackEffSE::ProcessEventMC()
-{
-//
-// Process current event with the definitions of the specified step in MC list
-// and store results in the container slot defined in second argument
-//
-
-  AliStack      *stack = fMCEvent->Stack();
-  AliMCParticle *part;
-
-  // other utility variables
-  Int_t ipart;
-
-  // in this case, we first take the resonance from MC
-  // and then we find its daughters and compute cuts on them
-  for (ipart = 0; ipart < fMCEvent->GetNumberOfTracks(); ipart++)
-  {
-    part = (AliMCParticle*) fMCEvent->GetTrack(ipart);
-
-    fDaughter.SetRef(part);
-    fDaughter.SetParticle(part->Particle());
-    fDaughter.FindMotherPDG(stack);
-    
-    FillContainer(&fStepListMC, 0);
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisTrackEffSE::ProcessEventESD()
-{
-//
-// Process current event with the definitions of the specified step in ESD list
-// and store results in the container slot defined in second argument
-//
-
-  Int_t ic, i, first = (Int_t)fStepListMC.GetEntries();
-
-  // get arrays of all charged tracks
-  TArrayI *a[2];
-  a[0] = fRsnPIDIndex.GetTracksArray(AliRsnDaughter::kNoPID, '+', AliPID::kUnknown);
-  a[1] = fRsnPIDIndex.GetTracksArray(AliRsnDaughter::kNoPID, '-', AliPID::kUnknown);
-
-  // external loop on tracks
-  for (ic = 0; ic < 2; ic++)
-  {
-    for (i = 0; i < a[ic]->GetSize(); i++)
-    {
-      // connect interface
-      fRsnEvent.SetDaughter(fDaughter, a[ic]->At(i));
-      if (!fDaughter.IsOK()) continue;
-      fDaughter.SetRequiredPID(fDaughter.PerfectPID());
-
-      FillContainer(&fStepListESD, first);
-    }
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisTrackEffSE::FillContainer
-(const TObjArray *stepList, Int_t firstOutStep)
-{
-//
-// Fill the containers
-//
-
-  Int_t ipid;
-  Int_t iaxis, nAxes  = fAxisList.GetEntries();
-  Int_t istep, nSteps = stepList->GetEntries();
-
-  // compute values for all axes
-  for (iaxis = 0; iaxis < nAxes; iaxis++) {
-    AliRsnFunctionAxis *fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(iaxis);
-    switch (fcnAxis->GetAxisObject())
-    {
-      case AliRsnFunctionAxis::kParticle:
-        fVar[iaxis] = (Double_t)fcnAxis->Eval(&fDaughter);
-        break;
-      case AliRsnFunctionAxis::kEvent:
-        fVar[iaxis] = (Double_t)fcnAxis->Eval(&fRsnEvent);
-        break;
-      default:
-        fVar[iaxis] = 0.0;
-    }
-  }
-
-  // fill all steps
-  for (istep = 0; istep < nSteps; istep++) {
-    AliRsnCutSet *cutSet = (AliRsnCutSet*)stepList->At(istep);
-    if (!cutSet->IsSelected(AliRsnCut::kParticle, &fDaughter)) break;
-    if (stepList == &fStepListESD && !PassedAllCutsMC()) break;
-
-    ipid = (Int_t)fDaughter.PerfectPID();
-    if (ipid == (Int_t)AliPID::kUnknown) ipid = (Int_t)AliPID::kSPECIES;
-    fContainer[ipid]->Fill(fVar.GetArray(), istep + firstOutStep);
-    fContainer[AliPID::kSPECIES]->Fill(fVar.GetArray(), istep + firstOutStep);
-  }
-}
-
-//_____________________________________________________________________________
-Bool_t AliRsnAnalysisTrackEffSE::PassedAllCutsMC()
-{
-//
-// Check if this daughter passes all cuts MC
-//
-
-  Int_t istep, nSteps = fStepListMC.GetEntries();
-
-  for (istep = 0; istep < nSteps; istep++) {
-    AliRsnCutSet *cutSet = (AliRsnCutSet*)fStepListMC.At(istep);
-    if (!cutSet->IsSelected(AliRsnCut::kParticle, &fDaughter)) return kFALSE;
-  }
-
-  return kTRUE;
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisTrackEffSE::RsnTerminate(Option_t*)
-{
-//
-// Termination.
-// Could be added some monitor histograms here.
-//
-
-  AliDebug(AliLog::kDebug+2,"<-");
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
diff --git a/PWG2/RESONANCES/AliRsnAnalysisTrackEffSE.h b/PWG2/RESONANCES/AliRsnAnalysisTrackEffSE.h
deleted file mode 100644 (file)
index a0ccfb8..0000000
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// Class AliRsnAnalysisTrackEffSE
-//
-// Virtual Class derivated from AliRsnVAnalysisTaskSE which will be base class
-// for all RSN SE tasks
-//
-// authors: Martin Vala (martin.vala@cern.ch)
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
-//
-#ifndef ALIRSNANALYSISTRACKEFFSE_H
-#define ALIRSNANALYSISTRACKEFFSE_H
-
-#include <TArrayD.h>
-
-#include "AliRsnVAnalysisTaskSE.h"
-
-class AliPID;
-
-class AliCFContainer;
-
-class AliRsnPairDef;
-class AliRsnPIDIndex;
-class AliRsnPIDDefESD;
-class AliRsnCutSet;
-class AliRsnFunctionAxis;
-
-class AliRsnAnalysisManager;
-class AliRsnAnalysisTrackEffSE : public AliRsnVAnalysisTaskSE
-{
-
-  public:
-    AliRsnAnalysisTrackEffSE(const char *name = "AliRsnAnalysisTaskEffSE");
-    AliRsnAnalysisTrackEffSE(const AliRsnAnalysisTrackEffSE& copy);
-    virtual ~AliRsnAnalysisTrackEffSE() {;};
-
-    // Implement this
-    virtual void    RsnUserCreateOutputObjects();
-    virtual void    RsnUserExec(Option_t*);
-    virtual void    RsnTerminate(Option_t*);
-
-    // settings
-    void            SetEventCuts(AliRsnCutSet *const cuts) {fEventCuts = cuts;}
-    void            AddStepMC(AliRsnCutSet *cuts) {fStepListMC.AddLast(cuts);}
-    void            AddStepESD(AliRsnCutSet *cuts) {fStepListESD.AddLast(cuts);}
-    void            AddAxis(AliRsnFunctionAxis *axis) {fAxisList.AddLast(axis);}
-
-  private:
-
-    AliRsnAnalysisTrackEffSE& operator=(const AliRsnAnalysisTrackEffSE& /*copy*/) {return *this;}
-    void                 ProcessEventMC();
-    void                 ProcessEventESD();
-    Bool_t               PassedAllCutsMC();
-    void                 FillContainer(const TObjArray *stepList, Int_t firstOutStep);
-
-    AliRsnCutSet         *fEventCuts;                     // event cuts
-    TObjArray             fStepListMC;                    // list of cut steps with MC
-    TObjArray             fStepListESD;                   // list of cut steps with ESD
-    TObjArray             fAxisList;                      // list of axes of efficiency plots
-    AliCFContainer       *fContainer[AliPID::kSPECIES+1]; // one container per particle type + 1 global
-    TArrayD               fVar;                           // list of variables of the container
-    AliRsnDaughter        fDaughter;                      // interface to track
-
-    ClassDef(AliRsnAnalysisTrackEffSE, 1)
-};
-
-#endif
index 19a2744a42fdc4ac2dd1f0ed7e5ed7cdc43cd40d..631b7bf32cb444ac847c72739d72ff95d2801a9b 100644 (file)
 //
 #include "AliLog.h"
 
+#include "AliRsnDaughter.h"
+#include "AliRsnMother.h"
+#include "AliRsnEvent.h"
+
 #include "AliRsnCut.h"
 
 ClassImp(AliRsnCut)
 
 //_________________________________________________________________________________________________
-AliRsnCut::AliRsnCut() :
-    TNamed(),
-    fVarType(kInt),
-    fMinI(0),
-    fMaxI(0),
-    fMinU(0),
-    fMaxU(0),
-    fMinD(0.0),
-    fMaxD(0.0),
-    fCutValueI(0),
-    fCutValueU(0),
-    fCutValueD(0.0),
-    fCutResult(kTRUE),
-    fEvent(0x0)
+AliRsnCut::AliRsnCut(ETarget target) :
+  TNamed(),
+  fVarType(kInt),
+  fTarget(target),
+  fMinI(0),
+  fMaxI(0),
+  fMinD(0.0),
+  fMaxD(0.0),
+  fCutValueI(0),
+  fCutValueD(0.0),
+  fCutResult(kTRUE),
+  fEvent(0x0)
 {
 //
 // Default constructor.
@@ -44,19 +46,17 @@ AliRsnCut::AliRsnCut() :
 
 //_________________________________________________________________________________________________
 AliRsnCut::AliRsnCut(const AliRsnCut& copy) :
-    TNamed(copy),
-    fVarType(copy.fVarType),
-    fMinI(copy.fMinI),
-    fMaxI(copy.fMaxI),
-    fMinU(copy.fMinU),
-    fMaxU(copy.fMaxU),
-    fMinD(copy.fMinD),
-    fMaxD(copy.fMaxD),
-    fCutValueI(copy.fCutValueI),
-    fCutValueU(copy.fCutValueU),
-    fCutValueD(copy.fCutValueD),
-    fCutResult(copy.fCutResult),
-    fEvent(copy.fEvent)
+  TNamed(copy),
+  fVarType(copy.fVarType),
+  fTarget(copy.fTarget),
+  fMinI(copy.fMinI),
+  fMaxI(copy.fMaxI),
+  fMinD(copy.fMinD),
+  fMaxD(copy.fMaxD),
+  fCutValueI(copy.fCutValueI),
+  fCutValueD(copy.fCutValueD),
+  fCutResult(copy.fCutResult),
+  fEvent(copy.fEvent)
 {
 //
 // Copy constructor.
@@ -65,49 +65,21 @@ AliRsnCut::AliRsnCut(const AliRsnCut& copy) :
 
 //_________________________________________________________________________________________________
 AliRsnCut::AliRsnCut
-(const char *name, Int_t min, Int_t max) :
-    TNamed(name, ""),
-    fVarType(kInt),
-    fMinI(min),
-    fMaxI(max),
-    fMinU(0),
-    fMaxU(0),
-    fMinD(0.0),
-    fMaxD(0.0),
-    fCutValueI(0),
-    fCutValueU(0),
-    fCutValueD(0.0),
-    fCutResult(kTRUE),
-    fEvent(0x0)
-{
-//
-// Constructor.
-// If the cut must check values inside a range,
-// both 'value' arguments must be used, and they are, in the order,
-// the minimum and maximum of the allowed range.
-// If the cut must check a value, the second 'value' argument will never be used.
-//
-}
-
-//_________________________________________________________________________________________________
-AliRsnCut::AliRsnCut
-(const char *name, ULong_t min, ULong_t max) :
-    TNamed(name, ""),
-    fVarType(kULong),
-    fMinI(0),
-    fMaxI(0),
-    fMinU(min),
-    fMaxU(max),
-    fMinD(0.0),
-    fMaxD(0.0),
-    fCutValueI(0),
-    fCutValueU(0),
-    fCutValueD(0.0),
-    fCutResult(kTRUE),
-    fEvent(0x0)
+(const char *name, ETarget target, Int_t min, Int_t max) :
+  TNamed(name, ""),
+  fVarType(kInt),
+  fTarget(target),
+  fMinI(min),
+  fMaxI(max),
+  fMinD(0.0),
+  fMaxD(0.0),
+  fCutValueI(0),
+  fCutValueD(0.0),
+  fCutResult(kTRUE),
+  fEvent(0x0)
 {
 //
-// Constructor.
+// Constructor with integer values.
 // If the cut must check values inside a range,
 // both 'value' arguments must be used, and they are, in the order,
 // the minimum and maximum of the allowed range.
@@ -117,23 +89,21 @@ AliRsnCut::AliRsnCut
 
 //_________________________________________________________________________________________________
 AliRsnCut::AliRsnCut
-(const char *name, Double_t min, Double_t max) :
-    TNamed(name, ""),
-    fVarType(kDouble),
-    fMinI(0),
-    fMaxI(0),
-    fMinU(0),
-    fMaxU(0),
-    fMinD(min),
-    fMaxD(max),
-    fCutValueI(0),
-    fCutValueU(0),
-    fCutValueD(0.0),
-    fCutResult(kTRUE),
-    fEvent(0x0)
+(const char *name, ETarget target, Double_t min, Double_t max) :
+  TNamed(name, ""),
+  fVarType(kDouble),
+  fTarget(target),
+  fMinI(0),
+  fMaxI(0),
+  fMinD(min),
+  fMaxD(max),
+  fCutValueI(0),
+  fCutValueD(0.0),
+  fCutResult(kTRUE),
+  fEvent(0x0)
 {
 //
-// Constructor.
+// Constructor with double values.
 // If the cut must check values inside a range,
 // both 'value' arguments must be used, and they are, in the order,
 // the minimum and maximum of the allowed range.
@@ -150,15 +120,13 @@ AliRsnCut& AliRsnCut::operator=(const AliRsnCut& copy)
 //
 
   fVarType   = copy.fVarType;
+  fTarget    = copy.fTarget;
   fMinI      = copy.fMinI;
   fMaxI      = copy.fMaxI;
   fMinD      = copy.fMinD;
   fMaxD      = copy.fMaxD;
-  fMinU      = copy.fMinU;
-  fMaxU      = copy.fMaxU;
   fCutValueI = copy.fCutValueI;
   fCutValueD = copy.fCutValueD;
-  fCutValueU = copy.fCutValueU;
   fCutResult = copy.fCutResult;
   fEvent     = copy.fEvent;
 
@@ -166,110 +134,174 @@ AliRsnCut& AliRsnCut::operator=(const AliRsnCut& copy)
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnDaughter* /*track*/)
+Bool_t AliRsnCut::TargetOK(TObject *obj1, TObject *obj2)
 {
 //
-// Virtual cut-checking method.
-// In base class, these methods compare the argument type
-// with the defined target, in order to detect a mismatch
+// This method checks if the expected target and the passed object match.
 //
 
-  AliWarning("This cut does not provide checks on AliRsnDaughter. This function will return kTRUE");
+  if (!obj1)
+  {
+    AliError("Cannot cut on a NULL object!");
+    return kFALSE;
+  }
+
+  switch (fTarget)
+  {
+    case kDaughter:
+      if (dynamic_cast<AliRsnDaughter*>(obj1) == 0x0)
+      {
+        AliError(Form("[%s] Target mismatch (obj #1): expected  'AliRsnDaughter', passed '%s'", GetName(), obj1->ClassName()));
+        Print();
+        return kFALSE;
+      }
+      break;
+    case kMother:
+      if (dynamic_cast<AliRsnMother*>(obj1) == 0x0)
+      {
+        AliError(Form("[%s] Target mismatch (obj #1): expected  'AliRsnMother', passed '%s'", GetName(), obj1->ClassName()));
+        Print();
+        return kFALSE;
+      }
+      break;
+    case kEvent:
+      if (dynamic_cast<AliRsnEvent*>(obj1) == 0x0)
+      {
+        AliError(Form("[%s] Target mismatch (obj #1): expected  'AliRsnEvent', passed '%s'", GetName(), obj1->ClassName()));
+        Print();
+        return kFALSE;
+      }
+      break;
+    case kMixEvent:
+      if (dynamic_cast<AliRsnEvent*>(obj1) == 0x0)
+      {
+        AliError(Form("[%s] Target mismatch (obj #1): expected  'AliRsnEvent', passed '%s' an", GetName(), obj1->ClassName()));
+        Print();
+        return kFALSE;
+      }
+      if (obj2)
+      {
+        if (dynamic_cast<AliRsnEvent*>(obj2) == 0x0)
+        {
+          AliError(Form("[%s] Target mismatch (obj #2): expected  'AliRsnEvent', passed '%s' an", GetName(), obj2->ClassName()));
+          Print();
+          return kFALSE;
+        }
+      }
+      else
+      {
+        AliError("Mix-event cuts require 2 not NULL objects");
+        Print();
+        return kFALSE;
+      }
+      break;
+    default:
+      return kTRUE;
+  }
+  
   return kTRUE;
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnPairParticle* /*pair*/)
+Bool_t AliRsnCut::IsSelected(TObject* /*obj1*/, TObject* /*obj2*/)
 {
 //
-// Virtual cut-checking method.
-// In base class, these methods compare the argument type
-// with the defined target, in order to detect a mismatch
+// Virtual cut-checking method for event mixing.
+// This method checks only that the target is the oner for mixing.
 //
 
-  AliWarning("This cut does not provide checks on AliRsnPairParticle. This function will return kTRUE");
+  AliWarning("Single-object cuts are not implemented here.");
   return kTRUE;
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*event*/)
+Bool_t AliRsnCut::OkValue()
 {
 //
-// Virtual cut-checking method.
-// In base class, these methods compare the argument type
-// with the defined target, in order to detect a mismatch
+// This method is used when the cut consists in comparing the cut value
+// with a reference value to which it must be equal (in case of doubles, 'almost' equal).
+// Then, the cut result is kTRUE if the cut value is equal to this reference value.
 //
 
-  AliWarning("This cut does not provide checks on AliRsnEvent. This function will return kTRUE");
-  return kTRUE;
+  switch (fVarType) 
+  {
+    case kInt:
+      return OkValueI();
+    case kDouble:
+      return OkValueD();
+    default:
+      AliError(Form("fVarType = %d --> not allowed", fVarType));
+      return kFALSE;
+  }
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*ev1*/, AliRsnEvent* /*ev2*/)
+Bool_t AliRsnCut::OkRange()
 {
 //
-// Virtual cut-checking method.
-// In base class, these methods compare the argument type
-// with the defined target, in order to detect a mismatch
+// This method is used when the cut consists in an allowed range
+// where the cut value must be included to pass the cut.
+// Then, the cut result is kTRUE if the cut value is inside this range.
 //
 
-  AliWarning("This cut does not provide checks on two AliRsnEvent's. This function will return kTRUE");
-  return kTRUE;
+  switch (fVarType) 
+  {
+    case kInt:
+      return OkRangeI();
+    case kDouble:
+      return OkRangeD();
+    default:
+      AliError(Form("fVarType = %d --> not allowed", fVarType));
+      return kFALSE;
+  }
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCut::OkValue()
+Bool_t AliRsnCut::OkValueI()
 {
 //
 // This method is used when the cut consists in comparing the cut value
-// with a reference value to which it must be equal (in case of doubles, 'almost' equal).
-// Then, the cut result is kTRUE if the cut value is equal to this reference value.
+// with a reference integer value to which it must be equal.
 //
 
-  switch (fVarType) {
-  case kInt:
-    // eval result
-    fCutResult = (fCutValueI == fMinI);
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
-    AliDebug(AliLog::kDebug + 3, Form("Checked value: %d", fCutValueI));
-    AliDebug(AliLog::kDebug + 3, Form("Cut value    : %d", fMinI));
-    AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  case kULong:
-    // eval result
-    fCutResult = (fCutValueU == fMinU);
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s" , GetName()));
-    AliDebug(AliLog::kDebug + 3, Form("Checked value: %lu", fCutValueU));
-    AliDebug(AliLog::kDebug + 3, Form("Cut value    : %lu", fMinU));
-    AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s" , (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  case kDouble:
-    // eval result
-    fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
-    AliDebug(AliLog::kDebug + 3, Form("Checked value: %f", fCutValueD));
-    AliDebug(AliLog::kDebug + 3, Form("Cut value    : %f", fMinD));
-    AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  default:
-    AliError(Form("fVarType = %d --> not allowed", fVarType));
-    return kFALSE;
-  }
+  // eval result
+  fCutResult = (fCutValueI == fMinI);
+  
+  // print debug message
+  AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
+  AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
+  AliDebug(AliLog::kDebug + 3, Form("Checked value: %d", fCutValueI));
+  AliDebug(AliLog::kDebug + 3, Form("Cut value    : %d", fMinI));
+  AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+  AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
+  
+  return fCutResult;
+}
 
+//_________________________________________________________________________________________________
+Bool_t AliRsnCut::OkValueD()
+{
+//
+// This method is used when the cut consists in comparing the cut value
+// with a reference double value to which it must be equal (or at least, almost).
+//
+
+  // eval result
+  fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
+  
+  // print debug message
+  AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
+  AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
+  AliDebug(AliLog::kDebug + 3, Form("Checked value: %f", fCutValueD));
+  AliDebug(AliLog::kDebug + 3, Form("Cut value    : %f", fMinD));
+  AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+  AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
+  
   return fCutResult;
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCut::OkRange()
+Bool_t AliRsnCut::OkRangeI()
 {
 //
 // This method is used when the cut consists in an allowed range
@@ -277,45 +309,74 @@ Bool_t AliRsnCut::OkRange()
 // Then, the cut result is kTRUE if the cut value is inside this range.
 //
 
-  switch (fVarType) {
-  case kInt:
-    // eval result
-    fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
-    AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueI));
-    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %d , %d", fMinI, fMaxI));
-    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  case kULong:
-    // eval result
-    fCutResult = ((fCutValueU >= fMinU) && (fCutValueU <= fMaxU));
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s"       , GetName()));
-    AliDebug(AliLog::kDebug + 2, Form("Checked value: %lu"      , fCutValueU));
-    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %lu , %lu", fMinU, fMaxU));
-    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s"       , (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  case kDouble:
-    // eval result
-    fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
-    // print debug message
-    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
-    AliDebug(AliLog::kDebug + 2, Form("Checked value: %f", fCutValueD));
-    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %f , %f", fMinD, fMaxD));
-    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-    break;
-  default:
-    AliError(Form("fVarType = %d --> not allowed", fVarType));
-    return kFALSE;
-  }
+  // eval result
+  fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
+  
+  // print debug message
+  AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
+  AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
+  AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueI));
+  AliDebug(AliLog::kDebug + 2, Form("Cut range    : %d , %d", fMinI, fMaxI));
+  AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+  AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
+  
+  return fCutResult;
+}
+
+//_________________________________________________________________________________________________
+Bool_t AliRsnCut::OkRangeD()
+{
+//
+// This method is used when the cut consists in an allowed range
+// where the cut value must be included to pass the cut.
+// Then, the cut result is kTRUE if the cut value is inside this range.
+//
+
+  // eval result
+  fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
+   
+  // print debug message
+  AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
+  AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
+  AliDebug(AliLog::kDebug + 2, Form("Checked value: %f", fCutValueD));
+  AliDebug(AliLog::kDebug + 2, Form("Cut range    : %f , %f", fMinD, fMaxD));
+  AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+  AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
 
   return fCutResult;
 }
 
+//_________________________________________________________________________________________________
+void AliRsnCut::Print(Option_t*) const
+{
+//
+// Override TObject::Print() method
+//
+
+  Char_t target[100];
+  switch (fTarget)
+  {
+    case kDaughter: sprintf(target, "DAUGHTER"); break;
+    case kMother  : sprintf(target, "MOTHER"); break;
+    case kEvent   : sprintf(target, "EVENT"); break;
+    case kMixEvent: sprintf(target, "MIX EVENT"); break;
+    default       : sprintf(target, "UNDEFINED"); break;
+  }
+
+  AliInfo("=== CUT DETAILS ====================================");
+  AliInfo(Form("Cut name     : [%s]", GetName()));
+  AliInfo(Form("Cut target   : [%s]", target));
+  AliInfo(Form("Cut edges [D]: [%f - %f]", fMinD, fMaxD));
+  AliInfo(Form("Cut edges [I]: [%d - %d]", fMinI, fMaxI));
+  AliInfo("====================================================");
+}
+
+//_________________________________________________________________________________________________
+void AliRsnCut::SetEvent(AliRsnEvent *event)
+{
+//
+// Sets the reference event
+//
+
+  fEvent = event;
+}
index 3a013336c081d2c96979b4e51a2a9291094e7342..ddf4bd37f145584c2dd56c8df4aeb9865d8445a1 100644 (file)
@@ -20,8 +20,6 @@
 
 #include "TNamed.h"
 
-class AliRsnDaughter;
-class AliRsnPairParticle;
 class AliRsnEvent;
 
 class AliRsnCut : public TNamed
@@ -29,61 +27,64 @@ class AliRsnCut : public TNamed
   public:
 
     // possible targets for a cut
-    enum ETarget {
-      kParticle = 0,
-      kPair,
+    enum ETarget 
+    {
+      kDaughter = 0,
+      kMother,
       kEvent,
       kMixEvent,
       kLastCutTarget
     };
 
     // data type for check
-    enum EVarType {
-      kInt = 0,
-      kULong,
+    enum EVarType 
+    {
+      kNoVar = 0,
+      kInt,
       kDouble
     };
 
-    AliRsnCut();
+    AliRsnCut(ETarget target = kLastCutTarget);
     AliRsnCut(const AliRsnCut& copy);
     AliRsnCut& operator=(const AliRsnCut& copy);
-    AliRsnCut(const char *name, Int_t    min, Int_t    max = 0);
-    AliRsnCut(const char *name, ULong_t  min, ULong_t  max = 0);
-    AliRsnCut(const char *name, Double_t min, Double_t max = 0);
-    virtual ~AliRsnCut() {;};
+    AliRsnCut(const char *name, ETarget target, Int_t    min, Int_t    max = 0 );
+    AliRsnCut(const char *name, ETarget target, Double_t min, Double_t max = 0.);
+    virtual ~AliRsnCut() { /*nothing*/ };
 
     void             SetRange(Int_t    min, Int_t    max) {fMinI = min; fMaxI = max; fVarType = kInt;}
-    void             SetRange(ULong_t  min, ULong_t  max) {fMinU = min; fMaxU = max; fVarType = kULong;}
     void             SetRange(Double_t min, Double_t max) {fMinD = min; fMaxD = max; fVarType = kDouble;}
 
     void             SetValue(Int_t value)    {fMinI = value; fVarType = kInt;}
-    void             SetValue(ULong_t value)  {fMinU = value; fVarType = kULong;}
     void             SetValue(Double_t value) {fMinD = value; fVarType = kDouble;}
 
-    void             SetEvent(AliRsnEvent *event) {fEvent = event;}
-
-    virtual Bool_t   IsSelected(ETarget tgt, AliRsnDaughter *daughter);
-    virtual Bool_t   IsSelected(ETarget tgt, AliRsnPairParticle *pair);
-    virtual Bool_t   IsSelected(ETarget tgt, AliRsnEvent *event);
-    virtual Bool_t   IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
+    virtual void     SetEvent(AliRsnEvent *event);
+    
+    ETarget          GetTarget() {return fTarget;}
+    Bool_t           IsTarget(ETarget target) {return (fTarget == target);}
+    Bool_t           TargetOK  (TObject *obj1, TObject *obj2 = 0x0);
+    virtual Bool_t   IsSelected(TObject *obj1, TObject *obj2 = 0x0);
+    virtual void     Print(Option_t *opt = "") const;
 
   protected:
 
     Bool_t  OkValue();
     Bool_t  OkRange();
+    Bool_t  OkValueI();
+    Bool_t  OkRangeI();
+    Bool_t  OkValueD();
+    Bool_t  OkRangeD();
 
     EVarType  fVarType;    // type of checked variable
+    ETarget   fTarget;     // type of object on which the cut is checked
 
     Int_t     fMinI;       // lower edge of INT range or ref. value for INT CUT
     Int_t     fMaxI;       // upper edge of INT range (not used for value cuts)
-    ULong_t   fMinU;       // lower edge of ULONG range or ref. value for INT CUT
-    ULong_t   fMaxU;       // upper edge of ULONG range (not used for value cuts)
     Double_t  fMinD;       // lower edge of DOUBLE range or ref. value for INT CUT
     Double_t  fMaxD;       // upper edge of DOUBLE range (not used for value cuts)
 
-    Int_t     fCutValueI;  // cut value
-    ULong_t   fCutValueU;  // cut value
-    Double_t  fCutValueD;  // cut value
+    Int_t     fCutValueI;  // cut value INT
+    Double_t  fCutValueD;  // cut value DOUBLE
+    
     Bool_t    fCutResult;  // tells if the cut is passed or not
 
     AliRsnEvent *fEvent;   //! pointer to current event (can be needed sometimes)
index d3b417f6c639639c538bc30508aac7e3052e1eef..dd1cea1a12ced4237e12622e95b4dda00766fe09 100644 (file)
@@ -26,10 +26,10 @@ ClassImp(AliRsnCutBetheBloch)
 
 //_________________________________________________________________________________________________
 AliRsnCutBetheBloch::AliRsnCutBetheBloch() :
-    AliRsnCut(),
-    fCorrect(kTRUE),
-    fMIP(50.0),
-    fType(AliPID::kUnknown)
+  AliRsnCut(AliRsnCut::kDaughter),
+  fCorrect(kTRUE),
+  fMIP(50.0),
+  fType(AliPID::kUnknown)
 {
 //
 // Default constructor.
@@ -41,10 +41,10 @@ AliRsnCutBetheBloch::AliRsnCutBetheBloch() :
 //_________________________________________________________________________________________________
 AliRsnCutBetheBloch::AliRsnCutBetheBloch
 (const char *name, Double_t fractionRange, AliPID::EParticleType type, Double_t mip, Bool_t correct) :
-    AliRsnCut(name, 0.0, fractionRange),
-    fCorrect(correct),
-    fMIP(mip),
-    fType(type)
+  AliRsnCut(name, AliRsnCut::kDaughter, 0.0, fractionRange),
+  fCorrect(correct),
+  fMIP(mip),
+  fType(type)
 {
 //
 // Main constructor.
@@ -75,7 +75,7 @@ Double_t AliRsnCutBetheBloch::BetheBloch(AliRsnDaughter * const trackRef)
   Double_t mass = pid.ParticleMass(fType);
 
   // get the track momentum at the inner wall of TPC: if absent cut is not passed
-  AliExternalTrackParam track(*trackRef->GetRefESD()->GetInnerParam());
+  AliExternalTrackParam track(*trackRef->GetRefESDtrack()->GetInnerParam());
 
   Double_t betaGamma = track.P() / mass;
   Double_t beta = betaGamma / TMath::Sqrt(1.0 + betaGamma * betaGamma);
@@ -102,37 +102,37 @@ Double_t AliRsnCutBetheBloch::RelDiff(AliRsnDaughter *track)
 // Relative difference between BB value and TPC signal
 //
 
-  if (!track->GetRefESD()) return -99999.9;
+  if (!track->GetRefESDtrack()) return -99999.9;
 
   // compute Bethe-Bloch with the given mass hypothesis
   Double_t bb = BetheBloch(track);
-  return TMath::Abs((track->GetRefESD()->GetTPCsignal() - bb) / bb);
+  return TMath::Abs((track->GetRefESDtrack()->GetTPCsignal() - bb) / bb);
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutBetheBloch::IsSelected(ETarget tgt, AliRsnDaughter *track)
+Bool_t AliRsnCutBetheBloch::IsSelected(TObject *obj1, TObject* /*obj2*/)
 {
 //
 // Cut checker.
 //
 
   // coherence check
-  if (tgt != AliRsnCut::kParticle) {
-    AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
+  if (!AliRsnCut::TargetOK(obj1))
+  {
+    AliError(Form("Wrong target. Skipping cut", GetName()));
     return kTRUE;
   }
-
-  // if the required PID of the track is not the same as the
-  // reference of the cut, the cut is automatically skipped
-  if (track->RequiredPID() != fType) return kTRUE;
+  
+  // dynamic cast the object into AliRsnDaughter
+  AliRsnDaughter *track = dynamic_cast<AliRsnDaughter*>(obj1);
 
   // retrieve the TPC signal
-  AliESDtrack *esd = track->GetRefESD();
+  AliESDtrack *esd = track->GetRefESDtrack();
   if (!esd) {
     AliError("ESD information unavailable");
     return kTRUE;
   }
-  if (!track->GetRefESD()->GetInnerParam()) {
+  if (!track->GetRefESDtrack()->GetInnerParam()) {
     AliDebug(AliLog::kDebug+2, "Rejecting a track with no info at the TPC inner wall");
     return kFALSE;
   }
@@ -147,36 +147,3 @@ Bool_t AliRsnCutBetheBloch::IsSelected(ETarget tgt, AliRsnDaughter *track)
   // then, this cut is checked inside the range
   return OkRange();
 }
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutBetheBloch::IsSelected(ETarget /*tgt*/, AliRsnPairParticle* /*pair*/)
-{
-//
-// Cut checker
-//
-
-  AliWarning("Cannot apply this cut to pairs");
-  return kTRUE;
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutBetheBloch::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*event*/)
-{
-//
-// Cut checker
-//
-
-  AliWarning("Cannot apply this cut to events");
-  return kTRUE;
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutBetheBloch::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*ev1*/, AliRsnEvent* /*ev2*/)
-{
-//
-// Cut checker
-//
-
-  AliWarning("Cannot apply this cut to event mixing");
-  return kTRUE;
-}
index 4a0269a5e24c80168c7b46e0cd4454d3815da4e9..4bcbaabdc1d110d898e8da3b31587d5f9fa476a0 100644 (file)
@@ -29,10 +29,7 @@ class AliRsnCutBetheBloch : public AliRsnCut
     Double_t       BetheBloch(AliRsnDaughter*const track);
     Double_t       RelDiff(AliRsnDaughter *track);
 
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnDaughter *daughter);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnPairParticle *pair);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *event);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
+    virtual Bool_t IsSelected(TObject *obj1, TObject *obj2 = 0x0);
 
   protected:
 
diff --git a/PWG2/RESONANCES/AliRsnCutDaughterType.cxx b/PWG2/RESONANCES/AliRsnCutDaughterType.cxx
new file mode 100644 (file)
index 0000000..f73a1a4
--- /dev/null
@@ -0,0 +1,82 @@
+//
+// Class AliRsnCutDaughterType
+//
+// General implementation of a single cut strategy, which can be:
+// - a value contained in a given interval  [--> IsBetween()   ]
+// - a value equal to a given reference     [--> MatchesValue()]
+//
+// In all cases, the reference value(s) is (are) given as data members
+// and each kind of cut requires a given value type (Int, UInt, Double),
+// but the cut check procedure is then automatized and chosen thanks to
+// an enumeration of the implemented cut types.
+// At the end, the user (or any other point which uses this object) has
+// to use the method IsSelected() to check if this cut has been passed.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#include "AliRsnDaughter.h"
+#include "AliRsnCutDaughterType.h"
+
+ClassImp(AliRsnCutDaughterType)
+
+//_________________________________________________________________________________________________
+AliRsnCutDaughterType::AliRsnCutDaughterType() :
+  AliRsnCut(AliRsnCut::kDaughter),
+  fRefType(kTypes)
+{
+//
+// Default constructor.
+//
+}
+
+//_________________________________________________________________________________________________
+AliRsnCutDaughterType::AliRsnCutDaughterType
+(const char *name, EType type) :
+  AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
+  fRefType(type)
+{
+//
+// Main constructor.
+//
+}
+
+//_________________________________________________________________________________________________
+Bool_t AliRsnCutDaughterType::IsSelected(TObject *obj1, TObject* /*obj2*/)
+{
+//
+// Cut checker.
+//
+
+  // coherence check
+  AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(obj1);
+  if (!daughter) return kFALSE;
+  
+  // check the daughter according to the selected type
+  // in some cases this means to retrieve the track status
+  AliVTrack   *track  = dynamic_cast<AliVTrack*>(daughter->GetRef());
+  AliESDtrack *esdT   = dynamic_cast<AliESDtrack*>(daughter->GetRef());
+  ULong_t      status = 0x0;
+  if (track) status = (ULong_t)track->GetStatus();
+  
+  switch (fRefType)
+  {
+    case kTrackTPC:
+      return ((status & AliESDtrack::kTPCin)  != 0);
+    case kTrackITSSA:
+      if (esdT)
+      {
+        UChar_t itsCluMap = track->GetITSClusterMap();
+        Int_t   k, nITS   = 0;
+        for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
+        if (nITS < 3) return kFALSE;
+      }
+      return ((status & AliESDtrack::kTPCin)  == 0 && (status & AliESDtrack::kITSrefit) != 0 && (status & AliESDtrack::kITSpureSA) == 0 && (status & AliESDtrack::kITSpid) != 0);
+    case kV0:
+      return daughter->IsV0();
+    default:
+      AliError("No good reference type is chosen. Cut skipped");
+      return kTRUE;
+  }
+}
diff --git a/PWG2/RESONANCES/AliRsnCutDaughterType.h b/PWG2/RESONANCES/AliRsnCutDaughterType.h
new file mode 100644 (file)
index 0000000..0e40b2d
--- /dev/null
@@ -0,0 +1,42 @@
+//
+// Class AliRsnCutRange
+//
+// General implementation of cuts which check a value inside a range.
+// This range can be defined by two integers or two doubles.
+// A user-friendly enumeration allows to define what is checked.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#ifndef ALIRSNCUTDAUGHTERTYPE_H
+#define ALIRSNCUTDAUGHTERTYPE_H
+
+#include "AliRsnCut.h"
+
+class AliRsnCutDaughterType : public AliRsnCut
+{
+  public:
+  
+    enum EType
+    {
+      kTrackTPC,
+      kTrackITSSA,
+      kV0,
+      kTypes
+    };
+
+    AliRsnCutDaughterType();
+    AliRsnCutDaughterType(const char *name, EType type);
+    virtual ~AliRsnCutDaughterType() {;};
+
+    virtual Bool_t   IsSelected(TObject *obj1, TObject *obj2 = 0x0);
+
+  protected:
+  
+    EType fRefType;   // type to which the track format is compared
+
+    ClassDef(AliRsnCutDaughterType, 1)
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnCutESD2010.cxx b/PWG2/RESONANCES/AliRsnCutESD2010.cxx
new file mode 100644 (file)
index 0000000..096c960
--- /dev/null
@@ -0,0 +1,276 @@
+//
+// Class AliRsnCutESD2010
+//
+// General implementation of a single cut strategy, which can be:
+// - a value contained in a given interval  [--> IsBetween()   ]
+// - a value equal to a given reference     [--> MatchesValue()]
+//
+// In all cases, the reference value(s) is (are) given as data members
+// and each kind of cut requires a given value type (Int, UInt, Double),
+// but the cut check procedure is then automatized and chosen thanks to
+// an enumeration of the implemented cut types.
+// At the end, the user (or any other point which uses this object) has
+// to use the method IsSelected() to check if this cut has been passed.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#include <Riostream.h>
+
+#include "AliESDpid.h"
+#include "AliTOFT0maker.h"
+#include "AliTOFcalib.h"
+#include "AliCDBManager.h"
+#include "AliITSPIDResponse.h"
+
+#include "AliRsnEvent.h"
+#include "AliRsnDaughter.h"
+#include "AliRsnCutESD2010.h"
+
+ClassImp(AliRsnCutESD2010)
+
+//_________________________________________________________________________________________________
+AliRsnCutESD2010::AliRsnCutESD2010() :
+  AliRsnCut(AliRsnCut::kDaughter),
+  fIsMC(kFALSE),
+  fCheckITS(kTRUE),
+  fCheckTPC(kTRUE),
+  fCheckTOF(kTRUE),
+  fMaxITSband(1E6),
+  fTPCpLimit(0.35),
+  fMinTPCband(-1E6),
+  fMaxTPCband( 1E6),
+  fESDtrackCutsTPC(),
+  fESDtrackCutsITS(),
+  fESDpid(0x0),
+  fTOFmaker(0x0),
+  fTOFcalib(0x0),
+  fTOFcalibrateESD(kFALSE),
+  fTOFcorrectTExp(kFALSE),
+  fTOFuseT0(kFALSE),
+  fTOFtuneMC(kFALSE),
+  fTOFresolution(0.0),
+  fLastRun(-1)
+{
+//
+// Default constructor.
+//
+}
+
+//_________________________________________________________________________________________________
+AliRsnCutESD2010::AliRsnCutESD2010
+(const char *name) :
+  AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
+  fIsMC(kFALSE),
+  fCheckITS(kTRUE),
+  fCheckTPC(kTRUE),
+  fCheckTOF(kTRUE),
+  fMaxITSband(1E6),
+  fTPCpLimit(0.35),
+  fMinTPCband(-1E6),
+  fMaxTPCband( 1E6),
+  fESDtrackCutsTPC(),
+  fESDtrackCutsITS(),
+  fESDpid(0x0),
+  fTOFmaker(0x0),
+  fTOFcalib(0x0),
+  fTOFcalibrateESD(kFALSE),
+  fTOFcorrectTExp(kFALSE),
+  fTOFuseT0(kFALSE),
+  fTOFtuneMC(kFALSE),
+  fTOFresolution(0.0),
+  fLastRun(-1)
+{
+//
+// Main constructor.
+//
+}
+
+//_________________________________________________________________________________________________
+AliRsnCutESD2010::AliRsnCutESD2010
+(const AliRsnCutESD2010& copy) :
+  AliRsnCut(copy),
+  fIsMC(kFALSE),
+  fCheckITS(copy.fCheckITS),
+  fCheckTPC(copy.fCheckTPC),
+  fCheckTOF(copy.fCheckTOF),
+  fMaxITSband(copy.fMaxITSband),
+  fTPCpLimit(copy.fTPCpLimit),
+  fMinTPCband(copy.fMinTPCband),
+  fMaxTPCband(copy.fMaxTPCband),
+  fESDtrackCutsTPC(copy.fESDtrackCutsTPC),
+  fESDtrackCutsITS(copy.fESDtrackCutsITS),
+  fESDpid(0x0),
+  fTOFmaker(0x0),
+  fTOFcalib(0x0),
+  fTOFcalibrateESD(copy.fTOFcalibrateESD),
+  fTOFcorrectTExp(copy.fTOFcorrectTExp),
+  fTOFuseT0(copy.fTOFuseT0),
+  fTOFtuneMC(copy.fTOFtuneMC),
+  fTOFresolution(copy.fTOFresolution),
+  fLastRun(-1)
+{
+//
+// Main constructor.
+//
+
+  Initialize();
+}
+
+//_________________________________________________________________________________________________
+void AliRsnCutESD2010::Initialize()
+{
+//
+// Main constructor.
+//
+
+  // setup TPC response
+  fESDpid = new AliESDpid;
+  fESDpid->GetTPCResponse().SetBetheBlochParameters(fTPCpar[0],fTPCpar[1],fTPCpar[2],fTPCpar[3],fTPCpar[4]);
+  
+  // setup TOF maker & calibration
+  fTOFcalib = new AliTOFcalib;
+  fTOFcalib->SetCorrectTExp(fTOFcorrectTExp);
+  fTOFmaker = new AliTOFT0maker(fESDpid, fTOFcalib);
+  fTOFmaker->SetTimeResolution(fTOFresolution);
+  fLastRun = -1;
+}
+
+//_________________________________________________________________________________________________
+void AliRsnCutESD2010::SetEvent(AliRsnEvent *event)
+{
+  // don't do anything if the event is the same as before
+  if (fEvent != 0x0 && fEvent == event) return;
+  
+  // retrieve the ESD event
+  AliESDEvent *esd = event->GetRefESD();
+  if (!esd)
+  {
+    fEvent = 0x0;
+    return;
+  }
+  else
+  {
+    fEvent = event;
+  }
+  
+  // initialize DB to current run
+  Int_t run = esd->GetRunNumber();
+  if (run != fLastRun)
+  {
+    cout << "Run = " << run << " -- LAST = " << fLastRun << endl;
+    fLastRun = run;
+    AliCDBManager *cdb = AliCDBManager::Instance();
+    cdb->SetDefaultStorage("raw://");
+    cdb->SetRun(run);
+    fTOFcalib->SetCorrectTExp(fTOFcorrectTExp);
+    fTOFcalib->Init();
+  }
+  
+  // if required, calibrate the TOF t0 maker with current event
+  if (fTOFcalibrateESD) fTOFcalib->CalibrateESD(esd);
+  if (fTOFtuneMC) fTOFmaker->TuneForMC(esd);
+  if (fTOFuseT0) 
+  {
+    fTOFmaker->ComputeT0TOF(esd);
+    fTOFmaker->ApplyT0TOF(esd);
+    fESDpid->MakePID(esd, kFALSE, 0.);
+  }
+}
+
+//_________________________________________________________________________________________________
+Bool_t AliRsnCutESD2010::IsSelected(TObject *obj1, TObject* /*obj2*/)
+{
+//
+// Cut checker.
+//
+
+  // coherence check: require an ESD track
+  AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(obj1);
+  if (!daughter) return kFALSE;
+  AliESDtrack *track = daughter->GetRefESDtrack();
+  if (!track) return kFALSE;
+  
+  // if no reference event, skip
+  if (!fEvent) return kFALSE;
+  
+  // ITS stuff #1 create the response function
+  AliITSPIDResponse itsrsp(fIsMC);
+  
+  // TOF: define fixed function for compatibility range
+  Double_t a1 = 0.01, a2 = -0.03;
+  Double_t b1 = 0.25, b2 =  0.25;
+  Double_t c1 = 0.05, c2 = -0.03;
+  Double_t ymax, ymin;
+  
+  ULong_t  status;
+  Int_t    k, nITS;
+  Double_t times[10], tpcNSigma, tpcMaxNSigma, itsSignal, itsNSigma, mom, tofTime, tofSigma, tofRef, tofRel;
+  Bool_t   okTOF, isTPC, isITSSA;
+  UChar_t  itsCluMap;
+  
+  // get commonly used variables
+  status  = (ULong_t)track->GetStatus();
+  mom     = track->P();
+  isTPC   = ((status & AliESDtrack::kTPCin)  != 0);
+  isITSSA = ((status & AliESDtrack::kTPCin)  == 0 && (status & AliESDtrack::kITSrefit) != 0 && (status & AliESDtrack::kITSpureSA) == 0 && (status & AliESDtrack::kITSpid) != 0);
+  
+  // accept only tracks which are TPC+ITS or ITS standalone
+  if (!isTPC && !isITSSA) return kFALSE;
+  
+  if (isTPC)
+  {
+    // check standard ESD cuts
+    if (!fESDtrackCutsTPC.IsSelected(track)) return kFALSE;
+    
+    // check TPC dE/dx
+    if (fCheckTPC)
+    {
+      tpcNSigma = TMath::Abs(fESDpid->NumberOfSigmasTPC(track, AliPID::kKaon));
+      if (track->GetInnerParam()->P() > fTPCpLimit) tpcMaxNSigma = fMinTPCband; else tpcMaxNSigma = fMaxTPCband;
+      if (tpcNSigma > tpcMaxNSigma) return kFALSE;
+    }
+    
+    // check TOF (only if momentum is large than function asymptote and flags are OK)
+    if (fCheckTOF)
+    {
+      okTOF = kTRUE;
+      if (((status & AliESDtrack::kTOFout) != 0) && ((status & AliESDtrack::kTIME) != 0) && mom > TMath::Max(b1, b2))
+      {
+        track->GetIntegratedTimes(times);
+        tofTime  = (Double_t)track->GetTOFsignal();
+        tofSigma = fTOFmaker->GetExpectedSigma(mom, times[AliPID::kKaon], AliPID::ParticleMass(AliPID::kKaon));
+        tofRef   = times[AliPID::kKaon];
+        if (tofRef > 0.0)
+        {
+          tofRel   = (tofTime - tofRef) / tofRef;
+          ymax     = a1 / (mom - b1) + c1;
+          ymin     = a2 / (mom - b2) + c2;
+          okTOF    = (tofRel >= ymin && tofRel <= ymax);
+        }
+      }
+      if (!okTOF) return kFALSE;
+    }
+  }
+  else
+  {
+    // check standard ESD cuts
+    if (!fESDtrackCutsITS.IsSelected(track)) return kFALSE;
+    
+    // check dE/dx
+    if (fCheckITS)
+    {
+      if ((status & AliESDtrack::kITSpid)  != 0) return kFALSE;
+      itsSignal = track->GetITSsignal();
+      itsCluMap = track->GetITSClusterMap();
+      nITS      = 0;
+      for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
+      if (nITS < 3) return kFALSE; // track not good for PID
+      itsNSigma = itsrsp.GetNumberOfSigmas(mom, itsSignal, AliPID::kKaon, nITS, kTRUE);
+      if (TMath::Abs(itsNSigma) > fMaxITSband) return kFALSE;
+    }
+  }
+  
+  return kTRUE;
+}
diff --git a/PWG2/RESONANCES/AliRsnCutESD2010.h b/PWG2/RESONANCES/AliRsnCutESD2010.h
new file mode 100644 (file)
index 0000000..af41b7b
--- /dev/null
@@ -0,0 +1,87 @@
+//
+// Class AliRsnCutRange
+//
+// General implementation of cuts which check a value inside a range.
+// This range can be defined by two integers or two doubles.
+// A user-friendly enumeration allows to define what is checked.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#ifndef ALIRSNCUTESD2010_H
+#define ALIRSNCUTESD2010_H
+
+#include "AliESDtrackCuts.h"
+#include "AliRsnCut.h"
+
+class AliESDpid;
+class AliTOFT0maker;
+class AliTOFcalib;
+
+class AliRsnCutESD2010 : public AliRsnCut
+{
+  public:
+
+    AliRsnCutESD2010();
+    AliRsnCutESD2010(const char *name);
+    virtual ~AliRsnCutESD2010() {;};
+
+    void             Initialize();
+    AliESDtrackCuts* GetCutsTPC() {return &fESDtrackCutsTPC;}
+    AliESDtrackCuts* GetCutsITS() {return &fESDtrackCutsITS;}
+    virtual Bool_t   IsSelected(TObject *obj1, TObject *obj2 = 0x0);
+    
+    void             SetMC      (Bool_t yn = kTRUE) {fIsMC = yn;}
+    void             SetCheckITS(Bool_t yn = kTRUE) {fCheckITS = yn;}
+    void             SetCheckTPC(Bool_t yn = kTRUE) {fCheckTPC = yn;}
+    void             SetCheckTOF(Bool_t yn = kTRUE) {fCheckTOF = yn;}
+    
+    void             SetITSband(Double_t v) {fMaxITSband = v;}
+    
+    void             SetTPCpLimit(Double_t v) {fTPCpLimit = v;}
+    void             SetTPCrange(Double_t min, Double_t max) {fMinTPCband = min; fMaxTPCband = max;}
+    void             SetTPCpar(Double_t p0, Double_t p1, Double_t p2, Double_t p3, Double_t p4)
+                       {fTPCpar[0]=p0;fTPCpar[1]=p1;fTPCpar[2]=p2;fTPCpar[3]=p3;fTPCpar[4]=p4;}
+
+    void             SetTOFcalibrateESD(Bool_t yn = kTRUE)  {fTOFcalibrateESD = yn;}
+    void             SetTOFcorrectTExp (Bool_t yn = kTRUE)  {fTOFcorrectTExp = yn;}
+    void             SetTOFuseT0       (Bool_t yn = kTRUE)  {fTOFuseT0 = yn;}
+    void             SetTOFtuneMC      (Bool_t yn = kTRUE)  {fTOFtuneMC = yn;}
+    void             SetTOFresolution  (Double_t v = 100.0) {fTOFresolution = v;}
+    
+    virtual void     SetEvent(AliRsnEvent *event);
+
+  protected:
+  
+    AliRsnCutESD2010(const AliRsnCutESD2010& copy);
+    AliRsnCutESD2010& operator=(const AliRsnCutESD2010& /*copy*/) {return (*this);}
+  
+    Bool_t           fIsMC;             // swithc for MC analysis
+    Bool_t           fCheckITS;         //  switch for ITS dE/dx check
+    Bool_t           fCheckTPC;         //  switch for TPC dE/dx check
+    Bool_t           fCheckTOF;         //  switch for TOF time check
+
+    Double_t         fMaxITSband;       //  range for ITS de/dx band
+
+    Double_t         fTPCpLimit;        //  limit to choose what band to apply
+    Double_t         fTPCpar[5];        //  parameters for TPC bethe-Bloch
+    Double_t         fMinTPCband;       //  range for TPC de/dx band - min
+    Double_t         fMaxTPCband;       //  range for TPC de/dx band - max
+    
+    AliESDtrackCuts  fESDtrackCutsTPC;  //  ESD standard defined track cuts for TPC tracks
+    AliESDtrackCuts  fESDtrackCutsITS;  //  ESD standard defined track cuts for ITS-SA tracks
+    AliESDpid       *fESDpid;           //! PID manager
+    AliTOFT0maker   *fTOFmaker;         //! TOF time0 computator
+    AliTOFcalib     *fTOFcalib;         //! TOF calibration
+    Bool_t           fTOFcalibrateESD;  //  TOF settings
+    Bool_t           fTOFcorrectTExp;   //  TOF settings
+    Bool_t           fTOFuseT0;         //  TOF settings
+    Bool_t           fTOFtuneMC;        //  TOF settings
+    Double_t         fTOFresolution;    //  TOF settings
+    Int_t            fLastRun;          //  last run number
+
+    ClassDef(AliRsnCutESD2010, 1)
+};
+
+#endif
index 59d509735c94fd06a30d41d57533520e43b7e8fa..9599ceb0baf798ff107ab9b0b626a42b3ae8a30e 100644 (file)
@@ -23,8 +23,8 @@ ClassImp(AliRsnCutESDPrimary)
 
 //_________________________________________________________________________________________________
 AliRsnCutESDPrimary::AliRsnCutESDPrimary() :
-    AliRsnCut(),
-    fCuts()
+  AliRsnCut(AliRsnCut::kDaughter),
+  fCuts()
 {
 //
 // Default constructor.
@@ -34,8 +34,8 @@ AliRsnCutESDPrimary::AliRsnCutESDPrimary() :
 //_________________________________________________________________________________________________
 AliRsnCutESDPrimary::AliRsnCutESDPrimary
 (const char *name) :
-    AliRsnCut(name, 0.0, 0.0),
-    fCuts()
+  AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
+  fCuts()
 {
 //
 // Main constructor.
@@ -43,22 +43,20 @@ AliRsnCutESDPrimary::AliRsnCutESDPrimary
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutESDPrimary::IsSelected(ETarget tgt, AliRsnDaughter * const track)
+Bool_t AliRsnCutESDPrimary::IsSelected(TObject *obj1, TObject* /*obj2*/)
 {
 //
 // Cut checker.
 //
 
   // coherence check
-  if (tgt != AliRsnCut::kParticle) {
-    AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
-    return kTRUE;
-  }
-
+  AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(obj1);
+  if (!daughter) return kFALSE;
+  
   // retrieve the TPC signal
-  AliVParticle *vpart = track->GetRef();
-  AliESDtrack *esdTrack = dynamic_cast<AliESDtrack*>(vpart);
-  if (!esdTrack) {
+  AliESDtrack *esdTrack = daughter->GetRefESDtrack();
+  if (!esdTrack) 
+  {
     AliError("ESD information unavailable");
     return kTRUE;
   }
@@ -66,36 +64,3 @@ Bool_t AliRsnCutESDPrimary::IsSelected(ETarget tgt, AliRsnDaughter * const track
   // check cut
   return fCuts.IsSelected(esdTrack);
 }
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutESDPrimary::IsSelected(ETarget /*tgt*/, AliRsnPairParticle* /*pair*/)
-{
-//
-// Cut checker
-//
-
-  AliWarning("Cannot apply this cut to pairs");
-  return kTRUE;
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutESDPrimary::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*event*/)
-{
-//
-// Cut checker
-//
-
-  AliWarning("Cannot apply this cut to events");
-  return kTRUE;
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutESDPrimary::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*ev1*/, AliRsnEvent* /*ev2*/)
-{
-//
-// Cut checker
-//
-
-  AliWarning("Cannot apply this cut to event mixing");
-  return kTRUE;
-}
index 8a0e54404ae849169bd77da8221a733964c18ef6..f9dc1dafc095c3626a840f113313951a8585f4cb 100644 (file)
@@ -24,11 +24,7 @@ class AliRsnCutESDPrimary : public AliRsnCut
     virtual ~AliRsnCutESDPrimary() {;};
 
     AliESDtrackCuts* GetCuts() {return &fCuts;}
-
-    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnDaughter*const daughter);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnPairParticle *pair);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *event);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
+    virtual Bool_t   IsSelected(TObject *obj1, TObject *obj2 = 0x0);
 
   protected:
 
diff --git a/PWG2/RESONANCES/AliRsnCutESDTrigger.cxx b/PWG2/RESONANCES/AliRsnCutESDTrigger.cxx
deleted file mode 100644 (file)
index dbe728e..0000000
+++ /dev/null
@@ -1,102 +0,0 @@
-//
-// Class AliRsnCutESDTrigger
-//
-// General implementation of a single cut strategy, which can be:
-// - a value contained in a given interval  [--> IsBetween()   ]
-// - a value equal to a given reference     [--> MatchesValue()]
-//
-// In all cases, the reference value(s) is (are) given as data members
-// and each kind of cut requires a given value type (Int, UInt, Double),
-// but the cut check procedure is then automatized and chosen thanks to
-// an enumeration of the implemented cut types.
-// At the end, the user (or any other point which uses this object) has
-// to use the method IsSelected() to check if this cut has been passed.
-//
-// authors: Martin Vala (martin.vala@cern.ch)
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
-//
-
-#include "AliESDEvent.h"
-#include "AliRsnEvent.h"
-#include "AliRsnCutESDTrigger.h"
-
-ClassImp(AliRsnCutESDTrigger)
-
-//_________________________________________________________________________________________________
-AliRsnCutESDTrigger::AliRsnCutESDTrigger() :
-    AliRsnCut(),
-    fTrigger()
-{
-//
-// Default constructor.
-//
-}
-
-//_________________________________________________________________________________________________
-AliRsnCutESDTrigger::AliRsnCutESDTrigger
-(const char *name, const char *mask) :
-    AliRsnCut(name, 0.0, 0.0),
-    fTrigger(mask)
-{
-//
-// Main constructor.
-//
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutESDTrigger::IsSelected(ETarget /*tgt*/, AliRsnDaughter* /*const track*/)
-{
-//
-// Cut checker.
-//
-
-  AliWarning("Cannot apply this cut to tracks");
-  return kTRUE;
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutESDTrigger::IsSelected(ETarget /*tgt*/, AliRsnPairParticle* /*pair*/)
-{
-//
-// Cut checker
-//
-
-  AliWarning("Cannot apply this cut to pairs");
-  return kTRUE;
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutESDTrigger::IsSelected(ETarget tgt, AliRsnEvent* const event)
-{
-//
-// Cut checker
-//
-
-  // coherence check
-  if (tgt != AliRsnCut::kEvent) {
-    AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
-    return kTRUE;
-  }
-
-  // retrieve the event trigger mask
-  AliVEvent *vevent = event->GetRef();
-  AliESDEvent *esd = dynamic_cast<AliESDEvent*>(vevent);
-  if (!esd) {
-    AliError("ESD information unavailable");
-    return kTRUE;
-  }
-  
-  // check trigger mask
-  return esd->IsTriggerClassFired(fTrigger.Data());
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutESDTrigger::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*ev1*/, AliRsnEvent* /*ev2*/)
-{
-//
-// Cut checker
-//
-
-  AliWarning("Cannot apply this cut to event mixing");
-  return kTRUE;
-}
diff --git a/PWG2/RESONANCES/AliRsnCutESDTrigger.h b/PWG2/RESONANCES/AliRsnCutESDTrigger.h
deleted file mode 100644 (file)
index bfba1c2..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// Class AliRsnCutRange
-//
-// General implementation of cuts which check a value inside a range.
-// This range can be defined by two integers or two doubles.
-// A user-friendly enumeration allows to define what is checked.
-//
-// authors: Martin Vala (martin.vala@cern.ch)
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
-//
-
-#ifndef ALIRSNCUTESDTrigger_H
-#define ALIRSNCUTESDTrigger_H
-
-#include <TString.h>
-#include "AliRsnCut.h"
-
-class AliRsnCutESDTrigger : public AliRsnCut
-{
-  public:
-
-    AliRsnCutESDTrigger();
-    AliRsnCutESDTrigger(const char *name, const char *mask);
-    virtual ~AliRsnCutESDTrigger() {;};
-      
-    void    SetTriggerMask(const char *mask) {fTrigger = mask;}
-
-    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnDaughter* daughter);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnPairParticle *pair);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent * const event);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
-
-  protected:
-
-    TString fTrigger;  // trigger mask
-
-    ClassDef(AliRsnCutESDTrigger, 1)
-};
-
-#endif
diff --git a/PWG2/RESONANCES/AliRsnCutManager.cxx b/PWG2/RESONANCES/AliRsnCutManager.cxx
new file mode 100644 (file)
index 0000000..be93cf8
--- /dev/null
@@ -0,0 +1,99 @@
+//
+// Class AliRsnCutManager
+//
+// The cut manager: contains a complete set of cut definitions
+// to be applied to all possible targets (one for each target),
+// in order to ease the set-up procedure of cuts and allow to
+// pass them at once to each object which must use them
+//
+// author: Martin Vala (martin.vala@cern.ch)
+//
+
+#include "AliLog.h"
+
+#include "AliRsnCutManager.h"
+
+ClassImp(AliRsnCutManager)
+
+//_____________________________________________________________________________
+AliRsnCutManager::AliRsnCutManager() :
+  TNamed("defaultName", "defaultTitle"),
+  fMotherCuts(0x0)
+{
+//
+// Constructor without arguments.
+//
+
+  Int_t i;
+  for (i = 0; i < 3; i++) fDaughterCuts[i] = 0x0;
+}
+
+//_____________________________________________________________________________
+AliRsnCutManager::AliRsnCutManager(const char *name, const char *title) :
+  TNamed(name, title),
+  fMotherCuts(0x0)
+{
+//
+// Constructor with name and title.
+//
+
+  Int_t i;
+  for (i = 0; i < 3; i++) fDaughterCuts[i] = 0x0;
+}
+
+//_____________________________________________________________________________
+AliRsnCutManager::AliRsnCutManager(const AliRsnCutManager &cut) :
+  TNamed(cut),
+  fMotherCuts(cut.fMotherCuts)
+{
+//
+// Constructor with name and title.
+//
+
+  Int_t i;
+  for (i = 0; i < 3; i++) fDaughterCuts[i] = cut.fDaughterCuts[i];
+}
+
+AliRsnCutManager& AliRsnCutManager::operator=(const AliRsnCutManager &cut)
+{
+//
+// Assign operator
+//
+
+  SetName(cut.GetName());
+  SetTitle(cut.GetTitle());
+  
+  Int_t i;
+  for (i = 0; i < 3; i++) fDaughterCuts[i] = cut.fDaughterCuts[i];
+  
+  fMotherCuts = cut.fMotherCuts;
+  
+  return (*this);
+}
+
+//_____________________________________________________________________________
+AliRsnCutManager::~AliRsnCutManager()
+{
+//
+// Destructor.
+// Deletes all cut definitions.
+//
+
+  Int_t i;
+  for (i = 0; i < 3; i++) delete fDaughterCuts[i];
+  
+  delete fMotherCuts;
+}
+
+//_____________________________________________________________________________
+void AliRsnCutManager::SetEvent(AliRsnEvent *event)
+{
+//
+// Sets reference event in all cut sets
+//
+
+  Int_t i;
+  for (i = 0; i < 3; i++) if (fDaughterCuts[i]) fDaughterCuts[i]->SetEvent(event);
+  
+  if (fMotherCuts) fMotherCuts->SetEvent(event);
+}
diff --git a/PWG2/RESONANCES/AliRsnCutManager.h b/PWG2/RESONANCES/AliRsnCutManager.h
new file mode 100644 (file)
index 0000000..36cd541
--- /dev/null
@@ -0,0 +1,56 @@
+//
+// Class AliRsnCutManager
+//
+// The cut manager: contains a complete set of cut definitions
+// to be applied to all possible targets (one for each target),
+// in order to ease the set-up procedure of cuts and allow to
+// pass them at once to each object which must use them
+//
+// author: Martin Vala (martin.vala@cern.ch)
+//
+
+#ifndef ALIRSNCUTMANAGER_H
+#define ALIRSNCUTMANAGER_H
+
+#include <TNamed.h>
+
+#include "AliRsnCut.h"
+#include "AliRsnDaughter.h"
+#include "AliRsnMother.h"
+#include "AliRsnCutSet.h"
+
+class AliRsnCutManager : public TNamed
+{
+  public:
+
+    AliRsnCutManager();
+    AliRsnCutManager(const char *name, const char* title = "");
+    AliRsnCutManager(const AliRsnCutManager &cut);
+    AliRsnCutManager& operator=(const AliRsnCutManager& cut);
+    ~AliRsnCutManager();
+    
+    AliRsnCutSet*    GetCommonDaughterCuts() {return fDaughterCuts[2];}
+    AliRsnCutSet*    GetDaughter1Cuts() {return fDaughterCuts[0];}
+    AliRsnCutSet*    GetDaughter2Cuts() {return fDaughterCuts[1];}
+    AliRsnCutSet*    GetMotherCuts() {return fMotherCuts;}
+
+    void    SetCommonDaughterCuts(AliRsnCutSet *cuts) {fDaughterCuts[2] = cuts;}
+    void    SetDaughter1Cuts(AliRsnCutSet *cuts) {fDaughterCuts[0] = cuts;}
+    void    SetDaughter2Cuts(AliRsnCutSet *cuts) {fDaughterCuts[1] = cuts;}
+    void    SetMotherCuts(AliRsnCutSet *cuts) {fMotherCuts = cuts;}
+    void    SetEvent(AliRsnEvent *event);
+    
+    Bool_t  PassCommonDaughterCuts(AliRsnDaughter *daughter) const {if (fDaughterCuts[2]) return fDaughterCuts[2]->IsSelected(daughter); return kTRUE;}
+    Bool_t  PassDaughter1Cuts(AliRsnDaughter *daughter) const {if (fDaughterCuts[0]) return fDaughterCuts[0]->IsSelected(daughter); return kTRUE;}
+    Bool_t  PassDaughter2Cuts(AliRsnDaughter *daughter) const {if (fDaughterCuts[1]) return fDaughterCuts[1]->IsSelected(daughter); return kTRUE;}
+    Bool_t  PassMotherCuts(AliRsnMother *mother) {if (fMotherCuts) return fMotherCuts->IsSelected(mother); return kTRUE;}
+
+  private:
+
+    AliRsnCutSet  *fDaughterCuts[3]; //  single-track cuts ([0] --> only first dtr, [1] --> only second, [2] --> all)
+    AliRsnCutSet  *fMotherCuts;      //  mother cuts (on relations between daughters)
+
+    ClassDef(AliRsnCutManager, 1)  // dictionary
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnCutMgr.cxx b/PWG2/RESONANCES/AliRsnCutMgr.cxx
deleted file mode 100644 (file)
index 879b150..0000000
+++ /dev/null
@@ -1,117 +0,0 @@
-//
-// Class AliRsnCutMgr
-//
-// The cut manager: contains a complete set of cut definitions
-// to be applied to all possible targets (one for each target),
-// in order to ease the set-up procedure of cuts and allow to
-// pass them at once to each object which must use them
-//
-// author: Martin Vala (martin.vala@cern.ch)
-//
-
-#include "AliLog.h"
-
-#include "AliRsnCutSet.h"
-#include "AliRsnCutMgr.h"
-
-ClassImp(AliRsnCutMgr)
-
-//_____________________________________________________________________________
-AliRsnCutMgr::AliRsnCutMgr() :
-    TNamed("defaultName", "defaultTitle")
-{
-//
-// Constructor without arguments.
-//
-
-  Int_t i;
-  for (i = 0; i < AliRsnCut::kLastCutTarget; i++) {
-    fCutSets[i] = 0;
-  }
-}
-
-//_____________________________________________________________________________
-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;
-  }
-}
-
-//_____________________________________________________________________________
-AliRsnCutMgr::~AliRsnCutMgr()
-{
-//
-// Destructor.
-// Deletes all cut definitions.
-//
-
-  Int_t i;
-  for (i = 0; i < AliRsnCut::kLastCutTarget; i++) {
-    delete fCutSets[i];
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnCutMgr::SetCutSet(AliRsnCut::ETarget type, AliRsnCutSet* const 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()));
-}
-
-//_____________________________________________________________________________
-Bool_t AliRsnCutMgr::IsSelected(AliRsnCut::ETarget type, TObject*const 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
-// 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;
-}
-
-//_____________________________________________________________________________
-void AliRsnCutMgr::SetEvent(AliRsnEvent *event)
-{
-//
-// Sets reference event in all cut sets
-//
-
-  Int_t i;
-  for (i = 0; i < AliRsnCut::kLastCutTarget; i++)
-  {
-    if (fCutSets[i]) fCutSets[i]->SetEvent(event);
-  }
-}
-
diff --git a/PWG2/RESONANCES/AliRsnCutMgr.h b/PWG2/RESONANCES/AliRsnCutMgr.h
deleted file mode 100644 (file)
index a9f77a9..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// Class AliRsnCutMgr
-//
-// The cut manager: contains a complete set of cut definitions
-// to be applied to all possible targets (one for each target),
-// in order to ease the set-up procedure of cuts and allow to
-// pass them at once to each object which must use them
-//
-// author: Martin Vala (martin.vala@cern.ch)
-//
-
-#ifndef ALIRSNCUTMGR_H
-#define ALIRSNCUTMGR_H
-
-#include <TNamed.h>
-
-#include "AliRsnCut.h"
-
-class AliRsnCutSet;
-
-class AliRsnCutMgr : public TNamed
-{
-  public:
-
-    AliRsnCutMgr();
-    AliRsnCutMgr(const char *name, const char* title);
-    ~AliRsnCutMgr();
-
-    void          SetCutSet(AliRsnCut::ETarget type, AliRsnCutSet*const cutset);
-    AliRsnCutSet* GetCutSet(AliRsnCut::ETarget type) const {return fCutSets[type];}
-    Bool_t        IsSelected(AliRsnCut::ETarget type, TObject *const obj);
-    void          SetEvent(AliRsnEvent *event);
-
-  private:
-
-    // dummy constructors
-    AliRsnCutMgr(const AliRsnCutMgr &cut) : TNamed(cut) {}
-    AliRsnCutMgr& operator=(const AliRsnCutMgr& /*cut*/) {return *this;}
-
-    AliRsnCutSet *fCutSets[AliRsnCut::kLastCutTarget];  // cut definitions for all targets
-
-    ClassDef(AliRsnCutMgr, 1)  // dictionary
-};
-
-#endif
diff --git a/PWG2/RESONANCES/AliRsnCutPID.cxx b/PWG2/RESONANCES/AliRsnCutPID.cxx
new file mode 100644 (file)
index 0000000..5893879
--- /dev/null
@@ -0,0 +1,252 @@
+//
+// Class AliRsnCutPID
+//
+// General implementation of a single cut strategy, which can be:
+// - a value contained in a given interval  [--> IsBetween()   ]
+// - a value equal to a given reference     [--> MatchesValue()]
+//
+// In all cases, the reference value(s) is (are) given as data members
+// and each kind of cut requires a given value type (Int, UInt, Double),
+// but the cut check procedure is then automatized and chosen thanks to
+// an enumeration of the implemented cut types.
+// At the end, the user (or any other point which uses this object) has
+// to use the method IsSelected() to check if this cut has been passed.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+#include "TMath.h"
+
+#include "AliExternalTrackParam.h"
+
+#include "AliRsnDaughter.h"
+#include "AliRsnCutPID.h"
+
+ClassImp(AliRsnCutPID)
+
+//_________________________________________________________________________________________________
+AliRsnCutPID::AliRsnCutPID() :
+  AliRsnCut(AliRsnCut::kDaughter),
+  fPerfect(kFALSE),
+  fUseDefault(kTRUE)
+{
+//
+// Default constructor.
+// Sets the cut to realistic PID with default weights,
+// and defines the 'fMinI' value of the base class as the PID
+// to which we want to compare this object.
+//
+
+  Int_t i;
+  
+  for (i = 0; i < kDetectors; i++) 
+  {
+    fUseDetector[i] = kFALSE;
+    fPtThreshold[i] = 0.0;
+    fGoAboveThreshold[i] = kTRUE;
+  }
+  
+  for (i = 0; i < AliPID::kSPECIES; i++)
+  {
+    fWeight[i] = 0.0;
+    fPrior[i] = 1.0;
+  }
+}
+
+//_________________________________________________________________________________________________
+AliRsnCutPID::AliRsnCutPID(const char *name, AliPID::EParticleType pid, Double_t probMin, Bool_t perfectPID) :
+  AliRsnCut(name, AliRsnCut::kDaughter, (Int_t)pid),
+  fPerfect(perfectPID),
+  fUseDefault(kTRUE)
+{
+//
+// Default constructor.
+// Sets the cut to realistic PID with default weights,
+// and defines the 'fMinI' value of the base class as the PID
+// to which we want to compare this object.
+//
+
+  Int_t i;
+  
+  for (i = 0; i < kDetectors; i++) 
+  {
+    fUseDetector[i] = kFALSE;
+    fPtThreshold[i] = 0.0;
+    fGoAboveThreshold[i] = kTRUE;
+  }
+  
+  for (i = 0; i < AliPID::kSPECIES; i++)
+  {
+    fWeight[i] = 0.0;
+    fPrior[i] = 1.0;
+  }
+  
+  fMinD = probMin;
+  fMaxD = 1.000001;
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnCutPID::CheckThreshold(EDetector det, Double_t value)
+{
+//
+// Checks if the passed value (track pT) stays in the 
+// interval where the detector should be accepted
+//
+
+  if (!CheckBounds(det)) return kFALSE;
+  
+  if (fGoAboveThreshold[det]) return (value >= fPtThreshold[det]);
+  else return (value <= fPtThreshold[det]);
+}
+
+//_________________________________________________________________________________________________
+Bool_t AliRsnCutPID::ComputeWeights(AliRsnDaughter *daughter)
+{
+//
+// Compute the PID weights using the class settings.
+// If the argument is an ESD track, customized weights can be computed
+// It the argument is a track (ESD or AOD), at least default weights
+// can be computed, otherwise, no weights can be defined.
+// The return value tells if the operation was successful.
+//
+
+  Int_t  i, j;
+  Bool_t useDefault = fUseDefault;
+  Bool_t perfectPID = fPerfect;
+  if (perfectPID && !daughter->GetRefMC()) perfectPID = kFALSE;
+  if (!daughter->GetRefESDtrack()) useDefault = kTRUE;
+  if (!daughter->GetRefESDtrack() && !daughter->GetRefAODtrack()) return kFALSE;
+  
+  // if perfect PID ise required, this overcomes all
+  // in this case the weight of the correct species is set to 1
+  // and the others to 0
+  // of course this happens only if there is a reference MC
+  if (perfectPID)
+  {
+    j = TMath::Abs(daughter->GetRefMC()->Particle()->GetPdgCode());
+    for (i = 0; i < AliPID::kSPECIES; i++)
+    {
+      if (AliPID::ParticleCode((AliPID::EParticleType)i) == j) fWeight[i] = 1.0;
+      else fWeight[i] = 0.0;
+    }
+    return kTRUE;
+  }
+  
+  // if default weights are (or need to be) used,
+  // they are taken directly and function exits
+  if (useDefault)
+  {
+    if (daughter->GetRefESDtrack())
+      daughter->GetRefESDtrack()->GetESDpid(fWeight);
+    else
+    {
+      for (i = 0; i < AliPID::kSPECIES; i++)
+        fWeight[i] = daughter->GetRefAODtrack()->PID()[i];
+    }
+    return kTRUE;
+  }
+  
+  // if we arrive here, this means that we have an ESD track
+  // and we want to customize the PID
+  AliESDtrack *track = daughter->GetRefESDtrack();
+  Double_t     w[kDetectors][AliPID::kSPECIES];
+  track->GetITSpid(w[kITS]);
+  track->GetTPCpid(w[kTPC]);
+  track->GetTRDpid(w[kTRD]);
+  track->GetTOFpid(w[kTOF]);
+  track->GetHMPIDpid(w[kHMPID]);
+
+  // if a detector is excluded or the track has not the right pT
+  // all related weights are set to 1 in order not to contribute
+  // to final multiplication
+  for (i = 0; i < kDetectors; i++) 
+  {
+    if (!fUseDetector[i] || !CheckThreshold((EDetector)i, track->Pt())) 
+    {
+      for (j = 0; j < AliPID::kSPECIES; j++) {
+        w[i][j] = 1.0;
+      }
+    }
+  }
+
+  // multiplicate all weights to compute final one
+  for (i = 0; i < AliPID::kSPECIES; i++) 
+  {
+    fWeight[i] = w[kITS][i] * w[kTPC][i] * w[kTRD][i] * w[kTOF][i] * w[kHMPID][i];
+  }
+  
+  return kTRUE;
+}
+
+//_________________________________________________________________________________________________
+Bool_t AliRsnCutPID::IsSelected(TObject *obj1, TObject* /*obj2*/)
+{
+//
+// Cut checker.
+//
+
+  // coherence check
+  if (!AliRsnCut::TargetOK(obj1))
+  {
+    AliError(Form("Wrong target. Skipping cut", GetName()));
+    return kTRUE;
+  }
+  
+  // convert the object into the unique correct type
+  AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(obj1);
+  
+  // try to compute the weights
+  if (!ComputeWeights(daughter)) return kFALSE;
+  
+  // combine with priors and get the majority
+  Int_t    i;
+  Double_t sum = 0.0, w[AliPID::kSPECIES];
+  for (i = 0; i < AliPID::kSPECIES; i++)
+  {
+    w[i] = fWeight[i] * fPrior[i];
+    sum += w[i];
+  }
+  if (sum <= 0.0)
+  {
+    AliError("Sum = 0");
+    return kFALSE;
+  }
+  for (i = 0; i < AliPID::kSPECIES; i++) w[i] /= sum;
+  
+  // find the largest probability and related PID
+  // and assign them to the mother class members which
+  // are checked for the cut
+  fCutValueI = 0;
+  fCutValueD = w[0];
+  for (i = 1; i < AliPID::kSPECIES; i++)
+  {
+    if (w[i] > fCutValueD) 
+    {
+      fCutValueD = w[i];
+      fCutValueI = i;
+    }
+  }
+  
+  // if the best probability is too small, the cut is failed anyway
+  if (!OkRangeD()) return kFALSE;
+  
+  // if the best probability is OK, the cut is passed
+  // if it correspond to the right particle
+  return OkValue();
+}
+
+void AliRsnCutPID::IncludeDetector(EDetector det, Double_t threshold, Bool_t goAbove)
+{
+//
+// Include a detector for a customized weight computing
+// and specify also its eventual threshold and if the detector
+// must be used above or below the threshold.
+// By default the threshold is zero and detector is always used.
+//
+
+  if (!CheckBounds(det)) return;
+  
+  fUseDetector[det] = kTRUE;
+  fPtThreshold[det] = threshold;
+  fGoAboveThreshold[det] = goAbove;
+}
diff --git a/PWG2/RESONANCES/AliRsnCutPID.h b/PWG2/RESONANCES/AliRsnCutPID.h
new file mode 100644 (file)
index 0000000..1ce587a
--- /dev/null
@@ -0,0 +1,65 @@
+//
+// Class AliRsnCutRange
+//
+// General implementation of cuts which check a value inside a range.
+// This range can be defined by two integers or two doubles.
+// A user-friendly enumeration allows to define what is checked.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#ifndef ALIRSNCUTPID_H
+#define ALIRSNCUTPID_H
+
+#include "AliPID.h"
+#include "AliRsnCut.h"
+
+class AliRsnDaughter;
+
+class AliRsnCutPID : public AliRsnCut
+{
+  public:
+    
+    enum EDetector 
+    {
+      kITS,
+      kTPC,
+      kTRD,
+      kTOF,
+      kHMPID,
+      kDetectors
+    };
+
+    AliRsnCutPID();
+    AliRsnCutPID(const char *name, AliPID::EParticleType pid, Double_t probMin = 0.0, Bool_t perfectPID = kFALSE);
+    virtual ~AliRsnCutPID() {;};
+    
+    void           SetDefault(Bool_t yn = kTRUE) {fUseDefault = yn;}
+    void           SetPrior(Int_t i, Double_t value) {if (i >= 0 && i < AliPID::kSPECIES) fPrior[i] = value;}
+    void           SetPerfect(Bool_t yn = kTRUE) {fPerfect = yn;}
+    
+    void           IncludeDetector(EDetector det, Double_t threshold = 0., Bool_t goAbove = kTRUE);
+    void           ExcludeDetector(EDetector det) {if (CheckBounds(det)) fUseDetector[det] = kFALSE;}
+
+    virtual Bool_t IsSelected(TObject *obj1, TObject *obj2 = 0x0);
+
+  protected:
+  
+    Bool_t   CheckBounds(EDetector det) const {return (det >= kITS && det < kDetectors);}
+    Bool_t   CheckThreshold(EDetector det, Double_t value);
+    Bool_t   ComputeWeights(AliRsnDaughter *daughter);
+    
+    Double_t              fPrior[AliPID::kSPECIES];        // prior probability
+    Double_t              fWeight[AliPID::kSPECIES];       // PID weights used for combinations
+  
+    Bool_t                fPerfect;                        // choice to use perfect PID
+    Bool_t                fUseDefault;                     // choice to use default combined PID weights (or customized)
+    Bool_t                fUseDetector[kDetectors];        // flag to include/exclude each single detector
+    Double_t              fPtThreshold[kDetectors];        // pT threshold above/below which a detector is considered
+    Double_t              fGoAboveThreshold[kDetectors];   // to choose if detector is used balow or above threshold
+
+    ClassDef(AliRsnCutPID, 1)
+};
+
+#endif
index b11c4433de91ada54530fabfb233ef5a5d8aeac9..694b252f935cd54ce5d7fe099766158ed8f83d86 100644 (file)
@@ -14,8 +14,8 @@ ClassImp(AliRsnCutPrimaryVertex)
 
 //_________________________________________________________________________________________________
 AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex() :
-    AliRsnCut(),
-    fAcceptTPC(kFALSE)
+  AliRsnCut(AliRsnCut::kEvent),
+  fAcceptTPC(kFALSE)
 {
 //
 // Default constructor.
@@ -25,8 +25,8 @@ AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex() :
 //_________________________________________________________________________________________________
 AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex
 (const char *name, Int_t nContributors, Bool_t acceptTPC) :
-    AliRsnCut(name, 0, nContributors - 1),
-    fAcceptTPC(acceptTPC)
+  AliRsnCut(name, AliRsnCut::kEvent, 0, nContributors - 1),
+  fAcceptTPC(acceptTPC)
 {
 //
 // Main constructor.
@@ -45,36 +45,16 @@ AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutPrimaryVertex::IsSelected(AliRsnCut::ETarget /*tgt*/, AliRsnDaughter*/*const track*/)
-{
-//
-// Cut checker.
-//
-
-  AliWarning("Cannot apply this cut to particles");
-  return kTRUE;
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutPrimaryVertex::IsSelected(AliRsnCut::ETarget, AliRsnPairParticle*/*const pair*/)
-{
-//
-// Cut checker
-//
-
-  AliWarning("Cannot apply this cut to pairs");
-  return kTRUE;
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutPrimaryVertex::IsSelected(AliRsnCut::ETarget, AliRsnEvent*event)
+Bool_t AliRsnCutPrimaryVertex::IsSelected(TObject *obj1, TObject* /*obj2*/)
 {
 //
 // Cut checker
 //
 
   // retrieve ESD event
-  AliESDEvent *esd = dynamic_cast<AliESDEvent*>(event->GetRef());
+  AliRsnEvent *rsn = dynamic_cast<AliRsnEvent*>(obj1);
+  if (!rsn) return kFALSE;
+  AliESDEvent *esd = dynamic_cast<AliESDEvent*>(rsn->GetRef());
   if (!esd) {
     AliDebug(AliLog::kDebug+2, "NO ESD");
     return kFALSE;
@@ -114,13 +94,3 @@ Bool_t AliRsnCutPrimaryVertex::IsSelected(AliRsnCut::ETarget, AliRsnEvent*event)
   return /*there is a NOT operator */!/*here*/OkRange();
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutPrimaryVertex::IsSelected(AliRsnCut::ETarget, AliRsnEvent*/*ev1*/, AliRsnEvent*/*ev2*/)
-{
-//
-// Cut checker
-//
-
-  AliWarning("Cannot apply this cut to event mixing");
-  return kTRUE;
-}
index fe9bac464566117422e91f8e5daa18763652feb3..3a8826606f21e4557f5ca0e9fc575904740dd865 100644 (file)
@@ -34,10 +34,7 @@ class AliRsnCutPrimaryVertex : public AliRsnCut
     AliRsnCutPrimaryVertex(const char *name, Int_t minContributors, Bool_t acceptTPC = kFALSE);
     virtual ~AliRsnCutPrimaryVertex() {;};
 
-    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnDaughter *daughter);
-    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnPairParticle *pair);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *event);
-    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
+    virtual Bool_t IsSelected(TObject *obj1, TObject *obj2 = 0x0);
 
   protected:
 
index 798059a3868cb89704b923e5a38d5b93c75bbcc2..584a12da210f9f4de546f8f26921d999b6fdc234 100644 (file)
@@ -9,7 +9,6 @@
 
 #include "AliLog.h"
 
-#include "AliRsnCut.h"
 #include "AliRsnExpression.h"
 
 #include "AliRsnCutSet.h"
 ClassImp(AliRsnCutSet)
 
 //_____________________________________________________________________________
-AliRsnCutSet::AliRsnCutSet() :
-    TNamed(),
-    fCuts(0),
-    fNumOfCuts(0),
-    fCutScheme(""),
-    fCutSchemeIndexed(""),
-    fBoolValues(0),
-    fIsScheme(kFALSE),
-    fExpression(0)
+AliRsnCutSet::AliRsnCutSet(AliRsnCut::ETarget target) :
+  TNamed(),
+  fTarget(target),
+  fCuts(0),
+  fNumOfCuts(0),
+  fCutScheme(""),
+  fCutSchemeIndexed(""),
+  fBoolValues(0),
+  fIsScheme(kFALSE),
+  fExpression(0)
 {
 //
 // Constructor without name (not recommended)
@@ -36,15 +36,16 @@ AliRsnCutSet::AliRsnCutSet() :
 }
 
 //_____________________________________________________________________________
-AliRsnCutSet::AliRsnCutSet(TString name) :
-    TNamed(name, name),
-    fCuts(0),
-    fNumOfCuts(0),
-    fCutScheme(""),
-    fCutSchemeIndexed(""),
-    fBoolValues(0),
-    fIsScheme(kFALSE),
-    fExpression(0)
+AliRsnCutSet::AliRsnCutSet(TString name, AliRsnCut::ETarget target) :
+  TNamed(name, name),
+  fTarget(target),
+  fCuts(0),
+  fNumOfCuts(0),
+  fCutScheme(""),
+  fCutSchemeIndexed(""),
+  fBoolValues(0),
+  fIsScheme(kFALSE),
+  fExpression(0)
 {
 //
 // Constructor with argument name (recommended)
@@ -57,14 +58,15 @@ AliRsnCutSet::AliRsnCutSet(TString name) :
 
 //_____________________________________________________________________________
 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)
+  TNamed((TNamed) copy),
+  fTarget(copy.fTarget),
+  fCuts(copy.fCuts),
+  fNumOfCuts(copy.fNumOfCuts),
+  fCutScheme(copy.fCutScheme),
+  fCutSchemeIndexed(copy.fCutSchemeIndexed),
+  fBoolValues(0),
+  fIsScheme(copy.fIsScheme),
+  fExpression(copy.fExpression)
 {
 //
 // Copy constructor
@@ -89,9 +91,17 @@ void AliRsnCutSet::AddCut(AliRsnCut *cut)
 {
 //
 // Add a new cut.
-// This must be done for all components of the final expression
+// This must be done for all components of the final expression.
+// If the target of the cut does not match the target of this,
+// the cut is not added.
 //
 
+  if (!cut->IsTarget(fTarget))
+  {
+    AliError("Cut target does not match the cut-set target. Not added.");
+    return;
+  }
+
   Int_t i;
 
   AliDebug(AliLog::kDebug,"<-");
@@ -101,7 +111,8 @@ void AliRsnCutSet::AddCut(AliRsnCut *cut)
   if (fBoolValues) delete [] fBoolValues;
 
   fBoolValues = new Bool_t[fNumOfCuts];
-  for (i = 0; i < fNumOfCuts; i++) {
+  for (i = 0; i < fNumOfCuts; i++) 
+  {
     fBoolValues[i] = kTRUE;
   }
 
@@ -115,94 +126,31 @@ void AliRsnCutSet::ShowCuts() const
 //
 // Prints all cuts
 //
-//   AliRsnCut *cut;
-//   for (Int_t i=0; i<fCuts.GetEntriesFast() ;i++)
-//   {
-//     cut = (AliRsnCut*) fCuts.At (i);
-//     AliInfo (Form ("%s (\"%s\") [%.2f - %.2f]",cut->GetName(),cut->GetTitle(),cut->GetMin(),cut->GetMax()));
-//   }
-}
-
-//_____________________________________________________________________________
-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;
-}
-
-//_____________________________________________________________________________
-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;
-}
-
-//_____________________________________________________________________________
-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);
+  
+  for (Int_t i = 0; i < fCuts.GetEntriesFast() ;i++)
+  {
+    cut = (AliRsnCut*)fCuts.At (i);
+    cut->Print();
   }
-
-  if (fIsScheme) boolReturn = Passed();
-  return boolReturn;
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnCutSet::IsSelected(AliRsnCut::ETarget type, AliRsnEvent * ev1, AliRsnEvent *ev2)
+Bool_t AliRsnCutSet::IsSelected(TObject *obj1, TObject *obj2)
 {
 //
 // 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,ev1,ev2);
+    cut = (AliRsnCut*)fCuts.At(i);
+    fBoolValues[i] = cut->IsSelected(obj1, obj2);
   }
 
   if (fIsScheme) boolReturn = Passed();
index a663716178c81e9d13527b33633385fd97c391c3..f49a9af5845d5586a356fcbc559eaea053f0954d 100644 (file)
@@ -26,8 +26,8 @@ class AliRsnCutSet : public TNamed
 {
   public:
 
-    AliRsnCutSet();
-    AliRsnCutSet(TString name);
+    AliRsnCutSet(AliRsnCut::ETarget target = AliRsnCut::kLastCutTarget);
+    AliRsnCutSet(TString name, AliRsnCut::ETarget target);
     AliRsnCutSet(const AliRsnCutSet &copy);
     AliRsnCutSet& operator=(const AliRsnCutSet& /*copy*/) {return (*this);}
     ~AliRsnCutSet();
@@ -42,10 +42,7 @@ class AliRsnCutSet : public TNamed
     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, AliRsnEvent *ev1, AliRsnEvent *ev2);
+    Bool_t    IsSelected(TObject *obj1, TObject *obj2 = 0x0);
 
     void SetBoolValue(Bool_t theValue,Int_t index) { fBoolValues[index] = theValue; }
     Bool_t GetBoolValue(Int_t index) const { return fBoolValues[index]; }
@@ -62,6 +59,7 @@ class AliRsnCutSet : public TNamed
 
   private:
 
+    AliRsnCut::ETarget fTarget;  // cut target
     TObjArray     fCuts;                  // array of cuts
     Int_t         fNumOfCuts;             // number of cuts
     TString       fCutScheme;             // cut scheme
index fc3c066370c8d2c9cdbf09efda5bb8f823ce1c64..3891851a6a49ecc4178961c55aeb7806c3ccb1eb 100644 (file)
 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
-#include "TParticle.h"
-#include "TMath.h"
+#include <TMath.h>
+#include <TLorentzVector.h>
 
 #include "AliRsnDaughter.h"
+#include "AliRsnMother.h"
 #include "AliRsnEvent.h"
-#include "AliRsnPairParticle.h"
 
 #include "AliRsnCutStd.h"
 
@@ -29,10 +29,10 @@ ClassImp(AliRsnCutStd)
 
 //_________________________________________________________________________________________________
 AliRsnCutStd::AliRsnCutStd() :
-    AliRsnCut(),
-    fType(kLastType),
-    fUseMC(kFALSE),
-    fMass(0.0)
+  AliRsnCut(),
+  fType(kLastType),
+  fUseMC(kFALSE),
+  fMass(0.0)
 {
 //
 // Default constructor.
@@ -41,68 +41,51 @@ AliRsnCutStd::AliRsnCutStd() :
 
 //_________________________________________________________________________________________________
 AliRsnCutStd::AliRsnCutStd
-(const char *name, EType type, Int_t val1, Int_t val2, Bool_t useMC) :
-    AliRsnCut(name, val1, val2),
-    fType(type),
-    fUseMC(useMC),
-    fMass(0.0)
+(const char *name, ETarget target, EType type, Int_t val1, Int_t val2, Bool_t useMC) :
+  AliRsnCut(name, target, val1, val2),
+  fType(type),
+  fUseMC(useMC),
+  fMass(0.0)
 {
 //
 // Main constructor.
 // Checks also that cut values are given in the correct type,
 // in order to avoid that one passes, for example, a value which should be double
-// but is interpreted as integer due to the overloading of constructors
+// but is interpreted as integer due to the overloading of constructors.
 //
 
-  switch (fType) {
+  switch (fType) 
+  {
     // int
-  case kMult:
-  case kMultDiff:
-  case kKink:
-  case kKinkMother:
-  case kAssignedPID:
-  case kTruePID:
-  case kRequiredPID:
-  case kCharge:
-    break;
-    // ulong
-  case kStatus:
-    if (fVarType != kULong) {
-      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
-      SetRange((ULong_t)val1, (ULong_t)val2);
-      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' ULONG range = %lu, %lu", GetName(), fMinU, fMaxU));
-    }
-    break;
+    case kMult:
+    case kCharge:
+      break;
     // double
-  case kP:
-  case kPt:
-  case kEta:
-  case kY:
-  case kThetaDeg:
-  case kDr:
-  case kDz:
-  case kTPCsignal:
-  case kMultDiffRel:
-  case kVzDiff:
-    if (fVarType != kDouble) {
-      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
-      SetRange((Double_t)val1, (Double_t)val2);
-      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
-    }
-    break;
+    case kP:
+    case kPt:
+    case kEta:
+    case kY:
+    case kThetaDeg:
+      if (fVarType != kDouble) 
+      {
+        AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
+        SetRange((Double_t)val1, (Double_t)val2);
+        AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
+      }
+      break;
     // other cuts are not based on a value, so no problem
-  default:
-    break;
+    default:
+      break;
   }
 }
 
 //_________________________________________________________________________________________________
 AliRsnCutStd::AliRsnCutStd
-(const char *name, EType type, ULong_t val1, ULong_t val2, Bool_t useMC) :
-    AliRsnCut(name, val1, val2),
-    fType(type),
-    fUseMC(useMC),
-    fMass(0.0)
+(const char *name, ETarget target, EType type, Double_t val1, Double_t val2, Bool_t useMC) :
+  AliRsnCut(name, target, val1, val2),
+  fType(type),
+  fUseMC(useMC),
+  fMass(0.0)
 {
 //
 // Main constructor.
@@ -111,280 +94,163 @@ AliRsnCutStd::AliRsnCutStd
 // but is interpreted as integer due to the overloading of constructors
 //
 
-  switch (fType) {
+  switch (fType) 
+  {
     // int
-  case kMult:
-  case kMultDiff:
-  case kKink:
-  case kKinkMother:
-  case kAssignedPID:
-  case kTruePID:
-  case kRequiredPID:
-  case kCharge:
-    if (fVarType != kInt) {
-      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
-      SetRange((Int_t)val1, (Int_t)val2);
-      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
-    }
-    break;
-    // ulong
-  case kStatus:
-    break;
+    case kMult:
+    case kCharge:
+      if (fVarType != kInt) 
+      {
+        AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
+        SetRange((Int_t)val1, (Int_t)val2);
+        AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
+      }
+      break;
     // double
-  case kP:
-  case kPt:
-  case kEta:
-  case kY:
-  case kThetaDeg:
-  case kDr:
-  case kDz:
-  case kTPCsignal:
-  case kMultDiffRel:
-  case kVzDiff:
-    if (fVarType != kDouble) {
-      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
-      SetRange((Double_t)val1, (Double_t)val2);
-      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
-    }
-    break;
+    case kP:
+    case kPt:
+    case kEta:
+    case kY:
+    case kThetaDeg:
+      break;
     // other cuts are not based on a value, so no problem
-  default:
-    break;
+    default:
+      break;
   }
 }
 
 //_________________________________________________________________________________________________
-AliRsnCutStd::AliRsnCutStd
-(const char *name, EType type, Double_t val1, Double_t val2, Bool_t useMC) :
-    AliRsnCut(name, val1, val2),
-    fType(type),
-    fUseMC(useMC),
-    fMass(0.0)
+AliRsnCut::EVarType AliRsnCutStd::CheckType()
 {
 //
-// Main constructor.
-// Checks also that cut values are given in the correct type,
-// in order to avoid that one passes, for example, a value which should be double
-// but is interpreted as integer due to the overloading of constructors
+// Returns the variable type expected for the selected cut type
 //
 
-  switch (fType) {
-    // int
-  case kMult:
-  case kMultDiff:
-  case kKink:
-  case kKinkMother:
-  case kAssignedPID:
-  case kTruePID:
-  case kRequiredPID:
-  case kCharge:
-    if (fVarType != kInt) {
-      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
-      SetRange((Int_t)val1, (Int_t)val2);
-      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
-    }
-    break;
-    // ulong
-  case kStatus:
-    if (fVarType != kULong) {
-      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
-      SetRange((ULong_t)val1, (ULong_t)val2);
-      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' ULONG range = %lu, %lu", GetName(), fMinU, fMaxU));
-    }
-    break;
-    // double
-  case kP:
-  case kPt:
-  case kEta:
-  case kY:
-  case kThetaDeg:
-  case kDr:
-  case kDz:
-  case kTPCsignal:
-  case kMultDiffRel:
-  case kVzDiff:
-    break;
+  switch (fType) 
+  {
+    // integer cuts
+    case kMult:
+    case kCharge:
+      return kInt;
+    // double couts
+    case kP:
+    case kPt:
+    case kEta:
+    case kY:
+    case kThetaDeg:
+      return kDouble;
     // other cuts are not based on a value, so no problem
-  default:
-    break;
+    default:
+      return kNoVar;
   }
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnDaughter * const track)
+Bool_t AliRsnCutStd::IsSelected(TObject *obj1, TObject *obj2)
 {
-//
-// Cut checker.
-//
-
-  // coherence check
-  if (tgt != AliRsnCut::kParticle) {
-    AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
-    return kTRUE;
-  }
-
-
-  // if MC info is required, try to retrieve the TParticle:
-  // if it is not present, the cut is skipped
-  // this avoids to raise a seg-fault when accessing the NULL TParticle object
-  TParticle *part = 0x0;
-  if (fUseMC) {
-    part = track->GetParticle();
-    if (!part) {
-      AliError("Required MC info but it is not present. Cut Skipped.");
-      return kTRUE;
-    }
-  }
-
-  // loop on allowed possibilities
-  switch (fType) {
-  case kP:
-    fCutValueD = fUseMC ? part->P() : track->P();
-    return OkRange();
-  case kPt:
-    fCutValueD = fUseMC ? part->Pt() : track->Pt();
-    return OkRange();
-  case kThetaDeg:
-    fCutValueD = track->ThetaDeg();
-    return OkRange();
-  case kEta:
-    fCutValueD = fUseMC ? part->Eta() : track->Eta();
-    return OkRange();
-  case kDr:
-    fCutValueD = track->Dr();
-    return OkRange();
-  case kDz:
-    fCutValueD = track->Dz();
-    return OkRange();
-  case kStatus:
-    fCutValueU = track->GetStatus();
-    return OkValue();
-  case kKink:
-    fCutValueI = track->IsKink();
-    return OkValue();
-  case kKinkMother:
-    fCutValueI = track->IsKinkMother();
-    return OkValue();
-  case kCharge:
-    fCutValueI = (Int_t)track->Charge();
-    return OkValue();
-  case kTruePID:
-    fCutValueI = (Int_t)track->PerfectPID();
-    return OkValue();
-  case kAssignedPID:
-    fCutValueI = (Int_t)track->AssignedPID();
-    return OkValue();
-  case kRequiredPID:
-    fCutValueI = (Int_t)track->RequiredPID();
-    return OkValue();
-  case kRealisticPID:
-    fCutValueI = (Int_t)track->RealisticPID();
-    return OkValue();
-  case kPairIndex:
-    fCutValueI = track->PairIndex();
-    return OkValue();
-  case kTruePIDMatch:
-    return (track->PerfectPID() == track->RequiredPID());
-  case kRealisticPIDMatch:
-    return (track->RealisticPID() == track->RequiredPID());
-  default:
-    AliWarning(Form("Value %d is not included in available cuts for DAUGHTER. Cut skipped.", fType));
+  // coherence check using the mother class method
+  if (!TargetOK(obj1, obj2)) 
+  {
+    AliError("Wrong target. Skipping cut");
     return kTRUE;
   }
+  
+  // if coherence check is OK, only one of the following
+  // dynamic casts will be successful, and it will trigger
+  // the correct internal method to check the cut
+  AliRsnDaughter *objD = dynamic_cast<AliRsnDaughter*>(obj1);
+  AliRsnMother   *objM = dynamic_cast<AliRsnMother*>(obj1);
+  AliRsnEvent    *objE = dynamic_cast<AliRsnEvent*>(obj1);  
+  if (objD) return IsDaughterSelected(objD);
+  else if (objM) return IsMotherSelected(objM);
+  else if (objE) return IsEventSelected(objE);
+  else return kTRUE;
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnPairParticle * const pair)
+Bool_t AliRsnCutStd::IsDaughterSelected(AliRsnDaughter *daughter)
 {
 //
-// Cut checker
+// Cut checker.
 //
 
-  // coherence check
-  if (tgt != AliRsnCut::kPair) {
-    AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
-    return kTRUE;
-  }
+  // get the correct reference object for kinematic cuts
+  // and check that this reference is not NULL, to avoid segfaults
+  AliVParticle *ref = fUseMC ? daughter->GetRefMC() : daughter->GetRef();
 
   // loop on allowed possibilities
-  switch (fType) {
-  case kP:
-    fCutValueD = (fUseMC ? pair->GetPMC() : pair->GetP());
-    return OkRange();
-  case kPt:
-    fCutValueD = (fUseMC ? pair->GetPtMC() : pair->GetPt());
-    return OkRange();
-  case kEta:
-    fCutValueD = (fUseMC ? pair->GetEtaMC() : pair->GetEta());
-    return OkRange();
-  case kY:
-    fCutValueD = (fUseMC ? pair->GetYMC(fMass) : pair->GetY(fMass));
-    return OkRange();
-  case kSameLabel:
-    return pair->IsLabelEqual();
-  case kTruePair:
-    fCutValueI = TMath::Abs(pair->CommonMother());
-    return OkValue();
-  default:
-    AliWarning(Form("Value %d is not included in available cuts for PAIR. Cut skipped.", fType));
-    return kTRUE;
+  switch (fType) 
+  {
+    case kP:
+      fCutValueD = ref->P();
+      return OkRange();
+    case kPt:
+      fCutValueD = ref->Pt();
+      return OkRange();
+    case kThetaDeg:
+      fCutValueD = ref->Theta() * TMath::RadToDeg();
+      return OkRange();
+    case kEta:
+      fCutValueD = ref->Eta();
+      return OkRange();
+    case kCharge:
+      fCutValueI = (Int_t)ref->Charge();
+      return OkValue();
+    default:
+      AliWarning(Form("Value %d is not included in available cuts for DAUGHTER. Cut skipped.", fType));
+      return kTRUE;
   }
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent * const event)
+Bool_t AliRsnCutStd::IsMotherSelected(AliRsnMother * const mother)
 {
 //
 // Cut checker
 //
-
-  // coherence check
-  if (tgt != AliRsnCut::kEvent) {
-    AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
-    return kTRUE;
-  }
-
+  
+  // use MC flag if required
+  TLorentzVector &sum = fUseMC ? mother->SumMC() : mother->Sum();
+  TLorentzVector &ref = fUseMC ? mother->RefMC() : mother->Ref();
+  
   // loop on allowed possibilities
-  switch (fType) {
-  case kMult:
-    fCutValueI = event->GetMultiplicity();
-    return OkRange();
-  default:
-    AliWarning(Form("Value %d is not included in available cuts for EVENT. Cut skipped.", fType));
-    return kTRUE;
+  switch (fType) 
+  {
+    case kP:
+      fCutValueD = sum.P();
+      return OkRange();
+    case kPt:
+      fCutValueD = sum.Perp();
+      return OkRange();
+    case kEta:
+      fCutValueD = sum.Eta();
+      return OkRange();
+    case kY:
+      fCutValueD = ref.Rapidity();
+      return OkRange();
+    case kSameLabel:
+      return mother->IsLabelEqual();
+    default:
+      AliWarning(Form("Value %d is not included in available cuts for PAIR. Cut skipped.", fType));
+      return kTRUE;
   }
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent * const ev1, AliRsnEvent * const ev2)
+Bool_t AliRsnCutStd::IsEventSelected(AliRsnEvent * const event)
 {
 //
 // Cut checker
 //
 
-  // coherence check
-  if (tgt != AliRsnCut::kMixEvent) {
-    AliError(Form("[%s] Wrong target. Skipping cut", GetName()));
-    return kTRUE;
-  }
-
   // loop on allowed possibilities
-  Double_t mult1, mult2;
-  switch (fType) {
-  case kMultDiff:
-    fCutValueI = TMath::Abs(ev1->GetMultiplicity() - ev2->GetMultiplicity());
-    return OkRange();
-  case kMultDiffRel:
-    mult1 = (Double_t)ev1->GetMultiplicity();
-    mult2 = (Double_t)ev2->GetMultiplicity();
-    if (mult1 == 0.0  && mult2 == 0.0) return kTRUE;
-    fCutValueD = 100.0 * TMath::Abs(mult1 - mult2) / TMath::Max(mult1, mult2); // in %
-    return OkRange();
-  case kVzDiff:
-    fCutValueD = TMath::Abs(ev1->GetVz() - ev2->GetVz());
-    return OkRange();
-  default:
-    AliWarning(Form("Value %d is not included in available cuts for MIXEVENT. Cut skipped.", fType));
-    return kTRUE;
+  switch (fType) 
+  {
+    case kMult:
+      fCutValueI = event->GetMultiplicity();
+      return OkRange();
+    default:
+      AliWarning(Form("Value %d is not included in available cuts for EVENT. Cut skipped.", fType));
+      return kTRUE;
   }
 }
index 6c4e645579d5eaa5927d7bf23390b5c09f922b61..b7e3d898a4de9285cf47ba3db3159652e6149eb7 100644 (file)
 
 #include "AliRsnCut.h"
 
+class AliRsnDaughter;
+class AliRsnMother;
+class AliRsnEvent;
+
 class AliRsnCutStd : public AliRsnCut
 {
   public:
 
     // available cut types
     // some ones work both for pairs and single tracks
-    enum EType {
+    enum EType 
+    {
       kP = 0,
       kPt,
       kEta,
       kY,
       kThetaDeg,
-      kDr,
-      kDz,
-      kTPCsignal,
       kMult,
-      kMultDiff,
-      kMultDiffRel,
-      kVzDiff,
-      // value cuts
-      kStatus,
-      kKink,
-      kKinkMother,
-      kAssignedPID,
-      kTruePID,
-      kRequiredPID,
-      kRealisticPID,
-      kPairIndex,
       // cut without reference values
       kCharge,
       kSameLabel,
-      kTruePair,
-      kTruePIDMatch,
-      kRealisticPIDMatch,
       // last
       kLastType
     };
 
     AliRsnCutStd();
-    AliRsnCutStd(const char *name, EType type, Int_t val1, Int_t val2 = 0, Bool_t useMC = kFALSE);
-    AliRsnCutStd(const char *name, EType type, ULong_t val1, ULong_t val2 = 0, Bool_t useMC = kFALSE);
-    AliRsnCutStd(const char *name, EType type, Double_t val1, Double_t val2 = 0.0, Bool_t useMC = kFALSE);
+    AliRsnCutStd(const char *name, ETarget target, EType type, Int_t    val1, Int_t    val2 = 0 , Bool_t useMC = kFALSE);
+    AliRsnCutStd(const char *name, ETarget target, EType type, Double_t val1, Double_t val2 = 0., Bool_t useMC = kFALSE);
     virtual ~AliRsnCutStd() { }
-
-    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnDaughter*const daughter);
-    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnPairParticle*const pair);
-    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnEvent*const event);
-    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnEvent*const ev1, AliRsnEvent*const ev2);
     
-    void SetMass(Double_t mass) {fMass = mass;}
+    void           SetMass(Double_t mass) {fMass = mass;}
+    EVarType       CheckType();
+    
+    virtual Bool_t IsSelected(TObject *obj1, TObject *obj2 = 0x0);
 
   protected:
+  
+    virtual Bool_t IsDaughterSelected(AliRsnDaughter *daughter);
+    virtual Bool_t IsMotherSelected(AliRsnMother *mother);
+    virtual Bool_t IsEventSelected(AliRsnEvent *event);
 
     EType     fType;       // cut type
     Bool_t    fUseMC;      // use or not MC values (when applicable)
index b65c7db6d5a4bfa3a9f875d80f0d82a31a2aa2ed..f54b076d1fc0356ba85764821070079dd2c2502d 100644 (file)
@@ -5,42 +5,37 @@
 // Points to the source of information, which is generally an AliVParticle-derived object
 // and contains few internal data-members to store "on fly" some important information
 // for the computations required during resonance analysis.
-// ---
-// Since the package revision, this object is not supposed to be stacked in memory
-// but created "on fly" during analysis and used just for computations, as an interface.
+// It contains a useful TLorentzVector data-member which, provided that a meaningful mass was assigned,
+// eases a lot the computation of invariant masses from summing up several of these objects.
 //
 // authors: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //          M. Vala (martin.vala@cern.ch)
 //
 
-#include <Riostream.h>
 #include <TParticle.h>
 
 #include "AliStack.h"
+#include "AliMCEvent.h"
+#include "AliESDEvent.h"
+#include "AliAODEvent.h"
 #include "AliESDtrack.h"
 #include "AliAODEvent.h"
 #include "AliAODVertex.h"
 #include "AliAODTrack.h"
 
-#include "AliRsnPIDDefESD.h"
 #include "AliRsnDaughter.h"
 
 ClassImp(AliRsnDaughter)
 
-AliRsnDaughter::EPIDMethod AliRsnDaughter::fgPIDMethod = AliRsnDaughter::kRealistic;
-
 //_____________________________________________________________________________
-AliRsnDaughter::AliRsnDaughter(AliVParticle *ref, TParticle *refMC) :
-    fOK((ref != 0)),
-    fKinkIndex(0),
-    fParticle(refMC),
-    fMotherPDG(0),
-    fStatus(0),
-    fPairIndex(0),
-    fDr(0.0),
-    fDz(0.0),
-    fReqPID(AliPID::kUnknown),
-    fRef(ref)
+AliRsnDaughter::AliRsnDaughter() :
+  fOK(kFALSE),
+  fLabel(-1),
+  fMotherPDG(0),
+  fP(0.0, 0.0, 0.0, 0.0),
+  fPMC(0.0, 0.0, 0.0, 0.0),
+  fRef(0x0),
+  fRefMC(0x0)
 {
 //
 // Default constructor.
@@ -49,21 +44,19 @@ AliRsnDaughter::AliRsnDaughter(AliVParticle *ref, TParticle *refMC) :
 
 //_____________________________________________________________________________
 AliRsnDaughter::AliRsnDaughter(const AliRsnDaughter &copy) :
-    TObject(copy),
-    fOK(copy.fOK),
-    fKinkIndex(copy.fKinkIndex),
-    fParticle(copy.fParticle),
-    fMotherPDG(copy.fMotherPDG),
-    fStatus(copy.fStatus),
-    fPairIndex(copy.fPairIndex),
-    fDr(copy.fDr),
-    fDz(copy.fDz),
-    fReqPID(copy.fReqPID),
-    fRef(copy.fRef)
+  TObject(copy),
+  fOK(copy.fOK),
+  fLabel(copy.fLabel),
+  fMotherPDG(copy.fMotherPDG),
+  fP(copy.fP),
+  fPMC(copy.fPMC),
+  fRef(copy.fRef),
+  fRefMC(copy.fRefMC)
 {
 //
 // Copy constructor.
-// Pointers are NOT duplicated.
+// Pointers are NOT duplicated, since they don't come from a 'new'
+// statement, but from just referencing something in the data source.
 //
 }
 
@@ -72,22 +65,17 @@ AliRsnDaughter& AliRsnDaughter::operator=(const AliRsnDaughter &copy)
 {
 //
 // Assignment operator.
+// Pointers are NOT duplicated, since they don't come from a 'new'
+// statement, but from just referencing something in the data source.
 //
 
-  (TObject)(*this) = (TObject)copy;
-
-  fOK = copy.fOK;
-  fKinkIndex = copy.fKinkIndex;
-  fParticle  = copy.fParticle;
+  fOK        = copy.fOK;
+  fLabel     = copy.fLabel;
   fMotherPDG = copy.fMotherPDG;
-  fStatus = copy.fStatus;
-  fPairIndex = copy.fPairIndex;
-  fDr = copy.fDr;
-  fDz = copy.fDz;
-
-  fReqPID = copy.fReqPID;
-
-  fRef = copy.fRef;
+  fP         = copy.fP;
+  fPMC       = copy.fPMC;
+  fRef       = copy.fRef;
+  fRefMC     = copy.fRefMC;
 
   return (*this);
 }
@@ -97,302 +85,31 @@ AliRsnDaughter::~AliRsnDaughter()
 {
 //
 // Destructor.
-// Since pointers do not allocate new objects, nothing is done.
-//
-}
-
-//_____________________________________________________________________________
-void AliRsnDaughter::RotateP
-(Double_t angle, Double_t &x, Double_t &y, Bool_t isDegrees) const
-{
-//
-// Rotate the transverse momentum by an angle (in DEGREES)
-// around Z axis (does not change the Z component).
-// Rotated values are stored in the two arguments passed by reference.
-//
-
-  if (isDegrees) angle *= TMath::DegToRad();
-
-  Double_t s = TMath::Sin(angle);
-  Double_t c = TMath::Cos(angle);
-
-  x = c*Px() - s*Py();
-  y = s*Px() + c*Py();
-}
-
-//_____________________________________________________________________________
-Double_t AliRsnDaughter::AngleTo(AliRsnDaughter d, Bool_t outInDegrees)
-{
-//
-// Compute angle between the vector momentum of this
-// and the one of argument.
-//
-
-  Double_t arg, dot, ptot2 = P2() * d.P2();
-
-  if (ptot2 <= 0) {
-    return 0.0;
-  } else {
-    dot = Px()*d.Px() + Py()*d.Py() + Pz()*d.Pz();
-    arg = dot / TMath::Sqrt(ptot2);
-    if (arg >  1.0) arg =  1.0;
-    if (arg < -1.0) arg = -1.0;
-    if (outInDegrees) return TMath::ACos(arg) * TMath::RadToDeg();
-    else return TMath::ACos(arg);
-  }
-}
-
-//_____________________________________________________________________________
-Int_t AliRsnDaughter::GetID() const
-{
-//
-// Return reference index, using the "GetID" method
-// of the possible source object.
-//
-
-  AliESDtrack *esd = dynamic_cast<AliESDtrack*>(fRef);
-  if (esd) return esd->GetID();
-
-  AliAODTrack *aod = dynamic_cast<AliAODTrack*>(fRef);
-  if (aod) return aod->GetID();
-
-  return GetLabel();
-}
-
-//_____________________________________________________________________________
-AliPID::EParticleType AliRsnDaughter::RealisticPID() const
-{
-//
-// Return the "realistic" PID of this track,
-// i.e. the particle species to which corresponds the largest PID probability.
-//
-
-  AliPID::EParticleType pid = AliPID::kElectron;
-  Double_t prob = fPID[0];
-
-  Int_t i;
-  for (i = 1; i < AliPID::kSPECIES; i++) {
-    if (fPID[i] > prob) {
-      prob = fPID[i];
-      pid = (AliPID::EParticleType)i;
-    }
-  }
-
-  return pid;
-}
-
-//_____________________________________________________________________________
-AliPID::EParticleType AliRsnDaughter::PerfectPID() const
-{
-//
-// Return the "perfect" PID of this track,
-// reading it from the MC information, if available.
-//
-
-  if (!fParticle) return AliPID::kUnknown;
-
-  Int_t absPDG = TMath::Abs(fParticle->GetPdgCode());
-  switch (absPDG) {
-  case   11:
-    return AliPID::kElectron;
-  case   13:
-    return AliPID::kMuon;
-  case  211:
-    return AliPID::kPion;
-  case  321:
-    return AliPID::kKaon;
-  case 2212:
-    return AliPID::kProton;
-  default:
-    AliDebug(2, Form("PDG code = %d not recognized. Return 'AliPID::kUnknown'", absPDG));
-    return AliPID::kUnknown;
-  }
-}
-
-//_____________________________________________________________________________
-AliPID::EParticleType AliRsnDaughter::PIDType(Double_t &prob) const
-{
-//
-// Return the PID type according to the selected method
-// in the argument passed by reference, the probability is stored.
-// It will be realistic for realistic PID and 1 for perfect PID.
-//
-
-  AliPID::EParticleType pid = AssignedPID();
-
-  prob = 1.0;
-  if (fgPIDMethod == kRealistic) prob = fPID[(Int_t)pid];
-
-  return pid;
-}
-
-//_____________________________________________________________________________
-AliPID::EParticleType AliRsnDaughter::AssignedPID() const
-{
-//
-// Return the PID type according to the selected method
-// in the argument passed by reference, the probability is stored.
-// It will be realistic for realistic PID and 1 for perfect PID.
-//
-
-  switch (fgPIDMethod) {
-  case kNoPID:
-    return AliPID::kUnknown;
-  case kPerfect:
-    return PerfectPID();
-  case kRealistic:
-    return RealisticPID();
-  default:
-    AliWarning("PID method not properly set. Returning realistic PID");
-    return RealisticPID();
-  }
-}
-
-//_____________________________________________________________________________
-Bool_t AliRsnDaughter::CombineWithPriors(const Double_t *priors, AliRsnPIDDefESD *pidDef)
-{
-//
-// Combine current PID weights (assumed to be them) with prior probs
+// Since pointers do not allocate new objects, no 'delete' is done.
 //
-
-  Int_t       i;
-  Double_t    sum = 0.0;
-
-  // get PID weights according to definition
-  // if the reference is not ESD or the pidDef is null
-  // of it is not null but is requires the ESD pid,
-  // the standard PID value is used, otherwise
-  if (pidDef && GetRefESD()) {
-    pidDef->ComputeWeights(GetRefESD(), fPID);
-  } else {
-    if (fRef->PID())
-      for (i = 0; i < AliPID::kSPECIES; i++) fPID[i] = fRef->PID()[i];
-    else if (fParticle) {
-      // if the PID() returns 0x0, this is a MC particle
-      // and we set the weight corresponding to its species to 1
-      // and the others to zero
-      for (i = 0; i < AliPID::kSPECIES; i++) fPID[i] = 0.0;
-      i = (Int_t)AliRsnDaughter::InternalType(TMath::Abs(fParticle->GetPdgCode()));
-      fPID[i] = 1.0;
-    }
-  }
-
-  // multiply weights and priors
-  for (i = 0; i < AliPID::kSPECIES; i++) {
-    fPID[i] *= priors[i];
-    sum += fPID[i];
-  }
-  if (sum <= 0.0) {
-    if (sum < 0.0) AliError(Form("Sum of weights = %f < 0", sum));
-    return kFALSE;
-  }
-
-  // normalize
-  for (i = 0; i < AliPID::kSPECIES; i++) fPID[i] /= sum;
-
-  return kTRUE;
-}
-
-//_____________________________________________________________________________
-void AliRsnDaughter::FindMotherPDG(AliStack *const stack)
-{
-//
-// Searches the stack to find the mother and retrieve its PDG code.
-//
-
-  if (!stack || !fParticle) return;
-
-  const Int_t mLabel = fParticle->GetFirstMother();
-  if (mLabel < 0) {
-    fMotherPDG = 0;
-  } else {
-    TParticle *mum = stack->Particle(mLabel);
-    if (mum) fMotherPDG = mum->GetPdgCode();
-    else fMotherPDG = 0;
-  }
-}
-
-//_____________________________________________________________________________
-Double_t AliRsnDaughter::GetMCEnergy(Double_t mass)
-{
-//
-// Uses the argument to compute 4-momentum energy
-//
-
-  if (!fParticle) return 0.0;
-
-  Double_t p2 = fParticle->Px()*fParticle->Px();
-  p2 += fParticle->Py()*fParticle->Py();
-  p2 += fParticle->Pz()*fParticle->Pz();
-
-  return TMath::Sqrt(mass*mass + p2);
-}
-
-//_____________________________________________________________________________
-void AliRsnDaughter::FindKinkIndex(const AliESDtrack *esdTrack)
-{
-//
-// Assign kink index from an ESD track
-//
-
-  Int_t i, ik[3];
-  for (i = 0; i < 3; i++) ik[i] = esdTrack->GetKinkIndex(i);
-
-  if (ik[0] < 0 || ik[1] < 0 || ik[2] < 0) {
-    SetKinkMother();
-  } else if (ik[0] > 0 || ik[1] > 0 || ik[2] > 0) {
-    SetKinkDaughter();
-  } else SetNoKink();
-}
-
-//_____________________________________________________________________________
-void AliRsnDaughter::FindKinkIndex(AliAODEvent *const event)
-{
-//
-// Assign kink index from an AOD event
-//
-
-  Int_t iv, id, nD, nV = event->GetNumberOfVertices();
-  for (iv = 0; iv < nV; iv++) {
-    AliAODVertex *v = event->GetVertex(iv);
-    AliAODVertex::AODVtx_t type = (AliAODVertex::AODVtx_t)v->GetType();
-    if (type != AliAODVertex::kKink) continue;
-    AliAODTrack *mother = (AliAODTrack*)v->GetParent();
-    if (mother == (AliAODTrack*)fRef) {
-      SetKinkMother();
-      return;
-    } else {
-      nD = v->GetNDaughters();
-      for (id = 0; id < nD; id++) {
-        AliAODTrack *son = (AliAODTrack*)v->GetDaughter(id);
-        if (son == (AliAODTrack*)fRef) {
-          SetKinkDaughter();
-          return;
-        }
-      }
-    }
-  }
-
-  SetNoKink();
 }
 
 //_____________________________________________________________________________
 void AliRsnDaughter::Reset()
 {
 //
-// Reset this track to meaningless values
+// Reset this track to meaningless values and to a 'bad' status.
+// After this has been done, this object should not be used
+// for analysis unless initialized properly.
 //
 
-  fOK = kFALSE;
-  fKinkIndex = 0;
-  fParticle = 0x0;
+  fOK        = kFALSE;
+  fLabel     = -1;
   fMotherPDG = 0;
-  fStatus = 0;
-  fRef = 0x0;
+  fRef       = 0x0;
+  fRefMC     = 0x0;
+  
+  fP  .SetXYZM(0.0, 0.0, 0.0, 0.0);
+  fPMC.SetXYZM(0.0, 0.0, 0.0, 0.0);
 }
 
 //_____________________________________________________________________________
-void AliRsnDaughter::Print(Option_t * const option) const
+void AliRsnDaughter::Print(Option_t * const /*option*/) const
 {
 //
 // Prints the values of data members, using the options:
@@ -409,102 +126,95 @@ void AliRsnDaughter::Print(Option_t * const option) const
 //
 // Index and label are printed by default.
 //
-
-  TString opt(option);
-  opt.ToUpper();
-
-  if (opt.Contains("L") || opt.Contains("ALL")) {
-    cout << ".......Index            : " << GetID() << endl;
-    cout << ".......Label            : " << GetLabel() << endl;
-  }
-  if (opt.Contains("P") || opt.Contains("ALL")) {
-    cout << ".......Px, Py, Pz, Pt   : " << Px() << ' ' << Py() << ' ' << Pz() << ' ' << Pt() << endl;
-  }
-  if (opt.Contains("A") || opt.Contains("ALL")) {
-    cout << ".......Phi, Theta       : " << Phi() << ' ' << Theta() << endl;
-  }
-  if (opt.Contains("V") || opt.Contains("ALL")) {
-    cout << ".......Vx, Vy, Vz       : " << Xv() << ' ' << Yv() << ' ' << Zv() << endl;
-  }
-  if (opt.Contains("I") || opt.Contains("ALL")) {
-    AliPID::EParticleType type;
-    Double_t prob;
-    type = PIDType(prob);
-    cout << ".......PID & prob       : " << AliPID::ParticleName(type) << ' ' << prob << endl;
-  }
-  if (opt.Contains("C") || opt.Contains("ALL")) {
-    cout << ".......Charge           : " << Charge() << endl;
-  }
-  if (opt.Contains("F") || opt.Contains("ALL")) {
-    cout << ".......Flags            : " << fStatus << endl;
-  }
-  if (opt.Contains("W") || opt.Contains("ALL")) {
-    cout << ".......Weights          : ";
-    Int_t i;
-    for (i = 0; i < AliPID::kSPECIES; i++) cout << fPID[i] << ' ';
-    cout << endl;
-  }
-  if (opt.Contains("M") || opt.Contains("ALL")) {
-    if (fParticle) {
-      cout << ".......PDG code         : " << fParticle->GetPdgCode() << endl;
-      cout << ".......Mother (label)   : " << fParticle->GetFirstMother() << endl;
-      cout << ".......Mother (PDG code): " << fMotherPDG << endl;
-    } else {
-      cout << ".......MC info not present" << endl;
-    }
-  }
+  
+  Char_t type[50], source[50];
+  if (IsTrack()) sprintf(type, "track");
+  else if (IsV0()) sprintf(type, "V0");
+  else sprintf(type, "none");
+  
+  if (IsESD()) sprintf(source, "ESD");
+  else if (IsAOD()) sprintf(source, "AOD");
+  else if (fRefMC != 0x0) sprintf(source, "MC only");
+  else sprintf(source, "none");
+  
+  AliInfo("===== ALIRSNDAUGHTER INFORMATION ==============================================");
+  AliInfo(Form(".......Index                  : %d", GetID()));
+  AliInfo(Form(".......Label                  : %d", GetLabel()));
+  AliInfo(Form(".......Type, source           : %s %s", type, source));
+  AliInfo(Form(".......Charge                 : %c", ChargeChar()));
+  
+  if (fRef)
+  {
+    AliInfo(Form(".......Px, Py, Pz, Pt (ref)   : %d %d %d %d", fP.X(), fP.Y(), fP.Z(), fP.Perp()));
+  } else AliInfo("....... absent REF");
+  
+  if (fRefMC) 
+  {
+    AliInfo(Form(".......Px, Py, Pz, Pt (ref MC): %d %d %d %d", fP.X(), fP.Y(), fP.Z(), fP.Perp())); 
+    AliInfo(Form(".......PDG code               : %d", fRefMC->Particle()->GetPdgCode()));
+    AliInfo(Form(".......Mother (label)         : %d", fRefMC->Particle()->GetFirstMother()));
+    AliInfo(Form(".......Mother (PDG code)      : %d", fMotherPDG));
+  } else AliInfo("....... absent REF MC");
+  
+  AliInfo("===== END ALIRSNDAUGHTER INFORMATION ==========================================");
 }
 
 //_____________________________________________________________________________
-AliPID::EParticleType AliRsnDaughter::InternalType(Int_t pdg)
+Int_t AliRsnDaughter::GetID() const
 {
 //
-// Return the internal enum value corresponding to the PDG
-// code passed as argument, if possible.
-// Otherwise, returns 'AliPID::kSPECIES' by default.
+// Return reference index, using the "GetID" method
+// of the possible source object.
+// In case of V0s, since this method is unsuccessful, return the label.
 //
 
-  AliPID::EParticleType value;
-  Int_t absPDG = TMath::Abs(pdg);
+  const AliESDtrack *esd = GetRefESDtrack();
+  if (esd) return esd->GetID();
 
-  switch (absPDG) {
-  case 11:
-    value = AliPID::kElectron;
-    break;
-  case 13:
-    value = AliPID::kMuon;
-    break;
-  case 211:
-    value = AliPID::kPion;
-    break;
-  case 321:
-    value = AliPID::kKaon;
-    break;
-  case 2212:
-    value = AliPID::kProton;
-    break;
-  default:
-    value = AliPID::kUnknown;
-  }
-  return value;
+  const AliAODTrack *aod = GetRefAODtrack();
+  if (aod) return aod->GetID();
+
+  return GetLabel();
 }
 
 //_____________________________________________________________________________
-const char* AliRsnDaughter::MethodName(EPIDMethod method)
+Bool_t AliRsnDaughter::HasFlag(ULong_t flag) const
 {
 //
-// Returns a string with the method name
+// Checks that the 'status' flag of the source object has one or 
+// a combination of status flags combined with the bitwise OR.
+// Works only with track-like objects.
 //
 
-  switch (method)
+  if (IsTrack())
   {
-    case kNoPID:
-      return "No PID";
-    case kRealistic:
-      return "Realistic";
-    case kPerfect:
-      return "Perfect";
-    default:
-      return "Unknown";
+    AliVTrack *track  = dynamic_cast<AliVTrack*>(fRef);
+    ULong_t    status = (ULong_t)track->GetStatus();
+    return ((status & flag) != 0);
   }
+  
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnDaughter::SetMass(Double_t mass)
+{
+//
+// The argument defines a mass to be assigned to the 4-momentum.
+// This value is not stored as a data-member, but serves just to modify
+// the energy of the 4-momentum both in the MC and non-MC objects,
+// while the vector momentum is taken from the respective references.
+// The method returns a BOOL outcome which is kFALSE in the case that
+// mass is meaningless or when both references are NULL or the goodness 
+// flag is not positive.
+//
+
+  if (!fOK) return kFALSE;
+  if (mass < 0.) return kFALSE;
+  if (!fRef && !fRefMC) return kFALSE;
+  
+  if (fRef)   fP  .SetXYZM(fRef  ->Px(), fRef  ->Py(), fRef  ->Pz(), mass);
+  if (fRefMC) fPMC.SetXYZM(fRefMC->Px(), fRefMC->Py(), fRefMC->Pz(), mass);
+  
+  return kTRUE;
 }
index 030a1f6f7cd07ea8bbfefe34f8459ea2541d28f8..dd5eb738c3e58aca97ee4903d80a00fc5b06b4d7 100644 (file)
 #ifndef ALIRSNDAUGHTER_H
 #define ALIRSNDAUGHTER_H
 
-#include <TMath.h>
+#include <TLorentzVector.h>
 
-#include "AliPID.h"
-#include "AliVParticle.h"
 #include "AliESDtrack.h"
 #include "AliAODTrack.h"
+#include "AliESDv0.h"
+#include "AliAODv0.h"
 #include "AliMCParticle.h"
 
-class TParticle;
+typedef AliPID::EParticleType EPARTYPE;
+
 class AliStack;
-class AliMCParticle;
-// class AliESDtrack;
-// class AliESDtrack;
-// class AliAODTrack;
-class AliAODEvent;
+class AliVEvent;
+class AliMCEvent;
 class AliRsnPIDDefESD;
 
 class AliRsnDaughter : public TObject
 {
   public:
-
-    enum EPIDMethod {
-      kNoPID = 0,
-      kRealistic,
-      kPerfect,
-      kMethods
+    
+    enum ERefType
+    {
+      kTrack = 0,
+      kV0,
+      kNoType
     };
 
-    AliRsnDaughter(AliVParticle *ref = 0, TParticle *refMC = 0);
+    AliRsnDaughter();
     AliRsnDaughter(const AliRsnDaughter &copy);
     virtual ~AliRsnDaughter();
     AliRsnDaughter& operator= (const AliRsnDaughter& copy);
-
-    // momentum
-    Double_t Px() const {return fRef->Px();}
-    Double_t Py() const {return fRef->Py();}
-    Double_t Pz() const {return fRef->Pz();}
-    Double_t Pt() const {return fRef->Pt();}
-    Double_t P2() const {return Pt()*Pt() + Pz()*Pz();}
-    Double_t P()  const {return TMath::Sqrt(P2());}
-    Double_t Eta() const {return fRef->Eta();}
-    Double_t Y() const {return fRef->Y();}
-    Double_t Y(Double_t mass) const {return 0.5*TMath::Log((E(mass) + Pz()) / (E(mass) - Pz()));}
-    Double_t E() const {return fRef->E();}
-    Double_t E(Double_t mass) const {return TMath::Sqrt(mass*mass + P2());}
-    Double_t Phi() const {return fRef->Phi();}
-    Double_t Theta() const {return fRef->Theta();}
-    Double_t PhiDeg() const {return TMath::RadToDeg() * Phi();}
-    Double_t ThetaDeg() const {return TMath::RadToDeg() * Theta();}
-    void     RotateP(Double_t angle, Double_t &x, Double_t &y, Bool_t isDegrees = kTRUE) const;
-    Double_t AngleTo(AliRsnDaughter d, Bool_t outInDegrees = kTRUE);
-
-    // DCA vertex
-    Double_t Xv() const {return fRef->Xv();}
-    Double_t Yv() const {return fRef->Yv();}
-    Double_t Zv() const {return fRef->Zv();}
-    Double_t Dr() const {return fDr;}
-    Double_t Dz() const {return fDz;}
-    void     SetDr(Double_t value) {fDr = value;}
-    void     SetDz(Double_t value) {fDz = value;}
-
-    // PID
-    const Double_t        *PID() const {return fRef->PID();}
-    const Double_t        *ComputedWeights() const {return fPID;}
-    Bool_t                 CombineWithPriors(const Double_t* priors, AliRsnPIDDefESD* pidDef = 0x0);
-    AliPID::EParticleType  RealisticPID() const;
-    AliPID::EParticleType  PerfectPID() const;
-    Bool_t                 IsPerfectPID(const AliPID::EParticleType type) const  {return (PerfectPID() == type);}
-    Bool_t                 IsRealisticPID(const AliPID::EParticleType type) const  {return (RealisticPID() == type);}
-    Double_t               PIDProb(AliPID::EParticleType type) const {return PID()[(Int_t)type];}
-    AliPID::EParticleType  PIDType(Double_t &prob) const;
-    AliPID::EParticleType  AssignedPID() const;
-    AliPID::EParticleType  RequiredPID() const {return fReqPID;}
-    void                   SetRequiredPID(AliPID::EParticleType type) {fReqPID = type;}
-
-    // integer parameters
-    Bool_t  IsPos() const {return (fRef->Charge() > 0);}
-    Bool_t  IsNeg() const {return (fRef->Charge() < 0);}
-    Bool_t  IsNeutral() const {return (!IsPos() && !IsNeg());}
-    Bool_t  IsSign(Char_t sign) const { if (sign=='+') return IsPos(); else if (sign=='-') return IsNeg(); else return IsNeutral();}
-    Short_t Charge() const {if (IsPos()) return 1; else if (IsNeg()) return -1; else return 0;}
-    Char_t  ChargeC() const {if (IsPos()) return '+'; else if (IsNeg()) return '-'; else return '0';}
-    Int_t   GetLabel() const {return fRef->GetLabel();}
+    
+    // utilities
+    void    Reset();
+    void    Print(Option_t* const option = "") const;
+    
+    // flags and labels
     Int_t   GetID() const;
-    void    SetStatus(ULong_t value) {fStatus = value;}
-    ULong_t GetStatus() const {return fStatus;}
-    Bool_t  CheckFlag(ULong_t flag) const {return ((fStatus & flag) > 0);}
-    void    SetGood() {fOK = kTRUE;}
+    Int_t   GetLabel() const {return fLabel;}
+    Bool_t  HasFlag(ULong_t flag) const;
+    Bool_t  IsOK() const {return fOK;}
     void    SetBad() {fOK = kFALSE;}
-    Bool_t  IsOK() const { return fOK; }
-    Int_t   PairIndex() {return fPairIndex;}
-    void    SetPairIndex(Int_t value) {fPairIndex = value;}
-
-    // Kinkness
-    Char_t  KinkIndex() const {return fKinkIndex;}
-    Bool_t  IsKinkMother() const {return (fKinkIndex < 0);}
-    Bool_t  IsKinkDaughter() const {return (fKinkIndex > 0);}
-    Bool_t  IsKink() const {return (IsKinkMother() || IsKinkDaughter());}
-    void    SetKink(Char_t kink) {fKinkIndex = kink;}
-    void    SetKinkMother() {fKinkIndex = -1;}
-    void    SetKinkDaughter() {fKinkIndex = 1;}
-    void    SetNoKink() {fKinkIndex = 0;}
-    void    FindKinkIndex(const AliESDtrack* track);
-    void    FindKinkIndex(AliAODEvent*const event);
+    void    SetGood() {fOK = kTRUE;}
+    void    SetLabel(Int_t label) {fLabel = label;}
+
+    // 4-momentum
+    TLorentzVector& P(Bool_t mc = kFALSE) {return (mc ? fPMC : fP);}
+    Bool_t          SetMass(Double_t mass);
+    
+    // charge
+    Bool_t  IsPos()             const {return (fRef->Charge() > 0);}
+    Bool_t  IsNeg()             const {return (fRef->Charge() < 0);}
+    Bool_t  IsNeutral()         const {return (!IsPos() && !IsNeg());}
+    Bool_t  IsSign(Char_t sign) const {if (sign=='+') return IsPos(); else if (sign=='-') return IsNeg(); else return IsNeutral();}
+    Short_t Charge()            const {if (IsPos()) return  1 ; else if (IsNeg()) return -1 ; else return  0 ;}
+    Char_t  ChargeChar()        const {if (IsPos()) return '+'; else if (IsNeg()) return '-'; else return '0';}
 
     // MC info & references
-    AliVParticle*  GetRef() const {return fRef;}
-    AliESDtrack*   GetRefESD() {return dynamic_cast<AliESDtrack*>(fRef);}
-    AliAODTrack*   GetRefAOD() {return dynamic_cast<AliAODTrack*>(fRef);}
-    AliMCParticle* GetRefMC()  {return dynamic_cast<AliMCParticle*>(fRef);}
-    TParticle*     GetParticle() const {return fParticle;}
-    Int_t          GetMotherPDG() const {return fMotherPDG;}
-    void           SetRef(AliVParticle * const ref) {fRef = ref;}
-    void           SetParticle(TParticle * const p) {fParticle = p;}
+    AliVParticle*  GetRef()         const {return fRef;}
+    AliESDtrack*   GetRefESDtrack() const {return dynamic_cast<AliESDtrack*>(fRef);}
+    AliAODTrack*   GetRefAODtrack() const {return dynamic_cast<AliAODTrack*>(fRef);}
+    AliESDv0*      GetRefESDv0()    const {return dynamic_cast<AliESDv0*>(fRef);}
+    AliAODv0*      GetRefAODv0()    const {return dynamic_cast<AliAODv0*>(fRef);}
+    AliMCParticle* GetRefMC()       const {return fRefMC;}
+    TParticle*     GetParticle()    const {if (fRefMC) return fRefMC->Particle(); else return 0x0;}
+    Int_t          GetMotherPDG()   const {return fMotherPDG;}
+    Bool_t         IsAOD()          const {if (GetRefAODtrack() || GetRefAODv0()) return kTRUE; return kFALSE;}
+    Bool_t         IsESD()          const {if (GetRefESDtrack() || GetRefESDv0()) return kTRUE; return kFALSE;}
+    Bool_t         IsTrack()        const {if (GetRefESDtrack() || GetRefAODtrack()) return kTRUE; return kFALSE;}
+    Bool_t         IsV0()           const {if (GetRefESDv0() || GetRefAODv0()) return kTRUE; return kFALSE;}
+    ERefType       RefType()        const {if (IsTrack()) return kTrack; if (IsV0()) return kV0; return kNoType;}
+    void           SetRef(AliVParticle *ref) {fRef = ref;}
+    void           SetRefMC(AliMCParticle *refMC) {fRefMC = refMC;}
     void           SetMotherPDG(Int_t value) {fMotherPDG = value;}
-    void           FindMotherPDG(AliStack *const stack);
-    Double_t       GetMCEnergy(Double_t mass);
-
-    // utilities
-    void          Reset();
-    void          Print(Option_t*const option = "ALL") const;
-
-    // static functions
-    static void                   SetPIDMethod(EPIDMethod method) {fgPIDMethod = method;}
-    static AliPID::EParticleType  InternalType(Int_t pdgCode);
-    static const char*            MethodName(EPIDMethod method);
 
   private:
 
-    Bool_t         fOK;                     // status flag for usability
-    Int_t          fKinkIndex;              // indicator of kinkness of the track
-    TParticle     *fParticle;               // pointer to (eventual) MC information
-    Int_t          fMotherPDG;              // PDG code of mother (if any)
-    ULong_t        fStatus;                 // track status (if available)
-    Int_t          fPairIndex;              // to know if it is member #1 or #2 of the pair (cfr. to PairDef)
-
-    Double_t       fDr;                     // transverse impact parameter
-    Double_t       fDz;                     // longitudinal impact parameter
-    Double_t       fPID[AliPID::kSPECIES];  // PID probabilities
-    AliPID::EParticleType fReqPID;          // PID assigned by pairdef
-
-    AliVParticle  *fRef;                    // reference to read object
-
-    static EPIDMethod fgPIDMethod;          // PID method used for analysis
-
-    ClassDef(AliRsnDaughter, 7)
+    Bool_t         fOK;                // internal utility flag which is kFALSE when this object should not be used
+    Int_t          fLabel;             // GEANT label of corresponding MC (not trivial for V0s)
+    Int_t          fMotherPDG;         // PDG code of mother (makes sense only if fRefMC is defined)
+    
+    TLorentzVector fP;                 // 4-vector filled with track info from default ref (if present)
+    TLorentzVector fPMC;               // 4-vector filled with track info from MC ref (if present)
+    
+    AliVParticle  *fRef;               // reference to track in ESD/AOD/MC (all info are taken from this object)
+    AliMCParticle *fRefMC;             // reference to corresponding MC particle
+
+    ClassDef(AliRsnDaughter, 8)
 };
 
 #endif
index a2244940b1914b507fca3afe297c972eb00dee89..cefc315ecb4c7344dab93f52873f807a673b881d 100644 (file)
 
 #include "AliLog.h"
 #include "AliVEvent.h"
-#include "AliESDEvent.h"
-#include "AliAODEvent.h"
 #include "AliMCEvent.h"
 #include "AliStack.h"
 #include "AliGenEventHeader.h"
+#include "AliRsnCutPID.h"
 
 #include "AliRsnEvent.h"
 
@@ -27,28 +26,21 @@ ClassImp(AliRsnEvent)
 
 //_____________________________________________________________________________
 AliRsnEvent::AliRsnEvent(AliVEvent *ref, AliMCEvent *refMC) :
-    fRef(ref),
-    fRefMC(refMC),
-    fPIDDefESD()
+  fRef(ref),
+  fRefMC(refMC),
+  fLeading(-1)
 {
 //
 // Default constructor.
-// Set the prior probabilities to some default values
 //
-
-  fPrior[0] = 0.02;
-  fPrior[1] = 0.02;
-  fPrior[2] = 0.83;
-  fPrior[3] = 0.07;
-  fPrior[4] = 0.06;
 }
 
 //_____________________________________________________________________________
 AliRsnEvent::AliRsnEvent(const AliRsnEvent &event) :
-    TObject(event),
-    fRef(event.fRef),
-    fRefMC(event.fRefMC),
-    fPIDDefESD(event.fPIDDefESD)
+  TObject(event),
+  fRef(event.fRef),
+  fRefMC(event.fRefMC),
+  fLeading(event.fLeading)
 {
 //
 // Copy constructor.
@@ -63,9 +55,9 @@ AliRsnEvent& AliRsnEvent::operator= (const AliRsnEvent & event)
 //
 
   (TObject)(*this) = (TObject)event;
-  fRef = event.fRef;
-  fRefMC = event.fRefMC;
-  fPIDDefESD = event.fPIDDefESD;
+  fRef             = event.fRef;
+  fRefMC           = event.fRefMC;
+  fLeading         = event.fLeading;
 
   return (*this);
 }
@@ -79,75 +71,134 @@ AliRsnEvent::~AliRsnEvent()
 }
 
 //_____________________________________________________________________________
-void AliRsnEvent::SetDaughter(AliRsnDaughter &out, Int_t i)
+Bool_t AliRsnEvent::SetDaughter(AliRsnDaughter &out, Int_t i, AliRsnDaughter::ERefType type)
 {
 //
-// Return a track stored here in format of AliRsnDaughter.
-// and finds in the reference event the informations to set
-// the proprietary data members of AliRsnDaughter
+// Using the second and third arguments, retrieves the i-th object in the
+// appropriate sample (tracks or V0s) and sets the firs reference object
+// in order to point to that.
+// If a MonteCarlo information is provided, sets the useful informations from there,
+// and in case of a V0, sets the 'label' data member only when the two daughters
+// of the V0 point to the same mother.
+// Returns kFALSE whenever the operation fails (out of range, NULL references).
 //
 
+  Int_t label;
+
   // retrieve reference particle from reference event
   // if it is found, by defaul track can be used (good)
-  AliVParticle *ref = (AliVParticle*)fRef->GetTrack(i);
-  if (!ref) return;
-  out.SetRef(ref);
-  out.SetGood();
-
-  // if MC info is present, retrieve from it
-  TParticle *refMC = 0;
-  if (fRefMC) {
-    Int_t label = TMath::Abs(ref->GetLabel());
-    refMC = fRefMC->Stack()->Particle(label);
-    out.SetParticle(refMC);
-    out.FindMotherPDG(fRefMC->Stack());
+  if (type == AliRsnDaughter::kTrack)
+  {
+    if (i >= fRef->GetNumberOfTracks())
+    {
+      out.SetBad();
+      return kFALSE;
+    }
+    AliVTrack *track = (AliVTrack*)fRef->GetTrack(i);
+    label = TMath::Abs(track->GetLabel());
+    if (!track)
+    {
+      out.SetBad();
+      return kFALSE;
+    }
+    else
+    {
+      out.SetRef(track);
+      out.SetLabel(label);
+      if (fRefMC)
+      {
+        if (label < fRefMC->GetNumberOfTracks()) 
+        {
+          AliMCParticle *part = (AliMCParticle*)fRefMC->GetTrack(label);
+          out.SetRefMC(part);
+        }
+      }
+      out.SetGood();
+    }
   }
-
-  // if fRef is MC event return
-  AliMCEvent *mc = dynamic_cast<AliMCEvent *>(fRef);
-  if (mc) return;
-
-  // dynamic reference to true nature of referenced event
-  // to get kink index
-  AliESDEvent *esd = dynamic_cast<AliESDEvent*>(fRef);
-  AliAODEvent *aod = dynamic_cast<AliAODEvent*>(fRef);
-
-  if (esd) {
-    // retrieve vertex and set impact parameters
-    Double_t dx = out.Xv(), dy = out.Yv(), dz = out.Zv();
-    const AliVVertex *v = fRef->GetPrimaryVertex();
-    if (v) {
-      dx -= v->GetX();
-      dy -= v->GetY();
-      dz -= v->GetZ();
-    } else if (fRefMC) {
-      // if reference is an MC event, no primary vertex is supplied
-      // but it is possible to retrieve it from header
-      TArrayF fvertex(3);
-      fRefMC->GenEventHeader()->PrimaryVertex(fvertex);
-      dx -= fvertex[0];
-      dy -= fvertex[1];
-      dz -= fvertex[2];
+  else if (type == AliRsnDaughter::kV0)
+  {
+    if (i > fRef->GetNumberOfV0s())
+    {
+      out.SetBad();
+      return kFALSE;
+    }
+    AliESDv0     *esdV = 0x0;
+    AliAODv0     *aodV = 0x0;
+    Int_t         lp, ln;
+    AliVTrack    *tp = 0x0, *tn = 0x0;
+    if (IsESD()) esdV = GetRefESD()->GetV0(i);
+    if (IsAOD()) aodV = GetRefAOD()->GetV0(i);
+    if (!esdV && !aodV)
+    {
+      out.SetBad();
+      return kFALSE;
+    }
+    else
+    {
+      if (esdV) out.SetRef(esdV); else out.SetRef(aodV);
+      // retrieve the V0 daughters, which must be done differently with ESD and AOD v0s
+      if (esdV)
+      {
+        // get the 2 daughters of the V0
+        AliESDEvent *ev = dynamic_cast<AliESDEvent*>(fRef);
+        tp = ev->GetTrack(esdV->GetPindex());
+        tn = ev->GetTrack(esdV->GetNindex());
+      }
+      else if (aodV)
+      {
+        // get the 2 daughters of the V0
+        AliAODEvent *ev = dynamic_cast<AliAODEvent*>(fRef);
+        tp = ev->GetTrack(aodV->GetPosID());
+        tn = ev->GetTrack(aodV->GetNegID());
+      }
+
+      // now, if we have a MC, use the two track objects
+      // to retrieve the true particle which generated the V0
+      // using their labels; by default they are a false V0 with label -1
+      label = -1;
+      if (tp && tn && fRefMC)
+      {
+        lp = TMath::Abs(tp->GetLabel());
+        ln = TMath::Abs(tn->GetLabel());
+        // if labels are meaningful, retrieve corresponding particles
+        TParticle *pp = fRefMC->Stack()->Particle(lp);
+        TParticle *pn = fRefMC->Stack()->Particle(ln);
+        // if their first mothers are the same, the V0 is true
+        // otherwise no label can be assigned
+        if (pp->GetFirstMother() == pn->GetFirstMother()) label = pp->GetFirstMother();
+      }
+      out.SetLabel(label);
+      out.SetGood();
     }
-    out.SetDr(TMath::Sqrt(dx*dx + dy*dy));
-    out.SetDz(dz);
   }
-  // compute PID probabilities by combining
-  // the PID weights in the source with priors
-  // and eventually using the PIDDefESD
-  // (the AliRsnDaughter objec knows how to manage the latter)
-  out.CombineWithPriors(fPrior, &fPIDDefESD);
-
-  if (esd) {
-    AliESDtrack *esdTrack = esd->GetTrack(i);
-    out.FindKinkIndex(esdTrack);
-  } else if (aod) {
-    out.FindKinkIndex(aod);
+  
+  // finally, in case we have a MC, searches for the mother, in order to store
+  // its PDG code into the output AliRsnDaughter
+  if (fRefMC)
+  {
+    label = out.GetLabel();
+    AliStack *stack = fRefMC->Stack();
+    if (label >= 0 && label < stack->GetNtrack())
+    {
+      TParticle *part = stack->Particle(label);
+      if (part)
+      {
+        Int_t imum = part->GetFirstMother();
+        if (imum >= 0 && imum <= stack->GetNtrack())
+        {
+          TParticle *mum = stack->Particle(imum);
+          if (mum) out.SetMotherPDG(TMath::Abs(mum->GetPdgCode()));
+        }
+      }
+    }
   }
+  
+  return kTRUE;
 }
 
 //_____________________________________________________________________________
-AliRsnDaughter AliRsnEvent::GetDaughter(Int_t i)
+AliRsnDaughter AliRsnEvent::GetDaughter(Int_t i, AliRsnDaughter::ERefType type)
 {
 //
 // Return an AliRsnDaughter taken from this event,
@@ -155,7 +206,7 @@ AliRsnDaughter AliRsnEvent::GetDaughter(Int_t i)
 //
 
   AliRsnDaughter out;
-  SetDaughter(out, i);
+  SetDaughter(out, i, type);
 
   return out;
 }
@@ -178,14 +229,15 @@ Double_t AliRsnEvent::GetVz()
 //
 // Return Z coord of primary vertex
 //
+
   AliDebug(AliLog::kDebug+2,"<-");
   return fRef->GetPrimaryVertex()->GetZ();
   AliDebug(AliLog::kDebug+2,"->");
 }
 
 //_____________________________________________________________________________
-AliRsnDaughter AliRsnEvent::GetLeadingParticle
-(Double_t ptMin, AliPID::EParticleType type)
+Int_t AliRsnEvent::SelectLeadingParticle
+(Double_t ptMin, AliRsnCutPID *cutPID)
 {
 //
 // Searches the collection of all particles with given PID type and charge,
@@ -197,23 +249,26 @@ AliRsnDaughter AliRsnEvent::GetLeadingParticle
 //
 
   Int_t i, nTracks = fRef->GetNumberOfTracks();
-  AliRsnDaughter output;
+  fLeading = -1;
+  AliRsnDaughter leading;
+  leading.SetBad();
 
   for (i = 0; i < nTracks; i++) {
     AliRsnDaughter track = GetDaughter(i);
-    if (!AcceptTrackPID(&track, type)) continue;
-    if (track.Pt() < ptMin) continue;
-    if (!output.IsOK() || track.Pt() > output.Pt()) {
-      output = track;
-      output.SetGood();
+    if (cutPID) if (!cutPID->IsSelected(&track)) continue;
+    if (track.P().Perp() < ptMin) continue;
+    if (!leading.IsOK() || track.P().Perp() > leading.P().Perp())
+    {
+      fLeading = i;
+      leading = track;
     }
   }
 
-  return output;
+  return fLeading;
 }
 
 //_________________________________________________________________________________________________
-Double_t AliRsnEvent::GetAverageMomentum(Int_t &count, AliPID::EParticleType type)
+Double_t AliRsnEvent::GetAverageMomentum(Int_t &count, AliRsnCutPID *cutPID)
 {
 //
 // Loops on the list of tracks and computes average total momentum.
@@ -224,8 +279,8 @@ Double_t AliRsnEvent::GetAverageMomentum(Int_t &count, AliPID::EParticleType typ
 
   for (i = 0, count = 0; i < nTracks; i++) {
     AliRsnDaughter track = GetDaughter(i);
-    if (!AcceptTrackPID(&track, type)) continue;
-    pmean += track.P();
+    if (cutPID) if (!cutPID->IsSelected(&track)) continue;
+    pmean += track.P().Mag();
     count++;
   }
 
@@ -256,7 +311,7 @@ Bool_t AliRsnEvent::GetAngleDistr
     AliRsnDaughter trk = GetDaughter(i);
     if (trk.GetID() == leading.GetID()) continue;
 
-    angle = leading.AngleTo(trk);
+    angle = leading.P().Angle(trk.P().Vect());
 
     angleMean += angle;
     angle2Mean += angle * angle;
@@ -271,63 +326,3 @@ Bool_t AliRsnEvent::GetAngleDistr
 
   return kTRUE;
 }
-
-//_____________________________________________________________________________
-void AliRsnEvent::SetPriorProbability(Double_t *const out)
-{
-//
-// Set all prior probabilities at once, using an assayr of values.
-//
-
-  Int_t i;
-
-  for (i = 0; i < AliPID::kSPECIES; i++) {
-    fPrior[i] = out[i];
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnEvent::DumpPriors()
-{
-//
-// Print all prior probabilities.
-// Printout is done using AliInfo, so this will not appear when
-// the GlobalLogLevel is set to higher level errors.
-//
-
-  Int_t i;
-
-  for (i = 0; i < AliPID::kSPECIES; i++) {
-    AliInfo(Form("Prior probability for %10s = %3.5f", AliPID::ParticleName((AliPID::EParticleType)i), fPrior[i]));
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnEvent::GetPriorProbability(Double_t *out) const
-{
-//
-// Stores in the passed argument all the values.
-//
-
-  Int_t i;
-
-  for (i = 0; i < AliPID::kSPECIES; i++) {
-    out[i] = fPrior[i];
-  }
-
-}
-
-//_____________________________________________________________________________
-Bool_t AliRsnEvent::AcceptTrackPID(AliRsnDaughter * const d, AliPID::EParticleType type)
-{
-//
-// [PRIVATE]
-// Checks if the track PID (according to method in use) corresponds
-// to the required identification species.
-// If the second argument is "kUnknown", answer of this method is always YES.
-//
-
-  if (type == AliPID::kUnknown) return kTRUE;
-
-  return (d->AssignedPID() == type);
-}
index e9b0d35f8d3e71249abdb207777cc8b9e76ef8ee..93ba8c80dbfc0e46b0bfc61bd581c505527eb01c 100644 (file)
 #ifndef ALIRSNEVENT_H
 #define ALIRSNEVENT_H
 
-#include "AliPID.h"
-#include "AliRsnPIDDefESD.h"
+#include "AliESDEvent.h"
+#include "AliAODEvent.h"
 #include "AliRsnDaughter.h"
 
 class AliVEvent;
 class AliMCEvent;
+class AliRsnCutPID;
 
 class AliRsnEvent : public TObject
 {
@@ -30,33 +31,31 @@ class AliRsnEvent : public TObject
     AliRsnEvent& operator= (const AliRsnEvent& copy);
     virtual ~AliRsnEvent();
 
-    void             SetRef(AliVEvent *const event, AliMCEvent *const mc = 0) {fRef = event; fRefMC = mc;}
-    void             SetRefMC(AliMCEvent * const mc) {fRefMC = mc;}
+    void             SetRef(AliVEvent * const event, AliMCEvent * const mc = 0) {fRef = event; fRefMC = mc;}
     AliVEvent*       GetRef() const {return fRef;}
     AliMCEvent*      GetRefMC() const {return fRefMC;}
-    AliRsnPIDDefESD* GetPIDDefESD() {return &fPIDDefESD;}
-
-    void             SetDaughter(AliRsnDaughter &daughter, Int_t index);
-    AliRsnDaughter   GetDaughter(Int_t i);
-    Int_t            GetMultiplicity();
+    AliESDEvent*     GetRefESD() const {return dynamic_cast<AliESDEvent*>(fRef);}
+    AliAODEvent*     GetRefAOD() const {return dynamic_cast<AliAODEvent*>(fRef);}
+    Bool_t           IsESD() const {return (GetRefESD() != 0x0);}
+    Bool_t           IsAOD() const {return (GetRefAOD() != 0x0);}
+    
     Double_t         GetVz();
-    AliRsnDaughter   GetLeadingParticle(Double_t ptMin = 0.0, AliPID::EParticleType type = AliPID::kUnknown);
-    Double_t         GetAverageMomentum(Int_t &count, AliPID::EParticleType type = AliPID::kUnknown);
-    Bool_t           GetAngleDistr(Double_t &angleMean, Double_t &angleRMS, AliRsnDaughter d);
-
-    void             SetPriorProbability(AliPID::EParticleType type, Double_t p) {if (type>=0&&type<(Int_t)AliPID::kSPECIES)fPrior[type]=p;}
-    void             SetPriorProbability(Double_t* const out);
-    void             DumpPriors();
-    void             GetPriorProbability(Double_t *out) const;
+    Int_t            GetMultiplicity();
+    
+    Bool_t           SetDaughter(AliRsnDaughter &daughter, Int_t index, AliRsnDaughter::ERefType type = AliRsnDaughter::kTrack);
+    AliRsnDaughter   GetDaughter(Int_t i, AliRsnDaughter::ERefType type = AliRsnDaughter::kTrack);
+    
+    Int_t            SelectLeadingParticle(Double_t ptMin = 0.0, AliRsnCutPID *cutPID = 0x0);
+    Int_t            GetLeadingParticleID() {return fLeading;}
+    void             SetLeadingParticle(AliRsnDaughter &leading) {if (fLeading >= 0) SetDaughter(leading, fLeading);}
+    Double_t         GetAverageMomentum(Int_t &count, AliRsnCutPID *cutPID = 0x0);
+    Bool_t           GetAngleDistr(Double_t &angleMean, Double_t &angleRMS, AliRsnDaughter reference);
 
   private:
 
-    Bool_t AcceptTrackPID(AliRsnDaughter*const d, AliPID::EParticleType type = AliPID::kUnknown);
-
-    Double_t         fPrior[AliPID::kSPECIES]; // prior probabilities 
-    AliVEvent       *fRef;                     // pointer to input event
-    AliMCEvent      *fRefMC;                   // pointer to reference MC event (if any)
-    AliRsnPIDDefESD  fPIDDefESD;               // (optional) customization of PID weights for ESD
+    AliVEvent       *fRef;         // pointer to input event
+    AliMCEvent      *fRefMC;       // pointer to reference MC event (if any)
+    Int_t            fLeading;     // index of leading track
 
     ClassDef(AliRsnEvent, 3);
 };
index bcd944a77bcea227334a3a5baf99118441f77778..a5d109c94f5c3569c44b3df64a3e0527d0534e90 100644 (file)
@@ -26,8 +26,8 @@
 #include "AliRsnDaughter.h"
 #include "AliRsnEvent.h"
 #include "AliRsnPairDef.h"
-#include "AliRsnPairParticle.h"
-#include "AliRsnFunctionAxis.h"
+#include "AliRsnMother.h"
+#include "AliRsnValue.h"
 
 #include "AliRsnFunction.h"
 
@@ -37,8 +37,7 @@ ClassImp(AliRsnFunction)
 AliRsnFunction::AliRsnFunction(Bool_t useTH1) :
     TNamed(),
     fPairDef(0x0),
-    fAxisList("AliRsnFunctionAxis", 0),
-    fTrack(0x0),
+    fAxisList("AliRsnValue", 0),
     fPair(0x0),
     fEvent(0x0),
     fUseTH1(useTH1),
@@ -56,7 +55,6 @@ AliRsnFunction::AliRsnFunction(const AliRsnFunction &copy) :
     TNamed(copy),
     fPairDef(copy.fPairDef),
     fAxisList(copy.fAxisList),
-    fTrack(copy.fTrack),
     fPair(copy.fPair),
     fEvent(copy.fEvent),
     fUseTH1(copy.fUseTH1),
@@ -80,7 +78,6 @@ const AliRsnFunction& AliRsnFunction::operator=(const AliRsnFunction& copy)
   SetTitle(copy.GetTitle());
 
   fPairDef = copy.fPairDef;
-  fTrack = copy.fTrack;
   fPair = copy.fPair;
   fEvent = copy.fEvent;
   fUseTH1 = copy.fUseTH1;
@@ -106,9 +103,9 @@ const char* AliRsnFunction::GetName() const
   TString name("");
 
   TObjArrayIter next(&fAxisList);
-  AliRsnFunctionAxis *axis = 0;
+  AliRsnValue *axis = 0;
 
-  while ((axis = (AliRsnFunctionAxis*)next())) {
+  while ((axis = (AliRsnValue*)next())) {
     if (name.Length() > 1) name += '_';
     name += axis->GetName();
   }
@@ -117,15 +114,18 @@ const char* AliRsnFunction::GetName() const
 }
 
 //________________________________________________________________________________________
-void AliRsnFunction::AddAxis(AliRsnFunctionAxis *const axis)
+void AliRsnFunction::AddAxis(AliRsnValue *const axis)
 {
+  AliDebug(AliLog::kDebug+2,"<-");
   Int_t size = fAxisList.GetEntries();
-  if (size >= 3 && fUseTH1)
+  new(fAxisList[size]) AliRsnValue(*axis);
+  AliDebug(AliLog::kDebug+2,"->");
+  
+  if (fAxisList.GetEntries() > 3)
   {
     AliWarning("A TH1-type output cannot add more than 3 axes: switching to THnSparse -- THIS COULD CAUSE VERY LARGE FILES!!!");
     fUseTH1 = kFALSE;
   }
-  new(fAxisList[size]) AliRsnFunctionAxis(*axis);
 }
 
 //________________________________________________________________________________________
@@ -157,9 +157,9 @@ TH1* AliRsnFunction::CreateHistogram(const char *histoName, const char *histoTit
   Double_t *max   = new Double_t[fSize];
 
   // retrieve binnings for main and secondary axes
-  AliRsnFunctionAxis *fcnAxis = 0;
+  AliRsnValue *fcnAxis = 0;
   for (Int_t i = 0; i < fSize; i++) {
-    fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(i);
+    fcnAxis = (AliRsnValue*)fAxisList.At(i);
     if (!fcnAxis) {
       nbins[i] = 0;
       min[i]   = 0.0;
@@ -214,9 +214,9 @@ THnSparseD* AliRsnFunction::CreateHistogramSparse(const char *histoName, const c
   Double_t *max   = new Double_t[fSize];
 
   // retrieve binnings for main and secondary axes
-  AliRsnFunctionAxis *fcnAxis = 0;
+  AliRsnValue *fcnAxis = 0;
   for (Int_t i = 0; i < fSize; i++) {
-    fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(i);
+    fcnAxis = (AliRsnValue*)fAxisList.At(i);
     if (!fcnAxis) {
       nbins[i] = 0;
       min[i]   = 0.0;
@@ -260,26 +260,14 @@ Bool_t AliRsnFunction::Fill()
   Int_t  i;
   Double_t *values = new Double_t[fSize];
 
-  AliRsnFunctionAxis *fcnAxis = 0;
+  AliRsnValue *fcnAxis = 0;
   for (i = 0; i < fSize; i++) {
-    fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(i);
+    fcnAxis = (AliRsnValue*)fAxisList.At(i);
     if (!fcnAxis) {
       values[i] = 0.0;
       continue;
     }
-    switch (fcnAxis->GetAxisObject()) {
-    case AliRsnFunctionAxis::kParticle:
-      values[i] = fcnAxis->Eval(fTrack);
-      break;
-    case AliRsnFunctionAxis::kPair:
-      values[i] = fcnAxis->Eval(fPair, fPairDef);
-      break;
-    case AliRsnFunctionAxis::kEvent:
-      values[i] = fcnAxis->Eval(fEvent);
-      break;
-    default:
-      values[i] = 0.0;
-    }
+    if (fcnAxis->Eval(fPair, fPairDef, fEvent)) values[i] = fcnAxis->GetValue();
   }
   
   // fill histogram
index 45ee40cf46739d8e2b52f0c62596173cf3d33f88..d2cf00c12e436f9af935d00058cc43b20a820bcb 100644 (file)
@@ -31,8 +31,8 @@
 
 #include "AliRsnCut.h"
 
-class AliRsnFunctionAxis;
-class AliRsnPairParticle;
+class AliRsnValue;
+class AliRsnMother;
 class AliRsnPairDef;
 
 class AliRsnFunction : public TNamed
@@ -46,20 +46,18 @@ class AliRsnFunction : public TNamed
     const AliRsnFunction& operator=(const AliRsnFunction &copy);
 
     void                 SetPairDef(AliRsnPairDef * const def) {fPairDef = def;}
-    void                 SetTrack(AliRsnDaughter * const track) {fTrack = track;}
-    void                 SetPair(AliRsnPairParticle * const pair) {fPair = pair;}
+    void                 SetPair(AliRsnMother * const pair) {fPair = pair;}
     void                 SetEvent(AliRsnEvent *const event) {fEvent = event;}
 
     AliRsnPairDef*       GetPairDef() const {return fPairDef;}
-    AliRsnDaughter*      GetTrack() const {return fTrack;}
-    AliRsnPairParticle*  GetPair() const {return fPair;}
+    AliRsnMother*        GetPair() const {return fPair;}
     AliRsnEvent*         GetEvent() const {return fEvent;}
     virtual const char*  GetName() const;
 
     Bool_t               IsUsingTH1() {return fUseTH1;}
     void                 UseTH1() {fUseTH1 = kTRUE;}
     void                 UseSparse() {fUseTH1 = kFALSE;}
-    void                 AddAxis(AliRsnFunctionAxis*const axis);
+    void                 AddAxis(AliRsnValue* const axis);
     Int_t                GetNumberOfAxes() {return fAxisList.GetEntries();}
     TH1*                 CreateHistogram(const char *histoName, const char *histoTitle);
     THnSparseD*          CreateHistogramSparse(const char *histoName, const char *histoTitle);
@@ -71,8 +69,7 @@ class AliRsnFunction : public TNamed
     AliRsnPairDef      *fPairDef;     // reference to used pair definition
     TClonesArray        fAxisList;    // list of axis
 
-    AliRsnDaughter     *fTrack;       // processed track
-    AliRsnPairParticle *fPair;        // processed pair
+    AliRsnMother       *fPair;        // processed pair
     AliRsnEvent        *fEvent;       // processed event
 
     Bool_t              fUseTH1;      // use TH1 or not?
diff --git a/PWG2/RESONANCES/AliRsnFunctionAxis.cxx b/PWG2/RESONANCES/AliRsnFunctionAxis.cxx
deleted file mode 100644 (file)
index 1121c25..0000000
+++ /dev/null
@@ -1,265 +0,0 @@
-//
-// Class AliRsnFunctionAxis
-//
-// 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
-//
-
-#include <TArrayD.h>
-
-#include "AliRsnEvent.h"
-#include "AliRsnPairParticle.h"
-#include "AliRsnPairDef.h"
-#include "AliRsnFunctionAxis.h"
-
-ClassImp(AliRsnFunctionAxis)
-
-//_____________________________________________________________________________
-AliRsnFunctionAxis::AliRsnFunctionAxis() :
-    fType(kAxisTypes),
-    fNBins(0),
-    fMin(0.0),
-    fMax(0.0),
-    fMass(0.0)
-{
-//
-// Default constructor
-//
-}
-
-//_____________________________________________________________________________
-AliRsnFunctionAxis::AliRsnFunctionAxis
-(EAxisType type, Int_t nbins, Double_t min, Double_t max) :
-    fType(type),
-    fNBins(0),
-    fMin(0.0),
-    fMax(0.0),
-    fMass(0.0)
-{
-//
-// Main constructor (version 1)
-//
-
-  SetBins(nbins, min, max);
-}
-
-//_____________________________________________________________________________
-AliRsnFunctionAxis::AliRsnFunctionAxis
-(EAxisType type, Double_t min, Double_t max, Double_t step) :
-    fType(type),
-    fNBins(0),
-    fMin(0.0),
-    fMax(0.0),
-    fMass(0.0)
-{
-//
-// Main constructor (version 2)
-//
-
-  SetBins(min, max, step);
-}
-
-//_____________________________________________________________________________
-const char* AliRsnFunctionAxis::GetName() const
-{
-//
-// Return the name of this object defined by the type
-//
-
-  switch (fType)
-  {
-    case kTrackPt:        return "PT";
-    case kTrackEta:       return "ETA";
-    case kTrack1P:        return "P1";
-    case kTrack2P:        return "P2";
-    case kTrack1Pt:       return "PT1";
-    case kTrack2Pt:       return "PT2";
-    case kPairInvMass:    return "IM";
-    case kPairInvMassMC:  return "IMMC";
-    case kPairInvMassRes: return "IMRES";
-    case kPairPt:         return "PT";
-    case kPairEta:        return "ETA";
-    case kPairMt:         return "MT";
-    case kPairY:          return "Y";
-    case kEventMult:      return "MULT";
-    default:              return "UNDEF";
-  }
-}
-
-//_____________________________________________________________________________
-TArrayD AliRsnFunctionAxis::GetArray() const
-{
-//
-// Creates an array with all bin edges
-//
-
-  TArrayD out(fNBins + 1);
-
-  Int_t i;
-  Double_t step = (fMax - fMin) / (Double_t)fNBins;
-
-  for (i = 0; i <= fNBins; i++) out[i] = fMin + step * (Double_t)i;
-
-  return out;
-}
-
-//_____________________________________________________________________________
-AliRsnFunctionAxis::EAxisObject AliRsnFunctionAxis::GetAxisObject() const
-{
-//
-// Tells what kind of object must be evaluated for this axis
-//
-
-  switch (fType)
-  {
-    case kTrackPt:
-    case kTrackEta:
-      return kParticle;
-    case kTrack1P:
-    case kTrack2P:
-    case kTrack1Pt:
-    case kTrack2Pt:
-    case kPairInvMass:
-    case kPairInvMassMC:
-    case kPairInvMassRes:
-    case kPairPt:
-    case kPairEta:
-    case kPairMt:
-    case kPairY:
-      return kPair;
-    case kEventMult:
-      return kEvent;
-    default:
-      return kNone;
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnFunctionAxis::SetBins(Int_t n, Double_t min, Double_t max)
-{
-//
-// Set binning for histogram.
-//
-
-  fNBins = n;
-
-  if (min < max) {
-    fMin = min;
-    fMax = max;
-  } else {
-    fMin = max;
-    fMax = min;
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnFunctionAxis::SetBins(Double_t min, Double_t max, Double_t step)
-{
-//
-// Binning for histogram.
-//
-
-  if (min < max) {
-    fMin = min;
-    fMax = max;
-  } else {
-    fMin = max;
-    fMax = min;
-  }
-
-  fNBins = (Int_t)((fMax - fMin) / (step)) + 1;
-}
-
-//_____________________________________________________________________________
-Double_t AliRsnFunctionAxis::Eval(AliRsnDaughter*const daughter) const
-{
-//
-// EValuation method for single tracks
-// (currently disabled)
-//
-
-  switch (fType)
-  {
-    case kTrackPt:
-      return daughter->Pt();
-    case kTrackEta:
-      return daughter->Eta();
-    default:
-      AliWarning("This axis type cannot be applied to particles");
-      return -999.0;
-  }
-
-  return 0.0;
-}
-
-//_____________________________________________________________________________
-Double_t AliRsnFunctionAxis::Eval(AliRsnPairParticle * const pair, AliRsnPairDef *const pairDef) const
-{
-//
-// EValuation method for pairs.
-// Requires also the pair definitions, in order to retrieve mass.
-//
-
-  Double_t mass = pairDef->GetMotherMass();
-
-  switch (fType)
-  {
-    case kTrack1P:
-      return pair->GetDaughter(0)->P();
-    case kTrack2P:
-      return pair->GetDaughter(1)->P();
-    case kTrack1Pt:
-      return pair->GetDaughter(0)->Pt();
-    case kTrack2Pt:
-      return pair->GetDaughter(1)->Pt();
-    case kPairInvMass:
-      return pair->GetInvMass(pairDef->GetMass(0), pairDef->GetMass(1));
-    case kPairInvMassMC:
-      return pair->GetInvMassMC(pairDef->GetMass(0), pairDef->GetMass(1));
-    case kPairInvMassRes: {
-        Double_t value;
-        value  = pair->GetInvMass(pairDef->GetMass(0), pairDef->GetMass(1));
-        value -= pair->GetInvMassMC(pairDef->GetMass(0), pairDef->GetMass(1));
-        value /= pair->GetInvMassMC(pairDef->GetMass(0), pairDef->GetMass(1));
-        return value;
-      }
-    case kPairPt:
-      return pair->GetPt();
-    case kPairEta:
-      return pair->GetEta();
-    case kPairMt:
-      //if (TMath::Abs(fMass) < 1E-5) AliWarning(Form("Suspicious mass value specified: %f", fMass));
-      //return TMath::Sqrt(pair->GetPt()*pair->GetPt() + fMass*fMass);
-      if (TMath::Abs(mass) < 1E-5) AliWarning(Form("Suspicious mass value specified: %f", mass));
-      return (TMath::Sqrt(pair->GetPt()*pair->GetPt() + mass*mass) - mass);
-    case kPairY:
-      //if (TMath::Abs(fMass) < 1E-5) AliWarning(Form("Suspicious mass value specified: %f", fMass));
-      //return pair->GetY(fMass);
-      if (TMath::Abs(mass) < 1E-5) AliWarning(Form("Suspicious mass value specified: %f", mass));
-      return pair->GetY(mass);
-    default:
-      AliWarning("This axis type cannot be applied to pairs");
-      return -999.0;
-  }
-}
-
-//_____________________________________________________________________________
-Double_t AliRsnFunctionAxis::Eval(AliRsnEvent *const event) const
-{
-//
-// EValuation method for events
-//
-
-  switch (fType)
-  {
-    case kEventMult:
-      return (Double_t)event->GetMultiplicity();
-    default:
-      AliWarning("This axis type cannot be applied to events");
-      return 0.0;
-  }
-}
diff --git a/PWG2/RESONANCES/AliRsnFunctionAxis.h b/PWG2/RESONANCES/AliRsnFunctionAxis.h
deleted file mode 100644 (file)
index 7a60790..0000000
+++ /dev/null
@@ -1,82 +0,0 @@
-//
-// Class AliRsnFunctionAxis
-//
-// 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 ALIRSNFUNCTIONAXIS_H
-#define ALIRSNFUNCTIONAXIS_H
-
-
-class TArrayD;
-class AliRsnPairDef;
-
-class AliRsnFunctionAxis : public TObject
-{
-  public:
-
-    enum EAxisType {
-      kTrackPt,
-      kTrackEta,
-      kTrack1P,
-      kTrack2P,
-      kTrack1Pt,
-      kTrack2Pt,
-      kPairInvMass,
-      kPairInvMassMC,
-      kPairInvMassRes,
-      kPairPt,
-      kPairEta,
-      kPairMt,
-      kPairY,
-      kEventMult,
-      kAxisTypes
-    };
-
-    enum EAxisObject {
-      kParticle,
-      kPair,
-      kEvent,
-      kNone
-    };
-
-    AliRsnFunctionAxis();
-    AliRsnFunctionAxis(EAxisType type, Int_t n, Double_t min, Double_t max);
-    AliRsnFunctionAxis(EAxisType type, Double_t min, Double_t max, Double_t step);
-    virtual ~AliRsnFunctionAxis() { }
-
-    virtual const char* GetName() const;
-
-    Int_t       GetNBins() const {return fNBins;}
-    Double_t    GetMin() const {return fMin;}
-    Double_t    GetMax() const {return fMax;}
-    TArrayD     GetArray() const;
-    EAxisObject GetAxisObject() const;
-
-    void     SetType(EAxisType type) {fType = type;}
-    void     SetBins(Int_t n, Double_t min, Double_t max);
-    void     SetBins(Double_t min, Double_t max, Double_t step);
-    void     SetMass(Double_t mass) {fMass = mass;}
-
-    Double_t Eval(AliRsnDaughter * const daughter) const;
-    Double_t Eval(AliRsnPairParticle*const pair, AliRsnPairDef*const pairDef) const;
-    Double_t Eval(AliRsnEvent *const event) const;
-
-  private:
-
-    EAxisType fType;    // binning type
-
-    Int_t     fNBins;   // number of bins
-    Double_t  fMin;     // lower edge
-    Double_t  fMax;     // upper edge
-    Double_t  fMass;    // reference mass for Y and Mt bins
-
-    // ROOT dictionary
-    ClassDef(AliRsnFunctionAxis, 1)
-};
-
-#endif
diff --git a/PWG2/RESONANCES/AliRsnHistoDef.cxx b/PWG2/RESONANCES/AliRsnHistoDef.cxx
deleted file mode 100644 (file)
index 61771a6..0000000
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// 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
-//
-
-#include <TObject.h>
-
-//#include "AliLog.h"
-#include "AliRsnHistoDef.h"
-
-ClassImp(AliRsnHistoDef)
-
-//_____________________________________________________________________________
-AliRsnHistoDef::AliRsnHistoDef() :
-    fNBins(0),
-    fMin(0.0),
-    fMax(0.0)
-{
-//
-// Default constructor
-//
-}
-
-//_____________________________________________________________________________
-AliRsnHistoDef::AliRsnHistoDef
-(Int_t nbins, Double_t min, Double_t max) :
-    fNBins(0),
-    fMin(0.0),
-    fMax(0.0)
-{
-//
-// 1D histo definition.
-//
-  SetBins(nbins, min, max);
-}
-
-//_____________________________________________________________________________
-AliRsnHistoDef::AliRsnHistoDef
-(Double_t min, Double_t max, Double_t step) :
-    fNBins(0),
-    fMin(0.0),
-    fMax(0.0)
-{
-//
-// 1D histo definition.
-//
-  SetBins(min, max, step);
-}
-
-//_____________________________________________________________________________
-void AliRsnHistoDef::SetBins(Int_t n, Double_t min, Double_t max)
-{
-//
-// Binning for histogram.
-//
-
-  fNBins = n;
-
-  if (min < max)
-  {
-    fMin = min;
-    fMax = max;
-  }
-  else
-  {
-    fMin = max;
-    fMax = min;
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnHistoDef::SetBins(Double_t min, Double_t max, Double_t step)
-{
-//
-// Binning for histogram.
-//
-
-  if (min < max)
-  {
-    fMin = min;
-    fMax = max;
-  }
-  else
-  {
-    fMin = max;
-    fMax = min;
-  }
-
-  fNBins = (Int_t)((fMax - fMin) / (step)) + 1;
-}
diff --git a/PWG2/RESONANCES/AliRsnHistoDef.h b/PWG2/RESONANCES/AliRsnHistoDef.h
deleted file mode 100644 (file)
index 2bdd01f..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// Class AliRsnHistoDef
-//
-// 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
-
-class AliRsnHistoDef : public TObject
-{
-  public:
-
-    AliRsnHistoDef();
-    AliRsnHistoDef(Int_t n, Double_t min, Double_t max);
-    AliRsnHistoDef(Double_t min, Double_t max, Double_t step);
-    virtual ~AliRsnHistoDef() { }
-
-    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(Double_t min, Double_t max, Double_t step);
-
-  private:
-
-    Int_t     fNBins;   // number of bins
-    Double_t  fMin;     // lower edge
-    Double_t  fMax;     // upper edge
-
-    // ROOT dictionary
-    ClassDef(AliRsnHistoDef, 1)
-};
-
-#endif
diff --git a/PWG2/RESONANCES/AliRsnMother.cxx b/PWG2/RESONANCES/AliRsnMother.cxx
new file mode 100644 (file)
index 0000000..df51c0a
--- /dev/null
@@ -0,0 +1,237 @@
+//
+// Class AliRsnMother
+//
+// Implementation of a pair of tracks, for several purposes
+// - computing the total 4-momentum & inv. mass for output histos filling
+// - evaluating cut checks on the pair of particles
+// - evaluating any kind of kinematic value over their sum
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+#include <Riostream.h>
+#include "AliRsnDaughter.h"
+#include "AliRsnPairDef.h"
+#include "AliRsnMother.h"
+
+ClassImp(AliRsnMother)
+
+//_____________________________________________________________________________
+AliRsnMother::AliRsnMother() : 
+  fUseMC(kFALSE),
+  fDefaultMass(0.0),
+  fSum(),
+  fSumMC(),
+  fRef(),
+  fRefMC()
+{
+//
+// Constructor.
+// Initializes all variables to meaningless values.
+//
+
+  Int_t i;
+  for (i = 0; i < 2; i++) fDaughter[i] = 0x0;
+}
+
+//_____________________________________________________________________________
+AliRsnMother::AliRsnMother(const AliRsnMother &obj) : 
+  TObject(obj), 
+  fUseMC(obj.fUseMC),
+  fDefaultMass(obj.fDefaultMass),
+  fSum(obj.fSum),
+  fSumMC(obj.fSumMC),
+  fRef(obj.fRef),
+  fRefMC(obj.fRefMC)
+{
+//
+// Copy constructor.
+// Initializes all variables to copy values.
+// Does not duplicate pointers.
+//
+
+  Int_t i;
+  for (i = 0; i < 2; i++) fDaughter[i] = obj.fDaughter[i];
+}
+
+//_____________________________________________________________________________
+AliRsnMother& AliRsnMother::operator=(const AliRsnMother &obj)
+{
+//
+// Assignment operator.
+// Initializes all variables to copy values.
+// Does not duplicate pointers.
+//
+
+  Int_t i;
+  
+  fDefaultMass = obj.fDefaultMass;
+  fSum = obj.fSum;
+  fRef = obj.fRef;
+  fSumMC = obj.fSumMC;
+  fRefMC = obj.fRefMC;
+  
+  for (i = 0; i < 2; i++) fDaughter[i] = obj.fDaughter[i];
+
+  return (*this);
+}
+
+//_____________________________________________________________________________
+AliRsnMother::~AliRsnMother()
+{
+//
+// Desctructor.
+// Does nothing, since pointers are not created in this class.
+//
+}
+
+//_____________________________________________________________________________
+Int_t AliRsnMother::CommonMother() const
+{
+//
+// Checks if the two tracks in the pair have the same mother.
+// This can be known if MC info is present.
+// If the mother label is the same, rhe PDG code of the mother is returned,
+// otherwise the method returns 0.
+//
+
+  // if MC info is not available, the pairs is not true by default
+  if (!fDaughter[0]->GetRefMC() || !fDaughter[1]->GetRefMC()) 
+  {
+    AliInfo("Cannot know if the pairs is true or not because MC Info is not present");
+    return 0;
+  }
+
+  // check that labels are the same
+  if (fDaughter[0]->GetParticle()->GetFirstMother() != fDaughter[1]->GetParticle()->GetFirstMother())
+    return 0;
+
+  // if we reach this point, the two tracks have the same mother
+  // let's check now the PDG code of this common mother
+  return TMath::Abs(fDaughter[0]->GetMotherPDG());
+}
+
+//_____________________________________________________________________________
+void AliRsnMother::SetDaughters
+(AliRsnDaughter *d0, Double_t mass0, AliRsnDaughter *d1, Double_t mass1)
+{
+//
+// Sets the pair defined in this usind tso passed daughters and two masses
+// which will be assigned to them, in order to recompute their 4-momenta
+// and sum them into the datamembers of this object.
+//
+
+  if (d0) fDaughter[0] = d0;
+  if (d1) fDaughter[1] = d1;
+  
+  if (!d0 || !d1) return;
+  
+  fDaughter[0]->SetMass(mass0);
+  fDaughter[1]->SetMass(mass1);
+  
+  fSum   = fDaughter[0]->P(kFALSE) + fDaughter[1]->P(kFALSE);
+  fSumMC = fDaughter[0]->P(kTRUE)  + fDaughter[1]->P(kTRUE);
+  
+  fRef  .SetXYZM(fSum  .X(), fSum  .Y(), fSum  .Z(), fDefaultMass);
+  fRefMC.SetXYZM(fSumMC.X(), fSumMC.Y(), fSumMC.Z(), fDefaultMass);
+}
+
+//_____________________________________________________________________________
+void AliRsnMother::ResetPair()
+{
+//
+// Resets the mother, nullifying all data members
+//
+
+  Int_t i;
+  for (i = 0; i < 2; i++) fDaughter[i] = 0x0;
+  
+  fSum  .SetXYZM(0.0, 0.0, 0.0, 0.0);
+  fRef  .SetXYZM(0.0, 0.0, 0.0, 0.0);
+  fSumMC.SetXYZM(0.0, 0.0, 0.0, 0.0);
+  fRefMC.SetXYZM(0.0, 0.0, 0.0, 0.0);
+}
+
+//_____________________________________________________________________________
+void AliRsnMother::PrintInfo(const Option_t * /*option*/) const
+{
+//
+// 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();
+  AliInfo("Track #2");
+  fDaughter[1]->Print();
+  AliInfo("========= END PAIR INFO ===========");
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnMother::CheckPair() const
+{
+//
+// Checks that the pair is well initialized:
+// - both daughters are good pointers
+// - if MC is required, both daughters have a MC reference
+//
+
+  if (!fDaughter[0] || !fDaughter[1]) 
+  {
+    AliError("One of the two tracks is NULL in this pair!");
+    return kFALSE;
+  }
+  
+  if (fUseMC)
+  {
+    if (fDaughter[0]->GetRefMC() == 0x0 || fDaughter[1]->GetRefMC() == 0x0)
+    {
+      AliError("Required MC info but not all MC refs are available");
+      return kFALSE;
+    }
+  }
+  
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnMother::MatchesDef(AliRsnPairDef *def)
+{
+//
+// Checks if the daughters, in any order, do match a given decay channel,
+// using the specified identification method, which can be the 'true' one
+// or the 'realistic' one only.
+//
+
+  if (!def) return kFALSE;
+  if (!fDaughter[0]->GetRefMC()) return kFALSE;
+  if (!fDaughter[1]->GetRefMC()) return kFALSE;
+
+  Bool_t decayMatch = kFALSE;
+  Int_t  pdg[2], ref[2];
+  pdg[0] = fDaughter[0]->GetRefMC()->Particle()->GetPdgCode();
+  pdg[1] = fDaughter[1]->GetRefMC()->Particle()->GetPdgCode();
+  ref[0] = TMath::Abs(AliPID::ParticleCode(def->GetPID(0)));
+  ref[1] = TMath::Abs(AliPID::ParticleCode(def->GetPID(1)));
+
+  // check #1:
+  // if first member of pairDef has same sign as first member of this,
+  // daughter[0] perfect PID must match first member of pairDef
+  // daughter[1] perfect PID must march second member of pairDef
+  if (fDaughter[0]->IsSign(def->GetCharge(0)) && fDaughter[1]->IsSign(def->GetCharge(1))) 
+  {
+    decayMatch = (pdg[0] == ref[0] && pdg[1] == ref[1]);
+  }
+
+  // check #2:
+  // if first member of pairDef has same sign as second member of this,
+  // daughter[0] perfect PID must match second member of pairDef
+  // daughter[1] perfect PID must march first member of pairDef
+  if (fDaughter[1]->IsSign(def->GetCharge(0)) && fDaughter[0]->IsSign(def->GetCharge(1))) 
+  {
+    decayMatch = (pdg[0] == ref[1] && pdg[1] == ref[0]);
+  }
+
+  return (decayMatch && (CommonMother() == def->GetMotherPDG()));
+}
diff --git a/PWG2/RESONANCES/AliRsnMother.h b/PWG2/RESONANCES/AliRsnMother.h
new file mode 100644 (file)
index 0000000..d5c7dd0
--- /dev/null
@@ -0,0 +1,64 @@
+//
+// Class AliRsnMother
+//
+// Implementation of a pair of tracks, for several purposes
+// - computing the total 4-momentum & inv. mass for output histos filling
+// - evaluating cut checks on the pair of particles
+// - evaluating any kind of kinematic value over their sum
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#ifndef ALIRSNMOTHER_H
+#define ALIRSNMOTHER_H
+
+#include <TLorentzVector.h>
+
+#include "AliRsnDaughter.h"
+
+class AliRsnPairDef;
+
+class AliRsnMother : public TObject
+{
+  public:
+
+    AliRsnMother();
+    AliRsnMother(const AliRsnMother &obj);
+    AliRsnMother& operator=(const AliRsnMother &obj);
+    virtual ~AliRsnMother();
+    
+    void              SetDefaultMass(Double_t mass) {fDefaultMass = mass; fRef.SetXYZM(fSum.X(),fSum.Y(),fSum.Z(),mass); fRefMC.SetXYZM(fSumMC.X(),fSumMC.Y(),fSumMC.Z(),mass);}
+    TLorentzVector&   Sum() {return fSum;}
+    TLorentzVector&   Ref() {return fRef;}
+    TLorentzVector&   SumMC() {return fSumMC;}
+    TLorentzVector&   RefMC() {return fRefMC;}
+    Double_t          OpeningAngle(Bool_t mc = kFALSE) const {if (fDaughter[0] && fDaughter[1]) return fDaughter[0]->P(mc).Angle(fDaughter[1]->P(mc).Vect()); return 1E6;}
+    Double_t          AngleTo(AliRsnDaughter track, Bool_t mc = kFALSE) const {return fSum.Angle(track.P(mc).Vect());}
+
+    AliRsnDaughter*   GetDaughter(const Int_t &index) const {if (index==0||index==1) return fDaughter[index]; return 0x0;}
+
+    Bool_t            IsLabelEqual() const {return abs(fDaughter[0]->GetLabel()) == abs(fDaughter[1]->GetLabel());}
+    Bool_t            IsIndexEqual() const {return (fDaughter[0]->GetID() == fDaughter[1]->GetID());}
+    Int_t             CommonMother() const;
+
+    void              SetDaughters(AliRsnDaughter * const daughter1, Double_t mass1, AliRsnDaughter * const daughter2, Double_t mass2);
+    void              ResetPair();
+    void              PrintInfo(const Option_t *option = "ALL") const;
+    Bool_t            CheckPair() const;
+    Bool_t            MatchesDef(AliRsnPairDef *pairDef);
+
+  private:
+
+    Bool_t           fUseMC;            // choose if momenta are taken from ESD/AOD or MC
+    Double_t         fDefaultMass;      // nominal resonance mass
+    AliRsnDaughter  *fDaughter[2];      // elements of the pair
+    TLorentzVector   fSum;              // sum computed from the two daughters
+    TLorentzVector   fSumMC;            // sum computed from the two daughters
+    TLorentzVector   fRef;              // a 4-vector with same momentum as the sum but the nominal mass of mother
+    TLorentzVector   fRefMC;            // a 4-vector with same momentum as the sum but the nominal mass of mother
+
+    ClassDef(AliRsnMother,1)
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnPIDDefESD.cxx b/PWG2/RESONANCES/AliRsnPIDDefESD.cxx
deleted file mode 100644 (file)
index 71c4bd7..0000000
+++ /dev/null
@@ -1,284 +0,0 @@
-/**************************************************************************
- * 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 AliRsnPIDDefESD
-//                     -------------------
-//           Simple collection of reconstructed tracks
-//           selected from an ESD event
-//           to be used for analysis.
-//           .........................................
-//
-// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
-//-------------------------------------------------------------------------
-
-#include <TString.h>
-
-#include "AliLog.h"
-#include "AliESDtrack.h"
-#include "AliRsnPIDDefESD.h"
-
-ClassImp(AliRsnPIDDefESD)
-
-//_____________________________________________________________________________
-AliRsnPIDDefESD::AliRsnPIDDefESD() :
-    fUseESDWeights(kTRUE)
-{
-//
-// Default constructor.
-// By default, it is set for using ESD weights,
-// so, values in other members are meaningless.
-//
-
-  Int_t i;
-  for (i = 0; i < kDetectors; i++) {
-    fUseDet[i] = kTRUE;
-    fDivValue[i] = 0.0;
-    fUseHigher[i] = kTRUE;
-  }
-}
-
-//_____________________________________________________________________________
-AliRsnPIDDefESD::AliRsnPIDDefESD(const AliRsnPIDDefESD& copy) :
-    TObject(copy),
-    fUseESDWeights(copy.fUseESDWeights)
-{
-//
-// Copy constructor.
-// Implemented to manage passing of this object to functions
-//
-
-  Int_t i;
-  for (i = 0; i < kDetectors; i++) {
-    fUseDet[i] = copy.fUseDet[i];
-    fDivValue[i] = copy.fDivValue[i];
-    fUseHigher[i] = copy.fUseHigher[i];
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnPIDDefESD::SetScheme(EScheme scheme, Double_t divValue)
-{
-//
-// Set one of the predefined schemes
-//
-
-  switch (scheme) {
-  case kSchemeESD:
-    fUseESDWeights = kTRUE;
-    break;
-  case kSchemeITS:
-    fUseESDWeights = kFALSE;
-    ExcludeAll();
-    IncludeDet(kITS);
-    SetDivValue(kITS, 0.0);
-    break;
-  case kSchemeTPC:
-    fUseESDWeights = kFALSE;
-    ExcludeAll();
-    IncludeDet(kTPC);
-    SetDivValue(kTPC, 0.0);
-    break;
-  case kSchemeTOF:
-    fUseESDWeights = kFALSE;
-    ExcludeAll();
-    IncludeDet(kTOF);
-    SetDivValue(kTOF, 0.0);
-    break;
-  case kSchemeITSandTPC:
-    fUseESDWeights = kFALSE;
-    ExcludeAll();
-    IncludeDet(kITS);
-    IncludeDet(kTPC);
-    SetDivValue(kITS, 0.0);
-    SetDivValue(kTPC, 0.0);
-    break;
-  case kSchemeITSandTOF:
-    fUseESDWeights = kFALSE;
-    ExcludeAll();
-    IncludeDet(kITS);
-    IncludeDet(kTOF);
-    SetDivValue(kITS, 0.0);
-    SetDivValue(kTOF, 0.0);
-    break;
-  case kSchemeTPCandTOF:
-    fUseESDWeights = kFALSE;
-    ExcludeAll();
-    IncludeDet(kTPC);
-    IncludeDet(kTOF);
-    SetDivValue(kTPC, 0.0);
-    SetDivValue(kTOF, 0.0);
-    break;
-  case kSchemeITSandTPCandTOF:
-    fUseESDWeights = kFALSE;
-    ExcludeAll();
-    IncludeDet(kITS);
-    IncludeDet(kTPC);
-    IncludeDet(kTOF);
-    SetDivValue(kITS, 0.0);
-    SetDivValue(kTPC, 0.0);
-    SetDivValue(kTOF, 0.0);
-    break;
-  case kSchemeITSandTPCandTOFwithSP:
-    fUseESDWeights = kFALSE;
-    ExcludeAll();
-    IncludeDet(kITS);
-    IncludeDet(kTPC);
-    IncludeDet(kTOF);
-    SetDivValue(kITS, 0.0);
-    SetDivValue(kTPC, 0.0);
-    SetDivValue(kTOF, divValue);
-    break;
-  case kSchemeITSandTPCorTOFwithSP:
-    fUseESDWeights = kFALSE;
-    ExcludeAll();
-    IncludeDet(kITS);
-    IncludeDet(kTPC);
-    IncludeDet(kTOF);
-    SetDivValue(kITS, divValue, kFALSE);
-    SetDivValue(kTPC, divValue, kFALSE);
-    SetDivValue(kTOF, divValue, kTRUE);
-    break;
-  default:
-    AliWarning("PID scheme unrecognized. Set to ESD");
-    fUseESDWeights = kTRUE;
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnPIDDefESD::ComputeWeights(AliESDtrack *track, Double_t *weights)
-{
-//
-// Computes the global PID weights using the given ranges
-//
-
-  if (fUseESDWeights) {
-    track->GetESDpid(weights);
-    return;
-  }
-
-  Double_t pt = track->Pt();
-  Double_t w[kDetectors][AliPID::kSPECIES];
-  track->GetITSpid(w[kITS]);
-  track->GetTPCpid(w[kTPC]);
-  track->GetTRDpid(w[kTRD]);
-  track->GetTOFpid(w[kTOF]);
-  track->GetHMPIDpid(w[kHMPID]);
-
-  Int_t i, j;
-  for (i = 0; i < kDetectors; i++) {
-//     if (!fUseDet[i] || pt < fDivValue[i])
-    if (!fUseDet[i] || !CheckDivValue((EDetector)i,pt)) {
-      for (j = 0; j < AliPID::kSPECIES; j++) {
-        w[i][j] = 1.0;
-      }
-    }
-  }
-
-  for (i = 0; i < AliPID::kSPECIES; i++) {
-    weights[i] = w[kITS][i] * w[kTPC][i] * w[kTRD][i] * w[kTOF][i] * w[kHMPID][i];
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnPIDDefESD::PrintStatus()
-{
-//
-// Print informations about this object configurations
-//
-
-  AliInfo("===== PIDDef status messages -- BEGIN");
-
-  if (fUseESDWeights) {
-    AliInfo("Using ESD weights");
-  } else {
-    AliInfo("NOT using ESD weights");
-  }
-
-  Int_t i;
-  for (i = 0; i < kDetectors; i++) {
-    AliInfo(Form("Detector name: %s -- accepted: %s -- divValue = %3.1f useHigher = %s", DetName((EDetector)i), (fUseDet[i]?"YES":"NO"), fDivValue[i],(fUseHigher[i]?"YES":"NO")));
-  }
-
-  AliInfo("===== PIDDef status messages -- END");
-}
-
-//_____________________________________________________________________________
-const char* AliRsnPIDDefESD::DetName(EDetector det) const
-{
-//
-// Detector name for messages
-//
-
-  switch (det) {
-  case kITS: return "ITS";
-  case kTPC: return "TPC";
-  case kTRD: return "TRD";
-  case kTOF: return "TOF";
-  case kHMPID: return "HMPID";
-  default: return "undef";
-  }
-}
-
-//_____________________________________________________________________________
-const char* AliRsnPIDDefESD::SchemeName()
-{
-//
-// Scheme name for messages
-//
-
-  TString out;
-
-  Int_t i, ndet = 0;
-
-  for (i = 0; i < kDetectors; i++)
-    if (fUseDet[i]) {
-      if (ndet > 0) out += '_';
-      out.Append(DetName((EDetector)i));
-    }
-
-  return out.Data();
-}
-
-//_____________________________________________________________________________
-void AliRsnPIDDefESD::SetDivValue(EDetector det, Double_t value, Bool_t userHigher)
-{
-//
-// Sets div.value properties for detector
-//
-  if (CheckBounds(det)) {
-    fDivValue[det] = value;
-    fUseHigher[det] = userHigher;
-  }
-}
-
-//_____________________________________________________________________________
-Bool_t AliRsnPIDDefESD::CheckDivValue(EDetector det,Double_t value)
-{
-//
-// Sets div.value properties for detector
-//
-  if (CheckBounds(det)) {
-    if (fUseHigher[det]) {
-      if (value > fDivValue[det]) return kTRUE;
-      else return kFALSE;
-    } else {
-      if (value < fDivValue[det]) return kTRUE;
-      else return kFALSE;
-    }
-  }
-
-  return kTRUE;
-}
diff --git a/PWG2/RESONANCES/AliRsnPIDDefESD.h b/PWG2/RESONANCES/AliRsnPIDDefESD.h
deleted file mode 100644 (file)
index 3dae9fa..0000000
+++ /dev/null
@@ -1,77 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               *
- **************************************************************************/
-
-/* $Id: AliRsnPIDScheme.h,v 1.5 2007/02/21 14:33:25 pulvir Exp $ */
-
-//-------------------------------------------------------------------------
-//                      Class AliRsnPIDDef
-//  Simple collection of reconstructed tracks, selected from an ESD event
-//
-// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
-//-------------------------------------------------------------------------
-
-#ifndef ALIRSNPIDDEFESD_H
-#define ALIRSNPIDDEFESD_H
-
-class AliESDtrack;
-
-class AliRsnPIDDefESD : public TObject
-{
-  public:
-
-    enum EDetector {
-      kITS = 0,
-      kTPC,
-      kTRD,
-      kTOF,
-      kHMPID,
-      kDetectors
-    };
-
-    enum EScheme {
-      kSchemeESD = 0,
-      kSchemeITS,
-      kSchemeTPC,
-      kSchemeTOF,
-      kSchemeITSandTPC,
-      kSchemeITSandTOF,
-      kSchemeTPCandTOF,
-      kSchemeITSandTPCandTOF,
-      kSchemeITSandTPCandTOFwithSP,
-      kSchemeITSandTPCorTOFwithSP,
-      kSchemeLastPIDType
-    };
-
-    AliRsnPIDDefESD();
-    AliRsnPIDDefESD(const AliRsnPIDDefESD& copy);
-    virtual ~AliRsnPIDDefESD() {}
-
-    void        UseESDWeights() {fUseESDWeights = kTRUE;};
-    void        NoESDWeights() {fUseESDWeights = kFALSE;}
-    void        SetScheme(EScheme scheme, Double_t divValue = 1.0);
-    void        IncludeDet(EDetector det) {if (CheckBounds(det)) fUseDet[det] = kTRUE;}
-    void        ExcludeDet(EDetector det) {if (CheckBounds(det)) fUseDet[det] = kFALSE;}
-    void        IncludeAll() { Int_t det; for (det = 0; det < kDetectors; det++) fUseDet[det] = kTRUE; }
-    void        ExcludeAll() { Int_t det; for (det = 0; det < kDetectors; det++) fUseDet[det] = kFALSE; }
-    void        SetDivValue(EDetector det, Double_t value,Bool_t userHigher=kTRUE);
-    void        ComputeWeights(AliESDtrack *track, Double_t *weights);
-    void        PrintStatus();
-    const char* DetName(EDetector det) const;
-    const char* SchemeName();
-
-  private:
-
-    Bool_t   CheckBounds(EDetector det) const { return (det >= kITS && det < kDetectors); }
-    Bool_t   CheckDivValue(EDetector det,Double_t value);
-
-    Bool_t   fUseESDWeights;          // with this flag, ESD weights are used
-    Bool_t   fUseDet[kDetectors];     // flag to switch off info from a detector
-    Double_t fDivValue[kDetectors];   // division value for detector weight acceptance
-    Double_t fUseHigher[kDetectors];  // accepted higher or lower then div value
-
-    ClassDef(AliRsnPIDDefESD,1);
-};
-
-#endif
diff --git a/PWG2/RESONANCES/AliRsnPIDIndex.cxx b/PWG2/RESONANCES/AliRsnPIDIndex.cxx
deleted file mode 100644 (file)
index 93d172b..0000000
+++ /dev/null
@@ -1,313 +0,0 @@
-//
-// Class AliRsnPIDIndex
-//
-// Sorts the indexes of all tracks in an AliRsnEvent
-// for a fast retrieval of them according to charge and PID.
-//
-// authors: Martin Vala (martin.vala@cern.ch)
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
-//
-
-#include "AliLog.h"
-
-#include "AliRsnEvent.h"
-#include "AliRsnPIDIndex.h"
-
-ClassImp(AliRsnPIDIndex)
-
-//_____________________________________________________________________________
-AliRsnPIDIndex::AliRsnPIDIndex(Int_t num)
-{
-//
-// Default constructor.
-// Reset all arrays to the size specified in the argument (default = 1000).
-//
-
-  Int_t imethod, icharge, ipid, i;
-
-  for (imethod = 0; imethod < AliRsnDaughter::kMethods; imethod++)
-  {
-    for (icharge = 0; icharge < 2; icharge++)
-    {
-      for (ipid = 0; ipid <= AliPID::kSPECIES; ipid++)
-      {
-        fNumOfIndex[imethod][icharge][ipid] = 0;
-        fIndex[imethod][icharge][ipid].Set(num);
-        for (i = 0; i < num; i++) fIndex[imethod][icharge][ipid].AddAt(-1, i);
-      }
-    }
-  }
-}
-
-//_____________________________________________________________________________
-AliRsnPIDIndex::AliRsnPIDIndex(const AliRsnPIDIndex & copy) :
-  TObject(copy)
-{
-//
-// Copy constructor.
-// Duplicates all arrays.
-//
-
-  Int_t imethod, icharge, ipid, i, size;
-
-  for (imethod = 0; imethod < AliRsnDaughter::kMethods; imethod++)
-  {
-    for (icharge = 0; icharge < 2; icharge++)
-    {
-      for (ipid = 0; ipid <= AliPID::kSPECIES; ipid++)
-      {
-        fNumOfIndex[imethod][icharge][ipid] = copy.fNumOfIndex[imethod][icharge][ipid];
-        size = copy.fIndex[imethod][icharge][ipid].GetSize();
-        fIndex[imethod][icharge][ipid].Set(size);
-        for (i = 0; i < size; i++) {
-          fIndex[imethod][icharge][ipid].AddAt(copy.fIndex[imethod][icharge][ipid].At(i), i);
-        }
-      }
-    }
-  }
-}
-
-//_____________________________________________________________________________
-AliRsnPIDIndex& AliRsnPIDIndex::operator= (const AliRsnPIDIndex & copy)
-{
-//
-// Assignment operator.
-// Duplicates all arrays.
-//
-
-  Int_t imethod, icharge, ipid, k, size;
-
-  for (imethod = 0; imethod < AliRsnDaughter::kMethods; imethod++)
-  {
-    for (icharge = 0; icharge < 2; icharge++)
-    {
-      for (ipid = 0; ipid <= AliPID::kSPECIES; ipid++)
-      {
-        fNumOfIndex[imethod][icharge][ipid] = copy.fNumOfIndex[imethod][icharge][ipid];
-        size = copy.fIndex[imethod][icharge][ipid].GetSize();
-        fIndex[imethod][icharge][ipid].Set(size);
-        for (k = 0; k < size; k++) {
-          fIndex[imethod][icharge][ipid].AddAt(copy.fIndex[imethod][icharge][ipid].At(k), k);
-        }
-      }
-    }
-  }
-
-  // return this object
-  return (*this);
-}
-
-//_____________________________________________________________________________
-AliRsnPIDIndex::~AliRsnPIDIndex()
-{
-//
-// Destructor.
-// Does nothing.
-//
-}
-
-//_____________________________________________________________________________
-void AliRsnPIDIndex::ResetAll(Int_t num)
-{
-//
-// Resets all arrays to a given size, and storing '-1' in all values
-//
-
-  Int_t imethod, icharge, ipid, i;
-
-  for (imethod = 0; imethod < AliRsnDaughter::kMethods; imethod++)
-  {
-    for (icharge = 0; icharge < 2; icharge++)
-    {
-      for (ipid = 0; ipid <= AliPID::kSPECIES; ipid++)
-      {
-        fNumOfIndex[imethod][icharge][ipid] = 0;
-        fIndex[imethod][icharge][ipid].Set(num);
-        for (i = 0; i < num; i++) fIndex[imethod][icharge][ipid].AddAt(-1, i);
-      }
-    }
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnPIDIndex::Print(Option_t* /*option*/) const
-{
-//
-// Prints AliRsnPIDIndex info
-//
-
-  Int_t i, j, l;
-
-  for (l = 0; l < AliRsnDaughter::kMethods; l++) {
-    for (i = 0; i < 2; i++) {
-      for (j = 0; j <= AliPID::kSPECIES; j++) {
-        AliInfo(Form(" [%d][%d][%d] %d %d",l, i, j, fIndex[l][i][j].GetSize(), fNumOfIndex[l][i][j]));
-      }
-    }
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnPIDIndex::AddIndex
-(const Int_t index, AliRsnDaughter::EPIDMethod meth, Char_t sign, AliPID::EParticleType type)
-{
-//
-// Adds one index (1st arg) to the corresponding array defined by:
-// - PID method (2nd arg)
-// - charge     (3rd arg)
-// - pid type   (4th arg)
-//
-
-  Int_t iMethod = (Int_t)meth;
-  Int_t iCharge = ChargeIndex(sign);
-  Int_t iType   = (Int_t)type;
-
-  // since AliPID kUnknown = 10 and kSPECIES = 5, the PID is "unknown"
-  // a correction in the storage index must be done
-  if (type == AliPID::kUnknown) iType = (Int_t)AliPID::kSPECIES;
-
-  // debug message (can this be removed?)
-  AliDebug(AliLog::kDebug+1,Form("Adding index=%d method=%d sign='%c', pidType=%d",index,meth,sign,type));
-
-  // check indexes before storing
-  if (iMethod < 0 || iMethod >= AliRsnDaughter::kMethods) return;
-  if (iCharge < 0 || iCharge > 1) return;
-  if (iType < 0 || iType > AliPID::kSPECIES) return;
-
-  // debug to know if adding was successful
-  AliDebug(AliLog::kDebug+1,Form("Adding succeeded for index=%d method=%d sign='%c', pidType=%d",index,meth,sign,type));
-
-  // insert the index in the array and increment the counter of occupied slots
-  fIndex[iMethod][iCharge][iType].AddAt(index, fNumOfIndex[iMethod][iCharge][iType]);
-  fNumOfIndex[iMethod][iCharge][iType]++;
-}
-
-//_____________________________________________________________________________
-void AliRsnPIDIndex::SetCorrectIndexSize()
-{
-//
-// Removes in every array the unused slots, to compress its size.
-//
-
-  Int_t i, j, l;
-  for (l = 0; l < AliRsnDaughter::kMethods; l++) {
-    for (i = 0; i < 2; i++) {
-      for (j = 0; j <= AliPID::kSPECIES; j++) {
-        fIndex[l][i][j].Set(fNumOfIndex[l][i][j]);
-      }
-    }
-  }
-}
-
-//_____________________________________________________________________________
-TArrayI* AliRsnPIDIndex::GetTracksArray
-(AliRsnDaughter::EPIDMethod meth, Char_t sign, AliPID::EParticleType type)
-{
-//
-// Returns the array of indexes of tracks whose charge
-// and PID correspond to the passed arguments:
-//   1) PID method
-//   2) sign of particle ('+' or '-')
-//   3) PID of particle (from AliRsnPID::EType)
-// Otherwise returns null pointer.
-//
-
-  Int_t iMethod = (Int_t)meth;
-  Int_t iCharge = ChargeIndex(sign);
-  Int_t iType   = (Int_t)type;
-
-  // since AliPID kUnknown = 10 and kSPECIES = 5, the PID is "unknown"
-  // a correction in the storage index must be done
-  if (type == AliPID::kUnknown) iType = (Int_t)AliPID::kSPECIES;
-
-  // check indexes
-  if (iMethod < 0 || iMethod >= AliRsnDaughter::kMethods)
-  {
-    AliError("Unrecognized PID method");
-    return 0x0;
-  }
-  if (iCharge < 0 || iCharge > 1)
-  {
-    AliError(Form("Charge index (%d) out of range", iCharge));
-    return 0x0;
-  }
-  if (iType < 0 || iType > AliPID::kSPECIES)
-  {
-    AliError(Form("PID index(%d) out of range", iType));
-    return 0x0;
-  }
-
-  return &fIndex[iMethod][iCharge][iType];
-}
-
-//_____________________________________________________________________________
-TArrayI* AliRsnPIDIndex::GetCharged(Char_t sign)
-{
-//
-// Returns the array of indexes of tracks whose charge
-// corresponds to the passed argument
-// Otherwise returns a null pointer.
-//
-
-  return GetTracksArray(AliRsnDaughter::kNoPID, sign, AliPID::kUnknown);
-}
-
-//_____________________________________________________________________________
-Int_t AliRsnPIDIndex::ChargeIndex(Char_t sign) const
-{
-//
-// Returns the array index corresponding to charge.
-// The inverse operation (returning '+' or '-' depending on charge)
-// is done by 'AliRsnDaughter::GetChargeC()' method.
-//
-
-  if (sign == '+') return 0;
-  else if (sign == '-') return 1;
-  else if (sign == '0') return 2;
-  else {
-    AliError(Form("Character '%c' not recognized as charge sign", sign));
-    return -1;
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnPIDIndex::FillFromEvent(AliRsnEvent* const event)
-{
-//
-// Scans a whole event and fills the arrays depending
-// on the identification of all tracks with all methods.
-//
-
-  Int_t numOfTracks = event->GetMultiplicity();
-
-  // first, reset all arrays to the multiplicity,
-  // in order to avoid 'out of range' errors
-  ResetAll(numOfTracks);
-
-  // now loop on tracks using a unique AliRsnDaughter object
-  // which will point to one track at a time, and allows
-  // to recovery the informations to classify it
-  Int_t i;
-  AliRsnDaughter daughter;
-  for (i = 0; i < numOfTracks; i++)
-  {
-    // link the cursor to current track
-    // this method recoveries the true PID and
-    // combines weights with prior probabilities (defined in AliRsnEvent)
-    // to obtain realistic PID
-    event->SetDaughter(daughter, i);
-
-    // assign current index to right slot for NoPID (essentially the charge)
-    AddIndex(i,AliRsnDaughter::kNoPID,daughter.ChargeC(),AliPID::kUnknown);
-
-    // assign current index to right slot for realistic PID
-    AddIndex(i, AliRsnDaughter::kRealistic, daughter.ChargeC(), daughter.RealisticPID());
-
-    // if MC info is present, assign current index to right slot for true PID
-    if (daughter.GetParticle())
-      AddIndex(i, AliRsnDaughter::kPerfect, daughter.ChargeC(), daughter.PerfectPID());
-  }
-
-  // at the end, compress all arrays to the correct size
-  SetCorrectIndexSize();
-}
diff --git a/PWG2/RESONANCES/AliRsnPIDIndex.h b/PWG2/RESONANCES/AliRsnPIDIndex.h
deleted file mode 100644 (file)
index 6055cd2..0000000
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// Class AliRsnPIDIndex
-//
-// It sorts the indexes of all tracks in an AliRsnEvent
-// for a fast retrieval of them according to charge and PID.
-//
-// authors: Martin Vala (martin.vala@cern.ch)
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
-//
-
-#ifndef ALIRSNPIDINDEX_H
-#define ALIRSNPIDINDEX_H
-
-#include <TArrayI.h>
-
-#include "AliRsnDaughter.h"
-#include "AliRsnPIDDefESD.h"
-
-class AliAODTrack;
-class AliRsnEvent;
-
-class AliRsnPIDIndex : public TObject
-{
-  public:
-
-    AliRsnPIDIndex(Int_t num = 1000);
-    AliRsnPIDIndex(const AliRsnPIDIndex &copy);
-    AliRsnPIDIndex& operator= (const AliRsnPIDIndex& copy);
-
-    virtual  ~AliRsnPIDIndex();
-
-    void      Print(Option_t *option = "") const;
-    void      ResetAll(Int_t num = 1000);
-
-    void      FillFromEvent(AliRsnEvent*const event = 0);
-
-    void      AddIndex(const Int_t index, AliRsnDaughter::EPIDMethod meth, Char_t sign, AliPID::EParticleType type);
-    void      SetCorrectIndexSize();
-
-    TArrayI*  GetTracksArray(AliRsnDaughter::EPIDMethod meth, Char_t sign, AliPID::EParticleType type);
-    TArrayI*  GetCharged(Char_t sign);
-
-  private:
-
-    Int_t     ChargeIndex(Char_t sign) const;
-    Char_t    IndexCharge(Short_t sign) const;
-
-    TArrayI   fIndex[AliRsnDaughter::kMethods][2][AliPID::kSPECIES + 1];       // index arrays of pos/neg particles of each PID
-    Int_t     fNumOfIndex[AliRsnDaughter::kMethods][2][AliPID::kSPECIES + 1];  //! array size
-
-    ClassDef(AliRsnPIDIndex, 1);
-};
-
-#endif
index 372ed49ab4e8b83776d5973e6328c0f26836d49b..bfecb91de6f6fc038a40a47e2eaf5cefb2a8e69a 100644 (file)
 //          M. Vala (email: martin.vala@cern.ch)
 //
 
+#include <Riostream.h>
 #include <TList.h>
 
 #include "AliLog.h"
 
+#include "AliRsnMother.h"
 #include "AliRsnEvent.h"
 #include "AliRsnFunction.h"
-#include "AliRsnPIDIndex.h"
-#include "AliRsnCutMgr.h"
+#include "AliRsnCutSet.h"
 #include "AliRsnCutStd.h"
+#include "AliRsnValue.h"
+#include "AliRsnCutManager.h"
 
 #include "AliRsnPair.h"
 
 ClassImp(AliRsnPair)
 
 //_____________________________________________________________________________
-AliRsnPair::AliRsnPair(EPairType type, AliRsnPairDef *def) :
-    TObject(),
-    fOnlyTrue(kFALSE),
-    fIsMixed(kFALSE),
-    fPairType(type),
-    fPIDMethod(AliRsnDaughter::kRealistic),
-    fPairDef(def),
-    fCutMgr(0),
-    fFunctions("AliRsnFunction", 0),
-    fTrack1(),
-    fTrack2(),
-    fPairParticle()
+AliRsnPair::AliRsnPair(const char *name, AliRsnPairDef *def) :
+  TNamed(name, ""),
+  fOnlyTrue(kFALSE),
+  fIsMixed(kFALSE),
+  fPairDef(def),
+  fCutManager(),
+  fMother(),
+  fEvent(0x0)
 {
 //
 // Default constructor
 //
+
   AliDebug(AliLog::kDebug+2,"<-");
   AliDebug(AliLog::kDebug+2,"->");
-  SetUp(type);
 }
 
 //_____________________________________________________________________________
 AliRsnPair::AliRsnPair(const AliRsnPair& copy) :
-    TObject(),
-    fOnlyTrue(copy.fOnlyTrue),
-    fIsMixed(copy.fIsMixed),
-    fPairType(copy.fPairType),
-    fPIDMethod(copy.fPIDMethod),
-    fPairDef(copy.fPairDef),
-    fCutMgr(copy.fCutMgr),
-    fFunctions(copy.fFunctions),
-    fTrack1(copy.fTrack1),
-    fTrack2(copy.fTrack2),
-    fPairParticle(copy.fPairParticle)
+  TNamed(copy),
+  fOnlyTrue(copy.fOnlyTrue),
+  fIsMixed(copy.fIsMixed),
+  fPairDef(copy.fPairDef),
+  fCutManager(copy.fCutManager),
+  fMother(copy.fMother),
+  fEvent(0x0)
 {
 //
 // Default constructor
 //
+
   AliDebug(AliLog::kDebug+2,"<-");
   AliDebug(AliLog::kDebug+2,"->");
 }
@@ -74,20 +70,10 @@ AliRsnPair& AliRsnPair::operator=(const AliRsnPair& copy)
 {
   fOnlyTrue = copy.fOnlyTrue;
   fIsMixed = copy.fIsMixed;
-  fPairType = copy.fPairType;
-  fPIDMethod = copy.fPIDMethod;
   fPairDef = copy.fPairDef;
-  fCutMgr = copy.fCutMgr;
-  fTrack1 = copy.fTrack1;
-  fTrack2 = copy.fTrack2;
-  fPairParticle = copy.fPairParticle;
-
-  Int_t i, n = copy.fFunctions.GetEntries();
-  for (i = 0; i < n; i++)
-  {
-    AliRsnFunction *fcn = (AliRsnFunction*)copy.fFunctions[i];
-    if (fcn) AddFunction(fcn);
-  }
+  fMother = copy.fMother;
+  fCutManager = copy.fCutManager;
+  fEvent = 0x0;
 
   return (*this);
 }
@@ -98,41 +84,8 @@ AliRsnPair::~AliRsnPair()
 //
 // Destructor
 //
-  AliDebug(AliLog::kDebug+2,"<-");
-  AliDebug(AliLog::kDebug+2,"->");
-}
 
-//_____________________________________________________________________________
-void AliRsnPair::SetUp(EPairType type)
-{
-//
-// Sets up flag values by the pair types
-//
   AliDebug(AliLog::kDebug+2,"<-");
-  switch (type) {
-  case kNoPID:
-    SetAllFlags(AliRsnDaughter::kNoPID, kFALSE);
-    break;
-  case kNoPIDMix:
-    SetAllFlags(AliRsnDaughter::kNoPID, kTRUE);
-    break;
-  case kRealisticPID:
-    SetAllFlags(AliRsnDaughter::kRealistic, kFALSE);
-    break;
-  case kRealisticPIDMix:
-    SetAllFlags(AliRsnDaughter::kRealistic, kTRUE);
-    break;
-  case kPerfectPID:
-    SetAllFlags(AliRsnDaughter::kPerfect, kFALSE);
-    break;
-  case kPerfectPIDMix:
-    SetAllFlags(AliRsnDaughter::kPerfect, kTRUE);
-    break;
-  default :
-    AliWarning("Wrong type selected: setting up for realistic PID - no mixing.");
-    SetAllFlags(AliRsnDaughter::kRealistic, kFALSE);
-    break;
-  }
   AliDebug(AliLog::kDebug+2,"->");
 }
 
@@ -142,328 +95,80 @@ void AliRsnPair::Print(Option_t* /*option*/) const
 //
 // Prints info about pair
 //
+
   AliDebug(AliLog::kDebug+2,"<-");
-  AliInfo(Form("%s", GetPairHistTitle(0x0).Data()));
-  AliInfo(Form("PDG %d %d", AliPID::ParticleCode(fPairDef->GetType(0)),
-               AliPID::ParticleCode(fPairDef->GetType(1))));
+  AliInfo(Form("PDG %d %d", AliPID::ParticleCode(fPairDef->GetPID(0)), AliPID::ParticleCode(fPairDef->GetPID(1))));
   AliInfo(Form("Masses %f %f", fPairDef->GetMass(0), fPairDef->GetMass(1)));
-  AliInfo(Form("Number of functions %d", fFunctions.GetEntries()));
 
-  switch (fPIDMethod) {
-  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");
-  }
   AliDebug(AliLog::kDebug+2,"->");
 }
 
 //_____________________________________________________________________________
-void AliRsnPair::LoopPair(AliRsnPIDIndex *const pidIndex1, AliRsnEvent *const ev1, AliRsnPIDIndex *const pidIndex2, AliRsnEvent *const ev2)
+Bool_t AliRsnPair::Fill
+(AliRsnDaughter *daughter0, AliRsnDaughter *daughter1, AliRsnEvent *ev0, AliRsnEvent *ev1)
 {
 //
-// Prepare the loop for computation of functions.
-// Each PIDIndex is used to retrieve the appropriate array of indexes
-// of the tracks to be used in each event.
-// In case of single-event analysis, only the first two arguments are used
-// and both arrays are taken from the same PIDIndex and will loop on the same event
-// In case of mixing, all arguments are used, and first set of tracks will be found
-// in the first event with the first PIDIndex, and the second set of tracks will
-// be found in second event with second PIDIndex.
+// Sets the two passed daughters to the AliRsnMother data member of this object
+// which is used to perform all computations to fill the value list.
+// This operation is done successfully only when the first passed object matches
+// the required object type (track/V0) and the required charge for first element in pair def,
+// and the second passed object does the same w.r. to the second element in pair def.
+// Moreover, all cuts are checked and the operation fails if a cut check is unsuccessful.
+// Finally, if a true pair is required, this is checked at the end.
 //
 
   AliDebug(AliLog::kDebug+2,"<-");
-
-  TArrayI *a1 = 0;
-  TArrayI *a2 = 0;
-
-  if (fPIDMethod == AliRsnDaughter::kNoPID) {
-    AliDebug(AliLog::kDebug+2, Form("Returning indexes of with NO PID (%d) ...", fPIDMethod));
-    a1 = pidIndex1->GetTracksArray(fPIDMethod, fPairDef->GetCharge(0), AliPID::kUnknown);
-    if (pidIndex2 && ev2)
-      a2 = pidIndex2->GetTracksArray(fPIDMethod, fPairDef->GetCharge(1), AliPID::kUnknown);
-    else
-      a2 = pidIndex1->GetTracksArray(fPIDMethod, fPairDef->GetCharge(1), AliPID::kUnknown);
-  } else {
-    AliDebug(AliLog::kDebug+2, Form("Returning indexes of with PID (%d) ...", fPIDMethod));
-    a1 = pidIndex1->GetTracksArray(fPIDMethod,fPairDef->GetCharge(0), (AliPID::EParticleType)fPairDef->GetType(0));
-    if (pidIndex2 && ev2)
-      a2 = pidIndex2->GetTracksArray(fPIDMethod, fPairDef->GetCharge(1), (AliPID::EParticleType)fPairDef->GetType(1));
-    else
-      a2 = pidIndex1->GetTracksArray(fPIDMethod, fPairDef->GetCharge(1), (AliPID::EParticleType)fPairDef->GetType(1));
-  }
-
-  LoopPair(a1, a2, ev1, ev2);
-
-  AliDebug(AliLog::kDebug+2,"->");
+  
+  // check for correct type-charge match for first element
+  if (daughter0->RefType() != fPairDef->GetDaughterType(0)) return kFALSE;
+  if (daughter0->ChargeChar() != fPairDef->GetCharge(0)) return kFALSE;
+  
+  // check for correct type-charge match for second element
+  if (daughter1->RefType() != fPairDef->GetDaughterType(1)) return kFALSE;
+  if (daughter1->ChargeChar() != fPairDef->GetCharge(1)) return kFALSE;
+    
+  // cuts on track #1 & common
+  fCutManager.SetEvent(ev0);
+  if (!fCutManager.PassDaughter1Cuts(daughter0)) return kFALSE;
+  if (!fCutManager.PassCommonDaughterCuts(daughter0)) return kFALSE;
+  
+  // cuts on track #2 & common
+  fCutManager.SetEvent(ev1);
+  if (!fCutManager.PassDaughter2Cuts(daughter1)) return kFALSE;
+  if (!fCutManager.PassCommonDaughterCuts(daughter1)) return kFALSE;
+  
+  // point to first event as reference
+  fEvent = ev0;
+  
+  // define pair & check
+  fMother.SetDaughters(daughter0, fPairDef->GetMass(0), daughter1, fPairDef->GetMass(1));
+  fCutManager.SetEvent(fEvent);
+  if (!fCutManager.PassMotherCuts(&fMother)) return kFALSE;
+  
+  // if required a true pair, check this here and eventually return a fail message
+  if (fOnlyTrue && !fMother.MatchesDef(fPairDef)) return kFALSE;
+
+  AliDebug(AliLog::kDebug+2,"->");
+  
+  return kTRUE;
 }
 
 //_____________________________________________________________________________
-void AliRsnPair::LoopPair(TArrayI *a1, TArrayI *a2, AliRsnEvent *ev1, AliRsnEvent *ev2)
+void AliRsnPair::Compute()
 {
 //
-// Loop on all pairs of tracks of the defined types/charges,
-// using the arrays of indexes and the events containing them.
-// This method is private, for safety reasons.
+// Virtual method to compute pair quantities of interest
 //
-  AliDebug(AliLog::kDebug+2,"<-");
-  if (!ev1) {AliError(Form("ev1 is %p. skipping LoopPair() ...",ev1))return;}
-  AliDebug(AliLog::kDebug+1,"ev1 is OK ...");
-
-
-  if (!ev2) {
-    if (fIsMixed) {
-      AliDebug(AliLog::kDebug+1, "ev2 is null and fIsMixed is true. Skipping ...");
-      return;
-    }
-    ev2 = ev1;
-  }
-
-  if (!(ev1 == ev2)) {
-    AliDebug(AliLog::kDebug+1,"ev1 is different then ev2 ...");
-  }
-
-  if (!a1) {AliDebug(AliLog::kDebug+1, "No TArrayI 1 from currentEvent->GetTracksArray(...)"); return;}
-  if (!a2) {AliDebug(AliLog::kDebug+1, "No TArrayI 2 from currentEvent->GetTracksArray(...)"); return;}
-
-  AliDebug(AliLog::kDebug+1,Form("a1=%d a2=%d",a1->GetSize(),a2->GetSize()));
-  if (a1->GetSize()<=0) {AliDebug(AliLog::kDebug+1, "Size of TArrayI 1 is 0 or less ..."); return;}
-  if (a2->GetSize()<=0) {AliDebug(AliLog::kDebug+1, "Size of TArrayI 2 is 0 or less ..."); return;}
-
-  AliDebug(AliLog::kDebug,Form("Indexes_a1=%d Indexes_a2=%d",a1->GetSize(),a2->GetSize()));
 
-  // cuts on events
-  if (!CutPass(ev1) || !CutPass(ev2)) return;
-  AliDebug(AliLog::kDebug+1,"Event cut passed...");
-  AliRsnDaughter::SetPIDMethod(fPIDMethod);
-  AliRsnFunction *fcn = 0;
-
-  Bool_t isLikeSign = fPairDef->IsLikeSign();
-  Int_t j, startj = 0;
-
-  for (Int_t i = 0; i < a1->GetSize(); i++) {
-    // get track #1
-    ev1->SetDaughter(fTrack1, a1->At(i));
-    if (!fTrack1.IsOK()) continue;
-    // assign the required PID type to track #1
-    fTrack1.SetRequiredPID(fPairDef->GetType(0));
-    AliDebug(AliLog::kDebug+1,"daughter1 is OK ...");
-    // cuts on track #1
-    if (!CutPass(&fTrack1)) continue;
-    AliDebug(AliLog::kDebug+1,"daughter1 cut passed ...");
-    // check starting index for searching the event:
-    // for like-sign pairs we avoid duplicating the pairs
-    if (isLikeSign) startj = i+1; else startj = 0;
-    // loop on event for all track #2 to be combined with the found track #1
-    for (j = startj; j < a2->GetSize(); j++) {
-      ev2->SetDaughter(fTrack2, a2->At(j));
-      if (!fTrack2.IsOK()) continue;
-      AliDebug(AliLog::kDebug+1,"daughter2 is OK ...");
-      // assign the required PID type to track #2
-      fTrack2.SetRequiredPID(fPairDef->GetType(1));
-      // skip by default the case where the two tracks have the same index
-      if (ev1 == ev2 && a1->At(i) == a2->At(j)) continue;
-      // cuts on track #2
-      if (!CutPass(&fTrack2)) continue;
-      AliDebug(AliLog::kDebug+1,"daughter2 cut passed ...");
-      // make pair
-      fPairParticle.SetPair(&fTrack1, &fTrack2);
-      // in case of request, check that it is true pair
-      if (fOnlyTrue)
-      {
-        if (fPairParticle.CommonMother() != fPairDef->GetMotherPDG()) continue;
-        if (fPairParticle.GetDaughter(0)->PerfectPID() != fPairDef->GetType(0)) continue;
-        if (fPairParticle.GetDaughter(1)->PerfectPID() != fPairDef->GetType(1)) continue;
-      }
-      // cuts on pair
-      if (!CutPass(&fPairParticle)) continue;
-      AliDebug(AliLog::kDebug+1, "pairParticle cut passed");
-
-      if (AliLog::GetDebugLevel("",GetName()) == AliLog::kDebug)
-        fPairParticle.PrintInfo();
-      AliDebug(AliLog::kDebug, "================= FILLING TO HISTOGRAM ==================");
-      // fill all histograms
-      TObjArrayIter nextFcn(&fFunctions);
-      while ((fcn = (AliRsnFunction*)nextFcn())) {
-        fcn->SetPairDef(fPairDef);
-        fcn->SetPair(&fPairParticle);
-        fcn->SetEvent(ev1);
-        fcn->Fill();
-      }
-    }
-  }
-  AliDebug(AliLog::kDebug+2,"->");
+  AliWarning("Implement this method in derived classes");
 }
 
 //_____________________________________________________________________________
-TList * AliRsnPair::GenerateHistograms(TString prefix,TList *list)
+void AliRsnPair::Init(const char* /*prefix*/, TList* /*list*/)
 {
 //
-// Generates needed histograms, giving them a name based on
-// the flags defined here, on the pair definition, and attaches
-// a prefix to it, according to the argument.
-//
-// All generated histograms are stored into the output TList.
-//
-  AliDebug(AliLog::kDebug+2,"<-");
-//   if (!list){
-//     TList *list = new TList();
-//     list->SetName(GetPairHistName(0x0).Data());
-//   }
-  Char_t hName[255], hTitle[255];
-  //AliRsnFunction *fcn = 0;
-  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);
-    //list->Add(fcn->CreateHistogram(hName, hTitle));
-    if (fcn->IsUsingTH1()) list->Add(fcn->CreateHistogram(hName, hTitle));
-    else list->Add(fcn->CreateHistogramSparse(hName, hTitle));
-    //histos->Print();
-    //list->Add(histos);
-  }
-//   cout << "PRINTING LIST" << endl;
-//   list->Print();
-  AliDebug(AliLog::kDebug+2,"->");
-  return list;
-}
-
-
-
-//_____________________________________________________________________________
-TString AliRsnPair::GetPairTypeName(EPairType type) const
-{
-//
-// Returns type name, made with particle names ant chosen PID
-//
-  AliDebug(AliLog::kDebug+2,"<-");
-  AliDebug(AliLog::kDebug+2,"->");
-  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;
-  default:
-    AliWarning("Unrecognized value of EPairTypeName argument");
-    break;
-  }
-
-  return "NOTYPE";
-}
-
-//_____________________________________________________________________________
-TString AliRsnPair::GetPairName() const
-{
+// Virtual method to compute pair quantities of interest
 //
-// Retruns pair name
-//
-  AliDebug(AliLog::kDebug+2,"<-");
-  TString sName;
-  sName += GetPairTypeName(fPairType);
-  sName += fPairDef->GetPairName();
-  AliDebug(AliLog::kDebug+2,"->");
-  return sName;
-}
-
-//_____________________________________________________________________________
-TString AliRsnPair::GetPairHistName(AliRsnFunction *const fcn, TString text) const
-{
-//
-// Returns definitive histogram name
-//
-  AliDebug(AliLog::kDebug+2,"<-");
-  TString sName;
-  if (fcn) {
-    sName = fcn->GetName();
-    sName += "_";
-  }
-  sName += GetPairName();
-  sName += "_";
-  if (fCutMgr) sName += fCutMgr->GetName();
-  sName += text;
-  AliDebug(AliLog::kDebug+2,"->");
-  return sName;
-}
-
-//_____________________________________________________________________________
-TString AliRsnPair::GetPairHistTitle(AliRsnFunction *const fcn, TString text) const
-{
-//
-// Returns definitive histogram title
-//
-  AliDebug(AliLog::kDebug+2,"<-");
-  TString sTitle;
-  if (fcn) {
-    sTitle = fcn->GetTitle();
-    sTitle += " ";
-  }
-  sTitle += GetPairName();
-  sTitle +=" ";
-  if (fCutMgr) sTitle += fCutMgr->GetTitle();
-  sTitle += text;
-  AliDebug(AliLog::kDebug+2,"->");
-  return sTitle;
-}
-
-//_____________________________________________________________________________
-void AliRsnPair::AddFunction(AliRsnFunction *const fcn)
-{
-//
-// Adds a new computing function
-//
-  AliDebug(AliLog::kDebug+2,"<-");
-  Int_t size = fFunctions.GetEntries();
-  new(fFunctions[size]) AliRsnFunction(*fcn);
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-//________________________________________________________________________________________
-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.
-//
-  AliDebug(AliLog::kDebug+2,"<-AliRsnDaughter");
-  AliDebug(AliLog::kDebug+2,"->");
-  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.
-//
-  AliDebug(AliLog::kDebug+2,"<-AliRsnPairParticle");
-  AliDebug(AliLog::kDebug+2,"->");
-  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.
-//
-  AliDebug(AliLog::kDebug+2,"<-AliRsnEvent");
-  AliDebug(AliLog::kDebug+2,"->");
-  if (!fCutMgr) return kTRUE;
-  else return fCutMgr->IsSelected(AliRsnCut::kEvent, e);
 
+  AliWarning("Implement this method in derived classes");
 }
index 71f04fbe82f9fde42363f6bef25f61d24eb686c5..ce2bf2cfd24c9c609bc0e01a4f01b1150a0d333e 100644 (file)
 #ifndef ALIRSNPAIR_H
 #define ALIRSNPAIR_H
 
+#include "TNamed.h"
 #include "TClonesArray.h"
 
 #include "AliRsnDaughter.h"
 #include "AliRsnPairDef.h"
-#include "AliRsnPairParticle.h"
+#include "AliRsnMother.h"
+#include "AliRsnCutManager.h"
 
 class TH1;
 class TH2;
@@ -22,22 +24,15 @@ class TList;
 class TArrayI;
 
 class AliRsnEvent;
-class AliRsnCutMgr;
-class AliRsnPIDIndex;
+class AliRsnCutSet;
 class AliRsnFunction;
+class AliRsnValue;
 
-class AliRsnPair : public TObject
+class AliRsnPair : public TNamed
 {
   public:
 
-    enum EPairType {
-      kNoPID = 0,    kNoPIDMix,
-      kRealisticPID, kRealisticPIDMix,
-      kPerfectPID,   kPerfectPIDMix,
-      kPairTypes
-    };
-
-    AliRsnPair(EPairType type = kRealisticPID, AliRsnPairDef *def = 0);
+    AliRsnPair(const char *name = "default", AliRsnPairDef *def = 0);
     AliRsnPair(const AliRsnPair &copy);
     AliRsnPair& operator=(const AliRsnPair&);
     ~AliRsnPair();
@@ -45,45 +40,30 @@ class AliRsnPair : public TObject
     void    SetOnlyTrue(Bool_t onlyTrue = kTRUE) {fOnlyTrue = onlyTrue;}
 
     void    Print(Option_t *option = "") const;
-    void    LoopPair(AliRsnPIDIndex*const pidIndex1, AliRsnEvent*const ev1, AliRsnPIDIndex*const pidIndex2 = 0, AliRsnEvent* ev2 = 0);
-    void    LoopPair(TArrayI *a1, TArrayI *a2, AliRsnEvent *ev1, AliRsnEvent *ev2 = 0);
-    void    SetCutMgr(AliRsnCutMgr* const mgr) { fCutMgr = mgr; }
-    void    AddFunction(AliRsnFunction*const fcn);
-    TList*  GenerateHistograms(TString prefix = "", TList *list=0);
-
+    void    SetMixed(Bool_t doit = kTRUE) {fIsMixed = doit;}
     Bool_t  IsMixed() const {return fIsMixed;}
-    Bool_t  IsPairEqual() const {
-      if (fPIDMethod == AliRsnDaughter::kNoPID) return (fPairDef->IsLikeSign());
-      else return (fPairDef->IsLikeSign() && fPairDef->HasEqualTypes());
-    }
-
-    TString GetPairTypeName(EPairType type) const;
-    TString GetPairName() const;
-    TString GetPairHistName(AliRsnFunction *const fcn, TString text = "") const;
-    TString GetPairHistTitle(AliRsnFunction *const fcn, TString text = "") const;
-
+    
+    AliRsnCutManager* GetCutManager() {return &fCutManager;}
+    AliRsnMother*     GetMother() {return &fMother;}
+    AliRsnPairDef*    GetPairDef() {return fPairDef;}
+    Bool_t            Fill(AliRsnDaughter *d0, AliRsnDaughter *d1, AliRsnEvent *ev1, AliRsnEvent *ev2);
+    virtual void      Compute();
+    virtual void      Init(const char *prefix, TList *list);
+
+  protected:
+
+    Bool_t            fOnlyTrue;        //  select true pairs only?
+    Bool_t            fIsMixed;         //  is this an event-mixing?
+
+    AliRsnPairDef    *fPairDef;         //  pair definition (particles, charges)
+    AliRsnCutManager  fCutManager;      //  collection of all cuts
+    AliRsnMother      fMother;          //  mother candidate (to avoid creating it continuously)
+    AliRsnEvent      *fEvent;           //  pointer to current event
+    
   private:
 
-    void     SetUp(EPairType type);
-    void     SetAllFlags(AliRsnDaughter::EPIDMethod pid, Bool_t mix) {fPIDMethod = pid; fIsMixed = mix;}
-
-    Bool_t   CutPass(AliRsnDaughter *d);
-    Bool_t   CutPass(AliRsnPairParticle *p);
-    Bool_t   CutPass(AliRsnEvent *e);
-
-    Bool_t                      fOnlyTrue;       // select true pairs only?
-    Bool_t                      fIsMixed;        // doing event-mixing ?
-    EPairType                   fPairType;       // pair type (PID + mixing or not)
-    AliRsnDaughter::EPIDMethod  fPIDMethod;      // pid type variable for single track
-
-    AliRsnPairDef              *fPairDef;        // pair definition (particles, charges)
-    AliRsnCutMgr               *fCutMgr;         // cut manager
-    TClonesArray                fFunctions;      // functions
-    AliRsnDaughter              fTrack1;         // track #1 (external loop)
-    AliRsnDaughter              fTrack2;         // track #2 (internal loop)
-    AliRsnPairParticle          fPairParticle;   // track pair
-
     ClassDef(AliRsnPair, 2)
 };
 
 #endif
+
index 8687a1044d282c074c4d5ce2f326bc42c2e14968..24d953082cc0ca4a02938eb585f36daa5c03e53c 100644 (file)
@@ -10,6 +10,7 @@
 //
 
 #include "AliLog.h"
+#include "AliPID.h"
 #include "AliRsnPairDef.h"
 
 ClassImp(AliRsnPairDef)
@@ -30,24 +31,11 @@ AliRsnPairDef::AliRsnPairDef() : fMotherMass(0.0), fMotherPDG(0)
   for (i = 0; i < 2; i++) {
     fCharge[i] = '0';
     fMass[i] = 0.0;
-    fType[i] = AliPID::kUnknown;
+    fPID[i] = AliPID::kUnknown;
+    fDaughterType[i] = AliRsnDaughter::kTrack;
   }
 }
 
-//_____________________________________________________________________________
-AliRsnPairDef::AliRsnPairDef
-(Char_t sign1, AliPID::EParticleType type1, Char_t sign2, AliPID::EParticleType type2, Int_t motherPDG, Double_t motherMass) :
-  fMotherMass(motherMass),
-  fMotherPDG(motherPDG)
-{
-//
-// Constructor with arguments.
-// This constructor allows to define all the working parameters.
-//
-
-  SetPair(sign1, type1, sign2, type2);
-}
-
 //_____________________________________________________________________________
 AliRsnPairDef::AliRsnPairDef
 (AliPID::EParticleType type1, Char_t sign1, AliPID::EParticleType type2, Char_t sign2, Int_t motherPDG, Double_t motherMass) :
@@ -59,21 +47,21 @@ AliRsnPairDef::AliRsnPairDef
 // This constructor allows to define all the working parameters.
 //
 
-  SetPair(sign1, type1, sign2, type2);
+  SetDaughters(type1, sign1, type2, sign2);
 }
 
 
 //_____________________________________________________________________________
 AliRsnPairDef::AliRsnPairDef(const AliRsnPairDef &copy) :
-    TObject(copy),
-    fMotherMass(copy.fMotherMass),
-    fMotherPDG(copy.fMotherPDG)
+  TObject(copy),
+  fMotherMass(copy.fMotherMass),
+  fMotherPDG(copy.fMotherPDG)
 {
 //
 // Copy constructor with standard behavior
 //
 
-  SetPair(copy.fCharge[0], copy.fType[0], copy.fCharge[1], copy.fType[1]);
+  SetDaughters(copy.fPID[0], copy.fCharge[0], copy.fPID[1], copy.fCharge[1]);
 }
 
 //_____________________________________________________________________________
@@ -85,13 +73,13 @@ const AliRsnPairDef& AliRsnPairDef::operator=(const AliRsnPairDef &copy)
 
   fMotherMass = copy.fMotherMass;
   fMotherPDG = copy.fMotherPDG;
-  SetPair(copy.fCharge[0], copy.fType[0], copy.fCharge[1], copy.fType[1]);
+  SetDaughters(copy.fPID[0], copy.fCharge[0], copy.fPID[1], copy.fCharge[1]);
 
   return (*this);
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnPairDef::SetPairElement(Int_t i, Char_t charge, AliPID::EParticleType type)
+Bool_t AliRsnPairDef::SetDaughter(Int_t i, AliPID::EParticleType type, Char_t charge)
 {
 //
 // Set one element of the pair
@@ -100,52 +88,57 @@ Bool_t AliRsnPairDef::SetPairElement(Int_t i, Char_t charge, AliPID::EParticleTy
 
   AliPID pid;
 
-  if (i < 0 || i > 1) {
+  if (i < 0 || i > 1) 
+  {
     AliError("Index out of range");
     return kFALSE;
   }
-  if (charge != '+' && charge != '-') {
-    AliError(Form("Character '%c' not recognized as charge sign", charge));
+  if (charge != '+' && charge != '-' && charge != '0')
+  {
+    AliError(Form("Character '%c' not recognized as charge sign"));
     return kFALSE;
   }
-  if (type < 0 && type > (Int_t)AliPID::kSPECIES) {
+  if (type < 0 && type > (Int_t)AliPID::kSPECIESN) 
+  {
     AliError("Type index out of enumeration range");
     return kFALSE;
   }
+  
   fCharge[i] = charge;
-  fType[i] = type;
+  fPID[i] = type;
   fMass[i] = pid.ParticleMass(type);
+  if ((Int_t)type < AliPID::kSPECIES) fDaughterType[i] = AliRsnDaughter::kTrack;
+  else if (type == AliPID::kKaon0) 
+  {
+    fDaughterType[i] = AliRsnDaughter::kV0;
+    fCharge[i] = '0';
+  }
+  else return kFALSE;
 
   return kTRUE;
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnPairDef::SetPair
-(Char_t charge1, AliPID::EParticleType type1, Char_t charge2, AliPID::EParticleType type2)
+Bool_t AliRsnPairDef::SetDaughters
+(AliPID::EParticleType type1, Char_t charge1, AliPID::EParticleType type2, Char_t charge2)
 {
 //
 // 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);
+  Bool_t part1 = SetDaughter(0, type1, charge1);
+  Bool_t part2 = SetDaughter(1, type2, charge2);
 
   return (part1 && part2);
 }
 
 //_____________________________________________________________________________
-TString AliRsnPairDef::GetPairName() const
+const char* AliRsnPairDef::GetPairName() const
 {
 //
 // Returns a compact string with the name of the pair,
 // to be used for naming objects related to it.
 //
 
-  TString sName;
-  sName += AliPID::ParticleShortName(fType[0]);
-  sName += fCharge[0];
-  sName += AliPID::ParticleShortName(fType[1]);
-  sName += fCharge[1];
-
-  return sName;
+  return Form("%s%c%s%c", AliPID::ParticleShortName(fPID[0]), fCharge[0], AliPID::ParticleShortName(fPID[1]), fCharge[1]);
 }
index 02d3a484984e47ed2a7050af593a596e268dc01f..667fc753baa98c491f6d20589a86685c011111bb 100644 (file)
@@ -13,6 +13,7 @@
 #define ALIRSNPAIRDEF_H
 
 #include "AliPID.h"
+#include "AliRsnDaughter.h"
 
 class AliRsnDaughter;
 
@@ -21,40 +22,41 @@ class AliRsnPairDef : public TObject
   public:
 
     AliRsnPairDef();
-    AliRsnPairDef(Char_t sign1, AliPID::EParticleType type1,
-                  Char_t sign2, AliPID::EParticleType type2, Int_t motherPDG = 0, Double_t motherMass = 0.0);
-    AliRsnPairDef(AliPID::EParticleType type1, Char_t sign1,
-                  AliPID::EParticleType type2, Char_t sign2, Int_t motherPDG = 0, Double_t motherMass = 0.0);
+    AliRsnPairDef(AliPID::EParticleType type1, Char_t sign1, AliPID::EParticleType type2, Char_t sign2, Int_t motherPDG = 0, Double_t motherMass = 0.0);
     AliRsnPairDef(const AliRsnPairDef &copy);
     const AliRsnPairDef& operator= (const AliRsnPairDef &copy);
     virtual ~AliRsnPairDef() { }
 
     // getters
-    Char_t                GetCharge(Int_t i) const {if (i>=0&&i<2) return fCharge[i]; else return 0;}
-    Short_t               GetChargeShort(Int_t i) const {if (GetCharge(i) == '+') return 1; else if (GetCharge(i) == '-') return -1; else return 0;}
-    AliPID::EParticleType GetType(Int_t i) const {if (i>=0&&i<2) return fType[i]; else return AliPID::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;}
-    Double_t              GetMotherMass() const {return fMotherMass;}
-    TString               GetPairName() const;
+    Int_t                    GetMotherPDG()  const {return fMotherPDG;}
+    Double_t                 GetMotherMass() const {return fMotherMass;}
+    Double_t                 GetMass(Int_t i) const {if (i>=0&&i<2) return fMass[i]; else return 0.0;}
+    Char_t                   GetCharge(Int_t i) const {if (i>=0&&i<2) return fCharge[i]; else return 0;}
+    Short_t                  GetChargeShort(Int_t i) const {if (GetCharge(i) == '+') return 1; else if (GetCharge(i) == '-') return -1; else return 0;}
+    AliPID::EParticleType    GetPID(Int_t i) const {if (i>=0&&i<2) return fPID[i]; else return AliPID::kUnknown;}
+    AliRsnDaughter::ERefType GetDaughterType(Int_t i) {if (i>=0&&i<2) return fDaughterType[i]; else return AliRsnDaughter::kNoType;}
+    const char*              GetPairName() const;
 
     // setters
-    Bool_t SetPairElement(Int_t i, Char_t charge, AliPID::EParticleType pid);
-    Bool_t SetPair(Char_t ch1, AliPID::EParticleType pid1, Char_t ch2, AliPID::EParticleType pid2);
     void   SetMotherPDG(Int_t pdg) {fMotherPDG = pdg;}
+    void   SetMotherMass(Double_t mass) {fMotherMass = mass;}
+    Bool_t SetDaughter(Int_t i, AliPID::EParticleType pid, Char_t charge = 0);
+    Bool_t SetDaughters(AliPID::EParticleType type1, Char_t sign1, AliPID::EParticleType type2, Char_t sign2);
 
     // pair information methods
     Bool_t IsLikeSign() const {return (fCharge[0] == fCharge[1]);}
-    Bool_t HasEqualTypes() const {return (fType[0] == fType[1]);}
+    Bool_t HasEqualPID() const {return (fPID[0] == fPID[1]);}
 
   private:
 
     // pair parameters
-    Double_t               fMotherMass; // nominal mass of true mother
-    Int_t                  fMotherPDG;  // PDG code of true mother (if known)
-    Double_t               fMass[2];    // mass of particles
-    Char_t                 fCharge[2];  // charge of particles
-    AliPID::EParticleType  fType[2];    // PID of particles
+    Double_t                  fMotherMass;      // nominal mass of true mother
+    Int_t                     fMotherPDG;       // PDG code of true mother (if known)
+    
+    Double_t                  fMass[2];         // mass of particles
+    Char_t                    fCharge[2];       // charge of particles
+    AliPID::EParticleType     fPID[2];          // PID of particles
+    AliRsnDaughter::ERefType  fDaughterType[2]; // object type (track/V0)
 
     // ROOT dictionary
     ClassDef(AliRsnPairDef, 1)
diff --git a/PWG2/RESONANCES/AliRsnPairFunctions.cxx b/PWG2/RESONANCES/AliRsnPairFunctions.cxx
new file mode 100644 (file)
index 0000000..1bbe267
--- /dev/null
@@ -0,0 +1,149 @@
+//
+// *** Class AliRsnPairFunctions ***
+//
+// "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 <TList.h>
+
+#include "AliLog.h"
+
+#include "AliRsnMother.h"
+#include "AliRsnEvent.h"
+#include "AliRsnFunction.h"
+#include "AliRsnCutSet.h"
+#include "AliRsnCutStd.h"
+#include "AliRsnValue.h"
+
+#include "AliRsnPairFunctions.h"
+
+ClassImp(AliRsnPairFunctions)
+
+//_____________________________________________________________________________
+AliRsnPairFunctions::AliRsnPairFunctions(const char *name, AliRsnPairDef *def) :
+  AliRsnPair(name, def),
+  fFunctions("AliRsnFunction", 0)
+{
+//
+// Default constructor
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+AliRsnPairFunctions::AliRsnPairFunctions(const AliRsnPairFunctions& copy) :
+  AliRsnPair(copy),
+  fFunctions(copy.fFunctions)
+{
+//
+// Default constructor
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+AliRsnPairFunctions& AliRsnPairFunctions::operator=(const AliRsnPairFunctions& copy)
+{
+  AliRsnPair::operator=(copy);
+
+  Int_t i, n = copy.fFunctions.GetEntries();
+  for (i = 0; i < n; i++)
+  {
+    AliRsnFunction *fcn = (AliRsnFunction*)copy.fFunctions[i];
+    if (fcn) AddFunction(fcn);
+  }
+
+  return (*this);
+}
+
+//_____________________________________________________________________________
+AliRsnPairFunctions::~AliRsnPairFunctions()
+{
+//
+// Destructor
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+void AliRsnPairFunctions::Compute()
+{
+//
+// Makes computations using the two passed daughter objects.
+// Checks all cuts and then computes the corresponding pair object
+// and then fill the list of required values using it.
+//
+  
+  AliDebug(AliLog::kDebug+2,"<-");
+  
+  TObjArrayIter   nextFcn(&fFunctions);
+  AliRsnFunction *fcn = 0x0;
+  
+  while ((fcn = (AliRsnFunction*)nextFcn())) 
+  {
+    fcn->SetPairDef(fPairDef);
+    fcn->SetPair(&fMother);
+    fcn->SetEvent(fEvent);
+    fcn->Fill();
+  }
+
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+void AliRsnPairFunctions::Init(const char *prefix, TList *list)
+{
+//
+// Generates needed histograms, giving them a name based on
+// the flags defined here, on the pair definition, and attaches
+// a prefix to it, according to the argument.
+//
+// All generated histograms are stored into the output TList.
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+
+  Int_t  i;
+  Char_t hName[255];
+  AliRsnFunction *fcn = 0;
+  for (i = 0; i < fFunctions.GetEntries(); i++)
+  {
+    fcn = (AliRsnFunction*)fFunctions.At(i);
+    sprintf(hName, "%s_%s_%s", prefix, GetName(), fcn->GetName());
+
+    if (fcn->IsUsingTH1()) list->Add(fcn->CreateHistogram(hName, ""));
+    else list->Add(fcn->CreateHistogramSparse(hName, ""));
+  }
+
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+void AliRsnPairFunctions::AddFunction(AliRsnFunction *const fcn)
+{
+//
+// Adds a new computing function
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  
+  fFunctions.Print();
+  Int_t size = fFunctions.GetEntries();
+  new(fFunctions[size]) AliRsnFunction(*fcn);
+  
+  AliDebug(AliLog::kDebug+2,"->");
+}
diff --git a/PWG2/RESONANCES/AliRsnPairFunctions.h b/PWG2/RESONANCES/AliRsnPairFunctions.h
new file mode 100644 (file)
index 0000000..732fda2
--- /dev/null
@@ -0,0 +1,47 @@
+//
+// *** Class AliRsnPairFunctions ***
+//
+// TODO
+//
+// authors: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it)
+//          M. Vala (email: martin.vala@cern.ch)
+//
+
+#ifndef AliRsnPairFunctions_H
+#define AliRsnPairFunctions_H
+
+#include "AliRsnPair.h"
+
+class TH1;
+class TH2;
+class TList;
+class TArrayI;
+
+class AliRsnEvent;
+class AliRsnCutSet;
+class AliRsnFunction;
+class AliRsnValue;
+
+class AliRsnPairFunctions : public AliRsnPair
+{
+  public:
+
+    AliRsnPairFunctions(const char *name = "default", AliRsnPairDef *def = 0);
+    AliRsnPairFunctions(const AliRsnPairFunctions &copy);
+    AliRsnPairFunctions& operator=(const AliRsnPairFunctions&);
+    ~AliRsnPairFunctions();
+
+    void         AddFunction(AliRsnFunction*const fcn);
+    TList*       GenerateHistograms(const char *prefix = "", TList *list = 0);
+    virtual void Compute();
+    virtual void Init(const char *prefix, TList *list);
+
+  protected:
+
+    TClonesArray   fFunctions;    // a list of functions which generate histograms
+
+    ClassDef(AliRsnPairFunctions, 2)
+};
+
+#endif
+
diff --git a/PWG2/RESONANCES/AliRsnPairManager.cxx b/PWG2/RESONANCES/AliRsnPairManager.cxx
deleted file mode 100644 (file)
index 6eaa811..0000000
+++ /dev/null
@@ -1,149 +0,0 @@
-//
-// Class AliRsnPairManager
-//
-// A collection of pairs for an analysis.
-// The function of this collection is just for purposes of well-sorting
-// the analyzed pairs into upper-level groups, in the case of a wide
-// analysis containing many resonances at once, or different settings for the same one.
-//
-// Each PairMgr will result in a separate list of histograms, which
-// can be seen as a folder in the output file, whose name is given by this object.
-//
-// author: M. Vala (email: martin.vala@cern.ch)
-//
-
-#include "AliLog.h"
-#include "AliRsnPair.h"
-
-#include "AliRsnPairManager.h"
-
-ClassImp(AliRsnPairManager)
-
-//_____________________________________________________________________________
-AliRsnPairManager::AliRsnPairManager(const char*name) :
-    AliRsnVManager(name)
-{
-//
-// Default constructor
-//
-
-  AliDebug(AliLog::kDebug +2, "<-");
-  AliDebug(AliLog::kDebug +2, "->");
-}
-
-//_____________________________________________________________________________
-void AliRsnPairManager::Add(TObject* objPair)
-{
-//
-// Adds a new AliRsnPair to the list owned by this object.
-//
-
-  AliDebug(AliLog::kDebug+2, "<-");
-  AliRsnPair *pair = dynamic_cast<AliRsnPair*>(objPair);
-
-  if (!pair) {
-    AliWarning(Form("Pair is %p. Skipping ...", pair));
-    return;
-  }
-
-  AliDebug(AliLog::kDebug+1, Form("Adding %s [%d entries] ...", pair->GetPairName().Data(), fArray.GetEntries()));
-  fArray.Add((AliRsnPair*)pair);
-
-  AliDebug(AliLog::kDebug+2, "->");
-}
-
-//_____________________________________________________________________________
-void AliRsnPairManager::AddPair(AliRsnPair* pair)
-{
-//
-// Adds a new AliRsnPair to the list owned by this object.
-//
-
-  Add(pair);
-}
-
-
-//_____________________________________________________________________________
-void AliRsnPairManager::Print(Option_t* /*dummy*/) const
-{
-//
-// Overload of TObject::Print() method.
-// With respect to the other print method, adds a title string.
-//
-
-  AliDebug(AliLog::kDebug+2,"<-");
-
-  AliInfo(Form("\t\t======== Pair Manager %s ========", GetName()));
-  PrintArray();
-
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-//_____________________________________________________________________________
-void AliRsnPairManager::PrintArray() const
-{
-//
-// Prints all pairs
-//
-
-  AliDebug(AliLog::kDebug+2,"<-");
-
-  AliRsnPair *pair = 0;
-  TObjArrayIter next(&fArray);
-  while ((pair = (AliRsnPair*)next())) pair->Print();
-
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-//_____________________________________________________________________________
-void AliRsnPairManager::InitAllPairs(TList* list)
-{
-//
-// Initialize all pairs, and builds a TList of histograms
-// which are created by each of them, in order to link it
-// to the output handler in the AnalysisTasks.
-//
-
-  AliDebug(AliLog::kDebug+2, "<-");
-
-//   TList *list = new TList();
-//   list->SetName(GetName());
-//   list->SetOwner();
-
-  AliRsnPair *pair = 0;
-  TObjArrayIter next(&fArray);
-
-  Int_t i = 0;
-  while ((pair = (AliRsnPair*)next())) {
-    if (!pair) continue;
-    AliDebug(AliLog::kDebug+1, Form("InitAllPairs of the PairManager(%s) [%d] ...", pair->GetPairName().Data(), i++));
-    pair->GenerateHistograms(GetName(),list);
-  }
-
-  AliDebug(AliLog::kDebug+2, "->");
-//   return list;
-}
-
-//_____________________________________________________________________________
-void AliRsnPairManager::ProcessAllPairs
-(AliRsnPIDIndex *pidIndexes1, AliRsnEvent *ev1, AliRsnPIDIndex *pidIndexes2, AliRsnEvent *ev2)
-{
-//
-// Processes one (single-event analysis) or two (event-mixing) events
-// to fill histograms in all stored pairs.
-//
-
-  AliDebug(AliLog::kDebug+2, "<-");
-
-  AliRsnPair *pair = 0;
-  TObjArrayIter next(&fArray);
-
-  Int_t i=0;
-  while ((pair = (AliRsnPair*)next())) {
-    if (!pair) continue;
-    AliDebug(AliLog::kDebug+1, Form("ProcessAllPairs of the PairManager(%s) [%d] ...", pair->GetPairName().Data(), i++));
-    pair->LoopPair(pidIndexes1, ev1, pidIndexes2, ev2);
-  }
-
-  AliDebug(AliLog::kDebug+2, "->");
-}
diff --git a/PWG2/RESONANCES/AliRsnPairManager.h b/PWG2/RESONANCES/AliRsnPairManager.h
deleted file mode 100644 (file)
index a7cb15b..0000000
+++ /dev/null
@@ -1,51 +0,0 @@
-//
-// Class AliRsnPairManager
-//
-// A collection of pairs for an analysis.
-// The function of this collection is just for purposes of well-sorting
-// the analyzed pairs into upper-level groups, in the case of a wide
-// analysis containing many resonances at once, or different settings for the same one.
-//
-// Each PairManager will result in a separate list of histograms, which
-// can be seen as a folder in the output file, named after this object.
-//
-// This object inherits from AliRsnVManager, and "forces" the type of the
-// stored objects to be of the "AliRsnPair" class.
-// No further data members are added.
-//
-// author: M. Vala (email: martin.vala@cern.ch)
-//
-
-#ifndef ALIRSNPAIRMANAGER_H
-#define ALIRSNPAIRMANAGER_H
-// #include <TObject.h>
-#include "AliRsnVManager.h"
-
-class TList;
-
-class AliRsnPair;
-class AliRsnPairManager;
-class AliRsnPIDIndex;
-class AliRsnEvent;
-class AliRsnPairManager : public AliRsnVManager
-{
-  public:
-
-    AliRsnPairManager(const char *name = "defaultPairMgr");
-    virtual ~AliRsnPairManager() {;};
-
-    //virtual void   Add(AliRsnPair *pair);
-    virtual void   Add(TObject *pair);
-    virtual void   AddPair(AliRsnPair *pair);
-    virtual void   PrintArray() const;
-    virtual void   Print(Option_t *option = "") const;
-
-    void   InitAllPairs(TList* list);
-    void   ProcessAllPairs(AliRsnPIDIndex *pidIndexes1, AliRsnEvent *ev1, AliRsnPIDIndex *pidIndexes2 = 0, AliRsnEvent *ev2 = 0);
-
-  private:
-
-    ClassDef(AliRsnPairManager, 1)
-};
-
-#endif
diff --git a/PWG2/RESONANCES/AliRsnPairNtuple.cxx b/PWG2/RESONANCES/AliRsnPairNtuple.cxx
new file mode 100644 (file)
index 0000000..035a3c0
--- /dev/null
@@ -0,0 +1,156 @@
+//
+// *** Class AliRsnPairNtuple ***
+//
+// "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 <TList.h>
+#include <TNtuple.h>
+
+#include "AliLog.h"
+
+#include "AliRsnMother.h"
+#include "AliRsnEvent.h"
+#include "AliRsnFunction.h"
+#include "AliRsnCutSet.h"
+#include "AliRsnCutStd.h"
+#include "AliRsnValue.h"
+
+#include "AliRsnPairNtuple.h"
+
+ClassImp(AliRsnPairNtuple)
+
+//_____________________________________________________________________________
+AliRsnPairNtuple::AliRsnPairNtuple(const char *name, AliRsnPairDef *def) :
+  AliRsnPair(name, def),
+  fValues("AliRsnValue", 0),
+  fNtuple(0x0)
+{
+//
+// Default constructor
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+AliRsnPairNtuple::AliRsnPairNtuple(const AliRsnPairNtuple& copy) :
+  AliRsnPair(copy),
+  fValues(copy.fValues),
+  fNtuple(copy.fNtuple)
+{
+//
+// Default constructor
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+AliRsnPairNtuple& AliRsnPairNtuple::operator=(const AliRsnPairNtuple& copy)
+{
+  AliRsnPair::operator=(copy);
+  
+  Int_t i, n = copy.fValues.GetEntries();
+  for (i = 0; i < n; i++)
+  {
+    AliRsnValue *fcn = (AliRsnValue*)copy.fValues[i];
+    if (fcn) AddValue(fcn);
+  }
+  
+  fNtuple = copy.fNtuple;
+
+  return (*this);
+}
+
+//_____________________________________________________________________________
+AliRsnPairNtuple::~AliRsnPairNtuple()
+{
+//
+// Destructor
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+void AliRsnPairNtuple::Compute()
+{
+//
+// Makes computations using the two passed daughter objects.
+// Checks all cuts and then computes the corresponding pair obje