Block of updates on RSN package:
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 9 Nov 2010 17:16:34 +0000 (17:16 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 9 Nov 2010 17:16:34 +0000 (17:16 +0000)
AliRsnDaughter:
- reorganized the list of methods
- added some utility getters which do a dynamic_cast into the allowed input types
- generalized the fRefMC data member to be able to get also the AOD MC particle type

AliRsnEvent:
- split the setter for main reference and MC reference
- added methods to dynamic_cast references to allowed input types for ESD and AOD
- splitted the SetDaughter(...) method for better readability, and implemented
  to cope with tracks and V0s both for ESD and AOD
- added a method to compute multiplicity using AliESDtrackCuts

AliRsnVAnalysisTaskSE-derived classes:
- adapted to splitted setters in AliRsnEvent

AliRsnValue:
- rewritten multiplicity-computation values

AliRsnCutPrimaryVertex:
- adjusted management of AOD primary vertex

AliRsnPair:
- manage AOD pairs

AliRsnAnalysisEffSE (**major update**)
- added all necessary code to run also on AOD MC productions

20 files changed:
PWG2/RESONANCES/AliRsnAnalysisEffSE.cxx
PWG2/RESONANCES/AliRsnAnalysisEffSE.h
PWG2/RESONANCES/AliRsnAnalysisManager.cxx
PWG2/RESONANCES/AliRsnAnalysisMonitorPairTask.cxx
PWG2/RESONANCES/AliRsnAnalysisMonitorTask.cxx
PWG2/RESONANCES/AliRsnCutPrimaryVertex.cxx
PWG2/RESONANCES/AliRsnCutStd.cxx
PWG2/RESONANCES/AliRsnDaughter.cxx
PWG2/RESONANCES/AliRsnDaughter.h
PWG2/RESONANCES/AliRsnEvent.cxx
PWG2/RESONANCES/AliRsnEvent.h
PWG2/RESONANCES/AliRsnMother.h
PWG2/RESONANCES/AliRsnPair.cxx
PWG2/RESONANCES/AliRsnVAnalysisTaskSE.cxx
PWG2/RESONANCES/AliRsnValue.cxx
PWG2/RESONANCES/AliRsnValue.h
PWG2/RESONANCES/macros/train/LHC2010-7TeV-phi/AddRsnAnalysis.C
PWG2/RESONANCES/macros/train/LHC2010-7TeV-phi/AddRsnAnalysisMult.C
PWG2/RESONANCES/macros/train/LHC2010-7TeV-phi/AddRsnEfficiency.C
PWG2/RESONANCES/macros/train/LHC2010-7TeV-phi/RsnConfig.C

index 9ab28c9..11232ea 100644 (file)
@@ -10,6 +10,7 @@
 #include <Riostream.h>
 #include "AliStack.h"
 #include "AliESDEvent.h"
+#include "AliAODEvent.h"
 #include "AliMCEvent.h"
 
 #include "AliCFContainer.h"
@@ -217,17 +218,37 @@ void AliRsnAnalysisEffSE::RsnUserExec(Option_t*)
   */
 
   AliDebug(AliLog::kDebug+2,"<-");
-  if (!fESDEvent || !fMCEvent) {
-    AliError("This task can process only ESD + MC events");
+  if (fMCOnly && fMCEvent)
+  {
+    fRsnEvent.SetRef  (fMCEvent);
+    fRsnEvent.SetRefMC(fMCEvent);
+  }
+  else if (fESDEvent)
+  {
+    fRsnEvent.SetRef  (fESDEvent);
+    fRsnEvent.SetRefMC(fMCEvent);
+  }
+  else if (fAODEventOut)
+  {
+    fRsnEvent.SetRef  (fAODEventOut);
+    fRsnEvent.SetRefMC(fAODEventOut);
+  }
+  else if (fAODEventIn)
+  {
+    fRsnEvent.SetRef  (fAODEventIn);
+    fRsnEvent.SetRefMC(fAODEventIn);
+  }
+  else {
+    AliError("NO ESD or AOD object!!! Skipping ...");
     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.IsSelected(&fRsnEvent)) {
+  if (!fEventCuts.IsSelected(&fRsnEvent)) 
+  {
     fTaskInfo.SetEventUsed(kFALSE);
     return;
   }
@@ -241,9 +262,8 @@ void AliRsnAnalysisEffSE::RsnUserExec(Option_t*)
   TObjArrayIter iter(&fPairDefList);
   while ( (pairDef = (AliRsnPairDef*)iter.Next()) )
   {
-    //ProcessEventMC(pairDef);
-    //ProcessEventESD(pairDef);
-    ProcessEvent(pairDef);
+    if (fRsnEvent.IsESD()) ProcessEventESD(pairDef);
+    if (fRsnEvent.IsAOD()) ProcessEventAOD(pairDef);
   }
 
   // Post the data
@@ -253,7 +273,7 @@ void AliRsnAnalysisEffSE::RsnUserExec(Option_t*)
 }
 
 //_____________________________________________________________________________
-void AliRsnAnalysisEffSE::ProcessEvent(AliRsnPairDef *pairDef)
+void AliRsnAnalysisEffSE::ProcessEventESD(AliRsnPairDef *pairDef)
 {
 //
 // Process current event with the definitions of the specified step in MC list
@@ -261,9 +281,9 @@ void AliRsnAnalysisEffSE::ProcessEvent(AliRsnPairDef *pairDef)
 // It is associated with the AliCFContainer with the name of the pair.
 //
 
-  AliStack      *stack = fRsnEvent.GetRefMC()->Stack();
+  AliStack      *stack = fRsnEvent.GetRefMCESD()->Stack();
   AliESDEvent   *esd   = fRsnEvent.GetRefESD();
-  AliMCEvent    *mc    = fRsnEvent.GetRefMC();
+  AliMCEvent    *mc    = fRsnEvent.GetRefMCESD();
   AliMCParticle *mother;
 
   if (!pairDef) return;
@@ -271,11 +291,12 @@ void AliRsnAnalysisEffSE::ProcessEvent(AliRsnPairDef *pairDef)
   if (!cont) return;
   
   // get informations from pairDef
-  Int_t pdgM = 0, pdgD[2] = {0, 0};
+  Int_t   pdgM = 0;
+  Int_t   pdgD[2] = {0, 0};
   Short_t chargeD[2] = {0, 0};
-  pdgM    = pairDef->GetMotherPDG();
-  pdgD[0] = AliPID::ParticleCode(pairDef->GetPID(0));
-  pdgD[1] = AliPID::ParticleCode(pairDef->GetPID(1));
+  pdgM       = pairDef->GetMotherPDG();
+  pdgD   [0] = AliPID::ParticleCode(pairDef->GetPID(0));
+  pdgD   [1] = AliPID::ParticleCode(pairDef->GetPID(1));
   chargeD[0] = pairDef->GetChargeShort(0);
   chargeD[1] = pairDef->GetChargeShort(1);
 
@@ -393,91 +414,138 @@ void AliRsnAnalysisEffSE::ProcessEvent(AliRsnPairDef *pairDef)
 }
 
 //_____________________________________________________________________________
-void AliRsnAnalysisEffSE::ProcessEventMC(AliRsnPairDef */*pairDef*/)
+void AliRsnAnalysisEffSE::ProcessEventAOD(AliRsnPairDef *pairDef)
 {
 //
 // Process current event with the definitions of the specified step in MC list
-// and store results in the container slot defined in second argument
+// and store results in the container slot defined in second argument.
+// It is associated with the AliCFContainer with the name of the pair.
 //
 
-  /*
-  AliStack      *stack = fMCEvent->Stack();
-  AliMCParticle *mother, *daughter;
+  AliAODEvent      *aod   = fRsnEvent.GetRefAOD();
+  AliAODMCParticle *mother;
+  TClonesArray     *mcArray = (TClonesArray*)aod->GetList()->FindObject(AliAODMCParticle::StdBranchName());
+  if (!mcArray) return;
 
   if (!pairDef) return;
-  AliCFContainer *cont = (AliCFContainer*)fContainerList->FindObject(pairDef->GetPairName().Data());
+  AliCFContainer *cont = (AliCFContainer*)fContainerList->FindObject(pairDef->GetPairName());
   if (!cont) return;
+  
+  // get informations from pairDef
+  Int_t   pdgM = 0;
+  Int_t   pdgD[2] = {0, 0};
+  Short_t chargeD[2] = {0, 0};
+  pdgM       = pairDef->GetMotherPDG();
+  pdgD   [0] = AliPID::ParticleCode(pairDef->GetPID(0));
+  pdgD   [1] = AliPID::ParticleCode(pairDef->GetPID(1));
+  chargeD[0] = pairDef->GetChargeShort(0);
+  chargeD[1] = pairDef->GetChargeShort(1);
 
   // other utility variables
-  Int_t i[2], j, 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 < stack->GetNprimary(); ipart++) 
-  {
-    mother = (AliMCParticle*) fMCEvent->GetTrack(ipart);
-    if (mother->Particle()->GetNDaughters() != 2) continue;
-
-    i[0] = mother->Particle()->GetFirstDaughter();
-    i[1] = mother->Particle()->GetLastDaughter();
+  Int_t             first, j;
+  Int_t             label [2] = {-1, -1};
+  Short_t           charge[2] = {0, 0};
+  Short_t           pairDefMatch[2] = {-1, -1};
+  Int_t             aodIndex[2] = {-1, -1};
+  AliAODMCParticle *part[2] = {0, 0};
+  
+  // loop on MC particles
+  TObjArrayIter next(mcArray);
+  while ( (mother = (AliAODMCParticle*)next()) )
+  {  
+    // check that it is a binary decay and the PDG code matches
+    if (mother->GetNDaughters() != 2) continue;
+    if (mother->GetPdgCode() != pdgM) continue;
 
-    for (j = 0; j < 2; j++) 
+    // store the labels of the two daughters
+    label[0] = mother->GetDaughter(0);
+    label[1] = mother->GetDaughter(1);
+    
+    // retrieve the particles and other stuff
+    // check if they match the order in the pairDef
+    for (j = 0; j < 2; j++)
     {
-      daughter = (AliMCParticle*) fMCEvent->GetTrack(i[j]);
-      fDaughter[j].SetRef(daughter);
-      fDaughter[j].SetRefMC(daughter);
-      fDaughter[j].FindMotherPDG(stack);
+      if (label[j] < 0) continue;
+      part[j]   = (AliAODMCParticle*)mcArray->At(label[j]);
+      pdgD[j]   = TMath::Abs(part[j]->GetPdgCode());
+      charge[j] = (Short_t)(part[j]->Charge());
+      if (pdgD[j] == AliPID::ParticleCode(pairDef->GetPID(0)) && charge[j] == pairDef->GetChargeShort(0))
+        pairDefMatch[j] = 0;
+      else if (pdgD[j] == AliPID::ParticleCode(pairDef->GetPID(1)) && charge[j] == pairDef->GetChargeShort(1))
+        pairDefMatch[j] = 1;
+      else
+        pairDefMatch[j] = -1;
+        
+      // find corresponding ESD particle: first try rejecting fakes,
+      // and in case of failure, try accepting fakes
+      aodIndex[j] = FindAODtrack(label[j], aod, kTRUE);
+      if (aodIndex[j] < 0) aodIndex[j] = FindAODtrack(label[j], aod, kFALSE);
     }
-
-    if (fDaughter[0].ChargeC() != pairDef->GetCharge(0)) continue;
-    if (fDaughter[1].ChargeC() != pairDef->GetCharge(1)) continue;
-    if (fDaughter[0].PerfectPID() != pairDef->GetType(0)) continue;
-    if (fDaughter[1].PerfectPID() != pairDef->GetType(1)) continue;
-
-    fPair.SetDaughters(&fDaughter[0], &fDaughter[1]);
-
-    // create pair
+    
+    // since each candidate good resonance is taken once, we must check
+    // that it matches the pair definition in any order, and reject in case
+    // in none of them the pair is OK
+    // anyway, we must associate the correct daughter to the correct data member
+    if (pairDefMatch[0] == 0 && pairDefMatch[1] == 1)
+    {
+      // 1st track --> 1st member of PairDef
+      fDaughter[0].SetRef((AliAODMCParticle*)mcArray->At(label[0]));
+      fDaughter[0].SetRefMC((AliAODMCParticle*)mcArray->At(label[0]));
+      fDaughter[0].SetGood();
+      // 2nd track --> 2nd member of PairDef
+      fDaughter[1].SetRef((AliAODMCParticle*)mcArray->At(label[1]));
+      fDaughter[1].SetRefMC((AliAODMCParticle*)mcArray->At(label[1]));
+      fDaughter[1].SetGood();
+    }
+    else if ((pairDefMatch[0] == 1 && pairDefMatch[1] == 0))
+    {
+      // 1st track --> 2nd member of PairDef
+      fDaughter[0].SetRef((AliAODMCParticle*)mcArray->At(label[1]));
+      fDaughter[0].SetRefMC((AliAODMCParticle*)mcArray->At(label[1]));
+      fDaughter[0].SetGood();
+      // 2nd track --> 1st member of PairDef
+      fDaughter[1].SetRef((AliAODMCParticle*)mcArray->At(label[0]));
+      fDaughter[1].SetRefMC((AliAODMCParticle*)mcArray->At(label[0]));
+      fDaughter[1].SetGood();
+    }
+    else
+    {
+      fDaughter[0].SetBad();
+      fDaughter[1].SetBad();
+    }
+    
+    // reject the pair if the matching was unsuccessful
+    if (!fDaughter[0].IsOK() || !fDaughter[1].IsOK()) continue;
+    
+    // first, we set the internal AliRsnMother object to
+    // the MC particles and then operate the selections on MC
+    fPair.SetDaughters(&fDaughter[0], pairDef->GetMass(0), &fDaughter[1], pairDef->GetMass(1));
     FillContainer(cont, &fStepListMC, pairDef, 0);
-  }
-  */
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisEffSE::ProcessEventESD(AliRsnPairDef */*pairDef*/)
-{
-//
-// 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 i0, i1, first = (Int_t)fStepListMC.GetEntries();
-
-  if (!pairDef) return;
-  AliCFContainer *cont = (AliCFContainer*)fContainerList->FindObject(pairDef->GetPairName().Data());
-  if (!cont) return;
-
-  // external loop on tracks
-  for (i0 = 0; i0 < a0->GetSize(); i0++) {
-    // connect interface
-    fRsnEvent.SetDaughter(fDaughter[0], a0->At(i0));
-    if (!fDaughter[0].IsOK()) continue;
-    fDaughter[0].SetRequiredPID(pairDef->GetType(0));
-
-    // internal loop on tracks
-    for (i1 = 0; i1 < a1->GetSize(); i1++) {
-      // connect interface
-      fRsnEvent.SetDaughter(fDaughter[1], a1->At(i1));
-      if (!fDaughter[1].IsOK()) continue;
-      fDaughter[1].SetRequiredPID(pairDef->GetType(1));
-      // build pair
-      fPair.SetPair(&fDaughter[0], &fDaughter[1]);
-      if (TMath::Abs(fPair.CommonMother()) != pairDef->GetMotherPDG()) continue;
-      // fill containers
-      FillContainer(cont, &fStepListESD, pairDef, first);
+    
+    // then, if both particles found a good match in the AOD
+    // reassociate the AOD tracks to the pair and fill AOD containers
+    if (aodIndex[0] < 0 || aodIndex[1] < 0) continue;
+    if (pairDefMatch[0] == 0 && pairDefMatch[1] == 1)
+    {
+      // 1st track --> 1st member of PairDef
+      fDaughter[0].SetRef(aod->GetTrack(aodIndex[0]));
+      // 2nd track --> 2nd member of PairDef
+      fDaughter[1].SetRef(aod->GetTrack(aodIndex[1]));
+      //cout << "****** MATCHING SCHEME 1" << endl;
+    }
+    else if ((pairDefMatch[0] == 1 && pairDefMatch[1] == 0))
+    {
+      // 1st track --> 2nd member of PairDef
+      fDaughter[0].SetRef(aod->GetTrack(aodIndex[1]));
+      // 2nd track --> 1st member of PairDef
+      fDaughter[1].SetRef(aod->GetTrack(aodIndex[0]));
+      //cout << "****** MATCHING SCHEME 2" << endl;
     }
+    //cout << "****** IDs = " << fDaughter[0].GetID() << ' ' << fDaughter[1].GetID() << endl;
+    // here we must remember how many steps were already filled
+    first = (Int_t)fStepListMC.GetEntries();
+    FillContainer(cont, &fStepListESD, pairDef, first);
   }
-  */
 }
 
 //_____________________________________________________________________________
@@ -664,3 +732,132 @@ TArrayI AliRsnAnalysisEffSE::FindESDtracks(Int_t label, AliESDEvent *esd)
   array.Set(nfound);
   return array;
 }
+
+//_____________________________________________________________________________
+Int_t AliRsnAnalysisEffSE::FindAODtrack(Int_t label, AliAODEvent *aod, Bool_t rejectFakes)
+{
+//
+// Finds in the ESD a track whose label corresponds to that in argument.
+// When global tracks are enabled, tries first to find a global track 
+// satisfying that requirement.
+// If no global tracks are found, if ITS-SA are enable, tries to search among them
+// otherwise return a negative number.
+// If global tracks are disabled, search only among ITS SA
+//
+
+  Int_t   i = 0;
+  Int_t   ntracks = aod->GetNumberOfTracks();
+  ULong_t status;
+  Bool_t  isTPC;
+  Bool_t  isITSSA;
+  
+  // loop for global tracks
+  if (fUseGlobal)
+  {
+    for (i = 0; i < ntracks; i++)
+    {
+      AliAODTrack *track = aod->GetTrack(i);
+      status  = (ULong_t)track->GetStatus();
+      isTPC   = ((status & AliESDtrack::kTPCin)  != 0);
+      if (!isTPC) continue;
+      
+      // check that label match
+      if (TMath::Abs(track->GetLabel()) != label) continue;
+      
+      // if required, reject fakes
+      if (rejectFakes && track->GetLabel() < 0) continue;
+      
+      // if all checks are passed and we are searching among global
+      // this means that thie track is a global one with the right label
+      // then, the return value is set to this, and returned
+      return i;
+    }
+  }
+  
+  // loop for ITS-SA tracks (this happens only if no global tracks were found
+  // or searching among globals is disabled)
+  if (fUseITSSA)
+  {
+    for (i = 0; i < ntracks; i++)
+    {
+      AliAODTrack *track = aod->GetTrack(i);
+      status  = (ULong_t)track->GetStatus();
+      isITSSA = ((status & AliESDtrack::kTPCin)  == 0 && (status & AliESDtrack::kITSrefit) != 0 && (status & AliESDtrack::kITSpureSA) == 0 && (status & AliESDtrack::kITSpid) != 0);
+      if (!isITSSA) continue;
+      
+      // check that label match
+      if (TMath::Abs(track->GetLabel()) != label) continue;
+            
+      // if required, reject fakes
+      if (rejectFakes && track->GetLabel() < 0) continue;
+      
+      // if all checks are passed and we are searching among global
+      // this means that thie track is a global one with the right label
+      // then, the return value is set to this, and returned
+      return i;
+    }
+  }
+  
+  // if we reach this point, no match were found
+  return -1;
+}
+
+//_____________________________________________________________________________
+TArrayI AliRsnAnalysisEffSE::FindAODtracks(Int_t label, AliAODEvent *aod)
+{
+//
+// Finds in the ESD a track whose label corresponds to that in argument.
+// When global tracks are enabled, tries first to find a global track 
+// satisfying that requirement.
+// If no global tracks are found, if ITS-SA are enable, tries to search among them
+// otherwise return a negative number.
+// If global tracks are disabled, search only among ITS SA
+//
+
+  Int_t   i = 0;
+  Int_t   ntracks = aod->GetNumberOfTracks();
+  ULong_t status;
+  Bool_t  isTPC;
+  Bool_t  isITSSA;
+  TArrayI array(100);
+  Int_t   nfound = 0;
+  
+  // loop for global tracks
+  if (fUseGlobal)
+  {
+    for (i = 0; i < ntracks; i++)
+    {
+      AliAODTrack *track = aod->GetTrack(i);
+      status  = (ULong_t)track->GetStatus();
+      isTPC   = ((status & AliESDtrack::kTPCin)  != 0);
+      if (!isTPC) continue;
+      
+      // check that label match
+      if (TMath::Abs(track->GetLabel()) != label) continue;
+      
+      array[nfound++] = i;
+    }
+  }
+  
+  // loop for ITS-SA tracks (this happens only if no global tracks were found
+  // or searching among globals is disabled)
+  if (fUseITSSA)
+  {
+    for (i = 0; i < ntracks; i++)
+    {
+      AliAODTrack *track = aod->GetTrack(i);
+      status  = (ULong_t)track->GetStatus();
+      isITSSA = ((status & AliESDtrack::kTPCin)  == 0 && (status & AliESDtrack::kITSrefit) != 0 && (status & AliESDtrack::kITSpureSA) == 0 && (status & AliESDtrack::kITSpid) != 0);
+      if (!isITSSA) continue;
+      
+      // check that label match
+      if (TMath::Abs(track->GetLabel()) != label) continue;
+            
+      array[nfound++] = i;
+    }
+  }
+  
+  array.Set(nfound);
+  return array;
+}
+
index c5bb885..43eb68e 100644 (file)
@@ -17,6 +17,7 @@
 #include "AliRsnVAnalysisTaskSE.h"
 #include "AliRsnEvent.h"
 #include "AliRsnMother.h"
+#include "AliRsnDaughter.h"
 
 class AliPID;
 
@@ -53,12 +54,13 @@ class AliRsnAnalysisEffSE : public AliRsnVAnalysisTaskSE
   private:
 
     AliRsnAnalysisEffSE& operator=(const AliRsnAnalysisEffSE& /*copy*/) {return *this;}
-    void                 ProcessEvent(AliRsnPairDef *pairDef);
-    void                 ProcessEventMC(AliRsnPairDef *pairDef);
     void                 ProcessEventESD(AliRsnPairDef *pairDef);
+    void                 ProcessEventAOD(AliRsnPairDef *pairDef);
     void                 FillContainer(AliCFContainer *cont, const TObjArray *stepList, AliRsnPairDef *pd, Int_t firstOutStep);
-    Int_t                FindESDtrack(Int_t label, AliESDEvent *esd, Bool_t rejectFakes);
+    Int_t                FindESDtrack (Int_t label, AliESDEvent *esd, Bool_t rejectFakes);
     TArrayI              FindESDtracks(Int_t label, AliESDEvent *esd);
+    Int_t                FindAODtrack (Int_t label, AliAODEvent *aod, Bool_t rejectFakes);
+    TArrayI              FindAODtracks(Int_t label, AliAODEvent *aod);
 
     Bool_t                fUseITSSA;                // switch to use ITS standalone tracks
     Bool_t                fUseGlobal;               // switch to use global tracks
index 9b461f8..b71f62b 100644 (file)
@@ -209,7 +209,7 @@ void AliRsnAnalysisManager::ProcessAllPairsMC(AliRsnEvent *ev0, AliRsnEvent *ev1
   for (i0 = 0; i0 < nTracks[0]; i0++)
   {
     // skip not physical primaries
-    if (!ev0->GetRefMC()->Stack()->IsPhysicalPrimary(i0)) continue;
+    if (!ev0->GetRefMCESD()->Stack()->IsPhysicalPrimary(i0)) continue;
     
     // assign first track
     ev0->SetDaughterMC(daughter0, i0);
@@ -221,7 +221,7 @@ void AliRsnAnalysisManager::ProcessAllPairsMC(AliRsnEvent *ev0, AliRsnEvent *ev1
       if (ev0 == ev1 && i0 == i1) continue;
       
       // skip not physical primaries
-      if (!ev1->GetRefMC()->Stack()->IsPhysicalPrimary(i1)) continue;
+      if (!ev1->GetRefMCESD()->Stack()->IsPhysicalPrimary(i1)) continue;
       
       // assign second track
       ev1->SetDaughterMC(daughter1, i1);
index 7ead0dd..e62ba0f 100644 (file)
@@ -165,7 +165,8 @@ void AliRsnAnalysisMonitorPairTask::UserExec(Option_t *)
   
   // create interface objects to AliRsnEvent to check event cuts
   AliRsnEvent event;
-  event.SetRef(esd, fMCEvent);
+  event.SetRef(esd);
+  event.SetRefMC(fMCEvent);
   if (!fEventCuts.IsSelected(&event)) return;
   
   // check the event
@@ -296,7 +297,8 @@ Bool_t AliRsnAnalysisMonitorPairTask::ProcessTrack(Int_t myIndex, Int_t esdIndex
 
   // create interfacr objects
   AliRsnEvent    event;
-  event.SetRef(esd, fMCEvent);
+  event.SetRef(esd);
+  event.SetRefMC(fMCEvent);
   AliRsnDaughter daughter;
   AliESDtrack *track = esd->GetTrack(esdIndex);
   event.SetDaughter(daughter, esdIndex, AliRsnDaughter::kTrack);
index 2426ad4..9a36ddf 100644 (file)
@@ -152,7 +152,8 @@ void AliRsnAnalysisMonitorTask::UserExec(Option_t *)
   
   // create interface objects to AliRsnEvent to check event cuts
   AliRsnEvent event;
-  event.SetRef(esd, fMCEvent);
+  event.SetRef(esd);
+  event.SetRefMC(fMCEvent);
   if (!fEventCuts.IsSelected(&event)) return;
   
   // check the event
@@ -218,7 +219,8 @@ void AliRsnAnalysisMonitorTask::ProcessESD
   // create interfacr objects
   AliRsnEvent    event;
   AliRsnDaughter daughter;
-  event.SetRef(esd, fMCEvent);
+  event.SetRef(esd);
+  event.SetRefMC(fMCEvent);
 
   // ITS stuff #1 
   // create the response function and initialize it to MC or not
index 6d10c01..f3bc89d 100644 (file)
@@ -60,8 +60,8 @@ Bool_t AliRsnCutPrimaryVertex::IsSelected(TObject *obj1, TObject* /*obj2*/)
   // retrieve ESD event
   AliRsnEvent *rsn = dynamic_cast<AliRsnEvent*>(obj1);
   if (!rsn) return kFALSE;
-  AliESDEvent *esd = dynamic_cast<AliESDEvent*>(rsn->GetRef());
-  AliAODEvent *aod = dynamic_cast<AliAODEvent*>(rsn->GetRef());
+  AliESDEvent *esd = rsn->GetRefESD();
+  AliAODEvent *aod = rsn->GetRefAOD();
   
   if (esd)
   {
@@ -106,11 +106,16 @@ Bool_t AliRsnCutPrimaryVertex::IsSelected(TObject *obj1, TObject* /*obj2*/)
   else if (aod)
   {
     // lines suggested by Andrea to reject TPC-only events
-    if(!aod->GetPrimaryVertexSPD()) return kFALSE;
-    if(aod->GetPrimaryVertexSPD()->GetNContributors() < 1) return kFALSE;
+    if(!fAcceptTPC)
+    {
+      if (!aod->GetPrimaryVertexSPD()) return kFALSE;
+      else if(aod->GetPrimaryVertexSPD()->GetNContributors() < 1) return kFALSE;
+    }
     
     AliAODVertex *prim = (AliAODVertex*)aod->GetPrimaryVertex();
-    fCutValueI = prim->GetNContributors();
+    if (!prim) return kFALSE;
+
+    //fCutValueI = prim->GetNContributors();
     fCutValueD = prim->GetZ();
   }
   else
index 06c3242..3c5fbb5 100644 (file)
@@ -208,7 +208,7 @@ Bool_t AliRsnCutStd::IsDaughterSelected(AliRsnDaughter *daughter)
       if (!fEvent->GetRefMC()) return kFALSE;
       else
       {
-        return fEvent->GetRefMC()->Stack()->IsPhysicalPrimary(TMath::Abs(((AliVTrack*)ref)->GetLabel()));
+        return fEvent->GetRefMCESD()->Stack()->IsPhysicalPrimary(TMath::Abs(((AliVTrack*)ref)->GetLabel()));
       }
     default:
       AliWarning(Form("Value %d is not included in available cuts for DAUGHTER. Cut skipped.", fType));
@@ -243,7 +243,7 @@ Bool_t AliRsnCutStd::IsMotherSelected(AliRsnMother * const mother)
       fCutValueD = ref.Rapidity();
       return OkRange();
     case kDipAngle:
-      fCutValueD = mother->GetDaughter(0)->P().Angle(mother->GetDaughter(1)->P().Vect());
+      fCutValueD = mother->GetDaughter(0)->Prec().Angle(mother->GetDaughter(1)->Prec().Vect());
       fCutValueD = TMath::Abs(TMath::ACos(fCutValueD));
       return OkRangeD();
     case kSameLabel:
index 1aacb34..ae9b349 100644 (file)
 //
 
 #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 "AliRsnDaughter.h"
 
 ClassImp(AliRsnDaughter)
@@ -32,8 +23,8 @@ 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),
+  fPrec(0.0, 0.0, 0.0, 0.0),
+  fPsim(0.0, 0.0, 0.0, 0.0),
   fRef(0x0),
   fRefMC(0x0)
 {
@@ -48,8 +39,8 @@ AliRsnDaughter::AliRsnDaughter(const AliRsnDaughter &copy) :
   fOK(copy.fOK),
   fLabel(copy.fLabel),
   fMotherPDG(copy.fMotherPDG),
-  fP(copy.fP),
-  fPMC(copy.fPMC),
+  fPrec(copy.fPrec),
+  fPsim(copy.fPsim),
   fRef(copy.fRef),
   fRefMC(copy.fRefMC)
 {
@@ -72,8 +63,8 @@ AliRsnDaughter& AliRsnDaughter::operator=(const AliRsnDaughter &copy)
   fOK        = copy.fOK;
   fLabel     = copy.fLabel;
   fMotherPDG = copy.fMotherPDG;
-  fP         = copy.fP;
-  fPMC       = copy.fPMC;
+  fPrec      = copy.fPrec;
+  fPsim      = copy.fPsim;
   fRef       = copy.fRef;
   fRefMC     = copy.fRefMC;
 
@@ -81,15 +72,6 @@ AliRsnDaughter& AliRsnDaughter::operator=(const AliRsnDaughter &copy)
 }
 
 //_____________________________________________________________________________
-AliRsnDaughter::~AliRsnDaughter()
-{
-//
-// Destructor.
-// Since pointers do not allocate new objects, no 'delete' is done.
-//
-}
-
-//_____________________________________________________________________________
 void AliRsnDaughter::Reset()
 {
 //
@@ -104,69 +86,35 @@ void AliRsnDaughter::Reset()
   fRef       = 0x0;
   fRefMC     = 0x0;
   
-  fP  .SetXYZM(0.0, 0.0, 0.0, 0.0);
-  fPMC.SetXYZM(0.0, 0.0, 0.0, 0.0);
+  fPrec.SetXYZM(0.0, 0.0, 0.0, 0.0);
+  fPsim.SetXYZM(0.0, 0.0, 0.0, 0.0);
 }
 
 //_____________________________________________________________________________
-void AliRsnDaughter::Print(Option_t * const /*option*/) const
+Int_t AliRsnDaughter::GetPDG(Bool_t abs)
 {
 //
-// Prints the values of data members.
+// Return the PDG code of the particle from MC ref (if any).
+// If argument is kTRUE, returns its absolute value.
 //
-  
-  Char_t type[50], source[50];
-  if (IsTrack()) snprintf(type, 5, "track");
-  else if (IsV0()) snprintf(type, 2, "V0");
-  else snprintf(type, 4, "none");
-  
-  if (IsESD()) snprintf(source, 3, "ESD");
-  else if (IsAOD()) snprintf(source, 3, "AOD");
-  else if (fRefMC != 0x0) snprintf(source, 7, "MC only");
-  else snprintf(source, 4, "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)   : %f %f %f %f", fP.X(), fP.Y(), fP.Z(), fP.Perp()));
-  } else AliInfo("....... absent REF");
-  
-  if (fRefMC) 
-  {
-    AliInfo(Form(".......Px, Py, Pz, Pt (ref MC): %f %f %f %f", fP.X(), fP.Y(), fP.Z(), fP.Perp())); 
-    
-    AliInfo(Form(".......PDG code               : %d", GetPDG()));
-  } else AliInfo("....... absent REF MC");
-  
-  AliInfo("===== END ALIRSNDAUGHTER INFORMATION ==========================================");
-}
 
-//_____________________________________________________________________________
-Int_t AliRsnDaughter::GetPDG(Bool_t abs) const
-{
-//
-// Return the PDG code of the particle from MC ref (if any)
-//
+  Int_t pdg = 0;
 
-  AliMCParticle    *esdPart = GetRefMCESD();
-  AliAODMCParticle *aodPart = GetRefMCAOD();
+  // ESD
+  AliMCParticle *esd = GetRefMCESD();
+  if (esd) pdg = esd->Particle()->GetPdgCode();
   
-  Int_t pdg = 0;
-  if (esdPart) pdg = esdPart->Particle()->GetPdgCode();
-  if (aodPart) pdg = aodPart->GetPdgCode();
+  // AOD
+  AliAODMCParticle *aod = GetRefMCAOD();
+  if (aod) pdg = aod->GetPdgCode();
   
+  // abs value if required
   if (abs) pdg = TMath::Abs(pdg);
-  
   return pdg;
 }
 
 //_____________________________________________________________________________
-Int_t AliRsnDaughter::GetID() const
+Int_t AliRsnDaughter::GetID()
 {
 //
 // Return reference index, using the "GetID" method
@@ -174,32 +122,34 @@ Int_t AliRsnDaughter::GetID() const
 // In case of V0s, since this method is unsuccessful, return the label.
 //
 
-  const AliESDtrack *esd = GetRefESDtrack();
+  // ESD tracks
+  AliESDtrack *esd = GetRefESDtrack();
   if (esd) return esd->GetID();
 
-  const AliAODTrack *aod = GetRefAODtrack();
+  // AOD tracks
+  AliAODTrack *aod = GetRefAODtrack();
   if (aod) return aod->GetID();
 
+  // whatever else
   return GetLabel();
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnDaughter::HasFlag(ULong_t flag) const
+Bool_t AliRsnDaughter::HasFlag(ULong_t flag)
 {
 //
 // 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.
+// a combination of status flags specified in argument.
+// Works only with track-like objects, irrespectively if they
+// are ESD or AOD tracks, since it refers to their AliVTrack base class.
 //
 
-  if (IsTrack())
-  {
-    AliVTrack *track  = dynamic_cast<AliVTrack*>(fRef);
-    ULong_t    status = (ULong_t)track->GetStatus();
-    return ((status & flag) != 0);
-  }
+  AliVTrack *track  = dynamic_cast<AliVTrack*>(fRef);
+  if (!track) return kFALSE;
   
-  return kTRUE;
+  ULong_t status = (ULong_t)track->GetStatus();
+  
+  return ((status & flag) != 0);
 }
 
 //_____________________________________________________________________________
@@ -208,17 +158,16 @@ Bool_t AliRsnDaughter::SetMass(Double_t mass)
 //
 // Assign a mass hypothesis to the track.
 // This causes the 4-momentum data members to be initialized
-// using the reconstructed or MC momentum and this mass.
+// using the momenta of referenced tracks/v0s and this mass.
 // This step is fundamental for the following of the analysis.
 // Of course, this operation is successful only if the mass is
 // a meaningful positive number, and the pointers are properly initialized.
 //
 
   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);
+  if (fRef)   fPrec.SetXYZM(fRef  ->Px(), fRef  ->Py(), fRef  ->Pz(), mass);
+  if (fRefMC) fPsim.SetXYZM(fRefMC->Px(), fRefMC->Py(), fRefMC->Pz(), mass);
   
   return kTRUE;
 }
index 9eb536f..73138fb 100644 (file)
@@ -1,9 +1,8 @@
 //
 // Class AliRsnDaughter
 //
-// Interface to candidate daughters of a resonance (tracks).
-// 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
+// Interface to candidate daughters of a resonance (tracks or V0s).
+// It contains two pointers to two AliVParticle-derived objects.
 // for the computations required during resonance analysis.
 // ---
 // Since the package revision, this object is not supposed to be stacked in memory
 #include <TLorentzVector.h>
 
 #include "AliESDtrack.h"
-#include "AliAODTrack.h"
 #include "AliESDv0.h"
-#include "AliAODv0.h"
 #include "AliMCParticle.h"
+
+#include "AliAODTrack.h"
+#include "AliAODv0.h"
 #include "AliAODMCParticle.h"
 
 typedef AliPID::EParticleType EPARTYPE;
@@ -40,69 +40,68 @@ class AliRsnDaughter : public TObject
 
     AliRsnDaughter();
     AliRsnDaughter(const AliRsnDaughter &copy);
-    virtual ~AliRsnDaughter();
     AliRsnDaughter& operator= (const AliRsnDaughter& copy);
+    virtual ~AliRsnDaughter() { /*nothing*/ }
     
-    // utilities
-    void    Reset();
-    void    Print(Option_t* const option = "") const;
+    // basic getters (for data members)
+    Bool_t              IsOK() const {return fOK;}
+    Int_t               GetLabel() const {return fLabel;}
+    Int_t               GetMotherPDG() const {return fMotherPDG;}
+    TLorentzVector&     Prec() {return fPrec;}
+    TLorentzVector&     Psim() {return fPsim;}
+    TLorentzVector&     P(Bool_t mc = kFALSE) {return (mc ? fPsim : fPrec);}
+    AliVParticle*       GetRef() {return fRef;}
+    AliVParticle*       GetRefMC() {return fRefMC;}
     
-    // flags and labels
-    Bool_t  IsOK() const {return fOK;}
-    Int_t   GetLabel() const {return fLabel;}
-    Int_t   GetPDG(Bool_t abs = kTRUE) const;
-    Int_t   GetMotherPDG() const {return fMotherPDG;}
-    Int_t   GetID() const;
-    Bool_t  HasFlag(ULong_t flag) const;
-    void    SetBad() {fOK = kFALSE;}
-    void    SetGood() {fOK = kTRUE;}
-    void    SetLabel(Int_t label) {fLabel = label;}
-    void    SetMotherPDG(Int_t value) {fMotherPDG = value;}
-
-    // 4-momentum
-    TLorentzVector& P(Bool_t mc = kFALSE) {return (mc ? fPMC : fP);}
-    TLorentzVector& Prec() {return fP;}
-    TLorentzVector& Psim() {return fPMC;}
-    Bool_t          SetMass(Double_t mass);
+    // basic setters (for data members)
+    void            SetBad() {fOK = kFALSE;}
+    void            SetGood() {fOK = kTRUE;}
+    void            SetLabel(Int_t label) {fLabel = label;}
+    void            SetMotherPDG(Int_t value) {fMotherPDG = value;}
+    void            SetRef(AliVParticle *p) {fRef = p;}
+    void            SetRefMC(AliVParticle *p = 0x0) {fRefMC = p;}
     
-    // charge
+    // charge checkers
     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';}
+    
+    // utilities
+    void    Reset();
+    Int_t   GetPDG(Bool_t abs = kTRUE);
+    Int_t   GetID();
+    Bool_t  HasFlag(ULong_t flag);
+    Bool_t  SetMass(Double_t mass);
 
     // getters which automatically convert refs into allowed types
-    AliVParticle*     GetRef()         const {return fRef;}
-    AliVParticle*     GetRefMC()       const {return fRefMC;}
-    AliMCParticle*    GetRefMCtrack()  const {return dynamic_cast<AliMCParticle*>(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*    GetRefMCESD()    const {return dynamic_cast<AliMCParticle*>(fRefMC);}
-    AliAODMCParticle* GetRefMCAOD()    const {return dynamic_cast<AliAODMCParticle*>(fRefMC);}
-    Bool_t            IsMC()           const {if (GetRefMCtrack()) return kTRUE; return kFALSE;}
-    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() || GetRefMCtrack()) 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(AliVParticle *refMC) {fRefMC = refMC;}
+    AliMCParticle*    GetRefMCtrack()  {return dynamic_cast<AliMCParticle*>(fRef);}
+    AliESDtrack*      GetRefESDtrack() {return dynamic_cast<AliESDtrack*>(fRef);}
+    AliAODTrack*      GetRefAODtrack() {return dynamic_cast<AliAODTrack*>(fRef);}
+    AliESDv0*         GetRefESDv0()    {return dynamic_cast<AliESDv0*>(fRef);}
+    AliAODv0*         GetRefAODv0()    {return dynamic_cast<AliAODv0*>(fRef);}
+    AliMCParticle*    GetRefMCESD()    {return dynamic_cast<AliMCParticle*>(fRefMC);}
+    AliAODMCParticle* GetRefMCAOD()    {return dynamic_cast<AliAODMCParticle*>(fRefMC);}
+    Bool_t            IsMC()           {if (GetRefMCtrack()) return kTRUE; return kFALSE;}
+    Bool_t            IsAOD()          {if (GetRefAODtrack() || GetRefAODv0()) return kTRUE; return kFALSE;}
+    Bool_t            IsESD()          {if (GetRefESDtrack() || GetRefESDv0()) return kTRUE; return kFALSE;}
+    Bool_t            IsTrack()        {if (GetRefESDtrack() || GetRefAODtrack() || GetRefMCtrack()) return kTRUE; return kFALSE;}
+    Bool_t            IsV0()           {if (GetRefESDv0() || GetRefAODv0()) return kTRUE; return kFALSE;}
+    ERefType          RefType()        {if (IsTrack()) return kTrack; if (IsV0()) return kV0; return kNoType;}
 
   private:
 
-    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)
+    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)
+    TLorentzVector fPrec;        // 4-vector filled with track info from default ref (if present)
+    TLorentzVector fPsim;        // 4-vector filled with track info from MC ref (if present)
     
-    AliVParticle  *fRef;               // reference to reconstructed track in ESD/AOD
-    AliVParticle  *fRefMC;             // reference to corresponding MC particle
+    AliVParticle  *fRef;         // reference to reconstructed track in ESD/AOD
+    AliVParticle  *fRefMC;       // reference to corresponding MC particle
 
     ClassDef(AliRsnDaughter, 8)
 };
index a149369..8387092 100644 (file)
 #include "AliMCEvent.h"
 #include "AliStack.h"
 #include "AliGenEventHeader.h"
+#include "AliAODEvent.h"
 #include "AliRsnCutPID.h"
+#include "AliESDtrackCuts.h"
 
 #include "AliRsnEvent.h"
 
 ClassImp(AliRsnEvent)
 
 //_____________________________________________________________________________
-AliRsnEvent::AliRsnEvent(AliVEvent *ref, AliMCEvent *refMC) :
+AliRsnEvent::AliRsnEvent(AliVEvent *ref, AliVEvent *refMC) :
   fRef(ref),
   fRefMC(refMC),
   fLeading(-1)
@@ -63,19 +65,11 @@ AliRsnEvent& AliRsnEvent::operator= (const AliRsnEvent & event)
 }
 
 //_____________________________________________________________________________
-AliRsnEvent::~AliRsnEvent()
-{
-//
-// Destructor.
-//
-}
-
-//_____________________________________________________________________________
 Bool_t AliRsnEvent::SetDaughter(AliRsnDaughter &out, Int_t i, AliRsnDaughter::ERefType type)
 {
 //
 // Using the second and third arguments, retrieves the i-th object in the
-// appropriate sample (tracks or V0s) and sets the firs reference object
+// appropriate sample (tracks or V0s) and sets the first 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
@@ -83,131 +77,24 @@ Bool_t AliRsnEvent::SetDaughter(AliRsnDaughter &out, Int_t i, AliRsnDaughter::ER
 // 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)
-  if (type == AliRsnDaughter::kTrack)
-  {
-    if (i >= fRef->GetNumberOfTracks())
-    {
-      out.SetBad();
-      return kFALSE;
-    }
-    AliVTrack *track = (AliVTrack*)fRef->GetTrack(i);
-    if (!track)
-    {
-      out.SetBad();
-      return kFALSE;
-    }
-    else
-    {
-      label = TMath::Abs(track->GetLabel());
-      out.SetRef(track);
-      out.SetLabel(label);
-      if (fRefMC)
-      {
-        if (label < fRefMC->GetNumberOfTracks()) 
-        {
-          AliMCParticle *part = (AliMCParticle*)fRefMC->GetTrack(label);
-          out.SetRefMC(part);
-        }
-      }
-      out.SetGood();
-    }
-  }
-  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();
-    }
-  }
+  Int_t result = 0;
   
-  // 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()));
-        }
-      }
-    }
-  }
+  if (IsESD() && type == AliRsnDaughter::kTrack) result = SetDaughterESDtrack(out, i);
+  if (IsAOD() && type == AliRsnDaughter::kTrack) result = SetDaughterAODtrack(out, i);
+  if (IsESD() && type == AliRsnDaughter::kV0   ) result = SetDaughterESDv0   (out, i);
+  if (IsAOD() && type == AliRsnDaughter::kV0   ) result = SetDaughterAODv0   (out, i);
   
