Removed old ME classes, since the nex event mixing has been introduced and is integra...
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 9 Feb 2011 10:40:29 +0000 (10:40 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 9 Feb 2011 10:40:29 +0000 (10:40 +0000)
while ole AliRsnAnalysiSE is kept for backward compatibility (and new configs work perfectly also there).

Removed experimental classes which apply to only one resonance, since they complicate things instead of simplifying.

Removed AOD integrated cut, which are managed elsewhere. ESD integrated cuts are kept since they are used currently,
and switching to new splitted implementation will be more gradual.

All classes have been passed with astyle in order to improve code style and readability. Configuration script is
a modified version of that provided by ROOT, with the addition not to break single-line implementations (inline functions implemented in .h file)

78 files changed:
PWG2/CMakelibPWG2resonances.pkg
PWG2/PWG2resonancesLinkDef.h
PWG2/RESONANCES/AliRsnAnalysisEffSE.cxx
PWG2/RESONANCES/AliRsnAnalysisEffSE.h
PWG2/RESONANCES/AliRsnAnalysisKStarKpi.cxx [deleted file]
PWG2/RESONANCES/AliRsnAnalysisKStarKpi.h [deleted file]
PWG2/RESONANCES/AliRsnAnalysisME.cxx [deleted file]
PWG2/RESONANCES/AliRsnAnalysisME.h [deleted file]
PWG2/RESONANCES/AliRsnAnalysisManager.cxx
PWG2/RESONANCES/AliRsnAnalysisManager.h
PWG2/RESONANCES/AliRsnAnalysisMonitorPairTask.cxx [deleted file]
PWG2/RESONANCES/AliRsnAnalysisMonitorPairTask.h [deleted file]
PWG2/RESONANCES/AliRsnAnalysisMonitorTask.cxx
PWG2/RESONANCES/AliRsnAnalysisMonitorTask.h
PWG2/RESONANCES/AliRsnAnalysisPhiKK.cxx [deleted file]
PWG2/RESONANCES/AliRsnAnalysisPhiKK.h [deleted file]
PWG2/RESONANCES/AliRsnAnalysisSE.cxx
PWG2/RESONANCES/AliRsnAnalysisSE.h
PWG2/RESONANCES/AliRsnAnalysisTask.cxx
PWG2/RESONANCES/AliRsnAnalysisTask.h
PWG2/RESONANCES/AliRsnCut.cxx
PWG2/RESONANCES/AliRsnCut.h
PWG2/RESONANCES/AliRsnCutAOD2010.cxx [deleted file]
PWG2/RESONANCES/AliRsnCutAOD2010.h [deleted file]
PWG2/RESONANCES/AliRsnCutESD2010.cxx
PWG2/RESONANCES/AliRsnCutESD2010.h
PWG2/RESONANCES/AliRsnCutManager.cxx
PWG2/RESONANCES/AliRsnCutManager.h
PWG2/RESONANCES/AliRsnCutPID.cxx
PWG2/RESONANCES/AliRsnCutPID.h
PWG2/RESONANCES/AliRsnCutPIDITS.cxx
PWG2/RESONANCES/AliRsnCutPIDITS.h
PWG2/RESONANCES/AliRsnCutPIDTOF.cxx
PWG2/RESONANCES/AliRsnCutPIDTOF.h
PWG2/RESONANCES/AliRsnCutPIDTPC.cxx
PWG2/RESONANCES/AliRsnCutPIDTPC.h
PWG2/RESONANCES/AliRsnCutPrimaryVertex.cxx
PWG2/RESONANCES/AliRsnCutPrimaryVertex.h
PWG2/RESONANCES/AliRsnCutSet.cxx
PWG2/RESONANCES/AliRsnCutSet.h
PWG2/RESONANCES/AliRsnCutTrackQuality.cxx
PWG2/RESONANCES/AliRsnCutTrackQuality.h
PWG2/RESONANCES/AliRsnCutValue.cxx
PWG2/RESONANCES/AliRsnCutValue.h
PWG2/RESONANCES/AliRsnDaughter.cxx
PWG2/RESONANCES/AliRsnDaughter.h
PWG2/RESONANCES/AliRsnEvent.cxx
PWG2/RESONANCES/AliRsnEvent.h
PWG2/RESONANCES/AliRsnExpression.cxx
PWG2/RESONANCES/AliRsnExpression.h
PWG2/RESONANCES/AliRsnFunction.cxx
PWG2/RESONANCES/AliRsnFunction.h
PWG2/RESONANCES/AliRsnMonitorTrack.cxx
PWG2/RESONANCES/AliRsnMonitorTrack.h
PWG2/RESONANCES/AliRsnMother.cxx
PWG2/RESONANCES/AliRsnMother.h
PWG2/RESONANCES/AliRsnPair.cxx
PWG2/RESONANCES/AliRsnPair.h
PWG2/RESONANCES/AliRsnPairDef.cxx
PWG2/RESONANCES/AliRsnPairDef.h
PWG2/RESONANCES/AliRsnPairFunctions.cxx
PWG2/RESONANCES/AliRsnPairFunctions.h
PWG2/RESONANCES/AliRsnPairNtuple.cxx
PWG2/RESONANCES/AliRsnPairNtuple.h
PWG2/RESONANCES/AliRsnTarget.cxx
PWG2/RESONANCES/AliRsnTarget.h
PWG2/RESONANCES/AliRsnVATProcessInfo.cxx
PWG2/RESONANCES/AliRsnVATProcessInfo.h
PWG2/RESONANCES/AliRsnVAnalysisTask.cxx
PWG2/RESONANCES/AliRsnVAnalysisTask.h
PWG2/RESONANCES/AliRsnVAnalysisTaskME.cxx [deleted file]
PWG2/RESONANCES/AliRsnVAnalysisTaskME.h [deleted file]
PWG2/RESONANCES/AliRsnVAnalysisTaskSE.cxx
PWG2/RESONANCES/AliRsnVAnalysisTaskSE.h
PWG2/RESONANCES/AliRsnValue.cxx
PWG2/RESONANCES/AliRsnValue.h
PWG2/RESONANCES/AliRsnVariableExpression.cxx
PWG2/RESONANCES/AliRsnVariableExpression.h

index 5ae2063..3aa1b12 100644 (file)
@@ -35,7 +35,6 @@ set ( SRCS RESONANCES/AliRsnDaughter.cxx
            RESONANCES/AliRsnCutValue.cxx 
            RESONANCES/AliRsnCutPrimaryVertex.cxx 
            RESONANCES/AliRsnCutESD2010.cxx 
-           RESONANCES/AliRsnCutAOD2010.cxx 
            RESONANCES/AliRsnCutTrackQuality.cxx 
            RESONANCES/AliRsnCutPID.cxx 
            RESONANCES/AliRsnCutPIDITS.cxx 
@@ -52,12 +51,8 @@ set ( SRCS RESONANCES/AliRsnDaughter.cxx
            RESONANCES/AliRsnAnalysisManager.cxx 
            RESONANCES/AliRsnVATProcessInfo.cxx 
            RESONANCES/AliRsnVAnalysisTaskSE.cxx 
-           RESONANCES/AliRsnVAnalysisTaskME.cxx 
            RESONANCES/AliRsnAnalysisSE.cxx 
-           RESONANCES/AliRsnAnalysisME.cxx 
            RESONANCES/AliRsnAnalysisEffSE.cxx 
-           RESONANCES/AliRsnAnalysisPhiKK.cxx 
-           RESONANCES/AliRsnAnalysisKStarKpi.cxx 
            RESONANCES/AliRsnVAnalysisTask.cxx 
            RESONANCES/AliRsnAnalysisTask.cxx 
            RESONANCES/AliRsnMonitorTrack.cxx 
index 12acecf..7026c41 100644 (file)
@@ -12,7 +12,6 @@
 #pragma link C++ class AliRsnCutValue+;
 #pragma link C++ class AliRsnCutPrimaryVertex+;
 #pragma link C++ class AliRsnCutESD2010+;
-#pragma link C++ class AliRsnCutAOD2010+;
 #pragma link C++ class AliRsnCutTrackQuality+;
 #pragma link C++ class AliRsnCutPID+;
 #pragma link C++ class AliRsnCutPIDITS+;
 
 #pragma link C++ class AliRsnVATProcessInfo+;
 #pragma link C++ class AliRsnVAnalysisTaskSE+;
-#pragma link C++ class AliRsnVAnalysisTaskME+;
 
 #pragma link C++ class AliRsnAnalysisSE+;
-#pragma link C++ class AliRsnAnalysisME+;
 #pragma link C++ class AliRsnAnalysisEffSE+;
-#pragma link C++ class AliRsnAnalysisPhiKK+;
-#pragma link C++ class AliRsnAnalysisKStarKpi+;
 
 #pragma link C++ class AliRsnVAnalysisTask+;
 #pragma link C++ class AliRsnAnalysisTask+;
index 0761193..90a86c9 100644 (file)
@@ -24,44 +24,44 @@ ClassImp(AliRsnAnalysisEffSE)
 
 //_____________________________________________________________________________
 AliRsnAnalysisEffSE::AliRsnAnalysisEffSE(const char *name) :
-  AliRsnVAnalysisTaskSE(name),
-  fUseITSSA(kTRUE),
-  fUseGlobal(kTRUE),
-  fStepListMC(0),
-  fStepListESD(0),
-  fAxisList("AliRsnValue", 0),
-  fPairDefList(0),
-  fContainerList(0x0),
-  fOutList(0x0),
-  fVar(0),
-  fPair(),
-  fEventCuts("eventCuts", AliRsnCut::kEvent)
+   AliRsnVAnalysisTaskSE(name),
+   fUseITSSA(kTRUE),
+   fUseGlobal(kTRUE),
+   fStepListMC(0),
+   fStepListESD(0),
+   fAxisList("AliRsnValue", 0),
+   fPairDefList(0),
+   fContainerList(0x0),
+   fOutList(0x0),
+   fVar(0),
+   fPair(),
+   fEventCuts("eventCuts", AliRsnCut::kEvent)
 {
 //
 // Default constructor.
 //
 
-  AliDebug(AliLog::kDebug+2,"<-");
+   AliDebug(AliLog::kDebug + 2, "<-");
 
-  DefineOutput(2, TList::Class());
+   DefineOutput(2, TList::Class());
 
-  AliDebug(AliLog::kDebug+2,"->");
+   AliDebug(AliLog::kDebug + 2, "->");
 }
 
 //_____________________________________________________________________________
 AliRsnAnalysisEffSE::AliRsnAnalysisEffSE(const AliRsnAnalysisEffSE& copy) :
-  AliRsnVAnalysisTaskSE(copy),
-  fUseITSSA(copy.fUseITSSA),
-  fUseGlobal(copy.fUseGlobal),
-  fStepListMC(copy.fStepListMC),
-  fStepListESD(copy.fStepListESD),
-  fAxisList(copy.fAxisList),
-  fPairDefList(copy.fPairDefList),
-  fContainerList(copy.fContainerList),
-  fOutList(0x0),
-  fVar(0),
-  fPair(),
-  fEventCuts(copy.fEventCuts)
+   AliRsnVAnalysisTaskSE(copy),
+   fUseITSSA(copy.fUseITSSA),
+   fUseGlobal(copy.fUseGlobal),
+   fStepListMC(copy.fStepListMC),
+   fStepListESD(copy.fStepListESD),
+   fAxisList(copy.fAxisList),
+   fPairDefList(copy.fPairDefList),
+   fContainerList(copy.fContainerList),
+   fOutList(0x0),
+   fVar(0),
+   fPair(),
+   fEventCuts(copy.fEventCuts)
 {
 //
 // Copy constrtuctor
@@ -75,28 +75,28 @@ void AliRsnAnalysisEffSE::AddStepMC(AliRsnCutManager *mgr)
 // Add a step on montecarlo
 //
 
-  fStepListMC.AddLast(mgr);
+   fStepListMC.AddLast(mgr);
 }
 
 //_____________________________________________________________________________
-void AliRsnAnalysisEffSE::AddStepESD(AliRsnCutManager *mgr) 
+void AliRsnAnalysisEffSE::AddStepESD(AliRsnCutManager *mgr)
 {
 //
 // Add a step on ESD
 //
 
-  fStepListESD.AddLast(mgr);
+   fStepListESD.AddLast(mgr);
 }
-    
+
 //_____________________________________________________________________________
-void AliRsnAnalysisEffSE::AddAxis(AliRsnValue *axis) 
+void AliRsnAnalysisEffSE::AddAxis(AliRsnValue *axis)
 {
 //
 // Add a new axis
 //
 
-  Int_t n = fAxisList.GetEntries();
-  new (fAxisList[n]) AliRsnValue(*axis);
+   Int_t n = fAxisList.GetEntries();
+   new(fAxisList[n]) AliRsnValue(*axis);
 }
 
 //_____________________________________________________________________________
@@ -109,68 +109,65 @@ void AliRsnAnalysisEffSE::RsnUserCreateOutputObjects()
 // 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  = 0;
-  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];
-  for (iaxis = 0; iaxis < nAxes; iaxis++) 
-  {
-    AliRsnValue *fcnAxis = (AliRsnValue*)fAxisList.At(iaxis);
-    nBins[iaxis] = fcnAxis->GetArray().GetSize() - 1;
-  }
-
-  // create ouput list of containers
-  fContainerList = new TList;
-  fContainerList->SetOwner();
-  fContainerList->SetName(Form("%s_containers", GetName()));
-
-  // initialize output list
-  OpenFile(2);
-  fOutList = new TList();
-  fOutList->SetOwner();
-
-  // create the containers
-  Int_t i = 0, nDef = (Int_t)fPairDefList.GetEntries();
-  for (i = 0; i < nDef; i++) 
-  {
-    AliRsnPairDef *def = (AliRsnPairDef*)fPairDefList[i];
-    AliCFContainer *cont = new AliCFContainer(Form("%s", def->GetPairName()), "", nSteps, nAxes, nBins);
-    // set the bin limits for each axis
-    for (iaxis = 0; iaxis < nAxes; iaxis++) 
-    {
-      AliRsnValue *fcnAxis = (AliRsnValue*)fAxisList.At(iaxis);
-      cont->SetBinLimits(iaxis, fcnAxis->GetArray().GetArray());
-    }
-    // add the container to output list
-    fContainerList->Add(cont);
-  }
+   AliDebug(AliLog::kDebug + 2, "<-");
+
+   // get number of steps and axes
+   Int_t iaxis  = 0;
+   Int_t nAxes  = fAxisList.GetEntries();
+   Int_t nSteps = (Int_t)fStepListMC.GetEntries() + (Int_t)fStepListESD.GetEntries();
 
-  fOutList->Add(fContainerList);
-  fOutList->Print();
+   if (!nSteps) {
+      AliError("No steps defined");
+      return;
+   }
+   if (!nAxes) {
+      AliError("No axes defined");
+      return;
+   }
 
-  PostData(2, fOutList);
-  
-  // clear heap
-  delete [] nBins;
+   // initialize variable list
+   fVar.Set(nAxes);
 
-  AliDebug(AliLog::kDebug+2,"->");
+   // retrieve number of bins for each axis
+   Int_t *nBins = new Int_t[nAxes];
+   for (iaxis = 0; iaxis < nAxes; iaxis++) {
+      AliRsnValue *fcnAxis = (AliRsnValue*)fAxisList.At(iaxis);
+      nBins[iaxis] = fcnAxis->GetArray().GetSize() - 1;
+   }
+
+   // create ouput list of containers
+   fContainerList = new TList;
+   fContainerList->SetOwner();
+   fContainerList->SetName(Form("%s_containers", GetName()));
+
+   // initialize output list
+   OpenFile(2);
+   fOutList = new TList();
+   fOutList->SetOwner();
+
+   // create the containers
+   Int_t i = 0, nDef = (Int_t)fPairDefList.GetEntries();
+   for (i = 0; i < nDef; i++) {
+      AliRsnPairDef *def = (AliRsnPairDef*)fPairDefList[i];
+      AliCFContainer *cont = new AliCFContainer(Form("%s", def->GetPairName()), "", nSteps, nAxes, nBins);
+      // set the bin limits for each axis
+      for (iaxis = 0; iaxis < nAxes; iaxis++) {
+         AliRsnValue *fcnAxis = (AliRsnValue*)fAxisList.At(iaxis);
+         cont->SetBinLimits(iaxis, fcnAxis->GetArray().GetArray());
+      }
+      // add the container to output list
+      fContainerList->Add(cont);
+   }
+
+   fOutList->Add(fContainerList);
+   fOutList->Print();
+
+   PostData(2, fOutList);
+
+   // clear heap
+   delete [] nBins;
+
+   AliDebug(AliLog::kDebug + 2, "->");
 }
 
 //_____________________________________________________________________________
@@ -182,17 +179,16 @@ void AliRsnAnalysisEffSE::RsnUserExec(Option_t*)
 // In this case, we NEED to have ESD and MC, otherwise we cannod do anything.
 //
 
-  // process first MC steps and then ESD steps
-  AliRsnPairDef *pairDef = 0;
-  TObjArrayIter iter(&fPairDefList);
-  while ( (pairDef = (AliRsnPairDef*)iter.Next()) )
-  {
-    if (fRsnEvent.IsESD()) ProcessEventESD(pairDef);
-    if (fRsnEvent.IsAOD()) ProcessEventAOD(pairDef);
-  }
+   // process first MC steps and then ESD steps
+   AliRsnPairDef *pairDef = 0;
+   TObjArrayIter iter(&fPairDefList);
+   while ((pairDef = (AliRsnPairDef*)iter.Next())) {
+      if (fRsnEvent.IsESD()) ProcessEventESD(pairDef);
+      if (fRsnEvent.IsAOD()) ProcessEventAOD(pairDef);
+   }
 
-  // Post the data
-  PostData(2, fOutList);
+   // Post the data
+   PostData(2, fOutList);
 }
 
 //_____________________________________________________________________________
@@ -204,136 +200,126 @@ void AliRsnAnalysisEffSE::ProcessEventESD(AliRsnPairDef *pairDef)
 // It is associated with the AliCFContainer with the name of the pair.
 //
 
-  AliStack      *stack = fRsnEvent.GetRefMCESD()->Stack();
-  AliESDEvent   *esd   = fRsnEvent.GetRefESD();
-  AliMCEvent    *mc    = fRsnEvent.GetRefMCESD();
-  AliMCParticle *mother;
-
-  if (!pairDef) return;
-  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      first, j, ipart;
-  Int_t      label[2] = {-1, -1};
-  Short_t    charge[2] = {0, 0};
-  Short_t    pairDefMatch[2] = {-1, -1};
-  Int_t      esdIndex[2] = {-1, -1};
-  TParticle *part[2] = {0, 0};
-
-  // 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++) 
-  {
-    // take a track from the MC event
-    mother = (AliMCParticle*) fMCEvent->GetTrack(ipart);
-    
-    // check that it is a binary decay and the PDG code matches
-    if (mother->Particle()->GetNDaughters() != 2) continue;
-    if (mother->Particle()->GetPdgCode() != pdgM) continue;
-
-    // store the labels of the two daughters
-    label[0] = mother->Particle()->GetFirstDaughter();
-    label[1] = mother->Particle()->GetLastDaughter();
-    
-    // retrieve the particles and other stuff
-    // check if they match the order in the pairDef
-    for (j = 0; j < 2; j++)
-    {
-      if (label[j] < 0) continue;
-      part[j]   = stack->Particle(label[j]);
-      pdgD[j]   = TMath::Abs(part[j]->GetPdgCode());
-      charge[j] = (Short_t)(part[j]->GetPDG()->Charge() / 3);
-      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
-      esdIndex[j] = FindESDtrack(label[j], esd, kTRUE);
-      //TArrayI idx = FindESDtracks(label[j], esd);
-      //for (Int_t kk = 0; kk < idx.GetSize(); kk++) cout << "DAUGHTER " << j << " --> FOUND INDEX: " << idx[kk] << endl;
-      if (esdIndex[j] < 0) esdIndex[j] = FindESDtrack(label[j], esd, kFALSE);
-      //cout << "DAUGHTER " << j << " SINGLE FOUND INDEX = " << esdIndex[j] << endl;
-    }
-    
-    // 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(mc->GetTrack(label[0]));
-      fDaughter[0].SetRefMC((AliMCParticle*)mc->GetTrack(label[0]));
-      fDaughter[0].SetGood();
-      // 2nd track --> 2nd member of PairDef
-      fDaughter[1].SetRef(mc->GetTrack(label[1]));
-      fDaughter[1].SetRefMC((AliMCParticle*)mc->GetTrack(label[1]));
-      fDaughter[1].SetGood();
-    }
-    else if ((pairDefMatch[0] == 1 && pairDefMatch[1] == 0))
-    {
-      // 1st track --> 2nd member of PairDef
-      fDaughter[0].SetRef(mc->GetTrack(label[1]));
-      fDaughter[0].SetRefMC((AliMCParticle*)mc->GetTrack(label[1]));
-      fDaughter[0].SetGood();
-      // 2nd track --> 1st member of PairDef
-      fDaughter[1].SetRef(mc->GetTrack(label[0]));
-      fDaughter[1].SetRefMC((AliMCParticle*)mc->GetTrack(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);
-    
-    // then, if both particles found a good match in the ESD
-    // reassociate the ESD tracks to the pair and fill ESD containers
-    if (esdIndex[0] < 0 || esdIndex[1] < 0) continue;
-    if (pairDefMatch[0] == 0 && pairDefMatch[1] == 1)
-    {
-      // 1st track --> 1st member of PairDef
-      fDaughter[0].SetRef(esd->GetTrack(esdIndex[0]));
-      // 2nd track --> 2nd member of PairDef
-      fDaughter[1].SetRef(esd->GetTrack(esdIndex[1]));
-      //cout << "****** MATCHING SCHEME 1" << endl;
-    }
-    else if ((pairDefMatch[0] == 1 && pairDefMatch[1] == 0))
-    {
-      // 1st track --> 2nd member of PairDef
-      fDaughter[0].SetRef(esd->GetTrack(esdIndex[1]));
-      // 2nd track --> 1st member of PairDef
-      fDaughter[1].SetRef(esd->GetTrack(esdIndex[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);
-  }
+   AliStack      *stack = fRsnEvent.GetRefMCESD()->Stack();
+   AliESDEvent   *esd   = fRsnEvent.GetRefESD();
+   AliMCEvent    *mc    = fRsnEvent.GetRefMCESD();
+   AliMCParticle *mother;
+
+   if (!pairDef) return;
+   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      first, j, ipart;
+   Int_t      label[2] = { -1, -1};
+   Short_t    charge[2] = {0, 0};
+   Short_t    pairDefMatch[2] = { -1, -1};
+   Int_t      esdIndex[2] = { -1, -1};
+   TParticle *part[2] = {0, 0};
+
+   // 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++) {
+      // take a track from the MC event
+      mother = (AliMCParticle*) fMCEvent->GetTrack(ipart);
+
+      // check that it is a binary decay and the PDG code matches
+      if (mother->Particle()->GetNDaughters() != 2) continue;
+      if (mother->Particle()->GetPdgCode() != pdgM) continue;
+
+      // store the labels of the two daughters
+      label[0] = mother->Particle()->GetFirstDaughter();
+      label[1] = mother->Particle()->GetLastDaughter();
+
+      // retrieve the particles and other stuff
+      // check if they match the order in the pairDef
+      for (j = 0; j < 2; j++) {
+         if (label[j] < 0) continue;
+         part[j]   = stack->Particle(label[j]);
+         pdgD[j]   = TMath::Abs(part[j]->GetPdgCode());
+         charge[j] = (Short_t)(part[j]->GetPDG()->Charge() / 3);
+         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
+         esdIndex[j] = FindESDtrack(label[j], esd, kTRUE);
+         //TArrayI idx = FindESDtracks(label[j], esd);
+         //for (Int_t kk = 0; kk < idx.GetSize(); kk++) cout << "DAUGHTER " << j << " --> FOUND INDEX: " << idx[kk] << endl;
+         if (esdIndex[j] < 0) esdIndex[j] = FindESDtrack(label[j], esd, kFALSE);
+         //cout << "DAUGHTER " << j << " SINGLE FOUND INDEX = " << esdIndex[j] << endl;
+      }
+
+      // 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(mc->GetTrack(label[0]));
+         fDaughter[0].SetRefMC((AliMCParticle*)mc->GetTrack(label[0]));
+         fDaughter[0].SetGood();
+         // 2nd track --> 2nd member of PairDef
+         fDaughter[1].SetRef(mc->GetTrack(label[1]));
+         fDaughter[1].SetRefMC((AliMCParticle*)mc->GetTrack(label[1]));
+         fDaughter[1].SetGood();
+      } else if ((pairDefMatch[0] == 1 && pairDefMatch[1] == 0)) {
+         // 1st track --> 2nd member of PairDef
+         fDaughter[0].SetRef(mc->GetTrack(label[1]));
+         fDaughter[0].SetRefMC((AliMCParticle*)mc->GetTrack(label[1]));
+         fDaughter[0].SetGood();
+         // 2nd track --> 1st member of PairDef
+         fDaughter[1].SetRef(mc->GetTrack(label[0]));
+         fDaughter[1].SetRefMC((AliMCParticle*)mc->GetTrack(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);
+
+      // then, if both particles found a good match in the ESD
+      // reassociate the ESD tracks to the pair and fill ESD containers
+      if (esdIndex[0] < 0 || esdIndex[1] < 0) continue;
+      if (pairDefMatch[0] == 0 && pairDefMatch[1] == 1) {
+         // 1st track --> 1st member of PairDef
+         fDaughter[0].SetRef(esd->GetTrack(esdIndex[0]));
+         // 2nd track --> 2nd member of PairDef
+         fDaughter[1].SetRef(esd->GetTrack(esdIndex[1]));
+         //cout << "****** MATCHING SCHEME 1" << endl;
+      } else if ((pairDefMatch[0] == 1 && pairDefMatch[1] == 0)) {
+         // 1st track --> 2nd member of PairDef
+         fDaughter[0].SetRef(esd->GetTrack(esdIndex[1]));
+         // 2nd track --> 1st member of PairDef
+         fDaughter[1].SetRef(esd->GetTrack(esdIndex[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);
+   }
 }
 
 //_____________________________________________________________________________
@@ -345,130 +331,120 @@ void AliRsnAnalysisEffSE::ProcessEventAOD(AliRsnPairDef *pairDef)
 // It is associated with the AliCFContainer with the name of the pair.
 //
 
-  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());
-  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             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;
-
-    // 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++)
-    {
-      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);
-    }
-    
-    // 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);
-    
-    // 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);
-  }
+   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());
+   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             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;
+
+      // 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++) {
+         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);
+      }
+
+      // 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);
+
+      // 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);
+   }
 }
 
 //_____________________________________________________________________________
@@ -478,47 +454,44 @@ void AliRsnAnalysisEffSE::FillContainer(AliCFContainer *cont, const TObjArray *s
 // Fill the containers
 //
 
-  Int_t  iaxis, nAxes  = fAxisList.GetEntries();
-  Int_t  istep, nSteps = stepList->GetEntries();
-  Bool_t computeOK;
-  
-  // set daughters to pair
-  fPair.SetDaughters(&fDaughter[0], pd->GetMass(0), &fDaughter[1], pd->GetMass(1));
-
-  // compute values for all axes
-  for (iaxis = 0; iaxis < nAxes; iaxis++) 
-  {
-    AliRsnValue *fcnAxis = (AliRsnValue*)fAxisList.At(iaxis);
-    fVar[iaxis] = -1E10;
-    switch (fcnAxis->GetTargetType())
-    {
-      case AliRsnTarget::kMother:
-        fcnAxis->SetSupportObject(pd);
-        computeOK = fcnAxis->Eval(&fPair);
-        break;
-      case AliRsnTarget::kEvent:
-        computeOK = fcnAxis->Eval(&fRsnEvent);
-        break;
-      default:
-        AliError(Form("Allowed targets are mothers and events; cannot use axis '%s' which has target '%s'", fcnAxis->GetName(), fcnAxis->GetTargetTypeName()));
-        computeOK = kFALSE;
-    }
-    if (computeOK) fVar[iaxis] = ((Float_t)fcnAxis->GetComputedValue());
-  }
-
-  // fill all steps
-  for (istep = 0; istep < nSteps; istep++) 
-  {
-    AliRsnCutManager *cutMgr = (AliRsnCutManager*)stepList->At(istep);
-    AliRsnTarget::SwitchToFirst();
-    if (!cutMgr->PassCommonDaughterCuts(&fDaughter[0])) break;
-    if (!cutMgr->PassCommonDaughterCuts(&fDaughter[1])) break;
-    if (!cutMgr->PassDaughter1Cuts(&fDaughter[0])) break;
-    if (!cutMgr->PassDaughter2Cuts(&fDaughter[1])) break;
-    if (!cutMgr->PassMotherCuts(&fPair)) break;
-    //cout << "**************************************** FILLING STEP " << istep << endl;
-    cont->Fill(fVar.GetArray(), istep + firstOutStep);
-  }
+   Int_t  iaxis, nAxes  = fAxisList.GetEntries();
+   Int_t  istep, nSteps = stepList->GetEntries();
+   Bool_t computeOK;
+
+   // set daughters to pair
+   fPair.SetDaughters(&fDaughter[0], pd->GetMass(0), &fDaughter[1], pd->GetMass(1));
+
+   // compute values for all axes
+   for (iaxis = 0; iaxis < nAxes; iaxis++) {
+      AliRsnValue *fcnAxis = (AliRsnValue*)fAxisList.At(iaxis);
+      fVar[iaxis] = -1E10;
+      switch (fcnAxis->GetTargetType()) {
+         case AliRsnTarget::kMother:
+            fcnAxis->SetSupportObject(pd);
+            computeOK = fcnAxis->Eval(&fPair);
+            break;
+         case AliRsnTarget::kEvent:
+            computeOK = fcnAxis->Eval(&fRsnEvent);
+            break;
+         default:
+            AliError(Form("Allowed targets are mothers and events; cannot use axis '%s' which has target '%s'", fcnAxis->GetName(), fcnAxis->GetTargetTypeName()));
+            computeOK = kFALSE;
+      }
+      if (computeOK) fVar[iaxis] = ((Float_t)fcnAxis->GetComputedValue());
+   }
+
+   // fill all steps
+   for (istep = 0; istep < nSteps; istep++) {
+      AliRsnCutManager *cutMgr = (AliRsnCutManager*)stepList->At(istep);
+      AliRsnTarget::SwitchToFirst();
+      if (!cutMgr->PassCommonDaughterCuts(&fDaughter[0])) break;
+      if (!cutMgr->PassCommonDaughterCuts(&fDaughter[1])) break;
+      if (!cutMgr->PassDaughter1Cuts(&fDaughter[0])) break;
+      if (!cutMgr->PassDaughter2Cuts(&fDaughter[1])) break;
+      if (!cutMgr->PassMotherCuts(&fPair)) break;
+      //cout << "**************************************** FILLING STEP " << istep << endl;
+      cont->Fill(fVar.GetArray(), istep + firstOutStep);
+   }
 }
 
 //_____________________________________________________________________________
@@ -529,8 +502,8 @@ void AliRsnAnalysisEffSE::RsnTerminate(Option_t*)
 // Could be added some monitor histograms here.
 //
 
-  AliDebug(AliLog::kDebug+2,"<-");
-  AliDebug(AliLog::kDebug+2,"->");
+   AliDebug(AliLog::kDebug + 2, "<-");
+   AliDebug(AliLog::kDebug + 2, "->");
 }
 
 //_____________________________________________________________________________
@@ -539,7 +512,7 @@ void AliRsnAnalysisEffSE::AddPairDef(AliRsnPairDef* pairDef)
 //
 //  Adds pair definition
 //
-  fPairDefList.AddLast(pairDef);
+   fPairDefList.AddLast(pairDef);
 }
 
 //_____________________________________________________________________________
@@ -547,68 +520,64 @@ Int_t AliRsnAnalysisEffSE::FindESDtrack(Int_t label, AliESDEvent *esd, Bool_t re
 {
 //
 // 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 
+// 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 = esd->GetNumberOfTracks();
-  ULong_t status;
-  Bool_t  isTPC;
-  Bool_t  isITSSA;
-  
-  // loop for global tracks
-  if (fUseGlobal)
-  {
-    for (i = 0; i < ntracks; i++)
-    {
-      AliESDtrack *track = esd->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++)
-    {
-      AliESDtrack *track = esd->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;
+   Int_t   i = 0;
+   Int_t   ntracks = esd->GetNumberOfTracks();
+   ULong_t status;
+   Bool_t  isTPC;
+   Bool_t  isITSSA;
+
+   // loop for global tracks
+   if (fUseGlobal) {
+      for (i = 0; i < ntracks; i++) {
+         AliESDtrack *track = esd->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++) {
+         AliESDtrack *track = esd->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;
 }
 
 //_____________________________________________________________________________
@@ -616,58 +585,54 @@ TArrayI AliRsnAnalysisEffSE::FindESDtracks(Int_t label, AliESDEvent *esd)
 {
 //
 // 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 
+// 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 = esd->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++)
-    {
-      AliESDtrack *track = esd->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++)
-    {
-      AliESDtrack *track = esd->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;
+   Int_t   i = 0;
+   Int_t   ntracks = esd->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++) {
+         AliESDtrack *track = esd->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++) {
+         AliESDtrack *track = esd->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;
 }
 
 //_____________________________________________________________________________
@@ -675,68 +640,64 @@ Int_t AliRsnAnalysisEffSE::FindAODtrack(Int_t label, AliAODEvent *aod, Bool_t re
 {
 //
 // 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 
+// 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;
+   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;
 }
 
 //_____________________________________________________________________________
@@ -744,58 +705,54 @@ 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 
+// 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;
+   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;
 }
 
 //______________________________________________________________________________
@@ -809,25 +766,24 @@ Bool_t AliRsnAnalysisEffSE::EventProcess()
 // omonyme function in mother class
 //
 
-  // initially, an event is expected to be bad
-  fTaskInfo.SetEventUsed(kFALSE);
-
-  // check the event cuts and update the info data accordingly
-  // events not passing the cuts must be rejected
-  if (!fEventCuts.IsSelected(&fRsnEvent))
-  {
-    fTaskInfo.SetEventUsed(kFALSE);
-    return kFALSE;
-  }
-  
-  // if we reach this point, cuts were passed;
-  // then additional operations can be done
-  
-  // find leading particle (without any PID/momentum restriction)
-  fRsnEvent.SelectLeadingParticle(0);
-  
-  // final return value is positive
-  // but call the mother class method which updates info object
-  fTaskInfo.SetEventUsed(kTRUE);
-  return AliRsnVAnalysisTaskSE::EventProcess();
+   // initially, an event is expected to be bad
+   fTaskInfo.SetEventUsed(kFALSE);
+
+   // check the event cuts and update the info data accordingly
+   // events not passing the cuts must be rejected
+   if (!fEventCuts.IsSelected(&fRsnEvent)) {
+      fTaskInfo.SetEventUsed(kFALSE);
+      return kFALSE;
+   }
+
+   // if we reach this point, cuts were passed;
+   // then additional operations can be done
+
+   // find leading particle (without any PID/momentum restriction)
+   fRsnEvent.SelectLeadingParticle(0);
+
+   // final return value is positive
+   // but call the mother class method which updates info object
+   fTaskInfo.SetEventUsed(kTRUE);
+   return AliRsnVAnalysisTaskSE::EventProcess();
 }
index 5e2df07..d0d86c5 100644 (file)
@@ -31,52 +31,51 @@ class AliRsnCutManager;
 class AliRsnValue;
 
 class AliRsnAnalysisManager;
-class AliRsnAnalysisEffSE : public AliRsnVAnalysisTaskSE
-{
+class AliRsnAnalysisEffSE : public AliRsnVAnalysisTaskSE {
 
-  public:
-    AliRsnAnalysisEffSE(const char *name = "AliRsnAnalysisTaskEffSE");
-    AliRsnAnalysisEffSE(const AliRsnAnalysisEffSE& copy);
-    virtual ~AliRsnAnalysisEffSE() {;};
+public:
+   AliRsnAnalysisEffSE(const char *name = "AliRsnAnalysisTaskEffSE");
+   AliRsnAnalysisEffSE(const AliRsnAnalysisEffSE& copy);
+   virtual ~AliRsnAnalysisEffSE() {;};
 
-    // Implement this
-    virtual void    RsnUserCreateOutputObjects();
-    virtual void    RsnUserExec(Option_t*);
-    virtual void    RsnTerminate(Option_t*);
-    virtual Bool_t  EventProcess();
+   // Implement this
+   virtual void    RsnUserCreateOutputObjects();
+   virtual void    RsnUserExec(Option_t*);
+   virtual void    RsnTerminate(Option_t*);
+   virtual Bool_t  EventProcess();
 
-    // settings
-    AliRsnCutSet*   GetEventCuts() {return &fEventCuts;}
-    void            AddPairDef(AliRsnPairDef *pairDef);
-    void            AddStepMC(AliRsnCutManager *mgr);
-    void            AddStepESD(AliRsnCutManager *mgr);
-    void            AddAxis(AliRsnValue *axis);
+   // settings
+   AliRsnCutSet*   GetEventCuts() {return &fEventCuts;}
+   void            AddPairDef(AliRsnPairDef *pairDef);
+   void            AddStepMC(AliRsnCutManager *mgr);
+   void            AddStepESD(AliRsnCutManager *mgr);
+   void            AddAxis(AliRsnValue *axis);
 
-  private:
+private:
 
-    AliRsnAnalysisEffSE& operator=(const AliRsnAnalysisEffSE& /*copy*/) {return *this;}
-    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);
-    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);
+   AliRsnAnalysisEffSE& operator=(const AliRsnAnalysisEffSE& /*copy*/) {return *this;}
+   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);
+   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
-    TObjArray             fStepListMC;              // list of cut managers for all steps with MC
-    TObjArray             fStepListESD;             // list of cut managers for all steps with ESD
-    TClonesArray          fAxisList;                // list of axes of efficiency plots
-    TObjArray             fPairDefList;             // decay channels
-    TList                *fContainerList;           // list of CF containers
-    TList                *fOutList;                 // global output list
-    TArrayD               fVar;                     // list of variables of the container
-    AliRsnMother          fPair;                    // interface to pair
-    AliRsnDaughter        fDaughter[2];             // interface to tracks
-    AliRsnCutSet          fEventCuts;               // event cuts
+   Bool_t                fUseITSSA;                // switch to use ITS standalone tracks
+   Bool_t                fUseGlobal;               // switch to use global tracks
+   TObjArray             fStepListMC;              // list of cut managers for all steps with MC
+   TObjArray             fStepListESD;             // list of cut managers for all steps with ESD
+   TClonesArray          fAxisList;                // list of axes of efficiency plots
+   TObjArray             fPairDefList;             // decay channels
+   TList                *fContainerList;           // list of CF containers
+   TList                *fOutList;                 // global output list
+   TArrayD               fVar;                     // list of variables of the container
+   AliRsnMother          fPair;                    // interface to pair
+   AliRsnDaughter        fDaughter[2];             // interface to tracks
+   AliRsnCutSet          fEventCuts;               // event cuts
 
-    ClassDef(AliRsnAnalysisEffSE, 1)
+   ClassDef(AliRsnAnalysisEffSE, 1)
 };
 
 #endif
diff --git a/PWG2/RESONANCES/AliRsnAnalysisKStarKpi.cxx b/PWG2/RESONANCES/AliRsnAnalysisKStarKpi.cxx
deleted file mode 100644 (file)
index 0c2bfb4..0000000
+++ /dev/null
@@ -1,365 +0,0 @@
-//
-// Class AliRsnAnalysisKStarKpi
-//
-// 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)
-//
-
-#include <Riostream.h>
-#include <TList.h>
-
-#include "AliRsnFunction.h"
-#include "AliRsnAnalysisKStarKpi.h"
-
-ClassImp(AliRsnAnalysisKStarKpi)
-
-//_____________________________________________________________________________
-AliRsnAnalysisKStarKpi::AliRsnAnalysisKStarKpi(const char *name, Bool_t useKine) :
-  AliRsnVAnalysisTaskSE(name, useKine),
-  fGoodK(0),
-  fGoodPi(0),
-  fKaon(),
-  fPion(),
-  fMother(),
-  fPairDef(AliPID::kKaon, '+', AliPID::kPion, '-', 313, 0.896),
-  fCutEvent(Form("%s_cutEvent", name), AliRsnTarget::kEvent),
-  fCutTrackCommon(Form("%s_cutTrackCom", name), AliRsnTarget::kDaughter),
-  fCutTrackKaon(Form("%s_cutTrackKaon", name), AliRsnTarget::kDaughter),
-  fCutTrackPion(Form("%s_cutTrackPion", name), AliRsnTarget::kDaughter),
-  fCutPair(Form("%s_cutPair", name), AliRsnTarget::kMother),
-  fFuncPM("AliRsnFunction", 0),
-  fFuncMP("AliRsnFunction", 0),
-  fFuncPP("AliRsnFunction", 0),
-  fFuncMM("AliRsnFunction", 0),
-  fFuncTruePM("AliRsnFunction", 0),
-  fFuncTrueMP("AliRsnFunction", 0),
-  fOutList(0x0)
-{
-//
-// Default constructor.
-// Defines another output slot for histograms/ntuples
-//
-
-  DefineOutput(2, TList::Class());
-}
-
-//_____________________________________________________________________________
-AliRsnAnalysisKStarKpi::AliRsnAnalysisKStarKpi(const AliRsnAnalysisKStarKpi& copy) :
-  AliRsnVAnalysisTaskSE(copy),
-  fGoodK(0),
-  fGoodPi(0),
-  fKaon(),
-  fPion(),
-  fMother(),
-  fPairDef(AliPID::kKaon, '+', AliPID::kKaon, '-', 333, 1.019455),
-  fCutEvent(copy.fCutEvent),
-  fCutTrackCommon(copy.fCutTrackCommon),
-  fCutTrackKaon(copy.fCutTrackKaon),
-  fCutTrackPion(copy.fCutTrackPion),
-  fCutPair(copy.fCutPair),
-  fFuncPM(copy.fFuncPM),
-  fFuncMP(copy.fFuncMP),
-  fFuncPP(copy.fFuncPP),
-  fFuncMM(copy.fFuncMM),
-  fFuncTruePM(copy.fFuncTruePM),
-  fFuncTrueMP(copy.fFuncTrueMP),
-  fOutList(0x0)
-{
-//
-// Copy constructor.
-//
-}
-
-//_____________________________________________________________________________
-AliRsnAnalysisKStarKpi& AliRsnAnalysisKStarKpi::operator=(const AliRsnAnalysisKStarKpi& copy)
-{
-//
-// Assigment operator.
-//
-
-  AliRsnVAnalysisTaskSE::operator=(copy);
-  
-  fFuncPM     = copy.fFuncPM;
-  fFuncMP     = copy.fFuncMP;
-  fFuncPP     = copy.fFuncPP;
-  fFuncMM     = copy.fFuncMM;
-  fFuncTruePM = copy.fFuncTruePM;
-  fFuncTrueMP = copy.fFuncTrueMP;
-  
-  fCutEvent       = copy.fCutEvent;
-  fCutTrackCommon = copy.fCutTrackCommon;
-  fCutTrackPion   = copy.fCutTrackPion;
-  fCutTrackKaon   = copy.fCutTrackKaon;
-  fCutPair        = copy.fCutPair;
-  
-  if (fOutList) fOutList->Clear();
-  
-  return (*this);
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisKStarKpi::AddFunction(AliRsnFunction* const fcn)
-{
-//
-// Adds a new computing function to each collection,
-// in order to have exactly the sames for each kind of pair.
-//
-  
-  Int_t size = fFuncPM.GetEntries();
-  
-  new (fFuncPM    [size]) AliRsnFunction(*fcn);
-  new (fFuncMP    [size]) AliRsnFunction(*fcn);
-  new (fFuncPP    [size]) AliRsnFunction(*fcn);
-  new (fFuncMM    [size]) AliRsnFunction(*fcn);
-  new (fFuncTruePM[size]) AliRsnFunction(*fcn);
-  new (fFuncTrueMP[size]) AliRsnFunction(*fcn);
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisKStarKpi::RsnUserCreateOutputObjects()
-{
-//
-// Creation of output objects.
-// These are created through the utility methods in the analysis manager,
-// which asks all the AliRsnPair objects to initialize their output which
-// is then linked to the TList data member of this, which will contain all the output.
-//
-
-  if (!fOutList) fOutList = new TList;
-  fOutList->Clear();
-  
-  Int_t   i, j, nFunc = fFuncPM.GetEntries();
-  TString hName(""), suf[6] = {"PM", "MP", "PP", "MM", "TruePM", "TrueMP"};
-  AliRsnFunction *fcn[6] = {0, 0, 0, 0};
-  
-  for (i = 0; i < nFunc; i++)
-  {
-    fcn[0] = (AliRsnFunction*)fFuncPM.At(i);
-    fcn[1] = (AliRsnFunction*)fFuncMP.At(i);
-    fcn[2] = (AliRsnFunction*)fFuncPP.At(i);
-    fcn[3] = (AliRsnFunction*)fFuncMM.At(i);
-    fcn[4] = (AliRsnFunction*)fFuncTruePM.At(i);
-    fcn[5] = (AliRsnFunction*)fFuncTrueMP.At(i);
-    for (j = 0; j < 6; j++)
-    {
-      fcn[j]->SetPairDef(&fPairDef);
-      fcn[j]->SetPair(&fMother);
-      
-      hName  = GetName();
-      hName += '_';
-      hName += suf[j];
-      hName += '_';
-      hName += fcn[j]->GetName();
-      if (fcn[j]->IsUsingTH1()) fOutList->Add(fcn[j]->CreateHistogram(hName.Data(), ""));
-      else fOutList->Add(fcn[j]->CreateHistogramSparse(hName.Data(), ""));
-    }
-  }
-
-  PostData(2, fOutList);
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisKStarKpi::RsnUserExec(Option_t*)
-{
-//
-// Execution of the analysis task.
-// Recovers the input event and processes it with all included pair objects,
-// using 'reconstructed' or 'MonteCarlo' functions depending on MC-only flag.
-//
-
-  // skip if the global event pointers are NULL
-  // and point to first event in the target 
-  AliRsnEvent *event = AliRsnEvent::GetCurrentEvent1();
-  if (!event) return;
-  AliRsnTarget::SwitchToFirst();
-  
-  // select good tracks, applying all cuts
-  // in this point we use only the 'fPion' data member
-  // but it holds for both kinds of particles
-  Int_t i, index, tot = event->GetAbsoluteSum(), ngoodK = 0, ngoodPi = 0;
-  Bool_t assignOK;
-  AliRsnDaughter::ERefType type;
-  fGoodK.Set(tot);
-  fGoodPi.Set(tot);
-  for (i = 0; i < tot; i++)
-  {
-    // assign track and skip all that are not charged tracks
-    assignOK = event->ConvertAbsoluteIndex(i, index, type);
-    if (!assignOK || type != AliRsnDaughter::kTrack) continue;
-    event->SetDaughter(fPion, index, AliRsnDaughter::kTrack);
-    
-    // skip tracks which don't pass common cuts
-    if (!fCutTrackCommon.IsSelected(&fPion)) continue;
-    
-    // accept tracks which pass also charge-related cuts
-    if (fCutTrackPion.IsSelected(&fPion))
-    {
-      fGoodPi[ngoodPi] = index;
-      ++ngoodPi;
-    }
-    else if (fCutTrackKaon.IsSelected(&fPion))
-    {
-      fGoodK[ngoodK] = index;
-      ++ngoodK;
-    }
-  }
-  fGoodK.Set(ngoodK);
-  fGoodPi.Set(ngoodPi);
-  
-  // now that the 'tot' value is useless, set it to
-  // the total number of functions, which by construction is THE SAME
-  // for all collections
-  tot = fFuncPM.GetEntries();
-  
-  // loop on selected tracks and fill histograms
-  // external loop is on kaons (first element in pairDef)
-  // internal loop is on pions (second element in pairDef)
-  Int_t i0, i1, m0, m1, motherPDG;
-  const Double_t  kaonMass = 0.493677;
-  const Double_t  pionMass = 0.13957;
-  const Int_t     kstarPDG = 313;
-  const Int_t     kaonPDG  = 313;
-  const Int_t     pionPDG  = 211;
-  AliRsnFunction *fcn;
-  for (i0 = 0; i0 < ngoodK; i0++)
-  {
-    index = fGoodK[i0];
-    event->SetDaughter(fKaon, index, AliRsnDaughter::kTrack);
-    
-    for (i1 = 0; i1 < ngoodPi; i1++)
-    {      
-      index = fGoodPi[i1];
-      event->SetDaughter(fPion, index, AliRsnDaughter::kTrack);
-      
-      // skip in case the two indexes match
-      if (fPion.GetID() == fKaon.GetID()) continue;
-      
-      // adjust charges of pair def
-      fPairDef.SetDaughters(AliPID::kKaon, fKaon.ChargeChar(), AliPID::kPion, fPion.ChargeChar());
-    
-      // fill the pair using the kaon masses and the passed daughters
-      fMother.SetDaughters(&fKaon, kaonMass, &fPion, pionMass);
-      
-      // check pair cuts
-      if (!fCutPair.IsSelected(&fMother)) continue;
-      
-      // if pair is like-sign, fill appropriate histos
-      if (fPairDef.IsLikeSign())
-      {
-        if (fKaon.Charge() > 0)
-        {
-          for (i = 0; i < tot; i++)
-          {
-            fcn = (AliRsnFunction*)fFuncPP[i];
-            fcn->Fill();
-          }
-        }
-        else
-        {
-          for (i = 0; i < tot; i++)
-          {
-            fcn = (AliRsnFunction*)fFuncMM[i];
-            fcn->Fill();
-          }
-        }
-      }
-      else
-      {
-        // if pair is unlike-sign, check that it is true
-        motherPDG = fMother.CommonMother(m0, m1);
-        if (motherPDG == kstarPDG)
-        {
-          if (m0 < 0 || m1 < 0) motherPDG = 0;
-          if (TMath::Abs(fKaon.GetPDG()) != kaonPDG) motherPDG = 0;
-          if (TMath::Abs(fPion.GetPDG()) != pionPDG) motherPDG = 0;
-        }
-        
-        // fill unlike-sign histo (the appropriate one)
-        if (fKaon.Charge() > 0)
-        {
-          for (i = 0; i < tot; i++)
-          {
-            fcn = (AliRsnFunction*)fFuncPM[i];
-            fcn->Fill();
-            if (motherPDG == kstarPDG)
-            {
-              fcn = (AliRsnFunction*)fFuncTruePM[i];
-              fcn->Fill();
-            }
-          }
-        }
-        else
-        {
-          for (i = 0; i < tot; i++)
-          {
-            fcn = (AliRsnFunction*)fFuncMP[i];
-            fcn->Fill();
-            if (motherPDG == kstarPDG)
-            {
-              fcn = (AliRsnFunction*)fFuncTrueMP[i];
-              fcn->Fill();
-            }
-          }
-        }
-      }
-    } // for (i1)
-  } // for (i0)
-  
-  PostData(2, fOutList);
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisKStarKpi::RsnTerminate(Option_t*)
-{
-//
-// Termination.
-// Could be added some monitor histograms here.
-//
-}
-
-//______________________________________________________________________________
-Bool_t AliRsnAnalysisKStarKpi::EventProcess()
-{
-//
-// Customized event pre-processing.
-// First checks if the current event passes all cuts,
-// and if it does, updates the informations and then
-// call the operations which are already defined in the
-// omonyme function in mother class
-//
-
-  // initially, an event is expected to be bad
-  fTaskInfo.SetEventUsed(kFALSE);
-  
-  // check #1: number of tracks in event (reject empty events)
-  Int_t ntracks = fRsnEvent.GetMultiplicity();
-  if (ntracks < 1) 
-  {
-    // empty events are rejected by default
-    fTaskInfo.SetEventUsed(kFALSE);
-    AliDebug(AliLog::kDebug, "Empty event. Skipping...");
-    return kFALSE;
-  }
-
-  // check the event cuts and update the info data accordingly
-  // events not passing the cuts must be rejected
-  if (!fCutEvent.IsSelected(&fRsnEvent))
-  {
-    fTaskInfo.SetEventUsed(kFALSE);
-    return kFALSE;
-  }
-  
-  // if we reach this point, cuts were passed;
-  // then additional operations can be done
-  
-  // find leading particle (without any PID/momentum restriction)
-  fRsnEvent.SelectLeadingParticle(0);
-  
-  // final return value is positive
-  // but call the mother class method which updates info object
-  fTaskInfo.SetEventUsed(kTRUE);
-  return AliRsnVAnalysisTaskSE::EventProcess();
-}
diff --git a/PWG2/RESONANCES/AliRsnAnalysisKStarKpi.h b/PWG2/RESONANCES/AliRsnAnalysisKStarKpi.h
deleted file mode 100644 (file)
index 40c1aa1..0000000
+++ /dev/null
@@ -1,75 +0,0 @@
-//
-// Class AliRsnAnalysisKStarKpi
-//
-// 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 AliRsnAnalysisKStarKpi_H
-#define AliRsnAnalysisKStarKpi_H
-
-#include "TClonesArray.h"
-
-#include "AliRsnVAnalysisTaskSE.h"
-
-#include "AliRsnDaughter.h"
-#include "AliRsnMother.h"
-#include "AliRsnPairDef.h"
-#include "AliRsnEvent.h"
-#include "AliRsnCutSet.h"
-
-class AliRsnPIDDefESD;
-
-class AliRsnAnalysisKStarKpi : public AliRsnVAnalysisTaskSE
-{
-  public:
-  
-    AliRsnAnalysisKStarKpi(const char *name = "RSNphi", Bool_t useKine = kFALSE);
-    AliRsnAnalysisKStarKpi(const AliRsnAnalysisKStarKpi& copy);
-    AliRsnAnalysisKStarKpi& operator=(const AliRsnAnalysisKStarKpi& copy);
-    virtual ~AliRsnAnalysisKStarKpi() {}
-
-    virtual void            RsnUserCreateOutputObjects();
-    virtual void            RsnUserExec(Option_t*);
-    virtual void            RsnTerminate(Option_t*);
-    virtual Bool_t          EventProcess();
-    
-    AliRsnCutSet*           GetEventCuts()          {return &fCutEvent;}
-    AliRsnCutSet*           GetCommonDaughterCuts() {return &fCutTrackCommon;}
-    AliRsnCutSet*           GetKaonDaughterCuts()   {return &fCutTrackKaon;}
-    AliRsnCutSet*           GetPionDaughterCuts()   {return &fCutTrackPion;}
-    AliRsnCutSet*           GetMotherCuts()         {return &fCutPair;}
-    
-    void                    AddFunction(AliRsnFunction* const fcn);
-    TList*                  GenerateHistograms();
-
-  private:
-  
-    TArrayI                 fGoodK;             // indexes of good tracks (kaons)
-    TArrayI                 fGoodPi;            // indexes of good tracks (pions)
-    AliRsnDaughter          fKaon;              // daughter data-member (pion)
-    AliRsnDaughter          fPion;              // daughter data-member (pion)
-    AliRsnMother            fMother;            // mother data-member (to save memory)
-    AliRsnPairDef           fPairDef;           // resonance decay tree (fixed)
-    
-    AliRsnCutSet            fCutEvent;          // cut set for events
-    AliRsnCutSet            fCutTrackCommon;    // cut set for tracks (common)
-    AliRsnCutSet            fCutTrackKaon;      // cut set for tracks (only pos)
-    AliRsnCutSet            fCutTrackPion;      // cut set for tracks (only neg)
-    AliRsnCutSet            fCutPair;           // cut set for pairs
-
-    TClonesArray            fFuncPM;            // collection of functions for unlike-sign (K+ pi-)
-    TClonesArray            fFuncMP;            // collection of functions for unlike-sign (K- pi+)
-    TClonesArray            fFuncPP;            // collection of functions for like-sign ++
-    TClonesArray            fFuncMM;            // collection of functions for like-sign --
-    TClonesArray            fFuncTruePM;        // collection of functions for unlike-sign true pairs (K+ pi-)
-    TClonesArray            fFuncTrueMP;        // collection of functions for unlike-sign true pairs (K- pi+)
-    
-    TList                  *fOutList;           // list of output events
-
-    ClassDef(AliRsnAnalysisKStarKpi, 1)
-};
-
-#endif
diff --git a/PWG2/RESONANCES/AliRsnAnalysisME.cxx b/PWG2/RESONANCES/AliRsnAnalysisME.cxx
deleted file mode 100644 (file)
index 951b10a..0000000
+++ /dev/null
@@ -1,220 +0,0 @@
-//
-// Class AliRsnAnalysisME
-//
-//
-// Virtual Class derivated from AliRsnVAnalysisTaskME which will be base class
-// for all RSN SE tasks
-//
-// authors: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
-//          Martin Vala (martin.vala@cern.ch)
-//
-
-#include "AliESDEvent.h"
-#include "AliMCEvent.h"
-#include "AliAODEvent.h"
-#include "AliMultiEventInputHandler.h"
-#include "AliRsnAnalysisME.h"
-
-ClassImp(AliRsnAnalysisME)
-
-//_____________________________________________________________________________
-AliRsnAnalysisME::AliRsnAnalysisME(const char *name) :
-    AliRsnVAnalysisTaskME(name),
-    fRsnAnalysisManager(),
-    fEvent(),
-    fEventMix(),
-    fOutList(0x0)
-{
-//
-// Default constructor
-//
-  AliDebug(AliLog::kDebug+2, "<-");
-
-  DefineOutput(2, TList::Class());
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-AliRsnAnalysisME::AliRsnAnalysisME(const AliRsnAnalysisME& copy) : AliRsnVAnalysisTaskME(copy),
-    fRsnAnalysisManager(copy.fRsnAnalysisManager),
-    fEvent(copy.fEvent),
-    fEventMix(copy.fEvent),
-    fOutList(0x0)
-{
-  AliDebug(AliLog::kDebug+2, "<-");
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisME::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, "<-");
-
-  fOutList = new TList();
-  fOutList->SetOwner();
-
-  fRsnAnalysisManager.InitAllPairs(fOutList);
-
-  PostData(2, fOutList);
-
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-void AliRsnAnalysisME::RsnUserExec(Option_t*)
-{
-//
-// Rsn User Exec
-//
-
-  fTaskInfo.SetEventUsed(kFALSE);
-
-  AliDebug(AliLog::kDebug+2, "<-");
-  if (!CheckAndPrintEvents()) return;
-
-  DoMixing(GetEvent(0));
-
-
-  // if cuts are passed or not cuts were defined,
-  // update the task info...
-  fTaskInfo.SetEventUsed(kTRUE);
-
-  PostData(2, fOutList);
-
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-
-//_____________________________________________________________________________
-void AliRsnAnalysisME::DoMixing(AliVEvent* ev)
-{
-//
-// Do Mixing
-//
-
-  Int_t nEvents = fInputHandler->GetBufferSize();
-  fESDEvent = dynamic_cast<AliESDEvent*>(ev);
-  fAODEvent = dynamic_cast<AliAODEvent*>(ev);
-
-  if (fESDEvent) {
-    AliESDEvent **esdEvent = new AliESDEvent*[nEvents];
-    for (Int_t i = 0; i < nEvents; i++) {
-      esdEvent[i] = dynamic_cast<AliESDEvent*>(GetEvent(i));
-      if (!esdEvent[i]) {
-        AliWarning(Form("Null ESD event in index %d", i));
-        continue;
-      }
-      if (i > 0)
-        DoESDMixing(esdEvent[0], esdEvent[i]);
-    }
-  } else if (fAODEvent) {
-    AliAODEvent **aodEvent = new AliAODEvent*[nEvents];
-    for (Int_t i = 0; i < nEvents; i++) {
-      aodEvent[i] = dynamic_cast<AliAODEvent*>(GetEvent(i));
-      if (!aodEvent[i]) {
-        AliWarning(Form("Null AOD event in index %d", i));
-        continue;
-      }
-      if (i > 0)
-        DoAODMixing(aodEvent[0], aodEvent[i]);
-    }
-  }
-
-}
-
-
-//_____________________________________________________________________________
-void AliRsnAnalysisME::DoAODMixing(AliAODEvent* aod1, AliAODEvent* aod2)
-{
-//
-// mixing of two aod events
-//
-
-  // assign events
-  fEvent.SetRef(aod1);
-  fEventMix.SetRef(aod2);
-  if (fEvent.GetMultiplicity() < 2) return;
-  if (fEventMix.GetMultiplicity() < 2) return;
-  
-  AliRsnEvent::SetCurrentEvent1(&fEvent);
-  AliRsnEvent::SetCurrentEvent2(&fEventMix);
-
-  fRsnAnalysisManager.ProcessAllPairs();
-  PostData(2, fOutList);
-
-  AliDebug(AliLog::kDebug, Form("AOD tracks %d", aod1->GetNumberOfTracks()));
-  AliDebug(AliLog::kDebug, Form("AOD tracks %d", aod2->GetNumberOfTracks()));
-
-}
-
-
-//_____________________________________________________________________________
-void AliRsnAnalysisME::DoESDMixing(AliESDEvent* esd1, AliESDEvent* esd2)
-{
-//
-// mixing of two esd events
-//
-
-  AliWarning(Form("ESD mixing not supported yet !!! (%p,%p)", esd1, esd2));
-  return;
-}
-
-
-
-//_____________________________________________________________________________
-void AliRsnAnalysisME::RsnTerminate(Option_t*)
-{
-//
-// Rsn Terminate
-//
-
-  AliDebug(AliLog::kDebug+2, "<-");
-  AliDebug(AliLog::kDebug+2,"->");
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisME::SetPriorProbability(AliPID::EParticleType type, Double_t p)
-{
-//
-// Sets the prior probability for Realistic PID, for a
-// given particle species.
-//
-
-  if (type >= 0 && type < (Int_t)AliPID::kSPECIES) {
-    fPrior[type] = p;
-  }
-
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisME::DumpPriors()
-{
-  //
-  // Print all prior probabilities
-  //
-
-  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 AliRsnAnalysisME::GetPriorProbability(Double_t *out) const
-{
-//
-// Gets all prior probabilities to out
-//
-
-  Int_t i;
-  for (i = 0;i < AliPID::kSPECIES;i++) {
-    out[i] = fPrior[i];
-  }
-}
-
-
diff --git a/PWG2/RESONANCES/AliRsnAnalysisME.h b/PWG2/RESONANCES/AliRsnAnalysisME.h
deleted file mode 100644 (file)
index 70072b7..0000000
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// Class AliRsnAnalysisME
-//
-// Virtual Class derivated from AliRsnVAnalysisTaskME 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 ALIRSNANALYSISME_H
-#define ALIRSNANALYSISME_H
-
-#include "AliPID.h"
-#include "AliRsnVAnalysisTaskME.h"
-#include "AliRsnAnalysisManager.h"
-#include "AliRsnEvent.h"
-
-class AliPID;
-class AliESDtrackCuts;
-class AliRsnAnalysisME : public AliRsnVAnalysisTaskME
-{
-
-  public:
-    AliRsnAnalysisME(const char *name = "AliRsnAnalysisME");
-    AliRsnAnalysisME(const AliRsnAnalysisME& copy);
-    virtual ~AliRsnAnalysisME() { ; };
-
-    // Implement this
-    virtual void    RsnUserCreateOutputObjects();
-    virtual void    RsnUserExec(Option_t*);
-    virtual void    RsnTerminate(Option_t*);
-
-    AliRsnAnalysisManager *GetAnalysisManager() {return &fRsnAnalysisManager;}
-    void SetAnalysisManagerName(const char *name) {fRsnAnalysisManager.SetName(name); };
-
-    // Prior probs
-    void            SetPriorProbability(AliPID::EParticleType type, Double_t p);
-    void            DumpPriors();
-    void            GetPriorProbability(Double_t *out)const;
-
-  private:
-
-    AliRsnAnalysisME& operator=(const AliRsnAnalysisME& /*copy*/) { return *this; }
-
-    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
-
-    void                  DoMixing(AliVEvent *ev);
-    void                  DoAODMixing(AliAODEvent* aod1, AliAODEvent* aod2);
-    void                  DoESDMixing(AliESDEvent* esd1, AliESDEvent* esd2);
-
-    ClassDef(AliRsnAnalysisME, 1)
-};
-
-#endif
index 8f923e6..b709022 100644 (file)
@@ -33,10 +33,10 @@ ClassImp(AliRsnAnalysisManager)
 
 //_____________________________________________________________________________
 AliRsnAnalysisManager::AliRsnAnalysisManager(const char*name) :
-  TNamed(name, ""),
-  fList(0x0),
-  fPairs(0),
-  fGlobalTrackCuts()
+   TNamed(name, ""),
+   fList(0x0),
+   fPairs(0),
+   fGlobalTrackCuts()
 {
 //
 // Default constructor
@@ -44,11 +44,11 @@ AliRsnAnalysisManager::AliRsnAnalysisManager(const char*name) :
 }
 
 //_____________________________________________________________________________
-AliRsnAnalysisManager::AliRsnAnalysisManager(const AliRsnAnalysisManager& copy) : 
-  TNamed(copy),
-  fList(copy.fList),
-  fPairs(copy.fPairs),
-  fGlobalTrackCuts(copy.fGlobalTrackCuts)
+AliRsnAnalysisManager::AliRsnAnalysisManager(const AliRsnAnalysisManager& copy) :
+   TNamed(copy),
+   fList(copy.fList),
+   fPairs(copy.fPairs),
+   fGlobalTrackCuts(copy.fGlobalTrackCuts)
 {
 //
 // Copy constructor
@@ -61,14 +61,14 @@ AliRsnAnalysisManager& AliRsnAnalysisManager::operator=(const AliRsnAnalysisMana
 //
 // Assignment operator
 //
-  
-  TNamed::operator=(copy);
-  
-  fList = copy.fList;
-  fPairs = copy.fPairs;
-  fGlobalTrackCuts = copy.fGlobalTrackCuts;
-  
-  return (*this);
+
+   TNamed::operator=(copy);
+
+   fList = copy.fList;
+   fPairs = copy.fPairs;
+   fGlobalTrackCuts = copy.fGlobalTrackCuts;
+
+   return (*this);
 }
 
 //_____________________________________________________________________________
@@ -78,18 +78,17 @@ void AliRsnAnalysisManager::Add(AliRsnPair *pair)
 // Adds a new pair manager to the list.
 //
 
-  AliDebug(AliLog::kDebug+2,"<-");
+   AliDebug(AliLog::kDebug + 2, "<-");
 
-  if (!pair) 
-  {
-    AliWarning(Form("AliRsnPairManager is %p. Skipping ...", pair));
-    return;
-  }
+   if (!pair) {
+      AliWarning(Form("AliRsnPairManager is %p. Skipping ...", pair));
+      return;
+   }
 
-  AliDebug(AliLog::kDebug+1, Form("Adding %s [%d]...", pair->GetName(), fPairs.GetEntries()));
-  fPairs.Add(pair);
+   AliDebug(AliLog::kDebug + 1, Form("Adding %s [%d]...", pair->GetName(), fPairs.GetEntries()));
+   fPairs.Add(pair);
 
-  AliDebug(AliLog::kDebug+2,"->");
+   AliDebug(AliLog::kDebug + 2, "->");
 }
 
 //_____________________________________________________________________________
@@ -99,8 +98,8 @@ void AliRsnAnalysisManager::Print(Option_t* /*dummy*/) const
 // Overload of the TObject::Print() method
 //
 
-  AliInfo(Form("\t======== Analysis Manager %s ========", GetName()));
-  PrintArray();
+   AliInfo(Form("\t======== Analysis Manager %s ========", GetName()));
+   PrintArray();
 }
 
 //_____________________________________________________________________________
@@ -110,13 +109,13 @@ void AliRsnAnalysisManager::PrintArray() const
 // Calls the "Print" method of all included pair managers
 //
 
-  AliDebug(AliLog::kDebug+2,"<-");
+   AliDebug(AliLog::kDebug + 2, "<-");
 
-  AliRsnPair *pair = 0;
-  TObjArrayIter next(&fPairs);
-  while ((pair = (AliRsnPair*)next())) pair->Print();
+   AliRsnPair *pair = 0;
+   TObjArrayIter next(&fPairs);
+   while ((pair = (AliRsnPair*)next())) pair->Print();
 
-  AliDebug(AliLog::kDebug+2,"->");
+   AliDebug(AliLog::kDebug + 2, "->");
 }
 
 //_____________________________________________________________________________
@@ -127,25 +126,24 @@ void AliRsnAnalysisManager::InitAllPairs(TList *list)
 // generated by each one into a unique final output TList
 //
 
-  AliDebug(AliLog::kDebug+2,"<-");
+   AliDebug(AliLog::kDebug + 2, "<-");
 
-  AliRsnPair   *pair = 0;
-  TObjArrayIter next(&fPairs);
-  Int_t i = 0;
-  while ((pair = (AliRsnPair*)next())) 
-  {
-    AliDebug(AliLog::kDebug+1, Form("InitAllPairs of the PairManager(%s) [%d] ...", pair->GetName(), i++));
+   AliRsnPair   *pair = 0;
+   TObjArrayIter next(&fPairs);
+   Int_t i = 0;
+   while ((pair = (AliRsnPair*)next())) {
+      AliDebug(AliLog::kDebug + 1, Form("InitAllPairs of the PairManager(%s) [%d] ...", pair->GetName(), i++));
 //     pair->Init("", list);
-    pair->Init(GetName(), list);
-    
-    // add a counter for used/unused events for each pair
-    TH1I *hPairUsed = new TH1I(Form("%s_%s_USED", GetName(),pair->GetName()), "Used events for pair", 2, 0, 2);
-    list->Add(hPairUsed);
-  }
-  
-  fList = list;
-  
-  AliDebug(AliLog::kDebug+2, "->");
+      pair->Init(GetName(), list);
+
+      // add a counter for used/unused events for each pair
+      TH1I *hPairUsed = new TH1I(Form("%s_%s_USED", GetName(), pair->GetName()), "Used events for pair", 2, 0, 2);
+      list->Add(hPairUsed);
+   }
+
+   fList = list;
+
+   AliDebug(AliLog::kDebug + 2, "->");
 }
 
 //_____________________________________________________________________________
@@ -155,101 +153,93 @@ void AliRsnAnalysisManager::ProcessAllPairs()
 // Process one or two events for all pair managers.
 //
 
-  static Int_t evnum = 0;
-  evnum++;
-
-  AliDebug(AliLog::kDebug+2,"<-");
-  
-  // skip if the global event pointers are NULL
-  if (!AliRsnEvent::IsCurrentEvent1()) return;
-  if (!AliRsnEvent::IsCurrentEvent2()) return;
-  
-  // for better readability, reference two pointers to the current events
-  AliRsnEvent *ev0 = AliRsnEvent::GetCurrentEvent1();
-  AliRsnEvent *ev1 = AliRsnEvent::GetCurrentEvent2();
-  
-  // count total number of candidates per event
-  // (sum of tracks, V0s and cascades)
-  Int_t nTot[2];
-  nTot[0] = AliRsnEvent::GetCurrentEvent1()->GetAbsoluteSum();
-  nTot[1] = AliRsnEvent::GetCurrentEvent2()->GetAbsoluteSum();
-  
-  // variables
-  Int_t          i0, i1, i, start, index0, index1;
-  AliRsnDaughter daughter0, daughter1;
-  AliRsnPair    *pair = 0x0;
-  TObjArrayIter  next(&fPairs);
-  AliRsnDaughter::ERefType type0, type1;
-  
-  // reset all counters which tell us
-  // how many entries were added now
-  while ((pair = (AliRsnPair*)next())) 
-  {
-    pair->ResetCount();
-  }
-  
-  // external loop
-  for (i0 = 0; i0 < nTot[0]; i0++)
-  {
-    // assign first track
-    if (!ev0->ConvertAbsoluteIndex(i0, index0, type0)) continue;
-    ev0->SetDaughter(daughter0, index0, type0);
-    
-    // check global cuts
-    if (!fGlobalTrackCuts.IsSelected(&daughter0)) continue;
-    
-    // define start depending if we are processing one or two events
-    start = (AliRsnEvent::SameEvent() ? i0 + 1 : 0);
-        
-    // internal loop (same criterion)
-    for (i1 = start; i1 < nTot[1]; i1++)
-    {
-      // if looking same event, skip the case when the two indexes are equal
-      // if (AliRsnEvent::SameEvent() && i0 == i1) continue;
-      
-      // assign second track
-      if (!ev1->ConvertAbsoluteIndex(i1, index1, type1)) continue;
-      ev1->SetDaughter(daughter1, index1, type1);
-      
+   static Int_t evnum = 0;
+   evnum++;
+
+   AliDebug(AliLog::kDebug + 2, "<-");
+
+   // skip if the global event pointers are NULL
+   if (!AliRsnEvent::IsCurrentEvent1()) return;
+   if (!AliRsnEvent::IsCurrentEvent2()) return;
+
+   // for better readability, reference two pointers to the current events
+   AliRsnEvent *ev0 = AliRsnEvent::GetCurrentEvent1();
+   AliRsnEvent *ev1 = AliRsnEvent::GetCurrentEvent2();
+
+   // count total number of candidates per event
+   // (sum of tracks, V0s and cascades)
+   Int_t nTot[2];
+   nTot[0] = AliRsnEvent::GetCurrentEvent1()->GetAbsoluteSum();
+   nTot[1] = AliRsnEvent::GetCurrentEvent2()->GetAbsoluteSum();
+
+   // variables
+   Int_t          i0, i1, i, start, index0, index1;
+   AliRsnDaughter daughter0, daughter1;
+   AliRsnPair    *pair = 0x0;
+   TObjArrayIter  next(&fPairs);
+   AliRsnDaughter::ERefType type0, type1;
+
+   // reset all counters which tell us
+   // how many entries were added now
+   while ((pair = (AliRsnPair*)next())) {
+      pair->ResetCount();
+   }
+
+   // external loop
+   for (i0 = 0; i0 < nTot[0]; i0++) {
+      // assign first track
+      if (!ev0->ConvertAbsoluteIndex(i0, index0, type0)) continue;
+      ev0->SetDaughter(daughter0, index0, type0);
+
       // check global cuts
-      if (!fGlobalTrackCuts.IsSelected(&daughter1)) continue;
-      
-      // 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 (AliRsnEvent::SameEvent() && pair->GetPairDef()->IsLikeSign() && i1 < i0) continue;
-                
-        // process the two tracks
-        if (pair->Fill(&daughter0, &daughter1))
-        {
-          pair->Compute();
-        }
-        else if (pair->Fill(&daughter1, &daughter0))
-        {
-          pair->Compute();
-        }
+      if (!fGlobalTrackCuts.IsSelected(&daughter0)) continue;
+
+      // define start depending if we are processing one or two events
+      start = (AliRsnEvent::SameEvent() ? i0 + 1 : 0);
+
+      // internal loop (same criterion)
+      for (i1 = start; i1 < nTot[1]; i1++) {
+         // if looking same event, skip the case when the two indexes are equal
+         // if (AliRsnEvent::SameEvent() && i0 == i1) continue;
+
+         // assign second track
+         if (!ev1->ConvertAbsoluteIndex(i1, index1, type1)) continue;
+         ev1->SetDaughter(daughter1, index1, type1);
+
+         // check global cuts
+         if (!fGlobalTrackCuts.IsSelected(&daughter1)) continue;
+
+         // 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 (AliRsnEvent::SameEvent() && pair->GetPairDef()->IsLikeSign() && i1 < i0) continue;
+
+            // process the two tracks
+            if (pair->Fill(&daughter0, &daughter1)) {
+               pair->Compute();
+            } else if (pair->Fill(&daughter1, &daughter0)) {
+               pair->Compute();
+            }
+         }
       }
-    }
-  }
-  
-  // update all count histograms counters
-  next.Reset();
-  if (!fList) return;
-  while ((pair = (AliRsnPair*)next())) 
-  {
-    TH1I *hist = (TH1I*)fList->FindObject(Form("_%s_USED", pair->GetName()));
-    if (!hist) continue;
-    if (pair->GetCount() > 0) hist->Fill(1); else hist->Fill(0);
-  }
-
-  AliDebug(AliLog::kDebug+2,"->");
+   }
+
+   // update all count histograms counters
+   next.Reset();
+   if (!fList) return;
+   while ((pair = (AliRsnPair*)next())) {
+      TH1I *hist = (TH1I*)fList->FindObject(Form("_%s_USED", pair->GetName()));
+      if (!hist) continue;
+      if (pair->GetCount() > 0) hist->Fill(1); else hist->Fill(0);
+   }
+
+   AliDebug(AliLog::kDebug + 2, "->");
 }
 
 //_____________________________________________________________________________
@@ -259,89 +249,84 @@ void AliRsnAnalysisManager::ProcessAllPairsMC()
 // Process one or two events for all pair managers.
 //
 
-  AliDebug(AliLog::kDebug+2,"<-");
-  
-  // skip if the global event pointers are NULL
-  if (!AliRsnEvent::IsCurrentEvent1()) return;
-  if (!AliRsnEvent::IsCurrentEvent2()) return;
-  
-  // for better readability, reference two pointers to the current events
-  AliRsnEvent *ev0 = AliRsnEvent::GetCurrentEvent1();
-  AliRsnEvent *ev1 = AliRsnEvent::GetCurrentEvent2();
-  
-  // this time the number of tracks comes from MC
-  Int_t nTracks[2];
-  nTracks[0] = ev0->GetRefMC()->GetNumberOfTracks();
-  nTracks[1] = ev1->GetRefMC()->GetNumberOfTracks();
-  
-  // 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, start, i;
-  Bool_t         filled;
-  AliRsnDaughter daughter0, daughter1;
-  AliRsnPair    *pair = 0x0;
-  TObjArrayIter  next(&fPairs);
-  
-  // reset all counters
-  while ((pair = (AliRsnPair*)next())) 
-  {
-    pair->ResetCount();
-  }
-  
-  for (i0 = 0; i0 < nTracks[0]; i0++)
-  {
-    // skip not physical primaries
-    if (!ev0->GetRefMCESD()->Stack()->IsPhysicalPrimary(i0)) continue;
-    
-    // assign first track
-    ev0->SetDaughterMC(daughter0, i0);
-    
-    // define start depending if we are processing one or two events
-    start = (AliRsnEvent::SameEvent() ? i0 + 1 : 0);
-        
-    // internal loop (same criterion)
-    for (i1 = start; i1 < nTracks[1]; i1++)
-    {
-      // if looking same event, skip the case when the two indexes are equal
-      if (AliRsnEvent::SameEvent() && i0 == i1) continue;
-      
+   AliDebug(AliLog::kDebug + 2, "<-");
+
+   // skip if the global event pointers are NULL
+   if (!AliRsnEvent::IsCurrentEvent1()) return;
+   if (!AliRsnEvent::IsCurrentEvent2()) return;
+
+   // for better readability, reference two pointers to the current events
+   AliRsnEvent *ev0 = AliRsnEvent::GetCurrentEvent1();
+   AliRsnEvent *ev1 = AliRsnEvent::GetCurrentEvent2();
+
+   // this time the number of tracks comes from MC
+   Int_t nTracks[2];
+   nTracks[0] = ev0->GetRefMC()->GetNumberOfTracks();
+   nTracks[1] = ev1->GetRefMC()->GetNumberOfTracks();
+
+   // 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, start, i;
+   Bool_t         filled;
+   AliRsnDaughter daughter0, daughter1;
+   AliRsnPair    *pair = 0x0;
+   TObjArrayIter  next(&fPairs);
+
+   // reset all counters
+   while ((pair = (AliRsnPair*)next())) {
+      pair->ResetCount();
+   }
+
+   for (i0 = 0; i0 < nTracks[0]; i0++) {
       // skip not physical primaries
-      if (!ev1->GetRefMCESD()->Stack()->IsPhysicalPrimary(i1)) continue;
-      
-      // assign second track
-      ev1->SetDaughterMC(daughter1, i1);
-      
-      // 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
-        filled = pair->Fill(&daughter0, &daughter1);
-        if (!filled) continue;
-        pair->Compute();
+      if (!ev0->GetRefMCESD()->Stack()->IsPhysicalPrimary(i0)) continue;
+
+      // assign first track
+      ev0->SetDaughterMC(daughter0, i0);
+
+      // define start depending if we are processing one or two events
+      start = (AliRsnEvent::SameEvent() ? i0 + 1 : 0);
+
+      // internal loop (same criterion)
+      for (i1 = start; i1 < nTracks[1]; i1++) {
+         // if looking same event, skip the case when the two indexes are equal
+         if (AliRsnEvent::SameEvent() && i0 == i1) continue;
+
+         // skip not physical primaries
+         if (!ev1->GetRefMCESD()->Stack()->IsPhysicalPrimary(i1)) continue;
+
+         // assign second track
+         ev1->SetDaughterMC(daughter1, i1);
+
+         // 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
+            filled = pair->Fill(&daughter0, &daughter1);
+            if (!filled) continue;
+            pair->Compute();
+         }
       }
-    }
-  }
-  
-  // update all count histograms counters
-  next.Reset();
-  if (!fList) return;
-  while ((pair = (AliRsnPair*)next())) 
-  {
-    TH1I *hist = (TH1I*)fList->FindObject(Form("_%s_USED", pair->GetName()));
-    if (!hist) continue;
-    if (pair->GetCount() > 0) hist->Fill(1); else hist->Fill(0);
-  }
-
-  AliDebug(AliLog::kDebug+2,"->");
+   }
+
+   // update all count histograms counters
+   next.Reset();
+   if (!fList) return;
+   while ((pair = (AliRsnPair*)next())) {
+      TH1I *hist = (TH1I*)fList->FindObject(Form("_%s_USED", pair->GetName()));
+      if (!hist) continue;
+      if (pair->GetCount() > 0) hist->Fill(1); else hist->Fill(0);
+   }
+
+   AliDebug(AliLog::kDebug + 2, "->");
 }
 
index 98f08d9..c12123c 100644 (file)
 class AliRsnEvent;
 class AliRsnPair;
 
-class AliRsnAnalysisManager : public TNamed
-{
-  public:
-
-    AliRsnAnalysisManager(const char*name = "RSN");
-    AliRsnAnalysisManager(const AliRsnAnalysisManager& copy);
-    AliRsnAnalysisManager& operator=(const AliRsnAnalysisManager& copy);
-    virtual ~AliRsnAnalysisManager() { }
-
-    virtual void   Add(AliRsnPair *pair);
-    virtual void   PrintArray() const;
-    virtual void   Print(Option_t *option = "") const;
-
-    void           InitAllPairs(TList*list);
-    void           ProcessAllPairs();
-    void           ProcessAllPairsMC();
-    AliRsnCutSet*  GetGlobalTrackCuts() {return &fGlobalTrackCuts;}
-
-  private:
-  
-    TList        *fList;             // container for output histograms (external object)
-    TObjArray     fPairs;            // collection of pair objects for the different outputs
-    AliRsnCutSet  fGlobalTrackCuts;  // a set of cuts which are applied to all tracks for all analysis
-
-    ClassDef(AliRsnAnalysisManager, 1)
+class AliRsnAnalysisManager : public TNamed {
+public:
+
+   AliRsnAnalysisManager(const char*name = "RSN");
+   AliRsnAnalysisManager(const AliRsnAnalysisManager& copy);
+   AliRsnAnalysisManager& operator=(const AliRsnAnalysisManager& copy);
+   virtual ~AliRsnAnalysisManager() { }
+
+   virtual void   Add(AliRsnPair *pair);
+   virtual void   PrintArray() const;
+   virtual void   Print(Option_t *option = "") const;
+
+   void           InitAllPairs(TList*list);
+   void           ProcessAllPairs();
+   void           ProcessAllPairsMC();
+   AliRsnCutSet*  GetGlobalTrackCuts() {return &fGlobalTrackCuts;}
+
+private:
+
+   TList        *fList;             // container for output histograms (external object)
+   TObjArray     fPairs;            // collection of pair objects for the different outputs
+   AliRsnCutSet  fGlobalTrackCuts;  // a set of cuts which are applied to all tracks for all analysis
+
+   ClassDef(AliRsnAnalysisManager, 1)
 };
 
 #endif
diff --git a/PWG2/RESONANCES/AliRsnAnalysisMonitorPairTask.cxx b/PWG2/RESONANCES/AliRsnAnalysisMonitorPairTask.cxx
deleted file mode 100644 (file)
index e62ba0f..0000000
+++ /dev/null
@@ -1,408 +0,0 @@
-//
-// 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 "AliRsnMonitorTrack.h"
-#include "AliRsnDaughter.h"
-#include "AliRsnEvent.h"
-
-#include "AliRsnAnalysisMonitorPairTask.h"
-
-ClassImp(AliRsnAnalysisMonitorPairTask)
-
-//__________________________________________________________________________________________________
-AliRsnAnalysisMonitorPairTask::AliRsnAnalysisMonitorPairTask(const char *name) :
-  AliAnalysisTaskSE(name),
-  fOut(0x0),
-  fInvMass(0.0),
-  fRangeMin(0.0),
-  fRangeMax(100.0),
-  fESDpid(0x0),
-  fTOFmaker(0x0),
-  fTOFcalib(0x0),
-  fTOFcalibrateESD(kFALSE),
-  fTOFcorrectTExp(kFALSE),
-  fTOFuseT0(kFALSE),
-  fTOFtuneMC(kFALSE),
-  fTOFresolution(0.0),
-  fEventCuts("eventCuts", AliRsnCut::kEvent),
-  fTrackCuts("trackCuts", AliRsnCut::kDaughter)
-  
-{
-//
-// Constructor
-//
-
-  DefineOutput(1, TTree::Class());
-}
-
-//__________________________________________________________________________________________________
-AliRsnAnalysisMonitorPairTask::AliRsnAnalysisMonitorPairTask(const AliRsnAnalysisMonitorPairTask& copy) :
-  AliAnalysisTaskSE(copy),
-  fOut(0x0),
-  fInvMass(0.0),
-  fRangeMin(copy.fRangeMin),
-  fRangeMax(copy.fRangeMax),
-  fESDpid(0x0),
-  fTOFmaker(0x0),
-  fTOFcalib(0x0),
-  fTOFcalibrateESD(kFALSE),
-  fTOFcorrectTExp(kFALSE),
-  fTOFuseT0(kFALSE),
-  fTOFtuneMC(kFALSE),
-  fTOFresolution(0.0),
-  fEventCuts(copy.fEventCuts),
-  fTrackCuts(copy.fTrackCuts)
-{
-//
-// Copy constructor
-//
-}
-
-//__________________________________________________________________________________________________
-AliRsnAnalysisMonitorPairTask& AliRsnAnalysisMonitorPairTask::operator=(const AliRsnAnalysisMonitorPairTask& copy)
-{
-//
-// Assignment operator
-//
-
-  fMass[0] = copy.fMass[0];
-  fMass[1] = copy.fMass[1];
-  
-  fRangeMin = copy.fRangeMin;
-  fRangeMax = copy.fRangeMax;
-
-  fTOFcalibrateESD = copy.fTOFcalibrateESD;
-  fTOFcorrectTExp = copy.fTOFcorrectTExp;
-  fTOFuseT0 = copy.fTOFuseT0;
-  fTOFtuneMC = copy.fTOFtuneMC;
-  fTOFresolution = copy.fTOFresolution;
-
-  return (*this);
-}
-
-//__________________________________________________________________________________________________
-AliRsnAnalysisMonitorPairTask::~AliRsnAnalysisMonitorPairTask()
-{
-//
-// Destructor
-//
-
-  if (fOut)    delete fOut;
-  if (fESDpid) delete fESDpid;
-  if (fTrack)  delete fTrack;
-}
-
-//__________________________________________________________________________________________________
-void AliRsnAnalysisMonitorPairTask::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);
-  
-  // create output branch object
-  fTrack[0] = new AliRsnMonitorTrack;
-  fTrack[1] = new AliRsnMonitorTrack;
-    
-  // create output tree
-  OpenFile(1);
-  fOut = new TTree("rsnPairMonitor", "Informations on pairs for cut checking");
-  fOut->Branch("track1", "AliRsnMonitorTrack", &fTrack[0]);
-  fOut->Branch("track2", "AliRsnMonitorTrack", &fTrack[1]);
-  fOut->Branch("minv"  , &fInvMass, "minv/F");
-}
-
-//__________________________________________________________________________________________________
-void AliRsnAnalysisMonitorPairTask::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
-//
-
-  // retrieve ESD event and related stack (if available)
-  AliESDEvent *esd   = dynamic_cast<AliESDEvent*>(fInputEvent);
-  AliStack    *stack = 0x0;
-  
-  // skip NULL events
-  if (!esd) return;
-  if (fMCEvent) stack = fMCEvent->Stack();
-  
-  // create interface objects to AliRsnEvent to check event cuts
-  AliRsnEvent event;
-  event.SetRef(esd);
-  event.SetRefMC(fMCEvent);
-  if (!fEventCuts.IsSelected(&event)) return;
-  
-  // check the event
-  Int_t type = EventEval(esd);
-    
-  // if processable, then process it
-  if      (type == 0) ProcessESD(esd, esd->GetPrimaryVertexTracks());
-  else if (type == 1) ProcessESD(esd, esd->GetPrimaryVertexSPD());
-  else return;
-  
-  // update histogram container
-  PostData(1, fOut);
-}
-
-//__________________________________________________________________________________________________
-void AliRsnAnalysisMonitorPairTask::Terminate(Option_t *)
-{
-//
-// Terminate
-//
-}
-
-//__________________________________________________________________________________________________
-Int_t AliRsnAnalysisMonitorPairTask::EventEval(AliESDEvent *esd)
-{
-//
-// Checks if the event is good for analysis.
-// Returns:
-// ---> 0 if a good primary vertex with tracks was found,
-// ---> 1 if a good SPD primary vertex was found
-// ---> 2 otherwise (event to be rejected)
-// In any case, adds an entry to the TTree, to keep trace of all events.
-//
-
-  // get the best primary vertex:
-  // first try that with tracks, then the SPD one
-  const AliESDVertex *vTrk  = esd->GetPrimaryVertexTracks();
-  const AliESDVertex *vSPD  = esd->GetPrimaryVertexSPD();
-  if(vTrk->GetNContributors() > 0)
-  {
-    return 0;
-  }
-  else if (vSPD->GetNContributors() > 0)
-  {
-    return 1;
-  }
-  else
-  {
-    return 2;
-  }
-}
-
-//__________________________________________________________________________________________________
-void AliRsnAnalysisMonitorPairTask::ProcessESD(AliESDEvent *esd, const AliESDVertex *v)
-{
-//
-// Process the ESD container, to read all tracks and copy their useful values.
-// All info are stored into an AliRsnMonitorTrack object and saved into the
-// TClonesArray which is one of the branches of the output TTree.
-//
-
-  // 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.);
-  }
-  
-  // loop on all tracks
-  Int_t          i0 , i1, ch0, ch1, ntracks = esd->GetNumberOfTracks();
-  TLorentzVector v0, v1, sum;
-  
-  // two nested loops on tracks
-  for (i0 = 0; i0 < ntracks; i0++)
-  {
-    if (!ProcessTrack(0, i0, esd, v)) continue;
-    ch0 = fTrack[0]->Charge();
-    v0.SetXYZM(fTrack[0]->PrecX(), fTrack[0]->PrecY(), fTrack[0]->PrecZ(), fMass[0]);
-    
-    for (i1 = i0 + 1; i1 < ntracks; i1++)
-    {
-      if (!ProcessTrack(1, i1, esd, v)) continue;
-      ch1 = fTrack[1]->Charge();
-      
-      // skip like-sign pairs
-      if (ch1 == ch0) continue;
-      
-      // check invmass range
-      v1.SetXYZM(fTrack[1]->PrecX(), fTrack[1]->PrecY(), fTrack[1]->PrecZ(), fMass[1]);  
-      sum = v0 + v1;
-      fInvMass = sum.M();
-      if (fInvMass < fRangeMin || fInvMass > fRangeMax) continue;
-      
-      // if here, add an entry to the tree
-      fOut->Fill();
-    }
-  }
-}
-
-//__________________________________________________________________________________________________
-Bool_t AliRsnAnalysisMonitorPairTask::ProcessTrack(Int_t myIndex, Int_t esdIndex, AliESDEvent *esd, const AliESDVertex *v)
-{
-//
-// Process a single track, and stores all its info into one of the two branch objects
-// defined by the first index, while the second chooses the track in the owner ESD
-//
-
-  if (myIndex < 0 || myIndex > 1) return kFALSE;
-  
-  // ITS stuff #1 
-  // create the response function and initialize it to MC or not
-  // depending if the AliStack object is there or not
-  AliStack *stack = 0x0;
-  if (fMCEvent) stack = fMCEvent->Stack();
-  Bool_t isMC = (stack != 0x0);
-  AliITSPIDResponse itsrsp(isMC);
-
-  // create interfacr objects
-  AliRsnEvent    event;
-  event.SetRef(esd);
-  event.SetRefMC(fMCEvent);
-  AliRsnDaughter daughter;
-  AliESDtrack *track = esd->GetTrack(esdIndex);
-  event.SetDaughter(daughter, esdIndex, AliRsnDaughter::kTrack);
-  
-  // skip NULL pointers, kink daughters and tracks which
-  // cannot be propagated to primary vertex
-  if (!track) return kFALSE;
-  if ((Int_t)track->GetKinkIndex(0) > 0) return kFALSE;
-  if (!track->RelateToVertex(v, esd->GetMagneticField(), kVeryBig)) return kFALSE;
-  
-  // useful variables
-  Int_t     k, nITS;
-  Bool_t    isTPC, isITSSA, isTOF;
-  Float_t   b[2], bCov[3];
-  Double_t  time[10];
-  
-  // reset the output object
-  // 'usable' flag will need to be set to 'ok'
-  fTrack[myIndex]->Reset();
-  
-  // check cuts
-  fTrack[myIndex]->CutsPassed() = fTrackCuts.IsSelected(&daughter);
-  
-  // get MC info if possible
-  if (stack) fTrack[myIndex]->AdoptMC(TMath::Abs(track->GetLabel()), stack);
-  
-  // copy general info
-  fTrack[myIndex]->Status() = (UInt_t)track->GetStatus();
-  fTrack[myIndex]->Length() = (Double_t)track->GetIntegratedLength();
-  fTrack[myIndex]->Charge() = (Int_t)track->Charge();
-  fTrack[myIndex]->PrecX()  = (Double_t)track->Px();
-  fTrack[myIndex]->PrecY()  = (Double_t)track->Py();
-  fTrack[myIndex]->PrecZ()  = (Double_t)track->Pz();
-  
-  // evaluate some flags from the status to decide what to do next in some points
-  isTPC   = ((fTrack[myIndex]->Status() & AliESDtrack::kTPCin)  != 0);
-  isITSSA = ((fTrack[myIndex]->Status() & AliESDtrack::kTPCin)  == 0 && (fTrack[myIndex]->Status() & AliESDtrack::kITSrefit) != 0 && (fTrack[myIndex]->Status() & AliESDtrack::kITSpureSA) == 0 && (fTrack[myIndex]->Status() & AliESDtrack::kITSpid) != 0);
-  isTOF   = ((fTrack[myIndex]->Status() & AliESDtrack::kTOFout) != 0 && (fTrack[myIndex]->Status() & AliESDtrack::kTIME) != 0);
-  
-  // accept only tracks which are TPC+ITS or ITS standalone
-  if (isITSSA)
-  {
-    fTrack[myIndex]->ITSsa() = kTRUE;
-    fTrack[myIndex]->TOFok() = kFALSE;
-  }
-  else if (isTPC)
-  {
-    fTrack[myIndex]->ITSsa() = kFALSE;
-    fTrack[myIndex]->TOFok() = isTOF;
-  }
-  else
-    return kFALSE;
-
-  // get DCA to primary vertex
-  track->GetImpactParameters(b, bCov);
-  fTrack[myIndex]->DCAr() = (Double_t)b[0];
-  fTrack[myIndex]->DCAz() = (Double_t)b[1];
-  
-  // get ITS info
-  for (k = 0; k < 6; k++)
-  {
-    fTrack[myIndex]->ITSmap(k) = track->HasPointOnITSLayer(k);
-  }
-  if (isITSSA)
-  {
-    fTrack[myIndex]->ITSchi2() = track->GetITSchi2();
-    fTrack[myIndex]->ITSsignal() = track->GetITSsignal();
-    nITS = fTrack[myIndex]->SSDcount() + fTrack[myIndex]->SDDcount();
-    for (k = 0; k < AliPID::kSPECIES; k++)
-    {
-      fTrack[myIndex]->ITSnsigma(k) = itsrsp.GetNumberOfSigmas(fTrack[myIndex]->Prec(), fTrack[myIndex]->ITSsignal(), (AliPID::EParticleType)k, nITS, kTRUE);
-    }
-  }
-  
-  // get TPC info
-  if (isTPC)
-  {
-    fTrack[myIndex]->TPCcount()  = (Int_t)track->GetTPCclusters(0);
-    fTrack[myIndex]->TPCchi2()   = (Double_t)track->GetTPCchi2();
-    fTrack[myIndex]->TPCsignal() = (Double_t)track->GetTPCsignal();
-    fTrack[myIndex]->PtpcX()     = fTrack[myIndex]->PtpcY() = fTrack[myIndex]->PtpcZ() = 1E10;
-    if (track->GetInnerParam())
-    {
-      fTrack[myIndex]->PtpcX() = track->GetInnerParam()->Px();
-      fTrack[myIndex]->PtpcY() = track->GetInnerParam()->Py();
-      fTrack[myIndex]->PtpcZ() = track->GetInnerParam()->Pz();
-      for (k = 0; k < AliPID::kSPECIES; k++) 
-      {
-        fTrack[myIndex]->TPCnsigma(k) = fESDpid->NumberOfSigmasTPC(track, (AliPID::EParticleType)k);
-      }
-    }
-  }
-  
-  // get TOF info
-  if (isTOF)
-  {
-    track->GetIntegratedTimes(time);
-    fTrack[myIndex]->TOFsignal() = (Double_t)track->GetTOFsignal();
-    for (k = 0; k < AliPID::kSPECIES; k++)
-    {
-      fTrack[myIndex]->TOFref(k)   = time[k];
-      fTrack[myIndex]->TOFsigma(k) = (Double_t)fTOFmaker->GetExpectedSigma(fTrack[myIndex]->Prec(), time[k], AliPID::ParticleMass(k));
-    }
-  }
-  
-  return kTRUE;
-}
diff --git a/PWG2/RESONANCES/AliRsnAnalysisMonitorPairTask.h b/PWG2/RESONANCES/AliRsnAnalysisMonitorPairTask.h
deleted file mode 100644 (file)
index 423b97b..0000000
+++ /dev/null
@@ -1,86 +0,0 @@
-//
-// Header file for implementation of data analysis aft 900 GeV
-//
-// Author: A. Pulvirenti
-//
-
-#ifndef ALIRSNANALYSISMONITORPAIRTASK_H
-#define ALIRSNANALYSISMONITORPAIRTASK_H
-
-#include "AliAnalysisTaskSE.h"
-#include "AliRsnCutSet.h"
-
-class TH1I;
-class TH1F;
-class TTree;
-
-class AliStack;
-class AliESDEvent;
-class AliESDVertex;
-class AliESDpid;
-class AliTOFT0maker;
-class AliTOFcalib;
-
-class AliRsnAnalysisMonitorPairTask : public AliAnalysisTaskSE
-{
-  public:
-  
-    AliRsnAnalysisMonitorPairTask(const char *name = "Phi7TeV");
-    AliRsnAnalysisMonitorPairTask(const AliRsnAnalysisMonitorPairTask& copy);
-    AliRsnAnalysisMonitorPairTask& operator=(const AliRsnAnalysisMonitorPairTask& copy);
-    virtual ~AliRsnAnalysisMonitorPairTask();
-    
-    void             SetMasses(Double_t m1, Double_t m2) {fMass[0] = m1; fMass[1] = m2;}
-    void             SetInvMassRange(Double_t m1, Double_t m2) {fRangeMin = m1, fRangeMax = m2;}
-    
-    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);
-    Bool_t           IsTPCtrack(AliESDtrack *track);
-    Bool_t           IsITSSAtrack(AliESDtrack *track);
-    void             ProcessESD(AliESDEvent *esd, const AliESDVertex *v);
-    Bool_t           ProcessTrack(Int_t myIndex, Int_t esdIndex, AliESDEvent *esd, const AliESDVertex *v);
-    
-    AliRsnCutSet*    GetEventCuts() {return &fEventCuts;}
-    AliRsnCutSet*    GetTrackCuts() {return &fTrackCuts;}
-
-  private:
-    
-    TTree              *fOut;              //  output TTree
-    AliRsnMonitorTrack *fTrack[2];         //  branch objects for output TTree
-    Double_t            fMass[2];          //  masses assigned to daughters
-    Float_t             fInvMass;          //  pair inv mass (computed with above masses)
-    Double_t            fRangeMin;         //  minimum accepted invmass
-    Double_t            fRangeMax;         //  maximum accepted invmass
-    
-    Double_t            fTPCpar[5];        //  parameters for TPC bethe-Bloch
-   
-    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
-    
-    AliRsnCutSet        fEventCuts;        //  event cuts
-    AliRsnCutSet        fTrackCuts;        //  track cuts
-
-    // ROOT dictionary
-    ClassDef(AliRsnAnalysisMonitorPairTask,1)
-};
-
-#endif
index 9a36ddf..ad5f843 100644 (file)
@@ -34,43 +34,43 @@ ClassImp(AliRsnAnalysisMonitorTask)
 
 //__________________________________________________________________________________________________
 AliRsnAnalysisMonitorTask::AliRsnAnalysisMonitorTask(const char *name) :
-  AliAnalysisTaskSE(name),
-  fOut(0x0),
-  fTrack(0x0),
-  fESDpid(0x0),
-  fTOFmaker(0x0),
-  fTOFcalib(0x0),
-  fTOFcalibrateESD(kFALSE),
-  fTOFcorrectTExp(kFALSE),
-  fTOFuseT0(kFALSE),
-  fTOFtuneMC(kFALSE),
-  fTOFresolution(0.0),
-  fEventCuts("eventCuts", AliRsnCut::kEvent),
-  fTrackCuts("trackCuts", AliRsnCut::kDaughter)
-  
+   AliAnalysisTaskSE(name),
+   fOut(0x0),
+   fTrack(0x0),
+   fESDpid(0x0),
+   fTOFmaker(0x0),
+   fTOFcalib(0x0),
+   fTOFcalibrateESD(kFALSE),
+   fTOFcorrectTExp(kFALSE),
+   fTOFuseT0(kFALSE),
+   fTOFtuneMC(kFALSE),
+   fTOFresolution(0.0),
+   fEventCuts("eventCuts", AliRsnCut::kEvent),
+   fTrackCuts("trackCuts", AliRsnCut::kDaughter)
+
 {
 //
 // Constructor
 //
 
-  DefineOutput(1, TTree::Class());
+   DefineOutput(1, TTree::Class());
 }
 
 //__________________________________________________________________________________________________
 AliRsnAnalysisMonitorTask::AliRsnAnalysisMonitorTask(const AliRsnAnalysisMonitorTask& copy) :
-  AliAnalysisTaskSE(copy),
-  fOut(0x0),
-  fTrack(0x0),
-  fESDpid(0x0),
-  fTOFmaker(0x0),
-  fTOFcalib(0x0),
-  fTOFcalibrateESD(kFALSE),
-  fTOFcorrectTExp(kFALSE),
-  fTOFuseT0(kFALSE),
-  fTOFtuneMC(kFALSE),
-  fTOFresolution(0.0),
-  fEventCuts(copy.fEventCuts),
-  fTrackCuts(copy.fTrackCuts)
+   AliAnalysisTaskSE(copy),
+   fOut(0x0),
+   fTrack(0x0),
+   fESDpid(0x0),
+   fTOFmaker(0x0),
+   fTOFcalib(0x0),
+   fTOFcalibrateESD(kFALSE),
+   fTOFcorrectTExp(kFALSE),
+   fTOFuseT0(kFALSE),
+   fTOFtuneMC(kFALSE),
+   fTOFresolution(0.0),
+   fEventCuts(copy.fEventCuts),
+   fTrackCuts(copy.fTrackCuts)
 {
 //
 // Copy constructor
@@ -84,13 +84,13 @@ AliRsnAnalysisMonitorTask& AliRsnAnalysisMonitorTask::operator=(const AliRsnAnal
 // Assignment operator
 //
 
-  fTOFcalibrateESD = copy.fTOFcalibrateESD;
-  fTOFcorrectTExp = copy.fTOFcorrectTExp;
-  fTOFuseT0 = copy.fTOFuseT0;
-  fTOFtuneMC = copy.fTOFtuneMC;
-  fTOFresolution = copy.fTOFresolution;
+   fTOFcalibrateESD = copy.fTOFcalibrateESD;
+   fTOFcorrectTExp = copy.fTOFcorrectTExp;
+   fTOFuseT0 = copy.fTOFuseT0;
+   fTOFtuneMC = copy.fTOFtuneMC;
+   fTOFresolution = copy.fTOFresolution;
 
-  return (*this);
+   return (*this);
 }
 
 //__________________________________________________________________________________________________
@@ -100,9 +100,9 @@ AliRsnAnalysisMonitorTask::~AliRsnAnalysisMonitorTask()
 // Destructor
 //
 
-  if (fOut)    delete fOut;
-  if (fESDpid) delete fESDpid;
-  if (fTrack)  delete fTrack;
+   if (fOut)    delete fOut;
+   if (fESDpid) delete fESDpid;
+   if (fTrack)  delete fTrack;
 }
 
 //__________________________________________________________________________________________________
@@ -112,22 +112,22 @@ void AliRsnAnalysisMonitorTask::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);
-  
-  // create output branch object
-  fTrack = new AliRsnMonitorTrack;
-    
-  // create output tree
-  OpenFile(1);
-  fOut = new TTree("rsnMonitor", "Informations on single tracks for cut checking");
-  fOut->Branch("tracks", "AliRsnMonitorTrack", &fTrack);
+   // 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);
+
+   // create output branch object
+   fTrack = new AliRsnMonitorTrack;
+
+   // create output tree
+   OpenFile(1);
+   fOut = new TTree("rsnMonitor", "Informations on single tracks for cut checking");
+   fOut->Branch("tracks", "AliRsnMonitorTrack", &fTrack);
 }
 
 //__________________________________________________________________________________________________
@@ -142,30 +142,30 @@ void AliRsnAnalysisMonitorTask::UserExec(Option_t *)
 // 3 -- event bad
 //
 
-  // retrieve ESD event and related stack (if available)
-  AliESDEvent *esd   = dynamic_cast<AliESDEvent*>(fInputEvent);
-  AliStack    *stack = 0x0;
-  
-  // skip NULL events
-  if (!esd) return;
-  if (fMCEvent) stack = fMCEvent->Stack();
-  
-  // create interface objects to AliRsnEvent to check event cuts
-  AliRsnEvent event;
-  event.SetRef(esd);
-  event.SetRefMC(fMCEvent);
-  if (!fEventCuts.IsSelected(&event)) return;
-  
-  // check the event
-  Int_t type = EventEval(esd);
-    
-  // if processable, then process it
-  if      (type == 0) ProcessESD(esd, esd->GetPrimaryVertexTracks(), stack);
-  else if (type == 1) ProcessESD(esd, esd->GetPrimaryVertexSPD()   , stack);
-  else return;
-  
-  // update histogram container
-  PostData(1, fOut);
+   // retrieve ESD event and related stack (if available)
+   AliESDEvent *esd   = dynamic_cast<AliESDEvent*>(fInputEvent);
+   AliStack    *stack = 0x0;
+
+   // skip NULL events
+   if (!esd) return;
+   if (fMCEvent) stack = fMCEvent->Stack();
+
+   // create interface objects to AliRsnEvent to check event cuts
+   AliRsnEvent event;
+   event.SetRef(esd);
+   event.SetRefMC(fMCEvent);
+   if (!fEventCuts.IsSelected(&event)) return;
+
+   // check the event
+   Int_t type = EventEval(esd);
+
+   // if processable, then process it
+   if (type == 0) ProcessESD(esd, esd->GetPrimaryVertexTracks(), stack);
+   else if (type == 1) ProcessESD(esd, esd->GetPrimaryVertexSPD()   , stack);
+   else return;
+
+   // update histogram container
+   PostData(1, fOut);
 }
 
 //__________________________________________________________________________________________________
@@ -188,22 +188,17 @@ Int_t AliRsnAnalysisMonitorTask::EventEval(AliESDEvent *esd)
 // In any case, adds an entry to the TTree, to keep trace of all events.
 //
 
-  // get the best primary vertex:
-  // first try that with tracks, then the SPD one
-  const AliESDVertex *vTrk  = esd->GetPrimaryVertexTracks();
-  const AliESDVertex *vSPD  = esd->GetPrimaryVertexSPD();
-  if(vTrk->GetNContributors() > 0)
-  {
-    return 0;
-  }
-  else if (vSPD->GetNContributors() > 0)
-  {
-    return 1;
-  }
-  else
-  {
-    return 2;
-  }
+   // get the best primary vertex:
+   // first try that with tracks, then the SPD one
+   const AliESDVertex *vTrk  = esd->GetPrimaryVertexTracks();
+   const AliESDVertex *vSPD  = esd->GetPrimaryVertexSPD();
+   if (vTrk->GetNContributors() > 0) {
+      return 0;
+   } else if (vSPD->GetNContributors() > 0) {
+      return 1;
+   } else {
+      return 2;
+   }
 }
 
 //__________________________________________________________________________________________________
@@ -216,143 +211,129 @@ void AliRsnAnalysisMonitorTask::ProcessESD
 // TClonesArray which is one of the branches of the output TTree.
 //
 
-  // create interfacr objects
-  AliRsnEvent    event;
-  AliRsnDaughter daughter;
-  event.SetRef(esd);
-  event.SetRefMC(fMCEvent);
-
-  // ITS stuff #1 
-  // create the response function and initialize it to MC or not
-  // depending if the AliStack object is there or not
-  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.);
-  }
-  
-  // loop on all tracks
-  Int_t               i, k, nITS, ntracks = esd->GetNumberOfTracks();;
-  Bool_t              isTPC, isITSSA, isTOF;
-  Float_t             b[2], bCov[3];
-  Double_t            time[10];
-  
-  for (i = 0; i < ntracks; i++)
-  {
-    AliESDtrack *track = esd->GetTrack(i);
-    event.SetDaughter(daughter, i, AliRsnDaughter::kTrack);
-    
-    // reset the output object
-    // 'usable' flag will need to be set to 'ok'
-    fTrack->Reset();
-    
-    // check cuts
-    fTrack->CutsPassed() = fTrackCuts.IsSelected(&daughter);
-        
-    // skip NULL pointers, kink daughters and tracks which
-    // cannot be propagated to primary vertex
-    if (!track) continue;
-    if ((Int_t)track->GetKinkIndex(0) > 0) continue;
-    if (!track->RelateToVertex(v, esd->GetMagneticField(), kVeryBig)) continue;
-    
-    // get MC info if possible
-    if (stack) fTrack->AdoptMC(TMath::Abs(track->GetLabel()), stack);
-    
-    // copy general info
-    fTrack->Status() = (UInt_t)track->GetStatus();
-    fTrack->Length() = (Double_t)track->GetIntegratedLength();
-    fTrack->Charge() = (Int_t)track->Charge();
-    fTrack->PrecX()  = (Double_t)track->Px();
-    fTrack->PrecY()  = (Double_t)track->Py();
-    fTrack->PrecZ()  = (Double_t)track->Pz();
-    
-    // evaluate some flags from the status to decide what to do next in some points
-    isTPC   = ((fTrack->Status() & AliESDtrack::kTPCin)  != 0);
-    isITSSA = ((fTrack->Status() & AliESDtrack::kTPCin)  == 0 && (fTrack->Status() & AliESDtrack::kITSrefit) != 0 && (fTrack->Status() & AliESDtrack::kITSpureSA) == 0 && (fTrack->Status() & AliESDtrack::kITSpid) != 0);
-    isTOF   = ((fTrack->Status() & AliESDtrack::kTOFout) != 0 && (fTrack->Status() & AliESDtrack::kTIME) != 0);
-    
-    // accept only tracks which are TPC+ITS or ITS standalone
-    if (isITSSA)
-    {
-      fTrack->ITSsa() = kTRUE;
-      fTrack->TOFok() = kFALSE;
-    }
-    else if (isTPC)
-    {
-      fTrack->ITSsa() = kFALSE;
-      fTrack->TOFok() = isTOF;
-    }
-    else
-      continue;
-
-    // get DCA to primary vertex
-    track->GetImpactParameters(b, bCov);
-    fTrack->DCAr() = (Double_t)b[0];
-    fTrack->DCAz() = (Double_t)b[1];
-    
-    // get ITS info
-    for (k = 0; k < 6; k++)
-    {
-      fTrack->ITSmap(k) = track->HasPointOnITSLayer(k);
-    }
-    if (isITSSA)
-    {
-      fTrack->ITSchi2() = track->GetITSchi2();
-      fTrack->ITSsignal() = track->GetITSsignal();
-      nITS = fTrack->SSDcount() + fTrack->SDDcount();
-      for (k = 0; k < AliPID::kSPECIES; k++)
-      {
-        fTrack->ITSnsigma(k) = itsrsp.GetNumberOfSigmas(fTrack->Prec(), fTrack->ITSsignal(), (AliPID::EParticleType)k, nITS, kTRUE);
+   // create interfacr objects
+   AliRsnEvent    event;
+   AliRsnDaughter daughter;
+   event.SetRef(esd);
+   event.SetRefMC(fMCEvent);
+
+   // ITS stuff #1
+   // create the response function and initialize it to MC or not
+   // depending if the AliStack object is there or not
+   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.);
+   }
+
+   // loop on all tracks
+   Int_t               i, k, nITS, ntracks = esd->GetNumberOfTracks();;
+   Bool_t              isTPC, isITSSA, isTOF;
+   Float_t             b[2], bCov[3];
+   Double_t            time[10];
+
+   for (i = 0; i < ntracks; i++) {
+      AliESDtrack *track = esd->GetTrack(i);
+      event.SetDaughter(daughter, i, AliRsnDaughter::kTrack);
+
+      // reset the output object
+      // 'usable' flag will need to be set to 'ok'
+      fTrack->Reset();
+
+      // check cuts
+      fTrack->CutsPassed() = fTrackCuts.IsSelected(&daughter);
+
+      // skip NULL pointers, kink daughters and tracks which
+      // cannot be propagated to primary vertex
+      if (!track) continue;
+      if ((Int_t)track->GetKinkIndex(0) > 0) continue;
+      if (!track->RelateToVertex(v, esd->GetMagneticField(), kVeryBig)) continue;
+
+      // get MC info if possible
+      if (stack) fTrack->AdoptMC(TMath::Abs(track->GetLabel()), stack);
+
+      // copy general info
+      fTrack->Status() = (UInt_t)track->GetStatus();
+      fTrack->Length() = (Double_t)track->GetIntegratedLength();
+      fTrack->Charge() = (Int_t)track->Charge();
+      fTrack->PrecX()  = (Double_t)track->Px();
+      fTrack->PrecY()  = (Double_t)track->Py();
+      fTrack->PrecZ()  = (Double_t)track->Pz();
+
+      // evaluate some flags from the status to decide what to do next in some points
+      isTPC   = ((fTrack->Status() & AliESDtrack::kTPCin)  != 0);
+      isITSSA = ((fTrack->Status() & AliESDtrack::kTPCin)  == 0 && (fTrack->Status() & AliESDtrack::kITSrefit) != 0 && (fTrack->Status() & AliESDtrack::kITSpureSA) == 0 && (fTrack->Status() & AliESDtrack::kITSpid) != 0);
+      isTOF   = ((fTrack->Status() & AliESDtrack::kTOFout) != 0 && (fTrack->Status() & AliESDtrack::kTIME) != 0);
+
+      // accept only tracks which are TPC+ITS or ITS standalone
+      if (isITSSA) {
+         fTrack->ITSsa() = kTRUE;
+         fTrack->TOFok() = kFALSE;
+      } else if (isTPC) {
+         fTrack->ITSsa() = kFALSE;
+         fTrack->TOFok() = isTOF;
+      } else
+         continue;
+
+      // get DCA to primary vertex
+      track->GetImpactParameters(b, bCov);
+      fTrack->DCAr() = (Double_t)b[0];
+      fTrack->DCAz() = (Double_t)b[1];
+
+      // get ITS info
+      for (k = 0; k < 6; k++) {
+         fTrack->ITSmap(k) = track->HasPointOnITSLayer(k);
+      }
+      if (isITSSA) {
+         fTrack->ITSchi2() = track->GetITSchi2();
+         fTrack->ITSsignal() = track->GetITSsignal();
+         nITS = fTrack->SSDcount() + fTrack->SDDcount();
+         for (k = 0; k < AliPID::kSPECIES; k++) {
+            fTrack->ITSnsigma(k) = itsrsp.GetNumberOfSigmas(fTrack->Prec(), fTrack->ITSsignal(), (AliPID::EParticleType)k, nITS, kTRUE);
+         }
       }
-    }
-    
-    // get TPC info
-    if (isTPC)
-    {
-      fTrack->TPCcount()  = (Int_t)track->GetTPCclusters(0);
-      fTrack->TPCchi2()   = (Double_t)track->GetTPCchi2();
-      fTrack->TPCsignal() = (Double_t)track->GetTPCsignal();
-      fTrack->PtpcX()     = fTrack->PtpcY() = fTrack->PtpcZ() = 1E10;
-      if (track->GetInnerParam())
-      {
-        fTrack->PtpcX() = track->GetInnerParam()->Px();
-        fTrack->PtpcY() = track->GetInnerParam()->Py();
-        fTrack->PtpcZ() = track->GetInnerParam()->Pz();
-        for (k = 0; k < AliPID::kSPECIES; k++) 
-        {
-          fTrack->TPCnsigma(k) = fESDpid->NumberOfSigmasTPC(track, (AliPID::EParticleType)k);
-        }
+
+      // get TPC info
+      if (isTPC) {
+         fTrack->TPCcount()  = (Int_t)track->GetTPCclusters(0);
+         fTrack->TPCchi2()   = (Double_t)track->GetTPCchi2();
+         fTrack->TPCsignal() = (Double_t)track->GetTPCsignal();
+         fTrack->PtpcX()     = fTrack->PtpcY() = fTrack->PtpcZ() = 1E10;
+         if (track->GetInnerParam()) {
+            fTrack->PtpcX() = track->GetInnerParam()->Px();
+            fTrack->PtpcY() = track->GetInnerParam()->Py();
+            fTrack->PtpcZ() = track->GetInnerParam()->Pz();
+            for (k = 0; k < AliPID::kSPECIES; k++) {
+               fTrack->TPCnsigma(k) = fESDpid->NumberOfSigmasTPC(track, (AliPID::EParticleType)k);
+            }
+         }
       }
-    }
-    
-    // get TOF info
-    if (isTOF)
-    {
-      track->GetIntegratedTimes(time);
-      fTrack->TOFsignal() = (Double_t)track->GetTOFsignal();
-      for (k = 0; k < AliPID::kSPECIES; k++)
-      {
-        fTrack->TOFref(k)   = time[k];
-        fTrack->TOFsigma(k) = (Double_t)fTOFmaker->GetExpectedSigma(fTrack->Prec(), time[k], AliPID::ParticleMass(k));
+
+      // get TOF info
+      if (isTOF) {
+         track->GetIntegratedTimes(time);
+         fTrack->TOFsignal() = (Double_t)track->GetTOFsignal();
+         for (k = 0; k < AliPID::kSPECIES; k++) {
+            fTrack->TOFref(k)   = time[k];
+            fTrack->TOFsigma(k) = (Double_t)fTOFmaker->GetExpectedSigma(fTrack->Prec(), time[k], AliPID::ParticleMass(k));
+         }
       }
-    }
-    
-    // add entry to TTree
-    fOut->Fill();
-  }
+
+      // add entry to TTree
+      fOut->Fill();
+   }
 }
index 66d1c75..642293b 100644 (file)
@@ -21,58 +21,57 @@ class AliESDpid;
 class AliTOFT0maker;
 class AliTOFcalib;
 
-class AliRsnAnalysisMonitorTask : public AliAnalysisTaskSE
-{
-  public:
-  
-    AliRsnAnalysisMonitorTask(const char *name = "Phi7TeV");
-    AliRsnAnalysisMonitorTask(const AliRsnAnalysisMonitorTask& copy);
-    AliRsnAnalysisMonitorTask& operator=(const AliRsnAnalysisMonitorTask& copy);
-    virtual ~AliRsnAnalysisMonitorTask();
-    
-    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);
-    Bool_t           IsTPCtrack(AliESDtrack *track);
-    Bool_t           IsITSSAtrack(AliESDtrack *track);
-    void             ProcessESD(AliESDEvent *esd, const AliESDVertex *v, AliStack *stack);
-    
-    AliRsnCutSet*    GetEventCuts() {return &fEventCuts;}
-    AliRsnCutSet*    GetTrackCuts() {return &fTrackCuts;}
-
-  private:
-    
-    TTree              *fOut;              //  output TTree
-    AliRsnMonitorTrack *fTrack;            //  branch object for output TTree
-    
-    Double_t            fTPCpar[5];        //  parameters for TPC bethe-Bloch
-   
-    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
-    
-    AliRsnCutSet        fEventCuts;        //  event cuts
-    AliRsnCutSet        fTrackCuts;        //  track cuts
-
-    // ROOT dictionary
-    ClassDef(AliRsnAnalysisMonitorTask,1)
+class AliRsnAnalysisMonitorTask : public AliAnalysisTaskSE {
+public:
+
+   AliRsnAnalysisMonitorTask(const char *name = "Phi7TeV");
+   AliRsnAnalysisMonitorTask(const AliRsnAnalysisMonitorTask& copy);
+   AliRsnAnalysisMonitorTask& operator=(const AliRsnAnalysisMonitorTask& copy);
+   virtual ~AliRsnAnalysisMonitorTask();
+
+   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);
+   Bool_t           IsTPCtrack(AliESDtrack *track);
+   Bool_t           IsITSSAtrack(AliESDtrack *track);
+   void             ProcessESD(AliESDEvent *esd, const AliESDVertex *v, AliStack *stack);
+
+   AliRsnCutSet*    GetEventCuts() {return &fEventCuts;}
+   AliRsnCutSet*    GetTrackCuts() {return &fTrackCuts;}
+
+private:
+
+   TTree              *fOut;              //  output TTree
+   AliRsnMonitorTrack *fTrack;            //  branch object for output TTree
+
+   Double_t            fTPCpar[5];        //  parameters for TPC bethe-Bloch
+
+   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
+
+   AliRsnCutSet        fEventCuts;        //  event cuts
+   AliRsnCutSet        fTrackCuts;        //  track cuts
+
+   // ROOT dictionary
+   ClassDef(AliRsnAnalysisMonitorTask, 1)
 };
 
 #endif
diff --git a/PWG2/RESONANCES/AliRsnAnalysisPhiKK.cxx b/PWG2/RESONANCES/AliRsnAnalysisPhiKK.cxx
deleted file mode 100644 (file)
index 4d0ef08..0000000
+++ /dev/null
@@ -1,372 +0,0 @@
-//
-// Class AliRsnAnalysisPhiKK
-//
-// 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)
-//
-
-#include <Riostream.h>
-#include <TList.h>
-
-#include "AliRsnFunction.h"
-#include "AliRsnAnalysisPhiKK.h"
-
-ClassImp(AliRsnAnalysisPhiKK)
-
-//_____________________________________________________________________________
-AliRsnAnalysisPhiKK::AliRsnAnalysisPhiKK(const char *name, Bool_t useKine) :
-  AliRsnVAnalysisTaskSE(name, useKine),
-  
-  fPairDef(AliPID::kKaon, '+', AliPID::kKaon, '-', 333, 1.019455),
-  
-  fCutEvent      (Form("%s_cutEvent"   , name), AliRsnTarget::kEvent),
-  fCutTrackCommon(Form("%s_cutTrackCom", name), AliRsnTarget::kDaughter),
-  fCutTrackPos   (Form("%s_cutTrackPos", name), AliRsnTarget::kDaughter),
-  fCutTrackNeg   (Form("%s_cutTrackNeg", name), AliRsnTarget::kDaughter),
-  fCutPair       (Form("%s_cutPair", name), AliRsnTarget::kMother),
-  
-  fFuncPM  ("AliRsnFunction", 0),
-  fFuncPP  ("AliRsnFunction", 0),
-  fFuncMM  ("AliRsnFunction", 0),
-  fFuncTrue("AliRsnFunction", 0),
-  
-  fOutList(0x0)
-{
-//
-// Default constructor.
-// Defines another output slot for histograms/ntuples
-//
-
-  DefineOutput(2, TList::Class());
-}
-
-//_____________________________________________________________________________
-AliRsnAnalysisPhiKK::AliRsnAnalysisPhiKK(const AliRsnAnalysisPhiKK& copy) :
-  AliRsnVAnalysisTaskSE(copy),
-  
-  fPairDef(AliPID::kKaon, '+', AliPID::kKaon, '-', 333, 1.019455),
-  
-  fCutEvent      (copy.fCutEvent),
-  fCutTrackCommon(copy.fCutTrackCommon),
-  fCutTrackPos   (copy.fCutTrackPos),
-  fCutTrackNeg   (copy.fCutTrackNeg),
-  fCutPair       (copy.fCutPair),
-  
-  fFuncPM  (copy.fFuncPM),
-  fFuncPP  (copy.fFuncPP),
-  fFuncMM  (copy.fFuncMM),
-  fFuncTrue(copy.fFuncTrue),
-  
-  fOutList(0x0)
-{
-//
-// Copy constructor.
-//
-}
-
-//_____________________________________________________________________________
-AliRsnAnalysisPhiKK& AliRsnAnalysisPhiKK::operator=(const AliRsnAnalysisPhiKK& copy)
-{
-//
-// Assigment operator.
-//
-
-  AliRsnVAnalysisTaskSE::operator=(copy);
-  
-  fFuncPM   = copy.fFuncPM;
-  fFuncPP   = copy.fFuncPP;
-  fFuncMM   = copy.fFuncMM;
-  fFuncTrue = copy.fFuncTrue;
-  
-  fCutEvent       = copy.fCutEvent;
-  fCutTrackCommon = copy.fCutTrackCommon;
-  fCutTrackPos    = copy.fCutTrackPos;
-  fCutTrackNeg    = copy.fCutTrackNeg;
-  fCutPair        = copy.fCutPair;
-  
-  if (fOutList) fOutList->Clear();
-  
-  return (*this);
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisPhiKK::AddFunction(AliRsnFunction* const fcn)
-{
-//
-// Adds a new computing function to each collection,
-// in order to have exactly the sames for each kind of pair.
-//
-  
-  Int_t size = fFuncPM.GetEntries();
-  
-  new (fFuncPM  [size]) AliRsnFunction(*fcn);
-  new (fFuncPP  [size]) AliRsnFunction(*fcn);
-  new (fFuncMM  [size]) AliRsnFunction(*fcn);
-  new (fFuncTrue[size]) AliRsnFunction(*fcn);
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisPhiKK::RsnUserCreateOutputObjects()
-{
-//
-// Creation of output objects.
-// These are created through the utility methods in the analysis manager,
-// which asks all the AliRsnPair objects to initialize their output which
-// is then linked to the TList data member of this, which will contain all the output.
-//
-
-  if (!fOutList) fOutList = new TList;
-  fOutList->Clear();
-  
-  Int_t   i, j, nFunc = fFuncPM.GetEntries();
-  TString hName(""), suf[4] = {"PM", "PP", "MM", "True"};
-  AliRsnFunction *fcn[4] = {0, 0, 0, 0};
-  
-  for (i = 0; i < nFunc; i++)
-  {
-    fcn[0] = (AliRsnFunction*)fFuncPM.At(i);
-    fcn[1] = (AliRsnFunction*)fFuncPP.At(i);
-    fcn[2] = (AliRsnFunction*)fFuncMM.At(i);
-    fcn[3] = (AliRsnFunction*)fFuncTrue.At(i);
-    for (j = 0; j < 4; j++)
-    {
-      hName  = GetName();
-      hName += '_';
-      hName += suf[j];
-      hName += '_';
-      hName += fcn[j]->GetName();
-      if (fcn[j]->IsUsingTH1()) fOutList->Add(fcn[j]->CreateHistogram(hName.Data(), ""));
-      else fOutList->Add(fcn[j]->CreateHistogramSparse(hName.Data(), ""));
-    }
-  }
-
-  PostData(2, fOutList);
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisPhiKK::RsnUserExec(Option_t*)
-{
-//
-// Execution of the analysis task.
-// Recovers the input event and processes it with all included pair objects,
-// using 'reconstructed' or 'MonteCarlo' functions depending on MC-only flag.
-//
-
-  // allocate statically all class objects used here
-  static TArrayI                   good(0);
-  static AliRsnDaughter            kaon[2], temp;
-  static AliRsnMother              phi;
-  static AliRsnDaughter::ERefType  type;
-  static AliRsnFunction           *fcn = 0x0;
-  static TClonesArray             *ref = 0x0;
-  
-  // define constants used for kinematics
-  static const Double_t kaonMass = 0.493677;
-  
-  // simpler variables are declared non static
-  Int_t  i, j, k, index, ngood = 0;
-  Int_t  tot = AliRsnTarget::GetCurrentEvent()->GetAbsoluteSum();
-  Bool_t assignOK, truePair;
-
-  // point to first event in the target 
-  AliRsnTarget::SwitchToFirst();
-  if (!AliRsnTarget::GetCurrentEvent()) return;
-  
-  // initially, set the array of good indexes 
-  // to the full number of tracks and reset the counter
-  good.Set(tot);
-  ngood = 0;
-  
-  // loop on tracks and get those which satisfy cuts
-  for (i = 0; i < tot; i++)
-  {
-    // assign track and skip all that are not charged tracks
-    assignOK = AliRsnTarget::GetCurrentEvent()->ConvertAbsoluteIndex(i, index, type);
-    if (!assignOK) continue;
-    if (type != AliRsnDaughter::kTrack) continue;
-    AliRsnTarget::GetCurrentEvent()->SetDaughter(temp, index, AliRsnDaughter::kTrack);
-    
-    // skip tracks which don't pass common cuts
-    if (!fCutTrackCommon.IsSelected(&temp)) continue;
-    
-    // accept tracks which pass also charge-related cuts
-    if ( (temp.Charge() > 0) && (fCutTrackPos.IsSelected(&temp)) )
-    {
-      good[ngood] = index;
-      ++ngood;
-    }
-    else if ( (temp.Charge() < 0) && (fCutTrackNeg.IsSelected(&temp)) )
-    {
-      good[ngood] = index;
-      ++ngood;
-    }
-  }
-  
-  // rese the arrays to the real counts
-  good.Set(ngood);
-  
-  // now that the 'tot' value is useless, set it to
-  // the total number of functions, which by construction 
-  // is THE SAME for all collections
-  tot = fFuncPM.GetEntries();
-  
-  // fill histograms: do a unique loop on all good indexes
-  // and choose the histogram to fill from track charges
-  for (i = 0; i < ngood; i++)
-  {
-    AliRsnTarget::GetCurrentEvent()->SetDaughter(kaon[0], good[i], AliRsnDaughter::kTrack);
-    
-    for (j = 0; j < ngood; j++)
-    {
-      // reject equal indexes
-      if (good[i] == good[j]) continue;
-      AliRsnTarget::GetCurrentEvent()->SetDaughter(kaon[1], good[j], AliRsnDaughter::kTrack);
-  
-      // adjust charges of pair def
-      fPairDef.SetDaughters(AliPID::kKaon, kaon[0].ChargeChar(), AliPID::kKaon, kaon[1].ChargeChar());
-    
-      // fill the pair using the kaon masses and the passed daughters
-      phi.SetDaughters(&kaon[0], kaonMass, &kaon[1], kaonMass);
-      
-      // check pair cuts
-      if (!fCutPair.IsSelected(&phi)) continue;
-      
-      // choose the functions to fill according to charges
-      if (fPairDef.IsLikeSign())
-      {
-        if (kaon[0].IsPos()) ref = &fFuncPP; else ref = &fFuncMM;
-        truePair = kFALSE;
-      }
-      else
-      {
-        ref = &fFuncPM;
-        truePair = IsTruePair(&kaon[0], &kaon[1]);
-      }
-        
-      // loop on functions in chosen collection and fill
-      for (k = 0; k < tot; k++)
-      {
-        // fill standard histogram
-        fcn = (AliRsnFunction*)fFuncPP[k];
-        fcn->SetPairDef(&fPairDef);
-        fcn->SetPair(&phi);
-        fcn->Fill();
-        
-        // in case of true pair, fill its histogram
-        if (truePair)
-        {
-          fcn = (AliRsnFunction*)fFuncTrue[k];
-          fcn->Fill();
-        }
-      }
-    } // end internal loop
-  } // end external loop
-  
-  PostData(2, fOutList);
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisPhiKK::RsnTerminate(Option_t*)
-{
-//
-// Termination.
-// Could be added some monitor histograms here.
-//
-}
-
-//______________________________________________________________________________
-Bool_t AliRsnAnalysisPhiKK::EventProcess()
-{
-//
-// Customized event pre-processing.
-// First checks if the current event passes all cuts,
-// and if it does, updates the informations and then
-// call the operations which are already defined in the
-// omonyme function in mother class
-//
-
-  // initially, an event is expected to be bad
-  fTaskInfo.SetEventUsed(kFALSE);
-  
-  // check #1: number of tracks in event (reject empty events)
-  Int_t ntracks = fRsnEvent.GetMultiplicity();
-  if (ntracks < 1) 
-  {
-    // empty events are rejected by default
-    fTaskInfo.SetEventUsed(kFALSE);
-    AliDebug(AliLog::kDebug, "Empty event. Skipping...");
-    return kFALSE;
-  }
-
-  // check the event cuts and update the info data accordingly
-  // events not passing the cuts must be rejected
-  if (!fCutEvent.IsSelected(&fRsnEvent))
-  {
-    fTaskInfo.SetEventUsed(kFALSE);
-    return kFALSE;
-  }
-  
-  // if we reach this point, cuts were passed;
-  // then additional operations can be done
-  
-  // find leading particle (without any PID/momentum restriction)
-  fRsnEvent.SelectLeadingParticle(0);
-  
-  // final return value is positive
-  // but call the mother class method which updates info object
-  fTaskInfo.SetEventUsed(kTRUE);
-  return AliRsnVAnalysisTaskSE::EventProcess();
-}
-
-//______________________________________________________________________________
-Bool_t AliRsnAnalysisPhiKK::IsTruePair(AliRsnDaughter *d1, AliRsnDaughter *d2)
-{
-//
-// Checks if the two daughters in argument come from the same phi resonance
-// and, if they do, check also that they are both kaons
-//
-
-  // constants related to PDG
-  static const Int_t phiPDG  = 333;
-  static const Int_t kaonPDG = 321;
-
-  // check #1: is MC present?
-  if (!d1->GetRefMC() || !d2->GetRefMC()) return kFALSE;
-
-  // check #2: same mother?
-  Int_t m1 = -1;
-  Int_t m2 = -2;
-  if (d1->IsESD() && d2->IsESD() )
-  {
-    if (d1->GetRefMCESD() && d2->GetRefMCESD())
-    {
-      m1 = d1->GetRefMCESD()->Particle()->GetFirstMother();
-      m2 = d2->GetRefMCESD()->Particle()->GetFirstMother();
-    }
-  }
-  if (d1->IsAOD() && d2->IsAOD())
-  {
-    if (d1->GetRefMCAOD() && d2->GetRefMCAOD())
-    {
-      m1 = d1->GetRefMCAOD()->GetMother();
-      m2 = d2->GetRefMCAOD()->GetMother();
-    }
-  }
-  if (m1 < 0 || m2 < 0 || (m1 > 0 && m2 > 0 && m1 != m2)) return kFALSE;
-  
-  // check #3: is the common mother a phi (PDG = 333)?
-  if (d1->GetMotherPDG() != phiPDG) return kFALSE;
-  
-  // check #4: are the two particles a K+K- pair?
-  m1 = d1->GetPDG();
-  m2 = d2->GetPDG();
-  if (m1 == kaonPDG && m2 == -kaonPDG) 
-    return kTRUE;
-  else if (m1 == -kaonPDG && m2 == kaonPDG)
-    return kTRUE;
-  else
-    return kFALSE;
-}
diff --git a/PWG2/RESONANCES/AliRsnAnalysisPhiKK.h b/PWG2/RESONANCES/AliRsnAnalysisPhiKK.h
deleted file mode 100644 (file)
index 06cf0e3..0000000
+++ /dev/null
@@ -1,70 +0,0 @@
-//
-// Class AliRsnAnalysisPhiKK
-//
-// 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 ALIRSNANALYSISPHIKK_H
-#define ALIRSNANALYSISPHIKK_H
-
-#include "TClonesArray.h"
-
-#include "AliRsnVAnalysisTaskSE.h"
-
-#include "AliRsnDaughter.h"
-#include "AliRsnMother.h"
-#include "AliRsnPairDef.h"
-#include "AliRsnEvent.h"
-#include "AliRsnCutSet.h"
-
-class AliRsnPIDDefESD;
-
-class AliRsnAnalysisPhiKK : public AliRsnVAnalysisTaskSE
-{
-  public:
-  
-    AliRsnAnalysisPhiKK(const char *name = "RSNphi", Bool_t useKine = kFALSE);
-    AliRsnAnalysisPhiKK(const AliRsnAnalysisPhiKK& copy);
-    AliRsnAnalysisPhiKK& operator=(const AliRsnAnalysisPhiKK& copy);
-    virtual ~AliRsnAnalysisPhiKK() {}
-
-    virtual void            RsnUserCreateOutputObjects();
-    virtual void            RsnUserExec(Option_t*);
-    virtual void            RsnTerminate(Option_t*);
-    virtual Bool_t          EventProcess();
-    
-    AliRsnCutSet*           GetEventCuts()          {return &fCutEvent;}
-    AliRsnCutSet*           GetCommonDaughterCuts() {return &fCutTrackCommon;}
-    AliRsnCutSet*           GetPosDaughterCuts()    {return &fCutTrackPos;}
-    AliRsnCutSet*           GetNegDaughterCuts()    {return &fCutTrackNeg;}
-    AliRsnCutSet*           GetMotherCuts()         {return &fCutPair;}
-    AliRsnPairDef*          GetPairDef()            {return &fPairDef;}
-    
-    static Bool_t           IsTruePair(AliRsnDaughter *d1, AliRsnDaughter *d2);
-    void                    AddFunction(AliRsnFunction* const fcn);
-    TList*                  GenerateHistograms();
-
-  private:
-  
-    AliRsnPairDef           fPairDef;           // resonance decay tree (fixed)
-    
-    AliRsnCutSet            fCutEvent;          // cut set for events
-    AliRsnCutSet            fCutTrackCommon;    // cut set for tracks (common)
-    AliRsnCutSet            fCutTrackPos;       // cut set for tracks (only pos)
-    AliRsnCutSet            fCutTrackNeg;       // cut set for tracks (only neg)
-    AliRsnCutSet            fCutPair;           // cut set for pairs
-
-    TClonesArray            fFuncPM;            // collection of functions for unlike-sign
-    TClonesArray            fFuncPP;            // collection of functions for like-sign ++
-    TClonesArray            fFuncMM;            // collection of functions for like-sign --
-    TClonesArray            fFuncTrue;          // collection of functions for unlike-sign true pairs
-    
-    TList                  *fOutList;           // list of output events
-
-    ClassDef(AliRsnAnalysisPhiKK, 1)
-};
-
-#endif
index e37b169..99b3726 100644 (file)
@@ -22,29 +22,29 @@ ClassImp(AliRsnAnalysisSE)
 
 //_____________________________________________________________________________
 AliRsnAnalysisSE::AliRsnAnalysisSE(const char *name, Bool_t useKine) :
-  AliRsnVAnalysisTaskSE(name, useKine),
-  fRsnAnalysisManager(),
-  fEventCuts("eventCuts", AliRsnCut::kEvent),
-  fOutList(0x0),
-  fZeroEventPercentWarning(100),
-  fUseZeroEventWarning(kTRUE)
+   AliRsnVAnalysisTaskSE(name, useKine),
+   fRsnAnalysisManager(),
+   fEventCuts("eventCuts", AliRsnCut::kEvent),
+   fOutList(0x0),
+   fZeroEventPercentWarning(100),
+   fUseZeroEventWarning(kTRUE)
 {
 //
 // Default constructor.
 // Defines another output slot for histograms/ntuples
 //
 
-  DefineOutput(2, TList::Class());
+   DefineOutput(2, TList::Class());
 }
 
 //_____________________________________________________________________________
 AliRsnAnalysisSE::AliRsnAnalysisSE(const AliRsnAnalysisSE& copy) :
-  AliRsnVAnalysisTaskSE(copy),
-  fRsnAnalysisManager(copy.fRsnAnalysisManager),
-  fEventCuts(copy.fEventCuts),
-  fOutList(0x0),
-  fZeroEventPercentWarning(copy.fZeroEventPercentWarning),
-  fUseZeroEventWarning(copy.fUseZeroEventWarning)
+   AliRsnVAnalysisTaskSE(copy),
+   fRsnAnalysisManager(copy.fRsnAnalysisManager),
+   fEventCuts(copy.fEventCuts),
+   fOutList(0x0),
+   fZeroEventPercentWarning(copy.fZeroEventPercentWarning),
+   fUseZeroEventWarning(copy.fUseZeroEventWarning)
 {
 //
 // Copy constructor.
@@ -58,15 +58,15 @@ AliRsnAnalysisSE& AliRsnAnalysisSE::operator=(const AliRsnAnalysisSE& copy)
 // Assigment operator.
 //
 
-  AliRsnVAnalysisTaskSE::operator=(copy);
-  
-  fRsnAnalysisManager = copy.fRsnAnalysisManager;
-  fEventCuts = copy.fEventCuts;
-  if (fOutList) fOutList->Clear();
-  fZeroEventPercentWarning = copy.fZeroEventPercentWarning;
-  fUseZeroEventWarning = copy.fUseZeroEventWarning;
-  
-  return (*this);
+   AliRsnVAnalysisTaskSE::operator=(copy);
+
+   fRsnAnalysisManager = copy.fRsnAnalysisManager;
+   fEventCuts = copy.fEventCuts;
+   if (fOutList) fOutList->Clear();
+   fZeroEventPercentWarning = copy.fZeroEventPercentWarning;
+   fUseZeroEventWarning = copy.fUseZeroEventWarning;
+
+   return (*this);
 }
 
 //_____________________________________________________________________________
@@ -79,12 +79,12 @@ void AliRsnAnalysisSE::RsnUserCreateOutputObjects()
 // is then linked to the TList data member of this, which will contain all the output.
 //
 
-  if (!fOutList) fOutList = new TList;
-  fOutList->Clear();
-  
-  fRsnAnalysisManager.InitAllPairs(fOutList);
+   if (!fOutList) fOutList = new TList;
+   fOutList->Clear();
+
+   fRsnAnalysisManager.InitAllPairs(fOutList);
 
-  PostData(2, fOutList);
+   PostData(2, fOutList);
 }
 
 //_____________________________________________________________________________
@@ -96,12 +96,12 @@ void AliRsnAnalysisSE::RsnUserExec(Option_t*)
 // using 'reconstructed' or 'MonteCarlo' functions depending on MC-only flag.
 //
 
-  if (fMCOnly) 
-    fRsnAnalysisManager.ProcessAllPairsMC();
-  else 
-    fRsnAnalysisManager.ProcessAllPairs();
-  
-  PostData(2, fOutList);
+   if (fMCOnly)
+      fRsnAnalysisManager.ProcessAllPairsMC();
+   else
+      fRsnAnalysisManager.ProcessAllPairs();
+
+   PostData(2, fOutList);
 }
 
 //_____________________________________________________________________________
@@ -124,48 +124,44 @@ Bool_t AliRsnAnalysisSE::EventProcess()
 // omonyme function in mother class
 //
 
-  // initially, an event is expected to be bad
-  fTaskInfo.SetEventUsed(kFALSE);
-  
-  // check #1: number of tracks in event (reject empty events)
-  Int_t    ntracks = fRsnEvent.GetMultiplicity();
-  Double_t zeroEventPercent = 0.0;
-  if (ntracks < 1) 
-  {
-    // if using the checker for amount of empty events, update it
-    if (fUseZeroEventWarning)
-    {
-      TH1I *hist = (TH1I*)fInfoList->FindObject(fTaskInfo.GetEventHistogramName());
-      if (hist)
-      {
-        if (hist->Integral() > 1) zeroEventPercent = (Double_t)hist->GetBinContent(1) / hist->Integral() * 100;
-        if ((zeroEventPercent > fZeroEventPercentWarning) && (fEntry > 100))
-          AliWarning(Form("%3.2f%% Events are with zero tracks (CurrentEvent=%d)!!!", zeroEventPercent, fEntry));
+   // initially, an event is expected to be bad
+   fTaskInfo.SetEventUsed(kFALSE);
+
+   // check #1: number of tracks in event (reject empty events)
+   Int_t    ntracks = fRsnEvent.GetMultiplicity();
+   Double_t zeroEventPercent = 0.0;
+   if (ntracks < 1) {
+      // if using the checker for amount of empty events, update it
+      if (fUseZeroEventWarning) {
+         TH1I *hist = (TH1I*)fInfoList->FindObject(fTaskInfo.GetEventHistogramName());
+         if (hist) {
+            if (hist->Integral() > 1) zeroEventPercent = (Double_t)hist->GetBinContent(1) / hist->Integral() * 100;
+            if ((zeroEventPercent > fZeroEventPercentWarning) && (fEntry > 100))
+               AliWarning(Form("%3.2f%% Events are with zero tracks (CurrentEvent=%d)!!!", zeroEventPercent, fEntry));
+         }
       }
-    }
-    
-    // empty events are rejected by default
-    fTaskInfo.SetEventUsed(kFALSE);
-    AliDebug(AliLog::kDebug, "Empty event. Skipping...");
-    return kFALSE;
-  }
-
-  // check the event cuts and update the info data accordingly
-  // events not passing the cuts must be rejected
-  if (!fEventCuts.IsSelected(&fRsnEvent))
-  {
-    fTaskInfo.SetEventUsed(kFALSE);
-    return kFALSE;
-  }
-  
-  // if we reach this point, cuts were passed;
-  // then additional operations can be done
-  
-  // find leading particle (without any PID/momentum restriction)
-  fRsnEvent.SelectLeadingParticle(0);
-  
-  // final return value is positive
-  // but call the mother class method which updates info object
-  fTaskInfo.SetEventUsed(kTRUE);
-  return AliRsnVAnalysisTaskSE::EventProcess();
+
+      // empty events are rejected by default
+      fTaskInfo.SetEventUsed(kFALSE);
+      AliDebug(AliLog::kDebug, "Empty event. Skipping...");
+      return kFALSE;
+   }
+
+   // check the event cuts and update the info data accordingly
+   // events not passing the cuts must be rejected
+   if (!fEventCuts.IsSelected(&fRsnEvent)) {
+      fTaskInfo.SetEventUsed(kFALSE);
+      return kFALSE;
+   }
+
+   // if we reach this point, cuts were passed;
+   // then additional operations can be done
+
+   // find leading particle (without any PID/momentum restriction)
+   fRsnEvent.SelectLeadingParticle(0);
+
+   // final return value is positive
+   // but call the mother class method which updates info object
+   fTaskInfo.SetEventUsed(kTRUE);
+   return AliRsnVAnalysisTaskSE::EventProcess();
 }
index 0b3b51a..9493c46 100644 (file)
 
 class AliRsnPIDDefESD;
 
-class AliRsnAnalysisSE : public AliRsnVAnalysisTaskSE
-{
-  public:
-  
-    AliRsnAnalysisSE(const char *name = "AliRsnAnalysisSE", Bool_t useKine = kFALSE);
-    AliRsnAnalysisSE(const AliRsnAnalysisSE& copy);
-    AliRsnAnalysisSE& operator=(const AliRsnAnalysisSE& copy);
-    virtual ~AliRsnAnalysisSE() {}
-
-    virtual void            RsnUserCreateOutputObjects();
-    virtual void            RsnUserExec(Option_t*);
-    virtual void            RsnTerminate(Option_t*);
-    virtual Bool_t          EventProcess();
-
-    AliRsnCutSet*           GetEventCuts()                           {return &fEventCuts;}
-    AliRsnAnalysisManager*  GetAnalysisManager()                     {return &fRsnAnalysisManager;}
-    void                    SetAnalysisManagerName(const char *name) {fRsnAnalysisManager.SetName(name);}
-
-    Double_t                GetZeroEventPercentWarning() const            {return fZeroEventPercentWarning;}
-    void                    SetZeroEventPercentWarning(Double_t val = 50) {fZeroEventPercentWarning = val;}
-    void                    UseZeroEventWarning(Bool_t b = kTRUE)         {fUseZeroEventWarning = b;}
-
-  private:
-
-    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)
-
-    ClassDef(AliRsnAnalysisSE, 1)
+class AliRsnAnalysisSE : public AliRsnVAnalysisTaskSE {
+public:
+
+   AliRsnAnalysisSE(const char *name = "AliRsnAnalysisSE", Bool_t useKine = kFALSE);
+   AliRsnAnalysisSE(const AliRsnAnalysisSE& copy);
+   AliRsnAnalysisSE& operator=(const AliRsnAnalysisSE& copy);
+   virtual ~AliRsnAnalysisSE() {}
+
+   virtual void            RsnUserCreateOutputObjects();
+   virtual void            RsnUserExec(Option_t*);
+   virtual void            RsnTerminate(Option_t*);
+   virtual Bool_t          EventProcess();
+
+   AliRsnCutSet*           GetEventCuts()                           {return &fEventCuts;}
+   AliRsnAnalysisManager*  GetAnalysisManager()                     {return &fRsnAnalysisManager;}
+   void                    SetAnalysisManagerName(const char *name) {fRsnAnalysisManager.SetName(name);}
+
+   Double_t                GetZeroEventPercentWarning() const            {return fZeroEventPercentWarning;}
+   void                    SetZeroEventPercentWarning(Double_t val = 50) {fZeroEventPercentWarning = val;}
+   void                    UseZeroEventWarning(Bool_t b = kTRUE)         {fUseZeroEventWarning = b;}
+
+private:
+
+   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)
+
+   ClassDef(AliRsnAnalysisSE, 1)
 };
 
 #endif
index f3cb77a..b2681aa 100644 (file)
@@ -22,29 +22,29 @@ ClassImp(AliRsnAnalysisTask)
 
 //_____________________________________________________________________________
 AliRsnAnalysisTask::AliRsnAnalysisTask(const char *name, Bool_t useKine) :
-  AliRsnVAnalysisTask(name, useKine),
-  fRsnAnalysisManager(),
-  fEventCuts("eventCuts", AliRsnCut::kEvent),
-  fOutList(0x0),
-  fZeroEventPercentWarning(100),
-  fUseZeroEventWarning(kTRUE)
+   AliRsnVAnalysisTask(name, useKine),
+   fRsnAnalysisManager(),
+   fEventCuts("eventCuts", AliRsnCut::kEvent),
+   fOutList(0x0),
+   fZeroEventPercentWarning(100),
+   fUseZeroEventWarning(kTRUE)
 {
 //
 // Default constructor.
 // Defines another output slot for histograms/ntuples
 //
 
-  DefineOutput(2, TList::Class());
+   DefineOutput(2, TList::Class());
 }
 
 //_____________________________________________________________________________
 AliRsnAnalysisTask::AliRsnAnalysisTask(const AliRsnAnalysisTask& copy) :
-  AliRsnVAnalysisTask(copy),
-  fRsnAnalysisManager(copy.fRsnAnalysisManager),
-  fEventCuts(copy.fEventCuts),
-  fOutList(0x0),
-  fZeroEventPercentWarning(copy.fZeroEventPercentWarning),
-  fUseZeroEventWarning(copy.fUseZeroEventWarning)
+   AliRsnVAnalysisTask(copy),
+   fRsnAnalysisManager(copy.fRsnAnalysisManager),
+   fEventCuts(copy.fEventCuts),
+   fOutList(0x0),
+   fZeroEventPercentWarning(copy.fZeroEventPercentWarning),
+   fUseZeroEventWarning(copy.fUseZeroEventWarning)
 {
 //
 // Copy constructor.
@@ -58,15 +58,15 @@ AliRsnAnalysisTask& AliRsnAnalysisTask::operator=(const AliRsnAnalysisTask& copy
 // Assigment operator.
 //
 
-  AliRsnVAnalysisTask::operator=(copy);
-  
-  fRsnAnalysisManager = copy.fRsnAnalysisManager;
-  fEventCuts = copy.fEventCuts;
-  if (fOutList) fOutList->Clear();
-  fZeroEventPercentWarning = copy.fZeroEventPercentWarning;
-  fUseZeroEventWarning = copy.fUseZeroEventWarning;
-  
-  return (*this);
+   AliRsnVAnalysisTask::operator=(copy);
+
+   fRsnAnalysisManager = copy.fRsnAnalysisManager;
+   fEventCuts = copy.fEventCuts;
+   if (fOutList) fOutList->Clear();
+   fZeroEventPercentWarning = copy.fZeroEventPercentWarning;
+   fUseZeroEventWarning = copy.fUseZeroEventWarning;
+
+   return (*this);
 }
 
 //_____________________________________________________________________________
@@ -79,12 +79,12 @@ void AliRsnAnalysisTask::RsnUserCreateOutputObjects()
 // is then linked to the TList data member of this, which will contain all the output.
 //
 
-  if (!fOutList) fOutList = new TList;
-  fOutList->Clear();
-  
-  fRsnAnalysisManager.InitAllPairs(fOutList);
+   if (!fOutList) fOutList = new TList;
+   fOutList->Clear();
 
-  PostData(2, fOutList);
+   fRsnAnalysisManager.InitAllPairs(fOutList);
+
+   PostData(2, fOutList);
 }
 
 //_____________________________________________________________________________
@@ -95,27 +95,27 @@ void AliRsnAnalysisTask::RsnUserExec(Option_t*)
 // Recovers the input event and processes it with all included pair objects,
 // using 'reconstructed' or 'MonteCarlo' functions depending on MC-only flag.
 //
-       if (IsMixing()) return;
-  
-       if (fMCOnly) 
-    fRsnAnalysisManager.ProcessAllPairsMC();
-  else 
-    fRsnAnalysisManager.ProcessAllPairs();
+   if (IsMixing()) return;
+
+   if (fMCOnly)
+      fRsnAnalysisManager.ProcessAllPairsMC();
+   else
+      fRsnAnalysisManager.ProcessAllPairs();
 
-       PostData(2, fOutList);
+   PostData(2, fOutList);
 }
 
 void AliRsnAnalysisTask::RsnUserExecMix(Option_t* /*opt*/)
 {
-  if (!IsMixing()) return;
-  AliDebug(AliLog::kDebug,Form("RSN Mixing %lld %d [%lld,%lld] %d",fMixedEH->CurrentEntry(),fMixedEH->NumberMixed(),fMixedEH->CurrentEntryMain(),fMixedEH->CurrentEntryMix(),fMixedEH->CurrentBinIndex()));
-  
-  // the virtual class has already sorted tracks in the PID index
-  // so we need here just to call the execution of analysis
-  if (!fMCOnly) 
-               fRsnAnalysisManager.ProcessAllPairs();
-  else 
-               fRsnAnalysisManager.ProcessAllPairsMC();
+   if (!IsMixing()) return;
+   AliDebug(AliLog::kDebug, Form("RSN Mixing %lld %d [%lld,%lld] %d", fMixedEH->CurrentEntry(), fMixedEH->NumberMixed(), fMixedEH->CurrentEntryMain(), fMixedEH->CurrentEntryMix(), fMixedEH->CurrentBinIndex()));
+
+   // the virtual class has already sorted tracks in the PID index
+   // so we need here just to call the execution of analysis
+   if (!fMCOnly)
+      fRsnAnalysisManager.ProcessAllPairs();
+   else
+      fRsnAnalysisManager.ProcessAllPairsMC();
 }
 
 //_____________________________________________________________________________
@@ -138,50 +138,46 @@ Bool_t AliRsnAnalysisTask::EventProcess()
 // omonyme function in mother class
 //
 
-  // initially, an event is expected to be bad
-  fTaskInfo.SetEventUsed(kFALSE);
-       
-       if (!AliRsnVAnalysisTask::EventProcess()) return kFALSE;
-  
-  // check #1: number of tracks in event (reject empty events)
-  Int_t    ntracks = fRsnEvent[0].GetMultiplicity();
-  Double_t zeroEventPercent = 0.0;
-  if (ntracks < 1) 
-  {
-    // if using the checker for amount of empty events, update it
-    if (fUseZeroEventWarning)
-    {
-      TH1I *hist = (TH1I*)fInfoList->FindObject(fTaskInfo.GetEventHistogramName());
-      if (hist)
-      {
-        if (hist->Integral() > 1) zeroEventPercent = (Double_t)hist->GetBinContent(1) / hist->Integral() * 100;
-        if ((zeroEventPercent > fZeroEventPercentWarning) && (fEntry > 100))
-          AliWarning(Form("%3.2f%% Events are with zero tracks (CurrentEvent=%d)!!!", zeroEventPercent, fEntry));
+   // initially, an event is expected to be bad
+   fTaskInfo.SetEventUsed(kFALSE);
+
+   if (!AliRsnVAnalysisTask::EventProcess()) return kFALSE;
+
+   // check #1: number of tracks in event (reject empty events)
+   Int_t    ntracks = fRsnEvent[0].GetMultiplicity();
+   Double_t zeroEventPercent = 0.0;
+   if (ntracks < 1) {
+      // if using the checker for amount of empty events, update it
+      if (fUseZeroEventWarning) {
+         TH1I *hist = (TH1I*)fInfoList->FindObject(fTaskInfo.GetEventHistogramName());
+         if (hist) {
+            if (hist->Integral() > 1) zeroEventPercent = (Double_t)hist->GetBinContent(1) / hist->Integral() * 100;
+            if ((zeroEventPercent > fZeroEventPercentWarning) && (fEntry > 100))
+               AliWarning(Form("%3.2f%% Events are with zero tracks (CurrentEvent=%d)!!!", zeroEventPercent, fEntry));
+         }
       }
-    }
-    
-    // empty events are rejected by default
-    fTaskInfo.SetEventUsed(kFALSE);
-    AliDebug(AliLog::kDebug, "Empty event. Skipping...");
-    return kFALSE;
-  }
-
-  // check the event cuts and update the info data accordingly
-  // events not passing the cuts must be rejected
-  if (!fEventCuts.IsSelected(&fRsnEvent[0]))
-  {
-    fTaskInfo.SetEventUsed(kFALSE);
-    return kFALSE;
-  }
-  
-  // if we reach this point, cuts were passed;
-  // then additional operations can be done
-  
-  // find leading particle (without any PID/momentum restriction)
-  fRsnEvent[0].SelectLeadingParticle(0);
-  
-  // final return value is positive
-  // but call the mother class method which updates info object
-  fTaskInfo.SetEventUsed(kTRUE);
-  return kTRUE;
+
+      // empty events are rejected by default
+      fTaskInfo.SetEventUsed(kFALSE);
+      AliDebug(AliLog::kDebug, "Empty event. Skipping...");
+      return kFALSE;
+   }
+
+   // check the event cuts and update the info data accordingly
+   // events not passing the cuts must be rejected
+   if (!fEventCuts.IsSelected(&fRsnEvent[0])) {
+      fTaskInfo.SetEventUsed(kFALSE);
+      return kFALSE;
+   }
+
+   // if we reach this point, cuts were passed;
+   // then additional operations can be done
+
+   // find leading particle (without any PID/momentum restriction)
+   fRsnEvent[0].SelectLeadingParticle(0);
+
+   // final return value is positive
+   // but call the mother class method which updates info object
+   fTaskInfo.SetEventUsed(kTRUE);
+   return kTRUE;
 }
index 21bfb3c..3c71c38 100644 (file)
 
 class AliRsnPIDDefESD;
 
-class AliRsnAnalysisTask : public AliRsnVAnalysisTask
-{
-  public:
-  
-    AliRsnAnalysisTask(const char *name = "AliRsnAnalysisTask", Bool_t useKine = kFALSE);
-    AliRsnAnalysisTask(const AliRsnAnalysisTask& copy);
-    AliRsnAnalysisTask& operator=(const AliRsnAnalysisTask& copy);
-    virtual ~AliRsnAnalysisTask() {}
-
-    virtual void            RsnUserCreateOutputObjects();
-    virtual void            RsnUserExec(Option_t*);
-    virtual void            RsnUserExecMix(Option_t* );
-    virtual void            RsnTerminate(Option_t*);
-    virtual Bool_t          EventProcess();
-
-    AliRsnCutSet*           GetEventCuts()                           {return &fEventCuts;}
-    AliRsnAnalysisManager*  GetAnalysisManager()                     {return &fRsnAnalysisManager;}
-    void                    SetAnalysisManagerName(const char *name) {fRsnAnalysisManager.SetName(name);}
-
-    Double_t                GetZeroEventPercentWarning() const            {return fZeroEventPercentWarning;}
-    void                    SetZeroEventPercentWarning(Double_t val = 50) {fZeroEventPercentWarning = val;}
-    void                    UseZeroEventWarning(Bool_t b = kTRUE)         {fUseZeroEventWarning = b;}
-
-  private:
-
-    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)
-
-    ClassDef(AliRsnAnalysisTask, 1)
+class AliRsnAnalysisTask : public AliRsnVAnalysisTask {
+public:
+
+   AliRsnAnalysisTask(const char *name = "AliRsnAnalysisTask", Bool_t useKine = kFALSE);
+   AliRsnAnalysisTask(const AliRsnAnalysisTask& copy);
+   AliRsnAnalysisTask& operator=(const AliRsnAnalysisTask& copy);
+   virtual ~AliRsnAnalysisTask() {}
+
+   virtual void            RsnUserCreateOutputObjects();
+   virtual void            RsnUserExec(Option_t*);
+   virtual void            RsnUserExecMix(Option_t*);
+   virtual void            RsnTerminate(Option_t*);
+   virtual Bool_t          EventProcess();
+
+   AliRsnCutSet*           GetEventCuts()                           {return &fEventCuts;}
+   AliRsnAnalysisManager*  GetAnalysisManager()                     {return &fRsnAnalysisManager;}
+   void                    SetAnalysisManagerName(const char *name) {fRsnAnalysisManager.SetName(name);}
+
+   Double_t                GetZeroEventPercentWarning() const            {return fZeroEventPercentWarning;}
+   void                    SetZeroEventPercentWarning(Double_t val = 50) {fZeroEventPercentWarning = val;}
+   void                    UseZeroEventWarning(Bool_t b = kTRUE)         {fUseZeroEventWarning = b;}
+
+private:
+
+   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)
+
+   ClassDef(AliRsnAnalysisTask, 1)
 };
 
 #endif
index c2a4ba5..17a67f2 100644 (file)
@@ -23,14 +23,14 @@ ClassImp(AliRsnCut)
 
 //______________________________________________________________________________
 AliRsnCut::AliRsnCut(const char *name, RSNTARGET target) :
-  AliRsnTarget(name, target),
-  fMinI(0),
-  fMaxI(0),
-  fMinD(0.),
-  fMaxD(0.),
-  fCutValueI(0),
-  fCutValueD(0.0),
-  fCutResult(kTRUE)
+   AliRsnTarget(name, target),
+   fMinI(0),
+   fMaxI(0),
+   fMinD(0.),
+   fMaxD(0.),
+   fCutValueI(0),
+   fCutValueD(0.0),
+   fCutResult(kTRUE)
 {
 //
 // Default constructor.
@@ -40,14 +40,14 @@ AliRsnCut::AliRsnCut(const char *name, RSNTARGET target) :
 //______________________________________________________________________________
 AliRsnCut::AliRsnCut
 (const char *name, RSNTARGET target, Int_t imin, Int_t imax, Double_t dmin, Double_t dmax) :
-  AliRsnTarget(name, target),
-  fMinI(imin),
-  fMaxI(imax),
-  fMinD(dmin),
-  fMaxD(dmax),
-  fCutValueI(0),
-  fCutValueD(0.0),
-  fCutResult(kTRUE)
+   AliRsnTarget(name, target),
+   fMinI(imin),
+   fMaxI(imax),
+   fMinD(dmin),
+   fMaxD(dmax),
+   fCutValueI(0),
+   fCutValueD(0.0),
+   fCutResult(kTRUE)
 {
 //
 // Constructor with arguments.
@@ -58,14 +58,14 @@ AliRsnCut::AliRsnCut
 //______________________________________________________________________________
 AliRsnCut::AliRsnCut
 (const char *name, RSNTARGET target, Double_t dmin, Double_t dmax, Int_t imin, Int_t imax) :
-  AliRsnTarget(name, target),
-  fMinI(imin),
-  fMaxI(imax),
-  fMinD(dmin),
-  fMaxD(dmax),
-  fCutValueI(0),
-  fCutValueD(0.0),
-  fCutResult(kTRUE)
+   AliRsnTarget(name, target),
+   fMinI(imin),
+   fMaxI(imax),
+   fMinD(dmin),
+   fMaxD(dmax),
+   fCutValueI(0),
+   fCutValueD(0.0),
+   fCutResult(kTRUE)
 {
 //
 // Constructor with arguments.
@@ -75,14 +75,14 @@ AliRsnCut::AliRsnCut
 
 //______________________________________________________________________________
 AliRsnCut::AliRsnCut(const AliRsnCut& copy) :
-  AliRsnTarget(copy),
-  fMinI(copy.fMinI),
-  fMaxI(copy.fMaxI),
-  fMinD(copy.fMinD),
-  fMaxD(copy.fMaxD),
-  fCutValueI(copy.fCutValueI),
-  fCutValueD(copy.fCutValueD),
-  fCutResult(copy.fCutResult)
+   AliRsnTarget(copy),
+   fMinI(copy.fMinI),
+   fMaxI(copy.fMaxI),
+   fMinD(copy.fMinD),
+   fMaxD(copy.fMaxD),
+   fCutValueI(copy.fCutValueI),
+   fCutValueD(copy.fCutValueD),
+   fCutResult(copy.fCutResult)
 {
 //
 // Copy constructor.
@@ -98,16 +98,16 @@ AliRsnCut& AliRsnCut::operator=(const AliRsnCut& copy)
 // Don't duplicate memory occupancy for pointer
 //
 
-  AliRsnTarget::operator=(copy);
-  
-  fMinI      = copy.fMinI;
-  fMaxI      = copy.fMaxI;
-  fMinD      = copy.fMinD;
-  fMaxD      = copy.fMaxD;
-  fCutValueI = copy.fCutValueI;
-  fCutValueD = copy.fCutValueD;
+   AliRsnTarget::operator=(copy);
 
-  return (*this);
+   fMinI      = copy.fMinI;
+   fMaxI      = copy.fMaxI;
+   fMinD      = copy.fMinD;
+   fMaxD      = copy.fMaxD;
+   fCutValueI = copy.fCutValueI;
+   fCutValueD = copy.fCutValueD;
+
+   return (*this);
 }
 
 //______________________________________________________________________________
@@ -120,8 +120,8 @@ Bool_t AliRsnCut::IsSelected(TObject* /*object*/)
 // which must return kTRUE if the cut is passed, and kFALSE otherwise.
 //
 
-  AliWarning("This virtual function must be implemented properly");
-  return kTRUE;
+   AliWarning("This virtual function must be implemented properly");
+   return kTRUE;
 }
 
 //______________________________________________________________________________
@@ -132,18 +132,18 @@ Bool_t AliRsnCut::OkValueI()
 // with a reference integer value to which it must be equal.
 //
 
-  // eval result
-  fCutResult = (fCutValueI == fMinI);
-  
-  // print debug message
-  AliDebug(AliLog::kDebug + 2, "=== 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 value    : %d", fMinI));
-  AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-  AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ================================");
-  
-  return fCutResult;
+   // eval result
+   fCutResult = (fCutValueI == fMinI);
+
+   // print debug message
+   AliDebug(AliLog::kDebug + 2, "=== 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 value    : %d", fMinI));
+   AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+   AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ================================");
+
+   return fCutResult;
 }
 
 //______________________________________________________________________________
@@ -154,18 +154,18 @@ Bool_t AliRsnCut::OkValueD()
 // 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 + 2, "=== 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 value    : %f", fMinD));
-  AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-  AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ================================");
-  
-  return fCutResult;
+   // eval result
+   fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
+
+   // print debug message
+   AliDebug(AliLog::kDebug + 2, "=== 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 value    : %f", fMinD));
+   AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+   AliDebug(AliLog::kDebug + 2, "=== END CUT DEBUG ================================");
+
+   return fCutResult;
 }
 
 //______________________________________________________________________________
@@ -177,18 +177,18 @@ Bool_t AliRsnCut::OkRangeI()
 // Then, the cut result is kTRUE if the cut value is inside this range.
 //
 
-  // eval result
-  fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
-  
-  // print debug message
-  AliDebug(AliLog::kDebug + 2, "=== 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 + 2, "=== END CUT DEBUG ================================");
-  
-  return fCutResult;
+   // eval result
+   fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
+
+   // print debug message
+   AliDebug(AliLog::kDebug + 2, "=== 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 + 2, "=== END CUT DEBUG ================================");
+
+   return fCutResult;
 }
 
 //______________________________________________________________________________
@@ -200,18 +200,18 @@ Bool_t AliRsnCut::OkRangeD()
 // 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 + 2, "=== 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 + 2, "=== END CUT DEBUG ================================");
+   // eval result
+   fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
+
+   // print debug message
+   AliDebug(AliLog::kDebug + 2, "=== 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 + 2, "=== END CUT DEBUG ================================");
 
-  return fCutResult;
+   return fCutResult;
 }
 
 //______________________________________________________________________________
@@ -222,10 +222,10 @@ void AliRsnCut::Print(Option_t*) const
 // and print some useful info about the cut general parameters.
 //
 
-  AliInfo("=== CUT DETAILS ====================================");
-  AliInfo(Form("Cut name     : [%s]", GetName()));
-  AliInfo(Form("Cut target   : [%s]", GetTargetTypeName()));
-  AliInfo(Form("Cut edges [D]: [%f - %f]", fMinD, fMaxD));
-  AliInfo(Form("Cut edges [I]: [%d - %d]", fMinI, fMaxI));
-  AliInfo("====================================================");
+   AliInfo("=== CUT DETAILS ====================================");
+   AliInfo(Form("Cut name     : [%s]", GetName()));
+   AliInfo(Form("Cut target   : [%s]", GetTargetTypeName()));
+   AliInfo(Form("Cut edges [D]: [%f - %f]", fMinD, fMaxD));
+   AliInfo(Form("Cut edges [I]: [%d - %d]", fMinI, fMaxI));
+   AliInfo("====================================================");
 }
index c977193..a8f60a9 100644 (file)
 
 class AliRsnEvent;
 
-class AliRsnCut : public AliRsnTarget
-{
-  public:
-
-    AliRsnCut(const char *name = "dummy", RSNTARGET target = AliRsnTarget::kTargetTypes);
-    AliRsnCut(const char *name, RSNTARGET target, Int_t    imin, Int_t    imax=0 , Double_t dmin=0., Double_t dmax=0.);
-    AliRsnCut(const char *name, RSNTARGET target, Double_t dmin, Double_t dmax=0., Int_t    imin=0 , Int_t    imax=0 );
-    AliRsnCut(const AliRsnCut& copy);
-    AliRsnCut& operator=(const AliRsnCut& copy);
-    virtual ~AliRsnCut() { };
-    
-    Int_t            GetMinI()                  {return fMinI;}
-    Int_t            GetMaxI()                  {return fMaxI;}
-    Double_t         GetMinD()                  {return fMinD;}
-    Double_t         GetMaxD()                  {return fMaxD;}
-    Int_t            GetCutValueI()             {return fCutValueI;}
-    Double_t         GetCutValueD()             {return fCutValueD;}
-    Bool_t           GetCutResult()             {return fCutResult;}
-    
-    void             SetRangeI(Int_t    min, Int_t    max) {fMinI = min; fMaxI = max;}
-    void             SetRangeD(Double_t min, Double_t max) {fMinD = min; fMaxD = max;}
-
-    void             SetValueI(Int_t value)    {fMinI = value;}
-    void             SetValueD(Double_t value) {fMinD = value;}
-
-    Bool_t           OkValueI();
-    Bool_t           OkRangeI();
-    Bool_t           OkValueD();
-    Bool_t           OkRangeD();
-    
-    virtual Bool_t   IsSelected(TObject *object);
-    virtual void     Print(Option_t *opt = "") const;
-
-  protected:
-
-    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)
-    Double_t     fMinD;       //  lower edge of DOUBLE range or ref. value for DOUBLE CUT
-    Double_t     fMaxD;       //  upper edge of DOUBLE range (not used for value cuts)
-
-    Int_t        fCutValueI;  //  cut value INT
-    Double_t     fCutValueD;  //  cut value DOUBLE
-    
-    Bool_t       fCutResult;  //  tells if the cut is passed or not
-
-    ClassDef(AliRsnCut, 1)
+class AliRsnCut : public AliRsnTarget {
+public:
+
+   AliRsnCut(const char *name = "dummy", RSNTARGET target = AliRsnTarget::kTargetTypes);
+   AliRsnCut(const char *name, RSNTARGET target, Int_t    imin, Int_t    imax = 0 , Double_t dmin = 0., Double_t dmax = 0.);
+   AliRsnCut(const char *name, RSNTARGET target, Double_t dmin, Double_t dmax = 0., Int_t    imin = 0 , Int_t    imax = 0);
+   AliRsnCut(const AliRsnCut& copy);
+   AliRsnCut& operator=(const AliRsnCut& copy);
+   virtual ~AliRsnCut() { };
+
+   Int_t            GetMinI()                  {return fMinI;}
+   Int_t            GetMaxI()                  {return fMaxI;}
+   Double_t         GetMinD()                  {return fMinD;}
+   Double_t         GetMaxD()                  {return fMaxD;}
+   Int_t            GetCutValueI()             {return fCutValueI;}
+   Double_t         GetCutValueD()             {return fCutValueD;}
+   Bool_t           GetCutResult()             {return fCutResult;}
+
+   void             SetRangeI(Int_t    min, Int_t    max) {fMinI = min; fMaxI = max;}
+   void             SetRangeD(Double_t min, Double_t max) {fMinD = min; fMaxD = max;}
+
+   void             SetValueI(Int_t value)    {fMinI = value;}
+   void             SetValueD(Double_t value) {fMinD = value;}
+
+   Bool_t           OkValueI();
+   Bool_t           OkRangeI();
+   Bool_t           OkValueD();
+   Bool_t           OkRangeD();
+
+   virtual Bool_t   IsSelected(TObject *object);
+   virtual void     Print(Option_t *opt = "") const;
+
+protected:
+
+   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)
+   Double_t     fMinD;       //  lower edge of DOUBLE range or ref. value for DOUBLE CUT
+   Double_t     fMaxD;       //  upper edge of DOUBLE range (not used for value cuts)
+
+   Int_t        fCutValueI;  //  cut value INT
+   Double_t     fCutValueD;  //  cut value DOUBLE
+
+   Bool_t       fCutResult;  //  tells if the cut is passed or not
+
+   ClassDef(AliRsnCut, 1)
 };
 
 #endif
diff --git a/PWG2/RESONANCES/AliRsnCutAOD2010.cxx b/PWG2/RESONANCES/AliRsnCutAOD2010.cxx
deleted file mode 100644 (file)
index fd639de..0000000
+++ /dev/null
@@ -1,376 +0,0 @@
-//
-// Class AliRsnCutAOD2010
-//
-// 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 <TBits.h>
-
-#include "AliESDtrack.h"
-#include "AliAODTrack.h"
-
-#include "AliRsnEvent.h"
-#include "AliRsnDaughter.h"
-#include "AliRsnCutAOD2010.h"
-
-ClassImp(AliRsnCutAOD2010)
-
-
-//_________________________________________________________________________________________________
-AliRsnCutAOD2010::AliRsnCutAOD2010(const char *name, Bool_t isMC) :
-  AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
-
-  fIsMC(kFALSE),
-  fCheckITS(kTRUE),
-  fCheckTPC(kTRUE),
-  fCheckTOF(kTRUE),
-  fUseGlobal(kTRUE),
-  fUseITSSA(kTRUE),
-  
-  fMaxEta(1E6),
-    
-  fPIDtype(AliPID::kKaon),
-  
-  fTPCminNclusters(70),
-  fTPCmaxChi2(4.0),
-  fTPCmaxNSigmaDCA(7.0),
-  fTPClowBand(5.0),
-  fTPChighBand(3.0),
-  fTPClowLimit(0.35),
-  
-  fITSminNclusters(4),
-  fITSmaxChi2(2.5),
-  fITSmaxNSigmaDCA(7.0),
-  fITSband(3.0),
-  
-  fTOFlowLimit(-2.5),
-  fTOFhighLimit(3.5),
-  
-  fPID()
-{
-//
-// Default constructor.
-// Sets all parameters to the currently used values, and requires
-// to know if we are running on data or MonteCarlo to set some others.
-//
-
-  fTPCparamDCA[0] = 0.0050;
-  fTPCparamDCA[1] = 0.0070;
-  fTPCparamDCA[2] = 1.0000;
-  
-  fITSparamDCA[0] = 0.0085;
-  fITSparamDCA[1] = 0.0026;
-  fITSparamDCA[2] = 1.5500;
-  
-  SetMC(isMC);
-}
-
-//_________________________________________________________________________________________________
-AliRsnCutAOD2010::AliRsnCutAOD2010
-(const AliRsnCutAOD2010& copy) :
-  AliRsnCut(copy),
-  
-  fIsMC(copy.fIsMC),
-  fCheckITS(copy.fCheckITS),
-  fCheckTPC(copy.fCheckTPC),
-  fCheckTOF(copy.fCheckTOF),
-  fUseGlobal(copy.fUseGlobal),
-  fUseITSSA(copy.fUseITSSA),
-  
-  fMaxEta(copy.fMaxEta),
-  
-  fPIDtype(copy.fPIDtype),
-  
-  fTPCminNclusters(copy.fTPCminNclusters),
-  fTPCmaxChi2(copy.fTPCmaxChi2),
-  fTPCmaxNSigmaDCA(copy.fTPCmaxNSigmaDCA),
-  fTPClowBand(copy.fTPClowBand),
-  fTPChighBand(copy.fTPChighBand),
-  fTPClowLimit(copy.fTPClowLimit),
-  
-  fITSminNclusters(copy.fITSminNclusters),
-  fITSmaxChi2(copy.fITSmaxChi2),
-  fITSmaxNSigmaDCA(copy.fITSmaxNSigmaDCA),
-  fITSband(copy.fITSband),
-  
-  fTOFlowLimit(copy.fTOFlowLimit),
-  fTOFhighLimit(copy.fTOFhighLimit),
-  
-  fPID(copy.fPID)
-{
-//
-// Copy constructor
-//
-
-  Int_t i = 0;
-  for (i = 0; i < 3; i++) 
-  {
-    fTPCparamDCA[i] = copy.fTPCparamDCA[i];
-    fITSparamDCA[i] = copy.fITSparamDCA[i];
-  }
-}
-
-//_________________________________________________________________________________________________
-void AliRsnCutAOD2010::SetMC(Bool_t yn)
-{
-//
-// Sets some parameters depending on MC or dataanalysis
-//
-  
-  fIsMC = yn;
-  
-  if (fIsMC)
-  {
-    AliDebug(AliLog::kDebug + 2, "Setting for MC");
-    fPID.GetTPCResponse().SetBetheBlochParameters(2.15898 / 50.0, 1.75295E1, 3.40030E-9, 1.96178, 3.91720);
-  }
-  else
-  {
-    AliDebug(AliLog::kDebug + 2, "Setting for DATA");
-    fPID.GetTPCResponse().SetBetheBlochParameters(1.41543 / 50.0, 2.63394E1, 5.0411E-11, 2.12543, 4.88663);
-  }
-  
-  AliITSPIDResponse itsrsp(fIsMC);
-  fPID.GetITSResponse() = itsrsp;
-}
-
-//_________________________________________________________________________________________________
-Bool_t AliRsnCutAOD2010::IsSelected(TObject *object)
-{
-//
-// Cut checker.
-//
-
-  // coherence check: require an AOD track
-  AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(object);
-  if (!daughter) return kFALSE;
-  AliAODTrack *track = daughter->GetRefAODtrack();
-  if (!track) return kFALSE;
-  
-  // step #0: check presence of an SPD cluster
-  Int_t nITS = 0, nSPD = 0;
-  nSPD  = TESTBIT(track->GetITSClusterMap(), 0);
-  nSPD += TESTBIT(track->GetITSClusterMap(), 1);
-  nITS  = track->GetITSNcls() - nSPD;
-  if (nSPD <= 0)
-  {
-    AliDebug(AliLog::kDebug + 2, "No SPD clusters in this track. Rejected");
-    return kFALSE;
-  }
-
-  // step #1: check status flags and reject track if it does not match any possibility
-  Bool_t isTPC, isTOF;
-  if (!track->IsOn(AliESDtrack::kTPCin) && track->IsOn(AliESDtrack::kITSrefit) && (!track->IsOn(AliESDtrack::kITSpureSA)))
-  {
-    isTPC = kFALSE;
-    isTOF = kFALSE;
-    if (!fUseITSSA)
-    {
-      AliDebug(AliLog::kDebug + 2, "ITS standalone not used. Rejected");
-      return kFALSE;
-    }
-  }
-  else if (track->IsOn(AliESDtrack::kTPCin) && track->IsOn(AliESDtrack::kTPCrefit) && track->IsOn(AliESDtrack::kITSrefit))
-  {
-    isTPC = kTRUE;
-    if (!fUseGlobal)
-    {
-      AliDebug(AliLog::kDebug + 2, "ITS standalone not used. Rejected");
-      return kFALSE;
-    }
-    if (track->IsOn(AliESDtrack::kTOFout) && track->IsOn(AliESDtrack::kTIME))
-      isTOF = kTRUE;
-    else
-      isTOF = kFALSE;
-  }
-  else
-  {
-    AliDebug(AliLog::kDebug + 2, "Track is not either a TPC track or a ITS standalone. Rejected");
-    return kFALSE;
-  }
-  
-  // step #2: check number of clusters
-  if (isTPC)
-  {
-    if (track->GetTPCNcls() < fTPCminNclusters)
-    {
-      AliDebug(AliLog::kDebug + 2, "Too few clusters. Rejected");
-      return kFALSE;
-    }
-  }
-  else
-  {
-    if (track->GetITSNcls() < fITSminNclusters)
-    {
-      AliDebug(AliLog::kDebug + 2, "Too few clusters. Rejected");
-      return kFALSE;
-    }
-  }
-  
-  // step #3: check chi square
-  if (isTPC)
-  {
-    if (track->Chi2perNDF() > fTPCmaxChi2)
-    {
-      AliDebug(AliLog::kDebug + 2, "Bad chi2. Rejected");
-      return kFALSE;
-    }
-  }
-  else
-  {
-    if (track->Chi2perNDF() > fITSmaxChi2)
-    {
-      AliDebug(AliLog::kDebug + 2, "Bad chi2. Rejected");
-      return kFALSE;
-    }
-  }
-  
-  // step #4: reject kink daughters
-  AliAODVertex *vertex = track->GetProdVertex();
-  if (isTPC && vertex != 0x0)
-  {
-    if (vertex->GetType() == AliAODVertex::kKink)
-    {
-      AliDebug(AliLog::kDebug + 2, "Kink daughter. Rejected");
-      return kFALSE;
-    }
-  }
-  
-  // step #5: DCA cut (transverse)
-  Double_t dz[2], cov[3], sigmaDCA = 0.0, nsigma = 0.0;
-  vertex = AliRsnTarget::GetCurrentEvent()->GetRefAOD()->GetPrimaryVertex();
-  if (!vertex)
-  {
-    AliDebug(AliLog::kDebug + 2, "NULL vertex");
-    return kFALSE;
-  }
-  if (!track->PropagateToDCA(vertex, AliRsnTarget::GetCurrentEvent()->GetRefAOD()->GetMagneticField(), kVeryBig, dz, cov))
-  {
-    AliDebug(AliLog::kDebug + 2, "Failed propagation to vertex");
-    return kFALSE;
-  }
-  // compute the pt-dependent sigma
-  if (isTPC)
-  {
-    sigmaDCA = fTPCparamDCA[0] + fTPCparamDCA[1] / TMath::Power(track->Pt(), fTPCparamDCA[2]);
-    nsigma = fTPCmaxNSigmaDCA;
-  }
-  else 
-  {
-    sigmaDCA = fITSparamDCA[0] + fITSparamDCA[1] / TMath::Power(track->Pt(), fITSparamDCA[2]);
-    nsigma = fITSmaxNSigmaDCA;
-  }
-  // check the DCA
-  if (dz[0] > nsigma * sigmaDCA)
-  {
-    AliDebug(AliLog::kDebug + 2, "Excceeded cut in DCA. Rejected");
-    return kFALSE;
-  }
-  
-  // step #6: check eta range
-  if (TMath::Abs(track->Eta()) >= fMaxEta)
-  {
-    AliDebug(AliLog::kDebug + 2, "Outside ETA acceptance");
-    return kFALSE;
-  }
-  
-  // step #7: PID cuts
-  if (isTPC)
-  {
-    if (fCheckTPC)
-    {
-      AliAODPid *pidObj    = track->GetDetPid();
-      Double_t   mom       = pidObj->GetTPCmomentum();
-      Double_t   nsigmaTPC = fPID.NumberOfSigmasTPC(track, fPIDtype);
-      Double_t   bandTPC   = fTPChighBand;
-      if (mom <= fTPClowLimit) bandTPC = fTPClowBand;
-      if (TMath::Abs(nsigmaTPC) > bandTPC) 
-      {
-        AliDebug(AliLog::kDebug + 2, "Bad TPC PID. Rejected");
-        return kFALSE;
-      }
-      else
-      {
-        AliDebug(AliLog::kDebug + 2, "Good TPC PID");
-        if (fCheckTOF && isTOF)
-        {
-          Double_t nsigmaTOF = (Double_t)fPID.NumberOfSigmasTOF(track, fPIDtype);
-          if (nsigmaTOF < fTOFlowLimit || nsigmaTOF > fTOFhighLimit)
-          {
-            AliDebug(AliLog::kDebug + 2, "Bad TOF PID. Rejected");
-            return kFALSE;
-          }
-          else
-          {
-            AliDebug(AliLog::kDebug + 2, "Good TOF PID. Accepted");
-            return kFALSE;
-          }
-        }
-        else
-        {
-          AliDebug(AliLog::kDebug + 2, "TOF not checked. Accepted");
-          return kTRUE;
-        }
-      }
-    }
-    else
-    {
-      if (fCheckTOF && isTOF)
-      {
-        Double_t nsigmaTOF = (Double_t)fPID.NumberOfSigmasTOF(track, fPIDtype);
-        if (nsigmaTOF < fTOFlowLimit || nsigmaTOF > fTOFhighLimit)
-        {
-          AliDebug(AliLog::kDebug + 2, "Bad TOF PID. Rejected");
-          return kFALSE;
-        }
-        else
-        {
-          AliDebug(AliLog::kDebug + 2, "Good TOF PID. Accepted");
-          return kFALSE;
-        }
-      }
-      else
-      {
-        AliDebug(AliLog::kDebug + 2, "No PID checked. Accepted");
-        return kTRUE;
-      }
-    }
-  }
-  else
-  {
-    if (fCheckITS)
-    {
-      if (nITS < 3 || !track->IsOn(AliESDtrack::kITSpid)) return kFALSE;
-      Double_t nsigmaITS = (Double_t)fPID.NumberOfSigmasITS(track, fPIDtype);
-      if (TMath::Abs(nsigmaITS) > fITSband)
-      {
-        AliDebug(AliLog::kDebug + 2, "Bad ITS PID. Rejected");
-        return kFALSE;
-      }
-      else
-      {
-        AliDebug(AliLog::kDebug + 2, "Good ITS PID. Accepted");
-        return kFALSE;
-      }
-    }
-    else
-    {
-      AliDebug(AliLog::kDebug + 2, "No PID checked. Accepted");
-      return kTRUE;
-    }
-  }
-}
diff --git a/PWG2/RESONANCES/AliRsnCutAOD2010.h b/PWG2/RESONANCES/AliRsnCutAOD2010.h
deleted file mode 100644 (file)
index 869efb6..0000000
+++ /dev/null
@@ -1,97 +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 ALIRSNCUTAOD2010_H
-#define ALIRSNCUTAOD2010_H
-
-#include "AliPID.h"
-#include "AliAODTrack.h"
-#include "AliAODpidUtil.h"
-
-#include "AliRsnCut.h"
-
-class AliRsnCutAOD2010 : public AliRsnCut
-{
-  public:
-
-    AliRsnCutAOD2010(const char *name = "cutAOD2010", Bool_t isMC = kFALSE);
-    AliRsnCutAOD2010(const AliRsnCutAOD2010& copy);
-    virtual ~AliRsnCutAOD2010() {;};
-
-    virtual Bool_t   IsSelected(TObject *object);
-    
-    void             SetMC       (Bool_t yn = kTRUE);
-    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             SetUseGlobal(Bool_t yn = kTRUE) {fUseGlobal = yn;}
-    void             SetUseITSSA (Bool_t yn = kTRUE) {fUseITSSA = yn;}
-    void             SetPIDtype  (AliPID::EParticleType pid) {fPIDtype = pid;}
-    void             SetMaxEta   (Double_t eta) {fMaxEta = eta;}
-    
-    void             SetTPCminNclusters(Int_t v)         {fTPCminNclusters = v;}
-    void             SetTPCmaxChi2(Double_t v)           {fTPCmaxChi2 = v;}     
-    void             SetTPCmaxNSigmaDCA(Double_t v)      {fTPCmaxNSigmaDCA = v;}
-    void             SetTPCparamDCA(Int_t i, Double_t v) {if (i >= 0 && i < 3) fTPCparamDCA[i] = v;} 
-    void             SetTPClowBand(Double_t v)           {fTPClowBand = v;}     
-    void             SetTPChighBand(Double_t v)          {fTPChighBand = v;}    
-    void             SetTPClowLimit(Double_t v)          {fTPClowLimit = v;}    
-    
-    void             SetITSminNclusters(Int_t v)         {fITSminNclusters = v;}
-    void             SetITSmaxChi2(Double_t v)           {fITSmaxChi2 = v;}     
-    void             SetITSmaxNSigmaDCA(Double_t v)      {fITSmaxNSigmaDCA = v;}
-    void             SetITSparamDCA(Int_t i, Double_t v) {if (i >= 0 && i < 3) fITSparamDCA[i] = v;} 
-    void             SetITSparamBB(Int_t i, Double_t v)  {if (i >= 0 && i < 3) fITSparamBB[i] = v;}  
-    void             SetITSband(Double_t v)              {fITSband = v;}    
-
-    void             SetTOFrange(Double_t v1, Double_t v2) {fTOFlowLimit = v1; fTOFhighLimit = v2;}
-    
-    AliAODpidUtil*   GetPIDUtil() {return &fPID;}
-
-  protected:
-  
-    AliRsnCutAOD2010& operator=(const AliRsnCutAOD2010& /*copy*/) {return (*this);}
-  
-    Bool_t                fIsMC;             // switch 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
-    Bool_t                fUseGlobal;        // switch to use TPC global tracks
-    Bool_t                fUseITSSA;         // switch to use ITS standalone tracks
-    
-    Double_t              fMaxEta;           // eta range for tracks
-    
-    AliPID::EParticleType fPIDtype;          // particle type for which PID is checked   
-    
-    Int_t                 fTPCminNclusters;  // minimum number of clusters in TPC
-    Double_t              fTPCmaxChi2;       // maximum chi2 / number of clusters in TPC
-    Double_t              fTPCmaxNSigmaDCA;  // cut in DCA (transv) in numbers of sigma (pt-dependent)
-    Double_t              fTPCparamDCA[3];   // parameters to compute sigma for DCA
-    Double_t              fTPClowBand;       // large band for low momentum PID
-    Double_t              fTPChighBand;      // large band for low momentum PID
-    Double_t              fTPClowLimit;      // limit of low momentum region
-    
-    Int_t                 fITSminNclusters;  // minimum number of clusters in TPC
-    Double_t              fITSmaxChi2;       // maximum chi2 / number of clusters in TPC
-    Double_t              fITSmaxNSigmaDCA;  // cut in DCA (transv) in numbers of sigma (pt-dependent)
-    Double_t              fITSparamDCA[3];   // parameters to compute sigma for DCA
-    Double_t              fITSparamBB[5];    // parameters for TPC Bethe-Bloch parameterization
-    Double_t              fITSband;          // fiducial region for selection of PID
-    
-    Double_t              fTOFlowLimit;      // low limit in asymmetric TOF PID cut
-    Double_t              fTOFhighLimit;     // low limit in asymmetric TOF PID cut
-    
-    AliAODpidUtil         fPID;              // PID utility
-
-    ClassDef(AliRsnCutAOD2010, 1)
-};
-
-#endif
index 8ef753d..bc23144 100644 (file)
@@ -43,62 +43,64 @@ Int_t          AliRsnCutESD2010::fgLastEventID     = -1;
 //_________________________________________________________________________________________________
 AliRsnCutESD2010::AliRsnCutESD2010
 (const char *name, Bool_t isMC) :
-  AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
-  fIsMC(isMC),
-  fCheckITS(kTRUE),
-  fCheckTPC(kTRUE),
-  fCheckTOF(kTRUE),
-  fUseITSTPC(kTRUE),
-  fUseITSSA(kTRUE),
-  fPID(AliPID::kKaon),
-  fMaxITSPIDmom(0.0),
-  fMaxITSband(3.0),
-  fTPCpLimit(0.35),
-  fMinTPCband(3.0),
-  fMaxTPCband(5.0),
-  fESDpid(),
-  fESDtrackCutsTPC(),
-  fESDtrackCutsITS(),
-  fMinTOF(-3.0),
-  fMaxTOF( 3.0)
+   AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
+   fIsMC(isMC),
+   fCheckITS(kTRUE),
+   fCheckTPC(kTRUE),
+   fCheckTOF(kTRUE),
+   fUseITSTPC(kTRUE),
+   fUseITSSA(kTRUE),
+   fPID(AliPID::kKaon),
+   fMaxITSPIDmom(0.0),
+   fMaxITSband(3.0),
+   fTPCpLimit(0.35),
+   fMinTPCband(3.0),
+   fMaxTPCband(5.0),
+   fESDpid(),
+   fESDtrackCutsTPC(),
+   fESDtrackCutsITS(),
+   fMinTOF(-3.0),
+   fMaxTOF(3.0),
+   fOCDBDefaultStorage("raw://")
 {
 //
 // Main constructor.
 //
 
-  SetMC(isMC);
+   SetMC(isMC);
 }
 
 //_________________________________________________________________________________________________
 AliRsnCutESD2010::AliRsnCutESD2010
 (const AliRsnCutESD2010& copy) :
-  AliRsnCut(copy),
-  fIsMC(copy.fIsMC),
-  fCheckITS(copy.fCheckITS),
-  fCheckTPC(copy.fCheckTPC),
-  fCheckTOF(copy.fCheckTOF),
-  fUseITSTPC(copy.fUseITSTPC),
-  fUseITSSA(copy.fUseITSSA),
-  fPID(copy.fPID),
-  fMaxITSPIDmom(copy.fMaxITSPIDmom),
-  fMaxITSband(copy.fMaxITSband),
-  fTPCpLimit(copy.fTPCpLimit),
-  fMinTPCband(copy.fMinTPCband),
-  fMaxTPCband(copy.fMaxTPCband),
-  fESDpid(copy.fESDpid),
-  fESDtrackCutsTPC(copy.fESDtrackCutsTPC),
-  fESDtrackCutsITS(copy.fESDtrackCutsITS),
-  fMinTOF(copy.fMinTOF),
-  fMaxTOF(copy.fMaxTOF)
+   AliRsnCut(copy),
+   fIsMC(copy.fIsMC),
+   fCheckITS(copy.fCheckITS),
+   fCheckTPC(copy.fCheckTPC),
+   fCheckTOF(copy.fCheckTOF),
+   fUseITSTPC(copy.fUseITSTPC),
+   fUseITSSA(copy.fUseITSSA),
+   fPID(copy.fPID),
+   fMaxITSPIDmom(copy.fMaxITSPIDmom),
+   fMaxITSband(copy.fMaxITSband),
+   fTPCpLimit(copy.fTPCpLimit),
+   fMinTPCband(copy.fMinTPCband),
+   fMaxTPCband(copy.fMaxTPCband),
+   fESDpid(copy.fESDpid),
+   fESDtrackCutsTPC(copy.fESDtrackCutsTPC),
+   fESDtrackCutsITS(copy.fESDtrackCutsITS),
+   fMinTOF(copy.fMinTOF),
+   fMaxTOF(copy.fMaxTOF),
+   fOCDBDefaultStorage(copy.fOCDBDefaultStorage)
 {
 //
 // Copy constructor.
 //
 
-  SetMC(copy.fIsMC);
+   SetMC(copy.fIsMC);
 
-  Int_t i = 0;
-  for (i = 0; i < 5; i++) fTPCpar[i] = copy.fTPCpar[i];
+   Int_t i = 0;
+   for (i = 0; i < 5; i++) fTPCpar[i] = copy.fTPCpar[i];
 }
 
 //_________________________________________________________________________________________________
@@ -108,33 +110,33 @@ AliRsnCutESD2010& AliRsnCutESD2010::operator=(const AliRsnCutESD2010& copy)
 // Assignment operator
 //
 
-  AliRsnCut::operator=(copy);
-
-  SetMC(copy.fIsMC);
-  
-  fCheckITS = copy.fCheckITS;
-  fCheckTPC = copy.fCheckTPC;
-  fCheckTOF = copy.fCheckTOF;
-  fUseITSTPC = copy.fUseITSTPC;
-  fUseITSSA = copy.fUseITSSA;
-  fPID = copy.fPID;
-  fMaxITSPIDmom = copy.fMaxITSPIDmom;
-  fMaxITSband = copy.fMaxITSband;
-  fTPCpLimit = copy.fTPCpLimit;
-  fMinTPCband = copy.fMinTPCband;
-  fMaxTPCband = copy.fMaxTPCband;
-  fMinTOF = copy.fMinTOF;
-  fMaxTOF = copy.fMaxTOF;
-  fESDpid = copy.fESDpid;
-  
-  Int_t i = 0;
-  for (i = 0; i < 5; i++) fTPCpar[i] = copy.fTPCpar[i];
-  
-  
-  fESDtrackCutsTPC = copy.fESDtrackCutsTPC;
-  fESDtrackCutsITS = copy.fESDtrackCutsITS;
-  
-  return (*this);
+   AliRsnCut::operator=(copy);
+
+   SetMC(copy.fIsMC);
+
+   fCheckITS = copy.fCheckITS;
+   fCheckTPC = copy.fCheckTPC;
+   fCheckTOF = copy.fCheckTOF;
+   fUseITSTPC = copy.fUseITSTPC;
+   fUseITSSA = copy.fUseITSSA;
+   fPID = copy.fPID;
+   fMaxITSPIDmom = copy.fMaxITSPIDmom;
+   fMaxITSband = copy.fMaxITSband;
+   fTPCpLimit = copy.fTPCpLimit;
+   fMinTPCband = copy.fMinTPCband;
+   fMaxTPCband = copy.fMaxTPCband;
+   fMinTOF = copy.fMinTOF;
+   fMaxTOF = copy.fMaxTOF;
+   fESDpid = copy.fESDpid;
+   fOCDBDefaultStorage = copy.fOCDBDefaultStorage;
+   Int_t i = 0;
+   for (i = 0; i < 5; i++) fTPCpar[i] = copy.fTPCpar[i];
+
+
+   fESDtrackCutsTPC = copy.fESDtrackCutsTPC;
+   fESDtrackCutsITS = copy.fESDtrackCutsITS;
+
+   return (*this);
 }
 
 //_________________________________________________________________________________________________
@@ -144,69 +146,61 @@ void AliRsnCutESD2010::SetMC(Bool_t isMC)
 // Sets some aspects of cuts depending on the fact that runs on MC or not
 //
 
-  fIsMC = isMC;
-  
-  AliITSPIDResponse itsresponse(fIsMC);
-  fESDpid.GetITSResponse() = itsresponse;
-  
-  if (isMC)
-  {
-    //fgTOFcalibrateESD = kFALSE;
-    fgTOFtuneMC       = kTRUE;
-  }
-  else
-  {
-    //fgTOFcalibrateESD = kTRUE;
-    fgTOFtuneMC       = kFALSE;
-  }
+   fIsMC = isMC;
+
+   AliITSPIDResponse itsresponse(fIsMC);
+   fESDpid.GetITSResponse() = itsresponse;
+
+   if (isMC) {
+      //fgTOFcalibrateESD = kFALSE;
+      fgTOFtuneMC       = kTRUE;
+   } else {
+      //fgTOFcalibrateESD = kTRUE;
+      fgTOFtuneMC       = kFALSE;
+   }
 }
 
 //_________________________________________________________________________________________________
 void AliRsnCutESD2010::ProcessEvent(AliESDEvent *esd)
 {
-  // get current run
-  Int_t run = esd->GetRunNumber();
-    
-  // if the run number has changed, update it now and give a message
-  if (run != fgLastRun)
-  {
-    AliInfo("============================================================================================");
-    AliInfo(Form("*** CHANGING RUN NUMBER: PREVIOUS = %d --> CURRENT = %d ***", fgLastRun, run));
-    AliInfo("============================================================================================");
-    fgLastRun = run;
-  
-    AliCDBManager::Instance()->SetDefaultStorage("raw://");
-    AliCDBManager::Instance()->SetRun(fgLastRun);
-    
-    if (fgTOFmaker) delete fgTOFmaker;
-    if (fgTOFcalib) delete fgTOFcalib;
-    
-    fgTOFcalib = new AliTOFcalib();
-    if (fIsMC)
-    {
-      fgTOFcalib->SetRemoveMeanT0(kFALSE);
-      fgTOFcalib->SetCalibrateTOFsignal(kFALSE);
-    }
-    else
-    {
-      fgTOFcalib->SetRemoveMeanT0(kTRUE);
-      fgTOFcalib->SetCalibrateTOFsignal(kTRUE);
-    }
-    if (fgTOFcorrectTExp) fgTOFcalib->SetCorrectTExp(kTRUE);
-    fgTOFcalib->Init();
-    
-    fgTOFmaker = new AliTOFT0maker(&fESDpid, fgTOFcalib);
-    fgTOFmaker->SetTimeResolution(fgTOFresolution);
-  }
-
-  /*if (fgTOFcalibrateESD)*/ fgTOFcalib->CalibrateESD(esd);
-  if (fgTOFtuneMC) fgTOFmaker->TuneForMC(esd);
-  if (fgTOFuseT0)
-  {
-    fgTOFmaker->ComputeT0TOF(esd);
-    fgTOFmaker->ApplyT0TOF(esd);
-    fESDpid.MakePID(esd, kFALSE, 0.);
-  }
+   // get current run
+   Int_t run = esd->GetRunNumber();
+
+   // if the run number has changed, update it now and give a message
+   if (run != fgLastRun) {
+      AliInfo("============================================================================================");
+      AliInfo(Form("*** CHANGING RUN NUMBER: PREVIOUS = %d --> CURRENT = %d ***", fgLastRun, run));
+      AliInfo("============================================================================================");
+      fgLastRun = run;
+
+      AliCDBManager::Instance()->SetDefaultStorage(fOCDBDefaultStorage.Data());
+      AliCDBManager::Instance()->SetRun(fgLastRun);
+
+      if (fgTOFmaker) delete fgTOFmaker;
+      if (fgTOFcalib) delete fgTOFcalib;
+
+      fgTOFcalib = new AliTOFcalib();
+      if (fIsMC) {
+         fgTOFcalib->SetRemoveMeanT0(kFALSE);
+         fgTOFcalib->SetCalibrateTOFsignal(kFALSE);
+      } else {
+         fgTOFcalib->SetRemoveMeanT0(kTRUE);
+         fgTOFcalib->SetCalibrateTOFsignal(kTRUE);
+      }
+      if (fgTOFcorrectTExp) fgTOFcalib->SetCorrectTExp(kTRUE);
+      fgTOFcalib->Init();
+
+      fgTOFmaker = new AliTOFT0maker(&fESDpid, fgTOFcalib);
+      fgTOFmaker->SetTimeResolution(fgTOFresolution);
+   }
+
+   /*if (fgTOFcalibrateESD)*/ fgTOFcalib->CalibrateESD(esd);
+   if (fgTOFtuneMC) fgTOFmaker->TuneForMC(esd);
+   if (fgTOFuseT0) {
+      fgTOFmaker->ComputeT0TOF(esd);
+      fgTOFmaker->ApplyT0TOF(esd);
+      fESDpid.MakePID(esd, kFALSE, 0.);
+   }
 }
 
 //_________________________________________________________________________________________________
@@ -216,84 +210,73 @@ Bool_t AliRsnCutESD2010::IsSelected(TObject *object)
 // Cut checker.
 //
 
-  // coherence check: require an ESD track
-  AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(object);
-  if (!daughter) return kFALSE;
-  AliESDtrack *track = daughter->GetRefESDtrack();
-  if (!track) return kFALSE;
-
-  // if no reference event, skip
-  AliRsnEvent *rsn = AliRsnTarget::GetCurrentEvent();
-  if (!rsn) return kFALSE;
-  if (fgLastEventID != rsn->GetLocalID())
-  {
-    ProcessEvent(rsn->GetRefESD());
-    fgLastEventID = rsn->GetLocalID();
-  }
-
-  // check quality and track type and reject tracks not passing this step
-  if (!OkQuality(track))
-  {
-    AliDebug(AliLog::kDebug+2, "Failed quality cut");
-    return kFALSE;
-  }
-  
-  // ITS PID can be checked always
-  // if PID is not required, the flag is sed as
-  // if the cut was alsways passed 
-  Bool_t okITSpid = OkITSPID(track);
-  if (!fCheckITS) okITSpid = kTRUE;
-  
-  // TPC PID can be checked only for TPC+ITS tracks
-  // if PID is not required, the flag is sed as
-  // if the cut was alsways passed
-  Bool_t okTPCpid = kFALSE;
-  if (IsITSTPC(track)) okTPCpid = OkTPCPID(track);
-  if (!fCheckTPC) okTPCpid = kTRUE;
-  
-  // TOF PID can be checked only if TOF is matched
-  // if PID is not required, the flag is sed as
-  // if the cut was alsways passed
-  Bool_t okTOFpid = kFALSE;
-  if (IsITSTPC(track) && MatchTOF(track)) okTOFpid = OkTOFPID(track);
-  if (!fCheckTOF) okTOFpid = kTRUE;
-  
-  // now combine all outcomes according to the different possibilities:
-  // -- ITS standalone:
-  //    --> only ITS PID, always
-  // -- ITS + TPC:
-  //    --> ITS PID, only for momenta lower than 'fMaxITSPIDmom' and when the ITSpid flag is active
-  //    --> TPC PID, always --> MASTER (first to be checked, if fails, track is rejected)
-  //    --> TOF PID, only if matched
-  if (IsITSSA(track))
-  {
-    if (!okITSpid)
-    {
-      AliDebug(AliLog::kDebug+2, "ITS standalone track --> ITS PID failed");
-      return kFALSE;
-    }
-  }
-  else // checking IsITSTPC() is redundant due to OkQuality() cut check
-  {
-    if (!okTPCpid)
-    {
-      AliDebug(AliLog::kDebug+2, "ITS+TPC track --> TPC PID failed");
+   // coherence check: require an ESD track
+   AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(object);
+   if (!daughter) return kFALSE;
+   AliESDtrack *track = daughter->GetRefESDtrack();
+   if (!track) return kFALSE;
+
+   // if no reference event, skip
+   AliRsnEvent *rsn = AliRsnTarget::GetCurrentEvent();
+   if (!rsn) return kFALSE;
+   if (fgLastEventID != rsn->GetLocalID()) {
+      ProcessEvent(rsn->GetRefESD());
+      fgLastEventID = rsn->GetLocalID();
+   }
+
+   // check quality and track type and reject tracks not passing this step
+   if (!OkQuality(track)) {
+      AliDebug(AliLog::kDebug + 2, "Failed quality cut");
       return kFALSE;
-    }
-    else if (MatchTOF(track) && !okTOFpid)
-    {
-      AliDebug(AliLog::kDebug+2, "ITS+TPC track --> TOF matched but TOF PID failed");
-      return kFALSE;
-    }
-    else if (track->IsOn(AliESDtrack::kITSpid) && track->P() <= fMaxITSPIDmom && !okITSpid)
-    {
-      AliDebug(AliLog::kDebug+2, Form("ITS+TPC track --> Momentum lower than limit (%.2f) and ITS PID failed", fMaxITSPIDmom));
-      return kFALSE;
-    }
-  }
-  
-  // arriving here, the track has survived all checks
-  return kTRUE;
+   }
+
+   // ITS PID can be checked always
+   // if PID is not required, the flag is sed as
+   // if the cut was alsways passed
+   Bool_t okITSpid = OkITSPID(track);
+   if (!fCheckITS) okITSpid = kTRUE;
+
+   // TPC PID can be checked only for TPC+ITS tracks
+   // if PID is not required, the flag is sed as
+   // if the cut was alsways passed
+   Bool_t okTPCpid = kFALSE;
+   if (IsITSTPC(track)) okTPCpid = OkTPCPID(track);
+   if (!fCheckTPC) okTPCpid = kTRUE;
+
+   // TOF PID can be checked only if TOF is matched
+   // if PID is not required, the flag is sed as
+   // if the cut was alsways passed
+   Bool_t okTOFpid = kFALSE;
+   if (IsITSTPC(track) && MatchTOF(track)) okTOFpid = OkTOFPID(track);
+   if (!fCheckTOF) okTOFpid = kTRUE;
+
+   // now combine all outcomes according to the different possibilities:
+   // -- ITS standalone:
+   //    --> only ITS PID, always
+   // -- ITS + TPC:
+   //    --> ITS PID, only for momenta lower than 'fMaxITSPIDmom' and when the ITSpid flag is active
+   //    --> TPC PID, always --> MASTER (first to be checked, if fails, track is rejected)
+   //    --> TOF PID, only if matched
+   if (IsITSSA(track)) {
+      if (!okITSpid) {
+         AliDebug(AliLog::kDebug + 2, "ITS standalone track --> ITS PID failed");
+         return kFALSE;
+      }
+   } else { // checking IsITSTPC() is redundant due to OkQuality() cut check
+      if (!okTPCpid) {
+         AliDebug(AliLog::kDebug + 2, "ITS+TPC track --> TPC PID failed");
+         return kFALSE;
+      } else if (MatchTOF(track) && !okTOFpid) {
+         AliDebug(AliLog::kDebug + 2, "ITS+TPC track --> TOF matched but TOF PID failed");
+         return kFALSE;
+      } else if (track->IsOn(AliESDtrack::kITSpid) && track->P() <= fMaxITSPIDmom && !okITSpid) {
+         AliDebug(AliLog::kDebug + 2, Form("ITS+TPC track --> Momentum lower than limit (%.2f) and ITS PID failed", fMaxITSPIDmom));
+         return kFALSE;
+      }
+   }
+
+   // arriving here, the track has survived all checks
+   return kTRUE;
 }
 
 //______________________________________________________________________________
@@ -305,116 +288,114 @@ Bool_t AliRsnCutESD2010::OkQuality(AliESDtrack *track)
 // If tracks of any type are not flagged to be used, they are rejected anyway.
 //
 
-  if (IsITSTPC(track)) return (fUseITSTPC && fESDtrackCutsTPC.IsSelected(track));
-  if (IsITSSA (track)) return (fUseITSSA  && fESDtrackCutsITS.IsSelected(track));
+   if (IsITSTPC(track)) return (fUseITSTPC && fESDtrackCutsTPC.IsSelected(track));
+   if (IsITSSA(track)) return (fUseITSSA  && fESDtrackCutsITS.IsSelected(track));
 
-  return kFALSE;
+   return kFALSE;
 }
 
 //______________________________________________________________________________
-Bool_t AliRsnCutESD2010::OkITSPID (AliESDtrack *track)
+Bool_t AliRsnCutESD2010::OkITSPID(AliESDtrack *track)
 {
 //
 // Check ITS particle identification with 3sigma cut
 //
 
-  // count PID layers and reject if they are too few
-  Int_t   k, nITSpidLayers = 0;
-  UChar_t itsCluMap = track->GetITSClusterMap();
-  for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITSpidLayers;
-  if (nITSpidLayers < 3)
-  {
-    AliDebug(AliLog::kDebug+2, "Rejecting track with too few ITS pid layers");
-    return kFALSE;
-  }
-  
-  // check the track type (ITS+TPC or ITS standalone)
-  // and reject it if it is of none of the allowed types
-  Bool_t isSA = kFALSE;
-  if (IsITSTPC(track)) isSA = kFALSE;
-  else if (IsITSSA(track)) isSA = kTRUE;
-  else
-  {
-    AliWarning("Track is neither ITS+TPC nor ITS standalone");
-    return kFALSE;
-  }
-  
-  // create the PID response object and compute nsigma
-  AliITSPIDResponse &itsrsp = fESDpid.GetITSResponse();
-  Double_t mom    = track->P();
-  Double_t nSigma = itsrsp.GetNumberOfSigmas(mom, track->GetITSsignal(), fPID, nITSpidLayers, isSA);
-  
-  // evaluate the cut
-  Bool_t ok = (TMath::Abs(nSigma) <= fMaxITSband);
-  
-  // debug message
-  AliDebug(AliLog::kDebug + 2, Form("ITS nsigma = %f -- max = %f -- cut %s", nSigma, fMaxITSband, (ok ? "passed" : "failed")));
-  
-  // outcome
-  return ok;
+   // count PID layers and reject if they are too few
+   Int_t   k, nITSpidLayers = 0;
+   UChar_t itsCluMap = track->GetITSClusterMap();
+   for (k = 2; k < 6; k++) if (itsCluMap & (1 << k)) ++nITSpidLayers;
+   if (nITSpidLayers < 3) {
+      AliDebug(AliLog::kDebug + 2, "Rejecting track with too few ITS pid layers");
+      return kFALSE;
+   }
+
+   // check the track type (ITS+TPC or ITS standalone)
+   // and reject it if it is of none of the allowed types
+   Bool_t isSA = kFALSE;
+   if (IsITSTPC(track)) isSA = kFALSE;
+   else if (IsITSSA(track)) isSA = kTRUE;
+   else {
+      AliWarning("Track is neither ITS+TPC nor ITS standalone");
+      return kFALSE;
+   }
+
+   // create the PID response object and compute nsigma
+   AliITSPIDResponse &itsrsp = fESDpid.GetITSResponse();
+   Double_t mom    = track->P();
+   Double_t nSigma = itsrsp.GetNumberOfSigmas(mom, track->GetITSsignal(), fPID, nITSpidLayers, isSA);
+
+   // evaluate the cut
+   Bool_t ok = (TMath::Abs(nSigma) <= fMaxITSband);
+
+   // debug message
+   AliDebug(AliLog::kDebug + 2, Form("ITS nsigma = %f -- max = %f -- cut %s", nSigma, fMaxITSband, (ok ? "passed" : "failed")));
+
+   // outcome
+   return ok;
 }
 
 //______________________________________________________________________________
-Bool_t AliRsnCutESD2010::OkTPCPID (AliESDtrack *track)
+Bool_t AliRsnCutESD2010::OkTPCPID(AliESDtrack *track)
 {
 //
 // Check TPC particle identification with {3|5}sigmacut,
 // depending on the track total momentum.
 //
 
-  // setup TPC PID response
-  AliTPCPIDResponse &tpcrsp = fESDpid.GetTPCResponse();
-  //tpcrsp.SetBetheBlochParameters(fTPCpar[0],fTPCpar[1],fTPCpar[2],fTPCpar[3],fTPCpar[4]);
-  
-  // get momentum and number of sigmas and choose the reference band
-  Double_t mom       = track->GetInnerParam()->P();
-  Double_t nSigma    = tpcrsp.GetNumberOfSigmas(mom, track->GetTPCsignal(), track->GetTPCsignalN(), fPID);
-  Double_t maxNSigma = fMaxTPCband;
-  if (mom < fTPCpLimit) maxNSigma = fMinTPCband;
-  
-  // evaluate the cut
-  Bool_t ok = (TMath::Abs(nSigma) <= maxNSigma);
-  
-  // debug message
-  AliDebug(AliLog::kDebug + 2, Form("TPC nsigma = %f -- max = %f -- cut %s", nSigma, maxNSigma, (ok ? "passed" : "failed")));
-  
-  // outcome
-  return ok;
+   // setup TPC PID response
+   AliTPCPIDResponse &tpcrsp = fESDpid.GetTPCResponse();
+   //tpcrsp.SetBetheBlochParameters(fTPCpar[0],fTPCpar[1],fTPCpar[2],fTPCpar[3],fTPCpar[4]);
+
+   // get momentum and number of sigmas and choose the reference band
+   Double_t mom       = track->GetInnerParam()->P();
+   Double_t nSigma    = tpcrsp.GetNumberOfSigmas(mom, track->GetTPCsignal(), track->GetTPCsignalN(), fPID);
+   Double_t maxNSigma = fMaxTPCband;
+   if (mom < fTPCpLimit) maxNSigma = fMinTPCband;
+
+   // evaluate the cut
+   Bool_t ok = (TMath::Abs(nSigma) <= maxNSigma);
+
+   // debug message
+   AliDebug(AliLog::kDebug + 2, Form("TPC nsigma = %f -- max = %f -- cut %s", nSigma, maxNSigma, (ok ? "passed" : "failed")));
+
+   // outcome
+   return ok;
 }
 
 //______________________________________________________________________________
-Bool_t AliRsnCutESD2010::OkTOFPID (AliESDtrack *track)
+Bool_t AliRsnCutESD2010::OkTOFPID(AliESDtrack *track)
 {
 //
 // Check TOF particle identification if matched there.
 //
 
-  // reject not TOF-matched tracks
-  if (!MatchTOF(track)) return kFALSE;
-  
-  // setup TOF PID response
-  AliTOFPIDResponse &tofrsp = fESDpid.GetTOFResponse();
-  
-  // get info for computation
-  Double_t momentum = track->P();
-  Double_t time     = track->GetTOFsignal();
-  Double_t timeint[AliPID::kSPECIES];
-  tofrsp.GetStartTime(momentum);
-  track->GetIntegratedTimes(timeint);
-
-  // check the cut
-  Double_t timeDiff = time - timeint[(Int_t)fPID];
-  Double_t sigmaRef = tofrsp.GetExpectedSigma(momentum, timeint[(Int_t)fPID], AliPID::ParticleMass(fPID));
-  Double_t nSigma   = timeDiff / sigmaRef;
-  
-  // evaluate the cut
-  Bool_t ok = (nSigma >= fMinTOF && nSigma <= fMaxTOF);
-  
-  // debug message
-  AliDebug(AliLog::kDebug + 2, Form("TOF nsigma = %f -- range = %f - %f -- cut %s", nSigma, fMinTOF, fMaxTOF, (ok ? "passed" : "failed")));
-  
-  // outcome
-  return ok;
+   // reject not TOF-matched tracks
+   if (!MatchTOF(track)) return kFALSE;
+
+   // setup TOF PID response
+   AliTOFPIDResponse &tofrsp = fESDpid.GetTOFResponse();
+
+   // get info for computation
+   Double_t momentum = track->P();
+   Double_t time     = track->GetTOFsignal();
+   Double_t timeint[AliPID::kSPECIES];
+   tofrsp.GetStartTime(momentum);
+   track->GetIntegratedTimes(timeint);
+
+   // check the cut
+   Double_t timeDiff = time - timeint[(Int_t)fPID];
+   Double_t sigmaRef = tofrsp.GetExpectedSigma(momentum, timeint[(Int_t)fPID], AliPID::ParticleMass(fPID));
+   Double_t nSigma   = timeDiff / sigmaRef;
+
+   // evaluate the cut
+   Bool_t ok = (nSigma >= fMinTOF && nSigma <= fMaxTOF);
+
+   // debug message
+   AliDebug(AliLog::kDebug + 2, Form("TOF nsigma = %f -- range = %f - %f -- cut %s", nSigma, fMinTOF, fMaxTOF, (ok ? "passed" : "failed")));
+
+   // outcome
+   return ok;
 }
 
 //_________________________________________________________________________________________________
@@ -424,19 +405,19 @@ void AliRsnCutESD2010::Print(const Option_t *) const
 // Print information on this cut
 //
 
-  AliInfo(Form("Cut name               : %s", GetName()));
-  AliInfo(Form("Using MC settings      : %s", (fIsMC ? "YES" : "NO")));
-  AliInfo(Form("Using TPC+ITS tracks   : %s", (fUseITSTPC ? "YES" : "NO")));
-  AliInfo(Form("Using ITS SA  tracks   : %s", (fUseITSSA ? "YES" : "NO")));
-  AliInfo(Form("Check ITS PID          : %s", (fCheckITS ? "YES" : "NO")));
-  AliInfo(Form("Check TPC PID          : %s", (fCheckTPC ? "YES" : "NO")));
-  AliInfo(Form("Check TOF PID          : %s", (fCheckTOF ? "YES" : "NO")));
-  AliInfo(Form("Reference particle     : %s", AliPID::ParticleName(fPID)));
-  AliInfo(Form("ITS PID range  (sigmas): %f", fMaxITSband));
-  AliInfo(Form("ITS PID range  (pt)    : %f", fMaxITSPIDmom));
-  AliInfo(Form("TPC PID ranges (sigmas): %f %f", fMinTPCband, fMaxTPCband));
-  AliInfo(Form("TPC PID limit  (p)     : %f", fTPCpLimit));
-  AliInfo(Form("TOF resolution         : %f", fgTOFresolution));
-  AliInfo(Form("TOF range (sigmas)     : %f - %f", fMinTOF, fMaxTOF));  
-  AliInfo(Form("TOF PID tuning from MC : %s", (fgTOFtuneMC ? "YES" : "NO")));
+   AliInfo(Form("Cut name               : %s", GetName()));
+   AliInfo(Form("Using MC settings      : %s", (fIsMC ? "YES" : "NO")));
+   AliInfo(Form("Using TPC+ITS tracks   : %s", (fUseITSTPC ? "YES" : "NO")));
+   AliInfo(Form("Using ITS SA  tracks   : %s", (fUseITSSA ? "YES" : "NO")));
+   AliInfo(Form("Check ITS PID          : %s", (fCheckITS ? "YES" : "NO")));
+   AliInfo(Form("Check TPC PID          : %s", (fCheckTPC ? "YES" : "NO")));
+   AliInfo(Form("Check TOF PID          : %s", (fCheckTOF ? "YES" : "NO")));
+   AliInfo(Form("Reference particle     : %s", AliPID::ParticleName(fPID)));
+   AliInfo(Form("ITS PID range  (sigmas): %f", fMaxITSband));
+   AliInfo(Form("ITS PID range  (pt)    : %f", fMaxITSPIDmom));
+   AliInfo(Form("TPC PID ranges (sigmas): %f %f", fMinTPCband, fMaxTPCband));
+   AliInfo(Form("TPC PID limit  (p)     : %f", fTPCpLimit));
+   AliInfo(Form("TOF resolution         : %f", fgTOFresolution));
+   AliInfo(Form("TOF range (sigmas)     : %f - %f", fMinTOF, fMaxTOF));
+   AliInfo(Form("TOF PID tuning from MC : %s", (fgTOFtuneMC ? "YES" : "NO")));
 }
index 83f28c3..7eecce3 100644 (file)
@@ -23,94 +23,96 @@ class AliESDpid;
 class AliTOFT0maker;
 class AliTOFcalib;
 
-class AliRsnCutESD2010 : public AliRsnCut
-{
-  public:
-
-    AliRsnCutESD2010(const char *name = "cutESD2010", Bool_t isMC = kFALSE);
-    AliRsnCutESD2010(const AliRsnCutESD2010& copy);
-    AliRsnCutESD2010& operator=(const AliRsnCutESD2010& copy);
-    virtual ~AliRsnCutESD2010() {;};
-
-    AliESDpid*       GetESDpid()  {return &fESDpid;}
-    AliESDtrackCuts* GetCutsTPC() {return &fESDtrackCutsTPC;}
-    AliESDtrackCuts* GetCutsITS() {return &fESDtrackCutsITS;}
-    void             CopyCutsTPC(const AliESDtrackCuts *cuts) {fESDtrackCutsTPC = (*cuts);}
-    void             CopyCutsITS(const AliESDtrackCuts *cuts) {fESDtrackCutsITS = (*cuts);}
-    void             CopyCutsTPC(AliESDtrackCuts cuts)        {fESDtrackCutsTPC = cuts;}
-    void             CopyCutsITS(AliESDtrackCuts cuts)        {fESDtrackCutsITS = cuts;}
-    virtual Bool_t   IsSelected(TObject *object);
-    virtual void     Print(const Option_t *option = "") const;
-    
-    void             SetMC       (Bool_t yn = kTRUE);
-    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             SetUseITSTPC(Bool_t yn = kTRUE) {fUseITSTPC = yn;}
-    void             SetUseITSSA (Bool_t yn = kTRUE) {fUseITSSA = yn;}
-    void             SetPID      (AliPID::EParticleType t) {fPID = t;}
-    
-    void             SetMaxITSPIDmom(Double_t v) {fMaxITSPIDmom = 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             SetTOFrange       (Double_t v1, Double_t v2) {fMinTOF = v1; fMaxTOF = v2;}
-    
-    virtual void     ProcessEvent(AliESDEvent *esd);
-    
-  //static void      SetTOFcalibrateESD(Bool_t yn)  {fgTOFcalibrateESD = yn;}
-    static void      SetTOFcorrectTExp (Bool_t yn)  {fgTOFcorrectTExp  = yn;}
-    static void      SetTOFuseT0       (Bool_t yn)  {fgTOFuseT0        = yn;}
-    static void      SetTOFtuneMC      (Bool_t yn)  {fgTOFtuneMC       = yn;}
-    static void      SetTOFresolution  (Double_t r) {fgTOFresolution   = r;}
-
-  protected:
-  
-    Bool_t  OkQuality(AliESDtrack *d);  // check track quality parameters and DCA
-    Bool_t  OkITSPID (AliESDtrack *d);  // check ITS PID
-    Bool_t  OkTPCPID (AliESDtrack *d);  // check TPC PID
-    Bool_t  OkTOFPID (AliESDtrack *d);  // check TOF PID
-    Bool_t  IsITSTPC (AliESDtrack *d);  // check that the track is TPC+ITS
-    Bool_t  IsITSSA  (AliESDtrack *d);  // check that the track is ITS standalone
-    Bool_t  MatchTOF (AliESDtrack *d);  // check that the track matches the TOF
-  
-    Bool_t                  fIsMC;             //  switch 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
-    Bool_t                  fUseITSTPC;        //  switch to use TPC global tracks
-    Bool_t                  fUseITSSA;         //  switch to use ITS standalone tracks
-    AliPID::EParticleType   fPID;              //  PID reference type used for checks
-    
-    Double_t                fMaxITSPIDmom;     //  maximum momentum where ITS PID is used for TPC+ITS tracks
-    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
-    
-    AliESDpid               fESDpid;           //  ESD PID object
-    AliESDtrackCuts         fESDtrackCutsTPC;  //  ESD standard defined track cuts for TPC tracks
-    AliESDtrackCuts         fESDtrackCutsITS;  //  ESD standard defined track cuts for ITS-SA tracks
-    Double_t                fMinTOF;           //  range for TOF PID (min)
-    Double_t                fMaxTOF;           //  range for TOF PID (max)
-    
-  //static Bool_t           fgTOFcalibrateESD; //! TOF settings
-    static Bool_t           fgTOFcorrectTExp;  //! TOF settings
-    static Bool_t           fgTOFuseT0;        //! TOF settings
-    static Bool_t           fgTOFtuneMC;       //! TOF settings
-    static Double_t         fgTOFresolution;   //! TOF settings
-    static AliTOFT0maker   *fgTOFmaker;        //! TOF time0 computator
-    static AliTOFcalib     *fgTOFcalib;        //! TOF calibration
-    static Int_t            fgLastRun;         //! last run number
-    static Int_t            fgLastEventID;     //! ID of last event processed
-
-    ClassDef(AliRsnCutESD2010, 1)
+class AliRsnCutESD2010 : public AliRsnCut {
+public:
+
+   AliRsnCutESD2010(const char *name = "cutESD2010", Bool_t isMC = kFALSE);
+   AliRsnCutESD2010(const AliRsnCutESD2010& copy);
+   AliRsnCutESD2010& operator=(const AliRsnCutESD2010& copy);
+   virtual ~AliRsnCutESD2010() {;};
+
+   AliESDpid*       GetESDpid()  {return &fESDpid;}
+   AliESDtrackCuts* GetCutsTPC() {return &fESDtrackCutsTPC;}
+   AliESDtrackCuts* GetCutsITS() {return &fESDtrackCutsITS;}
+   void             CopyCutsTPC(const AliESDtrackCuts *cuts) {fESDtrackCutsTPC = (*cuts);}
+   void             CopyCutsITS(const AliESDtrackCuts *cuts) {fESDtrackCutsITS = (*cuts);}
+   void             CopyCutsTPC(AliESDtrackCuts cuts)        {fESDtrackCutsTPC = cuts;}
+   void             CopyCutsITS(AliESDtrackCuts cuts)        {fESDtrackCutsITS = cuts;}
+   virtual Bool_t   IsSelected(TObject *object);
+   virtual void     Print(const Option_t *option = "") const;
+
+   void             SetMC(Bool_t yn = kTRUE);
+   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             SetUseITSTPC(Bool_t yn = kTRUE) {fUseITSTPC = yn;}
+   void             SetUseITSSA(Bool_t yn = kTRUE) {fUseITSSA = yn;}
+   void             SetPID(AliPID::EParticleType t) {fPID = t;}
+
+   void             SetMaxITSPIDmom(Double_t v) {fMaxITSPIDmom = 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             SetTOFrange(Double_t v1, Double_t v2) {fMinTOF = v1; fMaxTOF = v2;}
+   void                 SetOCDBDefaultStorage(TString s = "raw://") { fOCDBDefaultStorage = s;}
+
+   virtual void     ProcessEvent(AliESDEvent *esd);
+
+   //static void      SetTOFcalibrateESD(Bool_t yn)  {fgTOFcalibrateESD = yn;}
+   static void      SetTOFcorrectTExp(Bool_t yn)  {fgTOFcorrectTExp  = yn;}
+   static void      SetTOFuseT0(Bool_t yn)  {fgTOFuseT0        = yn;}
+   static void      SetTOFtuneMC(Bool_t yn)  {fgTOFtuneMC       = yn;}
+   static void      SetTOFresolution(Double_t r) {fgTOFresolution   = r;}
+
+protected:
+
+   Bool_t  OkQuality(AliESDtrack *d);  // check track quality parameters and DCA
+   Bool_t  OkITSPID(AliESDtrack *d);   // check ITS PID
+   Bool_t  OkTPCPID(AliESDtrack *d);   // check TPC PID
+   Bool_t  OkTOFPID(AliESDtrack *d);   // check TOF PID
+   Bool_t  IsITSTPC(AliESDtrack *d);   // check that the track is TPC+ITS
+   Bool_t  IsITSSA(AliESDtrack *d);    // check that the track is ITS standalone
+   Bool_t  MatchTOF(AliESDtrack *d);   // check that the track matches the TOF
+
+   Bool_t                  fIsMC;             //  switch 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
+   Bool_t                  fUseITSTPC;        //  switch to use TPC global tracks
+   Bool_t                  fUseITSSA;         //  switch to use ITS standalone tracks
+   AliPID::EParticleType   fPID;              //  PID reference type used for checks
+
+   Double_t                fMaxITSPIDmom;     //  maximum momentum where ITS PID is used for TPC+ITS tracks
+   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
+
+   AliESDpid               fESDpid;           //  ESD PID object
+   AliESDtrackCuts         fESDtrackCutsTPC;  //  ESD standard defined track cuts for TPC tracks
+   AliESDtrackCuts         fESDtrackCutsITS;  //  ESD standard defined track cuts for ITS-SA tracks
+   Double_t                fMinTOF;           //  range for TOF PID (min)
+   Double_t                fMaxTOF;           //  range for TOF PID (max)
+
+   TString                 fOCDBDefaultStorage;// default storage for OCDB (raw://)
+
+   //static Bool_t           fgTOFcalibrateESD; //! TOF settings
+   static Bool_t           fgTOFcorrectTExp;  //! TOF settings
+   static Bool_t           fgTOFuseT0;        //! TOF settings
+   static Bool_t           fgTOFtuneMC;       //! TOF settings
+   static Double_t         fgTOFresolution;   //! TOF settings
+   static AliTOFT0maker   *fgTOFmaker;        //! TOF time0 computator
+   static AliTOFcalib     *fgTOFcalib;        //! TOF calibration
+   static Int_t            fgLastRun;         //! last run number
+   static Int_t            fgLastEventID;     //! ID of last event processed
+
+   ClassDef(AliRsnCutESD2010, 1)
 };
 
 inline Bool_t AliRsnCutESD2010::IsITSTPC(AliESDtrack *vtrack)
@@ -119,15 +121,14 @@ inline Bool_t AliRsnCutESD2010::IsITSTPC(AliESDtrack *vtrack)
 // Checks if the track has the status flags required for a global track
 //
 
-  if (!vtrack)
-  {
-    AliWarning("NULL argument: impossible to check status");
-    return kFALSE;
-  }
-  
-  return vtrack->IsOn(AliESDtrack::kTPCin);
-  
-  return kTRUE;
+   if (!vtrack) {
+      AliWarning("NULL argument: impossible to check status");
+      return kFALSE;
+   }
+
+   return vtrack->IsOn(AliESDtrack::kTPCin);
+
+   return kTRUE;
 }
 
 inline Bool_t AliRsnCutESD2010::IsITSSA(AliESDtrack *vtrack)
@@ -136,20 +137,19 @@ inline Bool_t AliRsnCutESD2010::IsITSSA(AliESDtrack *vtrack)
 // Checks if the track has the status flags required for an ITS standalone track
 //
 
-  if (!vtrack)
-  {
-    AliWarning("NULL argument: impossible to check status");
-    return kFALSE;
-  }
-  
-  Bool_t isTPCin     = vtrack->IsOn(AliESDtrack::kTPCin);
-  Bool_t isITSrefit  = vtrack->IsOn(AliESDtrack::kITSrefit);
-  Bool_t isITSpureSA = vtrack->IsOn(AliESDtrack::kITSpureSA);
-  Bool_t isITSpid    = vtrack->IsOn(AliESDtrack::kITSpid);
-  
-  return ( (!isTPCin) && isITSrefit && (!isITSpureSA) && isITSpid );
-  
-  return kTRUE;
+   if (!vtrack) {
+      AliWarning("NULL argument: impossible to check status");
+      return kFALSE;
+   }
+
+   Bool_t isTPCin     = vtrack->IsOn(AliESDtrack::kTPCin);
+   Bool_t isITSrefit  = vtrack->IsOn(AliESDtrack::kITSrefit);
+   Bool_t isITSpureSA = vtrack->IsOn(AliESDtrack::kITSpureSA);
+   Bool_t isITSpid    = vtrack->IsOn(AliESDtrack::kITSpid);
+
+   return ((!isTPCin) && isITSrefit && (!isITSpureSA) && isITSpid);
+
+   return kTRUE;
 }
 
 
@@ -159,21 +159,20 @@ inline Bool_t AliRsnCutESD2010::MatchTOF(AliESDtrack *vtrack)
 // Checks if the track has matched the TOF detector
 //
 
-  if (!vtrack)
-  {
-    AliWarning("NULL argument: impossible to check status");
-    return kFALSE;
-  }
-  
-  // require a minimum length to have meaningful match
-  if (vtrack->GetIntegratedLength() < 350.) return kFALSE;
-  
-  Bool_t isTOFout = vtrack->IsOn(AliESDtrack::kTOFout);
-  Bool_t isTIME   = vtrack->IsOn(AliESDtrack::kTIME);
-  
-  return ( isTOFout && isTIME );
-  
-  return kTRUE;
+   if (!vtrack) {
+      AliWarning("NULL argument: impossible to check status");
+      return kFALSE;
+   }
+
+   // require a minimum length to have meaningful match
+   if (vtrack->GetIntegratedLength() < 350.) return kFALSE;
+
+   Bool_t isTOFout = vtrack->IsOn(AliESDtrack::kTOFout);
+   Bool_t isTIME   = vtrack->IsOn(AliESDtrack::kTIME);
+
+   return (isTOFout && isTIME);
+
+   return kTRUE;
 }
 
 #endif
index f150d87..b0ed660 100644 (file)
@@ -26,11 +26,11 @@ ClassImp(AliRsnCutManager)
 
 //_____________________________________________________________________________
 AliRsnCutManager::AliRsnCutManager() :
-  TNamed("defaultName", "defaultTitle"),
-  fDaughterCutsCommon("defaultCommon", AliRsnTarget::kDaughter),
-  fDaughterCuts1("defaultD1", AliRsnTarget::kDaughter),
-  fDaughterCuts2("defaultD2", AliRsnTarget::kDaughter),
-  fMotherCuts("defaultPair", AliRsnTarget::kMother)
+   TNamed("defaultName", "defaultTitle"),
+   fDaughterCutsCommon("defaultCommon", AliRsnTarget::kDaughter),
+   fDaughterCuts1("defaultD1", AliRsnTarget::kDaughter),
+   fDaughterCuts2("defaultD2", AliRsnTarget::kDaughter),
+   fMotherCuts("defaultPair", AliRsnTarget::kMother)
 {
 //
 // Constructor without arguments.
@@ -39,11 +39,11 @@ AliRsnCutManager::AliRsnCutManager() :
 
 //_____________________________________________________________________________
 AliRsnCutManager::AliRsnCutManager(const char *name, const char *title) :
-  TNamed(name, title),
-  fDaughterCutsCommon(Form("common_%s", name), AliRsnTarget::kDaughter),
-  fDaughterCuts1(Form("d1_%s", name), AliRsnTarget::kDaughter),
-  fDaughterCuts2(Form("d2_%s", name), AliRsnTarget::kDaughter),
-  fMotherCuts(Form("pair_%s", name), AliRsnTarget::kMother)
+   TNamed(name, title),
+   fDaughterCutsCommon(Form("common_%s", name), AliRsnTarget::kDaughter),
+   fDaughterCuts1(Form("d1_%s", name), AliRsnTarget::kDaughter),
+   fDaughterCuts2(Form("d2_%s", name), AliRsnTarget::kDaughter),
+   fMotherCuts(Form("pair_%s", name), AliRsnTarget::kMother)
 {
 //
 // Constructor with name and title.
@@ -52,11 +52,11 @@ AliRsnCutManager::AliRsnCutManager(const char *name, const char *title) :
 
 //_____________________________________________________________________________
 AliRsnCutManager::AliRsnCutManager(const AliRsnCutManager &cut) :
-  TNamed(cut),
-  fDaughterCutsCommon(cut.fDaughterCutsCommon),
-  fDaughterCuts1(cut.fDaughterCuts1),
-  fDaughterCuts2(cut.fDaughterCuts2),
-  fMotherCuts(cut.fMotherCuts)
+   TNamed(cut),
+   fDaughterCutsCommon(cut.fDaughterCutsCommon),
+   fDaughterCuts1(cut.fDaughterCuts1),
+   fDaughterCuts2(cut.fDaughterCuts2),
+   fMotherCuts(cut.fMotherCuts)
 {
 //
 // Constructor with name and title.
@@ -70,15 +70,15 @@ AliRsnCutManager& AliRsnCutManager::operator=(const AliRsnCutManager &cut)
 // Assign operator
 //
 
-  SetName(cut.GetName());
-  SetTitle(cut.GetTitle());
-  
-  fDaughterCuts2 = cut.fDaughterCuts2;
-  fDaughterCuts1 = cut.fDaughterCuts1;
-  fDaughterCutsCommon = cut.fDaughterCutsCommon;
-  fMotherCuts = cut.fMotherCuts;
-  
-  return (*this);
+   SetName(cut.GetName());
+   SetTitle(cut.GetTitle());
+
+   fDaughterCuts2 = cut.fDaughterCuts2;
+   fDaughterCuts1 = cut.fDaughterCuts1;
+   fDaughterCutsCommon = cut.fDaughterCutsCommon;
+   fMotherCuts = cut.fMotherCuts;
+
+   return (*this);
 }
 
 //_____________________________________________________________________________
index 7de65dd..b4829e6 100644 (file)
 
 class AliRsnCut;
 
-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 &fDaughterCutsCommon;}
-    AliRsnCutSet*  GetDaughter1Cuts()      {return &fDaughterCuts1;}
-    AliRsnCutSet*  GetDaughter2Cuts()      {return &fDaughterCuts2;}
-    AliRsnCutSet*  GetMotherCuts()         {return &fMotherCuts;}
-    
-    Bool_t         PassCommonDaughterCuts(AliRsnDaughter *daughter) {return fDaughterCutsCommon.IsSelected(daughter);}
-    Bool_t         PassDaughter1Cuts(AliRsnDaughter *daughter)      {return fDaughterCuts1.IsSelected(daughter);}
-    Bool_t         PassDaughter2Cuts(AliRsnDaughter *daughter)      {return fDaughterCuts2.IsSelected(daughter);}
-    Bool_t         PassMotherCuts(AliRsnMother *mother)             {return fMotherCuts.IsSelected(mother);}
-    Bool_t         PassSpecificDaughterCuts(Bool_t first, AliRsnDaughter *daughter)
-                     {if (first) return PassDaughter1Cuts(daughter); else return PassDaughter2Cuts(daughter);}
-
-  private:
-
-    AliRsnCutSet  fDaughterCutsCommon; // single-track cuts common to both daughters
-    AliRsnCutSet  fDaughterCuts1;      // single-track cuts for only first daughter
-    AliRsnCutSet  fDaughterCuts2;      // single-track cuts for only second daughter
-    AliRsnCutSet  fMotherCuts;         // mother cuts (on relations between daughters)
-
-    ClassDef(AliRsnCutManager, 2)      // dictionary
+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 &fDaughterCutsCommon;}
+   AliRsnCutSet*  GetDaughter1Cuts()      {return &fDaughterCuts1;}
+   AliRsnCutSet*  GetDaughter2Cuts()      {return &fDaughterCuts2;}
+   AliRsnCutSet*  GetMotherCuts()         {return &fMotherCuts;}
+
+   Bool_t         PassCommonDaughterCuts(AliRsnDaughter *daughter) {return fDaughterCutsCommon.IsSelected(daughter);}
+   Bool_t         PassDaughter1Cuts(AliRsnDaughter *daughter)      {return fDaughterCuts1.IsSelected(daughter);}
+   Bool_t         PassDaughter2Cuts(AliRsnDaughter *daughter)      {return fDaughterCuts2.IsSelected(daughter);}
+   Bool_t         PassMotherCuts(AliRsnMother *mother)             {return fMotherCuts.IsSelected(mother);}
+   Bool_t         PassSpecificDaughterCuts(Bool_t first, AliRsnDaughter *daughter)
+   {if (first) return PassDaughter1Cuts(daughter); else return PassDaughter2Cuts(daughter);}
+
+private:
+
+   AliRsnCutSet  fDaughterCutsCommon; // single-track cuts common to both daughters
+   AliRsnCutSet  fDaughterCuts1;      // single-track cuts for only first daughter
+   AliRsnCutSet  fDaughterCuts2;      // single-track cuts for only second daughter
+   AliRsnCutSet  fMotherCuts;         // mother cuts (on relations between daughters)
+
+   ClassDef(AliRsnCutManager, 2)      // dictionary
 };
 
 #endif
index 16ca585..b88389d 100644 (file)
@@ -26,9 +26,9 @@ ClassImp(AliRsnCutPID)
 
 //_________________________________________________________________________________________________
 AliRsnCutPID::AliRsnCutPID() :
-  AliRsnCut(),
-  fPerfect(kFALSE),
-  fUseDefault(kTRUE)
+   AliRsnCut(),
+   fPerfect(kFALSE),
+   fUseDefault(kTRUE)
 {
 //
 // Default constructor.
@@ -37,29 +37,27 @@ AliRsnCutPID::AliRsnCutPID() :
 // 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;
-  }
-  
-  SetTargetType(AliRsnTarget::kDaughter);
+   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;
+   }
+
+   SetTargetType(AliRsnTarget::kDaughter);
 }
 
 //_________________________________________________________________________________________________
 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)
+   AliRsnCut(name, AliRsnCut::kDaughter, (Int_t)pid),
+   fPerfect(perfectPID),
+   fUseDefault(kTRUE)
 {
 //
 // Default constructor.
@@ -68,39 +66,37 @@ AliRsnCutPID::AliRsnCutPID(const char *name, AliPID::EParticleType pid, Double_t
 // 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;
-  
-  SetTargetType(AliRsnTarget::kDaughter);
+   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;
+
+   SetTargetType(AliRsnTarget::kDaughter);
 }
 
 //_____________________________________________________________________________
 Bool_t AliRsnCutPID::CheckThreshold(EDetector det, Double_t value)
 {
 //
-// Checks if the passed value (track pT) stays in the 
+// 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]);
+   if (!CheckBounds(det)) return kFALSE;
+
+   if (fGoAboveThreshold[det]) return (value >= fPtThreshold[det]);
+   else return (value <= fPtThreshold[det]);
 }
 
 //_________________________________________________________________________________________________
@@ -114,67 +110,61 @@ Bool_t AliRsnCutPID::ComputeWeights(AliRsnDaughter *daughter)
 // 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()) return kFALSE;
-  if (!daughter->GetRefESDtrack()) useDefault = kTRUE;
-  if (!daughter->GetRefESDtrack() && !daughter->GetRefAODtrack()) return kFALSE;
-  
-  // if perfect PID ise required, 
-  // compare the PDG code of the type stored in 'fMinI' of the cut
-  // and that of the particle which is checked, looking at its MC
-  if (perfectPID)
-  {
-    i = TMath::Abs(AliPID::ParticleCode(fMinI));
-    j = daughter->GetPDG();
-    return (i == j);
-  }
-  
-  // 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;
+   Int_t  i, j;
+   Bool_t useDefault = fUseDefault;
+   Bool_t perfectPID = fPerfect;
+   if (perfectPID && !daughter->GetRefMC()) return kFALSE;
+   if (!daughter->GetRefESDtrack()) useDefault = kTRUE;
+   if (!daughter->GetRefESDtrack() && !daughter->GetRefAODtrack()) return kFALSE;
+
+   // if perfect PID ise required,
+   // compare the PDG code of the type stored in 'fMinI' of the cut
+   // and that of the particle which is checked, looking at its MC
+   if (perfectPID) {
+      i = TMath::Abs(AliPID::ParticleCode(fMinI));
+      j = daughter->GetPDG();
+      return (i == j);
+   }
+
+   // 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];
       }
-    }
-  }
-
-  // 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;
+      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;
 }
 
 //_________________________________________________________________________________________________
@@ -188,46 +178,41 @@ Int_t AliRsnCutPID::RealisticPID(AliRsnDaughter * const daughter, Double_t &prob
 // since the cut could require that it is larger than a threshold.
 //
 
-  // try to compute the weights
-  if (!ComputeWeights(daughter)) 
-  {
-    prob = -1.0;
-    return AliPID::kUnknown;
-  }
-  
-  // combine with priors and normalize
-  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");
-    prob = -1.0;
-    return AliPID::kUnknown;
-  }
-  for (i = 0; i < AliPID::kSPECIES; i++) w[i] /= sum;
-  
-  // find the largest probability and related PID
-  Int_t ibest = 0;
-  prob = w[0];
-  for (i = 1; i < AliPID::kSPECIES; i++)
-  {
-    if (w[i] > prob) 
-    {
-      prob = w[i];
-      ibest = i;
-    }
-  }
-  
-  // return the value, while the probability
-  // will be consequentially set
-  return ibest;
+   // try to compute the weights
+   if (!ComputeWeights(daughter)) {
+      prob = -1.0;
+      return AliPID::kUnknown;
+   }
+
+   // combine with priors and normalize
+   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");
+      prob = -1.0;
+      return AliPID::kUnknown;
+   }
+   for (i = 0; i < AliPID::kSPECIES; i++) w[i] /= sum;
+
+   // find the largest probability and related PID
+   Int_t ibest = 0;
+   prob = w[0];
+   for (i = 1; i < AliPID::kSPECIES; i++) {
+      if (w[i] > prob) {
+         prob = w[i];
+         ibest = i;
+      }
+   }
+
+   // return the value, while the probability
+   // will be consequentially set
+   return ibest;
 }
-  
+
 //_________________________________________________________________________________________________
 Int_t AliRsnCutPID::PerfectPID(AliRsnDaughter * const daughter)
 {
@@ -238,20 +223,19 @@ Int_t AliRsnCutPID::PerfectPID(AliRsnDaughter * const daughter)
 // into the enumeration from AliPID object.
 //
 
-  // works only if the MC is present
-  if (!daughter->GetRefMC()) return AliPID::kUnknown;
-  
-  // get the PDG code of the particle
-  Int_t pdg = daughter->GetPDG();
-  
-  // loop over all species listed in AliPID to find the match
-  Int_t i;
-  for (i = 0; i < AliPID::kSPECIES; i++)
-  {
-    if (AliPID::ParticleCode(i) == pdg) return i;
-  }
-  
-  return AliPID::kUnknown;
+   // works only if the MC is present
+   if (!daughter->GetRefMC()) return AliPID::kUnknown;
+
+   // get the PDG code of the particle
+   Int_t pdg = daughter->GetPDG();
+
+   // loop over all species listed in AliPID to find the match
+   Int_t i;
+   for (i = 0; i < AliPID::kSPECIES; i++) {
+      if (AliPID::ParticleCode(i) == pdg) return i;
+   }
+
+   return AliPID::kUnknown;
 }
 
 //_________________________________________________________________________________________________
@@ -260,35 +244,30 @@ Bool_t AliRsnCutPID::IsSelected(TObject *object)
 //
 // Cut checker.
 //
-  
-  // convert the object into the unique correct type
-  
-  if (!TargetOK(object))
-  {
-    AliError(Form("[%s]: this cut works only with AliRsnDaughter objects", GetName()));
-    return kTRUE;
-  }
-  
-  // if target is OK, do a dynamic cast
-  AliRsnDaughter *daughter = fDaughter;
-  
-  // depending on the PID type, recalls the appropriate method:
-  // in case of perfect PID, checks only if the PID type is 
-  // corresponding to the request in the cut (fMinI)
-  // while in case of realistic PID checks also the probability
-  // to be within the required interval
-  if (fPerfect && daughter)
-  {
-    fCutValueI = PerfectPID(daughter);
-    return OkValueI();
-  }
-  else if (daughter)
-  {
-    fCutValueI = RealisticPID(daughter, fCutValueD);
-    return OkValueI() && OkRangeD();
-  }
-  else
-    return kFALSE;
+
+   // convert the object into the unique correct type
+
+   if (!TargetOK(object)) {
+      AliError(Form("[%s]: this cut works only with AliRsnDaughter objects", GetName()));
+      return kTRUE;
+   }
+
+   // if target is OK, do a dynamic cast
+   AliRsnDaughter *daughter = fDaughter;
+
+   // depending on the PID type, recalls the appropriate method:
+   // in case of perfect PID, checks only if the PID type is
+   // corresponding to the request in the cut (fMinI)
+   // while in case of realistic PID checks also the probability
+   // to be within the required interval
+   if (fPerfect && daughter) {
+      fCutValueI = PerfectPID(daughter);
+      return OkValueI();
+   } else if (daughter) {
+      fCutValueI = RealisticPID(daughter, fCutValueD);
+      return OkValueI() && OkRangeD();
+   } else
+      return kFALSE;
 }
 
 //__________________________________________________________________________________________________
@@ -301,9 +280,9 @@ void AliRsnCutPID::IncludeDetector(EDetector det, Double_t threshold, Bool_t goA
 // By default the threshold is zero and detector is always used.
 //
 
-  if (!CheckBounds(det)) return;
-  
-  fUseDetector[det] = kTRUE;
-  fPtThreshold[det] = threshold;
-  fGoAboveThreshold[det] = goAbove;
+   if (!CheckBounds(det)) return;
+
+   fUseDetector[det] = kTRUE;
+   fPtThreshold[det] = threshold;
+   fGoAboveThreshold[det] = goAbove;
 }
index baf0748..ac23189 100644 (file)
 
 class AliRsnDaughter;
 
-class AliRsnCutPID : public AliRsnCut
-{
-  public:
-    
-    enum EDetector 
-    {
+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;}
-    
-    Bool_t         ComputeWeights(AliRsnDaughter *daughter);
-    Int_t          RealisticPID(AliRsnDaughter * const daughter, Double_t &prob);
-    Int_t          PerfectPID(AliRsnDaughter * const daughter);
-    Double_t       GetWeight(Int_t i) {if (i>=0&&i<AliPID::kSPECIES) return fWeight[i]; return 0.0;}
-
-    virtual Bool_t IsSelected(TObject *object);
-
-  protected:
-  
-    Bool_t   CheckBounds(EDetector det) const {return (det >= kITS && det < kDetectors);}
-    Bool_t   CheckThreshold(EDetector det, Double_t value);
-    
-    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)
+   };
+
+   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;}
+
+   Bool_t         ComputeWeights(AliRsnDaughter *daughter);
+   Int_t          RealisticPID(AliRsnDaughter * const daughter, Double_t &prob);
+   Int_t          PerfectPID(AliRsnDaughter * const daughter);
+   Double_t       GetWeight(Int_t i) {if (i >= 0 && i < AliPID::kSPECIES) return fWeight[i]; return 0.0;}
+
+   virtual Bool_t IsSelected(TObject *object);
+
+protected:
+
+   Bool_t   CheckBounds(EDetector det) const {return (det >= kITS && det < kDetectors);}
+   Bool_t   CheckThreshold(EDetector det, Double_t value);
+
+   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 ddec49a..82b2699 100644 (file)
@@ -26,14 +26,14 @@ ClassImp(AliRsnCutPIDITS)
 //_________________________________________________________________________________________________
 AliRsnCutPIDITS::AliRsnCutPIDITS
 (const char *name, AliPID::EParticleType ref, Double_t min, Double_t max, Bool_t rejectOutside) :
-  AliRsnCut(name, AliRsnCut::kDaughter, min, max),
-  fInitialized(kFALSE),
-  fRejectOutside(rejectOutside),
-  fMomMin(0.0),
-  fMomMax(1E+20),
-  fRefType(ref),
-  fESDpid(),
-  fAODpid()
+   AliRsnCut(name, AliRsnCut::kDaughter, min, max),
+   fInitialized(kFALSE),
+   fRejectOutside(rejectOutside),
+   fMomMin(0.0),
+   fMomMax(1E+20),
+   fRefType(ref),
+   fESDpid(),
+   fAODpid()
 {
 //
 // Main constructor.
@@ -43,14 +43,14 @@ AliRsnCutPIDITS::AliRsnCutPIDITS
 //_________________________________________________________________________________________________
 AliRsnCutPIDITS::AliRsnCutPIDITS
 (const AliRsnCutPIDITS& copy) :
-  AliRsnCut(copy),
-  fInitialized(kFALSE),
-  fRejectOutside(copy.fRejectOutside),
-  fMomMin(copy.fMomMin),
-  fMomMax(copy.fMomMax),
-  fRefType(copy.fRefType),
-  fESDpid(copy.fESDpid),
-  fAODpid(copy.fAODpid)
+   AliRsnCut(copy),
+   fInitialized(kFALSE),
+   fRejectOutside(copy.fRejectOutside),
+   fMomMin(copy.fMomMin),
+   fMomMax(copy.fMomMax),
+   fRefType(copy.fRefType),
+   fESDpid(copy.fESDpid),
+   fAODpid(copy.fAODpid)
 {
 //
 // Copy constructor.
@@ -64,17 +64,17 @@ AliRsnCutPIDITS& AliRsnCutPIDITS::operator=(const AliRsnCutPIDITS& copy)
 // Assignment operator
 //
 
-  AliRsnCut::operator=(copy);
+   AliRsnCut::operator=(copy);
 
-  fInitialized   = kFALSE;
-  fRejectOutside = copy.fRejectOutside;
-  fMomMin        = copy.fMomMin;
-  fMomMax        = copy.fMomMax;
-  fRefType       = copy.fRefType;
-  fESDpid        = copy.fESDpid;
-  fAODpid        = copy.fAODpid;
-  
-  return (*this);
+   fInitialized   = kFALSE;
+   fRejectOutside = copy.fRejectOutside;
+   fMomMin        = copy.fMomMin;
+   fMomMax        = copy.fMomMax;
+   fRefType       = copy.fRefType;
+   fESDpid        = copy.fESDpid;
+   fAODpid        = copy.fAODpid;
+
+   return (*this);
 }
 
 //_________________________________________________________________________________________________
@@ -84,10 +84,10 @@ void AliRsnCutPIDITS::SetMC(Bool_t yn)
 // Properly set the PID response
 //
 
-  AliITSPIDResponse itsresponse(yn);
-  
-  fESDpid.GetITSResponse() = itsresponse;
-  fAODpid.GetITSResponse() = itsresponse;
+   AliITSPIDResponse itsresponse(yn);
+
+   fESDpid.GetITSResponse() = itsresponse;
+   fAODpid.GetITSResponse() = itsresponse;
 }
 
 //_________________________________________________________________________________________________
@@ -97,76 +97,67 @@ Bool_t AliRsnCutPIDITS::IsSelected(TObject *object)
 // Cut checker.
 //
 
-  // initialize if needed
-  if (!fInitialized) Initialize();
-
-  // coherence check
-  if (!TargetOK(object)) return kFALSE;
-  
-  // reject not ITS tracks
-  // status is checked in the same way for all tracks
-  AliVTrack *vtrack = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
-  if (!vtrack)
-  {
-    AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
-    return kFALSE;
-  }
-  
-  // check status, to know it track is an ITS+TPC or ITS standalone
-  // and reject it if it is of none of them
-  Bool_t isSA = kFALSE;
-  if (IsTPC(vtrack)) isSA = kFALSE;
-  else if (IsSA(vtrack)) isSA = kTRUE;
-  else
-  {
-    AliDebug(AliLog::kDebug + 2, "Status flags unmatched");
-    return kFALSE;
-  }
-
-  // common evaluation variables
-  Int_t        k, nITSpidLayers = 0;
-  Double_t     mom      = vtrack->P();
-  AliESDtrack *esdTrack = fDaughter->GetRefESDtrack();
-  AliAODTrack *aodTrack = fDaughter->GetRefAODtrack();
-
-  // check momentum
-  if (mom < fMomMin || mom > fMomMax)
-  {
-    AliDebug(AliLog::kDebug + 2, Form("Track momentum = %.5f, outside allowed range", mom));
-    return (!fRejectOutside);
-  }
-
-  // count number of PID layers...
-  if (esdTrack) 
-  {
-    UChar_t itsCluMap = esdTrack->GetITSClusterMap();
-    for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITSpidLayers;
-  }
-  else if (aodTrack)
-  {
-    for(k = 2; k < 6; k++) if (TESTBIT(aodTrack->GetITSClusterMap(), k)) ++nITSpidLayers;
-  }
-  else
-  {
-    AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
-    return kFALSE;
-  }
-  // ...and reject tracks where it is smaller than 3
-  if (nITSpidLayers < 3)
-  {
-    AliDebug(AliLog::kDebug+2, "Rejecting track with too few ITS pid layers");
-    return kFALSE;
-  }
-    
-  // assign PID nsigmas to default cut check value
-  // since bad object types are rejected before, here we have an ESD track or AOD track
-  if (esdTrack) 
-    fCutValueD = fESDpid.GetITSResponse().GetNumberOfSigmas(mom, esdTrack->GetITSsignal(), fRefType, nITSpidLayers, isSA);
-  else
-    fCutValueD = fAODpid.NumberOfSigmasITS(aodTrack, fRefType);
-  
-  // use default cut checking method
-  return OkRangeD();
+   // initialize if needed
+   if (!fInitialized) Initialize();
+
+   // coherence check
+   if (!TargetOK(object)) return kFALSE;
+
+   // reject not ITS tracks
+   // status is checked in the same way for all tracks
+   AliVTrack *vtrack = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
+   if (!vtrack) {
+      AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
+      return kFALSE;
+   }
+
+   // check status, to know it track is an ITS+TPC or ITS standalone
+   // and reject it if it is of none of them
+   Bool_t isSA = kFALSE;
+   if (IsTPC(vtrack)) isSA = kFALSE;
+   else if (IsSA(vtrack)) isSA = kTRUE;
+   else {
+      AliDebug(AliLog::kDebug + 2, "Status flags unmatched");
+      return kFALSE;
+   }
+
+   // common evaluation variables
+   Int_t        k, nITSpidLayers = 0;
+   Double_t     mom      = vtrack->P();
+   AliESDtrack *esdTrack = fDaughter->GetRefESDtrack();
+   AliAODTrack *aodTrack = fDaughter->GetRefAODtrack();
+
+   // check momentum
+   if (mom < fMomMin || mom > fMomMax) {
+      AliDebug(AliLog::kDebug + 2, Form("Track momentum = %.5f, outside allowed range", mom));
+      return (!fRejectOutside);
+   }
+
+   // count number of PID layers...
+   if (esdTrack) {
+      UChar_t itsCluMap = esdTrack->GetITSClusterMap();
+      for (k = 2; k < 6; k++) if (itsCluMap & (1 << k)) ++nITSpidLayers;
+   } else if (aodTrack) {
+      for (k = 2; k < 6; k++) if (TESTBIT(aodTrack->GetITSClusterMap(), k)) ++nITSpidLayers;
+   } else {
+      AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
+      return kFALSE;
+   }
+   // ...and reject tracks where it is smaller than 3
+   if (nITSpidLayers < 3) {
+      AliDebug(AliLog::kDebug + 2, "Rejecting track with too few ITS pid layers");
+      return kFALSE;
+   }
+
+   // assign PID nsigmas to default cut check value
+   // since bad object types are rejected before, here we have an ESD track or AOD track
+   if (esdTrack)
+      fCutValueD = fESDpid.GetITSResponse().GetNumberOfSigmas(mom, esdTrack->GetITSsignal(), fRefType, nITSpidLayers, isSA);
+   else
+      fCutValueD = fAODpid.NumberOfSigmasITS(aodTrack, fRefType);
+
+   // use default cut checking method
+   return OkRangeD();
 }
 
 //_________________________________________________________________________________________________
@@ -176,10 +167,10 @@ void AliRsnCutPIDITS::Print(const Option_t *) const
 // Print information on this cut
 //
 
-  AliInfo(Form("Cut name                    : %s", GetName()));
-  AliInfo(Form("--> cut range (nsigma)      : %.3f %.3f", fMinD, fMaxD));
-  AliInfo(Form("--> momentum range          : %.3f %.3f", fMomMin, fMomMax));
-  AliInfo(Form("--> tracks outside range are: %s", (fRejectOutside ? "rejected" : "accepted")));
+   AliInfo(Form("Cut name                    : %s", GetName()));
+   AliInfo(Form("--> cut range (nsigma)      : %.3f %.3f", fMinD, fMaxD));
+   AliInfo(Form("--> momentum range          : %.3f %.3f", fMomMin, fMomMax));
+   AliInfo(Form("--> tracks outside range are: %s", (fRejectOutside ? "rejected" : "accepted")));
 }
 
 //_________________________________________________________________________________________________
@@ -189,13 +180,12 @@ void AliRsnCutPIDITS::Initialize()
 // Initialize ESD pid object from global one
 //
 
-  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
-  AliESDInputHandler *handler = dynamic_cast<AliESDInputHandler*>(mgr->GetInputEventHandler());
-  if (handler)
-  {
-    AliESDpid *pid = handler->GetESDpid();
-    fESDpid = (*pid);
-  }
-  
-  fInitialized = kTRUE;
+   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+   AliESDInputHandler *handler = dynamic_cast<AliESDInputHandler*>(mgr->GetInputEventHandler());
+   if (handler) {
+      AliESDpid *pid = handler->GetESDpid();
+      fESDpid = (*pid);
+   }
+
+   fInitialized = kTRUE;
 }
index 207cee8..7b5ae5a 100644 (file)
 #include "AliRsnDaughter.h"
 #include "AliRsnCut.h"
 
-class AliRsnCutPIDITS : public AliRsnCut
-{
-  public:
-
-    AliRsnCutPIDITS(const char *name          = "cutITS",
-                    EPARTYPE    ref           = AliPID::kKaon,
-                    Double_t    nSigmaMin     = -3.,
-                    Double_t    nSigmaMax     =  3.,
-                    Bool_t      rejectOutside = kTRUE);
-                    
-    AliRsnCutPIDITS(const AliRsnCutPIDITS& copy);
-    AliRsnCutPIDITS& operator=(const AliRsnCutPIDITS& copy);
-    virtual ~AliRsnCutPIDITS() { }
-
-    AliESDpid*       ESDpid()  {return &fESDpid;}
-    AliAODpidUtil*   AODpid()  {return &fAODpid;}
-
-    void             SetMC(Bool_t mc = kTRUE); 
-    void             SetRejectOutside(Bool_t yn = kTRUE)           {fRejectOutside = yn;}
-    void             SetMomentumRange(Double_t min, Double_t max)  {fMomMin = min; fMomMax = max;}
-    void             SetNSigmaRange(Double_t min, Double_t max)    {fMinD = min; fMaxD = max;}
-    void             SetRefType(EPARTYPE type)                     {fRefType = type;}
-
-    Bool_t           IsTPC(AliVTrack *vtrack);
-    Bool_t           IsSA(AliVTrack *vtrack);
-    virtual Bool_t   IsSelected(TObject *object);
-    virtual void     Print(const Option_t *option = "") const;
-
-  private:
-
-    void Initialize();
-
-    Bool_t          fInitialized;    // a mono-usage flag which initializes the ESD pid object
-    Bool_t          fRejectOutside;  // choose if tracks outside momentum range are rejected or not
-    Double_t        fMomMin;         // min p in range where this cut is checked
-    Double_t        fMomMax;         // max p in range where this cut is checked
-    EPARTYPE        fRefType;        // particle type for which PID is checked
-    AliESDpid       fESDpid;         // ESD PID object
-    AliAODpidUtil   fAODpid;         // AOD PID object
-
-    ClassDef(AliRsnCutPIDITS, 1)
+class AliRsnCutPIDITS : public AliRsnCut {
+public:
+
+   AliRsnCutPIDITS(const char *name          = "cutITS",
+                   EPARTYPE    ref           = AliPID::kKaon,
+                   Double_t    nSigmaMin     = -3.,
+                   Double_t    nSigmaMax     =  3.,
+                   Bool_t      rejectOutside = kTRUE);
+
+   AliRsnCutPIDITS(const AliRsnCutPIDITS& copy);
+   AliRsnCutPIDITS& operator=(const AliRsnCutPIDITS& copy);
+   virtual ~AliRsnCutPIDITS() { }
+
+   AliESDpid*       ESDpid()  {return &fESDpid;}
+   AliAODpidUtil*   AODpid()  {return &fAODpid;}
+
+   void             SetMC(Bool_t mc = kTRUE);
+   void             SetRejectOutside(Bool_t yn = kTRUE)           {fRejectOutside = yn;}
+   void             SetMomentumRange(Double_t min, Double_t max)  {fMomMin = min; fMomMax = max;}
+   void             SetNSigmaRange(Double_t min, Double_t max)    {fMinD = min; fMaxD = max;}
+   void             SetRefType(EPARTYPE type)                     {fRefType = type;}
+
+   Bool_t           IsTPC(AliVTrack *vtrack);
+   Bool_t           IsSA(AliVTrack *vtrack);
+   virtual Bool_t   IsSelected(TObject *object);
+   virtual void     Print(const Option_t *option = "") const;
+
+private:
+
+   void Initialize();
+
+   Bool_t          fInitialized;    // a mono-usage flag which initializes the ESD pid object
+   Bool_t          fRejectOutside;  // choose if tracks outside momentum range are rejected or not
+   Double_t        fMomMin;         // min p in range where this cut is checked
+   Double_t        fMomMax;         // max p in range where this cut is checked
+   EPARTYPE        fRefType;        // particle type for which PID is checked
+   AliESDpid       fESDpid;         // ESD PID object
+   AliAODpidUtil   fAODpid;         // AOD PID object
+
+   ClassDef(AliRsnCutPIDITS, 1)
 };
 
 inline Bool_t AliRsnCutPIDITS::IsTPC(AliVTrack *vtrack)
@@ -73,19 +72,18 @@ inline Bool_t AliRsnCutPIDITS::IsTPC(AliVTrack *vtrack)
 // Checks if the track has the status flags required for a global track
 //
 
-  if (!vtrack)
-  {
-    AliWarning("NULL argument: impossible to check status");
-    return kFALSE;
-  }
-  
-  Bool_t isTPCin     = ((vtrack->GetStatus() & AliESDtrack::kTPCin) != 0);
-  Bool_t isITSrefit  = ((vtrack->GetStatus() & AliESDtrack::kITSrefit) != 0);
-  Bool_t isITSpid    = ((vtrack->GetStatus() & AliESDtrack::kITSpid) != 0);
-  
-  return ( isTPCin && isITSrefit && isITSpid );
-  
-  return kTRUE;
+   if (!vtrack) {
+      AliWarning("NULL argument: impossible to check status");
+      return kFALSE;
+   }
+
+   Bool_t isTPCin     = ((vtrack->GetStatus() & AliESDtrack::kTPCin) != 0);
+   Bool_t isITSrefit  = ((vtrack->GetStatus() & AliESDtrack::kITSrefit) != 0);
+   Bool_t isITSpid    = ((vtrack->GetStatus() & AliESDtrack::kITSpid) != 0);
+
+   return (isTPCin && isITSrefit && isITSpid);
+
+   return kTRUE;
 }
 
 inline Bool_t AliRsnCutPIDITS::IsSA(AliVTrack *vtrack)
@@ -94,20 +92,19 @@ inline Bool_t AliRsnCutPIDITS::IsSA(AliVTrack *vtrack)
 // Checks if the track has the status flags required for an ITS standalone track
 //
 
-  if (!vtrack)
-  {
-    AliWarning("NULL argument: impossible to check status");
-    return kFALSE;
-  }
-  
-  Bool_t isTPCin     = ((vtrack->GetStatus() & AliESDtrack::kTPCin) != 0);
-  Bool_t isITSrefit  = ((vtrack->GetStatus() & AliESDtrack::kITSrefit) != 0);
-  Bool_t isITSpureSA = ((vtrack->GetStatus() & AliESDtrack::kITSpureSA) != 0);
-  Bool_t isITSpid    = ((vtrack->GetStatus() & AliESDtrack::kITSpid) != 0);
-  
-  return ( (!isTPCin) && isITSrefit && (!isITSpureSA) && isITSpid );
-  
-  return kTRUE;
+   if (!vtrack) {
+      AliWarning("NULL argument: impossible to check status");
+      return kFALSE;
+   }
+
+   Bool_t isTPCin     = ((vtrack->GetStatus() & AliESDtrack::kTPCin) != 0);
+   Bool_t isITSrefit  = ((vtrack->GetStatus() & AliESDtrack::kITSrefit) != 0);
+   Bool_t isITSpureSA = ((vtrack->GetStatus() & AliESDtrack::kITSpureSA) != 0);
+   Bool_t isITSpid    = ((vtrack->GetStatus() & AliESDtrack::kITSpid) != 0);
+
+   return ((!isTPCin) && isITSrefit && (!isITSpureSA) && isITSpid);
+
+   return kTRUE;
 }
 
 #endif
index 6b47b27..fd4b560 100644 (file)
@@ -21,13 +21,13 @@ ClassImp(AliRsnCutPIDTOF)
 //_________________________________________________________________________________________________
 AliRsnCutPIDTOF::AliRsnCutPIDTOF
 (const char *name, AliPID::EParticleType ref, Double_t min, Double_t max, Bool_t rejectUnmatched) :
-  AliRsnCut(name, AliRsnCut::kDaughter, min, max),
-  fInitialized(kFALSE),
-  fRejectUnmatched(rejectUnmatched),
-  fRefType(AliPID::kUnknown),
-  fRefMass(0.0),
-  fESDpid(),
-  fAODpid()
+   AliRsnCut(name, AliRsnCut::kDaughter, min, max),
+   fInitialized(kFALSE),
+   fRejectUnmatched(rejectUnmatched),
+   fRefType(AliPID::kUnknown),
+   fRefMass(0.0),
+   fESDpid(),
+   fAODpid()
 {
 //
 // Default constructor.
@@ -35,18 +35,18 @@ AliRsnCutPIDTOF::AliRsnCutPIDTOF
 // which sets the mass accordingly and coherently.
 //
 
-  SetRefType(ref);
+   SetRefType(ref);
 }
 
 //_________________________________________________________________________________________________
 AliRsnCutPIDTOF::AliRsnCutPIDTOF(const AliRsnCutPIDTOF& copy) :
-  AliRsnCut(copy),
-  fInitialized(kFALSE),
-  fRejectUnmatched(copy.fRejectUnmatched),
-  fRefType(AliPID::kUnknown),
-  fRefMass(0.0),
-  fESDpid(copy.fESDpid),
-  fAODpid(copy.fAODpid)
+   AliRsnCut(copy),
+   fInitialized(kFALSE),
+   fRejectUnmatched(copy.fRejectUnmatched),
+   fRefType(AliPID::kUnknown),
+   fRefMass(0.0),
+   fESDpid(copy.fESDpid),
+   fAODpid(copy.fAODpid)
 {
 //
 // Copy constructor.
@@ -54,7 +54,7 @@ AliRsnCutPIDTOF::AliRsnCutPIDTOF(const AliRsnCutPIDTOF& copy) :
 // which sets the mass accordingly and coherently.
 //
 
-  SetRefType(copy.fRefType);
+   SetRefType(copy.fRefType);
 }
 
 //_________________________________________________________________________________________________
@@ -66,14 +66,14 @@ AliRsnCutPIDTOF& AliRsnCutPIDTOF::operator=(const AliRsnCutPIDTOF& copy)
 // which sets the mass accordingly and coherently.
 //
 
-  fInitialized     = kFALSE;
-  fRejectUnmatched = copy.fRejectUnmatched;
-  fESDpid          = copy.fESDpid;
-  fAODpid          = copy.fAODpid;
+   fInitialized     = kFALSE;
+   fRejectUnmatched = copy.fRejectUnmatched;
+   fESDpid          = copy.fESDpid;
+   fAODpid          = copy.fAODpid;
 
-  SetRefType(copy.fRefType);
-  
-  return (*this);
+   SetRefType(copy.fRefType);
+
+   return (*this);
 }
 
 //_________________________________________________________________________________________________
@@ -83,70 +83,62 @@ Bool_t AliRsnCutPIDTOF::IsSelected(TObject *object)
 // Cut checker.
 //
 
-  // initialize if needed
-  if (!fInitialized) Initialize();
-
-  // coherence check
-  if (!TargetOK(object)) return kFALSE;
-  
-  // reject always non-track objects
-  AliVTrack *vtrack = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
-  if (!vtrack)
-  {
-    AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
-    return kFALSE;
-  }
-  
-  // checks that track is matched in TOF:
-  // if not, the track is accepted or rejected
-  // depending on the 'fRejectUnmatched' data member:
-  // -- kTRUE  --> all unmatched tracks are rejected
-  // -- kFALSE --> all unmatched tracks are accepted (it is assumed that other PIDs are done)
-  if (!IsMatched(vtrack))
-  {
-    AliDebug(AliLog::kDebug + 2, "Track is not matched with TOF");
-    return (!fRejectUnmatched);
-  }
-  
-  // retrieve real object type and
-  // prepare some useful variables
-  Double_t     tof, sigma, times[5];
-  Double_t    &ref = times[(Int_t)fRefType];
-  AliESDtrack *esdTrack = fDaughter->GetRefESDtrack();
-  AliAODTrack *aodTrack = fDaughter->GetRefAODtrack();
-
-  // cut check depends on the object type
-  if (esdTrack) 
-  {
-    // setup the ESD PID object
-    AliESDEvent *esd = AliRsnTarget::GetCurrentEvent()->GetRefESD();
-    if (!esd)
-    {
-      AliError("Processing an ESD track, but target is not an ESD event");
+   // initialize if needed
+   if (!fInitialized) Initialize();
+
+   // coherence check
+   if (!TargetOK(object)) return kFALSE;
+
+   // reject always non-track objects
+   AliVTrack *vtrack = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
+   if (!vtrack) {
+      AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
       return kFALSE;
-    }
-    fESDpid.SetTOFResponse(esd, AliESDpid::kTOF_T0);
-
-    // get time of flight, reference times and sigma
-    esdTrack->GetIntegratedTimes(times);
-    tof   = (Double_t)(esdTrack->GetTOFsignal() - fESDpid.GetTOFResponse().GetStartTime(esdTrack->P()));
-    sigma = (Double_t)fESDpid.GetTOFResponse().GetExpectedSigma(esdTrack->P(), ref, fRefMass);
-
-    // port values to standard AliRsnCut checker
-    fCutValueD = (tof - ref) / sigma;
-    return OkRangeD();
-  }
-  else if (aodTrack)
-  {
-    // for AOD tracks, all operations are done by the AOD PID utility
-    fCutValueD = (Double_t)fAODpid.NumberOfSigmasTOF(aodTrack, fRefType);
-    return OkRangeD();
-  }
-  else
-  {
-    AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
-    return kFALSE;
-  }
+   }
+
+   // checks that track is matched in TOF:
+   // if not, the track is accepted or rejected
+   // depending on the 'fRejectUnmatched' data member:
+   // -- kTRUE  --> all unmatched tracks are rejected
+   // -- kFALSE --> all unmatched tracks are accepted (it is assumed that other PIDs are done)
+   if (!IsMatched(vtrack)) {
+      AliDebug(AliLog::kDebug + 2, "Track is not matched with TOF");
+      return (!fRejectUnmatched);
+   }
+
+   // retrieve real object type and
+   // prepare some useful variables
+   Double_t     tof, sigma, times[5];
+   Double_t    &ref = times[(Int_t)fRefType];
+   AliESDtrack *esdTrack = fDaughter->GetRefESDtrack();
+   AliAODTrack *aodTrack = fDaughter->GetRefAODtrack();
+
+   // cut check depends on the object type
+   if (esdTrack) {
+      // setup the ESD PID object
+      AliESDEvent *esd = AliRsnTarget::GetCurrentEvent()->GetRefESD();
+      if (!esd) {
+         AliError("Processing an ESD track, but target is not an ESD event");
+         return kFALSE;
+      }
+      fESDpid.SetTOFResponse(esd, AliESDpid::kTOF_T0);
+
+      // get time of flight, reference times and sigma
+      esdTrack->GetIntegratedTimes(times);
+      tof   = (Double_t)(esdTrack->GetTOFsignal() - fESDpid.GetTOFResponse().GetStartTime(esdTrack->P()));
+      sigma = (Double_t)fESDpid.GetTOFResponse().GetExpectedSigma(esdTrack->P(), ref, fRefMass);
+
+      // port values to standard AliRsnCut checker
+      fCutValueD = (tof - ref) / sigma;
+      return OkRangeD();
+   } else if (aodTrack) {
+      // for AOD tracks, all operations are done by the AOD PID utility
+      fCutValueD = (Double_t)fAODpid.NumberOfSigmasTOF(aodTrack, fRefType);
+      return OkRangeD();
+   } else {
+      AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
+      return kFALSE;
+   }
 }
 
 //_________________________________________________________________________________________________
@@ -156,9 +148,9 @@ void AliRsnCutPIDTOF::Print(const Option_t *) const
 // Print information on this cut
 //
 
-  AliInfo(Form("Cut name, type            : %s %s", GetName(), ClassName()));
-  AliInfo(Form("TOF PID cut range (sigmas): %.3f %.3f", fMinD, fMaxD));
-  AliInfo(Form("Unmatched tracks are      : %s", (fRejectUnmatched ? "rejected" : "accepted")));
+   AliInfo(Form("Cut name, type            : %s %s", GetName(), ClassName()));
+   AliInfo(Form("TOF PID cut range (sigmas): %.3f %.3f", fMinD, fMaxD));
+   AliInfo(Form("Unmatched tracks are      : %s", (fRejectUnmatched ? "rejected" : "accepted")));
 }
 
 //_________________________________________________________________________________________________
@@ -168,13 +160,12 @@ void AliRsnCutPIDTOF::Initialize()
 // Initialize ESD pid object from global one
 //
 
-  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
-  AliESDInputHandler *handler = dynamic_cast<AliESDInputHandler*>(mgr->GetInputEventHandler());
-  if (handler)
-  {
-    AliESDpid *pid = handler->GetESDpid();
-    fESDpid = (*pid);
-  }
-  
-  fInitialized = kTRUE;
+   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+   AliESDInputHandler *handler = dynamic_cast<AliESDInputHandler*>(mgr->GetInputEventHandler());
+   if (handler) {
+      AliESDpid *pid = handler->GetESDpid();
+      fESDpid = (*pid);
+   }
+
+   fInitialized = kTRUE;
 }
index 1c92c3b..67dc986 100644 (file)
 #include "AliRsnDaughter.h"
 #include "AliRsnCut.h"
 
-class AliRsnCutPIDTOF : public AliRsnCut
-{
-  public:
-
-    AliRsnCutPIDTOF(const char *name            = "cutTOF",
-                    EPARTYPE    particle        = AliPID::kKaon,
-                    Double_t    nSigmaMin       = -3.,
-                    Double_t    nSigmaMax       =  3.,
-                    Bool_t      rejectUnmatched = kFALSE);
-                    
-    AliRsnCutPIDTOF(const AliRsnCutPIDTOF& copy);
-    AliRsnCutPIDTOF& operator=(const AliRsnCutPIDTOF& copy);
-    virtual ~AliRsnCutPIDTOF() { }
-
-    AliESDpid*      ESDpid()  {return &fESDpid;}
-    AliAODpidUtil*  AODpid()  {return &fAODpid;}
-    
-    void            SetRejectUnmatched(Bool_t yn = kTRUE)      {fRejectUnmatched = yn;}
-    void            SetNSigmaRange(Double_t min, Double_t max) {fMinD = min; fMaxD = max;}
-    void            SetRefType(EPARTYPE type)                  {fRefType = type; fRefMass = AliPID::ParticleMass(type);}
-
-    Bool_t          IsMatched(AliVTrack *vtrack);
-    virtual Bool_t  IsSelected(TObject *object);
-    virtual void    Print(const Option_t *option = "") const;
-
-  private:
-
-    void Initialize();
-
-    Bool_t            fInitialized;      // a mono-usage flag which initializes the ESD pid object
-    Bool_t            fRejectUnmatched;  //  decide if non TOF matched tracks pass the cut or not
-    EPARTYPE          fRefType;          //  particle type for which PID is checked   
-    Double_t          fRefMass;          //  reference mass used for computations
-    AliESDpid         fESDpid;           //  PID utility for ESD
-    AliAODpidUtil     fAODpid;           //  PID utility for AOD
-
-    ClassDef(AliRsnCutPIDTOF, 1)
+class AliRsnCutPIDTOF : public AliRsnCut {
+public:
+
+   AliRsnCutPIDTOF(const char *name            = "cutTOF",
+                   EPARTYPE    particle        = AliPID::kKaon,
+                   Double_t    nSigmaMin       = -3.,
+                   Double_t    nSigmaMax       =  3.,
+                   Bool_t      rejectUnmatched = kFALSE);
+
+   AliRsnCutPIDTOF(const AliRsnCutPIDTOF& copy);
+   AliRsnCutPIDTOF& operator=(const AliRsnCutPIDTOF& copy);
+   virtual ~AliRsnCutPIDTOF() { }
+
+   AliESDpid*      ESDpid()  {return &fESDpid;}
+   AliAODpidUtil*  AODpid()  {return &fAODpid;}
+
+   void            SetRejectUnmatched(Bool_t yn = kTRUE)      {fRejectUnmatched = yn;}
+   void            SetNSigmaRange(Double_t min, Double_t max) {fMinD = min; fMaxD = max;}
+   void            SetRefType(EPARTYPE type)                  {fRefType = type; fRefMass = AliPID::ParticleMass(type);}
+
+   Bool_t          IsMatched(AliVTrack *vtrack);
+   virtual Bool_t  IsSelected(TObject *object);
+   virtual void    Print(const Option_t *option = "") const;
+
+private:
+
+   void Initialize();
+
+   Bool_t            fInitialized;      // a mono-usage flag which initializes the ESD pid object
+   Bool_t            fRejectUnmatched;  //  decide if non TOF matched tracks pass the cut or not
+   EPARTYPE          fRefType;          //  particle type for which PID is checked
+   Double_t          fRefMass;          //  reference mass used for computations
+   AliESDpid         fESDpid;           //  PID utility for ESD
+   AliAODpidUtil     fAODpid;           //  PID utility for AOD
+
+   ClassDef(AliRsnCutPIDTOF, 1)
 };
 
 inline Bool_t AliRsnCutPIDTOF::IsMatched(AliVTrack *vtrack)
@@ -68,24 +67,23 @@ inline Bool_t AliRsnCutPIDTOF::IsMatched(AliVTrack *vtrack)
 // Checks if the track has the status flags required for an ITS standalone track
 //
 
-  if (!vtrack)
-  {
-    AliWarning("NULL argument: impossible to check status");
-    return kFALSE;
-  }
+   if (!vtrack) {
+      AliWarning("NULL argument: impossible to check status");
+      return kFALSE;
+   }
 
-  Bool_t isTOFout = ((vtrack->GetStatus() & AliESDtrack::kTOFout) != 0);
-  Bool_t isTIME   = ((vtrack->GetStatus() & AliESDtrack::kTIME) != 0);
+   Bool_t isTOFout = ((vtrack->GetStatus() & AliESDtrack::kTOFout) != 0);
+   Bool_t isTIME   = ((vtrack->GetStatus() & AliESDtrack::kTIME) != 0);
 
-  // if flags are not set, track is not matched
-  if ( !isTOFout || !isTIME ) return kFALSE;
+   // if flags are not set, track is not matched
+   if (!isTOFout || !isTIME) return kFALSE;
 
-  // do an additional check on integrated length for ESD tracks
-  AliESDtrack *esdTrack = dynamic_cast<AliESDtrack*>(vtrack);
-  if (esdTrack) if (esdTrack->GetIntegratedLength() < 350.) return kFALSE;
+   // do an additional check on integrated length for ESD tracks
+   AliESDtrack *esdTrack = dynamic_cast<AliESDtrack*>(vtrack);
+   if (esdTrack) if (esdTrack->GetIntegratedLength() < 350.) return kFALSE;
 
-  // if we are here, flags are OK and length also
-  return kTRUE;
+   // if we are here, flags are OK and length also
+   return kTRUE;
 }
 
 #endif
index 5e9aa7e..aaf928c 100644 (file)
@@ -25,14 +25,14 @@ ClassImp(AliRsnCutPIDTPC)
 //_________________________________________________________________________________________________
 AliRsnCutPIDTPC::AliRsnCutPIDTPC
 (const char *name, AliPID::EParticleType type, Double_t min, Double_t max, Bool_t rejectOutside) :
-  AliRsnCut(name, AliRsnCut::kDaughter, min, max),
-  fInitialized(kFALSE),
-  fRejectOutside(rejectOutside),
-  fMomMin(0.0),
-  fMomMax(1E+20),
-  fRefType(type),
-  fESDpid(),
-  fAODpid()
+   AliRsnCut(name, AliRsnCut::kDaughter, min, max),
+   fInitialized(kFALSE),
+   fRejectOutside(rejectOutside),
+   fMomMin(0.0),
+   fMomMax(1E+20),
+   fRefType(type),
+   fESDpid(),
+   fAODpid()
 {
 //
 // Main constructor.
@@ -42,14 +42,14 @@ AliRsnCutPIDTPC::AliRsnCutPIDTPC
 //_________________________________________________________________________________________________
 AliRsnCutPIDTPC::AliRsnCutPIDTPC
 (const AliRsnCutPIDTPC& copy) :
-  AliRsnCut(copy),
-  fInitialized(kFALSE),
-  fRejectOutside(copy.fRejectOutside),
-  fMomMin(copy.fMomMin),
-  fMomMax(copy.fMomMax),
-  fRefType(copy.fRefType),
-  fESDpid(copy.fESDpid),
-  fAODpid(copy.fAODpid)
+   AliRsnCut(copy),
+   fInitialized(kFALSE),
+   fRejectOutside(copy.fRejectOutside),
+   fMomMin(copy.fMomMin),
+   fMomMax(copy.fMomMax),
+   fRefType(copy.fRefType),
+   fESDpid(copy.fESDpid),
+   fAODpid(copy.fAODpid)
 {
 //
 // Copy constructor.
@@ -63,17 +63,17 @@ AliRsnCutPIDTPC& AliRsnCutPIDTPC::operator=(const AliRsnCutPIDTPC& copy)
 // Assignment operator
 //
 
-  AliRsnCut::operator=(copy);
+   AliRsnCut::operator=(copy);
 
-  fInitialized   = kFALSE;
-  fRejectOutside = copy.fRejectOutside;
-  fMomMin        = copy.fMomMin;
-  fMomMax        = copy.fMomMax;
-  fRefType       = copy.fRefType;
-  fESDpid        = copy.fESDpid;
-  fAODpid        = copy.fAODpid;
-  
-  return (*this);
+   fInitialized   = kFALSE;
+   fRejectOutside = copy.fRejectOutside;
+   fMomMin        = copy.fMomMin;
+   fMomMax        = copy.fMomMax;
+   fRefType       = copy.fRefType;
+   fESDpid        = copy.fESDpid;
+   fAODpid        = copy.fAODpid;
+
+   return (*this);
 }
 
 //_________________________________________________________________________________________________
@@ -83,8 +83,8 @@ void AliRsnCutPIDTPC::SetBBParam(Double_t p0, Double_t p1, Double_t p2, Double_t
 // Properly set the Bethe-Bloch parameters in all places where it is needed.
 //
 
-  fESDpid.GetTPCResponse().SetBetheBlochParameters(p0, p1, p2, p3, p4);
-  fAODpid.GetTPCResponse().SetBetheBlochParameters(p0, p1, p2, p3, p4);
+   fESDpid.GetTPCResponse().SetBetheBlochParameters(p0, p1, p2, p3, p4);
+   fAODpid.GetTPCResponse().SetBetheBlochParameters(p0, p1, p2, p3, p4);
 }
 
 //_________________________________________________________________________________________________
@@ -94,52 +94,49 @@ Bool_t AliRsnCutPIDTPC::IsSelected(TObject *object)
 // Cut checker.
 //
 
-  // initialize if needed
-  if (!fInitialized) Initialize();
-
-  // coherence check
-  if (!TargetOK(object)) return kFALSE;
-  
-  // reject not TPC tracks
-  AliVTrack *vtrack = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
-  if (!vtrack) return kFALSE;
-  if (!IsTPC(vtrack))
-  {
-    AliDebug(AliLog::kDebug + 2, "Track is not found in TPC");
-    return kFALSE;
-  }
-  
-  // common evaluation variables
-  Double_t     mom;
-  AliESDtrack *esdTrack = fDaughter->GetRefESDtrack();
-  AliAODTrack *aodTrack = fDaughter->GetRefAODtrack();
-
-  // get inner momentum and check it w.r. to allowed range:
-  // all tracks outside it will pass the cut or not, depending on 'fRejectOutside'
-  if (esdTrack)
-    mom = esdTrack->GetInnerParam()->P();
-  else if (aodTrack)
-    mom = aodTrack->GetDetPid()->GetTPCmomentum();
-  else
-  {
-    AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
-    return kFALSE;
-  }
-  if ((mom < fMomMin || mom > fMomMax))
-  {
-    AliDebug(AliLog::kDebug + 2, Form("Track momentum = %.5f, outside allowed range", mom));
-    return (!fRejectOutside);
-  }
-
-  // assign PID nsigmas to default cut check value
-  // since bad object types are rejected before, here we have an ESD track or AOD track
-  if (esdTrack) 
-    fCutValueD = fESDpid.GetTPCResponse().GetNumberOfSigmas(mom, esdTrack->GetTPCsignal(), esdTrack->GetTPCsignalN(), fRefType);
-  else
-    fCutValueD = fAODpid.NumberOfSigmasTPC(aodTrack, fRefType);
-
-  // use AliRsnCut default method to check cut
-  return OkRangeD();
+   // initialize if needed
+   if (!fInitialized) Initialize();
+
+   // coherence check
+   if (!TargetOK(object)) return kFALSE;
+
+   // reject not TPC tracks
+   AliVTrack *vtrack = dynamic_cast<AliVTrack*>(fDaughter->GetRef());
+   if (!vtrack) return kFALSE;
+   if (!IsTPC(vtrack)) {
+      AliDebug(AliLog::kDebug + 2, "Track is not found in TPC");
+      return kFALSE;
+   }
+
+   // common evaluation variables
+   Double_t     mom;
+   AliESDtrack *esdTrack = fDaughter->GetRefESDtrack();
+   AliAODTrack *aodTrack = fDaughter->GetRefAODtrack();
+
+   // get inner momentum and check it w.r. to allowed range:
+   // all tracks outside it will pass the cut or not, depending on 'fRejectOutside'
+   if (esdTrack)
+      mom = esdTrack->GetInnerParam()->P();
+   else if (aodTrack)
+      mom = aodTrack->GetDetPid()->GetTPCmomentum();
+   else {
+      AliDebug(AliLog::kDebug + 2, Form("Impossible to process an object of type '%s'. Cut applicable only to ESD/AOD tracks", fDaughter->GetRef()->ClassName()));
+      return kFALSE;
+   }
+   if ((mom < fMomMin || mom > fMomMax)) {
+      AliDebug(AliLog::kDebug + 2, Form("Track momentum = %.5f, outside allowed range", mom));
+      return (!fRejectOutside);
+   }
+
+   // assign PID nsigmas to default cut check value
+   // since bad object types are rejected before, here we have an ESD track or AOD track
+   if (esdTrack)
+      fCutValueD = fESDpid.GetTPCResponse().GetNumberOfSigmas(mom, esdTrack->GetTPCsignal(), esdTrack->GetTPCsignalN(), fRefType);
+   else
+      fCutValueD = fAODpid.NumberOfSigmasTPC(aodTrack, fRefType);
+
+   // use AliRsnCut default method to check cut
+   return OkRangeD();
 }
 
 //_________________________________________________________________________________________________
@@ -149,10 +146,10 @@ void AliRsnCutPIDTPC::Print(const Option_t *) const
 // Print information on this cut
 //
 
-  AliInfo(Form("Cut name                    : %s", GetName()));
-  AliInfo(Form("--> cut range (nsigma)      : %.3f %.3f", fMinD, fMaxD));
-  AliInfo(Form("--> momentum range          : %.3f %.3f", fMomMin, fMomMax));
-  AliInfo(Form("--> tracks outside range are: %s", (fRejectOutside ? "rejected" : "accepted")));
+   AliInfo(Form("Cut name                    : %s", GetName()));
+   AliInfo(Form("--> cut range (nsigma)      : %.3f %.3f", fMinD, fMaxD));
+   AliInfo(Form("--> momentum range          : %.3f %.3f", fMomMin, fMomMax));
+   AliInfo(Form("--> tracks outside range are: %s", (fRejectOutside ? "rejected" : "accepted")));
 }
 
 //_________________________________________________________________________________________________
@@ -162,13 +159,12 @@ void AliRsnCutPIDTPC::Initialize()
 // Initialize ESD pid object from global one
 //
 
-  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
-  AliESDInputHandler *handler = dynamic_cast<AliESDInputHandler*>(mgr->GetInputEventHandler());
-  if (handler)
-  {
-    AliESDpid *pid = handler->GetESDpid();
-    fESDpid = (*pid);
-  }
+   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+   AliESDInputHandler *handler = dynamic_cast<AliESDInputHandler*>(mgr->GetInputEventHandler());
+   if (handler) {
+      AliESDpid *pid = handler->GetESDpid();
+      fESDpid = (*pid);
+   }
 
-  fInitialized = kTRUE;
+   fInitialized = kTRUE;
 }
index 1d80f7e..1adf970 100644 (file)
 #include "AliRsnDaughter.h"
 #include "AliRsnCut.h"
 
-class AliRsnCutPIDTPC : public AliRsnCut
-{
-  public:
-
-    AliRsnCutPIDTPC(const char *name       = "cutTPC",
-                    EPARTYPE type          = AliPID::kKaon,
-                    Double_t nSigmaMin     = -3.,
-                    Double_t nSigmaMax     =  3.,
-                    Bool_t   rejectOutside = kTRUE);
-                    
-    AliRsnCutPIDTPC(const AliRsnCutPIDTPC& copy);
-    AliRsnCutPIDTPC& operator=(const AliRsnCutPIDTPC& copy);
-    virtual ~AliRsnCutPIDTPC() { }
-
-    AliESDpid*       ESDpid()  {return &fESDpid;}
-    AliAODpidUtil*   AODpid()  {return &fAODpid;}
-
-    void             SetRejectOutside(Bool_t yn = kTRUE)           {fRejectOutside = yn;}
-    void             SetMomentumRange(Double_t min, Double_t max)  {fMomMin = min; fMomMax = max;}
-    void             SetNSigmaRange(Double_t min, Double_t max)    {fMinD = min; fMaxD = max;}
-    void             SetRefType(EPARTYPE type)                     {fRefType = type;}
-    void             SetBBParam(Double_t *p)                       {SetBBParam(p[0], p[1], p[2], p[3], p[4]);}
-    void             SetBBParam(Double_t p0, Double_t p1, Double_t p2, Double_t p3, Double_t p4);
-
-    Bool_t           IsTPC(AliVTrack *vtrack);
-    virtual Bool_t   IsSelected(TObject *object);
-    virtual void     Print(const Option_t *option = "") const;
-
-  private:
-
-    void Initialize();
-
-    Bool_t          fInitialized;    // a mono-usage flag which initializes the ESD pid object
-    Bool_t          fRejectOutside;  // choose if tracks outside momentum range are rejected or not
-    Double_t        fMomMin;         // min p in range where this cut is checked
-    Double_t        fMomMax;         // max p in range where this cut is checked
-    EPARTYPE        fRefType;        // particle type for which PID is checked
-    AliESDpid       fESDpid;         // ESD PID object
-    AliAODpidUtil   fAODpid;         // AOD PID object
-
-    ClassDef(AliRsnCutPIDTPC, 1)
+class AliRsnCutPIDTPC : public AliRsnCut {
+public:
+
+   AliRsnCutPIDTPC(const char *name       = "cutTPC",
+                   EPARTYPE type          = AliPID::kKaon,
+                   Double_t nSigmaMin     = -3.,
+                   Double_t nSigmaMax     =  3.,
+                   Bool_t   rejectOutside = kTRUE);
+
+   AliRsnCutPIDTPC(const AliRsnCutPIDTPC& copy);
+   AliRsnCutPIDTPC& operator=(const AliRsnCutPIDTPC& copy);
+   virtual ~AliRsnCutPIDTPC() { }
+
+   AliESDpid*       ESDpid()  {return &fESDpid;}
+   AliAODpidUtil*   AODpid()  {return &fAODpid;}
+
+   void             SetRejectOutside(Bool_t yn = kTRUE)           {fRejectOutside = yn;}
+   void             SetMomentumRange(Double_t min, Double_t max)  {fMomMin = min; fMomMax = max;}
+   void             SetNSigmaRange(Double_t min, Double_t max)    {fMinD = min; fMaxD = max;}
+   void             SetRefType(EPARTYPE type)                     {fRefType = type;}
+   void             SetBBParam(Double_t *p)                       {SetBBParam(p[0], p[1], p[2], p[3], p[4]);}
+   void             SetBBParam(Double_t p0, Double_t p1, Double_t p2, Double_t p3, Double_t p4);
+
+   Bool_t           IsTPC(AliVTrack *vtrack);
+   virtual Bool_t   IsSelected(TObject *object);
+   virtual void     Print(const Option_t *option = "") const;
+
+private:
+
+   void Initialize();
+
+   Bool_t          fInitialized;    // a mono-usage flag which initializes the ESD pid object
+   Bool_t          fRejectOutside;  // choose if tracks outside momentum range are rejected or not
+   Double_t        fMomMin;         // min p in range where this cut is checked
+   Double_t        fMomMax;         // max p in range where this cut is checked
+   EPARTYPE        fRefType;        // particle type for which PID is checked
+   AliESDpid       fESDpid;         // ESD PID object
+   AliAODpidUtil   fAODpid;         // AOD PID object
+
+   ClassDef(AliRsnCutPIDTPC, 1)
 };
 
 inline Bool_t AliRsnCutPIDTPC::IsTPC(AliVTrack *vtrack)
@@ -73,19 +72,18 @@ inline Bool_t AliRsnCutPIDTPC::IsTPC(AliVTrack *vtrack)
 // Checks if the track has the status flags required for a global track
 //
 
-  if (!vtrack)
-  {
-    AliWarning("NULL argument: impossible to check status");
-    return kFALSE;
-  }
-  
-  Bool_t isTPCin     = ((vtrack->GetStatus() & AliESDtrack::kTPCin) != 0);
-  Bool_t isITSrefit  = ((vtrack->GetStatus() & AliESDtrack::kITSrefit) != 0);
-  Bool_t isITSpid    = ((vtrack->GetStatus() & AliESDtrack::kITSpid) != 0);
-  
-  return ( isTPCin && isITSrefit && isITSpid );
-  
-  return kTRUE;
+   if (!vtrack) {
+      AliWarning("NULL argument: impossible to check status");
+      return kFALSE;
+   }
+
+   Bool_t isTPCin     = ((vtrack->GetStatus() & AliESDtrack::kTPCin) != 0);
+   Bool_t isITSrefit  = ((vtrack->GetStatus() & AliESDtrack::kITSrefit) != 0);
+   Bool_t isITSpid    = ((vtrack->GetStatus() & AliESDtrack::kITSpid) != 0);
+
+   return (isTPCin && isITSrefit && isITSpid);
+
+   return kTRUE;
 }
 
 #endif
index afc75eb..48ac81e 100644 (file)
@@ -15,9 +15,9 @@ ClassImp(AliRsnCutPrimaryVertex)
 //_________________________________________________________________________________________________
 AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex
 (const char *name, Double_t maxVz, Int_t nContributors, Bool_t acceptTPC) :
-  AliRsnCut(name, AliRsnCut::kEvent, 0, nContributors - 1, 0.0, maxVz),
-  fAcceptTPC(acceptTPC),
-  fCheckPileUp(kFALSE)
+   AliRsnCut(name, AliRsnCut::kEvent, 0, nContributors - 1, 0.0, maxVz),
+   fAcceptTPC(acceptTPC),
+   fCheckPileUp(kFALSE)
 {
 //
 // Main constructor.
@@ -34,8 +34,8 @@ AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex
 // must be decreased by 1 to get the right behaviour, since this is integer.
 //
 
-  fMinD = 0.0;
-  fMaxD = maxVz + 1E-6;
+   fMinD = 0.0;
+   fMaxD = maxVz + 1E-6;
 }
 
 //_________________________________________________________________________________________________
@@ -44,84 +44,71 @@ Bool_t AliRsnCutPrimaryVertex::IsSelected(TObject *object)
 //
 // Cut checker
 //
-  
-  // retrieve ESD event
-  AliRsnEvent *rsn = dynamic_cast<AliRsnEvent*>(object);
-  if (!rsn) return kFALSE;
-  AliESDEvent *esd = rsn->GetRefESD();
-  AliAODEvent *aod = rsn->GetRefAOD();
-  
-  if (esd)
-  {
-    // pile-up check
-    if (fCheckPileUp)
-    {
-      if (esd->IsPileupFromSPD()) return kFALSE;
-    }
-    
-    // get the best primary vertex:
-    // first try the one with tracks
-    const AliESDVertex *vTrk  = esd->GetPrimaryVertexTracks();
-    const AliESDVertex *vSPD  = esd->GetPrimaryVertexSPD();
-    const AliESDVertex *vTPC  = esd->GetPrimaryVertexTPC();
-    Int_t               ncTrk = -1;
-    Int_t               ncSPD = -1;
-    Int_t               ncTPC = -1;
-    Double_t            vzTrk = 1000000.0;
-    Double_t            vzSPD = 1000000.0;
-    Double_t            vzTPC = 1000000.0;
-    if (vTrk) vzTrk = TMath::Abs(vTrk->GetZv());
-    if (vSPD) vzSPD = TMath::Abs(vSPD->GetZv());
-    if (vTPC) vzTPC = TMath::Abs(vTPC->GetZv());
-    if (vTrk) ncTrk = (Int_t)vTrk->GetNContributors();
-    if (vSPD) ncSPD = (Int_t)vSPD->GetNContributors();
-    if (vTPC) ncTPC = (Int_t)vTPC->GetNContributors();
-    if(vTrk && ncTrk > 0)
-    {
-      fCutValueI = ncTrk;
-      fCutValueD = vzTrk;
-    }
-    else if (vSPD && ncSPD > 0)
-    {
-      fCutValueI = ncSPD;
-      fCutValueD = vzSPD;
-    }
-    else if (vTPC && ncTPC > 0)
-    {
-      if (!fAcceptTPC) 
-        return kFALSE;
-      else
-      {
-        fCutValueI = ncTPC;
-        fCutValueD = vzTPC;
+
+   // retrieve ESD event
+   AliRsnEvent *rsn = dynamic_cast<AliRsnEvent*>(object);
+   if (!rsn) return kFALSE;
+   AliESDEvent *esd = rsn->GetRefESD();
+   AliAODEvent *aod = rsn->GetRefAOD();
+
+   if (esd) {
+      // pile-up check
+      if (fCheckPileUp) {
+         if (esd->IsPileupFromSPD()) return kFALSE;
       }
-    }
-    else
+
+      // get the best primary vertex:
+      // first try the one with tracks
+      const AliESDVertex *vTrk  = esd->GetPrimaryVertexTracks();
+      const AliESDVertex *vSPD  = esd->GetPrimaryVertexSPD();
+      const AliESDVertex *vTPC  = esd->GetPrimaryVertexTPC();
+      Int_t               ncTrk = -1;
+      Int_t               ncSPD = -1;
+      Int_t               ncTPC = -1;
+      Double_t            vzTrk = 1000000.0;
+      Double_t            vzSPD = 1000000.0;
+      Double_t            vzTPC = 1000000.0;
+      if (vTrk) vzTrk = TMath::Abs(vTrk->GetZv());
+      if (vSPD) vzSPD = TMath::Abs(vSPD->GetZv());
+      if (vTPC) vzTPC = TMath::Abs(vTPC->GetZv());
+      if (vTrk) ncTrk = (Int_t)vTrk->GetNContributors();
+      if (vSPD) ncSPD = (Int_t)vSPD->GetNContributors();
+      if (vTPC) ncTPC = (Int_t)vTPC->GetNContributors();
+      if (vTrk && ncTrk > 0) {
+         fCutValueI = ncTrk;
+         fCutValueD = vzTrk;
+      } else if (vSPD && ncSPD > 0) {
+         fCutValueI = ncSPD;
+         fCutValueD = vzSPD;
+      } else if (vTPC && ncTPC > 0) {
+         if (!fAcceptTPC)
+            return kFALSE;
+         else {
+            fCutValueI = ncTPC;
+            fCutValueD = vzTPC;
+         }
+      } else
+         return kFALSE;
+   } else if (aod) {
+      // pile-up check is not yet available for AODs
+
+      // lines suggested by Andrea to reject TPC-only events
+      if (!fAcceptTPC) {
+         if (!aod->GetPrimaryVertexSPD()) return kFALSE;
+         else if (aod->GetPrimaryVertexSPD()->GetNContributors() < 1) return kFALSE;
+      }
+
+      AliAODVertex *prim = (AliAODVertex*)aod->GetPrimaryVertex();
+      if (!prim) return kFALSE;
+
+      fCutValueI = prim->GetNContributors();
+      fCutValueD = prim->GetZ();
+   } else
       return kFALSE;
-  }
-  else if (aod)
-  {
-    // pile-up check is not yet available for AODs
-    
-    // lines suggested by Andrea to reject TPC-only events
-    if(!fAcceptTPC)
-    {
-      if (!aod->GetPrimaryVertexSPD()) return kFALSE;
-      else if(aod->GetPrimaryVertexSPD()->GetNContributors() < 1) return kFALSE;
-    }
-    
-    AliAODVertex *prim = (AliAODVertex*)aod->GetPrimaryVertex();
-    if (!prim) return kFALSE;
 
-    fCutValueI = prim->GetNContributors();
-    fCutValueD = prim->GetZ();
-  }
-  else
-    return kFALSE;
-    
-  // output
-  Bool_t result = ((!OkRangeI()) && OkRangeD());
-  return result;
+   // output
+   Bool_t result = ((!OkRangeI()) && OkRangeD());
+   return result;
 }
 
 //_________________________________________________________________________________________________
@@ -131,8 +118,8 @@ void AliRsnCutPrimaryVertex::Print(const Option_t *) const
 // Print information on this cut
 //
 
-  AliInfo(Form("Cut name                     : %s", GetName()));
-  AliInfo(Form("Accepting TPC primary vertex : %s", (fAcceptTPC ? "YES" : "NO")));
-  AliInfo(Form("Contributors range (outside) : %d - %d", fMinI, fMaxI));
-  AliInfo(Form("Z-vertex     range (inside)  : %f - %f", fMinD, fMaxD));
+   AliInfo(Form("Cut name                     : %s", GetName()));
+   AliInfo(Form("Accepting TPC primary vertex : %s", (fAcceptTPC ? "YES" : "NO")));
+   AliInfo(Form("Contributors range (outside) : %d - %d", fMinI, fMaxI));
+   AliInfo(Form("Z-vertex     range (inside)  : %f - %f", fMinD, fMaxD));
 }
index 360b1b8..faf6803 100644 (file)
 class AliRsnEvent;
 class AliRsnDaughter;
 class AliRsnPairParticle;
-class AliRsnCutPrimaryVertex : public AliRsnCut
-{
-  public:
+class AliRsnCutPrimaryVertex : public AliRsnCut {
+public:
 
-    AliRsnCutPrimaryVertex(const char *name = "cutPrimVert", Double_t maxVz = 10.0, Int_t minContributors = 1, Bool_t acceptTPC = kFALSE);
-    virtual ~AliRsnCutPrimaryVertex() {;};
+   AliRsnCutPrimaryVertex(const char *name = "cutPrimVert", Double_t maxVz = 10.0, Int_t minContributors = 1, Bool_t acceptTPC = kFALSE);
+   virtual ~AliRsnCutPrimaryVertex() {;};
 
-    void           SetCheckPileUp(Bool_t doit = kTRUE) {fCheckPileUp = doit;}
-    virtual Bool_t IsSelected(TObject *object);
-    virtual void   Print(const Option_t *option = "") const;
+   void           SetCheckPileUp(Bool_t doit = kTRUE) {fCheckPileUp = doit;}
+   virtual Bool_t IsSelected(TObject *object);
+   virtual void   Print(const Option_t *option = "") const;
 
-  protected:
+protected:
 
-    Bool_t fAcceptTPC;   // if kTRUE, the TPC primary vertexes are accepted
-    Bool_t fCheckPileUp; // check and reject pileupped events (pp)
+   Bool_t fAcceptTPC;   // if kTRUE, the TPC primary vertexes are accepted
+   Bool_t fCheckPileUp; // check and reject pileupped events (pp)
 
-    ClassDef(AliRsnCutPrimaryVertex, 1)
+   ClassDef(AliRsnCutPrimaryVertex, 1)
 };
 
 #endif
index 69037bb..39aea35 100644 (file)
@@ -17,66 +17,65 @@ ClassImp(AliRsnCutSet)
 
 //_____________________________________________________________________________
 AliRsnCutSet::AliRsnCutSet() :
-  AliRsnTarget(),
-  fCuts(0),
-  fNumOfCuts(0),
-  fCutScheme(""),
-  fCutSchemeIndexed(""),
-  fBoolValues(0),
-  fIsScheme(kFALSE),
-  fExpression(0)
+   AliRsnTarget(),
+   fCuts(0),
+   fNumOfCuts(0),
+   fCutScheme(""),
+   fCutSchemeIndexed(""),
+   fBoolValues(0),
+   fIsScheme(kFALSE),
+   fExpression(0)
 {
 //
 // Constructor without name (not recommended)
 //
 
-  fBoolValues = new Bool_t[1];
-  AliRsnExpression::fgCutSet = this;
+   fBoolValues = new Bool_t[1];
+   AliRsnExpression::fgCutSet = this;
 }
 
 //_____________________________________________________________________________
 AliRsnCutSet::AliRsnCutSet(const char *name, RSNTARGET target) :
-  AliRsnTarget(name, target),
-  fCuts(0),
-  fNumOfCuts(0),
-  fCutScheme(""),
-  fCutSchemeIndexed(""),
-  fBoolValues(0),
-  fIsScheme(kFALSE),
-  fExpression(0)
+   AliRsnTarget(name, target),
+   fCuts(0),
+   fNumOfCuts(0),
+   fCutScheme(""),
+   fCutSchemeIndexed(""),
+   fBoolValues(0),
+   fIsScheme(kFALSE),
+   fExpression(0)
 {
 //
 // Constructor with argument name (recommended)
 //
 
-  fBoolValues = new Bool_t[1];
-  fExpression = 0;
-  AliRsnExpression::fgCutSet = this;
+   fBoolValues = new Bool_t[1];
+   fExpression = 0;
+   AliRsnExpression::fgCutSet = this;
 }
 
 //_____________________________________________________________________________
 AliRsnCutSet::AliRsnCutSet(const AliRsnCutSet & copy) :
-  AliRsnTarget(copy),
-  fCuts(copy.fCuts),
-  fNumOfCuts(copy.fNumOfCuts),
-  fCutScheme(copy.fCutScheme),
-  fCutSchemeIndexed(copy.fCutSchemeIndexed),
-  fBoolValues(0),
-  fIsScheme(copy.fIsScheme),
-  fExpression(copy.fExpression)
+   AliRsnTarget(copy),
+   fCuts(copy.fCuts),
+   fNumOfCuts(copy.fNumOfCuts),
+   fCutScheme(copy.fCutScheme),
+   fCutSchemeIndexed(copy.fCutSchemeIndexed),
+   fBoolValues(0),
+   fIsScheme(copy.fIsScheme),
+   fExpression(copy.fExpression)
 {
 //
 // Copy constructor
 //
 
-  Int_t i;
-  fBoolValues = new Bool_t[fNumOfCuts];
-  for (i = 0; i < fNumOfCuts; ++i) 
-  {
-    fBoolValues[i] = copy.fBoolValues[i];
-  }
-  
-  AliRsnExpression::fgCutSet = this;
+   Int_t i;
+   fBoolValues = new Bool_t[fNumOfCuts];
+   for (i = 0; i < fNumOfCuts; ++i) {
+      fBoolValues[i] = copy.fBoolValues[i];
+   }
+
+   AliRsnExpression::fgCutSet = this;
 }
 
 //_____________________________________________________________________________
@@ -85,28 +84,27 @@ AliRsnCutSet& AliRsnCutSet::operator=(const AliRsnCutSet & copy)
 //
 // Assignment operator.
 //
-  
-  AliRsnTarget::operator=(copy);
-  
-  fCuts = copy.fCuts;
-  fNumOfCuts = copy.fNumOfCuts;
-  fCutScheme = copy.fCutScheme;
-  fCutSchemeIndexed = copy.fCutSchemeIndexed;
-  fIsScheme = copy.fIsScheme;
-  fExpression = copy.fExpression;
-  
-  if (fBoolValues) delete [] fBoolValues;
-
-  Int_t i;
-  fBoolValues = new Bool_t[fNumOfCuts];
-  for (i = 0; i < fNumOfCuts; ++i) 
-  {
-    fBoolValues[i] = copy.fBoolValues[i];
-  }
-
-  AliRsnExpression::fgCutSet = this;
-  
-  return (*this);
+
+   AliRsnTarget::operator=(copy);
+
+   fCuts = copy.fCuts;
+   fNumOfCuts = copy.fNumOfCuts;
+   fCutScheme = copy.fCutScheme;
+   fCutSchemeIndexed = copy.fCutSchemeIndexed;
+   fIsScheme = copy.fIsScheme;
+   fExpression = copy.fExpression;
+
+   if (fBoolValues) delete [] fBoolValues;
+
+   Int_t i;
+   fBoolValues = new Bool_t[fNumOfCuts];
+   for (i = 0; i < fNumOfCuts; ++i) {
+      fBoolValues[i] = copy.fBoolValues[i];
+   }
+
+   AliRsnExpression::fgCutS