-  return kTRUE;
+  return (result == 0);
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnEvent::SetDaughterMC(AliRsnDaughter &out, Int_t i)
+Bool_t AliRsnEvent::SetDaughterMC(AliRsnDaughter &out, Int_t label)
 {
 //
 // Using the second argument, retrieves the i-th object in the
-// appropriate sample 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).
+// MC sample (if present) and assigns the track using only that,
+// so that it is considered both as main reference and MC reference.
+// (used for MC-only analysis).
 //
 
   if (!fRefMC)
@@ -215,80 +102,114 @@ Bool_t AliRsnEvent::SetDaughterMC(AliRsnDaughter &out, Int_t i)
     out.SetBad();
     return kFALSE;
   }
-
-  if (i >= fRefMC->GetNumberOfTracks())
-  {
-    out.SetBad();
-    return kFALSE;
-  }
   
-  AliMCParticle *track = (AliMCParticle*)fRef->GetTrack(i);
-  if (!track)
-  {
-    out.SetBad();
-    return kFALSE;
-  }
-  else
+  // try to convert into both types
+  Int_t        imum;
+  AliMCEvent  *esd = GetRefMCESD();
+  AliAODEvent *aod = GetRefMCAOD();
+  
+  // ESD
+  if (esd)
   {
+    // if the MC track exists, assign it
+    AliMCParticle *track = (AliMCParticle*)fRef->GetTrack(label);
+    if (!track)
+    {
+      out.SetBad();
+      return kFALSE;
+    }
     out.SetRef(track);
     out.SetRefMC(track);
-    out.SetLabel(i);
+    out.SetLabel(label);
     out.SetGood();
+    
+    // search for its mother in stack
+    imum = track->GetMother();
+    if (imum >= 0 && imum < esd->Stack()->GetNtrack())
+    {
+      TParticle *mum = esd->Stack()->Particle(imum);
+      if (mum) out.SetMotherPDG(TMath::Abs(mum->GetPdgCode()));
+    }
   }
   
-  AliStack  *stack = fRefMC->Stack();
-  TParticle *part  = track->Particle();
-  if (part)
+  // AOD
+  if (aod)
   {
-    Int_t imum = part->GetFirstMother();
-    if (imum >= 0 && imum <= stack->GetNtrack())
+    // checks that array of MC particles exists
+    TClonesArray *mcArray = (TClonesArray*)aod->GetList()->FindObject(AliAODMCParticle::StdBranchName());
+    if(!mcArray)
     {
-      TParticle *mum = stack->Particle(imum);
-      if (mum) out.SetMotherPDG(TMath::Abs(mum->GetPdgCode()));
+      out.SetBad();
+      return kFALSE;
+    }
+    
+    // in this case one has to loop over the sample to find the good one
+    TObjArrayIter next(mcArray);
+    AliAODMCParticle *part = 0x0;
+    while ( (part = (AliAODMCParticle*)next()) )
+    {
+      if (TMath::Abs(part->GetLabel()) == label)
+      {
+        // if the MC track exists, assign it
+        out.SetRef(part);
+        out.SetRefMC(part);
+        out.SetLabel(label);
+        out.SetGood();
+        
+        // search for the mother
+        imum = part->GetMother();
+        if (imum >= 0 && imum < mcArray->GetEntriesFast())
+        {
+          AliAODMCParticle *mum = (AliAODMCParticle*)mcArray->At(imum);
+          if (mum) out.SetMotherPDG(TMath::Abs(mum->GetPdgCode()));
+        }
+        break;
+      }
     }
+    return kTRUE;
   }
   
-  return kTRUE;
+  return kFALSE;
 }
 
 //_____________________________________________________________________________
 AliRsnDaughter AliRsnEvent::GetDaughter(Int_t i, AliRsnDaughter::ERefType type)
 {
 //
-// Return an AliRsnDaughter taken from this event,
-// with all additional data members well set.
+// Returns a daughter set using same criteria as SetDaughter
 //
-
-  AliRsnDaughter out;
-  SetDaughter(out, i, type);
-
-  return out;
+  
+  AliRsnDaughter d; 
+  SetDaughter(d, i, type); 
+  return d;
 }
 
 //_____________________________________________________________________________
 AliRsnDaughter AliRsnEvent::GetDaughterMC(Int_t i)
 {
 //
-// Return an AliRsnDaughter taken from this event,
-// with all additional data members well set.
+// Returns a daughter set using same criteria as SetDaughterMC
 //
-
-  AliRsnDaughter out;
-  SetDaughterMC(out, i);
-
-  return out;
+  
+  AliRsnDaughter d; 
+  SetDaughterMC(d, i); 
+  return d;
 }
 
 //_____________________________________________________________________________
-Int_t AliRsnEvent::GetMultiplicity()
+Int_t AliRsnEvent::GetMultiplicity(AliESDtrackCuts *cuts)
 {
 //
-// Returns event multiplicity
+// Returns event multiplicity as the number of tracks.
+// If the argument is not NULL, returns instead the 
+// number of tracks passing the cuts hereby defined.
 //
-  AliDebug(AliLog::kDebug+2,"<-");
+
   if (!fRef) return 0;
-  AliDebug(AliLog::kDebug+2,"->");
-  return fRef->GetNumberOfTracks();
+  
+  AliESDEvent *esd = GetRefESD();
+  if (cuts && esd) return cuts->CountAcceptedTracks(esd); 
+  else return fRef->GetNumberOfTracks();
 }
 
 //_____________________________________________________________________________
@@ -298,9 +219,7 @@ Double_t AliRsnEvent::GetVz()
 // Return Z coord of primary vertex
 //
 
-  AliDebug(AliLog::kDebug+2,"<-");
   return fRef->GetPrimaryVertex()->GetZ();
-  AliDebug(AliLog::kDebug+2,"->");
 }
 
 //_____________________________________________________________________________
@@ -321,10 +240,11 @@ Int_t AliRsnEvent::SelectLeadingParticle
   AliRsnDaughter leading;
   leading.SetBad();
 
-  for (i = 0; i < nTracks; i++) {
+  for (i = 0; i < nTracks; i++) 
+  {
     AliRsnDaughter track = GetDaughter(i);
     if (cutPID) if (!cutPID->IsSelected(&track)) continue;
-    AliVParticle *ref = track.GetRef();
+    const AliVParticle *ref = track.GetRef();
     if (ref->Pt() < ptMin) continue;
     //double pt = track.P().Perp();
     //Printf("track %d %g", i, pt);
@@ -397,3 +317,239 @@ Bool_t AliRsnEvent::GetAngleDistr
 
   return kTRUE;
 }
+
+//_____________________________________________________________________________
+Int_t AliRsnEvent::SetDaughterESDtrack(AliRsnDaughter &out, Int_t i)
+{
+//
+// Setup the first argument to the track identified by the index.
+// When available, adds the MC information and references.
+// ---
+// Version #1: ESD tracks
+//
+  
+  // check 1: index in good range
+  if (i < 0 || i >= fRef->GetNumberOfTracks())
+  {
+    out.SetBad();
+    return 1;
+  }
+  
+  // check 2: not NULL object
+  AliVTrack *track = (AliVTrack*)fRef->GetTrack(i);
+  if (!track)
+  {
+    out.SetBad();
+    return 2;
+  }
+  
+  // assign references of reconstructed track
+  Int_t label = TMath::Abs(track->GetLabel());
+  out.SetRef(track);
+  out.SetLabel(label);
+  out.SetGood();
+  
+  // search for MC track, if available
+  AliMCEvent *mc = GetRefMCESD();
+  if (!mc) return 0;
+  
+  // loop on particles using the track label as reference
+  // and then assign also the mother type, if found
+  AliStack *stack = mc->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()));
+      }
+    }
+    else
+    {
+      return 3;
+    }
+  }
+  
+  return 0;
+}
+
+//_____________________________________________________________________________
+Int_t AliRsnEvent::SetDaughterAODtrack(AliRsnDaughter &out, Int_t i)
+{
+//
+// Setup the first argument to the track identified by the index.
+// When available, adds the MC information and references.
+// ---
+// Version #2: AOD tracks
+//
+  
+  // check 1: index in good range
+  if (i < 0 || i >= fRef->GetNumberOfTracks())
+  {
+    out.SetBad();
+    return 1;
+  }
+  
+  // check 2: not NULL object
+  AliVTrack *track = (AliVTrack*)fRef->GetTrack(i);
+  if (!track)
+  {
+    out.SetBad();
+    return 2;
+  }
+  
+  // assign references of reconstructed track
+  Int_t label = TMath::Abs(track->GetLabel());
+  out.SetRef(track);
+  out.SetLabel(label);
+  out.SetGood();
+  
+  // search for MC track, if available
+  AliAODEvent *mc = GetRefMCAOD();
+  if (!mc) return 0;
+  
+  // loop on particles using the track label as reference
+  // and then assign also the mother type, if found
+  TClonesArray *mcArray = (TClonesArray*)mc->GetList()->FindObject(AliAODMCParticle::StdBranchName());
+  if(!mcArray) return 0;
+  TObjArrayIter next(mcArray);
+  AliAODMCParticle *part = 0x0;
+  while ( (part = (AliAODMCParticle*)next()) )
+  {
+    if (TMath::Abs(part->GetLabel()) == label)
+    {
+      out.SetRefMC(part);
+      Int_t imum = part->GetMother();
+      if (imum >= 0 && imum <= mcArray->GetEntriesFast())
+      {
+        AliAODMCParticle *mum = (AliAODMCParticle*)mcArray->At(imum);
+        if (mum) out.SetMotherPDG(TMath::Abs(mum->GetPdgCode()));
+      }
+      break;
+    }
+  }
+  
+  return 0;
+}
+
+//_____________________________________________________________________________
+Int_t AliRsnEvent::SetDaughterESDv0(AliRsnDaughter &out, Int_t i)
+{
+//
+// Setup the first argument to the track identified by the index.
+// When available, adds the MC information and references.
+// ---
+// Version #3: ESD v0
+//
+
+  // check 1: index in good range
+  if (i > fRef->GetNumberOfV0s())
+  {
+    out.SetBad();
+    return 1;
+  }
+  
+  // check 2: not NULL object
+  AliESDEvent *ev = GetRefESD();
+  AliESDv0    *v0 = ev->GetV0(i);
+  if (!v0)
+  {
+    out.SetBad();
+    return 2;
+  }
+  
+  // assign references of reconstructed track
+  out.SetRef(v0);
+  out.SetGood();
+  
+  // this time, assigning label is not trivial,
+  // it is done only if MC is present and both
+  // daughters come from a true particle
+  AliMCEvent  *mc = GetRefMCESD();
+  AliESDtrack *tp = ev->GetTrack(v0->GetPindex());
+  AliESDtrack *tn = ev->GetTrack(v0->GetNindex());
+  if (mc && tp && tn)
+  {
+    Int_t        lp = TMath::Abs(tp->GetLabel());
+    Int_t        ln = TMath::Abs(tn->GetLabel());
+    TParticle   *pp = mc->Stack()->Particle(lp);
+    TParticle   *pn = mc->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()) out.SetLabel(pp->GetFirstMother());
+  }
+  
+  return 0;
+}
+
+//_____________________________________________________________________________
+Int_t AliRsnEvent::SetDaughterAODv0(AliRsnDaughter &out, Int_t i)
+{
+//
+// Setup the first argument to the track identified by the index.
+// When available, adds the MC information and references.
+// ---
+// Version #4: AOD v0
+//
+
+  // check 1: index in good range
+  if (i > fRef->GetNumberOfV0s())
+  {
+    out.SetBad();
+    return 1;
+  }
+  
+  // check 2: not NULL object
+  AliAODEvent *ev = GetRefAOD();
+  AliAODv0    *v0 = ev->GetV0(i);
+  if (!v0)
+  {
+    out.SetBad();
+    return 2;
+  }
+  
+  // assign references of reconstructed track
+  out.SetRef(v0);
+  out.SetGood();
+  out.SetLabel(-1);
+  
+  // this time, assigning label is not trivial,
+  // it is done only if MC is present and both
+  // daughters come from a true particle
+  TClonesArray *mcArray = (TClonesArray*)ev->GetList()->FindObject(AliAODMCParticle::StdBranchName());
+  AliAODTrack  *tp = ev->GetTrack(v0->GetPosID());
+  AliAODTrack  *tn = ev->GetTrack(v0->GetNegID());
+  if (mcArray && tp && tn)
+  {
+    Int_t        lp = TMath::Abs(tp->GetLabel());
+    Int_t        ln = TMath::Abs(tn->GetLabel());
+    // loop on array to find MC daughters
+    AliAODMCParticle *pp = 0x0, *pn = 0x0;
+    TObjArrayIter next(mcArray);
+    AliAODMCParticle *part = 0x0;
+    while ( (part = (AliAODMCParticle*)next()) )
+    {
+      if (TMath::Abs(part->GetLabel()) == lp) pp = (AliAODMCParticle*)mcArray->IndexOf(part);
+      if (TMath::Abs(part->GetLabel()) == ln) pn = (AliAODMCParticle*)mcArray->IndexOf(part);
+    }
+    // assign a MC reference and a label only to true V0s
+    if (pp->GetMother() == pn->GetMother())
+    {
+      AliAODMCParticle *mcv0 = (AliAODMCParticle*)mcArray->At(pp->GetMother());
+      out.SetRefMC(mcv0);
+      out.SetLabel(pp->GetMother());
+      Int_t imum = mcv0->GetMother();
+      if (imum >= 0 && imum <= mcArray->GetEntriesFast())
+      {
+        AliAODMCParticle *mum = (AliAODMCParticle*)mcArray->At(imum);
+        if (mum) out.SetMotherPDG(TMath::Abs(mum->GetPdgCode()));
+      }
+    }
+  }
+  
+  return 0;
+}
index cf95e5a..331ffa1 100644 (file)
 #ifndef ALIRSNEVENT_H
 #define ALIRSNEVENT_H
 
+#include "AliMCEvent.h"
 #include "AliESDEvent.h"
 #include "AliAODEvent.h"
 #include "AliRsnDaughter.h"
 
 class AliVEvent;
-class AliMCEvent;
 class AliRsnCutPID;
+class AliESDtrackCuts;
 
 class AliRsnEvent : public TObject
 {
   public:
 
-    AliRsnEvent(AliVEvent *ref = 0, AliMCEvent *refMC = 0);
+    AliRsnEvent(AliVEvent *ref = 0, AliVEvent *refMC = 0);
     AliRsnEvent(const AliRsnEvent& copy);
     AliRsnEvent& operator= (const AliRsnEvent& copy);
-    virtual ~AliRsnEvent();
-
-    void             SetRef(AliVEvent * const event, AliMCEvent * const mc = 0) {fRef = event; fRefMC = mc;}
-    AliVEvent*       GetRef() const {return fRef;}
-    AliMCEvent*      GetRefMC() const {return fRefMC;}
-    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);}
+    virtual ~AliRsnEvent() { /*nothing*/ }
+    
+    // basic setters/getters
+    void       SetRef(AliVEvent *ref) {fRef = ref;}
+    void       SetRefMC(AliVEvent *refmc) {fRefMC = refmc;}
+    void       SetLeadingIndex(Int_t i) {fLeading = i;}
+    AliVEvent* GetRef() {return fRef;}
+    AliVEvent* GetRefMC() {return fRefMC;}
+    Int_t      GetLeadingIndex() const {return fLeading;}
+    
+    // getters which convert into allowed input types
+    AliESDEvent* GetRefESD()   {return dynamic_cast<AliESDEvent*>(fRef);}
+    AliAODEvent* GetRefAOD()   {return dynamic_cast<AliAODEvent*>(fRef);}
+    AliMCEvent*  GetRefMCESD() {return dynamic_cast<AliMCEvent*>(fRefMC);}
+    AliAODEvent* GetRefMCAOD() {return dynamic_cast<AliAODEvent*>(fRefMC);}
+    Bool_t       IsESD()       {return (GetRefESD() != 0x0);}
+    Bool_t       IsAOD()       {return (GetRefAOD() != 0x0);}
     
+    // advanced getters
     Double_t         GetVz();
-    Int_t            GetMultiplicity();
+    Int_t            GetMultiplicity(AliESDtrackCuts *cuts = 0x0);
     
+    // setters for a daughter
     Bool_t           SetDaughter(AliRsnDaughter &daughter, Int_t index, AliRsnDaughter::ERefType type = AliRsnDaughter::kTrack);
     Bool_t           SetDaughterMC(AliRsnDaughter &daughter, Int_t index);
     AliRsnDaughter   GetDaughter(Int_t i, AliRsnDaughter::ERefType type = AliRsnDaughter::kTrack);
     AliRsnDaughter   GetDaughterMC(Int_t i);
     
+    // leading particle stuff
     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);}
@@ -54,12 +66,17 @@ class AliRsnEvent : public TObject
     Bool_t           GetAngleDistr(Double_t &angleMean, Double_t &angleRMS, AliRsnDaughter reference);
 
   private:
+  
+    Int_t SetDaughterESDtrack(AliRsnDaughter &target, Int_t index);
+    Int_t SetDaughterAODtrack(AliRsnDaughter &target, Int_t index);
+    Int_t SetDaughterESDv0   (AliRsnDaughter &target, Int_t index);
+    Int_t SetDaughterAODv0   (AliRsnDaughter &target, Int_t index);
 
-    AliVEvent       *fRef;         // pointer to input event
-    AliMCEvent      *fRefMC;       // pointer to reference MC event (if any)
-    Int_t            fLeading;     // index of leading track
+    AliVEvent       *fRef;      // pointer to input event
+    AliVEvent       *fRefMC;    // pointer to reference MC event (if any)
+    Int_t            fLeading;  // index of leading track
 
-    ClassDef(AliRsnEvent, 3);
+    ClassDef(AliRsnEvent, 4);
 };
 
 #endif
index ac70d61..6f29d9a 100644 (file)
@@ -15,6 +15,7 @@
 
 #include <TLorentzVector.h>
 
+#include "AliRsnEvent.h"
 #include "AliRsnDaughter.h"
 
 class AliRsnPairDef;
@@ -29,15 +30,16 @@ class AliRsnMother : public TObject
     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&   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());}
     Double_t          CosThetaStar(Bool_t first = kTRUE, Bool_t useMC = kFALSE);
 
-    AliRsnDaughter*   GetDaughter(const Int_t &index) const {if (index==0||index==1) return fDaughter[index]; return 0x0;}
+    AliRsnDaughter*   GetDaughter   (const Int_t &index) const {if (index==0||index==1) return fDaughter[index]; return 0x0;}
+    AliRsnDaughter&   GetDaughterRef(const Int_t &index) const {if (index==1) return (*fDaughter[1]); return (*fDaughter[0]);}
 
     Bool_t            IsLabelEqual() const {return abs(fDaughter[0]->GetLabel()) == abs(fDaughter[1]->GetLabel());}
     Bool_t            IsIndexEqual() const {return (fDaughter[0]->GetID() == fDaughter[1]->GetID());}
index ae91ca7..2eae80b 100644 (file)
@@ -126,7 +126,7 @@ Bool_t AliRsnPair::Fill
   // and that of the mother, according to current pair def
   // this could be needed for some cuts
   fMother.SetDaughters(daughter0, fPairDef->GetMass(0), daughter1, fPairDef->GetMass(1));
-  
+    
   // 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;
index 6c680bd..6aa237e 100644 (file)
@@ -183,13 +183,25 @@ void AliRsnVAnalysisTaskSE::UserExec(Option_t* opt)
   // otherwise the AOD event is used;
   // if the MC information is available, it is linked
   if (fMCOnly && fMCEvent)
-    fRsnEvent.SetRef(fMCEvent, fMCEvent);
+  {
+    fRsnEvent.SetRef  (fMCEvent);
+    fRsnEvent.SetRefMC(fMCEvent);
+  }
   else if (fESDEvent)
-    fRsnEvent.SetRef(fESDEvent, fMCEvent);
+  {
+    fRsnEvent.SetRef  (fESDEvent);
+    fRsnEvent.SetRefMC(fMCEvent);
+  }
   else if (fAODEventOut)
-    fRsnEvent.SetRef(fAODEventOut);
+  {
+    fRsnEvent.SetRef  (fAODEventOut);
+    fRsnEvent.SetRefMC(fAODEventOut);
+  }
   else if (fAODEventIn)
-    fRsnEvent.SetRef(fAODEventIn);
+  {
+    fRsnEvent.SetRef  (fAODEventIn);
+    fRsnEvent.SetRefMC(fAODEventIn);
+  }
   else {
     AliError("NO ESD or AOD object!!! Skipping ...");
     return;
index 0a89c22..fa393e7 100644 (file)
@@ -158,7 +158,7 @@ void AliRsnValue::SetBins(Int_t nbins, Double_t *array)
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnValue::Eval(AliRsnMother * const mother, AliRsnPairDef * const pairDef, AliRsnEvent * const event)
+Bool_t AliRsnValue::Eval(AliRsnMother *mother, AliRsnPairDef *pairDef, AliRsnEvent *event)
 {
 //
 // Evaluation of the required value.
@@ -247,26 +247,14 @@ Bool_t AliRsnValue::Eval(AliRsnMother * const mother, AliRsnPairDef * const pair
     case kPairCosThetaStar:
       fValue = mother->CosThetaStar();
       break;
-    case kPairCosThetaStar1:
-      //fValue = TMath::Cos(mother->ThetaStar(kTRUE, kFALSE));
-      break;
-    case kPairCosThetaStar2:
-      //fValue = TMath::Cos(mother->ThetaStar(kFALSE, kFALSE));
-      break;
-    case kPairCosThetaStarMC1:
-      //fValue = TMath::Cos(mother->ThetaStar(kTRUE, kTRUE));
-      break;
-    case kPairCosThetaStarMC2:
-      //fValue = TMath::Cos(mother->ThetaStar(kFALSE, kTRUE));
-      break;
     case kAngleToLeading:
       {
          int ID1 = (mother->GetDaughter(0))->GetID();
          int ID2 = (mother->GetDaughter(1))->GetID();
          int leadingID = event->SelectLeadingParticle(0);
          if(leadingID == ID1 || leadingID == ID2) return kFALSE;
-         AliRsnDaughter  leadingPart = event->GetDaughter(leadingID);
-         AliVParticle *ref = leadingPart.GetRef();
+         AliRsnDaughter leadingPart = event->GetDaughter(leadingID);
+         AliVParticle  *ref = leadingPart.GetRef();
 
          fValue = ref->Phi() - mother->Sum().Phi();
          //return angle w.r.t. leading particle in the range -pi/2, 3/2pi
@@ -281,25 +269,15 @@ Bool_t AliRsnValue::Eval(AliRsnMother * const mother, AliRsnPairDef * const pair
         fValue = 0.0;
         return kFALSE;
       }
-      else fValue = (Double_t)event->GetMultiplicity();
+      else fValue = (Double_t)event->GetMultiplicity(0x0);
       break;
-    case kEventMultESDcuts:
-      if (!event)
+    case kEventMultESDCuts:
+      if (!event) 
       {
         fValue = 0.0;
         return kFALSE;
       }
-      else
-      {
-        AliESDEvent *esd = event->GetRefESD();
-        if (!esd)
-        {
-          AliError("Cannot use method based on ESD cuts when input is not ESD.");
-          fValue = 0.0;
-          return kFALSE;
-        }
-        fValue = (Double_t)fESDCuts.CountAcceptedTracks(esd);
-      }
+      else fValue = (Double_t)event->GetMultiplicity(&fESDCuts);
       break;
     case kLeadingPt:
       if (!event) 
@@ -356,23 +334,13 @@ Bool_t AliRsnValue::Eval(AliRsnDaughter * const daughter, AliRsnEvent * const ev
       }
       else fValue = (Double_t)event->GetMultiplicity();
       break;
-    case kEventMultESDcuts:
-      if (!event)
+    case kEventMultESDCuts:
+      if (!event) 
       {
         fValue = 0.0;
         return kFALSE;
       }
-      else
-      {
-        AliESDEvent *esd = event->GetRefESD();
-        if (!esd)
-        {
-          AliError("Cannot use method based on ESD cuts when input is not ESD.");
-          fValue = 0.0;
-          return kFALSE;
-        }
-        fValue = (Double_t)fESDCuts.CountAcceptedTracks(esd);
-      }
+      else fValue = (Double_t)event->GetMultiplicity(&fESDCuts);
       break;
     case kLeadingPt:
       if (!event) 
index f0c1844..0a1ef22 100644 (file)
@@ -44,15 +44,11 @@ class AliRsnValue : public TNamed
       kPairPtRatio,
       kPairDipAngle,
       kPairCosThetaStar,
-      kPairCosThetaStar1,
-      kPairCosThetaStar2,
-      kPairCosThetaStarMC1,
-      kPairCosThetaStarMC2,
       kAngleToLeading,
       kLeadingPt,
       kQInv,
       kEventMult,
-      kEventMultESDcuts,
+      kEventMultESDCuts,
       kValueTypes
     };
 
@@ -77,8 +73,8 @@ class AliRsnValue : public TNamed
     void        Set(EValueType type, Double_t min, Double_t max, Double_t step) {fType = type; SetBins(min, max, step);}
     void        Set(EValueType type, Int_t n, Double_t *array) {fType = type; SetBins(n, array);}
     
-    virtual Bool_t  Eval(AliRsnMother * const mother, AliRsnPairDef * const pairDef, AliRsnEvent * const event);
-    virtual Bool_t  Eval(AliRsnDaughter * const daughter, AliRsnEvent * const event);
+    virtual Bool_t  Eval(AliRsnMother *mother, AliRsnPairDef *pairDef, AliRsnEvent *event);
+    virtual Bool_t  Eval(AliRsnDaughter *daughter, AliRsnEvent *event);
     virtual void    Print(Option_t *option = "") const;
 
   protected:
index e147ea4..b0a8bbc 100644 (file)
@@ -41,8 +41,9 @@ Bool_t AddRsnAnalysis
     ConfigESDCutsTPC(cutMult->GetCuts());
     
     task->GetEventCuts()->AddCut(cutVertex);
-    task->GetEventCuts()->AddCut(cutMult);
-    task->GetEventCuts()->SetCutScheme("cutVertex&cutMult");
+    //task->GetEventCuts()->AddCut(cutMult);
+    //task->GetEventCuts()->SetCutScheme("cutVertex&cutMult");
+    task->GetEventCuts()->SetCutScheme("cutVertex");
   }
 
   // add the task to manager
index a739fcd..5fcd41b 100644 (file)
@@ -13,7 +13,7 @@
 Bool_t AddRsnAnalysisMult
 (
   const char *options,
-  const char *configs = "RsnConfigNoSA.C RsnConfigSA.C RsnConfigDipNoSA.C RsnConfigDipSA.C",
+  const char *configs = "RsnConfigNoSA.C RsnConfigSA.C",
   const char *path    = "$(ALICE_ROOT)/PWG2/RESONANCES/macros/train/LHC2010-7TeV-phi"
 )
 {
index af9d82c..aa8a717 100644 (file)
@@ -40,7 +40,7 @@ Bool_t AddRsnEfficiency(const char *dataLabel)
   AliRsnValue *axisIM   = new AliRsnValue("IM"  , AliRsnValue::kPairInvMass     , 500  , 0.9,  1.4);
   //AliRsnValue *axisPt   = new AliRsnValue("PT"  , AliRsnValue::kPairPt          , npt  , pt);
   //AliRsnValue *axisY    = new AliRsnValue("Y"   , AliRsnValue::kPairY           , ny   , y);
-  AliRsnValue *axisMult = new AliRsnValue("Mult", AliRsnValue::kEventMultESDcuts, nmult, mult);
+  //AliRsnValue *axisMult = new AliRsnValue("Mult", AliRsnValue::kEventMultESDcuts, nmult, mult);
   AliRsnValue *axisPt   = new AliRsnValue("PT"  , AliRsnValue::kPairPt          , 100,  0.0, 10.0);
   AliRsnValue *axisY    = new AliRsnValue("Y"   , AliRsnValue::kPairY           ,  20, -1.0,  1.0);
   ConfigESDCutsTPC(axisMult->GetCuts());
index 7ccb350..753f982 100644 (file)
@@ -198,7 +198,7 @@ Bool_t RsnConfig
   AliRsnValue *axisIM   = new AliRsnValue("IM"  , AliRsnValue::kPairInvMass     , 500 , 0.9,  1.4);
   AliRsnValue *axisPt   = new AliRsnValue("PT"  , AliRsnValue::kPairPt          , npt  , pt);
   AliRsnValue *axisY    = new AliRsnValue("Y"   , AliRsnValue::kPairY           , ny   , y);
-  AliRsnValue *axisMult = new AliRsnValue("Mult", AliRsnValue::kEventMultESDcuts, nmult, mult);
+  AliRsnValue *axisMult = new AliRsnValue("Mult", AliRsnValue::kEventMultESDCuts, nmult, mult);
   ConfigESDCutsTPC(axisMult->GetCuts());
 
   // create function and add axes