Made a general review to fix as possible most coding conventions violations.
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Jul 2009 14:03:16 +0000 (14:03 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Jul 2009 14:03:16 +0000 (14:03 +0000)
Reorganized section of macros:
- "macros/test"     contain some test macros for stand-alone runs
                    useful for developers
- "macros/train"    contain all required macros for train runs
- "macros/tutorial" will contain tutorial macros to learn to use package

Added a new AnalysisTask object: AliAnalysisTaskEffSE,
which makes use of AliCFContainers to make efficiency computations for corrections
using the internal structure of RSN package to define cuts of all selection steps
and to compute the values to be used for container filling.

79 files changed:
PWG2/CMake_libPWG2resonances.txt
PWG2/PWG2resonancesLinkDef.h
PWG2/RESONANCES/AliRsnAnalysisEffSE.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisEffSE.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisME.cxx
PWG2/RESONANCES/AliRsnAnalysisME.h
PWG2/RESONANCES/AliRsnAnalysisManager.cxx
PWG2/RESONANCES/AliRsnAnalysisManager.h
PWG2/RESONANCES/AliRsnAnalysisSE.cxx
PWG2/RESONANCES/AliRsnAnalysisSE.h
PWG2/RESONANCES/AliRsnCut.cxx
PWG2/RESONANCES/AliRsnCut.h
PWG2/RESONANCES/AliRsnCutBetheBloch.cxx
PWG2/RESONANCES/AliRsnCutBetheBloch.h
PWG2/RESONANCES/AliRsnCutESDPrimary.cxx
PWG2/RESONANCES/AliRsnCutESDPrimary.h
PWG2/RESONANCES/AliRsnCutMgr.cxx
PWG2/RESONANCES/AliRsnCutMgr.h
PWG2/RESONANCES/AliRsnCutPrimaryVertex.cxx
PWG2/RESONANCES/AliRsnCutPrimaryVertex.h
PWG2/RESONANCES/AliRsnCutSet.cxx
PWG2/RESONANCES/AliRsnCutSet.h
PWG2/RESONANCES/AliRsnCutStd.cxx
PWG2/RESONANCES/AliRsnCutStd.h
PWG2/RESONANCES/AliRsnDaughter.cxx
PWG2/RESONANCES/AliRsnDaughter.h
PWG2/RESONANCES/AliRsnEvent.cxx
PWG2/RESONANCES/AliRsnEvent.h
PWG2/RESONANCES/AliRsnExpression.cxx
PWG2/RESONANCES/AliRsnExpression.h
PWG2/RESONANCES/AliRsnFunction.cxx
PWG2/RESONANCES/AliRsnFunction.h
PWG2/RESONANCES/AliRsnFunctionAxis.cxx
PWG2/RESONANCES/AliRsnFunctionAxis.h
PWG2/RESONANCES/AliRsnPIDDefESD.cxx
PWG2/RESONANCES/AliRsnPIDDefESD.h
PWG2/RESONANCES/AliRsnPIDIndex.cxx
PWG2/RESONANCES/AliRsnPIDIndex.h
PWG2/RESONANCES/AliRsnPair.cxx
PWG2/RESONANCES/AliRsnPair.h
PWG2/RESONANCES/AliRsnPairDef.cxx
PWG2/RESONANCES/AliRsnPairDef.h
PWG2/RESONANCES/AliRsnPairManager.cxx
PWG2/RESONANCES/AliRsnPairManager.h
PWG2/RESONANCES/AliRsnPairParticle.cxx
PWG2/RESONANCES/AliRsnPairParticle.h
PWG2/RESONANCES/AliRsnVATProcessInfo.cxx
PWG2/RESONANCES/AliRsnVATProcessInfo.h
PWG2/RESONANCES/AliRsnVAnalysisTaskME.cxx
PWG2/RESONANCES/AliRsnVAnalysisTaskME.h
PWG2/RESONANCES/AliRsnVAnalysisTaskSE.cxx
PWG2/RESONANCES/AliRsnVAnalysisTaskSE.h
PWG2/RESONANCES/AliRsnVManager.cxx
PWG2/RESONANCES/AliRsnVManager.h
PWG2/RESONANCES/AliRsnVariableExpression.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnVariableExpression.h [new file with mode: 0644]
PWG2/RESONANCES/macros/AddAnalysisTaskRsn.C [deleted file]
PWG2/RESONANCES/macros/AliRsnLoad.C [deleted file]
PWG2/RESONANCES/macros/AliRsnTaskAlien.C [deleted file]
PWG2/RESONANCES/macros/AliRsnTaskProof.C [deleted file]
PWG2/RESONANCES/macros/CreateAnalysisManager.C [deleted file]
PWG2/RESONANCES/macros/CreatePairsPhi.C [deleted file]
PWG2/RESONANCES/macros/RsnConfig.C
PWG2/RESONANCES/macros/RsnConfigTest.C [deleted file]
PWG2/RESONANCES/macros/alien/RsnMergeAlien.C [deleted file]
PWG2/RESONANCES/macros/alien/rsn-merge.jdl [deleted file]
PWG2/RESONANCES/macros/alien/rsn-merge.sh [deleted file]
PWG2/RESONANCES/macros/test/AliRsnAnalysis.C [moved from PWG2/RESONANCES/macros/AliRsnAnalysis.C with 100% similarity]
PWG2/RESONANCES/macros/test/AliRsnTrain.C [moved from PWG2/RESONANCES/macros/AliRsnTrain.C with 100% similarity]
PWG2/RESONANCES/macros/test/PWG2resonancesUtils.C [moved from PWG2/RESONANCES/macros/PWG2resonancesUtils.C with 100% similarity]
PWG2/RESONANCES/macros/test/ProcessConfig.C [moved from PWG2/RESONANCES/macros/ProcessConfig.C with 100% similarity]
PWG2/RESONANCES/macros/test/runESDMCFilter.C [moved from PWG2/RESONANCES/macros/runESDMCFilter.C with 100% similarity]
PWG2/RESONANCES/macros/test/runProcess.C [moved from PWG2/RESONANCES/macros/runProcess.C with 100% similarity]
PWG2/RESONANCES/macros/test/runRsnAnalysisSE.C [moved from PWG2/RESONANCES/macros/runRsnAnalysisSE.C with 100% similarity]
PWG2/RESONANCES/macros/train/AddAnalysisTaskRsn.C [new file with mode: 0644]
PWG2/RESONANCES/macros/train/AddAnalysisTaskRsnEffNoPID.C [new file with mode: 0644]
PWG2/RESONANCES/macros/train/AddAnalysisTaskRsnEffPID.C [new file with mode: 0644]
PWG2/RESONANCES/macros/train/RsnConfig.C [new file with mode: 0644]
PWG2/libPWG2resonances.pkg

index cfef2fdf5904d15ee632763b0affbc2ea6f9a229..82d498576e41946d03e94778269bac7c20ad2e37 100644 (file)
@@ -2,14 +2,15 @@
 
 set(SRCS  RESONANCES/AliRsnDaughter.cxx
     RESONANCES/AliRsnPairParticle.cxx
+    RESONANCES/AliRsnExpression.cxx
+    RESONANCES/AliRsnVariableExpression.cxx
     RESONANCES/AliRsnCut.cxx
     RESONANCES/AliRsnCutStd.cxx
     RESONANCES/AliRsnCutBetheBloch.cxx
     RESONANCES/AliRsnCutESDPrimary.cxx
-    RESONANCES/AliRsnCutPrimaryVertex.cxx 
+    RESONANCES/AliRsnCutPrimaryVertex.cxx
     RESONANCES/AliRsnCutSet.cxx
     RESONANCES/AliRsnCutMgr.cxx
-    RESONANCES/AliRsnExpression.cxx
     RESONANCES/AliRsnPIDIndex.cxx
     RESONANCES/AliRsnPIDDefESD.cxx
     RESONANCES/AliRsnEvent.cxx
@@ -25,7 +26,7 @@ set(SRCS  RESONANCES/AliRsnDaughter.cxx
     RESONANCES/AliRsnAnalysisManager.cxx
     RESONANCES/AliRsnAnalysisSE.cxx
     RESONANCES/AliRsnAnalysisME.cxx
-
+    RESONANCES/AliRsnAnalysisEffSE.cxx
 )
 
 # fill list of header files from list of source files
index 484140aad0a4a0dc22062234ffec54485a5854fd..f4e668edf32a5223785b0bd9175b266d8d3d2272 100644 (file)
@@ -3,6 +3,8 @@
 #pragma link C++ class AliRsnDaughter+;
 #pragma link C++ class AliRsnPairParticle+;
 
+#pragma link C++ class AliRsnExpression+;
+#pragma link C++ class AliRsnVariableExpression+;
 #pragma link C++ class AliRsnCut+;
 #pragma link C++ class AliRsnCutStd+;
 #pragma link C++ class AliRsnCutBetheBloch+;
@@ -10,8 +12,7 @@
 #pragma link C++ class AliRsnCutPrimaryVertex+;
 #pragma link C++ class AliRsnCutSet+;
 #pragma link C++ class AliRsnCutMgr+;
-#pragma link C++ class AliRsnExpression+;
-#pragma link C++ class AliRsnVariableExpression+;
+
 
 #pragma link C++ class AliRsnPIDIndex+;
 #pragma link C++ class AliRsnPIDDefESD+;
@@ -34,5 +35,6 @@
 #pragma link C++ class AliRsnAnalysisManager+;
 #pragma link C++ class AliRsnAnalysisSE+;
 #pragma link C++ class AliRsnAnalysisME+;
+#pragma link C++ class AliRsnAnalysisEffSE+;
 
 #endif
diff --git a/PWG2/RESONANCES/AliRsnAnalysisEffSE.cxx b/PWG2/RESONANCES/AliRsnAnalysisEffSE.cxx
new file mode 100644 (file)
index 0000000..23fc80d
--- /dev/null
@@ -0,0 +1,343 @@
+//
+// Class AliRsnAnalysisEffSE
+//
+// TODO
+// TODO
+//
+// authors: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//          Martin Vala (martin.vala@cern.ch)
+//
+#include <Riostream.h>
+#include "AliStack.h"
+#include "AliESDEvent.h"
+#include "AliMCEvent.h"
+
+#include "AliCFContainer.h"
+#include "AliRsnCutMgr.h"
+#include "AliRsnFunctionAxis.h"
+#include "AliRsnAnalysisEffSE.h"
+#include "AliRsnPairDef.h"
+#include "AliRsnCutSet.h"
+
+ClassImp(AliRsnAnalysisEffSE)
+
+//_____________________________________________________________________________
+AliRsnAnalysisEffSE::AliRsnAnalysisEffSE(const char *name) :
+  AliRsnVAnalysisTaskSE(name),
+  fEventCuts(0x0),
+  fStepListMC(0),
+  fStepListESD(0),
+  fAxisList(0),
+  fPairDefList(0),
+  fContainerList(0x0),
+  fVar(0),
+  fPair()
+{
+//
+// Default constructor.
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+
+  DefineOutput(2, TList::Class());
+
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+AliRsnAnalysisEffSE::AliRsnAnalysisEffSE(const AliRsnAnalysisEffSE& copy) :
+  AliRsnVAnalysisTaskSE(copy),
+  fEventCuts(copy.fEventCuts),
+  fContainerList(copy.fContainerList)
+{
+//
+// Copy constrtuctor
+//
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisEffSE::RsnUserCreateOutputObjects()
+{
+//
+// Creation of output objects.
+// These are created through the utility methods in the analysis manager,
+// which produces a list of histograms for each specified set of pairs.
+// Each of these lists is added to the main list of this task.
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+
+  // get number of steps and axes
+  Int_t iaxis;
+  Int_t nAxes  = fAxisList.GetEntries();
+  Int_t nSteps = (Int_t)fStepListMC.GetEntries() + (Int_t)fStepListESD.GetEntries();
+
+  if (!nSteps) {
+    AliError("No steps defined");
+    return;
+  }
+  if (!nAxes) {
+    AliError("No axes defined");
+    return;
+  }
+
+  // initialize variable list
+  fVar.Set(nAxes);
+
+  // retrieve number of bins for each axis
+  Int_t   *nBins     = new Int_t[nAxes];
+  TArrayD *binLimits = new TArrayD[nAxes];
+  for (iaxis = 0; iaxis < nAxes; iaxis++) {
+    AliRsnFunctionAxis *fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(iaxis);
+    binLimits[iaxis] = fcnAxis->GetArray();
+    nBins[iaxis] = binLimits[iaxis].GetSize() - 1;
+  }
+
+  // create ouput list of containers
+  fContainerList = new TList;
+  fContainerList->SetOwner();
+  fContainerList->SetName(Form("%s_containers", GetName()));
+
+  // initialize output list
+  OpenFile(2);
+  fOutList[1] = new TList();
+  fOutList[1]->SetOwner();
+
+  // create the containers
+  Int_t i, nDef = (Int_t)fPairDefList.GetEntries();
+  for (i = 0; i < nDef; i++) {
+    AliRsnPairDef *def = (AliRsnPairDef*)fPairDefList[i];
+    AliCFContainer *cont = new AliCFContainer(Form("%s", def->GetPairName().Data()), "", nSteps, nAxes, nBins);
+    // set the bin limits for each axis
+    for (iaxis = 0; iaxis < nAxes; iaxis++) cont->SetBinLimits(iaxis, binLimits[iaxis].GetArray());
+    // add the container to output list
+    fContainerList->Add(cont);
+  }
+
+  fOutList[1]->Add(fContainerList);
+
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisEffSE::RsnUserExec(Option_t*)
+{
+//
+// Execution of the analysis task.
+// Recovers the input event and processes it with all included pair objects.
+// In this case, we NEED to have ESD and MC, otherwise we cannod do anything.
+//ULTIMO UNDO
+/*
+  AliRsnDaughter trk;
+  for (Int_t i = 0; i <= AliPID::kSPECIES; i++)
+  {
+    cout << AliPID::ParticleName((AliPID::EParticleType)i) << ": " << endl;
+    for (Int_t m = 0; m < AliRsnDaughter::kMethods; m++)
+    {
+      cout << "-- method: " << AliRsnDaughter::MethodName((AliRsnDaughter::EPIDMethod)m) << endl;
+      Char_t   sign[2] = {'+', '-'};
+      for (Int_t s = 0; s < 2; s++)
+      {
+        TArrayI *a = fRsnPIDIndex.GetTracksArray((AliRsnDaughter::EPIDMethod)m, sign[s], (AliPID::EParticleType)i);
+        Int_t n = a->GetSize();
+        for (Int_t j = 0; j < n; j++)
+        {
+          Int_t k = a->At(j);
+          cout << "-- -- track " << Form("%4d ", k) << ": ";
+          fRsnEvent.SetDaughter(trk, k);
+          cout << "charge = " << (trk.IsPos() ? "+ " : (trk.IsNeg() ? "- " : "0 "));
+          cout << "truePID = " << Form("%10s ", AliPID::ParticleName(trk.PerfectPID()));
+          cout << "realPID = " << Form("%10s ", AliPID::ParticleName(trk.RealisticPID()));
+          cout << endl;
+          cout << "-- -- -- weights (computed): ";
+          for (Int_t q = 0; q < AliPID::kSPECIES; q++)
+            cout << Form("%15.12f", trk.ComputedWeights()[q]) << ' ';
+          cout << endl;
+          cout << "-- -- -- weights (original): ";
+          for (Int_t q = 0; q < AliPID::kSPECIES; q++)
+            cout << Form("%15.12f", trk.GetRef()->PID()[q]) << ' ';
+          cout << endl;
+        }
+      }
+    }
+  } return;
+  */
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  if (!fESDEvent || !fMCEvent) {
+    AliError("This task can process only ESD + MC events");
+    return;
+  }
+  fRsnEvent.SetRef(fESDEvent, fMCEvent);
+
+  // if general event cuts are added to the task (recommended)
+  // they are checked here on the RSN event interface and,
+  // if the event does not pass them, it is skipped and ProcessInfo
+  // is updated accordingly
+  if (fEventCuts) {
+    if (!fEventCuts->IsSelected(AliRsnCut::kEvent, &fRsnEvent)) {
+      fTaskInfo.SetEventUsed(kFALSE);
+      return;
+    }
+  }
+
+  // if cuts are passed or not cuts were defined,
+  // update the task info before processing the event
+  fTaskInfo.SetEventUsed(kTRUE);
+
+  // process first MC steps and then ESD steps
+  AliRsnPairDef *pairDef = 0;
+  TObjArrayIter iter(&fPairDefList);
+  while ( (pairDef = (AliRsnPairDef*)iter.Next()) )
+  {
+    ProcessEventMC(pairDef);
+    ProcessEventESD(pairDef);
+  }
+
+  // Post the data
+  PostData(2, fOutList[1]);
+
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisEffSE::ProcessEventMC(AliRsnPairDef *pairDef)
+{
+//
+// Process current event with the definitions of the specified step in MC list
+// and store results in the container slot defined in second argument
+//
+
+  AliStack      *stack = fMCEvent->Stack();
+  AliMCParticle *mother, *daughter;
+
+  if (!pairDef) return;
+  AliCFContainer *cont = (AliCFContainer*)fContainerList->FindObject(pairDef->GetPairName().Data());
+  if (!cont) return;
+
+  // other utility variables
+  Int_t i[2], j, ipart;
+
+  // in this case, we first take the resonance from MC
+  // and then we find its daughters and compute cuts on them
+  for (ipart = 0; ipart < stack->GetNprimary(); ipart++) {
+    mother = fMCEvent->GetTrack(ipart);
+    if (mother->Particle()->GetNDaughters() != 2) continue;
+
+    i[0] = mother->Particle()->GetFirstDaughter();
+    i[1] = mother->Particle()->GetLastDaughter();
+
+    for (j = 0; j < 2; j++) {
+      daughter = fMCEvent->GetTrack(i[j]);
+      fDaughter[j].SetRef(daughter);
+      fDaughter[j].SetParticle(daughter->Particle());
+      fDaughter[j].FindMotherPDG(stack);
+    }
+
+    if (fDaughter[0].ChargeC() != pairDef->GetCharge(0)) continue;
+    if (fDaughter[1].ChargeC() != pairDef->GetCharge(1)) continue;
+    if (fDaughter[0].PerfectPID() != pairDef->GetType(0)) continue;
+    if (fDaughter[1].PerfectPID() != pairDef->GetType(1)) continue;
+
+    fPair.SetPair(&fDaughter[0], &fDaughter[1]);
+
+    // create pair
+    FillContainer(cont, &fStepListMC, pairDef, 0);
+  }
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisEffSE::ProcessEventESD(AliRsnPairDef *pairDef)
+{
+//
+// Process current event with the definitions of the specified step in ESD list
+// and store results in the container slot defined in second argument
+//
+
+  Int_t i0, i1, first = (Int_t)fStepListMC.GetEntries();
+
+  if (!pairDef) return;
+  AliCFContainer *cont = (AliCFContainer*)fContainerList->FindObject(pairDef->GetPairName().Data());
+  if (!cont) return;
+
+  // get arrays of all charged tracks
+  TArrayI *a0 = fRsnPIDIndex.GetTracksArray(AliRsnDaughter::kPerfect, pairDef->GetCharge(0), pairDef->GetType(0));
+  TArrayI *a1 = fRsnPIDIndex.GetTracksArray(AliRsnDaughter::kPerfect, pairDef->GetCharge(1), pairDef->GetType(1));
+
+  // external loop on tracks
+  for (i0 = 0; i0 < a0->GetSize(); i0++) {
+    // connect interface
+    fRsnEvent.SetDaughter(fDaughter[0], a0->At(i0));
+    if (!fDaughter[0].IsOK()) continue;
+    fDaughter[0].SetRequiredPID(pairDef->GetType(0));
+
+    // internal loop on tracks
+    for (i1 = 0; i1 < a1->GetSize(); i1++) {
+      // connect interface
+      fRsnEvent.SetDaughter(fDaughter[1], a1->At(i1));
+      if (!fDaughter[1].IsOK()) continue;
+      fDaughter[1].SetRequiredPID(pairDef->GetType(1));
+      // build pair
+      fPair.SetPair(&fDaughter[0], &fDaughter[1]);
+      if (TMath::Abs(fPair.CommonMother()) != pairDef->GetMotherPDG()) continue;
+      // fill containers
+      FillContainer(cont, &fStepListESD, pairDef, first);
+    }
+  }
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisEffSE::FillContainer(AliCFContainer *cont, const TObjArray *stepList, AliRsnPairDef *pd, Int_t firstOutStep)
+{
+//
+// Fill the containers
+//
+
+  Int_t iaxis, nAxes  = fAxisList.GetEntries();
+  Int_t istep, nSteps = stepList->GetEntries();
+
+  // compute values for all axes
+  for (iaxis = 0; iaxis < nAxes; iaxis++) {
+    AliRsnFunctionAxis *fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(iaxis);
+    switch (fcnAxis->GetAxisObject()) {
+    case AliRsnFunctionAxis::kPair:
+      fVar[iaxis] = (Double_t)fcnAxis->Eval(&fPair, pd);
+      break;
+    case AliRsnFunctionAxis::kEvent:
+      fVar[iaxis] = (Double_t)fcnAxis->Eval(&fRsnEvent);
+      break;
+    default:
+      fVar[iaxis] = 0.0;
+    }
+  }
+
+  // fill all steps
+  for (istep = 0; istep < nSteps; istep++) {
+    AliRsnCutMgr *cutMgr = (AliRsnCutMgr*)stepList->At(istep);
+    if (!cutMgr->IsSelected(AliRsnCut::kParticle, &fDaughter[0])) break;
+    if (!cutMgr->IsSelected(AliRsnCut::kParticle, &fDaughter[1])) break;
+    if (!cutMgr->IsSelected(AliRsnCut::kPair,     &fPair)) break;
+    cont->Fill(fVar.GetArray(), istep + firstOutStep);
+  }
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisEffSE::RsnTerminate(Option_t*)
+{
+//
+// Termination.
+// Could be added some monitor histograms here.
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  AliDebug(AliLog::kDebug+2,"->");
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisEffSE::AddPairDef(AliRsnPairDef* pairDef)
+{
+//
+//  Adds pair definition
+//
+  fPairDefList.AddLast(pairDef);
+}
diff --git a/PWG2/RESONANCES/AliRsnAnalysisEffSE.h b/PWG2/RESONANCES/AliRsnAnalysisEffSE.h
new file mode 100644 (file)
index 0000000..ab6b88b
--- /dev/null
@@ -0,0 +1,72 @@
+//
+// Class AliRsnAnalysisEffSE
+//
+// 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 ALIRSNANALYSISEFFSE_H
+#define ALIRSNANALYSISEFFSE_H
+
+#include <TArrayD.h>
+
+#include "AliRsnVAnalysisTaskSE.h"
+#include "AliRsnEvent.h"
+#include "AliRsnPairParticle.h"
+#include "AliRsnPIDIndex.h"
+
+class AliPID;
+
+class AliCFContainer;
+
+class AliRsnPairDef;
+class AliRsnPIDIndex;
+class AliRsnPIDDefESD;
+class AliRsnCutSet;
+class AliRsnCutMgr;
+class AliRsnFunctionAxis;
+
+class AliRsnAnalysisManager;
+class AliRsnAnalysisEffSE : public AliRsnVAnalysisTaskSE
+{
+
+  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*);
+
+    // settings
+    void            SetEventCuts(AliRsnCutSet *const cuts) {fEventCuts = cuts;}
+    void            AddPairDef(AliRsnPairDef *pairDef);
+    void            AddStepMC(AliRsnCutMgr *mgr) {fStepListMC.AddLast(mgr);}
+    void            AddStepESD(AliRsnCutMgr *mgr) {fStepListESD.AddLast(mgr);}
+    void            AddAxis(AliRsnFunctionAxis *axis) {fAxisList.AddLast(axis);}
+
+  private:
+
+    AliRsnAnalysisEffSE& operator=(const AliRsnAnalysisEffSE& /*copy*/) {return *this;}
+    void                 ProcessEventMC(AliRsnPairDef *pairDef);
+    void                 ProcessEventESD(AliRsnPairDef *pairDef);
+    void                 FillContainer(AliCFContainer *cont, const TObjArray *stepList, AliRsnPairDef *pd, Int_t firstOutStep);
+
+    AliRsnCutSet         *fEventCuts;               // event cuts
+    TObjArray             fStepListMC;              // list of cut managers for all steps with MC
+    TObjArray             fStepListESD;             // list of cut managers for all steps with ESD
+    TObjArray             fAxisList;                // list of axes of efficiency plots
+    TObjArray             fPairDefList;             // decay channels
+    TList                *fContainerList;           // list of CF containers
+    TArrayD               fVar;                     // list of variables of the container
+    AliRsnPairParticle    fPair;                    // interface to pair
+    AliRsnDaughter        fDaughter[2];             // interface to tracks
+
+    ClassDef(AliRsnAnalysisEffSE, 1)
+};
+
+#endif
index a770a460576d399f3b13f194d5425397c24a78dd..ecc599c16d9d4417ca0e90ecf555db8cffaed9f1 100644 (file)
@@ -2,11 +2,16 @@
 // Class AliRsnAnalysisME
 //
 // TODO
+// TODO
 //
 // authors: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //          Martin Vala (martin.vala@cern.ch)
 //
 
+#include "AliESDEvent.h"
+#include "AliMCEvent.h"
+#include "AliAODEvent.h"
+
 #include "AliRsnAnalysisME.h"
 
 ClassImp(AliRsnAnalysisME)
@@ -18,8 +23,7 @@ AliRsnAnalysisME::AliRsnAnalysisME(const char *name) :
     fPIDIndex(0),
     fPIDIndexMix(0),
     fEvent(),
-    fEventMix(),
-    fESDCuts(0)
+    fEventMix()
 {
 //
 // Default constructor
@@ -33,8 +37,7 @@ AliRsnAnalysisME::AliRsnAnalysisME(const AliRsnAnalysisME& copy) : AliRsnVAnalys
     fPIDIndex(copy.fPIDIndex),
     fPIDIndexMix(copy.fPIDIndexMix),
     fEvent(copy.fEvent),
-    fEventMix(copy.fEvent),
-    fESDCuts(copy.fESDCuts)
+    fEventMix(copy.fEvent)
 {
   AliDebug(AliLog::kDebug+2,"<-");
   AliDebug(AliLog::kDebug+2,"->");
@@ -43,6 +46,9 @@ AliRsnAnalysisME::AliRsnAnalysisME(const AliRsnAnalysisME& copy) : AliRsnVAnalys
 //_____________________________________________________________________________
 void AliRsnAnalysisME::RsnUserCreateOutputObjects()
 {
+//
+// TODO
+//
   AliLog::SetClassDebugLevel(GetName(), fLogType);
   AliDebug(AliLog::kDebug+2,"<-");
 //     AliRsnVAnalysisTaskME::UserCreateOutputObjects();
@@ -56,14 +62,19 @@ void AliRsnAnalysisME::RsnUserCreateOutputObjects()
 //
 //     fOutList->Add(fTaskInfo.GenerateInfoList());
 
-  fOutList->Add(fRsnAnalysisManager.InitAllPairMgrs());
+//   fOutList->Add();
+  fRsnAnalysisManager.InitAllPairMgrs(fOutList);
 //     fRsnAnalysisManager.Print();
 
   AliDebug(AliLog::kDebug+2,"->");
 }
 
-void AliRsnAnalysisME::RsnUserExec(Option_t* )
+void AliRsnAnalysisME::RsnUserExec(Option_t*)
 {
+//
+// TODO
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
   if (fESDEvent) {
     AliDebug(AliLog::kDebug+1,Form("fESDEvent if %p",fESDEvent));
@@ -89,13 +100,13 @@ void AliRsnAnalysisME::RsnUserExec(Option_t* )
 
   // sort tracks w.r. to PID
   fPIDIndex.ResetAll(fEvent.GetMultiplicity());
-  fPIDIndex.SetPriorProbability(fPrior);
-  fPIDIndex.FillFromEvent(&fEvent, fESDCuts);
+  fEvent.SetPriorProbability(fPrior);
+  fPIDIndex.FillFromEvent(&fEvent);
   fPIDIndex.SetCorrectIndexSize();
 
   fPIDIndexMix.ResetAll(fEventMix.GetMultiplicity());
-  fPIDIndexMix.SetPriorProbability(fPrior);
-  fPIDIndexMix.FillFromEvent(&fEventMix, fESDCuts);
+  fEventMix.SetPriorProbability(fPrior);
+  fPIDIndexMix.FillFromEvent(&fEventMix);
   fPIDIndexMix.SetCorrectIndexSize();
 
   fRsnAnalysisManager.ProcessAllPairMgrs(&fPIDIndex, &fEvent, &fPIDIndexMix, &fEventMix);
@@ -107,14 +118,23 @@ void AliRsnAnalysisME::RsnUserExec(Option_t* )
 
 
 //_____________________________________________________________________________
-void AliRsnAnalysisME::RsnTerminate(Option_t* )
+void AliRsnAnalysisME::RsnTerminate(Option_t*)
 {
+//
+// TODO
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
   AliDebug(AliLog::kDebug+2,"->");
 }
 
+//_____________________________________________________________________________
 AliRsnAnalysisManager* AliRsnAnalysisME::GetAnalysisManager(TString name)
 {
+//
+// Gets all prior probabilities to out
+//
+
   if (!name.IsNull()) {
     SetAnalysisManagerName(name.Data());
   }
@@ -149,8 +169,11 @@ void AliRsnAnalysisME::DumpPriors()
 }
 
 //_____________________________________________________________________________
-void AliRsnAnalysisME::GetPriorProbability(Double_t *out)
+void AliRsnAnalysisME::GetPriorProbability(Double_t *out) const
 {
+//
+// Gets all prior probabilities to out
+//
 
   Int_t i;
   for (i=0;i<AliPID::kSPECIES;i++) {
index 31ebd20dbd99a3acc192a9d08288b3814e9d0721..48e945c31ae45500512673b90acb89358537a215 100644 (file)
@@ -1,55 +1,57 @@
-//\r
-// Class AliRsnAnalysisME\r
-//\r
-// Virtual Class derivated from AliRsnVAnalysisTaskME which will be base class\r
-// for all RSN SE tasks\r
-//\r
-// authors: Martin Vala (martin.vala@cern.ch)\r
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)\r
-//\r
-#ifndef AliRsnAnalysisME_H\r
-#define AliRsnAnalysisME_H\r
-\r
-#include "AliRsnVAnalysisTaskME.h"\r
-#include "AliRsnAnalysisManager.h"\r
-\r
-class AliRsnAnalysisME : public AliRsnVAnalysisTaskME\r
-{\r
-\r
-  public:\r
-    AliRsnAnalysisME(const char *name = "AliRsnAnalysisME");\r
-    AliRsnAnalysisME(const AliRsnAnalysisME& copy);\r
-\r
-    // Implement this\r
-    virtual void    RsnUserCreateOutputObjects();\r
-    virtual void    RsnUserExec(Option_t*);\r
-    virtual void    RsnTerminate(Option_t*);\r
-\r
-    AliRsnAnalysisManager *GetAnalysisManager(TString name="");\r
-    void SetAnalysisManagerName(const char*name) { fRsnAnalysisManager.SetName(name);};\r
-\r
-    // Prior probs\r
-    void            SetPriorProbability(AliPID::EParticleType type, Double_t p);\r
-    void            DumpPriors();\r
-    void            GetPriorProbability(Double_t *out);\r
-\r
-    // ESD cuts\r
-    void            SetESDtrackCuts(AliESDtrackCuts *cuts) {fESDCuts = cuts;}\r
-\r
-  private:\r
-\r
-    AliRsnAnalysisME& operator=(const AliRsnAnalysisME& /*copy*/) {return *this;}\r
-\r
-    AliRsnAnalysisManager fRsnAnalysisManager;      // analysis main engine\r
-    AliRsnPIDIndex        fPIDIndex;                // utility --> PID sorter\r
-    AliRsnPIDIndex        fPIDIndexMix;             // utility --> PID sorter (mixed event)\r
-    AliRsnEvent           fEvent;                   // utility --> event interface\r
-    AliRsnEvent           fEventMix;                // utility --> event interface (mixed event)\r
-\r
-    AliESDtrackCuts      *fESDCuts;                 // ESD track cuts\r
-    Double_t              fPrior[AliPID::kSPECIES]; // prior probabilities\r
-\r
-    ClassDef(AliRsnAnalysisME, 1)\r
-};\r
-\r
-#endif\r
+//
+// 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"
+#include "AliRsnPIDIndex.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(TString name="");
+    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
+    AliRsnPIDIndex        fPIDIndex;                // utility --> PID sorter
+    AliRsnPIDIndex        fPIDIndexMix;             // utility --> PID sorter (mixed event)
+    AliRsnEvent           fEvent;                   // utility --> event interface
+    AliRsnEvent           fEventMix;                // utility --> event interface (mixed event)
+
+    Double_t              fPrior[AliPID::kSPECIES]; // prior probabilities
+
+    ClassDef(AliRsnAnalysisME, 1)
+};
+
+#endif
index f0f2be97ab0a58a51afa656bb30b34e755cccb43..f1cc9f781dbc15dbc4155dd793dbe73fef300442 100644 (file)
 // revised by : A. Pulvirenti [alberto.pulvirenti@ct.infn.it]
 //
 
-#include "AliLog.h"
+#include <TROOT.h>
 
+#include "AliLog.h"
+#include "AliRsnPIDIndex.h"
+#include "AliRsnEvent.h"
+#include "AliRsnPairManager.h"
+#include "AliRsnPair.h"
 #include "AliRsnAnalysisManager.h"
 
+
 ClassImp(AliRsnAnalysisManager)
 
 //_____________________________________________________________________________
@@ -56,6 +62,8 @@ void AliRsnAnalysisManager::Add(TObject *objPairMgr)
   AliDebug(AliLog::kDebug+2,"->");
 }
 
+
+
 //_____________________________________________________________________________
 void AliRsnAnalysisManager::Print(Option_t* /*dummy*/) const
 {
@@ -84,7 +92,7 @@ void AliRsnAnalysisManager::PrintArray() const
 }
 
 //_____________________________________________________________________________
-TList* AliRsnAnalysisManager::InitAllPairMgrs()
+void AliRsnAnalysisManager::InitAllPairMgrs(TList *list)
 {
 //
 // Initialize all pair managers, and put all the TList of histograms
@@ -93,19 +101,20 @@ TList* AliRsnAnalysisManager::InitAllPairMgrs()
 
   AliDebug(AliLog::kDebug+2,"<-");
 
-  TList *list = new TList();
-  list->SetName(GetName());
-  list->SetOwner();
+//   TList *list = new TList();
+//   list->SetName(GetName());
+//   list->SetOwner();
 
   AliRsnPairManager *pairMgr = 0;
   TObjArrayIter next(&fArray);
   Int_t i = 0;
   while ((pairMgr = (AliRsnPairManager*)next())) {
     AliDebug(AliLog::kDebug+1, Form("InitAllPairs of the AnalysisManager(%s) [%d] ...", pairMgr->GetName(), i++));
-    list->Add(pairMgr->InitAllPairs());
+//     list->Add();
+    pairMgr->InitAllPairs(list);
   }
   AliDebug(AliLog::kDebug+2, "->");
-  return list;
+//   return list;
 }
 
 //_____________________________________________________________________________
index e8bc17fecc4cc9a4bd8a3a8742390cb474c82ddb..55c5fe96ec811ffc03b6521974ed773dad530345 100644 (file)
 // revised by : A. Pulvirenti [alberto.pulvirenti@ct.infn.it]
 //
 
-#ifndef AliRsnAnalysisManager_H
-#define AliRsnAnalysisManager_H
+#ifndef ALIRSNANALYSISMANAGER_H
+#define ALIRSNANALYSISMANAGER_H
 
-#include <TROOT.h>
+// #include <TROOT.h>
 
 #include "AliRsnVManager.h"
-#include "AliRsnPairManager.h"
-
+// #include "AliRsnPairManager.h"
+class TROOT;
+class AliRsnPIDIndex;
+class AliRsnEvent;
+class AliRsnPairManager;
 class AliRsnAnalysisManager : public AliRsnVManager
 {
   public:
 
     AliRsnAnalysisManager(const char*name = "defaultAnalysisMgr");
+    virtual ~AliRsnAnalysisManager() {;};
 
     //virtual void   Add(AliRsnPairManager *pair);
     virtual void   Add(TObject *pair);
@@ -36,7 +40,7 @@ class AliRsnAnalysisManager : public AliRsnVManager
     virtual void   PrintArray() const;
     virtual void   Print(Option_t *option = "") const;
 
-    TList*         InitAllPairMgrs();
+    void           InitAllPairMgrs(TList*list);
     void           ProcessAllPairMgrs(AliRsnPIDIndex *pidIndexes1, AliRsnEvent *ev1, AliRsnPIDIndex *pidIndexes2 = 0, AliRsnEvent *ev2 = 0);
 
   private:
index 6ee21ad7db352dc1c9b29082cd6cbdfb36b7c7e6..f62e0cf28f7597e658502604aaa1688c05383530 100644 (file)
@@ -6,7 +6,11 @@
 // authors: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //          Martin Vala (martin.vala@cern.ch)
 //
-#include "Riostream.h"
+#include <Riostream.h>
+#include "AliESDEvent.h"
+#include "AliMCEvent.h"
+#include "AliAODEvent.h"
+
 #include "AliRsnCutSet.h"
 #include "AliRsnVATProcessInfo.h"
 #include "AliRsnAnalysisSE.h"
 ClassImp(AliRsnAnalysisSE)
 
 //_____________________________________________________________________________
-AliRsnAnalysisSE::AliRsnAnalysisSE(const char *name) :
-    AliRsnVAnalysisTaskSE(name),
+AliRsnAnalysisSE::AliRsnAnalysisSE(const char *name,Int_t numOfOutputs) :
+    AliRsnVAnalysisTaskSE(name,numOfOutputs),
     fRsnAnalysisManager(),
-    fPIDIndex(0),
-    fEvent(),
     fEventCuts(0x0),
-    fESDCuts(0)
+    fZeroEventPercentWarning(50),
+    fUseZeroEventWarning(kTRUE)
 {
 //
-// Default constructor
+// Default constructor.
 //
+
   AliDebug(AliLog::kDebug+2,"<-");
+  for (Int_t i=0;i<fNumberOfOutputs;i++) {
+    DefineOutput(i+2, TList::Class());
+  }
   AliDebug(AliLog::kDebug+2,"->");
 }
 
-AliRsnAnalysisSE::AliRsnAnalysisSE(const AliRsnAnalysisSE& copy) : AliRsnVAnalysisTaskSE(copy),
-    fRsnAnalysisManager(copy.fRsnAnalysisManager),
-    fPIDIndex(copy.fPIDIndex),
-    fEvent(copy.fEvent),
-    fEventCuts(copy.fEventCuts),
-    fESDCuts(copy.fESDCuts)
+//_____________________________________________________________________________
+AliRsnAnalysisSE::AliRsnAnalysisSE(const AliRsnAnalysisSE& copy) :
+  AliRsnVAnalysisTaskSE(copy),
+  fRsnAnalysisManager(copy.fRsnAnalysisManager),
+  fEventCuts(copy.fEventCuts),
+  fZeroEventPercentWarning(copy.fZeroEventPercentWarning),
+  fUseZeroEventWarning(copy.fUseZeroEventWarning)
 {
+//
+// Copy constructor.
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
   AliDebug(AliLog::kDebug+2,"->");
 }
@@ -43,123 +55,124 @@ AliRsnAnalysisSE::AliRsnAnalysisSE(const AliRsnAnalysisSE& copy) : AliRsnVAnalys
 //_____________________________________________________________________________
 void AliRsnAnalysisSE::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->Add(fRsnAnalysisManager.InitAllPairMgrs());
+  Int_t i;
+  for (i = 1; i < kMaxNumberOfOutputs + 1; i++)
+  {
+    if (i <= fNumberOfOutputs + 1) OpenFile(i+1);
+    fOutList[i] = new TList();
+    fOutList[i]->SetOwner();
+  }
+
+  for (i = 0; i < fNumberOfOutputs; i++)
+  {
+    fRsnAnalysisManager[i].InitAllPairMgrs(fOutList[i+1]);
+  }
 
   AliDebug(AliLog::kDebug+2,"->");
 }
 
-void AliRsnAnalysisSE::RsnUserExec(Option_t* )
+//_____________________________________________________________________________
+void AliRsnAnalysisSE::RsnUserExec(Option_t*)
 {
+//
+// Execution of the analysis task.
+// Recovers the input event and processes it with all included pair objects.
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
+  
+  fTaskInfo.SetEventUsed(kFALSE);
+
   if (fESDEvent) {
-    AliDebug(AliLog::kDebug+1,Form("fESDEvent if %p",fESDEvent));
-    AliDebug(AliLog::kDebug,Form("ESD tracks %d",fESDEvent->GetNumberOfTracks()));
+    AliDebug(AliLog::kDebug+1, Form("fESDEvent is %p", fESDEvent));
+    AliDebug(AliLog::kDebug, Form("ESD tracks %d", fESDEvent->GetNumberOfTracks()));
   }
   if (fMCEvent) {
-    AliDebug(AliLog::kDebug+1,Form("fMCEvent if %p",fMCEvent));
-    AliDebug(AliLog::kDebug,Form("MC tracks %d",fMCEvent->GetNumberOfTracks()));
+    AliDebug(AliLog::kDebug+1, Form("fMCEvent is %p", fMCEvent));
+    AliDebug(AliLog::kDebug, Form("MC tracks %d", fMCEvent->GetNumberOfTracks()));
   }
   if (fAODEventIn) {
-    AliDebug(AliLog::kDebug+1,Form("fAODEventIn if %p",fAODEventIn));
-    AliDebug(AliLog::kDebug,Form("AOD(in) tracks %d",fAODEventIn->GetNumberOfTracks()));
+    AliDebug(AliLog::kDebug+1, Form("fAODEventIn is %p", fAODEventIn));
+    AliDebug(AliLog::kDebug, Form("AOD(in) tracks %d", fAODEventIn->GetNumberOfTracks()));
   }
-
   if (fAODEventOut) {
-    AliDebug(AliLog::kDebug+1,Form("fAODEventOut if %p",fAODEventOut));
-    AliDebug(AliLog::kDebug,Form("AOD(out) tracks %d",fAODEventOut->GetNumberOfTracks()));
+    AliDebug(AliLog::kDebug+1, Form("fAODEventOut if %p", fAODEventOut));
+    AliDebug(AliLog::kDebug, Form("AOD(out) tracks %d", fAODEventOut->GetNumberOfTracks()));
   }
 
-  // assign event
-  if (fAODEventOut)
-    fEvent.SetRef(fAODEventOut);
-  else if (fESDEvent)
-    fEvent.SetRef(fESDEvent, fMCEvent);
-  else
+  // Removing empty events
+  if (fRsnEvent.GetMultiplicity()<=0) {
+    AliDebug(AliLog::kDebug, "Zero event!!! Skipping ...");
+    fTaskInfo.SetEventUsed(kFALSE);
+    if (fUseZeroEventWarning)
+    {
+      TH1I *hist = (TH1I*)fOutList[0]->FindObject(fTaskInfo.GetEventHistogramName());
+      if (!hist) return;
+      Double_t 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));
+    }
     return;
-  if (fEvent.GetMultiplicity()<2) return;
+  }
+
+  // if general event cuts are added to the task (recommended)
+  // they are checked here on the RSN event interface and,
+  // if the event does not pass them, it is skipped and ProcessInfo
+  // is updated accordingly
   if (fEventCuts) {
-    if (!fEventCuts->IsSelected(AliRsnCut::kEvent, &fEvent)) {
-      fTaskInfo.SetNumberOfTracks(0);
+    if (!fEventCuts->IsSelected(AliRsnCut::kEvent, &fRsnEvent)) {
+      fTaskInfo.SetEventUsed(kFALSE);
       return;
     }
-    else {
-      if (fESDEvent) {
-        fTaskInfo.SetNumberOfTracks(fESDEvent->GetNumberOfTracks());
-      }
-      else if (fAODEventOut) {
-        fTaskInfo.SetNumberOfTracks(fAODEventOut->GetNumberOfTracks());
-      }
-      else if (fAODEventIn) {
-        fTaskInfo.SetNumberOfTracks(fAODEventIn->GetNumberOfTracks());
-      }
-    }
   }
 
-  // sort tracks w.r. to PID
-  fPIDIndex.ResetAll(fEvent.GetMultiplicity());
-  fPIDIndex.SetPriorProbability(fPrior);
-  fPIDIndex.FillFromEvent(&fEvent, fESDCuts);
-  fPIDIndex.SetCorrectIndexSize();
-
-  fRsnAnalysisManager.ProcessAllPairMgrs(&fPIDIndex, &fEvent);
+  // if cuts are passed or not cuts were defined,
+  // update the task info...
+  fTaskInfo.SetEventUsed(kTRUE);
 
+  // the virtual class has already sorted tracks in the PID index
+  // so we need here just to call the execution of analysis
+  for (Int_t i = 0; i < fNumberOfOutputs; i++)
+  {
+    fRsnAnalysisManager[i].ProcessAllPairMgrs(&fRsnPIDIndex, &fRsnEvent);
+    PostData(i+2, fOutList[i+1]);
+  }
   AliDebug(AliLog::kDebug+2,"->");
 }
 
 
 //_____________________________________________________________________________
-void AliRsnAnalysisSE::RsnTerminate(Option_t* )
+void AliRsnAnalysisSE::RsnTerminate(Option_t*)
 {
+//
+// Termination.
+// Could be added some monitor histograms here.
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
   AliDebug(AliLog::kDebug+2,"->");
 }
 
 //_____________________________________________________________________________
-AliRsnAnalysisManager* AliRsnAnalysisSE::GetAnalysisManager(TString name)
-{
-  if (!name.IsNull()) {
-    SetAnalysisManagerName(name.Data());
-  }
-
-  return &fRsnAnalysisManager;
-}
-
-
-//_____________________________________________________________________________
-void AliRsnAnalysisSE::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 AliRsnAnalysisSE::DumpPriors()
+AliRsnAnalysisManager* AliRsnAnalysisSE::GetAnalysisManager(Int_t index, TString name)
 {
-  //
-  // Print all prior probabilities
-  //
+//
+// Recovery the analysis manager
+//
 
-  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]));
+  if (!name.IsNull())
+  {
+    SetAnalysisManagerName(name.Data(), index);
   }
-}
-
-//_____________________________________________________________________________
-void AliRsnAnalysisSE::GetPriorProbability(Double_t *out)
-{
 
-  Int_t i;
-  for (i=0;i<AliPID::kSPECIES;i++) {
-    out[i] = fPrior[i];
-  }
+  return &fRsnAnalysisManager[index];
 }
index 9e4a9a61044bfdb09a1623896e7e91d692d55e22..b165527bf8313b71d7471849d3a551a1b4ad7308 100644 (file)
@@ -1,65 +1,59 @@
-//\r
-// Class AliRsnAnalysisSE\r
-//\r
-// Virtual Class derivated from AliRsnVAnalysisTaskSE which will be base class\r
-// for all RSN SE tasks\r
-//\r
-// authors: Martin Vala (martin.vala@cern.ch)\r
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)\r
-//\r
-#ifndef AliRsnAnalysisSE_H\r
-#define AliRsnAnalysisSE_H\r
-\r
-#include "AliPID.h"\r
-#include "AliRsnVAnalysisTaskSE.h"\r
-#include "AliRsnAnalysisManager.h"\r
-#include "AliRsnPIDIndex.h"\r
-\r
-class AliRsnPIDDefESD;\r
-class AliRsnCutSet;\r
-\r
-class AliRsnAnalysisSE : public AliRsnVAnalysisTaskSE\r
-{\r
-\r
-public:\r
-    AliRsnAnalysisSE(const char *name = "AliRsnAnalysisSE");\r
-    AliRsnAnalysisSE(const AliRsnAnalysisSE& copy);\r
-\r
-    // Implement this\r
-    virtual void    RsnUserCreateOutputObjects();\r
-    virtual void    RsnUserExec(Option_t*);\r
-    virtual void    RsnTerminate(Option_t*);\r
-\r
-    AliRsnAnalysisManager *GetAnalysisManager(TString name = "");\r
-    void                   SetAnalysisManagerName(const char*name) {fRsnAnalysisManager.SetName(name);};\r
-\r
-    // Prior probs\r
-    void            SetPriorProbability(AliPID::EParticleType type, Double_t p);\r
-    void            DumpPriors();\r
-    void            GetPriorProbability(Double_t *out);\r
-\r
-    // ESD cuts\r
-    void            SetESDtrackCuts(AliESDtrackCuts *cuts) {fESDCuts = cuts;}\r
-\r
-    // Indexer\r
-    AliRsnPIDIndex* GetPIDIndex() {return &fPIDIndex;}\r
-    AliRsnPIDDefESD* GetPIDDef() {return fPIDIndex.GetPIDDef();}\r
-    AliRsnCutSet* GetEventCuts() {return fEventCuts;}\r
-    void SetEventCuts(AliRsnCutSet *cuts) {fEventCuts = cuts;}\r
-\r
-private:\r
-\r
-    AliRsnAnalysisSE& operator=(const AliRsnAnalysisSE& /*copy*/) {return *this;}\r
-\r
-    AliRsnAnalysisManager fRsnAnalysisManager;      // analysis main engine\r
-    AliRsnPIDIndex        fPIDIndex;                // utility --> PID sorter\r
-    AliRsnEvent           fEvent;                   // utility --> event interface\r
-    AliRsnCutSet         *fEventCuts;               // event cuts\r
-\r
-    AliESDtrackCuts      *fESDCuts;                 // ESD track cuts\r
-    Double_t              fPrior[AliPID::kSPECIES]; // prior probabilities\r
-\r
-    ClassDef(AliRsnAnalysisSE, 1)\r
-};\r
-\r
-#endif\r
+//
+// Class AliRsnAnalysisSE
+//
+// 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 ALIRSNANALYSISSE_H
+#define ALIRSNANALYSISSE_H
+
+#include "AliPID.h"
+#include "AliRsnVAnalysisTaskSE.h"
+#include "AliRsnAnalysisManager.h"
+#include "AliRsnPIDIndex.h"
+#include "AliRsnEvent.h"
+
+class AliRsnPIDDefESD;
+class AliRsnCutSet;
+
+class AliRsnAnalysisSE : public AliRsnVAnalysisTaskSE
+{
+
+  public:
+    AliRsnAnalysisSE(const char *name = "AliRsnAnalysisSE",Int_t numOfOutputs=1);
+    AliRsnAnalysisSE(const AliRsnAnalysisSE& copy);
+    virtual ~AliRsnAnalysisSE() {;};
+
+    // Implement this
+    virtual void    RsnUserCreateOutputObjects();
+    virtual void    RsnUserExec(Option_t*);
+    virtual void    RsnTerminate(Option_t*);
+
+    AliRsnAnalysisManager *GetAnalysisManager(Int_t index = 0, TString name = "");
+    void                   SetAnalysisManagerName(const char *name, Int_t index = 0)
+                            {fRsnAnalysisManager[index].SetName(name);}
+
+    AliRsnCutSet* GetEventCuts() const {return fEventCuts;}
+    void          SetEventCuts(AliRsnCutSet *const cuts) {fEventCuts = cuts;}
+
+    Double_t GetZeroEventPercentWarning() const { return fZeroEventPercentWarning;}
+    void     SetZeroEventPercentWarning(Double_t val = 50) { fZeroEventPercentWarning = val;}
+    void     UseZeroEventWarning(Bool_t b = true) { fUseZeroEventWarning = b;}
+
+  private:
+
+    AliRsnAnalysisSE& operator=(const AliRsnAnalysisSE& /*copy*/) {return *this;}
+
+    AliRsnAnalysisManager fRsnAnalysisManager[10];  // analysis main engine
+    AliRsnCutSet         *fEventCuts;               // event cuts
+
+    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 f6b085ae5d71fd41a5116612104dbb39d40717b3..f1d2a38a66c95716b146bc065d2e213c35aaa898 100644 (file)
 //
 #include "AliLog.h"
 
-#include "AliRsnDaughter.h"
-#include "AliRsnPairParticle.h"
-#include "AliRsnEvent.h"
-
 #include "AliRsnCut.h"
 
 ClassImp(AliRsnCut)
 
 //_________________________________________________________________________________________________
 AliRsnCut::AliRsnCut() :
-  TNamed(),
-  fVarType(kInt),
-  fMinI(0),
-  fMaxI(0),
-  fMinU(0),
-  fMaxU(0),
-  fMinD(0.0),
-  fMaxD(0.0),
-  fCutValueI(0),
-  fCutValueU(0),
-  fCutValueD(0.0),
-  fCutResult(kTRUE)
+    TNamed(),
+    fVarType(kInt),
+    fMinI(0),
+    fMaxI(0),
+    fMinU(0),
+    fMaxU(0),
+    fMinD(0.0),
+    fMaxD(0.0),
+    fCutValueI(0),
+    fCutValueU(0),
+    fCutValueD(0.0),
+    fCutResult(kTRUE)
 {
 //
 // Default constructor.
@@ -48,18 +44,18 @@ AliRsnCut::AliRsnCut() :
 //_________________________________________________________________________________________________
 AliRsnCut::AliRsnCut
 (const char *name, Int_t min, Int_t max) :
-  TNamed(name, ""),
-  fVarType(kInt),
-  fMinI(min),
-  fMaxI(max),
-  fMinU(0),
-  fMaxU(0),
-  fMinD(0.0),
-  fMaxD(0.0),
-  fCutValueI(0),
-  fCutValueU(0),
-  fCutValueD(0.0),
-  fCutResult(kTRUE)
+    TNamed(name, ""),
+    fVarType(kInt),
+    fMinI(min),
+    fMaxI(max),
+    fMinU(0),
+    fMaxU(0),
+    fMinD(0.0),
+    fMaxD(0.0),
+    fCutValueI(0),
+    fCutValueU(0),
+    fCutValueD(0.0),
+    fCutResult(kTRUE)
 {
 //
 // Constructor.
@@ -73,18 +69,18 @@ AliRsnCut::AliRsnCut
 //_________________________________________________________________________________________________
 AliRsnCut::AliRsnCut
 (const char *name, ULong_t min, ULong_t max) :
-  TNamed(name, ""),
-  fVarType(kULong),
-  fMinI(0),
-  fMaxI(0),
-  fMinU(min),
-  fMaxU(max),
-  fMinD(0.0),
-  fMaxD(0.0),
-  fCutValueI(0),
-  fCutValueU(0),
-  fCutValueD(0.0),
-  fCutResult(kTRUE)
+    TNamed(name, ""),
+    fVarType(kULong),
+    fMinI(0),
+    fMaxI(0),
+    fMinU(min),
+    fMaxU(max),
+    fMinD(0.0),
+    fMaxD(0.0),
+    fCutValueI(0),
+    fCutValueU(0),
+    fCutValueD(0.0),
+    fCutResult(kTRUE)
 {
 //
 // Constructor.
@@ -98,18 +94,18 @@ AliRsnCut::AliRsnCut
 //_________________________________________________________________________________________________
 AliRsnCut::AliRsnCut
 (const char *name, Double_t min, Double_t max) :
-  TNamed(name, ""),
-  fVarType(kDouble),
-  fMinI(0),
-  fMaxI(0),
-  fMinU(0),
-  fMaxU(0),
-  fMinD(min),
-  fMaxD(max),
-  fCutValueI(0),
-  fCutValueU(0),
-  fCutValueD(0.0),
-  fCutResult(kTRUE)
+    TNamed(name, ""),
+    fVarType(kDouble),
+    fMinI(0),
+    fMaxI(0),
+    fMinU(0),
+    fMaxU(0),
+    fMinD(min),
+    fMaxD(max),
+    fCutValueI(0),
+    fCutValueU(0),
+    fCutValueD(0.0),
+    fCutResult(kTRUE)
 {
 //
 // Constructor.
@@ -129,6 +125,7 @@ Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnDaughter* /*track*/)
 // with the defined target, in order to detect a mismatch
 //
 
+  AliWarning("This cut does not provide checks on AliRsnDaughter. This function will return kTRUE");
   return kTRUE;
 }
 
@@ -141,6 +138,7 @@ Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnPairParticle* /*pair*/)
 // with the defined target, in order to detect a mismatch
 //
 
+  AliWarning("This cut does not provide checks on AliRsnPairParticle. This function will return kTRUE");
   return kTRUE;
 }
 
@@ -153,6 +151,7 @@ Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*event*/)
 // with the defined target, in order to detect a mismatch
 //
 
+  AliWarning("This cut does not provide checks on AliRsnEvent. This function will return kTRUE");
   return kTRUE;
 }
 
@@ -165,6 +164,7 @@ Bool_t AliRsnCut::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*ev1*/, AliRsnEvent*
 // with the defined target, in order to detect a mismatch
 //
 
+  AliWarning("This cut does not provide checks on two AliRsnEvent's. This function will return kTRUE");
   return kTRUE;
 }
 
@@ -177,44 +177,43 @@ Bool_t AliRsnCut::OkValue()
 // Then, the cut result is kTRUE if the cut value is equal to this reference value.
 //
 
-  switch (fVarType)
-  {
-    case kInt:
-      // eval result
-      fCutResult = (fCutValueI == fMinI);
-      // print debug message
-      AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-      AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
-      AliDebug(AliLog::kDebug + 3, Form("Checked value: %d", fCutValueI));
-      AliDebug(AliLog::kDebug + 3, Form("Cut value    : %d", fMinI));
-      AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-      AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-      break;
-    case kULong:
-      // eval result
-      fCutResult = (fCutValueU == fMinU);
-      // print debug message
-      AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-      AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
-      AliDebug(AliLog::kDebug + 3, Form("Checked value: %d", fCutValueU));
-      AliDebug(AliLog::kDebug + 3, Form("Cut value    : %d", fMinU));
-      AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-      AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-      break;
-    case kDouble:
-      // eval result
-      fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
-      // print debug message
-      AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-      AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
-      AliDebug(AliLog::kDebug + 3, Form("Checked value: %f", fCutValueD));
-      AliDebug(AliLog::kDebug + 3, Form("Cut value    : %f", fMinD));
-      AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-      AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-      break;
-    default:
-      AliError(Form("fVarType = %d --> not allowed", fVarType));
-      return kFALSE;
+  switch (fVarType) {
+  case kInt:
+    // eval result
+    fCutResult = (fCutValueI == fMinI);
+    // print debug message
+    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
+    AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
+    AliDebug(AliLog::kDebug + 3, Form("Checked value: %d", fCutValueI));
+    AliDebug(AliLog::kDebug + 3, Form("Cut value    : %d", fMinI));
+    AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
+    break;
+  case kULong:
+    // eval result
+    fCutResult = (fCutValueU == fMinU);
+    // print debug message
+    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
+    AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
+    AliDebug(AliLog::kDebug + 3, Form("Checked value: %d", fCutValueU));
+    AliDebug(AliLog::kDebug + 3, Form("Cut value    : %d", fMinU));
+    AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
+    break;
+  case kDouble:
+    // eval result
+    fCutResult = (TMath::Abs(fCutValueD - fMinD) < 1E-6);
+    // print debug message
+    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
+    AliDebug(AliLog::kDebug + 3, Form("Cut name     : %s", GetName()));
+    AliDebug(AliLog::kDebug + 3, Form("Checked value: %f", fCutValueD));
+    AliDebug(AliLog::kDebug + 3, Form("Cut value    : %f", fMinD));
+    AliDebug(AliLog::kDebug + 3, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
+    break;
+  default:
+    AliError(Form("fVarType = %d --> not allowed", fVarType));
+    return kFALSE;
   }
 
   return fCutResult;
@@ -229,44 +228,43 @@ Bool_t AliRsnCut::OkRange()
 // Then, the cut result is kTRUE if the cut value is inside this range.
 //
 
-  switch (fVarType)
-  {
-    case kInt:
-      // eval result
-      fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
-      // print debug message
-      AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-      AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
-      AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueI));
-      AliDebug(AliLog::kDebug + 2, Form("Cut range    : %d , %d", fMinI, fMaxI));
-      AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-      AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-      break;
-    case kULong:
-      // eval result
-      fCutResult = ((fCutValueU >= fMinU) && (fCutValueU <= fMaxU));
-      // print debug message
-      AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-      AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
-      AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueU));
-      AliDebug(AliLog::kDebug + 2, Form("Cut range    : %d , %d", fMinU, fMaxU));
-      AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-      AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-      break;
-    case kDouble:
-      // eval result
-      fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
-      // print debug message
-      AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
-      AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
-      AliDebug(AliLog::kDebug + 2, Form("Checked value: %f", fCutValueD));
-      AliDebug(AliLog::kDebug + 2, Form("Cut range    : %f , %f", fMinD, fMaxD));
-      AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
-      AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
-      break;
-    default:
-      AliError(Form("fVarType = %d --> not allowed", fVarType));
-      return kFALSE;
+  switch (fVarType) {
+  case kInt:
+    // eval result
+    fCutResult = ((fCutValueI >= fMinI) && (fCutValueI <= fMaxI));
+    // print debug message
+    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
+    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
+    AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueI));
+    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %d , %d", fMinI, fMaxI));
+    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
+    break;
+  case kULong:
+    // eval result
+    fCutResult = ((fCutValueU >= fMinU) && (fCutValueU <= fMaxU));
+    // print debug message
+    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
+    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
+    AliDebug(AliLog::kDebug + 2, Form("Checked value: %d", fCutValueU));
+    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %d , %d", fMinU, fMaxU));
+    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
+    break;
+  case kDouble:
+    // eval result
+    fCutResult = ((fCutValueD >= fMinD) && (fCutValueD <= fMaxD));
+    // print debug message
+    AliDebug(AliLog::kDebug + 3, "=== CUT DEBUG ====================================");
+    AliDebug(AliLog::kDebug + 2, Form("Cut name     : %s", GetName()));
+    AliDebug(AliLog::kDebug + 2, Form("Checked value: %f", fCutValueD));
+    AliDebug(AliLog::kDebug + 2, Form("Cut range    : %f , %f", fMinD, fMaxD));
+    AliDebug(AliLog::kDebug + 2, Form("Cut result   : %s", (fCutResult ? "PASSED" : "NOT PASSED")));
+    AliDebug(AliLog::kDebug + 3, "=== END CUT DEBUG ================================");
+    break;
+  default:
+    AliError(Form("fVarType = %d --> not allowed", fVarType));
+    return kFALSE;
   }
 
   return fCutResult;
index e207deabd072006f2bc8de8d3c2029e99907ed93..215ae8197adae66d80ea05b109c1b4e809b750dc 100644 (file)
@@ -48,7 +48,7 @@ class AliRsnCut : public TNamed
     AliRsnCut(const char *name, Int_t    min, Int_t    max = 0);
     AliRsnCut(const char *name, ULong_t  min, ULong_t  max = 0);
     AliRsnCut(const char *name, Double_t min, Double_t max = 0);
-    virtual ~AliRsnCut() { }
+    virtual ~AliRsnCut() {;};
 
     void             SetRange(Int_t    min, Int_t    max) {fMinI = min; fMaxI = max; fVarType = kInt;}
     void             SetRange(ULong_t  min, ULong_t  max) {fMinU = min; fMaxU = max; fVarType = kULong;}
@@ -63,7 +63,7 @@ class AliRsnCut : public TNamed
     virtual Bool_t   IsSelected(ETarget tgt, AliRsnEvent *event);
     virtual Bool_t   IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
 
-protected:
+  protected:
 
     Bool_t  OkValue();
     Bool_t  OkRange();
index 627281b51a386ea79843da4903bab1e6cf7e0a88..492cacbbf02bbcc0a64b3b45bd9d3ea973c53698 100644 (file)
@@ -17,9 +17,6 @@
 //
 #include "TMath.h"
 
-#include "AliLog.h"
-#include "AliESDtrack.h"
-
 #include "AliRsnDaughter.h"
 #include "AliRsnCutBetheBloch.h"
 
@@ -27,10 +24,10 @@ ClassImp(AliRsnCutBetheBloch)
 
 //_________________________________________________________________________________________________
 AliRsnCutBetheBloch::AliRsnCutBetheBloch() :
-  AliRsnCut(),
-  fCorrect(kTRUE),
-  fMIP(50.0),
-  fType(AliPID::kUnknown)
+    AliRsnCut(),
+    fCorrect(kTRUE),
+    fMIP(50.0),
+    fType(AliPID::kUnknown)
 {
 //
 // Default constructor.
@@ -42,10 +39,10 @@ AliRsnCutBetheBloch::AliRsnCutBetheBloch() :
 //_________________________________________________________________________________________________
 AliRsnCutBetheBloch::AliRsnCutBetheBloch
 (const char *name, Double_t fractionRange, AliPID::EParticleType type, Double_t mip, Bool_t correct) :
-  AliRsnCut(name, 0.0, fractionRange),
-  fCorrect(correct),
-  fMIP(mip),
-  fType(type)
+    AliRsnCut(name, 0.0, fractionRange),
+    fCorrect(correct),
+    fMIP(mip),
+    fType(type)
 {
 //
 // Main constructor.
@@ -59,7 +56,7 @@ AliRsnCutBetheBloch::AliRsnCutBetheBloch
 }
 
 //_____________________________________________________________________________
-Double_t AliRsnCutBetheBloch::BetheBloch(AliRsnDaughter *track)
+Double_t AliRsnCutBetheBloch::BetheBloch(AliRsnDaughter * const track)
 {
 //
 // Computes the theoretical dE/dx according to
@@ -84,8 +81,7 @@ Double_t AliRsnCutBetheBloch::BetheBloch(AliRsnDaughter *track)
 
   Double_t out = (fConst[1] - aa - bb) * fConst[0] / aa;
 
-  if (fCorrect)
-  {
+  if (fCorrect) {
     Double_t kMeanCorr = 0.1;
     Double_t meanCorr = (1 + (out - 1) * kMeanCorr);
     out *= meanCorr;
@@ -116,8 +112,7 @@ Bool_t AliRsnCutBetheBloch::IsSelected(ETarget tgt, AliRsnDaughter *track)
 //
 
   // coherence check
-  if (tgt != AliRsnCut::kParticle)
-  {
+  if (tgt != AliRsnCut::kParticle) {
     AliError(Form("Wrong target. Skipping cut", GetName()));
     return kTRUE;
   }
@@ -127,8 +122,7 @@ Bool_t AliRsnCutBetheBloch::IsSelected(ETarget tgt, AliRsnDaughter *track)
   if (track->RequiredPID() != fType) return kTRUE;
 
   // retrieve the TPC signal
-  AliVParticle *vpart = track->GetRef();
-  AliESDtrack *esd = dynamic_cast<AliESDtrack*>(vpart);
+  AliESDtrack *esd = track->GetRefESD();
   if (!esd) {
     AliError("ESD information unavailable");
     return kTRUE;
index c71de547f70e2dd0218af3eafd5d4c0a963b0eca..4a0269a5e24c80168c7b46e0cd4454d3815da4e9 100644 (file)
@@ -9,38 +9,39 @@
 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
-#ifndef ALIRSNCUTBETHEBLOCK_H
-#define ALIRSNCUTBETHEBLOCK_H
+#ifndef ALIRSNCUTBETHEBLOCH_H
+#define ALIRSNCUTBETHEBLOCH_H
 
 #include "AliPID.h"
 #include "AliRsnCut.h"
 
 class AliRsnCutBetheBloch : public AliRsnCut
 {
- public:
 public:
 
-  AliRsnCutBetheBloch();
-  AliRsnCutBetheBloch(const char *name, Double_t fractionRange, AliPID::EParticleType type, Double_t mip = 50.0, Bool_t correct = kTRUE);
+    AliRsnCutBetheBloch();
+    AliRsnCutBetheBloch(const char *name, Double_t fractionRange, AliPID::EParticleType type, Double_t mip = 50.0, Bool_t correct = kTRUE);
+    virtual ~AliRsnCutBetheBloch() {;};
 
-  void           SetType(AliPID::EParticleType type) {fType = type;}
-  void           SetMIP(Double_t mip) {fMIP = mip;}
-  void           SetCalibConstant(Int_t i, Double_t value) {if (i>=0&&i<5) fConst[i] = value;}
-  Double_t       BetheBloch(AliRsnDaughter *track);
-  Double_t       RelDiff(AliRsnDaughter *track);
+    void           SetType(AliPID::EParticleType type) {fType = type;}
+    void           SetMIP(Double_t mip) {fMIP = mip;}
+    void           SetCalibConstant(Int_t i, Double_t value) {if (i>=0&&i<5) fConst[i] = value;}
+    Double_t       BetheBloch(AliRsnDaughter*const track);
+    Double_t       RelDiff(AliRsnDaughter *track);
 
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnDaughter *daughter);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnPairParticle *pair);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *event);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
+    virtual Bool_t IsSelected(ETarget tgt, AliRsnDaughter *daughter);
+    virtual Bool_t IsSelected(ETarget tgt, AliRsnPairParticle *pair);
+    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *event);
+    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
 
-protected:
+  protected:
 
-  Bool_t                fCorrect;   // apply or not the saturation corrections
-  Double_t              fMIP;       // MIP normalization
-  Double_t              fConst[5];  // calibration constants
-  AliPID::EParticleType fType;      // reference particle type
+    Bool_t                fCorrect;   // apply or not the saturation corrections
+    Double_t              fMIP;       // MIP normalization
+    Double_t              fConst[5];  // calibration constants
+    AliPID::EParticleType fType;      // reference particle type
 
-  ClassDef(AliRsnCutBetheBloch, 1)
+    ClassDef(AliRsnCutBetheBloch, 1)
 };
 
 #endif
index 55198372041258615599783663ae4b7c6f268872..5cb005884db8968b903da298722e6c782989117f 100644 (file)
 // authors: Martin Vala (martin.vala@cern.ch)
 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
-#include "TMath.h"
-
-#include "AliLog.h"
-#include "AliESDtrack.h"
-#include "AliESDtrackCuts.h"
 
 #include "AliRsnDaughter.h"
 #include "AliRsnCutESDPrimary.h"
@@ -28,8 +23,8 @@ ClassImp(AliRsnCutESDPrimary)
 
 //_________________________________________________________________________________________________
 AliRsnCutESDPrimary::AliRsnCutESDPrimary() :
-  AliRsnCut(),
-  fCuts()
+    AliRsnCut(),
+    fCuts()
 {
 //
 // Default constructor.
@@ -39,8 +34,8 @@ AliRsnCutESDPrimary::AliRsnCutESDPrimary() :
 //_________________________________________________________________________________________________
 AliRsnCutESDPrimary::AliRsnCutESDPrimary
 (const char *name) :
-  AliRsnCut(name, 0.0, 0.0),
-  fCuts()
+    AliRsnCut(name, 0.0, 0.0),
+    fCuts()
 {
 //
 // Main constructor.
@@ -48,15 +43,14 @@ AliRsnCutESDPrimary::AliRsnCutESDPrimary
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutESDPrimary::IsSelected(ETarget tgt, AliRsnDaughter *track)
+Bool_t AliRsnCutESDPrimary::IsSelected(ETarget tgt, AliRsnDaughter * const track)
 {
 //
 // Cut checker.
 //
 
   // coherence check
-  if (tgt != AliRsnCut::kParticle)
-  {
+  if (tgt != AliRsnCut::kParticle) {
     AliError(Form("Wrong target. Skipping cut", GetName()));
     return kTRUE;
   }
index ef1b5eee155a6569e48565ca85a7f33ecf87f433..8a0e54404ae849169bd77da8221a733964c18ef6 100644 (file)
 
 class AliRsnCutESDPrimary : public AliRsnCut
 {
- public:
 public:
 
-  AliRsnCutESDPrimary();
-  AliRsnCutESDPrimary(const char *name);
+    AliRsnCutESDPrimary();
+    AliRsnCutESDPrimary(const char *name);
+    virtual ~AliRsnCutESDPrimary() {;};
 
-  AliESDtrackCuts GetCuts() {return fCuts;}
+    AliESDtrackCuts* GetCuts() {return &fCuts;}
 
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnDaughter *daughter);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnPairParticle *pair);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *event);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
+    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnDaughter*const daughter);
+    virtual Bool_t IsSelected(ETarget tgt, AliRsnPairParticle *pair);
+    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *event);
+    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
 
-protected:
+  protected:
 
-  AliESDtrackCuts fCuts;  // set of ESD track cuts
+    AliESDtrackCuts fCuts;  // set of ESD track cuts
 
-  ClassDef(AliRsnCutESDPrimary, 1)
+    ClassDef(AliRsnCutESDPrimary, 1)
 };
 
 #endif
index d687bb5343fe7bcd3d4ffebb3ff783b575722092..6e4dc88a801bb73896597dbf6ac94759aed928dc 100644 (file)
@@ -11,8 +11,6 @@
 
 #include "AliLog.h"
 
-#include "AliRsnDaughter.h"
-#include "AliRsnEvent.h"
 #include "AliRsnCutSet.h"
 #include "AliRsnCutMgr.h"
 
@@ -27,8 +25,7 @@ AliRsnCutMgr::AliRsnCutMgr() :
 //
 
   Int_t i;
-  for (i = 0; i < AliRsnCut::kLastCutTarget; i++)
-  {
+  for (i = 0; i < AliRsnCut::kLastCutTarget; i++) {
     fCutSets[i] = 0;
   }
 }
@@ -42,8 +39,7 @@ AliRsnCutMgr::AliRsnCutMgr(const char *name, const char *title) :
 //
 
   Int_t i;
-  for (i = 0; i < AliRsnCut::kLastCutTarget; i++)
-  {
+  for (i = 0; i < AliRsnCut::kLastCutTarget; i++) {
     fCutSets[i] = 0;
   }
 }
@@ -57,14 +53,13 @@ AliRsnCutMgr::~AliRsnCutMgr()
 //
 
   Int_t i;
-  for (i = 0; i < AliRsnCut::kLastCutTarget; i++)
-  {
+  for (i = 0; i < AliRsnCut::kLastCutTarget; i++) {
     delete fCutSets[i];
   }
 }
 
 //_____________________________________________________________________________
-void AliRsnCutMgr::SetCutSet(AliRsnCut::ETarget type, AliRsnCutSet* cutset)
+void AliRsnCutMgr::SetCutSet(AliRsnCut::ETarget type, AliRsnCutSet* const cutset)
 {
 //
 // Assign a cut set to a given target
@@ -75,7 +70,7 @@ void AliRsnCutMgr::SetCutSet(AliRsnCut::ETarget type, AliRsnCutSet* cutset)
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnCutMgr::IsSelected(AliRsnCut::ETarget type,TObject *obj)
+Bool_t AliRsnCutMgr::IsSelected(AliRsnCut::ETarget type, TObject*const obj)
 {
 //
 // Check if a given object passes the cuts defined for it.
@@ -87,21 +82,20 @@ Bool_t AliRsnCutMgr::IsSelected(AliRsnCut::ETarget type,TObject *obj)
   AliDebug(AliLog::kDebug, "<-");
   if (!fCutSets[type]) return kTRUE;
 
-  switch (type)
-  {
-    case AliRsnCut::kParticle:
-      return fCutSets[type]->IsSelected(type, (AliRsnDaughter*)obj);
-      break;
-    case AliRsnCut::kPair:
-      return fCutSets[type]->IsSelected(type, (AliRsnPairParticle*)obj);
-      break;
-    case AliRsnCut::kEvent:
-      return fCutSets[type]->IsSelected(type, (AliRsnEvent*)obj);
-      break;
-    default:
-      AliWarning("Wrong target selected.");
-      return kTRUE;
-      break;
+  switch (type) {
+  case AliRsnCut::kParticle:
+    return fCutSets[type]->IsSelected(type, (AliRsnDaughter*)obj);
+    break;
+  case AliRsnCut::kPair:
+    return fCutSets[type]->IsSelected(type, (AliRsnPairParticle*)obj);
+    break;
+  case AliRsnCut::kEvent:
+    return fCutSets[type]->IsSelected(type, (AliRsnEvent*)obj);
+    break;
+  default:
+    AliWarning("Wrong target selected.");
+    return kTRUE;
+    break;
   }
 
   return kTRUE;
index f96c2be9a10ab7030b076188f363f54b6fd67798..1ca6b4776b08612e370a98485ff3f627431cd63e 100644 (file)
@@ -12,8 +12,7 @@
 #ifndef ALIRSNCUTMGR_H
 #define ALIRSNCUTMGR_H
 
-#include "TNamed.h"
-#include "TObjArray.h"
+#include <TNamed.h>
 
 #include "AliRsnCut.h"
 
@@ -27,9 +26,9 @@ class AliRsnCutMgr : public TNamed
     AliRsnCutMgr(const char *name, const char* title);
     ~AliRsnCutMgr();
 
-    void          SetCutSet(AliRsnCut::ETarget type, AliRsnCutSet* cutset);
+    void          SetCutSet(AliRsnCut::ETarget type, AliRsnCutSet*const cutset);
     AliRsnCutSet* GetCutSet(AliRsnCut::ETarget type) {return fCutSets[type];}
-    Bool_t        IsSelected(AliRsnCut::ETarget type, TObject *obj);
+    Bool_t        IsSelected(AliRsnCut::ETarget type, TObject *const obj);
 
   private:
 
index 5927b0623d94f37a4201b296cdb3392b36054469..263f8a6dbb382898f2248fccef4577476bb82eda 100644 (file)
 // authors: Martin Vala (martin.vala@cern.ch)
 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
-#include "Riostream.h"
-#include "TMath.h"
 
-#include "AliLog.h"
-#include "AliESDEvent.h"
-#include "AliESDVertex.h"
-
-#include "AliRsnEvent.h"
+// #include "AliLog.h"
+// #include "AliESDEvent.h"
+// #include "AliESDVertex.h"
+// 
+// #include "AliRsnEvent.h"
+// #include "AliRsnCutPrimaryVertex.h"
+
+// #include "Riostream.h"
+// #include "TMath.h"
+// 
+// #include "AliLog.h"
+// #include "AliESDEvent.h"
+// #include "AliESDVertex.h"
+// 
+// #include "AliRsnEvent.h"
 #include "AliRsnCutPrimaryVertex.h"
 
 ClassImp(AliRsnCutPrimaryVertex)
 
 //_________________________________________________________________________________________________
 AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex() :
-  AliRsnCut()
+    AliRsnCut()
 {
 //
 // Default constructor.
@@ -39,7 +47,7 @@ AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex() :
 //_________________________________________________________________________________________________
 AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex
 (const char *name, Int_t nContributors) :
-  AliRsnCut(name, 0, nContributors)
+    AliRsnCut(name, 0, nContributors)
 {
 //
 // Main constructor.
@@ -48,18 +56,17 @@ AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutPrimaryVertex::IsSelected(ETarget tgt, AliRsnDaughter *track)
+Bool_t AliRsnCutPrimaryVertex::IsSelected(AliRsnCut::ETarget /*tgt*/, AliRsnDaughter*/*const track*/) const
 {
 //
 // Cut checker.
 //
-
   AliWarning("Cannot apply this cut to particles");
   return kTRUE;
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutPrimaryVertex::IsSelected(ETarget /*tgt*/, AliRsnPairParticle* /*pair*/)
+Bool_t AliRsnCutPrimaryVertex::IsSelected(AliRsnCut::ETarget, AliRsnPairParticle*/*const pair*/) const
 {
 //
 // Cut checker
@@ -70,7 +77,7 @@ Bool_t AliRsnCutPrimaryVertex::IsSelected(ETarget /*tgt*/, AliRsnPairParticle* /
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutPrimaryVertex::IsSelected(ETarget /*tgt*/, AliRsnEvent *event)
+Bool_t AliRsnCutPrimaryVertex::IsSelected(AliRsnCut::ETarget, AliRsnEvent*event)
 {
 //
 // Cut checker
@@ -101,7 +108,7 @@ Bool_t AliRsnCutPrimaryVertex::IsSelected(ETarget /*tgt*/, AliRsnEvent *event)
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutPrimaryVertex::IsSelected(ETarget /*tgt*/, AliRsnEvent* /*ev1*/, AliRsnEvent* /*ev2*/)
+Bool_t AliRsnCutPrimaryVertex::IsSelected(AliRsnCut::ETarget, AliRsnEvent*/*ev1*/, AliRsnEvent*/*ev2*/) const
 {
 //
 // Cut checker
index ab96260852647d62c38ab99898b358fc5b67785d..a7e87e9daa69d6fc687c619416ed3486777472f3 100644 (file)
 #ifndef ALIRSNCUTPRIMARYVERTEX_H
 #define ALIRSNCUTPRIMARYVERTEX_H
 
-#include "AliPID.h"
 #include "AliRsnCut.h"
+#include "AliPID.h"
+
+#include "Riostream.h"
+#include "TMath.h"
+
+#include "AliLog.h"
+#include "AliESDEvent.h"
+#include "AliESDVertex.h"
+
+#include "AliRsnEvent.h"
 
+class AliRsnEvent;
+class AliRsnDaughter;
+class AliRsnPairParticle;
 class AliRsnCutPrimaryVertex : public AliRsnCut
 {
- public:
 public:
 
-  AliRsnCutPrimaryVertex();
-  AliRsnCutPrimaryVertex(const char *name, Int_t minContributors);
+    AliRsnCutPrimaryVertex();
+    AliRsnCutPrimaryVertex(const char *name, Int_t minContributors);
+    virtual ~AliRsnCutPrimaryVertex() {;};
 
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnDaughter *daughter);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnPairParticle *pair);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *event);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
+    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnDaughter *daughter) const;
+    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnPairParticle *pair) const;
+    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *event);
+    virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2) const;
 
-protected:
+  protected:
 
-  ClassDef(AliRsnCutPrimaryVertex, 1)
+    ClassDef(AliRsnCutPrimaryVertex, 1)
 };
 
 #endif
index 4bf61b2aeae81654329a791a7551d8189b816c61..3235e39f7000b9951517205f748fe4eff19817ae 100644 (file)
@@ -32,7 +32,7 @@ AliRsnCutSet::AliRsnCutSet() :
 //
 
   fBoolValues = new Bool_t[1];
-  AliRsnExpression::sCutSet = this;
+  AliRsnExpression::fgCutSet = this;
 }
 
 //_____________________________________________________________________________
@@ -52,7 +52,7 @@ AliRsnCutSet::AliRsnCutSet(TString name) :
 
   fBoolValues = new Bool_t[1];
   fExpression = 0;
-  AliRsnExpression::sCutSet = this;
+  AliRsnExpression::fgCutSet = this;
 }
 
 //_____________________________________________________________________________
@@ -70,7 +70,7 @@ AliRsnCutSet::AliRsnCutSet(const AliRsnCutSet & copy) :
 // Copy constructor
 //
 
-  AliRsnExpression::sCutSet = this;
+  AliRsnExpression::fgCutSet = this;
 }
 
 //_____________________________________________________________________________
@@ -101,8 +101,7 @@ void AliRsnCutSet::AddCut(AliRsnCut *cut)
   if (fBoolValues) delete fBoolValues;
 
   fBoolValues = new Bool_t[fNumOfCuts];
-  for (i = 0; i < fNumOfCuts; i++)
-  {
+  for (i = 0; i < fNumOfCuts; i++) {
     fBoolValues[i] = kTRUE;
   }
 
@@ -111,7 +110,7 @@ void AliRsnCutSet::AddCut(AliRsnCut *cut)
 }
 
 //_____________________________________________________________________________
-void AliRsnCutSet::ShowCuts()
+void AliRsnCutSet::ShowCuts() const
 {
 //
 // Prints all cuts
@@ -137,8 +136,7 @@ Bool_t AliRsnCutSet::IsSelected(AliRsnCut::ETarget type, AliRsnDaughter *daughte
 
   Bool_t boolReturn = kTRUE;
   AliRsnCut *cut;
-  for (i = 0; i < fNumOfCuts; i++)
-  {
+  for (i = 0; i < fNumOfCuts; i++) {
     cut = (AliRsnCut*)fCuts.At(i);
     fBoolValues[i] = cut->IsSelected(type,daughter);
   }
@@ -160,8 +158,7 @@ Bool_t AliRsnCutSet::IsSelected(AliRsnCut::ETarget type, AliRsnPairParticle * pa
 
   Bool_t boolReturn = kTRUE;
   AliRsnCut *cut;
-  for (i = 0; i < fNumOfCuts; i++)
-  {
+  for (i = 0; i < fNumOfCuts; i++) {
     cut = (AliRsnCut*) fCuts.At(i);
     fBoolValues[i] = cut->IsSelected(type,pair);
   }
@@ -182,8 +179,7 @@ Bool_t AliRsnCutSet::IsSelected(AliRsnCut::ETarget type, AliRsnEvent * event)
 
   Bool_t boolReturn = kTRUE;
   AliRsnCut *cut;
-  for (i = 0; i < fNumOfCuts; i++)
-  {
+  for (i = 0; i < fNumOfCuts; i++) {
     cut = (AliRsnCut*) fCuts.At(i);
     fBoolValues[i] = cut->IsSelected(type,event);
   }
@@ -204,8 +200,7 @@ Bool_t AliRsnCutSet::IsSelected(AliRsnCut::ETarget type, AliRsnEvent * ev1, AliR
 
   Bool_t boolReturn = kTRUE;
   AliRsnCut *cut;
-  for (i = 0; i < fNumOfCuts; i++)
-  {
+  for (i = 0; i < fNumOfCuts; i++) {
     cut = (AliRsnCut*) fCuts.At(i);
     fBoolValues[i] = cut->IsSelected(type,ev1,ev2);
   }
@@ -253,8 +248,7 @@ Int_t AliRsnCutSet::GetIndexByCutName(TString s)
   Int_t i;
   AliRsnCut *cut;
 
-  for (i = 0; i < fCuts.GetEntriesFast(); i++)
-  {
+  for (i = 0; i < fCuts.GetEntriesFast(); i++) {
     cut = (AliRsnCut*) fCuts.At(i);
     if (!s.CompareTo(cut->GetName())) return i;
   }
@@ -270,9 +264,8 @@ Bool_t AliRsnCutSet::Passed()
 // and gives a global response to the cut check
 //
 
-  AliRsnExpression::sCutSet = this;
-  if (!fExpression)
-  {
+  AliRsnExpression::fgCutSet = this;
+  if (!fExpression) {
     fExpression = new AliRsnExpression(fCutSchemeIndexed);
     AliDebug(AliLog::kDebug,"fExpression was created.");
   }
@@ -338,8 +331,7 @@ void AliRsnCutSet::PrintSetInfo()
   AliInfo(Form("Num of Cuts: %d", fCuts.GetEntriesFast()));
   AliInfo("====== Cuts ======");
   AliRsnCut *cut;
-  for (i = 0; i < fCuts.GetEntriesFast(); i++)
-  {
+  for (i = 0; i < fCuts.GetEntriesFast(); i++) {
     cut = (AliRsnCut*) fCuts.At(i);
     if (cut) AliInfo(Form("%d %d",i,fBoolValues[i]));
   }
@@ -359,8 +351,7 @@ TString AliRsnCutSet::GetCutSchemeIndexed()
   TString str(fCutScheme);
   AliDebug(AliLog::kDebug,Form("Num of cuts %d",fCuts.GetEntriesFast()));
   AliRsnCut *cut;
-  for (i = 0; i < fCuts.GetEntriesFast(); i++)
-  {
+  for (i = 0; i < fCuts.GetEntriesFast(); i++) {
     cut = (AliRsnCut*) fCuts.At(i);
     str.ReplaceAll(cut->GetName(),Form("%d",i));
   }
index d1528e833b40dbdf698a39c3c9f3fd42ed159d53..c5d720315e130e7bcdf9cad339dbea6d6fc965aa 100644 (file)
@@ -29,11 +29,12 @@ class AliRsnCutSet : public TNamed
     AliRsnCutSet();
     AliRsnCutSet(TString name);
     AliRsnCutSet(const AliRsnCutSet &copy);
+    AliRsnCutSet& operator=(const AliRsnCutSet& /*copy*/) {return (*this);}
     ~AliRsnCutSet();
 
     void      AddCut(AliRsnCut* cut);
 
-    void      ShowCuts();
+    void      ShowCuts() const;
     Int_t     GetIndexByCutName(TString s);
     Bool_t    Passed();
     Bool_t    IsValidScheme();
@@ -59,8 +60,6 @@ class AliRsnCutSet : public TNamed
 
   private:
 
-    AliRsnCutSet& operator=(const AliRsnCutSet& /*copy*/) {return (*this);}
-
     TObjArray     fCuts;                  // array of cuts
     Int_t         fNumOfCuts;             // number of cuts
     TString       fCutScheme;             // cut scheme
index 689a0f7ff9cd83dfacb471ec86dedfcc9a5d819c..ae51e00b8e52fefcd1e04286f21d3678607ecdba 100644 (file)
 // authors: Martin Vala (martin.vala@cern.ch)
 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
-#include "Riostream.h"
+
 #include "TParticle.h"
 #include "TMath.h"
 
-#include "AliLog.h"
-
 #include "AliRsnDaughter.h"
 #include "AliRsnEvent.h"
 #include "AliRsnPairParticle.h"
@@ -31,9 +29,9 @@ ClassImp(AliRsnCutStd)
 
 //_________________________________________________________________________________________________
 AliRsnCutStd::AliRsnCutStd() :
-  AliRsnCut(),
-  fType(kLastType),
-  fUseMC(kFALSE)
+    AliRsnCut(),
+    fType(kLastType),
+    fUseMC(kFALSE)
 {
 //
 // Default constructor.
@@ -43,9 +41,9 @@ AliRsnCutStd::AliRsnCutStd() :
 //_________________________________________________________________________________________________
 AliRsnCutStd::AliRsnCutStd
 (const char *name, EType type, Int_t val1, Int_t val2, Bool_t useMC) :
-  AliRsnCut(name, val1, val2),
-  fType(type),
-  fUseMC(useMC)
+    AliRsnCut(name, val1, val2),
+    fType(type),
+    fUseMC(useMC)
 {
 //
 // Main constructor.
@@ -54,56 +52,53 @@ AliRsnCutStd::AliRsnCutStd
 // but is interpreted as integer due to the overloading of constructors
 //
 
-  switch (fType)
-  {
+  switch (fType) {
     // int
-    case kMult:
-    case kMultDiff:
-    case kKink:
-    case kKinkMother:
-    case kAssignedPID:
-    case kTruePID:
-    case kRequiredPID:
-    case kCharge:
-      break;
+  case kMult:
+  case kMultDiff:
+  case kKink:
+  case kKinkMother:
+  case kAssignedPID:
+  case kTruePID:
+  case kRequiredPID:
+  case kCharge:
+    break;
     // ulong
-    case kStatus:
-      if (fVarType != kULong)
-      {
-        AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
-        SetRange((ULong_t)val1, (ULong_t)val2);
-        AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' ULONG range = %d, %d", GetName(), fMinU, fMaxU));
-      }
-      break;
+  case kStatus:
+    if (fVarType != kULong) {
+      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
+      SetRange((ULong_t)val1, (ULong_t)val2);
+      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' ULONG range = %d, %d", GetName(), fMinU, fMaxU));
+    }
+    break;
     // double
-    case kP:
-    case kPt:
-    case kEta:
-    case kThetaDeg:
-    case kDr:
-    case kDz:
-    case kTPCsignal:
-    case kMultDiffRel:
-    case kVzDiff:
-      if (fVarType != kDouble)
-      {
-        AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
-        SetRange((Double_t)val1, (Double_t)val2);
-        AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
-      }
-      break;
+  case kP:
+  case kPt:
+  case kEta:
+  case kThetaDeg:
+  case kDr:
+  case kDz:
+  case kTPCsignal:
+  case kMultDiffRel:
+  case kVzDiff:
+    if (fVarType != kDouble) {
+      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
+      SetRange((Double_t)val1, (Double_t)val2);
+      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
+    }
+    break;
     // other cuts are not based on a value, so no problem
-    default:
-      break;
+  default:
+    break;
   }
 }
 
 //_________________________________________________________________________________________________
 AliRsnCutStd::AliRsnCutStd
 (const char *name, EType type, ULong_t val1, ULong_t val2, Bool_t useMC) :
-  AliRsnCut(name, val1, val2),
-  fType(type),
-  fUseMC(useMC)
+    AliRsnCut(name, val1, val2),
+    fType(type),
+    fUseMC(useMC)
 {
 //
 // Main constructor.
@@ -112,56 +107,53 @@ AliRsnCutStd::AliRsnCutStd
 // but is interpreted as integer due to the overloading of constructors
 //
 
-  switch (fType)
-  {
+  switch (fType) {
     // int
-    case kMult:
-    case kMultDiff:
-    case kKink:
-    case kKinkMother:
-    case kAssignedPID:
-    case kTruePID:
-    case kRequiredPID:
-    case kCharge:
-      if (fVarType != kInt)
-      {
-        AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
-        SetRange((Int_t)val1, (Int_t)val2);
-        AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
-      }
-      break;
+  case kMult:
+  case kMultDiff:
+  case kKink:
+  case kKinkMother:
+  case kAssignedPID:
+  case kTruePID:
+  case kRequiredPID:
+  case kCharge:
+    if (fVarType != kInt) {
+      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
+      SetRange((Int_t)val1, (Int_t)val2);
+      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
+    }
+    break;
     // ulong
-    case kStatus:
-      break;
+  case kStatus:
+    break;
     // double
-    case kP:
-    case kPt:
-    case kEta:
-    case kThetaDeg:
-    case kDr:
-    case kDz:
-    case kTPCsignal:
-    case kMultDiffRel:
-    case kVzDiff:
-      if (fVarType != kDouble)
-      {
-        AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
-        SetRange((Double_t)val1, (Double_t)val2);
-        AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
-      }
-      break;
+  case kP:
+  case kPt:
+  case kEta:
+  case kThetaDeg:
+  case kDr:
+  case kDz:
+  case kTPCsignal:
+  case kMultDiffRel:
+  case kVzDiff:
+    if (fVarType != kDouble) {
+      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
+      SetRange((Double_t)val1, (Double_t)val2);
+      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
+    }
+    break;
     // other cuts are not based on a value, so no problem
-    default:
-      break;
+  default:
+    break;
   }
 }
 
 //_________________________________________________________________________________________________
 AliRsnCutStd::AliRsnCutStd
 (const char *name, EType type, Double_t val1, Double_t val2, Bool_t useMC) :
-  AliRsnCut(name, val1, val2),
-  fType(type),
-  fUseMC(useMC)
+    AliRsnCut(name, val1, val2),
+    fType(type),
+    fUseMC(useMC)
 {
 //
 // Main constructor.
@@ -170,60 +162,56 @@ AliRsnCutStd::AliRsnCutStd
 // but is interpreted as integer due to the overloading of constructors
 //
 
-  switch (fType)
-  {
+  switch (fType) {
     // int
-    case kMult:
-    case kMultDiff:
-    case kKink:
-    case kKinkMother:
-    case kAssignedPID:
-    case kTruePID:
-    case kRequiredPID:
-    case kCharge:
-      if (fVarType != kInt)
-      {
-        AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
-        SetRange((Int_t)val1, (Int_t)val2);
-        AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
-      }
-      break;
+  case kMult:
+  case kMultDiff:
+  case kKink:
+  case kKinkMother:
+  case kAssignedPID:
+  case kTruePID:
+  case kRequiredPID:
+  case kCharge:
+    if (fVarType != kInt) {
+      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
+      SetRange((Int_t)val1, (Int_t)val2);
+      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
+    }
+    break;
     // ulong
-    case kStatus:
-      if (fVarType != kULong)
-      {
-        AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
-        SetRange((ULong_t)val1, (ULong_t)val2);
-        AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' ULONG range = %d, %d", GetName(), fMinU, fMaxU));
-      }
-      break;
+  case kStatus:
+    if (fVarType != kULong) {
+      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
+      SetRange((ULong_t)val1, (ULong_t)val2);
+      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' ULONG range = %d, %d", GetName(), fMinU, fMaxU));
+    }
+    break;
     // double
-    case kP:
-    case kPt:
-    case kEta:
-    case kThetaDeg:
-    case kDr:
-    case kDz:
-    case kTPCsignal:
-    case kMultDiffRel:
-    case kVzDiff:
-      break;
+  case kP:
+  case kPt:
+  case kEta:
+  case kThetaDeg:
+  case kDr:
+  case kDz:
+  case kTPCsignal:
+  case kMultDiffRel:
+  case kVzDiff:
+    break;
     // other cuts are not based on a value, so no problem
-    default:
-      break;
+  default:
+    break;
   }
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnDaughter *track)
+Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnDaughter * const track)
 {
 //
 // Cut checker.
 //
 
   // coherence check
-  if (tgt != AliRsnCut::kParticle)
-  {
+  if (tgt != AliRsnCut::kParticle) {
     AliError(Form("Wrong target. Skipping cut", GetName()));
     return kTRUE;
   }
@@ -242,151 +230,147 @@ Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnDaughter *track)
   }
 
   // loop on allowed possibilities
-  switch(fType)
-  {
-    case kP:
-      fCutValueD = fUseMC ? part->P() : track->P();
-      return OkRange();
-    case kPt:
-      fCutValueD = fUseMC ? part->Pt() : track->Pt();
-      return OkRange();
-    case kThetaDeg:
-      fCutValueD = track->ThetaDeg();
-      return OkRange();
-    case kEta:
-      fCutValueD = fUseMC ? part->Eta() : track->Eta();
-      return OkRange();
-    case kDr:
-      fCutValueD = track->Dr();
-      return OkRange();
-    case kDz:
-      fCutValueD = track->Dz();
-      return OkRange();
-    case kStatus:
-      fCutValueU = track->GetStatus();
-      return OkValue();
-    case kKink:
-      fCutValueI = track->IsKink();
-      return OkValue();
-    case kKinkMother:
-      fCutValueI = track->IsKinkMother();
-      return OkValue();
-    case kCharge:
-      fCutValueI = (Int_t)track->Charge();
-      return OkValue();
-    case kTruePID:
-      fCutValueI = (Int_t)track->PerfectPID();
-      return OkValue();
-    case kAssignedPID:
-      fCutValueI = (Int_t)track->AssignedPID();
-      return OkValue();
-    case kRequiredPID:
-      fCutValueI = (Int_t)track->RequiredPID();
-      return OkValue();
-    case kRealisticPID:
-      fCutValueI = (Int_t)track->RealisticPID();
-      return OkValue();
-    default:
-      AliWarning(Form("Value %d is not included in available cuts for DAUGHTER. Cut skipped.", fType));
-      return kTRUE;
+  switch (fType) {
+  case kP:
+    fCutValueD = fUseMC ? part->P() : track->P();
+    return OkRange();
+  case kPt:
+    fCutValueD = fUseMC ? part->Pt() : track->Pt();
+    return OkRange();
+  case kThetaDeg:
+    fCutValueD = track->ThetaDeg();
+    return OkRange();
+  case kEta:
+    fCutValueD = fUseMC ? part->Eta() : track->Eta();
+    return OkRange();
+  case kDr:
+    fCutValueD = track->Dr();
+    return OkRange();
+  case kDz:
+    fCutValueD = track->Dz();
+    return OkRange();
+  case kStatus:
+    fCutValueU = track->GetStatus();
+    return OkValue();
+  case kKink:
+    fCutValueI = track->IsKink();
+    return OkValue();
+  case kKinkMother:
+    fCutValueI = track->IsKinkMother();
+    return OkValue();
+  case kCharge:
+    fCutValueI = (Int_t)track->Charge();
+    return OkValue();
+  case kTruePID:
+    fCutValueI = (Int_t)track->PerfectPID();
+    return OkValue();
+  case kAssignedPID:
+    fCutValueI = (Int_t)track->AssignedPID();
+    return OkValue();
+  case kRequiredPID:
+    fCutValueI = (Int_t)track->RequiredPID();
+    return OkValue();
+  case kRealisticPID:
+    fCutValueI = (Int_t)track->RealisticPID();
+  case kTruePIDMatch:
+    return (track->PerfectPID() == track->RequiredPID());
+  case kRealisticPIDMatch:
+    return (track->RealisticPID() == track->RequiredPID());
+  default:
+    AliWarning(Form("Value %d is not included in available cuts for DAUGHTER. Cut skipped.", fType));
+    return kTRUE;
   }
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnPairParticle *pair)
+Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnPairParticle * const pair)
 {
 //
 // Cut checker
 //
 
   // coherence check
-  if (tgt != AliRsnCut::kPair)
-  {
+  if (tgt != AliRsnCut::kPair) {
     AliError(Form("Wrong target. Skipping cut", GetName()));
     return kTRUE;
   }
 
   // loop on allowed possibilities
-  switch(fType)
-  {
-    case kP:
-      fCutValueD = (fUseMC ? pair->GetPMC() : pair->GetP());
-      return OkRange();
-    case kPt:
-      fCutValueD = (fUseMC ? pair->GetPtMC() : pair->GetPt());
-      return OkRange();
-    case kEta:
-      fCutValueD = (fUseMC ? pair->GetEtaMC() : pair->GetEta());
-      return OkRange();
-    case kSameLabel:
-      return pair->IsLabelEqual();
-    case kTruePair:
-      fCutValueI = pair->CommonMother();
-      return OkValue();
-    default:
-      AliWarning(Form("Value %d is not included in available cuts for PAIR. Cut skipped.", fType));
-      return kTRUE;
+  switch (fType) {
+  case kP:
+    fCutValueD = (fUseMC ? pair->GetPMC() : pair->GetP());
+    return OkRange();
+  case kPt:
+    fCutValueD = (fUseMC ? pair->GetPtMC() : pair->GetPt());
+    return OkRange();
+  case kEta:
+    fCutValueD = (fUseMC ? pair->GetEtaMC() : pair->GetEta());
+    return OkRange();
+  case kSameLabel:
+    return pair->IsLabelEqual();
+  case kTruePair:
+    fCutValueI = TMath::Abs(pair->CommonMother());
+    return OkValue();
+  default:
+    AliWarning(Form("Value %d is not included in available cuts for PAIR. Cut skipped.", fType));
+    return kTRUE;
   }
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent *event)
+Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent * const event)
 {
 //
 // Cut checker
 //
 
   // coherence check
-  if (tgt != AliRsnCut::kEvent)
-  {
+  if (tgt != AliRsnCut::kEvent) {
     AliError(Form("Wrong target. Skipping cut", GetName()));
     return kTRUE;
   }
 
   // loop on allowed possibilities
-  switch(fType)
-  {
-    case kMult:
-      fCutValueI = event->GetMultiplicity();
-      return OkRange();
-    default:
-      AliWarning(Form("Value %d is not included in available cuts for EVENT. Cut skipped.", fType));
-      return kTRUE;
+  switch (fType) {
+  case kMult:
+    fCutValueI = event->GetMultiplicity();
+    return OkRange();
+  default:
+    AliWarning(Form("Value %d is not included in available cuts for EVENT. Cut skipped.", fType));
+    return kTRUE;
   }
 }
 
 //_________________________________________________________________________________________________
-Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2)
+Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent * const ev1, AliRsnEvent * const ev2)
 {
 //
 // Cut checker
 //
 
   // coherence check
-  if (tgt != AliRsnCut::kMixEvent)
-  {
+  if (tgt != AliRsnCut::kMixEvent) {
     AliError(Form("Wrong target. Skipping cut", GetName()));
     return kTRUE;
   }
 
   // loop on allowed possibilities
   Double_t mult1, mult2;
-  switch(fType)
-  {
-    case kMultDiff:
-      fCutValueI = TMath::Abs(ev1->GetMultiplicity() - ev2->GetMultiplicity());
-      return OkRange();
-    case kMultDiffRel:
-      mult1 = (Double_t)ev1->GetMultiplicity();
-      mult2 = (Double_t)ev2->GetMultiplicity();
-      if (mult1 == 0.0  && mult2 == 0.0) return kTRUE;
-      fCutValueD = 100.0 * TMath::Abs(mult1 - mult2) / TMath::Max(mult1, mult2); // in %
-      return OkRange();
-    case kVzDiff:
-      fCutValueD = TMath::Abs(ev1->GetVz() - ev2->GetVz());
-      return OkRange();
-    default:
-      AliWarning(Form("Value %d is not included in available cuts for MIXEVENT. Cut skipped.", fType));
-      return kTRUE;
+  switch (fType) {
+  case kMultDiff:
+    fCutValueI = TMath::Abs(ev1->GetMultiplicity() - ev2->GetMultiplicity());
+    return OkRange();
+  case kMultDiffRel:
+    mult1 = (Double_t)ev1->GetMultiplicity();
+    mult2 = (Double_t)ev2->GetMultiplicity();
+    if (mult1 == 0.0  && mult2 == 0.0) return kTRUE;
+    fCutValueD = 100.0 * TMath::Abs(mult1 - mult2) / TMath::Max(mult1, mult2); // in %
+    return OkRange();
+  case kVzDiff:
+    fCutValueD = TMath::Abs(ev1->GetVz() - ev2->GetVz());
+    return OkRange();
+  default:
+    AliWarning(Form("Value %d is not included in available cuts for MIXEVENT. Cut skipped.", fType));
+    return kTRUE;
   }
 }
index 1fe658aaeb8550efe58b6a07339d1f4d93cb8363..c79ba8a6aff8cd6595579fad0926362ec4fcfbb0 100644 (file)
 
 class AliRsnCutStd : public AliRsnCut
 {
- public:
 public:
 
-  // available cut types
-  // some ones work both for pairs and single tracks
-  enum EType {
-    kP = 0,
-    kPt,
-    kEta,
-    kThetaDeg,
-    kDr,
-    kDz,
-    kTPCsignal,
-    kMult,
-    kMultDiff,
-    kMultDiffRel,
-    kVzDiff,
-    // value cuts
-    kStatus,
-    kKink,
-    kKinkMother,
-    kAssignedPID,
-    kTruePID,
-    kRequiredPID,
-    kRealisticPID,
-    // cut without reference values
-    kCharge,
-    kSameLabel,
-    kTruePair,
-    // last
-    kLastType
-  };
+    // available cut types
+    // some ones work both for pairs and single tracks
+    enum EType {
+      kP = 0,
+      kPt,
+      kEta,
+      kThetaDeg,
+      kDr,
+      kDz,
+      kTPCsignal,
+      kMult,
+      kMultDiff,
+      kMultDiffRel,
+      kVzDiff,
+      // value cuts
+      kStatus,
+      kKink,
+      kKinkMother,
+      kAssignedPID,
+      kTruePID,
+      kRequiredPID,
+      kRealisticPID,
+      // cut without reference values
+      kCharge,
+      kSameLabel,
+      kTruePair,
+      kTruePIDMatch,
+      kRealisticPIDMatch,
+      // last
+      kLastType
+    };
 
-  AliRsnCutStd();
-  AliRsnCutStd(const char *name, EType type, Int_t val1, Int_t val2 = 0, Bool_t useMC = kFALSE);
-  AliRsnCutStd(const char *name, EType type, ULong_t val1, ULong_t val2 = 0, Bool_t useMC = kFALSE);
-  AliRsnCutStd(const char *name, EType type, Double_t val1, Double_t val2 = 0.0, Bool_t useMC = kFALSE);
-  virtual ~AliRsnCutStd() { }
+    AliRsnCutStd();
+    AliRsnCutStd(const char *name, EType type, Int_t val1, Int_t val2 = 0, Bool_t useMC = kFALSE);
+    AliRsnCutStd(const char *name, EType type, ULong_t val1, ULong_t val2 = 0, Bool_t useMC = kFALSE);
+    AliRsnCutStd(const char *name, EType type, Double_t val1, Double_t val2 = 0.0, Bool_t useMC = kFALSE);
+    virtual ~AliRsnCutStd() { }
 
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnDaughter *daughter);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnPairParticle *pair);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *event);
-  virtual Bool_t IsSelected(ETarget tgt, AliRsnEvent *ev1, AliRsnEvent *ev2);
+    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnDaughter*const daughter);
+    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnPairParticle*const pair);
+    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnEvent*const event);
+    virtual Bool_t IsSelected(AliRsnCut::ETarget tgt, AliRsnEvent*const ev1, AliRsnEvent*const ev2);
 
-protected:
+  protected:
 
-  EType     fType;       // cut type
-  Bool_t    fUseMC;      // use or not MC values (when applicable)
+    EType     fType;       // cut type
+    Bool_t    fUseMC;      // use or not MC values (when applicable)
 
-  ClassDef(AliRsnCutStd, 1)
+    ClassDef(AliRsnCutStd, 1)
 };
 
 #endif
index bfb7b39683178699a98b859039b0300ced6f69d0..4761e4b18f5045cf193c41d464839562def1fe40 100644 (file)
 //
 
 #include <Riostream.h>
-
 #include <TParticle.h>
-#include <TString.h>
 
-#include "AliLog.h"
 #include "AliStack.h"
 #include "AliESDtrack.h"
 #include "AliAODEvent.h"
@@ -34,15 +31,15 @@ AliRsnDaughter::EPIDMethod AliRsnDaughter::fgPIDMethod = AliRsnDaughter::kRealis
 
 //_____________________________________________________________________________
 AliRsnDaughter::AliRsnDaughter(AliVParticle *ref, TParticle *refMC) :
-  fOK((ref != 0)),
-  fKinkIndex(0),
-  fParticle(refMC),
-  fMotherPDG(0),
-  fStatus(0),
-  fDr(0.0),
-  fDz(0.0),
-  fReqPID(AliPID::kUnknown),
-  fRef(ref)
+    fOK((ref != 0)),
+    fKinkIndex(0),
+    fParticle(refMC),
+    fMotherPDG(0),
+    fStatus(0),
+    fDr(0.0),
+    fDz(0.0),
+    fReqPID(AliPID::kUnknown),
+    fRef(ref)
 {
 //
 // Default constructor.
@@ -51,16 +48,16 @@ AliRsnDaughter::AliRsnDaughter(AliVParticle *ref, TParticle *refMC) :
 
 //_____________________________________________________________________________
 AliRsnDaughter::AliRsnDaughter(const AliRsnDaughter &copy) :
-  TObject(copy),
-  fOK(copy.fOK),
-  fKinkIndex(copy.fKinkIndex),
-  fParticle(copy.fParticle),
-  fMotherPDG(copy.fMotherPDG),
-  fStatus(copy.fStatus),
-  fDr(copy.fDr),
-  fDz(copy.fDz),
-  fReqPID(copy.fReqPID),
-  fRef(copy.fRef)
+    TObject(copy),
+    fOK(copy.fOK),
+    fKinkIndex(copy.fKinkIndex),
+    fParticle(copy.fParticle),
+    fMotherPDG(copy.fMotherPDG),
+    fStatus(copy.fStatus),
+    fDr(copy.fDr),
+    fDz(copy.fDz),
+    fReqPID(copy.fReqPID),
+    fRef(copy.fRef)
 {
 //
 // Copy constructor.
@@ -193,19 +190,19 @@ AliPID::EParticleType AliRsnDaughter::PerfectPID() const
 
   Int_t absPDG = TMath::Abs(fParticle->GetPdgCode());
   switch (absPDG) {
-    case   11:
-      return AliPID::kElectron;
-    case   13:
-      return AliPID::kMuon;
-    case  211:
-      return AliPID::kPion;
-    case  321:
-      return AliPID::kKaon;
-    case 2212:
-      return AliPID::kProton;
-    default:
-      AliDebug(2, Form("PDG code = %d not recognized. Return 'AliPID::kUnknown'", absPDG));
-      return AliPID::kUnknown;
+  case   11:
+    return AliPID::kElectron;
+  case   13:
+    return AliPID::kMuon;
+  case  211:
+    return AliPID::kPion;
+  case  321:
+    return AliPID::kKaon;
+  case 2212:
+    return AliPID::kProton;
+  default:
+    AliDebug(2, Form("PDG code = %d not recognized. Return 'AliPID::kUnknown'", absPDG));
+    return AliPID::kUnknown;
   }
 }
 
@@ -236,20 +233,20 @@ AliPID::EParticleType AliRsnDaughter::AssignedPID() const
 //
 
   switch (fgPIDMethod) {
-    case kNoPID:
-      return AliPID::kUnknown;
-    case kPerfect:
-      return PerfectPID();
-    case kRealistic:
-      return RealisticPID();
-    default:
-      AliWarning("PID method not properly set. Returning realistic PID");
-      return RealisticPID();
+  case kNoPID:
+    return AliPID::kUnknown;
+  case kPerfect:
+    return PerfectPID();
+  case kRealistic:
+    return RealisticPID();
+  default:
+    AliWarning("PID method not properly set. Returning realistic PID");
+    return RealisticPID();
   }
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnDaughter::CombineWithPriors(Double_t *priors, AliRsnPIDDefESD *pidDef)
+Bool_t AliRsnDaughter::CombineWithPriors(const Double_t *priors, AliRsnPIDDefESD *pidDef)
 {
 //
 // Combine current PID weights (assumed to be them) with prior probs
@@ -262,14 +259,19 @@ Bool_t AliRsnDaughter::CombineWithPriors(Double_t *priors, AliRsnPIDDefESD *pidD
   // if the reference is not ESD or the pidDef is null
   // of it is not null but is requires the ESD pid,
   // the standard PID value is used, otherwise
-  if (pidDef)
-  {
-    AliESDtrack *esdTrack = GetRefESD();
-    if (esdTrack) pidDef->ComputeWeights(esdTrack, fPID);
-  }
-  else
-  {
-    for (i = 0; i < AliPID::kSPECIES; i++) fPID[i] = fRef->PID()[i];
+  if (pidDef && GetRefESD()) {
+    pidDef->ComputeWeights(GetRefESD(), fPID);
+  } else {
+    if (fRef->PID())
+      for (i = 0; i < AliPID::kSPECIES; i++) fPID[i] = fRef->PID()[i];
+    else if (fParticle) {
+      // if the PID() returns 0x0, this is a MC particle
+      // and we set the weight corresponding to its species to 1
+      // and the others to zero
+      for (i = 0; i < AliPID::kSPECIES; i++) fPID[i] = 0.0;
+      i = (Int_t)AliRsnDaughter::InternalType(TMath::Abs(fParticle->GetPdgCode()));
+      fPID[i] = 1.0;
+    }
   }
 
   // multiply weights and priors
@@ -277,8 +279,8 @@ Bool_t AliRsnDaughter::CombineWithPriors(Double_t *priors, AliRsnPIDDefESD *pidD
     fPID[i] *= priors[i];
     sum += fPID[i];
   }
-  if (sum <= (Double_t) 0.) {
-    AliError(Form("Sum of weights = %f <= 0", sum));
+  if (sum <= 0.0) {
+    if (sum < 0.0) AliError(Form("Sum of weights = %f < 0", sum));
     return kFALSE;
   }
 
@@ -289,17 +291,7 @@ Bool_t AliRsnDaughter::CombineWithPriors(Double_t *priors, AliRsnPIDDefESD *pidD
 }
 
 //_____________________________________________________________________________
-AliESDtrack* AliRsnDaughter::GetRefESD()
-{
-//
-// Return a reference in format of ESD track
-//
-
-  return dynamic_cast<AliESDtrack *>(fRef);
-}
-
-//_____________________________________________________________________________
-void AliRsnDaughter::FindMotherPDG(AliStack *stack)
+void AliRsnDaughter::FindMotherPDG(AliStack *const stack)
 {
 //
 // Searches the stack to find the mother and retrieve its PDG code.
@@ -307,11 +299,10 @@ void AliRsnDaughter::FindMotherPDG(AliStack *stack)
 
   if (!stack || !fParticle) return;
 
-  Int_t mLabel = fParticle->GetFirstMother();
+  const Int_t mLabel = fParticle->GetFirstMother();
   if (mLabel < 0) {
     fMotherPDG = 0;
-  }
-  else {
+  } else {
     TParticle *mum = stack->Particle(mLabel);
     if (mum) fMotherPDG = mum->GetPdgCode();
     else fMotherPDG = 0;
@@ -335,7 +326,7 @@ Double_t AliRsnDaughter::GetMCEnergy(Double_t mass)
 }
 
 //_____________________________________________________________________________
-void AliRsnDaughter::FindKinkIndex(AliESDtrack *esdTrack)
+void AliRsnDaughter::FindKinkIndex(const AliESDtrack *esdTrack)
 {
 //
 // Assign kink index from an ESD track
@@ -346,15 +337,13 @@ void AliRsnDaughter::FindKinkIndex(AliESDtrack *esdTrack)
 
   if (ik[0] < 0 || ik[1] < 0 || ik[2] < 0) {
     SetKinkMother();
-  }
-  else if (ik[0] > 0 || ik[1] > 0 || ik[2] > 0) {
+  } else if (ik[0] > 0 || ik[1] > 0 || ik[2] > 0) {
     SetKinkDaughter();
-  }
-  else SetNoKink();
+  } else SetNoKink();
 }
 
 //_____________________________________________________________________________
-void AliRsnDaughter::FindKinkIndex(AliAODEvent *event)
+void AliRsnDaughter::FindKinkIndex(AliAODEvent *const event)
 {
 //
 // Assign kink index from an AOD event
@@ -400,7 +389,7 @@ void AliRsnDaughter::Reset()
 }
 
 //_____________________________________________________________________________
-void AliRsnDaughter::Print(Option_t *option) const
+void AliRsnDaughter::Print(Option_t * const option) const
 {
 //
 // Prints the values of data members, using the options:
@@ -465,33 +454,54 @@ void AliRsnDaughter::Print(Option_t *option) const
 
 //_____________________________________________________________________________
 AliPID::EParticleType AliRsnDaughter::InternalType(Int_t pdg)
+{
 //
 // Return the internal enum value corresponding to the PDG
 // code passed as argument, if possible.
 // Otherwise, returns 'AliPID::kSPECIES' by default.
 //
-{
+
   AliPID::EParticleType value;
   Int_t absPDG = TMath::Abs(pdg);
 
   switch (absPDG) {
-    case 11:
-      value = AliPID::kElectron;
-      break;
-    case 13:
-      value = AliPID::kMuon;
-      break;
-    case 211:
-      value = AliPID::kPion;
-      break;
-    case 321:
-      value = AliPID::kKaon;
-      break;
-    case 2212:
-      value = AliPID::kProton;
-      break;
-    default:
-      value = AliPID::kUnknown;
+  case 11:
+    value = AliPID::kElectron;
+    break;
+  case 13:
+    value = AliPID::kMuon;
+    break;
+  case 211:
+    value = AliPID::kPion;
+    break;
+  case 321:
+    value = AliPID::kKaon;
+    break;
+  case 2212:
+    value = AliPID::kProton;
+    break;
+  default:
+    value = AliPID::kUnknown;
   }
   return value;
 }
+
+//_____________________________________________________________________________
+const char* AliRsnDaughter::MethodName(EPIDMethod method)
+{
+//
+// Returns a string with the method name
+//
+
+  switch (method)
+  {
+    case kNoPID:
+      return "No PID";
+    case kRealistic:
+      return "Realistic";
+    case kPerfect:
+      return "Perfect";
+    default:
+      return "Unknown";
+  }
+}
index a01bec5c90e56e6da0d1e1d2380e3ee2407a1f46..77fa69f3ae8401ae72ea82bd718e2130732f3a2e 100644 (file)
 
 #include "AliPID.h"
 #include "AliVParticle.h"
+#include "AliESDtrack.h"
+#include "AliAODTrack.h"
+#include "AliMCParticle.h"
 
 class TParticle;
 class AliStack;
-class AliESDtrack;
+class AliMCParticle;
+// class AliESDtrack;
+// class AliESDtrack;
+// class AliAODTrack;
 class AliAODEvent;
 class AliRsnPIDDefESD;
 
@@ -31,8 +37,7 @@ class AliRsnDaughter : public TObject
 {
   public:
 
-    enum EPIDMethod
-    {
+    enum EPIDMethod {
       kNoPID = 0,
       kRealistic,
       kPerfect,
@@ -74,9 +79,12 @@ class AliRsnDaughter : public TObject
 
     // PID
     const Double_t        *PID() const {return fRef->PID();}
-    Bool_t                 CombineWithPriors(Double_t *priors, AliRsnPIDDefESD *pidDef = 0x0);
+    const Double_t        *ComputedWeights() const {return fPID;}
+    Bool_t                 CombineWithPriors(const Double_t* priors, AliRsnPIDDefESD* pidDef = 0x0);
     AliPID::EParticleType  RealisticPID() const;
     AliPID::EParticleType  PerfectPID() const;
+    Bool_t                 IsPerfectPID(const AliPID::EParticleType type) const  {return (PerfectPID() == type);}
+    Bool_t                 IsRealisticPID(const AliPID::EParticleType type) const  {return (RealisticPID() == type);}
     Double_t               PIDProb(AliPID::EParticleType type) const {return PID()[(Int_t)type];}
     AliPID::EParticleType  PIDType(Double_t &prob) const;
     AliPID::EParticleType  AssignedPID() const;
@@ -84,7 +92,12 @@ class AliRsnDaughter : public TObject
     void                   SetRequiredPID(AliPID::EParticleType type) {fReqPID = type;}
 
     // integer parameters
-    Short_t Charge() const {return fRef->Charge();}
+    Bool_t  IsPos() const {return (fRef->Charge() > 0);}
+    Bool_t  IsNeg() const {return (fRef->Charge() < 0);}
+    Bool_t  IsNeutral() const {return (!IsPos() && !IsNeg());}
+    Bool_t  IsSign(Char_t sign) { if (sign=='+') return IsPos(); else if (sign=='-') return IsNeg(); else return IsNeutral();}
+    Short_t Charge() const {if (IsPos()) return 1; else if (IsNeg()) return -1; else return 0;}
+    Char_t  ChargeC() const {if (IsPos()) return '+'; else if (IsNeg()) return '-'; else return '0';}
     Int_t   GetLabel() const {return fRef->GetLabel();}
     Int_t   GetID() const;
     void    SetStatus(ULong_t value) {fStatus = value;}
@@ -92,7 +105,7 @@ class AliRsnDaughter : public TObject
     Bool_t  CheckFlag(ULong_t flag) const {return ((fStatus & flag) > 0);}
     void    SetGood() {fOK = kTRUE;}
     void    SetBad() {fOK = kFALSE;}
-    Bool_t  IsOK() {return fOK;}
+    Bool_t  IsOK() const { return fOK; }
 
     // Kinkness
     Char_t  KinkIndex() const {return fKinkIndex;}
@@ -103,27 +116,30 @@ class AliRsnDaughter : public TObject
     void    SetKinkMother() {fKinkIndex = -1;}
     void    SetKinkDaughter() {fKinkIndex = 1;}
     void    SetNoKink() {fKinkIndex = 0;}
-    void    FindKinkIndex(AliESDtrack *track);
-    void    FindKinkIndex(AliAODEvent *event);
+    void    FindKinkIndex(const AliESDtrack* track);
+    void    FindKinkIndex(AliAODEvent*const event);
 
     // MC info & references
-    AliVParticle* GetRef() {return fRef;}
-    AliESDtrack*  GetRefESD();
-    TParticle*    GetParticle() {return fParticle;}
-    Int_t         GetMotherPDG() {return fMotherPDG;}
-    void          SetRef(AliVParticle *ref) {fRef = ref;}
-    void          SetParticle(TParticle *p) {fParticle = p;}
-    void          SetMotherPDG(Int_t value) {fMotherPDG = value;}
-    void          FindMotherPDG(AliStack *stack);
-    Double_t      GetMCEnergy(Double_t mass);
+    AliVParticle*  GetRef() const {return fRef;}
+    AliESDtrack*   GetRefESD() {return dynamic_cast<AliESDtrack*>(fRef);}
+    AliAODTrack*   GetRefAOD() {return dynamic_cast<AliAODTrack*>(fRef);}
+    AliMCParticle* GetRefMC()  {return dynamic_cast<AliMCParticle*>(fRef);}
+    TParticle*     GetParticle() const {return fParticle;}
+    Int_t          GetMotherPDG() const {return fMotherPDG;}
+    void           SetRef(AliVParticle * const ref) {fRef = ref;}
+    void           SetParticle(TParticle * const p) {fParticle = p;}
+    void           SetMotherPDG(Int_t value) {fMotherPDG = value;}
+    void           FindMotherPDG(AliStack *const stack);
+    Double_t       GetMCEnergy(Double_t mass);
 
     // utilities
     void          Reset();
-    void          Print(Option_t *option = "ALL") const;
+    void          Print(Option_t*const option = "ALL") const;
 
     // static functions
     static void                   SetPIDMethod(EPIDMethod method) {fgPIDMethod = method;}
     static AliPID::EParticleType  InternalType(Int_t pdgCode);
+    static const char*            MethodName(EPIDMethod method);
 
   private:
 
index eb2104cffbcb96bbf1b82ec32824359d81eb48cd..4ed67c09ee2d7b499a4ae8911ab02e69b2cce017 100644 (file)
@@ -1,18 +1,3 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
 //
 // *** Class AliRsnEvent ***
 //
@@ -26,7 +11,7 @@
 //          M. Vala (email: martin.vala@cern.ch)
 //
 
-#include <Riostream.h>
+#include <TArrayF.h>
 
 #include "AliLog.h"
 #include "AliVEvent.h"
@@ -34,6 +19,7 @@
 #include "AliAODEvent.h"
 #include "AliMCEvent.h"
 #include "AliStack.h"
+#include "AliGenEventHeader.h"
 
 #include "AliRsnEvent.h"
 
@@ -41,20 +27,28 @@ ClassImp(AliRsnEvent)
 
 //_____________________________________________________________________________
 AliRsnEvent::AliRsnEvent(AliVEvent *ref, AliMCEvent *refMC) :
-    fRef(ref),
-    fRefMC(refMC)
+  fRef(ref),
+  fRefMC(refMC),
+  fPIDDefESD()
 {
 //
-// Default constructor
+// Default constructor.
+// Set the prior probabilities to some default values
 //
+
+  fPrior[0] = 0.02;
+  fPrior[1] = 0.02;
+  fPrior[2] = 0.83;
+  fPrior[3] = 0.07;
+  fPrior[4] = 0.06;
 }
 
 //_____________________________________________________________________________
 AliRsnEvent::AliRsnEvent(const AliRsnEvent &event) :
-    TObject(event),
-    fRef(event.fRef),
-    fRefMC(event.fRefMC)
-
+  TObject(event),
+  fRef(event.fRef),
+  fRefMC(event.fRefMC),
+  fPIDDefESD(event.fPIDDefESD)
 {
 //
 // Copy constructor.
@@ -71,6 +65,7 @@ AliRsnEvent& AliRsnEvent::operator= (const AliRsnEvent &event)
   (TObject)(*this) = (TObject)event;
   fRef = event.fRef;
   fRefMC = event.fRefMC;
+  fPIDDefESD = event.fPIDDefESD;
 
   return (*this);
 }
@@ -93,35 +88,46 @@ void AliRsnEvent::SetDaughter(AliRsnDaughter &out, Int_t i)
 //
 
   // retrieve reference particle from reference event
+  // if it is found, by defaul track can be used (good)
   AliVParticle *ref = (AliVParticle*)fRef->GetTrack(i);
-
   if (!ref) return;
+  out.SetRef(ref);
+  out.SetGood();
 
   // if MC info is present, retrieve from it
   TParticle *refMC = 0;
   if (fRefMC) {
     Int_t label = TMath::Abs(ref->GetLabel());
     refMC = fRefMC->Stack()->Particle(label);
-  }
-
-  // create output object
-  out.SetRef(ref);
-  out.SetGood();
-  out.SetParticle(refMC);
-  if (fRefMC)
+    out.SetParticle(refMC);
     out.FindMotherPDG(fRefMC->Stack());
+  }
 
-  // retrieve primary vertex and set impact parameters
+  // retrieve vertex and set impact parameters
   Double_t dx = out.Xv(), dy = out.Yv(), dz = out.Zv();
   const AliVVertex *v = fRef->GetPrimaryVertex();
   if (v) {
     dx -= v->GetX();
     dy -= v->GetY();
     dz -= v->GetZ();
+  } else if (fRefMC) {
+    // if reference is an MC event, no primary vertex is supplied
+    // but it is possible to retrieve it from header
+    TArrayF fvertex(3);
+    fRefMC->GenEventHeader()->PrimaryVertex(fvertex);
+    dx -= fvertex[0];
+    dy -= fvertex[1];
+    dz -= fvertex[2];
   }
   out.SetDr(TMath::Sqrt(dx*dx + dy*dy));
   out.SetDz(dz);
 
+  // compute PID probabilities by combining
+  // the PID weights in the source with priors
+  // and eventually using the PIDDefESD
+  // (the AliRsnDaughter objec knows how to manage the latter)
+  out.CombineWithPriors(fPrior, &fPIDDefESD);
+
   // dynamic reference to true nature of referenced event
   // to get kink index
   AliESDEvent *esd = dynamic_cast<AliESDEvent*>(fRef);
@@ -133,8 +139,6 @@ void AliRsnEvent::SetDaughter(AliRsnDaughter &out, Int_t i)
   } else if (aod) {
     out.FindKinkIndex(aod);
   }
-
-  out.SetGood();
 }
 
 //_____________________________________________________________________________
@@ -264,8 +268,55 @@ Bool_t AliRsnEvent::GetAngleDistr
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnEvent::AcceptTrackPID
-(AliRsnDaughter *d, AliPID::EParticleType type)
+void AliRsnEvent::SetPriorProbability(Double_t *const out)
+{
+//
+// Set all prior probabilities at once, using an assayr of values.
+//
+
+  Int_t i;
+
+  for (i = 0; i < AliPID::kSPECIES; i++)
+  {
+    fPrior[i] = out[i];
+  }
+}
+
+//_____________________________________________________________________________
+void AliRsnEvent::DumpPriors()
+{
+//
+// Print all prior probabilities.
+// Printout is done using AliInfo, so this will not appear when
+// the GlobalLogLevel is set to higher level errors.
+//
+
+  Int_t i;
+  
+  for (i = 0; i < AliPID::kSPECIES; i++)
+  {
+    AliInfo(Form("Prior probability for %10s = %3.5f", AliPID::ParticleName((AliPID::EParticleType)i), fPrior[i]));
+  }
+}
+
+//_____________________________________________________________________________
+void AliRsnEvent::GetPriorProbability(Double_t *out) const
+{
+//
+// Stores in the passed argument all the values.
+//
+
+  Int_t i;
+
+  for (i = 0; i < AliPID::kSPECIES; i++)
+  {
+    out[i] = fPrior[i];
+  }
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnEvent::AcceptTrackPID(AliRsnDaughter * const d, AliPID::EParticleType type)
 {
 //
 // [PRIVATE]
index 330b79506e2bfc6ac4ed9b401231d94284efbfda..7c63461c676fa512c81e6f0a8030aed469846965 100644 (file)
@@ -1,10 +1,3 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               *
- **************************************************************************/
-
-/* $Id$ */
-
 //
 // *** Class AliRsnEvent ***
 //
@@ -21,6 +14,8 @@
 #ifndef ALIRSNEVENT_H
 #define ALIRSNEVENT_H
 
+#include "AliPID.h"
+#include "AliRsnPIDDefESD.h"
 #include "AliRsnDaughter.h"
 
 class AliVEvent;
@@ -35,25 +30,33 @@ class AliRsnEvent : public TObject
     AliRsnEvent& operator= (const AliRsnEvent& copy);
     virtual ~AliRsnEvent();
 
-    void        SetRef(AliVEvent *event, AliMCEvent *mc = 0) {fRef = event; fRefMC = mc;}
-    void        SetRefMC(AliMCEvent *mc) {fRefMC = mc;}
-    AliVEvent*  GetRef() {return fRef;}
-    AliMCEvent* GetRefMC() {return fRefMC;}
+    void             SetRef(AliVEvent *const event, AliMCEvent *const mc = 0) {fRef = event; fRefMC = mc;}
+    void             SetRefMC(AliMCEvent * const mc) {fRefMC = mc;}
+    AliVEvent*       GetRef() {return fRef;}
+    AliMCEvent*      GetRefMC() {return fRefMC;}
+    AliRsnPIDDefESD* GetPIDDefESD() {return &fPIDDefESD;}
+
+    void             SetDaughter(AliRsnDaughter &daughter, Int_t index);
+    AliRsnDaughter   GetDaughter(Int_t i);
+    Int_t            GetMultiplicity();
+    Double_t         GetVz();
+    AliRsnDaughter   GetLeadingParticle(Double_t ptMin = 0.0, AliPID::EParticleType type = AliPID::kUnknown);
+    Double_t         GetAverageMomentum(Int_t &count, AliPID::EParticleType type = AliPID::kUnknown);
+    Bool_t           GetAngleDistr(Double_t &angleMean, Double_t &angleRMS, AliRsnDaughter d);
 
-    void            SetDaughter(AliRsnDaughter &daughter, Int_t index);
-    AliRsnDaughter  GetDaughter(Int_t i);
-    Int_t           GetMultiplicity();
-    Double_t        GetVz();
-    AliRsnDaughter  GetLeadingParticle(Double_t ptMin = 0.0, AliPID::EParticleType type = AliPID::kUnknown);
-    Double_t        GetAverageMomentum(Int_t &count, AliPID::EParticleType type = AliPID::kUnknown);
-    Bool_t          GetAngleDistr(Double_t &angleMean, Double_t &angleRMS, AliRsnDaughter d);
+    void             SetPriorProbability(AliPID::EParticleType type, Double_t p) {if (type>=0&&type<(Int_t)AliPID::kSPECIES)fPrior[type]=p;}
+    void             SetPriorProbability(Double_t* const out);
+    void             DumpPriors();
+    void             GetPriorProbability(Double_t *out) const;
 
   private:
 
-    Bool_t AcceptTrackPID(AliRsnDaughter *d, AliPID::EParticleType type = AliPID::kUnknown);
+    Bool_t AcceptTrackPID(AliRsnDaughter*const d, AliPID::EParticleType type = AliPID::kUnknown);
 
-    AliVEvent  *fRef;   // pointer to input event (if it is an AOD, this is NULL)
-    AliMCEvent *fRefMC; // pointer to reference MC event (if any)
+    Double_t         fPrior[AliPID::kSPECIES]; // prior probabilities 
+    AliVEvent       *fRef;                     // pointer to input event
+    AliMCEvent      *fRefMC;                   // pointer to reference MC event (if any)
+    AliRsnPIDDefESD  fPIDDefESD;               // (optional) customization of PID weights for ESD
 
     ClassDef(AliRsnEvent, 3);
 };
index 5eefee5ded80cd2c76da41708de73e90ab298153..deb92f68d1ce1ff312b11a8f51d02513f054a480 100644 (file)
@@ -1,17 +1,22 @@
-#include <Riostream.h>
+//
+// AliRsnExpresion class is used to handle operators &|! in AliRsnCut
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
 #include <TString.h>
 #include <TObjString.h>
 #include <TObjArray.h>
 
 #include "AliLog.h"
 
-#include "AliRsnCut.h"
-#include "AliRsnCutSet.h"
+#include "AliRsnVariableExpression.h"
 #include "AliRsnExpression.h"
 
 ClassImp(AliRsnExpression)
 
-AliRsnCutSet *AliRsnExpression::sCutSet = 0;
+AliRsnCutSet *AliRsnExpression::fgCutSet = 0;
 
 //______________________________________________________________________________
 AliRsnExpression::AliRsnExpression(TString exp) :
@@ -54,8 +59,7 @@ AliRsnExpression& AliRsnExpression::operator= (const AliRsnExpression& e)
 {
   // AliRsnExpression assignment operator.
 
-  if (this != &e)
-  {
+  if (this != &e) {
     TObject::operator= (e);
     fArg1 = e.fArg1;
     fArg2 = e.fArg2;
@@ -91,36 +95,33 @@ AliRsnExpression::AliRsnExpression(int op, AliRsnExpression* a) :
 Bool_t AliRsnExpression::Value(TObjArray &vars)
 {
   //  Evaluate the expression
-  if (fArg2 == 0 && fVname.IsNull())
-  {
+  if (fArg2 == 0 && fVname.IsNull()) {
     AliError("Expression undefined.");
     return kFALSE;
   }
 
 //   AliDebug(AliLog::kDebug,Form("fOperator %d",fOperator));
 
-  switch (fOperator)
-  {
+  switch (fOperator) {
 
-    case kOpOR :
-      return fArg1->Value(vars) || fArg2->Value(vars);
+  case kOpOR :
+    return fArg1->Value(vars) || fArg2->Value(vars);
 
-    case kOpAND :
-      return fArg1->Value(vars) && fArg2->Value(vars);
+  case kOpAND :
+    return fArg1->Value(vars) && fArg2->Value(vars);
 
-    case kOpNOT :
-      return !(fArg2->Value(vars));
+  case kOpNOT :
+    return !(fArg2->Value(vars));
 
-    case 0 :
-    {
-//       Int_t indexx = sCutSet->GetIndexByCutName ( fVname.Data() );
+  case 0 : {
+//       Int_t indexx = fgCutSet->GetIndexByCutName ( fVname.Data() );
       AliDebug(AliLog::kDebug,Form("Vname %s",fVname.Data()));
-//       return sCutSet->GetBoolValue ( indexx );
-      return sCutSet->GetBoolValue(fVname.Atoi());
+//       return fgCutSet->GetBoolValue ( indexx );
+      return fgCutSet->GetBoolValue(fVname.Atoi());
     }
 
-    default:
-      AliError("Illegal operator in expression!");
+  default:
+    AliError("Illegal operator in expression!");
 
   }
   return kFALSE;
@@ -133,16 +134,14 @@ TString AliRsnExpression::Unparse() const
   // Unparse the expression
 
   TString opVals[4] = { "", "&", "|","!" };
-  if (fArg2 == 0 && fVname.IsNull())
-  {
+  if (fArg2 == 0 && fVname.IsNull()) {
     AliError("Expression undefined.");
     return "Error";
   }
 
   if (fArg2 == 0 && !fVname.IsNull()) return fVname;
 
-  if (fArg1 == 0 && fArg2)
-  {
+  if (fArg1 == 0 && fArg2) {
     return opVals[fOperator]+fArg2->Unparse();
   }
   return "("+fArg1->Unparse() +" "+opVals[fOperator]+" "+fArg2->Unparse() +")";
@@ -155,8 +154,7 @@ TObjArray* AliRsnExpression::Tokenize(TString str) const
 
   // Remove spaces
   TString str1;
-  for (Int_t i=0; i<str.Length(); i++)
-  {
+  for (Int_t i=0; i<str.Length(); i++) {
     if (str[i] == ' ') continue;
     str1.Append(str[i]);
   }
@@ -165,8 +163,7 @@ TObjArray* AliRsnExpression::Tokenize(TString str) const
   // put all variables together
   Int_t nvt = valtok->GetEntriesFast();
   TString sumval;
-  for (Int_t i=0; i<nvt; i++)
-  {
+  for (Int_t i=0; i<nvt; i++) {
     TObjString* val = (TObjString*) valtok->At(i);
     sumval.Append(val->String());
   }
@@ -175,8 +172,7 @@ TObjArray* AliRsnExpression::Tokenize(TString str) const
   // put all operator in one string
   TString operators;
   Int_t nopt = optok->GetEntriesFast();
-  for (Int_t i=0; i<nopt; i++)
-  {
+  for (Int_t i=0; i<nopt; i++) {
     TObjString* val1 = (TObjString*) optok->At(i);
     operators.Append(val1->String());
   }
@@ -188,20 +184,17 @@ TObjArray* AliRsnExpression::Tokenize(TString str) const
   TObjArray* tokens = new TObjArray(valtok->GetEntriesFast() + operators.Length());
   int io = 0,iv = 0;
   int index = 0;
-  while (1)
-  {
+  while (1) {
     TString so = operators[io];
     int indexO = str1.Index(so, index);
     TString val2 = ((TObjString*) valtok->At(iv))->String();
     int indexV = str1.Index(val2, index);
-    if ((indexO < indexV || indexV < 0) && indexO >=0)
-    {
+    if ((indexO < indexV || indexV < 0) && indexO >=0) {
       tokens->AddLast(new TObjString(so));
       index += so.Length();
       io++;
     }
-    if ((indexV < indexO || indexO < 0) && indexV >=0)
-    {
+    if ((indexV < indexO || indexO < 0) && indexV >=0) {
       tokens->AddLast(new TObjString(val2));
       index += val2.Length();
       iv++;
@@ -236,8 +229,7 @@ AliRsnExpression* AliRsnExpression::Element(TObjArray &st, Int_t &i)
   TString token = "@";
   TObjString* valt;
   // next token
-  if (i < nt-1)
-  {
+  if (i < nt-1) {
     i++;
     valt = (TObjString*) st.At(i);
     token = valt->String();
@@ -245,35 +237,31 @@ AliRsnExpression* AliRsnExpression::Element(TObjArray &st, Int_t &i)
   // token type
   char ttok = (token[0]!='|' && token[0]!='&' &&
                token[0]!='!' && token[0]!='('&& token[0]!=')') ? 'w' : token[0];
-  switch (ttok)
-  {
-    case 'w' :
-    {
+  switch (ttok) {
+  case 'w' : {
       result = new AliRsnVariableExpression(token);
       break;
     }
-    case '(' :
-      result = Expression(st, i);
-      // next token
-      if (i < nt-1)
-      {
-        i++;
-        valt = (TObjString*) st.At(i);
-        token = valt->String();
-      }
-      if (token[0] != ')')
-      {
-        //       i--; // push back
-        AliErrorGeneral("AliRsnExpression::Element", "Mismatched parenthesis.");
-        delete result;
-        result = new AliRsnExpression;
-      }
-      break;
-    default:
-      i--; // push back
-      AliErrorGeneral("AliRsnExpression::Element", Form("Unexpected symbol on input. %s", token.Data()));
-      if (result) delete result;
+  case '(' :
+    result = Expression(st, i);
+    // next token
+    if (i < nt-1) {
+      i++;
+      valt = (TObjString*) st.At(i);
+      token = valt->String();
+    }
+    if (token[0] != ')') {
+      //       i--; // push back
+      AliErrorGeneral("AliRsnExpression::Element", "Mismatched parenthesis.");
+      delete result;
       result = new AliRsnExpression;
+    }
+    break;
+  default:
+    i--; // push back
+    AliErrorGeneral("AliRsnExpression::Element", Form("Unexpected symbol on input. %s", token.Data()));
+    if (result) delete result;
+    result = new AliRsnExpression;
   }
   return result;
 }
@@ -287,20 +275,18 @@ AliRsnExpression* AliRsnExpression::Primary(TObjArray &st, Int_t &i)
   TString token = "@";
   TObjString* valt;
   // next token
-  if (i < nt-1)
-  {
+  if (i < nt-1) {
     i++;
     valt = (TObjString*) st.At(i);
     token = valt->String();
   }
 
-  switch (token[0])
-  {
-    case '!' :
-      return new AliRsnExpression(kOpNOT, Primary(st, i));
-    default:
-      i--; // push back
-      return Element(st, i);
+  switch (token[0]) {
+  case '!' :
+    return new AliRsnExpression(kOpNOT, Primary(st, i));
+  default:
+    i--; // push back
+    return Element(st, i);
   }
 }
 
@@ -320,58 +306,37 @@ AliRsnExpression* AliRsnExpression::Expression(TObjArray &st,Int_t &i)
 
   result = Primary(st, i);
 //   cout <<"i "<<i<< "Primary " << result->Unparse() << endl;
-  while (! done)
-  {
+  while (! done) {
     // next token
     if (i < nt-1) i++;
     else break;
     valt = (TObjString*) st.At(i);
     token = valt->String();
-    switch (token[0])
-    {
-      case '&' :
-        result = new AliRsnExpression(kOpAND, result, Primary(st, i));
+    switch (token[0]) {
+    case '&' :
+      result = new AliRsnExpression(kOpAND, result, Primary(st, i));
 //   cout <<"i "<<i<< " Expression AND " << result->Unparse() << endl;
-        break;
-      case '|' :
-        result = new AliRsnExpression(kOpOR, result, Primary(st, i));
+      break;
+    case '|' :
+      result = new AliRsnExpression(kOpOR, result, Primary(st, i));
 //   cout <<"i "<<i<< " Expression OR " << result->Unparse() << endl;
-        break;
-      default:
-        done = kTRUE;
-        i--; // push back
-        break;
+      break;
+    default:
+      done = kTRUE;
+      i--; // push back
+      break;
     }
   }
   stack--;
-  if (stack == 0 && !token.IsNull() && token[0] == ')')
-  {
+  if (stack == 0 && !token.IsNull() && token[0] == ')') {
     AliErrorGeneral("AliRsnExpression::Expression", "To many closing parenthesis.");
     delete result;
     result = new AliRsnExpression;
-  }
-  else
-    if (stack == 0 && i< nt-1)
-    {
+  } else
+    if (stack == 0 && i< nt-1) {
       AliErrorGeneral("AliRsnExpression::Expression", Form("Unexpected symbol on input. %s", token.Data()));
       delete result;
       result = new AliRsnExpression;
     }
   return result;
 }
-
-////////////////////////////////////////////////////////////////////////////////
-
-ClassImp(AliRsnVariableExpression)
-
-//______________________________________________________________________________
-Bool_t AliRsnVariableExpression::Value(TObjArray& /*pgm*/)
-{
-
-//   Int_t indexx = sCutSet->GetIndexByCutName ( fVname.Data() );
-  AliDebug(AliLog::kDebug,Form("Vname %s",fVname.Data()));
-//   return sCutSet->GetBoolValue ( indexx );
-
-  return sCutSet->GetBoolValue(fVname.Atoi());
-}
-
index c0796dc09faa187a83a22e815d46484d6b6db093..b9c2939e38ddda31190afb1ed05d2211331684c2 100644 (file)
@@ -1,18 +1,18 @@
+//
+// AliRsnExpresion class is used to handle operators &|! in AliRsnCut
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
 #ifndef ALIRSNEXPRESSION_H
 #define ALIRSNEXPRESSION_H
 
 #include <TObject.h>
-#include <TString.h>
-
-#include "AliRsnCutSet.h"
 
 class TObjArray;
-class AliRsnCutSet;
-/**
-  @author Martin Vala <Martin.Vala@cern.ch>
- */
-
-// These are the valid operators types.
+#include "AliRsnCutSet.h"
+class AliRsnVariableExpression;
 
 class AliRsnExpression : public TObject
 {
@@ -20,8 +20,7 @@ class AliRsnExpression : public TObject
   public:
 
     // operators for complex cut expressions
-    enum ECutOp
-    {
+    enum ECutOp {
       kOpAND=1,   // AND '&'
       kOpOR,      // OR '|'
       kOpNOT      // Unary negation '!'
@@ -36,17 +35,17 @@ class AliRsnExpression : public TObject
     virtual Bool_t     Value(TObjArray & vars);
     virtual TString     Unparse() const;
 
-    void SetCutSet(AliRsnCutSet* theValue) { sCutSet = theValue; }
-    AliRsnCutSet* GetCutSet() const { return sCutSet; }
+    void SetCutSet(AliRsnCutSet* const theValue) { fgCutSet = theValue; }
+    AliRsnCutSet* GetCutSet() const { return fgCutSet; }
 
 
-    TString    fVname;   // Variable name
-    static AliRsnCutSet        *sCutSet;
+    TString                     fVname;   // Variable name
+    static AliRsnCutSet        *fgCutSet;
 
   private:
-    AliRsnExpression*   fArg1;         // left argument
-    AliRsnExpression*   fArg2;         // right argument
-    Int_t                 fOperator;     // operator
+    AliRsnExpression*           fArg1;         // left argument
+    AliRsnExpression*           fArg2;         // right argument
+    Int_t                       fOperator;     // operator
 
     AliRsnExpression(int op, AliRsnExpression* a);
     AliRsnExpression(int op, AliRsnExpression* a, AliRsnExpression* b);
@@ -59,18 +58,4 @@ class AliRsnExpression : public TObject
     ClassDef(AliRsnExpression, 1);    // Class to evaluate an expression
 };
 
-
-///////////////////////////////////////////////////////////////////////////
-
-class AliRsnVariableExpression: public AliRsnExpression
-{
-  public:
-    AliRsnVariableExpression(TString a) : AliRsnExpression() { fVname = a;  };
-    ~AliRsnVariableExpression() {}
-    virtual Bool_t    Value(TObjArray& pgm);
-    virtual TString    Unparse() const { return fVname; }
-
-    ClassDef(AliRsnVariableExpression, 1);    // Class to define a variable expression
-};
-
 #endif
index 4b7a645b099ea980de6a5901961c1f5a76badfda..2bfe52cd47cef527c9eb95eaf077c13114a6d2ea 100644 (file)
@@ -19,7 +19,6 @@
 // author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
 //
 
-#include <Riostream.h>
 #include <TString.h>
 
 #include "AliLog.h"
@@ -27,7 +26,8 @@
 #include "AliRsnDaughter.h"
 #include "AliRsnEvent.h"
 #include "AliRsnPairDef.h"
-#include "AliRsnCut.h"
+#include "AliRsnPairParticle.h"
+#include "AliRsnFunctionAxis.h"
 
 #include "AliRsnFunction.h"
 
@@ -35,13 +35,13 @@ ClassImp(AliRsnFunction)
 
 //________________________________________________________________________________________
 AliRsnFunction::AliRsnFunction() :
-  TNamed(),
-  fPairDef(0x0),
-  fAxisList("AliRsnFunctionAxis", 0),
-  fTrack(0x0),
-  fPair(0x0),
-  fEvent(0x0),
-  fHistogram(0x0)
+    TNamed(),
+    fPairDef(0x0),
+    fAxisList("AliRsnFunctionAxis", 0),
+    fTrack(0x0),
+    fPair(0x0),
+    fEvent(0x0),
+    fHistogram(0x0)
 {
 //
 // Constructor.
@@ -50,13 +50,13 @@ AliRsnFunction::AliRsnFunction() :
 
 //________________________________________________________________________________________
 AliRsnFunction::AliRsnFunction(const AliRsnFunction &copy) :
-  TNamed(copy),
-  fPairDef(copy.fPairDef),
-  fAxisList(copy.fAxisList),
-  fTrack(copy.fTrack),
-  fPair(copy.fPair),
-  fEvent(copy.fEvent),
-  fHistogram(0x0)
+    TNamed(copy),
+    fPairDef(copy.fPairDef),
+    fAxisList(copy.fAxisList),
+    fTrack(copy.fTrack),
+    fPair(copy.fPair),
+    fEvent(copy.fEvent),
+    fHistogram(0x0)
 {
 //
 // Copy constructor.
@@ -97,8 +97,7 @@ const char* AliRsnFunction::GetName() const
   TObjArrayIter next(&fAxisList);
   AliRsnFunctionAxis *axis = 0;
 
-  while ( (axis = (AliRsnFunctionAxis*)next()) )
-  {
+  while ((axis = (AliRsnFunctionAxis*)next())) {
     if (name.Length() > 1) name += '_';
     name += axis->GetName();
   }
@@ -107,10 +106,10 @@ const char* AliRsnFunction::GetName() const
 }
 
 //________________________________________________________________________________________
-void AliRsnFunction::AddAxis(AliRsnFunctionAxis *axis)
+void AliRsnFunction::AddAxis(AliRsnFunctionAxis *const axis)
 {
   Int_t size = fAxisList.GetEntries();
-  new (fAxisList[size]) AliRsnFunctionAxis(*axis);
+  new(fAxisList[size]) AliRsnFunctionAxis(*axis);
 }
 
 //________________________________________________________________________________________
@@ -136,8 +135,7 @@ THnSparseD* AliRsnFunction::CreateHistogram(const char *histoName, const char *h
 
   // retrieve binnings for main and secondary axes
   AliRsnFunctionAxis *fcnAxis = 0;
-  for (Int_t i = 0; i < size; i++)
-  {
+  for (Int_t i = 0; i < size; i++) {
     fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(i);
     if (!fcnAxis) {
       nbins[i] = 0;
@@ -171,26 +169,24 @@ Bool_t AliRsnFunction::Fill()
   Double_t *values = new Double_t[nAxes];
 
   AliRsnFunctionAxis *fcnAxis = 0;
-  for (i = 0; i < nAxes; i++)
-  {
+  for (i = 0; i < nAxes; i++) {
     fcnAxis = (AliRsnFunctionAxis*)fAxisList.At(i);
     if (!fcnAxis) {
       values[i] = 0.0;
       continue;
     }
-    switch (fcnAxis->GetAxisObject())
-    {
-      case AliRsnFunctionAxis::kParticle:
-        values[i] = fcnAxis->Eval(fTrack);
-        break;
-      case AliRsnFunctionAxis::kPair:
-        values[i] = fcnAxis->Eval(fPair, fPairDef);
-        break;
-      case AliRsnFunctionAxis::kEvent:
-        values[i] = fcnAxis->Eval(fEvent);
-        break;
-      default:
-        values[i] = 0.0;
+    switch (fcnAxis->GetAxisObject()) {
+    case AliRsnFunctionAxis::kParticle:
+      values[i] = fcnAxis->Eval(fTrack);
+      break;
+    case AliRsnFunctionAxis::kPair:
+      values[i] = fcnAxis->Eval(fPair, fPairDef);
+      break;
+    case AliRsnFunctionAxis::kEvent:
+      values[i] = fcnAxis->Eval(fEvent);
+      break;
+    default:
+      values[i] = 0.0;
     }
   }
 
index 8555e73bc5f618ed300a2300b92fcec888935168..2b34751fb10843e783b89b6942ea31c63545d7e3 100644 (file)
 // author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
 //
 
-#ifndef ALIRSNFunction_H
-#define ALIRSNFunction_H
+#ifndef ALIRSNFUNCTION_H
+#define ALIRSNFUNCTION_H
 
 #include <TClonesArray.h>
 #include <THnSparse.h>
 #include <TNamed.h>
 
 #include "AliRsnCut.h"
-#include "AliRsnFunctionAxis.h"
-#include "AliRsnPairParticle.h"
 
+class AliRsnFunctionAxis;
+class AliRsnPairParticle;
 class AliRsnPairDef;
 
 class AliRsnFunction : public TNamed
@@ -42,18 +42,18 @@ class AliRsnFunction : public TNamed
     virtual ~AliRsnFunction() { delete fHistogram; }
     const AliRsnFunction& operator=(const AliRsnFunction &copy);
 
-    void                 SetPairDef(AliRsnPairDef *def) {fPairDef = def;}
-    void                 SetTrack(AliRsnDaughter *track) {fTrack = track;}
-    void                 SetPair(AliRsnPairParticle *pair) {fPair = pair;}
-    void                 SetEvent(AliRsnEvent *event) {fEvent = event;}
+    void                 SetPairDef(AliRsnPairDef * const def) {fPairDef = def;}
+    void                 SetTrack(AliRsnDaughter * const track) {fTrack = track;}
+    void                 SetPair(AliRsnPairParticle * const pair) {fPair = pair;}
+    void                 SetEvent(AliRsnEvent *const event) {fEvent = event;}
 
-    AliRsnPairDef*       GetPairDef() {return fPairDef;}
-    AliRsnDaughter*      GetTrack() {return fTrack;}
-    AliRsnPairParticle*  GetPair() {return fPair;}
-    AliRsnEvent*         GetEvent() {return fEvent;}
+    AliRsnPairDef*       GetPairDef() const {return fPairDef;}
+    AliRsnDaughter*      GetTrack() const {return fTrack;}
+    AliRsnPairParticle*  GetPair() const {return fPair;}
+    AliRsnEvent*         GetEvent() const {return fEvent;}
     virtual const char*  GetName() const;
 
-    void                 AddAxis(AliRsnFunctionAxis *axis);
+    void                 AddAxis(AliRsnFunctionAxis*const axis);
     Int_t                GetNumberOfAxes() {return fAxisList.GetEntries();}
     THnSparseD*          CreateHistogram(const char *histoName, const char *histoTitle);
 
index aae03d2eda513c1b729e5946ae2b783541803249..936c0961df5a91d811f6a50e609671a1b357c9fa 100644 (file)
@@ -8,9 +8,8 @@
 // This class considers the possibility of a 1D or 2D histograms
 // with its related binning, and can create a new histo from his definitions
 //
-#include "TObject.h"
 
-#include "AliLog.h"
+#include <TArrayD.h>
 
 #include "AliRsnEvent.h"
 #include "AliRsnPairParticle.h"
@@ -21,10 +20,10 @@ ClassImp(AliRsnFunctionAxis)
 
 //_____________________________________________________________________________
 AliRsnFunctionAxis::AliRsnFunctionAxis() :
-  fType(kAxisTypes),
-  fNBins(0),
-  fMin(0.0),
-  fMax(0.0)
+    fType(kAxisTypes),
+    fNBins(0),
+    fMin(0.0),
+    fMax(0.0)
 {
 //
 // Default constructor
@@ -34,10 +33,10 @@ AliRsnFunctionAxis::AliRsnFunctionAxis() :
 //_____________________________________________________________________________
 AliRsnFunctionAxis::AliRsnFunctionAxis
 (EAxisType type, Int_t nbins, Double_t min, Double_t max) :
-  fType(type),
-  fNBins(0),
-  fMin(0.0),
-  fMax(0.0)
+    fType(type),
+    fNBins(0),
+    fMin(0.0),
+    fMax(0.0)
 {
 //
 // Main constructor (version 1)
@@ -49,10 +48,10 @@ AliRsnFunctionAxis::AliRsnFunctionAxis
 //_____________________________________________________________________________
 AliRsnFunctionAxis::AliRsnFunctionAxis
 (EAxisType type, Double_t min, Double_t max, Double_t step) :
-  fType(type),
-  fNBins(0),
-  fMin(0.0),
-  fMax(0.0)
+    fType(type),
+    fNBins(0),
+    fMin(0.0),
+    fMax(0.0)
 {
 //
 // Main constructor (version 2)
@@ -68,45 +67,60 @@ const char* AliRsnFunctionAxis::GetName() const
 // Return the name of this object defined by the type
 //
 
-  switch (fType)
-  {
-    case kTrack1P:        return "P1";
-    case kTrack2P:        return "P2";
-    case kTrack1Pt:       return "PT1";
-    case kTrack2Pt:       return "PT2";
-    case kPairInvMass:    return "IM";
-    case kPairInvMassMC:  return "IMMC";
-    case kPairInvMassRes: return "IMRES";
-    case kPairPt:         return "PT";
-    case kPairEta:        return "ETA";
-    case kEventMult:      return "MULT";
-    default:              return "UNDEF";
+  switch (fType) {
+  case kTrack1P:        return "P1";
+  case kTrack2P:        return "P2";
+  case kTrack1Pt:       return "PT1";
+  case kTrack2Pt:       return "PT2";
+  case kPairInvMass:    return "IM";
+  case kPairInvMassMC:  return "IMMC";
+  case kPairInvMassRes: return "IMRES";
+  case kPairPt:         return "PT";
+  case kPairEta:        return "ETA";
+  case kEventMult:      return "MULT";
+  default:              return "UNDEF";
   }
 }
 
 //_____________________________________________________________________________
-AliRsnFunctionAxis::EAxisObject AliRsnFunctionAxis::GetAxisObject()
+TArrayD AliRsnFunctionAxis::GetArray() const
+{
+//
+// Creates an array with all bin edges
+//
+
+  TArrayD out(fNBins + 1);
+
+  Int_t i;
+  Double_t step = (fMax - fMin) / (Double_t)fNBins;
+
+  for (i = 0; i <= fNBins; i++) out[i] = fMin + step * (Double_t)i;
+
+  return out;
+}
+
+//_____________________________________________________________________________
+AliRsnFunctionAxis::EAxisObject AliRsnFunctionAxis::GetAxisObject() const
 {
 //
 // Tells what kind of object must be evaluated for this axis
 //
 
-  switch (fType)
-  {
-    case kTrack1P:
-    case kTrack2P:
-    case kTrack1Pt:
-    case kTrack2Pt:
-    case kPairInvMass:
-    case kPairInvMassMC:
-    case kPairInvMassRes:
-    case kPairPt:
-    case kPairEta:
-      return kPair;
-    case kEventMult:
-      return kEvent;
-    default:
-      return kNone;
+  switch (fType) {
+  case kTrack1P:
+  case kTrack2P:
+  case kTrack1Pt:
+  case kTrack2Pt:
+  case kPairInvMass:
+  case kPairInvMassMC:
+  case kPairInvMassRes:
+  case kPairPt:
+  case kPairEta:
+    return kPair;
+  case kEventMult:
+    return kEvent;
+  default:
+    return kNone;
   }
 }
 
@@ -119,13 +133,10 @@ void AliRsnFunctionAxis::SetBins(Int_t n, Double_t min, Double_t max)
 
   fNBins = n;
 
-  if (min < max)
-  {
+  if (min < max) {
     fMin = min;
     fMax = max;
-  }
-  else
-  {
+  } else {
     fMin = max;
     fMax = min;
   }
@@ -138,13 +149,10 @@ void AliRsnFunctionAxis::SetBins(Double_t min, Double_t max, Double_t step)
 // Binning for histogram.
 //
 
-  if (min < max)
-  {
+  if (min < max) {
     fMin = min;
     fMax = max;
-  }
-  else
-  {
+  } else {
     fMin = max;
     fMax = min;
   }
@@ -153,7 +161,7 @@ void AliRsnFunctionAxis::SetBins(Double_t min, Double_t max, Double_t step)
 }
 
 //_____________________________________________________________________________
-Double_t AliRsnFunctionAxis::Eval(AliRsnDaughter* /*daughter*/)
+Double_t AliRsnFunctionAxis::Eval(AliRsnDaughter* /*daughter*/) const
 {
 //
 // EValuation method for single tracks
@@ -164,58 +172,55 @@ Double_t AliRsnFunctionAxis::Eval(AliRsnDaughter* /*daughter*/)
 }
 
 //_____________________________________________________________________________
-Double_t AliRsnFunctionAxis::Eval(AliRsnPairParticle *pair, AliRsnPairDef *pairDef)
+Double_t AliRsnFunctionAxis::Eval(AliRsnPairParticle * const pair, AliRsnPairDef *const pairDef) const
 {
 //
 // EValuation method for pairs.
 // Requires also the pair definitions, in order to retrieve mass.
 //
 
-  switch (fType)
-  {
-    case kTrack1P:
-      return pair->GetDaughter(0)->P();
-    case kTrack2P:
-      return pair->GetDaughter(1)->P();
-    case kTrack1Pt:
-      return pair->GetDaughter(0)->Pt();
-    case kTrack2Pt:
-      return pair->GetDaughter(1)->Pt();
-    case kPairInvMass:
-      return pair->GetInvMass(pairDef->GetMass(0), pairDef->GetMass(1));
-    case kPairInvMassMC:
-      return pair->GetInvMassMC(pairDef->GetMass(0), pairDef->GetMass(1));
-    case kPairInvMassRes:
-      {
-        Double_t value;
-        value  = pair->GetInvMass(pairDef->GetMass(0), pairDef->GetMass(1));
-        value -= pair->GetInvMassMC(pairDef->GetMass(0), pairDef->GetMass(1));
-        value /= pair->GetInvMassMC(pairDef->GetMass(0), pairDef->GetMass(1));
-        return value;
-      }
-    case kPairPt:
-      return pair->GetPt();
-    case kPairEta:
-      return pair->GetEta();
-    default:
-      AliWarning("This axis type cannot be applied to pairs");
-      return -999.0;
+  switch (fType) {
+  case kTrack1P:
+    return pair->GetDaughter(0)->P();
+  case kTrack2P:
+    return pair->GetDaughter(1)->P();
+  case kTrack1Pt:
+    return pair->GetDaughter(0)->Pt();
+  case kTrack2Pt:
+    return pair->GetDaughter(1)->Pt();
+  case kPairInvMass:
+    return pair->GetInvMass(pairDef->GetMass(0), pairDef->GetMass(1));
+  case kPairInvMassMC:
+    return pair->GetInvMassMC(pairDef->GetMass(0), pairDef->GetMass(1));
+  case kPairInvMassRes: {
+      Double_t value;
+      value  = pair->GetInvMass(pairDef->GetMass(0), pairDef->GetMass(1));
+      value -= pair->GetInvMassMC(pairDef->GetMass(0), pairDef->GetMass(1));
+      value /= pair->GetInvMassMC(pairDef->GetMass(0), pairDef->GetMass(1));
+      return value;
+    }
+  case kPairPt:
+    return pair->GetPt();
+  case kPairEta:
+    return pair->GetEta();
+  default:
+    AliWarning("This axis type cannot be applied to pairs");
+    return -999.0;
   }
 }
 
 //_____________________________________________________________________________
-Double_t AliRsnFunctionAxis::Eval(AliRsnEvent *event)
+Double_t AliRsnFunctionAxis::Eval(AliRsnEvent *const event) const
 {
 //
 // EValuation method for events
 //
 
-  switch (fType)
-  {
-    case kEventMult:
-      return (Double_t)event->GetMultiplicity();
-    default:
-      AliWarning("This axis type cannot be applied to events");
-      return 0.0;
+  switch (fType) {
+  case kEventMult:
+    return (Double_t)event->GetMultiplicity();
+  default:
+    AliWarning("This axis type cannot be applied to events");
+    return 0.0;
   }
 }
index 2650a832e271483e4154f2614ecc0bf1afd70b9f..ef7a49006b3cc69c4045c61fb0e76becac61030c 100644 (file)
@@ -8,17 +8,18 @@
 // not used as typical output of analysis in this package.
 //
 
-#ifndef ALIRSNFunctionAxis_H
-#define ALIRSNFunctionAxis_H
+#ifndef ALIRSNFUNCTIONAXIS_H
+#define ALIRSNFUNCTIONAXIS_H
 
+
+class TArrayD;
 class AliRsnPairDef;
 
 class AliRsnFunctionAxis : public TObject
 {
   public:
 
-    enum EAxisType
-    {
+    enum EAxisType {
       kTrack1P,
       kTrack2P,
       kTrack1Pt,
@@ -32,8 +33,7 @@ class AliRsnFunctionAxis : public TObject
       kAxisTypes
     };
 
-    enum EAxisObject
-    {
+    enum EAxisObject {
       kParticle,
       kPair,
       kEvent,
@@ -50,15 +50,16 @@ class AliRsnFunctionAxis : public TObject
     Int_t       GetNBins() const {return fNBins;}
     Double_t    GetMin() const {return fMin;}
     Double_t    GetMax() const {return fMax;}
-    EAxisObject GetAxisObject();
+    TArrayD     GetArray() const;
+    EAxisObject GetAxisObject() const;
 
     void     SetType(EAxisType type) {fType = type;}
     void     SetBins(Int_t n, Double_t min, Double_t max);
     void     SetBins(Double_t min, Double_t max, Double_t step);
 
-    Double_t Eval(AliRsnDaughter *daughter);
-    Double_t Eval(AliRsnPairParticle *pair, AliRsnPairDef *pairDef);
-    Double_t Eval(AliRsnEvent *event);
+    Double_t Eval(AliRsnDaughter *daughter) const;
+    Double_t Eval(AliRsnPairParticle*const pair, AliRsnPairDef*const pairDef) const;
+    Double_t Eval(AliRsnEvent *const event) const;
 
   private:
 
index 47fd60a04f32065a063e8258d917d64935a1af59..71c4bd7500beccf3d95a970531171c2ed1e75c7f 100644 (file)
 // author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
 //-------------------------------------------------------------------------
 
-#include <TMath.h>
 #include <TString.h>
-#include <TClonesArray.h>
-#include <TDatabasePDG.h>
 
 #include "AliLog.h"
 #include "AliESDtrack.h"
-#include "AliRsnDaughter.h"
 #include "AliRsnPIDDefESD.h"
 
 ClassImp(AliRsnPIDDefESD)
 
 //_____________________________________________________________________________
 AliRsnPIDDefESD::AliRsnPIDDefESD() :
-  fUseESDWeights(kTRUE)
+    fUseESDWeights(kTRUE)
 {
 //
 // Default constructor.
@@ -56,8 +52,8 @@ AliRsnPIDDefESD::AliRsnPIDDefESD() :
 
 //_____________________________________________________________________________
 AliRsnPIDDefESD::AliRsnPIDDefESD(const AliRsnPIDDefESD& copy) :
-  TObject(copy),
-  fUseESDWeights(copy.fUseESDWeights)
+    TObject(copy),
+    fUseESDWeights(copy.fUseESDWeights)
 {
 //
 // Copy constructor.
@@ -80,84 +76,84 @@ void AliRsnPIDDefESD::SetScheme(EScheme scheme, Double_t divValue)
 //
 
   switch (scheme) {
-    case kSchemeESD:
-      fUseESDWeights = kTRUE;
-      break;
-    case kSchemeITS:
-      fUseESDWeights = kFALSE;
-      ExcludeAll();
-      IncludeDet(kITS);
-      SetDivValue(kITS, 0.0);
-      break;
-    case kSchemeTPC:
-      fUseESDWeights = kFALSE;
-      ExcludeAll();
-      IncludeDet(kTPC);
-      SetDivValue(kTPC, 0.0);
-      break;
-    case kSchemeTOF:
-      fUseESDWeights = kFALSE;
-      ExcludeAll();
-      IncludeDet(kTOF);
-      SetDivValue(kTOF, 0.0);
-      break;
-    case kSchemeITSandTPC:
-      fUseESDWeights = kFALSE;
-      ExcludeAll();
-      IncludeDet(kITS);
-      IncludeDet(kTPC);
-      SetDivValue(kITS, 0.0);
-      SetDivValue(kTPC, 0.0);
-      break;
-    case kSchemeITSandTOF:
-      fUseESDWeights = kFALSE;
-      ExcludeAll();
-      IncludeDet(kITS);
-      IncludeDet(kTOF);
-      SetDivValue(kITS, 0.0);
-      SetDivValue(kTOF, 0.0);
-      break;
-    case kSchemeTPCandTOF:
-      fUseESDWeights = kFALSE;
-      ExcludeAll();
-      IncludeDet(kTPC);
-      IncludeDet(kTOF);
-      SetDivValue(kTPC, 0.0);
-      SetDivValue(kTOF, 0.0);
-      break;
-    case kSchemeITSandTPCandTOF:
-      fUseESDWeights = kFALSE;
-      ExcludeAll();
-      IncludeDet(kITS);
-      IncludeDet(kTPC);
-      IncludeDet(kTOF);
-      SetDivValue(kITS, 0.0);
-      SetDivValue(kTPC, 0.0);
-      SetDivValue(kTOF, 0.0);
-      break;
-    case kSchemeITSandTPCandTOFwithSP:
-      fUseESDWeights = kFALSE;
-      ExcludeAll();
-      IncludeDet(kITS);
-      IncludeDet(kTPC);
-      IncludeDet(kTOF);
-      SetDivValue(kITS, 0.0);
-      SetDivValue(kTPC, 0.0);
-      SetDivValue(kTOF, divValue);
-      break;
-    case kSchemeITSandTPCorTOFwithSP:
-      fUseESDWeights = kFALSE;
-      ExcludeAll();
-      IncludeDet(kITS);
-      IncludeDet(kTPC);
-      IncludeDet(kTOF);
-      SetDivValue(kITS, divValue, kFALSE);
-      SetDivValue(kTPC, divValue, kFALSE);
-      SetDivValue(kTOF, divValue, kTRUE);
-      break;
-    default:
-      AliWarning("PID scheme unrecognized. Set to ESD");
-      fUseESDWeights = kTRUE;
+  case kSchemeESD:
+    fUseESDWeights = kTRUE;
+    break;
+  case kSchemeITS:
+    fUseESDWeights = kFALSE;
+    ExcludeAll();
+    IncludeDet(kITS);
+    SetDivValue(kITS, 0.0);
+    break;
+  case kSchemeTPC:
+    fUseESDWeights = kFALSE;
+    ExcludeAll();
+    IncludeDet(kTPC);
+    SetDivValue(kTPC, 0.0);
+    break;
+  case kSchemeTOF:
+    fUseESDWeights = kFALSE;
+    ExcludeAll();
+    IncludeDet(kTOF);
+    SetDivValue(kTOF, 0.0);
+    break;
+  case kSchemeITSandTPC:
+    fUseESDWeights = kFALSE;
+    ExcludeAll();
+    IncludeDet(kITS);
+    IncludeDet(kTPC);
+    SetDivValue(kITS, 0.0);
+    SetDivValue(kTPC, 0.0);
+    break;
+  case kSchemeITSandTOF:
+    fUseESDWeights = kFALSE;
+    ExcludeAll();
+    IncludeDet(kITS);
+    IncludeDet(kTOF);
+    SetDivValue(kITS, 0.0);
+    SetDivValue(kTOF, 0.0);
+    break;
+  case kSchemeTPCandTOF:
+    fUseESDWeights = kFALSE;
+    ExcludeAll();
+    IncludeDet(kTPC);
+    IncludeDet(kTOF);
+    SetDivValue(kTPC, 0.0);
+    SetDivValue(kTOF, 0.0);
+    break;
+  case kSchemeITSandTPCandTOF:
+    fUseESDWeights = kFALSE;
+    ExcludeAll();
+    IncludeDet(kITS);
+    IncludeDet(kTPC);
+    IncludeDet(kTOF);
+    SetDivValue(kITS, 0.0);
+    SetDivValue(kTPC, 0.0);
+    SetDivValue(kTOF, 0.0);
+    break;
+  case kSchemeITSandTPCandTOFwithSP:
+    fUseESDWeights = kFALSE;
+    ExcludeAll();
+    IncludeDet(kITS);
+    IncludeDet(kTPC);
+    IncludeDet(kTOF);
+    SetDivValue(kITS, 0.0);
+    SetDivValue(kTPC, 0.0);
+    SetDivValue(kTOF, divValue);
+    break;
+  case kSchemeITSandTPCorTOFwithSP:
+    fUseESDWeights = kFALSE;
+    ExcludeAll();
+    IncludeDet(kITS);
+    IncludeDet(kTPC);
+    IncludeDet(kTOF);
+    SetDivValue(kITS, divValue, kFALSE);
+    SetDivValue(kTPC, divValue, kFALSE);
+    SetDivValue(kTOF, divValue, kTRUE);
+    break;
+  default:
+    AliWarning("PID scheme unrecognized. Set to ESD");
+    fUseESDWeights = kTRUE;
   }
 }
 
@@ -220,19 +216,19 @@ void AliRsnPIDDefESD::PrintStatus()
 }
 
 //_____________________________________________________________________________
-const char* AliRsnPIDDefESD::DetName(EDetector det)
+const char* AliRsnPIDDefESD::DetName(EDetector det) const
 {
 //
 // Detector name for messages
 //
 
   switch (det) {
-    case kITS: return "ITS";
-    case kTPC: return "TPC";
-    case kTRD: return "TRD";
-    case kTOF: return "TOF";
-    case kHMPID: return "HMPID";
-    default: return "undef";
+  case kITS: return "ITS";
+  case kTPC: return "TPC";
+  case kTRD: return "TRD";
+  case kTOF: return "TOF";
+  case kHMPID: return "HMPID";
+  default: return "undef";
   }
 }
 
@@ -248,8 +244,7 @@ const char* AliRsnPIDDefESD::SchemeName()
   Int_t i, ndet = 0;
 
   for (i = 0; i < kDetectors; i++)
-    if (fUseDet[i])
-    {
+    if (fUseDet[i]) {
       if (ndet > 0) out += '_';
       out.Append(DetName((EDetector)i));
     }
index f3b3ec8902d47c7053fc567439f9730a5bd7ba45..3dae9fa79b7c8033154497a678d5d52d3ad49151 100644 (file)
@@ -58,12 +58,12 @@ class AliRsnPIDDefESD : public TObject
     void        SetDivValue(EDetector det, Double_t value,Bool_t userHigher=kTRUE);
     void        ComputeWeights(AliESDtrack *track, Double_t *weights);
     void        PrintStatus();
-    const char* DetName(EDetector);
+    const char* DetName(EDetector det) const;
     const char* SchemeName();
 
   private:
 
-    Bool_t   CheckBounds(EDetector det) { return (det >= kITS && det < kDetectors); }
+    Bool_t   CheckBounds(EDetector det) const { return (det >= kITS && det < kDetectors); }
     Bool_t   CheckDivValue(EDetector det,Double_t value);
 
     Bool_t   fUseESDWeights;          // with this flag, ESD weights are used
index feef344640b66254c2df4c614f099fa861c87a2c..3f4ecd7d8911004e1ebbb158faa5fe058e765f17 100644 (file)
@@ -1,62 +1,66 @@
 //
 // Class AliRsnPIDIndex
 //
-// It sorts the indexes of all tracks in an AliRsnEvent
+// Sorts the indexes of all tracks in an AliRsnEvent
 // for a fast retrieval of them according to charge and PID.
 //
-// author: M. Vala (email: martin.vala@cern.ch)
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
-#include <TObject.h>
-
 #include "AliLog.h"
-#include "AliESDtrack.h"
-#include "AliESDtrackCuts.h"
 
+#include "AliRsnEvent.h"
 #include "AliRsnPIDIndex.h"
 
 ClassImp(AliRsnPIDIndex)
 
 //_____________________________________________________________________________
-AliRsnPIDIndex::AliRsnPIDIndex(Int_t num) : fPIDDef()
+AliRsnPIDIndex::AliRsnPIDIndex(Int_t num)
 {
 //
-// Default constructor
+// Default constructor.
+// Reset all arrays to the size specified in the argument (default = 1000).
 //
-  Int_t i, j, k, l;
 
-  for (l = 0; l < AliRsnDaughter::kMethods; l++) {
-    for (i = 0; i < 2; i++) {
-      for (j = 0; j <= AliPID::kSPECIES; j++) {
-        fNumOfIndex[l][i][j] = 0;
-        fIndex[l][i][j].Set(num);
-        for (k = 0; k < num; k++) fIndex[l][i][j].AddAt(-1, k);
+  Int_t imethod, icharge, ipid, i;
+
+  for (imethod = 0; imethod < AliRsnDaughter::kMethods; imethod++)
+  {
+    for (icharge = 0; icharge < 2; icharge++)
+    {
+      for (ipid = 0; ipid <= AliPID::kSPECIES; ipid++)
+      {
+        fNumOfIndex[imethod][icharge][ipid] = 0;
+        fIndex[imethod][icharge][ipid].Set(num);
+        for (i = 0; i < num; i++) fIndex[imethod][icharge][ipid].AddAt(-1, i);
       }
     }
   }
 }
 
 //_____________________________________________________________________________
-AliRsnPIDIndex::AliRsnPIDIndex(const AliRsnPIDIndex & copy)
-    : TObject(copy),
-    fPIDDef(copy.fPIDDef)
+AliRsnPIDIndex::AliRsnPIDIndex(const AliRsnPIDIndex & copy) :
+  TObject(copy)
 {
 //
 // Copy constructor.
-// Creates new instances of all collections
-// to store a copy of all objects.
+// Duplicates all arrays.
 //
 
-  Int_t l, i, j, k, size;
-
-  for (l = 0; l < AliRsnDaughter::kMethods; l++) {
-    for (i = 0; i < 2; i++) {
-      for (j = 0; j <= AliPID::kSPECIES; j++) {
-        fNumOfIndex[l][i][j] = copy.fNumOfIndex[l][i][j];
-        size = copy.fIndex[l][i][j].GetSize();
-        fIndex[l][i][j].Set(size);
-        for (k = 0; k < size; k++) {
-          fIndex[l][i][j].AddAt(copy.fIndex[l][i][j].At(k), k);
+  Int_t imethod, icharge, ipid, i, size;
+
+  for (imethod = 0; imethod < AliRsnDaughter::kMethods; imethod++)
+  {
+    for (icharge = 0; icharge < 2; icharge++)
+    {
+      for (ipid = 0; ipid <= AliPID::kSPECIES; ipid++)
+      {
+        fNumOfIndex[imethod][icharge][ipid] = copy.fNumOfIndex[imethod][icharge][ipid];
+        size = copy.fIndex[imethod][icharge][ipid].GetSize();
+        fIndex[imethod][icharge][ipid].Set(size);
+        for (i = 0; i < size; i++) {
+          fIndex[imethod][icharge][ipid].AddAt(copy.fIndex[imethod][icharge][ipid].At(i), i);
         }
       }
     }
@@ -68,20 +72,22 @@ AliRsnPIDIndex& AliRsnPIDIndex::operator= (const AliRsnPIDIndex & copy)
 {
 //
 // Assignment operator.
-// Creates new instances of all collections
-// to store a copy of all objects.
+// Duplicates all arrays.
 //
 
-  Int_t l, i, j, k, size;
-
-  for (l = 0; l < AliRsnDaughter::kMethods; l++) {
-    for (i = 0; i < 2; i++) {
-      for (j = 0; j < AliPID::kSPECIES; j++) {
-        fNumOfIndex[l][i][j] = copy.fNumOfIndex[l][i][j];
-        size = copy.fIndex[l][i][j].GetSize();
-        fIndex[l][i][j].Set(size);
+  Int_t imethod, icharge, ipid, k, size;
+
+  for (imethod = 0; imethod < AliRsnDaughter::kMethods; imethod++)
+  {
+    for (icharge = 0; icharge < 2; icharge++)
+    {
+      for (ipid = 0; ipid <= AliPID::kSPECIES; ipid++)
+      {
+        fNumOfIndex[imethod][icharge][ipid] = copy.fNumOfIndex[imethod][icharge][ipid];
+        size = copy.fIndex[imethod][icharge][ipid].GetSize();
+        fIndex[imethod][icharge][ipid].Set(size);
         for (k = 0; k < size; k++) {
-          fIndex[l][i][j].AddAt(copy.fIndex[l][i][j].At(k), k);
+          fIndex[imethod][icharge][ipid].AddAt(copy.fIndex[imethod][icharge][ipid].At(k), k);
         }
       }
     }
@@ -91,6 +97,7 @@ AliRsnPIDIndex& AliRsnPIDIndex::operator= (const AliRsnPIDIndex & copy)
   return (*this);
 }
 
+//_____________________________________________________________________________
 AliRsnPIDIndex::~AliRsnPIDIndex()
 {
 //
@@ -98,21 +105,25 @@ AliRsnPIDIndex::~AliRsnPIDIndex()
 // Does nothing.
 //
 }
+
 //_____________________________________________________________________________
 void AliRsnPIDIndex::ResetAll(Int_t num)
 {
 //
-// Resets All
+// Resets all arrays to a given size, and storing '-1' in all values
 //
 
-  Int_t i, j, k, l;
-
-  for (l = 0; l < AliRsnDaughter::kMethods; l++) {
-    for (i = 0; i < 2; i++) {
-      for (j = 0; j <= AliPID::kSPECIES; j++) {
-        fNumOfIndex[l][i][j] = 0;
-        fIndex[l][i][j].Set(num);
-        for (k = 0; k < num; k++) fIndex[l][i][j].AddAt(-1, k);
+  Int_t imethod, icharge, ipid, i;
+
+  for (imethod = 0; imethod < AliRsnDaughter::kMethods; imethod++)
+  {
+    for (icharge = 0; icharge < 2; icharge++)
+    {
+      for (ipid = 0; ipid <= AliPID::kSPECIES; ipid++)
+      {
+        fNumOfIndex[imethod][icharge][ipid] = 0;
+        fIndex[imethod][icharge][ipid].Set(num);
+        for (i = 0; i < num; i++) fIndex[imethod][icharge][ipid].AddAt(-1, i);
       }
     }
   }
@@ -124,6 +135,7 @@ void AliRsnPIDIndex::Print(Option_t* /*option*/) const
 //
 // Prints AliRsnPIDIndex info
 //
+
   Int_t i, j, l;
 
   for (l = 0; l < AliRsnDaughter::kMethods; l++) {
@@ -136,28 +148,45 @@ void AliRsnPIDIndex::Print(Option_t* /*option*/) const
 }
 
 //_____________________________________________________________________________
-void AliRsnPIDIndex::AddIndex(const Int_t index, AliRsnDaughter::EPIDMethod meth, Char_t sign, AliPID::EParticleType  type)
+void AliRsnPIDIndex::AddIndex
+(const Int_t index, AliRsnDaughter::EPIDMethod meth, Char_t sign, AliPID::EParticleType type)
 {
 //
-// Adds index to corresponding TArrayI
+// Adds one index (1st arg) to the corresponding array defined by:
+// - PID method (2nd arg)
+// - charge     (3rd arg)
+// - pid type   (4th arg)
 //
 
   Int_t iMethod = (Int_t)meth;
   Int_t iCharge = ChargeIndex(sign);
-  Int_t iType = (Int_t)type;
-  // in AliPID kUnknown = 10 and kSPECIES = 5!
+  Int_t iType   = (Int_t)type;
+
+  // since AliPID kUnknown = 10 and kSPECIES = 5, the PID is "unknown"
+  // a correction in the storage index must be done
   if (type == AliPID::kUnknown) iType = (Int_t)AliPID::kSPECIES;
+
+  // debug message (can this be removed?)
   AliDebug(AliLog::kDebug+1,Form("Adding index=%d method=%d sign='%c', pidType=%d",index,meth,sign,type));
+
+  // check indexes before storing
+  if (iMethod < 0 || iMethod >= AliRsnDaughter::kMethods) return;
+  if (iCharge < 0 || iCharge > 1) return;
+  if (iType < 0 || iType > AliPID::kSPECIES) return;
+
+  // debug to know if adding was successful
+  AliDebug(AliLog::kDebug+1,Form("Adding succeeded for index=%d method=%d sign='%c', pidType=%d",index,meth,sign,type));
+
+  // insert the index in the array and increment the counter of occupied slots
   fIndex[iMethod][iCharge][iType].AddAt(index, fNumOfIndex[iMethod][iCharge][iType]);
   fNumOfIndex[iMethod][iCharge][iType]++;
-
 }
 
 //_____________________________________________________________________________
 void AliRsnPIDIndex::SetCorrectIndexSize()
 {
 //
-// Sets Correct sizes to all TArrayI
+// Removes in every array the unused slots, to compress its size.
 //
 
   Int_t i, j, l;
@@ -171,27 +200,44 @@ void AliRsnPIDIndex::SetCorrectIndexSize()
 }
 
 //_____________________________________________________________________________
-TArrayI* AliRsnPIDIndex::GetTracksArray(AliRsnDaughter::EPIDMethod meth, Char_t sign, AliPID::EParticleType type)
+TArrayI* AliRsnPIDIndex::GetTracksArray
+(AliRsnDaughter::EPIDMethod meth, Char_t sign, AliPID::EParticleType type)
 {
 //
 // Returns the array of indexes of tracks whose charge
 // and PID correspond to the passed arguments:
-//   1) sign of particle ('+' or '-')
-//   2) PID of particle (from AliRsnPID::EType)
+//   1) PID method
+//   2) sign of particle ('+' or '-')
+//   3) PID of particle (from AliRsnPID::EType)
 // Otherwise returns null pointer.
 //
 
   Int_t iMethod = (Int_t)meth;
-  Int_t icharge = ChargeIndex(sign);
-  Int_t itype   = 0;
-  if (icharge < 0) return (TArrayI *) 0x0;
-  if (type == AliPID::kUnknown) itype = (Int_t)AliPID::kSPECIES; else itype = (Int_t)type;
-  if (itype < 0 || itype > (Int_t)AliPID::kSPECIES) {
-    AliError(Form("Index %d out of range", itype));
-    return (TArrayI *) 0x0;
+  Int_t iCharge = ChargeIndex(sign);
+  Int_t iType   = (Int_t)type;
+
+  // since AliPID kUnknown = 10 and kSPECIES = 5, the PID is "unknown"
+  // a correction in the storage index must be done
+  if (type == AliPID::kUnknown) iType = (Int_t)AliPID::kSPECIES;
+
+  // check indexes
+  if (iMethod < 0 || iMethod >= AliRsnDaughter::kMethods)
+  {
+    AliError("Unrecognized PID method");
+    return 0x0;
+  }
+  if (iCharge < 0 || iCharge > 1)
+  {
+    AliError(Form("Charge index (%d) out of range", iCharge));
+    return 0x0;
+  }
+  if (iType < 0 || iType > AliPID::kSPECIES)
+  {
+    AliError(Form("PID index(%d) out of range", iType));
+    return 0x0;
   }
 
-  return &fIndex[iMethod][icharge][itype];
+  return &fIndex[iMethod][iCharge][iType];
 }
 
 //_____________________________________________________________________________
@@ -202,19 +248,22 @@ TArrayI* AliRsnPIDIndex::GetCharged(Char_t sign)
 // corresponds to the passed argument
 // Otherwise returns a null pointer.
 //
-  return GetTracksArray(AliRsnDaughter::kNoPID, sign, AliPID::kUnknown);
 
+  return GetTracksArray(AliRsnDaughter::kNoPID, sign, AliPID::kUnknown);
 }
 
 //_____________________________________________________________________________
 Int_t AliRsnPIDIndex::ChargeIndex(Char_t sign) const
 {
 //
-// Returns the array index corresponding to charge
+// Returns the array index corresponding to charge.
+// The inverse operation (returning '+' or '-' depending on charge)
+// is done by 'AliRsnDaughter::GetChargeC()' method.
 //
 
   if (sign == '+') return 0;
   else if (sign == '-') return 1;
+  else if (sign == '0') return 2;
   else {
     AliError(Form("Character '%c' not recognized as charge sign", sign));
     return -1;
@@ -222,96 +271,43 @@ Int_t AliRsnPIDIndex::ChargeIndex(Char_t sign) const
 }
 
 //_____________________________________________________________________________
-Char_t AliRsnPIDIndex::IndexCharge(Short_t sign) const
-{
-  //
-  // Returns the array index corresponding to charge
-  //
-
-  if (sign == 1) return '+';
-  else if (sign == -1) return '-';
-  else {
-    AliError(Form("Charge is different the 0(+) and 1(-) value is '%d'...", sign));
-    return '+';
-  }
-}
-
-//_____________________________________________________________________________
-void AliRsnPIDIndex::FillFromEvent(AliRsnEvent* event, AliESDtrackCuts *cuts)
+void AliRsnPIDIndex::FillFromEvent(AliRsnEvent* const event)
 {
 //
-// Fills indexes from event
+// Scans a whole event and fills the arrays depending
+// on the identification of all tracks with all methods.
 //
 
   Int_t numOfTracks = event->GetMultiplicity();
-  AliRsnDaughter daughter;
-  Int_t i;
-  for (i=0;i<numOfTracks;i++) {
-    daughter = event->GetDaughter(i);
-    // if ESD track cuts are specified, 
-    // and if the reference is an ESD track
-    // skip all tracks not passing the cut
-    if (cuts) {
-      AliESDtrack *track = daughter.GetRefESD();
-      if (track) if (!cuts->IsSelected(track)) continue;
-    }
-    daughter.CombineWithPriors(fPrior, &fPIDDef);
-//     daughter.Print("ALL");
-
-    AddIndex(i,AliRsnDaughter::kNoPID,IndexCharge(daughter.Charge()),AliPID::kUnknown);
-    AddIndex(i,AliRsnDaughter::kRealistic,IndexCharge(daughter.Charge()),(AliPID::EParticleType)daughter.RealisticPID());
-    if (daughter.GetParticle())
-      AddIndex(i,AliRsnDaughter::kPerfect,IndexCharge(daughter.Charge()),(AliPID::EParticleType)daughter.PerfectPID());
-  }
-}
-
-
-//_____________________________________________________________________________
-void AliRsnPIDIndex::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 AliRsnPIDIndex::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 AliRsnPIDIndex::GetPriorProbability(Double_t *out)
-{
+  // first, reset all arrays to the multiplicity,
+  // in order to avoid 'out of range' errors
+  ResetAll(numOfTracks);
 
+  // now loop on tracks using a unique AliRsnDaughter object
+  // which will point to one track at a time, and allows
+  // to recovery the informations to classify it
   Int_t i;
-  for (i=0; i<AliPID::kSPECIES; i++) {
-    out[i] = fPrior[i];
-  }
+  AliRsnDaughter daughter;
+  for (i = 0; i < numOfTracks; i++)
+  {
+    // link the cursor to current track
+    // this method recoveries the true PID and
+    // combines weights with prior probabilities (defined in AliRsnEvent)
+    // to obtain realistic PID
+    event->SetDaughter(daughter, i);
 
-}
+    // assign current index to right slot for NoPID (essentially the charge)
+    AddIndex(i,AliRsnDaughter::kNoPID,daughter.ChargeC(),AliPID::kUnknown);
 
-//_____________________________________________________________________________
-void AliRsnPIDIndex::SetPriorProbability(Double_t *out)
-{
+    // assign current index to right slot for realistic PID
+    AddIndex(i, AliRsnDaughter::kRealistic, daughter.ChargeC(), daughter.RealisticPID());
 
-  Int_t i;
-  for (i=0;i<AliPID::kSPECIES;i++) {
-    fPrior[i] = out[i];
+    // if MC info is present, assign current index to right slot for true PID
+    if (daughter.GetParticle())
+      AddIndex(i, AliRsnDaughter::kPerfect, daughter.ChargeC(), daughter.PerfectPID());
   }
 
+  // at the end, compress all arrays to the correct size
+  SetCorrectIndexSize();
 }
-
index abd2f1a0e2359cd92620833796e6ea22fbaa09cd..6055cd27017200c35d2ef80fe28e470f5559b6e2 100644 (file)
@@ -4,20 +4,20 @@
 // It sorts the indexes of all tracks in an AliRsnEvent
 // for a fast retrieval of them according to charge and PID.
 //
-// author: M. Vala (email: martin.vala@cern.ch)
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
-#ifndef AliRsnPIDIndex_h
-#define AliRsnPIDIndex_h
+#ifndef ALIRSNPIDINDEX_H
+#define ALIRSNPIDINDEX_H
 
 #include <TArrayI.h>
 
-#include "AliRsnEvent.h"
-#include "AliAODTrack.h"
 #include "AliRsnDaughter.h"
 #include "AliRsnPIDDefESD.h"
 
-class AliESDtrackCuts;
+class AliAODTrack;
+class AliRsnEvent;
 
 class AliRsnPIDIndex : public TObject
 {
@@ -30,23 +30,15 @@ class AliRsnPIDIndex : public TObject
     virtual  ~AliRsnPIDIndex();
 
     void      Print(Option_t *option = "") const;
-    void      ResetAll(Int_t num=1000);
-    
-    void      FillFromEvent(AliRsnEvent *event = 0, AliESDtrackCuts *cuts = 0);
+    void      ResetAll(Int_t num = 1000);
+
+    void      FillFromEvent(AliRsnEvent*const event = 0);
 
     void      AddIndex(const Int_t index, AliRsnDaughter::EPIDMethod meth, Char_t sign, AliPID::EParticleType type);
     void      SetCorrectIndexSize();
 
     TArrayI*  GetTracksArray(AliRsnDaughter::EPIDMethod meth, Char_t sign, AliPID::EParticleType type);
     TArrayI*  GetCharged(Char_t sign);
-    
-    // Prior probs
-    void            SetPriorProbability(AliPID::EParticleType type, Double_t p);
-    void            SetPriorProbability(Double_t *out);
-    void            DumpPriors();
-    void            GetPriorProbability(Double_t *out);
-
-    AliRsnPIDDefESD* GetPIDDef() {return &fPIDDef;}
 
   private:
 
@@ -55,9 +47,6 @@ class AliRsnPIDIndex : public TObject
 
     TArrayI   fIndex[AliRsnDaughter::kMethods][2][AliPID::kSPECIES + 1];       // index arrays of pos/neg particles of each PID
     Int_t     fNumOfIndex[AliRsnDaughter::kMethods][2][AliPID::kSPECIES + 1];  //! array size
-    
-    Double_t         fPrior[AliPID::kSPECIES]; // prior probabilities
-    AliRsnPIDDefESD  fPIDDef; // customization of weights
 
     ClassDef(AliRsnPIDIndex, 1);
 };
index 4e9f86c31a42af9a9b7d92ee49411159f95a77b2..b87ec9a6718edeba03df7d440709d48efda88d77 100644 (file)
 //          M. Vala (email: martin.vala@cern.ch)
 //
 
-#include <Riostream.h>
-#include <TObjArray.h>
+#include <TList.h>
 
 #include "AliLog.h"
 
+#include "AliRsnEvent.h"
 #include "AliRsnFunction.h"
+#include "AliRsnPIDIndex.h"
+#include "AliRsnCutMgr.h"
+#include "AliRsnCutStd.h"
 
 #include "AliRsnPair.h"
 
@@ -26,6 +29,7 @@ ClassImp(AliRsnPair)
 //_____________________________________________________________________________
 AliRsnPair::AliRsnPair(EPairType type, AliRsnPairDef *def) :
     TObject(),
+    fOnlyTrue(kFALSE),
     fIsMixed(kFALSE),
     fPairType(type),
     fPIDMethod(AliRsnDaughter::kRealistic),
@@ -61,28 +65,28 @@ void AliRsnPair::SetUp(EPairType type)
 //
   AliDebug(AliLog::kDebug+2,"<-");
   switch (type) {
-    case kNoPID:
-      SetAllFlags(AliRsnDaughter::kNoPID, kFALSE);
-      break;
-    case kNoPIDMix:
-      SetAllFlags(AliRsnDaughter::kNoPID, kTRUE);
-      break;
-    case kRealisticPID:
-      SetAllFlags(AliRsnDaughter::kRealistic, kFALSE);
-      break;
-    case kRealisticPIDMix:
-      SetAllFlags(AliRsnDaughter::kRealistic, kTRUE);
-      break;
-    case kPerfectPID:
-      SetAllFlags (AliRsnDaughter::kPerfect, kFALSE);
-      break;
-    case kPerfectPIDMix:
-      SetAllFlags (AliRsnDaughter::kPerfect, kTRUE);
-      break;
-    default :
-      AliWarning("Wrong type selected: setting up for realistic PID - no mixing.");
-      SetAllFlags(AliRsnDaughter::kRealistic, kFALSE);
-      break;
+  case kNoPID:
+    SetAllFlags(AliRsnDaughter::kNoPID, kFALSE);
+    break;
+  case kNoPIDMix:
+    SetAllFlags(AliRsnDaughter::kNoPID, kTRUE);
+    break;
+  case kRealisticPID:
+    SetAllFlags(AliRsnDaughter::kRealistic, kFALSE);
+    break;
+  case kRealisticPIDMix:
+    SetAllFlags(AliRsnDaughter::kRealistic, kTRUE);
+    break;
+  case kPerfectPID:
+    SetAllFlags(AliRsnDaughter::kPerfect, kFALSE);
+    break;
+  case kPerfectPIDMix:
+    SetAllFlags(AliRsnDaughter::kPerfect, kTRUE);
+    break;
+  default :
+    AliWarning("Wrong type selected: setting up for realistic PID - no mixing.");
+    SetAllFlags(AliRsnDaughter::kRealistic, kFALSE);
+    break;
   }
   AliDebug(AliLog::kDebug+2,"->");
 }
@@ -101,24 +105,23 @@ void AliRsnPair::Print(Option_t* /*option*/) const
   AliInfo(Form("Number of functions %d", fFunctions.GetEntries()));
 
   switch (fPIDMethod) {
-    case AliRsnDaughter::kNoPID:
-      AliInfo("PID method: none");
-      break;
-    case AliRsnDaughter::kRealistic:
-      AliInfo("PID method: realistic");
-      break;
-    case AliRsnDaughter::kPerfect:
-      AliInfo("PID method: perfect");
-      break;
-    default:
-      AliInfo("PID method: undefined");
+  case AliRsnDaughter::kNoPID:
+    AliInfo("PID method: none");
+    break;
+  case AliRsnDaughter::kRealistic:
+    AliInfo("PID method: realistic");
+    break;
+  case AliRsnDaughter::kPerfect:
+    AliInfo("PID method: perfect");
+    break;
+  default:
+    AliInfo("PID method: undefined");
   }
   AliDebug(AliLog::kDebug+2,"->");
 }
 
 //_____________________________________________________________________________
-void AliRsnPair::LoopPair
-(AliRsnPIDIndex *pidIndex1, AliRsnEvent *ev1, AliRsnPIDIndex *pidIndex2, AliRsnEvent *ev2)
+void AliRsnPair::LoopPair(AliRsnPIDIndex *const pidIndex1, AliRsnEvent *const ev1, AliRsnPIDIndex *const pidIndex2, AliRsnEvent *const ev2)
 {
 //
 // Prepare the loop for computation of functions.
@@ -136,17 +139,14 @@ void AliRsnPair::LoopPair
   TArrayI *a1 = 0;
   TArrayI *a2 = 0;
 
-  if (fPIDMethod == AliRsnDaughter::kNoPID)
-  {
+  if (fPIDMethod == AliRsnDaughter::kNoPID) {
     AliDebug(AliLog::kDebug+2, Form("Returning indexes of with NO PID (%d) ...", fPIDMethod));
     a1 = pidIndex1->GetTracksArray(fPIDMethod, fPairDef->GetCharge(0), AliPID::kUnknown);
     if (pidIndex2 && ev2)
       a2 = pidIndex2->GetTracksArray(fPIDMethod, fPairDef->GetCharge(1), AliPID::kUnknown);
     else
       a2 = pidIndex1->GetTracksArray(fPIDMethod, fPairDef->GetCharge(1), AliPID::kUnknown);
-  }
-  else
-  {
+  } else {
     AliDebug(AliLog::kDebug+2, Form("Returning indexes of with PID (%d) ...", fPIDMethod));
     a1 = pidIndex1->GetTracksArray(fPIDMethod,fPairDef->GetCharge(0), (AliPID::EParticleType)fPairDef->GetType(0));
     if (pidIndex2 && ev2)
@@ -175,19 +175,20 @@ void AliRsnPair::LoopPair(TArrayI *a1, TArrayI *a2, AliRsnEvent *ev1, AliRsnEven
 
   if (!ev2) {
     if (fIsMixed) {
-      AliDebug(AliLog::kDebug, "ev2 is null and fIsMixed is true. Skipping ...");
+      AliDebug(AliLog::kDebug+1, "ev2 is null and fIsMixed is true. Skipping ...");
       return;
     }
     ev2 = ev1;
   }
 
-  if (!a1) {AliDebug(AliLog::kDebug, "No TArrayI 1 from currentEvent->GetTracksArray(...)"); return;}
-  if (!a2) {AliDebug(AliLog::kDebug, "No TArrayI 2 from currentEvent->GetTracksArray(...)"); return;}
+  if (!a1) {AliDebug(AliLog::kDebug+1, "No TArrayI 1 from currentEvent->GetTracksArray(...)"); return;}
+  if (!a2) {AliDebug(AliLog::kDebug+1, "No TArrayI 2 from currentEvent->GetTracksArray(...)"); return;}
 
   AliDebug(AliLog::kDebug+1,Form("a1=%d a2=%d",a1->GetSize(),a2->GetSize()));
-  if (a1->GetSize()<=0) {AliDebug(AliLog::kDebug, "Size of TArrayI 1 is 0 or less ..."); return;}
-  if (a2->GetSize()<=0) {AliDebug(AliLog::kDebug, "Size of TArrayI 2 is 0 or less ..."); return;}
+  if (a1->GetSize()<=0) {AliDebug(AliLog::kDebug+1, "Size of TArrayI 1 is 0 or less ..."); return;}
+  if (a2->GetSize()<=0) {AliDebug(AliLog::kDebug+1, "Size of TArrayI 2 is 0 or less ..."); return;}
 
+  AliDebug(AliLog::kDebug,Form("Indexes_a1=%d Indexes_a2=%d",a1->GetSize(),a2->GetSize()));
 
   // cuts on events
   if (!CutPass(ev1) || !CutPass(ev2)) return;
@@ -223,16 +224,23 @@ void AliRsnPair::LoopPair(TArrayI *a1, TArrayI *a2, AliRsnEvent *ev1, AliRsnEven
       AliDebug(AliLog::kDebug+1,"daughter2 cut passed ...");
       // make pair
       fPairParticle.SetPair(&fTrack1, &fTrack2);
-
+      // in case of request, check that it is true pair
+      if (fOnlyTrue)
+      {
+        if (fPairParticle.CommonMother() != fPairDef->GetMotherPDG()) continue;
+        if (fPairParticle.GetDaughter(0)->PerfectPID() != fPairDef->GetType(0)) continue;
+        if (fPairParticle.GetDaughter(1)->PerfectPID() != fPairDef->GetType(1)) continue;
+      }
       // cuts on pair
       if (!CutPass(&fPairParticle)) continue;
       AliDebug(AliLog::kDebug+1, "pairParticle cut passed");
 
-//       fPairParticle.PrintInfo();
+      if (AliLog::GetDebugLevel("",GetName()) == AliLog::kDebug)
+        fPairParticle.PrintInfo();
 
       // fill all histograms
       TObjArrayIter nextFcn(&fFunctions);
-      while ( (fcn = (AliRsnFunction*)nextFcn()) ) {
+      while ((fcn = (AliRsnFunction*)nextFcn())) {
         fcn->SetPairDef(fPairDef);
         fcn->SetPair(&fPairParticle);
         fcn->SetEvent(ev1);
@@ -254,10 +262,10 @@ TList * AliRsnPair::GenerateHistograms(TString prefix,TList *list)
 // All generated histograms are stored into the output TList.
 //
   AliDebug(AliLog::kDebug+2,"<-");
-  if (!list){
-    TList *list = new TList();
-    list->SetName(GetPairHistName(0x0).Data());
-  }
+//   if (!list){
+//     TList *list = new TList();
+//     list->SetName(GetPairHistName(0x0).Data());
+//   }
   Char_t hName[255], hTitle[255];
   //AliRsnFunction *fcn = 0;
   AliRsnFunction *fcn = 0;
@@ -270,8 +278,8 @@ TList * AliRsnPair::GenerateHistograms(TString prefix,TList *list)
     //histos->Print();
     //list->Add(histos);
   }
-  cout << "PRINTING LIST" << endl;
-  list->Print();
+//   cout << "PRINTING LIST" << endl;
+//   list->Print();
   AliDebug(AliLog::kDebug+2,"->");
   return list;
 }
@@ -287,15 +295,15 @@ TString AliRsnPair::GetPairTypeName(EPairType type) const
   AliDebug(AliLog::kDebug+2,"<-");
   AliDebug(AliLog::kDebug+2,"->");
   switch (type) {
-    case kNoPID : return ("NOPID_");break;
-    case kNoPIDMix : return ("NOPIDMIX_");break;
-    case kRealisticPID : return ("REALISTIC_");break;
-    case kRealisticPIDMix : return ("REALISTICMIX_");break;
-    case kPerfectPID : return ("PERFECT_");break;
-    case kPerfectPIDMix : return ("PERFECTMIX_");break;
-    default:
-      AliWarning("Unrecognized value of EPairTypeName argument");
-      break;
+  case kNoPID : return ("NOPID_");break;
+  case kNoPIDMix : return ("NOPIDMIX_");break;
+  case kRealisticPID : return ("REALISTIC_");break;
+  case kRealisticPIDMix : return ("REALISTICMIX_");break;
+  case kPerfectPID : return ("PERFECT_");break;
+  case kPerfectPIDMix : return ("PERFECTMIX_");break;
+  default:
+    AliWarning("Unrecognized value of EPairTypeName argument");
+    break;
   }
 
   return "NOTYPE";
@@ -316,7 +324,7 @@ TString AliRsnPair::GetPairName() const
 }
 
 //_____________________________________________________________________________
-TString AliRsnPair::GetPairHistName(AliRsnFunction *fcn, TString text) const
+TString AliRsnPair::GetPairHistName(AliRsnFunction *const fcn, TString text) const
 {
 //
 // Returns definitive histogram name
@@ -336,7 +344,7 @@ TString AliRsnPair::GetPairHistName(AliRsnFunction *fcn, TString text) const
 }
 
 //_____________________________________________________________________________
-TString AliRsnPair::GetPairHistTitle(AliRsnFunction *fcn, TString text) const
+TString AliRsnPair::GetPairHistTitle(AliRsnFunction *const fcn, TString text) const
 {
 //
 // Returns definitive histogram title
@@ -356,14 +364,14 @@ TString AliRsnPair::GetPairHistTitle(AliRsnFunction *fcn, TString text) const
 }
 
 //_____________________________________________________________________________
-void AliRsnPair::AddFunction(AliRsnFunction *fcn)
+void AliRsnPair::AddFunction(AliRsnFunction *const fcn)
 {
 //
 // Adds a new computing function
 //
   AliDebug(AliLog::kDebug+2,"<-");
   Int_t size = fFunctions.GetEntries();
-  new (fFunctions[size]) AliRsnFunction(*fcn);
+  new(fFunctions[size]) AliRsnFunction(*fcn);
   AliDebug(AliLog::kDebug+2,"->");
 }
 
index c5507923f61e40c8eee079607e8a9dd4a80a2b06..d4b4e95b7d11d073ea7f895e3bdd63e5ec1d42da 100644 (file)
 #ifndef ALIRSNPAIR_H
 #define ALIRSNPAIR_H
 
-#include "TH1.h"
-#include "TH2.h"
-#include "TList.h"
-#include "TArrayI.h"
 #include "TClonesArray.h"
 
 #include "AliRsnDaughter.h"
 #include "AliRsnPairDef.h"
 #include "AliRsnPairParticle.h"
-#include "AliRsnEvent.h"
-#include "AliRsnCutMgr.h"
-#include "AliRsnPIDIndex.h"
 
+class TH1;
+class TH2;
+class TList;
+class TArrayI;
+
+class AliRsnEvent;
+class AliRsnCutMgr;
+class AliRsnPIDIndex;
 class AliRsnFunction;
 
 class AliRsnPair : public TObject
 {
   public:
 
-    enum EPairType
-    {
+    enum EPairType {
       kNoPID = 0,    kNoPIDMix,
       kRealisticPID, kRealisticPIDMix,
       kPerfectPID,   kPerfectPIDMix,
@@ -40,27 +40,31 @@ class AliRsnPair : public TObject
     AliRsnPair(EPairType type = kRealisticPID, AliRsnPairDef *def = 0);
     ~AliRsnPair();
 
+    void    SetOnlyTrue(Bool_t onlyTrue = kTRUE) {fOnlyTrue = onlyTrue;}
+
     void    Print(Option_t *option = "") const;
-    void    LoopPair(AliRsnPIDIndex *pidIndex1, AliRsnEvent *ev1, AliRsnPIDIndex *pidIndex2 = 0, AliRsnEvent *ev2 = 0);
+    void    LoopPair(AliRsnPIDIndex*const pidIndex1, AliRsnEvent*const ev1, AliRsnPIDIndex*const pidIndex2 = 0, AliRsnEvent* ev2 = 0);
     void    LoopPair(TArrayI *a1, TArrayI *a2, AliRsnEvent *ev1, AliRsnEvent *ev2 = 0);
-    void    SetCutMgr(AliRsnCutMgr* theValue) { fCutMgr = theValue; }
-    void    AddFunction(AliRsnFunction *fcn);
+    void    SetCutMgr(AliRsnCutMgr* const mgr) { fCutMgr = mgr; }
+    void    AddFunction(AliRsnFunction*const fcn);
     TList*  GenerateHistograms(TString prefix = "", TList *list=0);
 
-    Bool_t  IsMixed() {return fIsMixed;}
-    Bool_t  IsPairEqual() {if (fPIDMethod == AliRsnDaughter::kNoPID) return (fPairDef->IsLikeSign());
-                           else return (fPairDef->IsLikeSign() && fPairDef->HasEqualTypes());}
+    Bool_t  IsMixed() const {return fIsMixed;}
+    Bool_t  IsPairEqual() const {
+      if (fPIDMethod == AliRsnDaughter::kNoPID) return (fPairDef->IsLikeSign());
+      else return (fPairDef->IsLikeSign() && fPairDef->HasEqualTypes());
+    }
 
     TString GetPairTypeName(EPairType type) const;
     TString GetPairName() const;
-    TString GetPairHistName(AliRsnFunction *fcn, TString text = "") const;
-    TString GetPairHistTitle(AliRsnFunction *fcn, TString text = "") const;
+    TString GetPairHistName(AliRsnFunction *const fcn, TString text = "") const;
+    TString GetPairHistTitle(AliRsnFunction *const fcn, TString text = "") const;
 
   private:
 
-    AliRsnPair (const AliRsnPair &copy) : TObject(copy),
-      fIsMixed(kFALSE),fPairType(kPairTypes),fPIDMethod(AliRsnDaughter::kRealistic),
-      fPairDef(0x0),fCutMgr(0x0),fFunctions("AliRsnFunction",0),fTrack1(),fTrack2(),fPairParticle() {}
+    AliRsnPair(const AliRsnPair &copy) : TObject(copy),
+        fIsMixed(kFALSE),fPairType(kPairTypes),fPIDMethod(AliRsnDaughter::kRealistic),
+        fPairDef(0x0),fCutMgr(0x0),fFunctions("AliRsnFunction",0),fTrack1(),fTrack2(),fPairParticle() {}
     AliRsnPair& operator=(const AliRsnPair&) {return *this;}
 
     void     SetUp(EPairType type);
@@ -70,6 +74,7 @@ class AliRsnPair : public TObject
     Bool_t   CutPass(AliRsnPairParticle *p);
     Bool_t   CutPass(AliRsnEvent *e);
 
+    Bool_t                      fOnlyTrue;       // select true pairs only?
     Bool_t                      fIsMixed;        // doing event-mixing ?
     EPairType                   fPairType;       // pair type (PID + mixing or not)
     AliRsnDaughter::EPIDMethod  fPIDMethod;      // pid type variable for single track
@@ -81,7 +86,7 @@ class AliRsnPair : public TObject
     AliRsnDaughter              fTrack2;         // track #2 (internal loop)
     AliRsnPairParticle          fPairParticle;   // track pair
 
-    ClassDef (AliRsnPair, 2)
+    ClassDef(AliRsnPair, 2)
 };
 
 #endif
index 6a02d34efcff33b8b1d64c02bf207949bfe0bf66..1ebf7d19e3d22b3bab0ae501deb46612d78da73a 100644 (file)
@@ -9,10 +9,7 @@
 // author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
-#include <Riostream.h>
-
 #include "AliLog.h"
-#include "AliRsnDaughter.h"
 #include "AliRsnPairDef.h"
 
 ClassImp(AliRsnPairDef)
@@ -30,8 +27,7 @@ AliRsnPairDef::AliRsnPairDef() : fMotherPDG(0)
 //
 
   Int_t i;
-  for (i = 0; i < 2; i++)
-  {
+  for (i = 0; i < 2; i++) {
     fCharge[i] = '0';
     fMass[i] = 0.0;
     fType[i] = AliPID::kUnknown;
@@ -100,18 +96,15 @@ Bool_t AliRsnPairDef::SetPairElement(Int_t i, Char_t charge, AliPID::EParticleTy
 
   AliPID pid;
 
-  if (i < 0 || i > 1)
-  {
+  if (i < 0 || i > 1) {
     AliError("Index out of range");
     return kFALSE;
   }
-  if (charge != '+' && charge != '-')
-  {
+  if (charge != '+' && charge != '-') {
     AliError(Form("Character '%c' not recognized as charge sign"));
     return kFALSE;
   }
-  if (type < 0 && type > (Int_t)AliPID::kSPECIES)
-  {
+  if (type < 0 && type > (Int_t)AliPID::kSPECIES) {
     AliError("Type index out of enumeration range");
     return kFALSE;
   }
@@ -137,7 +130,7 @@ Bool_t AliRsnPairDef::SetPair
 }
 
 //_____________________________________________________________________________
-TString AliRsnPairDef::GetPairName()
+TString AliRsnPairDef::GetPairName() const
 {
 //
 // Returns a compact string with the name of the pair,
index eaf691c09b538445f83ece6e37c9e0757e865f36..8fe1e7d6c29d0cebc4ea2f0a02693ae49bd4177f 100644 (file)
@@ -12,8 +12,6 @@
 #ifndef ALIRSNPAIRDEF_H
 #define ALIRSNPAIRDEF_H
 
-#include <TString.h>
-
 #include "AliPID.h"
 
 class AliRsnDaughter;
@@ -33,10 +31,11 @@ class AliRsnPairDef : public TObject
 
     // getters
     Char_t                GetCharge(Int_t i) const {if (i>=0&&i<2) return fCharge[i]; else return 0;}
+    Short_t               GetChargeShort(Int_t i) const {if (GetCharge(i) == '+') return 1; else if (GetCharge(i) == '-') return -1; else return 0;}
     AliPID::EParticleType GetType(Int_t i) const {if (i>=0&&i<2) return fType[i]; else return AliPID::kUnknown;}
     Double_t              GetMass(Int_t i) const {if (i>=0&&i<2) return fMass[i]; else return 0.0;}
     Int_t                 GetMotherPDG() const {return fMotherPDG;}
-    TString               GetPairName();
+    TString               GetPairName() const;
 
     // setters
     Bool_t SetPairElement(Int_t i, Char_t charge, AliPID::EParticleType pid);
@@ -44,8 +43,8 @@ class AliRsnPairDef : public TObject
     void   SetMotherPDG(Int_t pdg) {fMotherPDG = pdg;}
 
     // pair information methods
-    Bool_t IsLikeSign() {return (fCharge[0] == fCharge[1]);}
-    Bool_t HasEqualTypes() {return (fType[0] == fType[1]);}
+    Bool_t IsLikeSign() const {return (fCharge[0] == fCharge[1]);}
+    Bool_t HasEqualTypes() const {return (fType[0] == fType[1]);}
 
   private:
 
index a97a8c6134f4b26d9cb7ead070ff814aa1328395..6eaa8117d6c3fbb30393b0b08eb7b39b00ede0b6 100644 (file)
@@ -13,6 +13,7 @@
 //
 
 #include "AliLog.h"
+#include "AliRsnPair.h"
 
 #include "AliRsnPairManager.h"
 
@@ -20,7 +21,7 @@ ClassImp(AliRsnPairManager)
 
 //_____________________________________________________________________________
 AliRsnPairManager::AliRsnPairManager(const char*name) :
-  AliRsnVManager(name)
+    AliRsnVManager(name)
 {
 //
 // Default constructor
@@ -31,8 +32,7 @@ AliRsnPairManager::AliRsnPairManager(const char*name) :
 }
 
 //_____________________________________________________________________________
-//void AliRsnPairManager::Add(AliRsnPair *pair)
-void AliRsnPairManager::Add(TObject *objPair)
+void AliRsnPairManager::Add(TObject* objPair)
 {
 //
 // Adds a new AliRsnPair to the list owned by this object.
@@ -52,6 +52,17 @@ void AliRsnPairManager::Add(TObject *objPair)
   AliDebug(AliLog::kDebug+2, "->");
 }
 
+//_____________________________________________________________________________
+void AliRsnPairManager::AddPair(AliRsnPair* pair)
+{
+//
+// Adds a new AliRsnPair to the list owned by this object.
+//
+
+  Add(pair);
+}
+
+
 //_____________________________________________________________________________
 void AliRsnPairManager::Print(Option_t* /*dummy*/) const
 {
@@ -85,7 +96,7 @@ void AliRsnPairManager::PrintArray() const
 }
 
 //_____________________________________________________________________________
-TList* AliRsnPairManager::InitAllPairs()
+void AliRsnPairManager::InitAllPairs(TList* list)
 {
 //
 // Initialize all pairs, and builds a TList of histograms
@@ -95,9 +106,9 @@ TList* AliRsnPairManager::InitAllPairs()
 
   AliDebug(AliLog::kDebug+2, "<-");
 
-  TList *list = new TList();
-  list->SetName(GetName());
-  list->SetOwner();
+//   TList *list = new TList();
+//   list->SetName(GetName());
+//   list->SetOwner();
 
   AliRsnPair *pair = 0;
   TObjArrayIter next(&fArray);
@@ -110,7 +121,7 @@ TList* AliRsnPairManager::InitAllPairs()
   }
 
   AliDebug(AliLog::kDebug+2, "->");
-  return list;
+//   return list;
 }
 
 //_____________________________________________________________________________
index b62b7f6a96c3d894f6cbd298b47a9e0618bd94b9..a7cb15bf0cf00a8828ab38d3d4b6d67a5d82d2d1 100644 (file)
 // author: M. Vala (email: martin.vala@cern.ch)
 //
 
-#ifndef AliRsnPairManager_H
-#define AliRsnPairManager_H
-
-#include <TList.h>
-
+#ifndef ALIRSNPAIRMANAGER_H
+#define ALIRSNPAIRMANAGER_H
+// #include <TObject.h>
 #include "AliRsnVManager.h"
-#include "AliRsnPair.h"
 
+class TList;
+
+class AliRsnPair;
+class AliRsnPairManager;
+class AliRsnPIDIndex;
+class AliRsnEvent;
 class AliRsnPairManager : public AliRsnVManager
 {
   public:
 
     AliRsnPairManager(const char *name = "defaultPairMgr");
+    virtual ~AliRsnPairManager() {;};
 
     //virtual void   Add(AliRsnPair *pair);
     virtual void   Add(TObject *pair);
-    virtual void   AddPair(AliRsnPair *pair) {Add(pair);}
+    virtual void   AddPair(AliRsnPair *pair);
     virtual void   PrintArray() const;
     virtual void   Print(Option_t *option = "") const;
 
-            TList* InitAllPairs();
-            void   ProcessAllPairs(AliRsnPIDIndex *pidIndexes1, AliRsnEvent *ev1, AliRsnPIDIndex *pidIndexes2 = 0, AliRsnEvent *ev2 = 0);
+    void   InitAllPairs(TList* list);
+    void   ProcessAllPairs(AliRsnPIDIndex *pidIndexes1, AliRsnEvent *ev1, AliRsnPIDIndex *pidIndexes2 = 0, AliRsnEvent *ev2 = 0);
 
   private:
 
index 1a26990bef20c6909145ed20179bcdc9009b024e..ca77148ea84fd9c9616dbeb1c2ae4f7001df0a4b 100644 (file)
 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
-#include <TParticle.h>
-
-#include "AliLog.h"
-#include "AliRsnDaughter.h"
+#include "AliRsnPairDef.h"
 #include "AliRsnPairParticle.h"
 
 ClassImp(AliRsnPairParticle)
@@ -265,7 +262,7 @@ Int_t AliRsnPairParticle::CommonMother()
 }
 
 //_____________________________________________________________________________
-void AliRsnPairParticle::SetPair(AliRsnDaughter *daughter1, AliRsnDaughter *daughter2)
+void AliRsnPairParticle::SetPair(AliRsnDaughter * const daughter1, AliRsnDaughter * const daughter2)
 {
 //
 // Accepts two AliRsnDaughter's which are the two tracks in the pair,
@@ -380,3 +377,37 @@ void AliRsnPairParticle::PrintInfo(const Option_t *option)
   fDaughter[1]->Print(option);
   AliInfo("========= END PAIR INFO ===========");
 }
+
+//_____________________________________________________________________________
+Bool_t AliRsnPairParticle::MatchesDef(AliRsnPairDef *def)
+{
+//
+// Checks if the daughters, in any order, do match a given decay channel,
+// using the specified identification method, which can be the 'true' one
+// or the 'realistic' one only.
+//
+
+  if (!def) return kFALSE;
+
+  Bool_t decayMatch = kFALSE;
+
+  // check #1:
+  // daughter[0] matches first member of pairDef
+  // daughter[1] matches second member of pairDef
+  if (fDaughter[0]->IsSign(def->GetCharge(0)) && fDaughter[1]->IsSign(def->GetCharge(1))) {
+    decayMatch = (fDaughter[0]->IsPerfectPID(def->GetType(0)) && fDaughter[1]->IsPerfectPID(def->GetType(1)));
+    fDaughter[0]->SetRequiredPID(def->GetType(0));
+    fDaughter[1]->SetRequiredPID(def->GetType(1));
+  }
+
+  // check #2:
+  // daughter[1] matches first member of pairDef
+  // daughter[0] matches second member of pairDef
+  if (fDaughter[1]->IsSign(def->GetCharge(0)) && fDaughter[0]->IsSign(def->GetCharge(1))) {
+    decayMatch = (fDaughter[1]->IsPerfectPID(def->GetType(0)) && fDaughter[0]->IsPerfectPID(def->GetType(1)));
+    fDaughter[1]->SetRequiredPID(def->GetType(0));
+    fDaughter[0]->SetRequiredPID(def->GetType(1));
+  }
+
+  return (decayMatch && (CommonMother() == def->GetMotherPDG()));
+}
index 05cc02a08a99f77a65bfbe35a938ee5bfd8d4502..6c1f9df7f24edbb1484af53e53fb7525dbfafdf0 100644 (file)
@@ -17,6 +17,8 @@
 
 #include "AliRsnDaughter.h"
 
+class AliRsnPairDef;
+
 class AliRsnPairParticle : public TObject
 {
   public:
@@ -38,9 +40,11 @@ class AliRsnPairParticle : public TObject
     Double_t          GetPz() const {return fPTot[2];}
     Double_t          GetPt() const {return TMath::Sqrt(GetPt2());}
     Double_t          GetPhi() const {return TMath::Pi() + TMath::ATan2(-fPTot[1], -fPTot[0]);}
-    Double_t          GetTheta() const {if (fPTot[2]==0.0){return TMath::PiOver2();}
-      else{return TMath::ACos(fPTot[2]/GetP());}}
-    Double_t          GetEta() const {return -TMath::Log(TMath::Tan(0.5*GetTheta()));}
+    Double_t          GetTheta() const {
+      if (fPTot[2]==0.0) {return TMath::PiOver2();}
+      else {return TMath::ACos(fPTot[2]/GetP());}
+    }
+    Double_t          GetEta() const {Double_t a = TMath::Tan(0.5*GetTheta()); if (a > 0.) return -TMath::Log(a); return 999999.0;}
     Double_t          GetY(Double_t m1, Double_t m2) const {return 0.5*TMath::Log((GetEtot(m1,m2)+fPTot[2])/(GetEtot(m1,m2)-fPTot[2]));}
 
     Double_t          GetEtotMC(Double_t m1, Double_t m2) const;
@@ -52,8 +56,10 @@ class AliRsnPairParticle : public TObject
     Double_t          GetPzMC() const {return fPTotMC[2];}
     Double_t          GetPtMC() const {return TMath::Sqrt(GetPt2MC());}
     Double_t          GetPhiMC() const {return TMath::Pi() + TMath::ATan2(-fPTotMC[1], -fPTotMC[0]);}
-    Double_t          GetThetaMC() const {if (fPTotMC[2]==0.0){return TMath::PiOver2();}
-      else{return TMath::ACos(fPTotMC[2]/GetPMC());}}
+    Double_t          GetThetaMC() const {
+      if (fPTotMC[2]==0.0) {return TMath::PiOver2();}
+      else {return TMath::ACos(fPTotMC[2]/GetPMC());}
+    }
     Double_t          GetEtaMC() const {return -TMath::Log(TMath::Tan(0.5*GetThetaMC()));}
     Double_t          GetYMC(Double_t m1, Double_t m2) const {return 0.5*TMath::Log((GetEtotMC(m1,m2)+fPTotMC[2])/(GetEtotMC(m1,m2)-fPTotMC[2]));}
 
@@ -66,10 +72,11 @@ class AliRsnPairParticle : public TObject
     Bool_t            IsTruePair(Int_t refPDG = 0);
     Int_t             CommonMother();
 
-    void              SetPair(AliRsnDaughter *daughter1, AliRsnDaughter *daughter2);
+    void              SetPair(AliRsnDaughter * const daughter1, AliRsnDaughter * const daughter2);
     void              ResetPair();
     void              RotateTrack(Int_t i, Double_t angle, Bool_t isDegrees = kTRUE);
     void              PrintInfo(const Option_t *option = "ALL");
+    Bool_t            MatchesDef(AliRsnPairDef *def);
 
   private:
 
index a827f4954be90cd48a553e28d127188399d1e10f..215bc62a36dc92d23bf8e0e52176e4896fc07f2c 100644 (file)
@@ -2,6 +2,7 @@
 // *** Class AliRsnVATProcessInfo ***
 //
 //  TODO
+//  TODO
 //
 // authors: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it)
 //          M. Vala (email: martin.vala@cern.ch)
 ClassImp(AliRsnVATProcessInfo)
 
 //_____________________________________________________________________________
-AliRsnVATProcessInfo::AliRsnVATProcessInfo(const char *name) : TNamed(name,name),
-        fHistUsedEvents(0x0),
-        fNumOfTracks(0),
-        fPrintInfoNumber(1000)
+AliRsnVATProcessInfo::AliRsnVATProcessInfo(const char *name) :
+    TNamed(name,name),
+    fHistUsedEvents(0x0),
+    fEventUsed(kFALSE),
+    fPrintInfoNumber(1000)
 {
-    AliDebug(AliLog::kDebug+2,"<-");
-    AliDebug(AliLog::kDebug+2,"->");
+//
+// Constructor.
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  AliDebug(AliLog::kDebug+2,"->");
 }
 
 //_____________________________________________________________________________
-AliRsnVATProcessInfo::AliRsnVATProcessInfo(const AliRsnVATProcessInfo& copy) : TNamed(copy),
-        fHistUsedEvents(copy.fHistUsedEvents),
-        fNumOfTracks(copy.fNumOfTracks),
-        fPrintInfoNumber(copy.fPrintInfoNumber)
-
+AliRsnVATProcessInfo::AliRsnVATProcessInfo(const AliRsnVATProcessInfo& copy) :
+    TNamed(copy),
+    fHistUsedEvents(copy.fHistUsedEvents),
+    fEventUsed(copy.fEventUsed),
+    fPrintInfoNumber(copy.fPrintInfoNumber)
 {
-    AliDebug(AliLog::kDebug+2,"<-");
-    AliDebug(AliLog::kDebug+2,"->");
+//
+// Copy constructor.
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  AliDebug(AliLog::kDebug+2,"->");
 }
 
 //_____________________________________________________________________________
 AliRsnVATProcessInfo::~AliRsnVATProcessInfo()
 {
-    AliDebug(AliLog::kDebug+2,"<-");
-    AliDebug(AliLog::kDebug+2,"->");
+//
+// Destructor.
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
+  AliDebug(AliLog::kDebug+2,"->");
 }
 
-TList* AliRsnVATProcessInfo::GenerateInfoList() {
-    AliDebug(AliLog::kDebug+2,"<-");
+//_____________________________________________________________________________
+void AliRsnVATProcessInfo::GenerateInfoList(TList *list)
+{
+//
+// Creates a TList containing all objects created in this class.
+// This list will be passe to the AnalysisTask object and will generate
+// a separate directory in the output file, with these informations.
+// This TList will have the same name of this object and will own its content.
+//
+
+  AliDebug(AliLog::kDebug+2,"<-");
 
-    AliDebug(AliLog::kWarning,"Doing new TList(), so make sure you delete this list ... ");
+  // create list
+  AliDebug(AliLog::kWarning,"Doing new TList(), so make sure you delete this list ... ");
+//   TList* list = new TList();
+//   list->SetName(GetName());
+//   list->SetOwner();
 
-    TList* list = new TList();
-    list->SetName(GetName());
-    list->SetOwner();
+  // initialize contained objects
+  fHistUsedEvents = new TH1I(GetEventHistogramName(), "Skipped/used events", 2, 0, 2);
 
-    fHistUsedEvents = new TH1I(GetEventHistogramName(), "skipped and used events in this analysis", 2, 0, 2);
-    list->Add(fHistUsedEvents);
+  // ad objects to list
+  list->Add(fHistUsedEvents);
 
-    AliDebug(AliLog::kDebug+2,"->");
-    return list;
+  AliDebug(AliLog::kDebug+2,"->");
 }
 
-void AliRsnVATProcessInfo::FillInfo() {
-    if (!fNumOfTracks)
-        fHistUsedEvents->Fill(fNumOfTracks);
-    else
-        fHistUsedEvents->Fill(1);
+//_____________________________________________________________________________
+void AliRsnVATProcessInfo::FillInfo()
+{
+//
+// This method defines how the information histograms must be filled.
+// The structure of this class is auto-consistend, but in case of inheritance
+// this method must be modified accordingly.
+// Current implementation uses the 'fEventUsed' flag to choose if the event
+// has been used or not, and increments the corrisponding bin in the related
+// histogram (bin '0' = skipped, bin '1' = used).
+//
+
+  if (fEventUsed)
+    fHistUsedEvents->Fill(1);
+  else
+    fHistUsedEvents->Fill(0);
+}
+
+//_____________________________________________________________________________
+void AliRsnVATProcessInfo::PrintInfo(const Long64_t &num)
+{
+//
+// This method is used in some cases
+// to inform about number of events processed
+//
+
+  if ((num+1) % fPrintInfoNumber == 0) AliInfo(Form("Events processed %d",num+1));
 }
 
-void AliRsnVATProcessInfo::PrintInfo(const Long64_t &num) {
-  if ((num+1)%fPrintInfoNumber == 0){
-    AliInfo(Form("Events processed %d",num+1));
-  }
 
+Long64_t AliRsnVATProcessInfo::GetNumerOfEventsProcessed()
+{
+//
+// returns number of events from histogram
+//
+  if (fHistUsedEvents)
+    return fHistUsedEvents->Integral();
+  return 0;
 }
 
index 8ae1f738c93d7cf12566ae86db54e23b104aec83..896efbcdf1143f2f9938410de027df697ffc6a91 100644 (file)
@@ -7,37 +7,35 @@
 //          M. Vala (email: martin.vala@cern.ch)
 //
 
-#ifndef AliRsnVATProcessInfo_H
-#define AliRsnVATProcessInfo_H
+#ifndef ALIRSNVATPROCESSINFO_H
+#define ALIRSNVATPROCESSINFO_H
 
 #include <TNamed.h>
-#include <TH1.h>
+class TH1I;
 
 class AliRsnVATProcessInfo : public TNamed
 {
-public:
-    AliRsnVATProcessInfo(const char*name="AT_RSNInfo");
+  public:
+    AliRsnVATProcessInfo(const char*name = "AT_RSNInfo");
     AliRsnVATProcessInfo(const AliRsnVATProcessInfo& copy);
-    AliRsnVATProcessInfo& operator= (const AliRsnVATProcessInfo& /*copy*/) {
-        return *this;
-    }
+    AliRsnVATProcessInfo& operator= (const AliRsnVATProcessInfo& /*copy*/) {return *this;}
     ~AliRsnVATProcessInfo();
 
-    TList* GenerateInfoList();
+    void         GenerateInfoList(TList* list);
     virtual void FillInfo();
     virtual void PrintInfo(const Long64_t &num);
 
-    void SetNumberOfTracks(const Int_t & num) { fNumOfTracks = num; }
-    Int_t GetNumberOfTracks() { return fNumOfTracks; };
-
     const char* GetEventHistogramName() { return Form("hEventsUsed_%s",GetName()); };
+    Long64_t    GetNumerOfEventsProcessed();
+    void        SetEventUsed(Bool_t isUsed = kTRUE) { fEventUsed = isUsed; }
+    Bool_t      IsEventUsed() const { return fEventUsed; };
 
-    void SetPrintInfoNumber(const Long64_t &num=1) { fPrintInfoNumber = num; }
+    void        SetPrintInfoNumber(const Long64_t &num=1) { fPrintInfoNumber = num; }
 
-private:
+  private:
 
     TH1I         *fHistUsedEvents;
-    Int_t         fNumOfTracks;
+    Int_t         fEventUsed;
 
     Long64_t      fPrintInfoNumber;
 
index 7f5297bfca37d93b204c3555adc55c2f0711070a..46bbb4c4dc0b088263a380006632212d225bcf06 100644 (file)
@@ -8,8 +8,7 @@
 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
-// #include "AliAnalysisManager.h"
-// #include "AliAODHandler.h"
+#include <TH1.h>
 
 #include "AliESDEvent.h"
 #include "AliMCEvent.h"
@@ -59,7 +58,7 @@ void AliRsnVAnalysisTaskME::LocalInit()
 //
   AliLog::SetClassDebugLevel(GetName(), fLogType);
   SetDebugForOtherClasses();
-  
+
   AliDebug(AliLog::kDebug+2,"<-");
   AliAnalysisTaskME::LocalInit();
   AliDebug(AliLog::kDebug+2,"->");
@@ -80,6 +79,10 @@ Bool_t AliRsnVAnalysisTaskME::Notify()
 //_____________________________________________________________________________
 void AliRsnVAnalysisTaskME::ConnectInputData(Option_t *opt)
 {
+//
+// TODO
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
   AliAnalysisTaskME::ConnectInputData(opt);
 
@@ -109,6 +112,10 @@ void AliRsnVAnalysisTaskME::ConnectInputData(Option_t *opt)
 //_____________________________________________________________________________
 void AliRsnVAnalysisTaskME::RsnUserCreateOutputObjects()
 {
+//
+// TODO
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
 
   AliDebug(AliLog::kDebug+2,"->");
@@ -118,17 +125,21 @@ void AliRsnVAnalysisTaskME::RsnUserCreateOutputObjects()
 //_____________________________________________________________________________
 void AliRsnVAnalysisTaskME::UserCreateOutputObjects()
 {
+//
+// TODO
+//
+
   AliLog::SetClassDebugLevel(GetName(), fLogType);
-  
+
   SetDebugForOtherClasses();
-  
+
   AliDebug(AliLog::kDebug+2,"<-");
 
   fOutList = new TList();
   fOutList->SetOwner();
 
-  fOutList->Add(fTaskInfo.GenerateInfoList());
-
+//   fOutList->Add();
+  fTaskInfo.GenerateInfoList(fOutList);
   RsnUserCreateOutputObjects();
 
   AliDebug(AliLog::kDebug+2,"<-");
@@ -137,6 +148,9 @@ void AliRsnVAnalysisTaskME::UserCreateOutputObjects()
 //_____________________________________________________________________________
 void AliRsnVAnalysisTaskME::UserExec(Option_t* opt)
 {
+//
+// TODO
+//
 
   AliDebug(AliLog::kDebug+2,"<-");
 
@@ -152,8 +166,12 @@ void AliRsnVAnalysisTaskME::UserExec(Option_t* opt)
 }
 
 //_____________________________________________________________________________
-void AliRsnVAnalysisTaskME::RsnUserExec(Option_t* )
+void AliRsnVAnalysisTaskME::RsnUserExec(Option_t*)
 {
+//
+// TODO
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
 //     if (fESDEvent) {
 //         AliDebug(AliLog::kDebug+1,Form("fESDEvent if %p",fESDEvent));
@@ -179,6 +197,10 @@ void AliRsnVAnalysisTaskME::RsnUserExec(Option_t* )
 //_____________________________________________________________________________
 void AliRsnVAnalysisTaskME::Terminate(Option_t* opt)
 {
+//
+// TODO
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
   AliAnalysisTask::Terminate();
 
@@ -190,9 +212,7 @@ void AliRsnVAnalysisTaskME::Terminate(Option_t* opt)
 
   RsnTerminate(opt);
 
-  TList* lEventInfo = (TList*) fOutList->FindObject(fTaskInfo.GetName());
-
-  TH1I *hEventInfo = (TH1I*) lEventInfo->FindObject(fTaskInfo.GetEventHistogramName());
+  TH1I *hEventInfo = (TH1I*) fOutList->FindObject(fTaskInfo.GetEventHistogramName());
   if (!hEventInfo) {
     AliError(Form("hEventInfo is %p",hEventInfo));
     return;
@@ -208,8 +228,12 @@ void AliRsnVAnalysisTaskME::Terminate(Option_t* opt)
 }
 
 //_____________________________________________________________________________
-void AliRsnVAnalysisTaskME::RsnTerminate(Option_t* )
+void AliRsnVAnalysisTaskME::RsnTerminate(Option_t*)
 {
+//
+// TODO
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
   AliDebug(AliLog::kDebug+2,"->");
 }
@@ -217,11 +241,14 @@ void AliRsnVAnalysisTaskME::RsnTerminate(Option_t* )
 //_____________________________________________________________________________
 void AliRsnVAnalysisTaskME::FillInfo()
 {
+//
+// TODO
+//
 
   if (fESDEvent) {
-    fTaskInfo.SetNumberOfTracks(fESDEvent->GetNumberOfTracks());
+    fTaskInfo.SetEventUsed(kTRUE);
   } else if (fAODEvent) {
-    fTaskInfo.SetNumberOfTracks(fAODEvent->GetNumberOfTracks());
+    fTaskInfo.SetEventUsed(kTRUE);
   }
 
   fTaskInfo.FillInfo();
@@ -230,6 +257,10 @@ void AliRsnVAnalysisTaskME::FillInfo()
 //_____________________________________________________________________________
 void AliRsnVAnalysisTaskME::SetLogType(AliLog::EType_t type,TString otherClasses)
 {
+//
+// TODO
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
   fLogType = type;
   fLogClassesString = otherClasses;
@@ -238,6 +269,10 @@ void AliRsnVAnalysisTaskME::SetLogType(AliLog::EType_t type,TString otherClasses
 //_____________________________________________________________________________
 void AliRsnVAnalysisTaskME::SetDebugForOtherClasses()
 {
+//
+// TODOss ss
+//
+
   AliDebug(AliLog::kDebug+2,"<-");
   TObjArray* array = fLogClassesString.Tokenize(":");
   TObjString *str;
index 4aac28b6c536e79aa1be98e99d476332ddff09ef..0f353920732993b7bb1ff1f7d826b0717e2defee 100644 (file)
@@ -1,70 +1,67 @@
-//\r
-// Class AliRsnVAnalysisTaskME\r
-//\r
-// Virtual Class derivated from AliAnalysisTaskME which will be base class\r
-// for all RSN ME tasks\r
-//\r
-// authors: Martin Vala (martin.vala@cern.ch)\r
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)\r
-//\r
-#ifndef AliRsnVATME_H\r
-#define AliRsnVATME_H\r
-\r
-#include <TH1.h>\r
-\r
-#include "AliLog.h"\r
-\r
-#include "AliESDEvent.h"\r
-#include "AliMCEvent.h"\r
-#include "AliAODEvent.h"\r
-\r
-#include "AliRsnVATProcessInfo.h"\r
-\r
-#include "AliAnalysisTaskME.h"\r
-\r
-class AliRsnVAnalysisTaskME : public AliAnalysisTaskME\r
-{\r
-public:\r
-    AliRsnVAnalysisTaskME(const char *name = "AliRsnVAnalysisTaskME");\r
-    AliRsnVAnalysisTaskME(const AliRsnVAnalysisTaskME& copy);\r
-    AliRsnVAnalysisTaskME& operator= (const AliRsnVAnalysisTaskME& /*copy*/) {\r
-        return *this;\r
-    }\r
-    virtual ~AliRsnVAnalysisTaskME() {/* Does nothing*/}\r
-\r
-    virtual void    LocalInit();\r
-    virtual Bool_t  Notify();\r
-    virtual void    ConnectInputData(Option_t *);\r
-    // Implementation of interface methods\r
-    virtual void    UserCreateOutputObjects();\r
-    virtual void    UserExec(Option_t*);\r
-    virtual void    Terminate(Option_t*);\r
-\r
-    // Implement this\r
-    virtual void    RsnUserCreateOutputObjects();\r
-    virtual void    RsnUserExec(Option_t*);\r
-    virtual void    RsnTerminate(Option_t*);\r
-\r
-    virtual void    FillInfo();\r
-\r
-    void            SetLogType(AliLog::EType_t type,TString otherClasses="");\r
-    void            SetPrintInfoNumber(const Long64_t &num=100) { fTaskInfo.SetPrintInfoNumber(num); }\r
-\r
-protected:\r
-\r
-    AliLog::EType_t         fLogType;\r
-    TString                 fLogClassesString;\r
-\r
-    AliESDEvent            *fESDEvent;        // AliVEvent event\r
-    AliMCEvent             *fMCEvent;         // ESD event\r
-    AliAODEvent            *fAODEvent;        // AOD event\r
-\r
-    TList                  *fOutList;\r
-    AliRsnVATProcessInfo    fTaskInfo;\r
-    \r
-    void            SetDebugForOtherClasses();\r
-\r
-    ClassDef(AliRsnVAnalysisTaskME, 1)\r
-};\r
-\r
-#endif\r
+//
+// Class AliRsnVAnalysisTaskME
+//
+// Virtual Class derivated from AliAnalysisTaskME which will be base class
+// for all RSN ME tasks
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+#ifndef ALIRSNVANALYSISTASKME_H
+#define ALIRSNVANALYSISTASKME_H
+
+#include "AliLog.h"
+#include "AliRsnVATProcessInfo.h"
+
+#include "AliAnalysisTaskME.h"
+
+class TH1;
+class AliESDEvent;
+class AliMCEvent;
+class AliAODEvent;
+class AliRsnVAnalysisTaskME : public AliAnalysisTaskME
+{
+  public:
+    AliRsnVAnalysisTaskME(const char *name = "AliRsnVAnalysisTaskME");
+    AliRsnVAnalysisTaskME(const AliRsnVAnalysisTaskME& copy);
+    AliRsnVAnalysisTaskME& operator= (const AliRsnVAnalysisTaskME& /*copy*/) {
+      return *this;
+    }
+    virtual ~AliRsnVAnalysisTaskME() {/* Does nothing*/}
+
+    virtual void    LocalInit();
+    virtual Bool_t  Notify();
+    virtual void    ConnectInputData(Option_t *opt);
+    // Implementation of interface methods
+    virtual void    UserCreateOutputObjects();
+    virtual void    UserExec(Option_t *opt);
+    virtual void    Terminate(Option_t *opt);
+
+    // Implement this
+    virtual void    RsnUserCreateOutputObjects();
+    virtual void    RsnUserExec(Option_t *opt);
+    virtual void    RsnTerminate(Option_t *opt);
+
+    virtual void    FillInfo();
+
+    void            SetLogType(AliLog::EType_t type,TString otherClasses="");
+    void            SetPrintInfoNumber(const Long64_t &num=100) { fTaskInfo.SetPrintInfoNumber(num); }
+
+  protected:
+
+    AliLog::EType_t         fLogType;
+    TString                 fLogClassesString;
+
+    AliESDEvent            *fESDEvent;        // AliVEvent event
+    AliMCEvent             *fMCEvent;         // ESD event
+    AliAODEvent            *fAODEvent;        // AOD event
+
+    TList                  *fOutList;
+    AliRsnVATProcessInfo    fTaskInfo;
+
+    void            SetDebugForOtherClasses();
+
+    ClassDef(AliRsnVAnalysisTaskME, 1)
+};
+
+#endif
index 4526c92a0d328c7c563778bb2fb37cc04d992d03..98d14af5d1852654a371f9b7e309bf8515afc075 100644 (file)
 
 #include "AliRsnVAnalysisTaskSE.h"
 
+#include "AliESDEvent.h"
+#include "AliMCEvent.h"
+#include "AliAODEvent.h"
+
 ClassImp(AliRsnVAnalysisTaskSE)
 
 //_____________________________________________________________________________
-AliRsnVAnalysisTaskSE::AliRsnVAnalysisTaskSE(const char *name) :
-  AliAnalysisTaskSE(name),
-  fLogType(AliLog::kInfo),
-  fLogClassesString(""),
-  fESDEvent(0x0),
-  fMCEvent(0x0),
-  fAODEventIn(0x0),
-  fAODEventOut(0x0),
-  fOutList(0x0),
-  fTaskInfo(name)
+AliRsnVAnalysisTaskSE::AliRsnVAnalysisTaskSE
+(const char *name, Int_t numOfOutputs, Bool_t mcOnly) :
+    AliAnalysisTaskSE(name),
+    fLogType(AliLog::kInfo),
+    fLogClassesString(""),
+    fESDEvent(0x0),
+    fMCEvent(0x0),
+    fAODEventIn(0x0),
+    fAODEventOut(0x0),
+    fMCOnly(mcOnly),
+    fRsnEvent(),
+    fRsnPIDIndex(),
+    fNumberOfOutputs(numOfOutputs),
+    fTaskInfo(name)
 {
 //
 // Default constructor.
@@ -31,22 +39,32 @@ AliRsnVAnalysisTaskSE::AliRsnVAnalysisTaskSE(const char *name) :
 
   AliDebug(AliLog::kDebug+2,"<-");
 
+  if (fNumberOfOutputs<0) fNumberOfOutputs = 0;
+  if (fNumberOfOutputs>kMaxNumberOfOutputs) {
+    AliWarning(Form("We support only %d outputs. If you need more ask for it.",kMaxNumberOfOutputs));
+    AliWarning(Form("For now we are setting it to %d.",kMaxNumberOfOutputs));
+    fNumberOfOutputs = kMaxNumberOfOutputs;
+  }
+
   DefineOutput(1, TList::Class());
 
   AliDebug(AliLog::kDebug+2,"->");
 }
 
 //_____________________________________________________________________________
-AliRsnVAnalysisTaskSE::AliRsnVAnalysisTaskSE(const AliRsnVAnalysisTaskSE& copy) : 
-  AliAnalysisTaskSE(copy),
-  fLogType(copy.fLogType),
-  fLogClassesString(copy.fLogClassesString),
-  fESDEvent(copy.fESDEvent),
-  fMCEvent(copy.fMCEvent),
-  fAODEventIn(copy.fAODEventIn),
-  fAODEventOut(copy.fAODEventOut),
-  fOutList(copy.fOutList),
-  fTaskInfo(copy.fTaskInfo)
+AliRsnVAnalysisTaskSE::AliRsnVAnalysisTaskSE(const AliRsnVAnalysisTaskSE& copy) :
+    AliAnalysisTaskSE(copy),
+    fLogType(copy.fLogType),
+    fLogClassesString(copy.fLogClassesString),
+    fESDEvent(copy.fESDEvent),
+    fMCEvent(copy.fMCEvent),
+    fAODEventIn(copy.fAODEventIn),
+    fAODEventOut(copy.fAODEventOut),
+    fMCOnly(copy.fMCOnly),
+    fRsnEvent(),
+    fRsnPIDIndex(),
+    fNumberOfOutputs(copy.fNumberOfOutputs),
+    fTaskInfo(copy.fTaskInfo)
 {
 //
 // Copy constructor.
@@ -103,7 +121,7 @@ void AliRsnVAnalysisTaskSE::ConnectInputData(Option_t *opt)
   AliAnalysisTaskSE::ConnectInputData(opt);
 
   // getting AliESDEvent
-  fESDEvent = dynamic_cast<AliESDEvent *> (fInputEvent);
+  fESDEvent = dynamic_cast<AliESDEvent *>(fInputEvent);
 
   if (fESDEvent) {
     AliInfo(Form("Input is ESD (%p)", fESDEvent));
@@ -114,11 +132,11 @@ void AliRsnVAnalysisTaskSE::ConnectInputData(Option_t *opt)
   }
 
   // getting AliAODEvent from input
-  fAODEventIn = dynamic_cast<AliAODEvent *> (fInputEvent);
+  fAODEventIn = dynamic_cast<AliAODEvent *>(fInputEvent);
   if (fAODEventIn) AliInfo(Form("Input is AOD INPUT (%p)",fAODEventIn));
 
   // getting AliAODEvent if it is output from previous task
-  fAODEventOut = dynamic_cast<AliAODEvent *> (AODEvent());
+  fAODEventOut = dynamic_cast<AliAODEvent *>(AODEvent());
   if (fAODEventOut) AliInfo(Form("Input is AOD OUTPUT (%p)",fAODEventOut));
 
   AliDebug(AliLog::kDebug+2,"->");
@@ -152,11 +170,9 @@ void AliRsnVAnalysisTaskSE::UserCreateOutputObjects()
 
   AliDebug(AliLog::kDebug+2, "<-");
 
-  fOutList = new TList();
-  fOutList->SetOwner();
-
-  fOutList->Add(fTaskInfo.GenerateInfoList());
-
+  fOutList[0] = new TList();
+  fOutList[0]->SetOwner();
+  fTaskInfo.GenerateInfoList(fOutList[0]);
   RsnUserCreateOutputObjects();
 
   AliDebug(AliLog::kDebug+2,"<-");
@@ -165,23 +181,49 @@ void AliRsnVAnalysisTaskSE::UserCreateOutputObjects()
 //_____________________________________________________________________________
 void AliRsnVAnalysisTaskSE::UserExec(Option_t* opt)
 {
+//
+//
+//
 
   AliDebug(AliLog::kDebug+2,"<-");
 
+  // sets properly the RSN package event interface:
+  // if an ESD event is available, it has priority,
+  // otherwise the AOD event is used;
+  // if the MC information is available, it is linked
+  if (fMCOnly && fMCEvent)
+    fRsnEvent.SetRef(fMCEvent, fMCEvent);
+  else if (fESDEvent)
+    fRsnEvent.SetRef(fESDEvent, fMCEvent);
+  else if (fAODEventOut)
+    fRsnEvent.SetRef(fAODEventOut);
+  else if (fAODEventIn)
+    fRsnEvent.SetRef(fAODEventIn);
+  else {
+    AliError("NO ESD or AOD object!!! Skipping ...");
+    return;
+  }
+
+  // sort tracks w.r. to PID...
+  fRsnPIDIndex.FillFromEvent(&fRsnEvent);
+
   RsnUserExec(opt);
 
   FillInfo();
 
-  fTaskInfo.PrintInfo(fEntry);
+  fTaskInfo.PrintInfo(fTaskInfo.GetNumerOfEventsProcessed());
 
-  PostData(1, fOutList);
+  PostData(1, fOutList[0]);
 
   AliDebug(AliLog::kDebug+2,"->");
 }
 
 //_____________________________________________________________________________
-void AliRsnVAnalysisTaskSE::RsnUserExec(Option_t* )
+void AliRsnVAnalysisTaskSE::RsnUserExec(Option_t*)
 {
+//
+//
+//
 
   if (fESDEvent) {
     AliDebug(AliLog::kDebug+1, Form("fESDEvent is %p", fESDEvent));
@@ -214,17 +256,15 @@ void AliRsnVAnalysisTaskSE::Terminate(Option_t* opt)
   AliDebug(AliLog::kDebug+2,"<-");
   AliAnalysisTask::Terminate();
 
-  fOutList = dynamic_cast<TList*>(GetOutputData(1));
-  if (!fOutList) {
-    AliError(Form("At end of analysis, fOutList is %p", fOutList));
+  TList* list  = dynamic_cast<TList*>(GetOutputData(1));
+  if (!list) {
+    AliError(Form("At end of analysis, fOutList is %p", list));
     return;
   }
 
   RsnTerminate(opt);
 
-  TList* lEventInfo = (TList*) fOutList->FindObject(fTaskInfo.GetName());
-
-  TH1I *hEventInfo = (TH1I*) lEventInfo->FindObject(fTaskInfo.GetEventHistogramName());
+  TH1I *hEventInfo = (TH1I*) list->FindObject(fTaskInfo.GetEventHistogramName());
   if (!hEventInfo) {
     AliError(Form("hEventInfo is %p",hEventInfo));
     return;
@@ -240,7 +280,7 @@ void AliRsnVAnalysisTaskSE::Terminate(Option_t* opt)
 }
 
 //_____________________________________________________________________________
-void AliRsnVAnalysisTaskSE::RsnTerminate(Option_t* )
+void AliRsnVAnalysisTaskSE::RsnTerminate(Option_t*)
 {
 //
 // Overload this to add additional termination operations
@@ -258,18 +298,9 @@ void AliRsnVAnalysisTaskSE::FillInfo()
 //
 
   AliDebug(AliLog::kDebug+2, "<-");
-  /*
-  if (fAODEventOut) {
-    fTaskInfo.SetNumberOfTracks(fAODEventOut->GetNumberOfTracks());
-  }
-  else if (fESDEvent) {
-    fTaskInfo.SetNumberOfTracks(fESDEvent->GetNumberOfTracks());
-  }
-  else if (fAODEventIn) {
-    fTaskInfo.SetNumberOfTracks(fAODEventIn->GetNumberOfTracks());
-  }
-  */
+
   fTaskInfo.FillInfo();
+
   AliDebug(AliLog::kDebug+2,"->");
 }
 
index 8621b6e9c613771297cf038412e088c953173218..4ed78baac21e8bda08b7b1ca0ab929a8ed844947 100644 (file)
@@ -1,72 +1,88 @@
-//\r
-// Class AliRsnVAnalysisTaskSE\r
-//\r
-// Virtual Class derivated from AliAnalysisTaskSE which will be base class\r
-// for all RSN SE tasks\r
-//\r
-// authors: Martin Vala (martin.vala@cern.ch)\r
-//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)\r
-//\r
-#ifndef ALIRSNVANALYSISTASKSE_H\r
-#define ALIRSNVANALYSISTASKSE_H\r
-\r
-#include <TH1.h>\r
-\r
-#include "AliLog.h"\r
-\r
-#include "AliAnalysisTaskSE.h"\r
-\r
-\r
-#include "AliESDEvent.h"\r
-#include "AliMCEvent.h"\r
-#include "AliAODEvent.h"\r
-// class AliRsnEvent;\r
-\r
-#include "AliRsnVATProcessInfo.h"\r
-\r
-class AliRsnVAnalysisTaskSE : public AliAnalysisTaskSE\r
-{\r
-  public:\r
-\r
-    AliRsnVAnalysisTaskSE(const char *name = "AliRsnVAnalysisTaskSE");\r
-    AliRsnVAnalysisTaskSE(const AliRsnVAnalysisTaskSE& copy);\r
-    AliRsnVAnalysisTaskSE& operator= (const AliRsnVAnalysisTaskSE& /*copy*/) { return *this; }\r
-    virtual ~AliRsnVAnalysisTaskSE() {/* Does nothing*/}\r
-\r
-    virtual void    LocalInit();\r
-    virtual Bool_t  Notify();\r
-    virtual void    ConnectInputData(Option_t *);\r
-    // Implementation of interface methods\r
-    virtual void    UserCreateOutputObjects();\r
-    virtual void    UserExec(Option_t*);\r
-    virtual void    Terminate(Option_t*);\r
-\r
-    // Implement this\r
-    virtual void    RsnUserCreateOutputObjects();\r
-    virtual void    RsnUserExec(Option_t*);\r
-    virtual void    RsnTerminate(Option_t*);\r
-\r
-    virtual void    FillInfo();\r
-\r
-    void SetLogType(AliLog::EType_t type, TString otherClasses = "");\r
-    void SetPrintInfoNumber(const Long64_t &num = 100) { fTaskInfo.SetPrintInfoNumber(num); }\r
-\r
-  protected:\r
-\r
-    AliLog::EType_t         fLogType;\r
-    TString                 fLogClassesString;\r
-\r
-    AliESDEvent            *fESDEvent;        // ESD event\r
-    AliMCEvent             *fMCEvent;         // MC event\r
-    AliAODEvent            *fAODEventIn;      // AOD event from input\r
-    AliAODEvent            *fAODEventOut;     // AOD event from output from previous taks\r
-\r
-    TList                  *fOutList;\r
-    AliRsnVATProcessInfo    fTaskInfo;\r
-    \r
-    void SetDebugForOtherClasses();\r
-\r
-    ClassDef(AliRsnVAnalysisTaskSE, 1)\r
-};\r
-\r
-#endif\r
+//
+// Class AliRsnVAnalysisTaskSE
+//
+// Virtual Class derivated from AliAnalysisTaskSE 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 ALIRSNVANALYSISTASKSE_H
+#define ALIRSNVANALYSISTASKSE_H
+
+#include <TH1.h>
+
+#include "AliLog.h"
+
+#include "AliAnalysisTaskSE.h"
+
+#include "AliRsnEvent.h"
+#include "AliRsnPIDIndex.h"
+#include "AliRsnVATProcessInfo.h"
+
+class AliESDEvent;
+class AliAODEvent;
+class AliMCEvent;
+
+class AliRsnVAnalysisTaskSE : public AliAnalysisTaskSE
+{
+  public:
+    enum {
+      kMaxNumberOfOutputs=10
+    };
+
+    AliRsnVAnalysisTaskSE(const char *name = "AliRsnVAnalysisTaskSE", Int_t numOfOutputs = 1, Bool_t mcOnly = kFALSE);
+    AliRsnVAnalysisTaskSE(const AliRsnVAnalysisTaskSE& copy);
+    AliRsnVAnalysisTaskSE& operator= (const AliRsnVAnalysisTaskSE& /*copy*/) { return *this; }
+    virtual ~AliRsnVAnalysisTaskSE() {/* Does nothing*/;}
+
+    virtual void    LocalInit();
+    virtual Bool_t  Notify();
+    virtual void    ConnectInputData(Option_t *opt);
+    // Implementation of interface methods
+    virtual void    UserCreateOutputObjects();
+    virtual void    UserExec(Option_t* opt);
+    virtual void    Terminate(Option_t* opt);
+
+    // Implement this
+    virtual void    RsnUserCreateOutputObjects();
+    virtual void    RsnUserExec(Option_t*);
+    virtual void    RsnTerminate(Option_t*);
+
+    virtual void    FillInfo();
+
+    // Prior probs
+    AliRsnPIDIndex* GetPIDIndex() {return &fRsnPIDIndex;}
+    AliRsnEvent*    GetRsnEvent() {return &fRsnEvent;}
+    void            SetPriorProbability(AliPID::EParticleType type, Double_t p) {fRsnEvent.SetPriorProbability(type, p);}
+    void            DumpPriors() {fRsnEvent.DumpPriors();}
+    void            GetPriorProbability(Double_t *out) const {fRsnEvent.GetPriorProbability(out);}
+
+    void SetMCOnly(Bool_t mcOnly = kTRUE) {fMCOnly = mcOnly;}
+    void SetLogType(AliLog::EType_t type, TString otherClasses = "");
+    void SetPrintInfoNumber(const Long64_t &num = 100) { fTaskInfo.SetPrintInfoNumber(num); }
+
+  protected:
+
+    AliLog::EType_t         fLogType;
+    TString                 fLogClassesString;
+
+    AliESDEvent            *fESDEvent;        // ESD event
+    AliMCEvent             *fMCEvent;         // MC event
+    AliAODEvent            *fAODEventIn;      // AOD event from input
+    AliAODEvent            *fAODEventOut;     // AOD event from output from previous taks
+
+    Bool_t                  fMCOnly;          // use only MC information
+    AliRsnEvent             fRsnEvent;        // interface to event for RSN package
+    AliRsnPIDIndex          fRsnPIDIndex;     // PID method sorter
+
+    Int_t                   fNumberOfOutputs;
+    TList                  *fOutList[kMaxNumberOfOutputs+1]; //!
+    AliRsnVATProcessInfo    fTaskInfo;
+
+    void SetDebugForOtherClasses();
+
+    ClassDef(AliRsnVAnalysisTaskSE, 1)
+};
+
+#endif
index 75f2c20b00dfa8fb0b76261299a047ce93a9eb71..a927d7aed77821a13b26f33556542c9b95b339a1 100644 (file)
@@ -19,8 +19,8 @@ ClassImp(AliRsnVManager)
 
 //_____________________________________________________________________________
 AliRsnVManager::AliRsnVManager(const char*name) :
-  TNamed(name, name),
-  fArray(0)
+    TNamed(name, name),
+    fArray(0)
 {
 //
 // Default constructor
@@ -36,7 +36,7 @@ AliRsnVManager::~AliRsnVManager()
 }
 
 //_____________________________________________________________________________
-void AliRsnVManager::Add(TObject *obj)
+void AliRsnVManager::Add(TObject*const obj)
 {
 //
 // Add a new object in the list.
index 5be49879a3abbf8669884b8fab2b05613eea6e26..a85e43dd18412d8820177f72b03da47824c3aa78 100644 (file)
@@ -11,8 +11,8 @@
 // revised by : A. Pulvirenti [alberto.pulvirenti@ct.infn.it]
 //
 
-#ifndef AliRsnVManager_H
-#define AliRsnVManager_H
+#ifndef ALIRSNVMANAGER_H
+#define ALIRSNVMANAGER_H
 
 #include <TNamed.h>
 
@@ -23,10 +23,10 @@ class AliRsnVManager : public TNamed
     AliRsnVManager(const char*name = "default");
     ~AliRsnVManager();
 
-    virtual void        Add(TObject *pair);
-            TObjArray*  GetArray() {return &fArray;}
-            Int_t       GetEntries() {return fArray.GetEntries();}
-            Int_t       GetEntriesFast() {return fArray.GetEntriesFast();}
+    virtual void        Add(TObject *const pair);
+    TObjArray*  GetArray() {return &fArray;}
+    Int_t       GetEntries() {return fArray.GetEntries();}
+    Int_t       GetEntriesFast() {return fArray.GetEntriesFast();}
     virtual void        PrintArray() const;
     virtual void        Print(Option_t *opt = "") const;
 
diff --git a/PWG2/RESONANCES/AliRsnVariableExpression.cxx b/PWG2/RESONANCES/AliRsnVariableExpression.cxx
new file mode 100644 (file)
index 0000000..5a319ce
--- /dev/null
@@ -0,0 +1,26 @@
+//
+// AliRsnVariableExpresion class is used
+// to help AliRsnExpresion class
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#include "AliLog.h"
+
+#include "AliRsnCut.h"
+#include "AliRsnVariableExpression.h"
+
+ClassImp(AliRsnVariableExpression)
+
+//______________________________________________________________________________
+Bool_t AliRsnVariableExpression::Value(TObjArray& /*pgm*/)
+{
+
+//   Int_t indexx = fgCutSet->GetIndexByCutName ( fVname.Data() );
+  AliDebug(AliLog::kDebug,Form("Vname %s",fVname.Data()));
+//   return fgCutSet->GetBoolValue ( indexx );
+
+  return fgCutSet->GetBoolValue(fVname.Atoi());
+}
+
diff --git a/PWG2/RESONANCES/AliRsnVariableExpression.h b/PWG2/RESONANCES/AliRsnVariableExpression.h
new file mode 100644 (file)
index 0000000..5ed4046
--- /dev/null
@@ -0,0 +1,24 @@
+//
+// AliRsnVariableExpresion class is used to help AliRsnExpresion class
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#ifndef ALIRSNVARIABLEEXPRESSION_H
+#define ALIRSNVARIABLEEXPRESSION_H
+
+#include "AliRsnExpression.h"
+
+class AliRsnVariableExpression: public AliRsnExpression
+{
+  public:
+    AliRsnVariableExpression(TString a) : AliRsnExpression() { fVname = a;  };
+    ~AliRsnVariableExpression() {}
+    virtual Bool_t    Value(TObjArray& pgm);
+    virtual TString    Unparse() const { return fVname; }
+
+    ClassDef(AliRsnVariableExpression, 1);    // Class to define a variable expression
+};
+
+#endif
diff --git a/PWG2/RESONANCES/macros/AddAnalysisTaskRsn.C b/PWG2/RESONANCES/macros/AddAnalysisTaskRsn.C
deleted file mode 100644 (file)
index fa65a1b..0000000
+++ /dev/null
@@ -1,404 +0,0 @@
-//
-// Macro to create the full analysis manager for Resonances
-//
-
-static Double_t  cov11 = 2;
-static Double_t  cov22 = 2;
-static Double_t  cov33 = 0.5;
-static Double_t  cov44 = 0.5;
-static Double_t  cov55 = 2;
-static Double_t  nSigmaToVertex = 4;
-static Double_t  dcaToVertex = 3.0;
-static Double_t  maxChi2PerClusterTPC = 3.5;
-static Bool_t    requireTPCRefit = kTRUE;
-static Bool_t    requireSigmaToVertex = kTRUE;
-static Bool_t    acceptKinkDaughters = kFALSE;
-static Int_t     minNClustersTPC = 50;
-
-Bool_t AddAnalysisTaskRsn
-(
-  AliLog::EType_t  debugType  = AliLog::kInfo, // debug depth for some classes
-  Bool_t           useTPCOnly = kFALSE,        // use TPC only PID
-  const char      *outFile    = "rsn.root",    // output file name
-  Bool_t           sourceESD  = kTRUE          // if true, the source of data is ESD, otherwise is AOD from filter task
-)
-{
-  // retrieve analysis manager
-  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
-
-  // initialize task
-  AliRsnAnalysisSE *task = new AliRsnAnalysisSE("AliRsnAnalysisSE");
-  //task->SetLogType(debugType, "AliRsnAnalysisManager:AliRsnPairManager:AliRsnPairManager:AliRsnPair");
-  task->SetLogType(debugType, "AliRsnCut:AliRsnCutPrimaryVertex");
-
-  // set prior probabilities for PID
-  task->SetPriorProbability(AliPID::kElectron, 0.02);
-  task->SetPriorProbability(AliPID::kMuon,     0.02);
-  task->SetPriorProbability(AliPID::kPion,     0.83);
-  task->SetPriorProbability(AliPID::kKaon,     0.07);
-  task->SetPriorProbability(AliPID::kProton,   0.06);
-  task->DumpPriors();
-
-  // initialize analysis manager with pairs from config
-  AliRsnAnalysisManager *anaMgr = task->GetAnalysisManager("MyAnalysisSE");
-  anaMgr->Add(CreatePairsNoPID("PHI_NoPID_0"   , 333, AliPID::kKaon, AliPID::kKaon, 10000.0));
-  anaMgr->Add(CreatePairsNoPID("PHI_NoPID_10"  , 333, AliPID::kKaon, AliPID::kKaon,     0.1));
-  anaMgr->Add(CreatePairsNoPID("PHI_NoPID_20"  , 333, AliPID::kKaon, AliPID::kKaon,     0.2));
-  anaMgr->Add(CreatePairsPID  ("PHI_PID"       , 333, AliPID::kKaon, AliPID::kKaon));
-  //anaMgr->Add(CreatePairsNoPID("KSTAR_NoPID_0" , 313, AliPID::kKaon, AliPID::kPion, 10000.0));
-  //anaMgr->Add(CreatePairsNoPID("KSTAR_NoPID_10", 313, AliPID::kKaon, AliPID::kPion,     0.1));
-  //anaMgr->Add(CreatePairsNoPID("KSTAR_NoPID_20", 313, AliPID::kKaon, AliPID::kPion,     0.2));
-  //anaMgr->Add(CreatePairsPID  ("KSTAR_PID"     , 313, AliPID::kKaon, AliPID::kPion));
-  cout << "CREATED PAIRS" << endl;
-
-  // setup cuts for ESD tracks
-  if (sourceESD)
-  {
-    AliESDtrackCuts *esdCuts = new AliESDtrackCuts;
-    esdCuts->SetMaxCovDiagonalElements(cov11, cov22, cov33, cov44, cov55);
-    esdCuts->SetRequireSigmaToVertex(requireSigmaToVertex);
-    if (requireSigmaToVertex) esdCuts->SetMaxNsigmaToVertex(nSigmaToVertex);
-    else
-    {
-      esdCuts->SetDCAToVertexZ(dcaToVertex);
-      esdCuts->SetDCAToVertexXY(dcaToVertex);
-    }
-    esdCuts->SetRequireTPCRefit(requireTPCRefit);
-    esdCuts->SetAcceptKinkDaughters(acceptKinkDaughters);
-    esdCuts->SetMinNClustersTPC(minNClustersTPC);
-    esdCuts->SetMaxChi2PerClusterTPC(maxChi2PerClusterTPC);
-    task->SetESDtrackCuts(esdCuts);
-  }
-  cout << "SET ESD CUTS" << endl;
-
-  // set PID customization if necessary
-  if (useTPCOnly) {
-    Info("Using TPC only PID");
-    task->GetPIDDef()->SetScheme(AliRsnPIDDefESD::kSchemeTPC);
-  }
-  cout << "SET PID SCHEME" << endl;
-
-  // setup cuts for events (good primary vertex)
-  AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 3);
-  AliRsnCutSet *cutSetEvent = new AliRsnCutSet("eventCuts");
-  cutSetEvent->AddCut(cutVertex);
-  cutSetEvent->SetCutScheme("cutVertex");
-  task->SetEventCuts(cutSetEvent);
-  cout << "SET EVENT CUT SCHEME" << endl;
-
-  // add the task to manager
-  mgr->AddTask(task);
-  cout << "ADD TASK" << endl;
-
-  // connect input container according to source choice
-  if (sourceESD) mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
-  else mgr->ConnectInput(task, 0, mgr->GetCommonOutputContainer());
-  cout << "CONNECT INPUT" << endl;
-
-  // initialize and connect container for the output
-  AliAnalysisDataContainer *out = mgr->CreateContainer("RSN", TList::Class(), AliAnalysisManager::kOutputContainer, outFile);
-  mgr->ConnectOutput(task, 1, out);
-  cout << "CONNECT OUTPUT" << endl;
-}
-
-AliRsnFunction* DefineFunctionIM()
-{
-//
-// In general, for all processed pairs in one analysis the same functions are computed.
-// Then, they are defined separately here and added in the same way to all pairs.
-//
-
-  // define all binnings
-  AliRsnFunctionAxis *axisIM   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairInvMass,    1000,  0.0,   2.0);
-  AliRsnFunctionAxis *axisPt   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairPt,           10,  0.0,  10.0);
-  AliRsnFunctionAxis *axisEta  = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairEta,          10, -1.0,   1.0);
-  AliRsnFunctionAxis *axisMult = new AliRsnFunctionAxis(AliRsnFunctionAxis::kEventMult,         8,  0.0, 200.0);
-
-  // define function
-  AliRsnFunction *fcn = new AliRsnFunction;
-  fcn->AddAxis(axisIM);
-  fcn->AddAxis(axisPt);
-  fcn->AddAxis(axisEta);
-  fcn->AddAxis(axisMult);
-
-  return fcn;
-}
-
-AliRsnFunction* DefineFunctionP1P2()
-{
-//
-// In general, for all processed pairs in one analysis the same functions are computed.
-// Then, they are defined separately here and added in the same way to all pairs.
-//
-
-  // define all binnings
-  AliRsnFunctionAxis *axisP1   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kTrack1P,          50,  0.0,   5.0);
-  AliRsnFunctionAxis *axisP2   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kTrack2P,          50,  0.0,   5.0);
-  AliRsnFunctionAxis *axisPt   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairPt,           10,  0.0,  10.0);
-  AliRsnFunctionAxis *axisEta  = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairEta,          10, -1.0,   1.0);
-  AliRsnFunctionAxis *axisMult = new AliRsnFunctionAxis(AliRsnFunctionAxis::kEventMult,         8,  0.0, 200.0);
-
-  // define function
-  AliRsnFunction *fcn = new AliRsnFunction;
-  fcn->AddAxis(axisP1);
-  fcn->AddAxis(axisP2);
-  fcn->AddAxis(axisPt);
-  fcn->AddAxis(axisEta);
-  fcn->AddAxis(axisMult);
-
-  return fcn;
-}
-
-AliRsnPairManager* CreatePairsNoPID
-(
-  const char            *pairMgrName,    // name for the pair manager
-  Int_t                  resonancePDG,   // PDG code of resonance (for true pairs)
-  AliPID::EParticleType  type1,          // PID of one member of decay (+)
-  AliPID::EParticleType  type2,          // PID of other member of decay (-)
-  Double_t               bbCut = 10000.0 // cut on Bethe-Bloch
-)
-{
-//
-// Creates an AliRsnPairMgr for a specified resonance, which contains:
-// - signal (inv. mass)
-// - event mixing (inv. mass)
-// - like-sign (inv. mass)
-// - true pairs (inv. mass, resolution)
-//
-// For all pairs, a binning in Pt and Eta is provided, and a cut in multiplicity
-// which defines a multiplicity bin where the analysis is computed.
-//
-// Arguments define how the pair manager must be built, and are explained above
-//
-
-  AliRsnPairManager  *pairMgr  = new AliRsnPairManager(pairMgrName);
-
-  // === PAIR DEFINITIONS =========================================================================
-
-  // if particle #1 and #2 are different, two histograms must be built
-  // for each scheme (signal, true, mixed, like-sign) exchanging both particles and signs
-  Int_t i, j, nArray = 1;
-  if (type1 != type2) nArray = 2;
-
-  AliRsnPairDef *defUnlike[2] = {0, 0};
-  AliRsnPairDef *defLikePP[2] = {0, 0};
-  AliRsnPairDef *defLikeMM[2] = {0, 0};
-
-  defUnlike[0] = new AliRsnPairDef(type1, '+', type2, '-', resonancePDG);
-  defLikePP[0] = new AliRsnPairDef(type1, '+', type2, '+', resonancePDG);
-  defLikeMM[0] = new AliRsnPairDef(type1, '-', type2, '-', resonancePDG);
-
-  defUnlike[1] = new AliRsnPairDef(type2, '+', type1, '-', resonancePDG);
-  defLikePP[1] = new AliRsnPairDef(type2, '+', type1, '+', resonancePDG);
-  defLikeMM[1] = new AliRsnPairDef(type2, '-', type1, '-', resonancePDG);
-
-  // === PAIR ANALYSIS ENGINES ====================================================================
-
-  // define null (dummy) objects and initialize only the ones which are needed,
-  // depending again on particle types;
-  // array is organized as follows:
-  // [0] - true pairs
-  // [1] - signal
-  // [2] - like PP
-  // [3] - like MM
-  AliRsnPair *noPID[2][4] = {0,0,0,0,0,0,0,0};
-
-  for (i = 0; i < nArray; i++) {
-    noPID[i][0] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
-    noPID[i][1] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
-    noPID[i][2] = new AliRsnPair(AliRsnPair::kNoPID, defLikePP[i]);
-    noPID[i][3] = new AliRsnPair(AliRsnPair::kNoPID, defLikeMM[i]);
-  }
-
-  // === CUTS =====================================================================================
-
-  // cuts for tracks:
-  // -- Bethe-Bloch & required kaon PID
-  AliRsnCutBetheBloch *cutKaonBB = new AliRsnCutBetheBloch("cutKaon", bbCut, AliPID::kKaon);
-  cutKaonBB->SetCalibConstant(0, 0.76176e-1);
-  cutKaonBB->SetCalibConstant(1, 10.632);
-  cutKaonBB->SetCalibConstant(2, 0.13279e-4);
-  cutKaonBB->SetCalibConstant(3, 1.8631);
-  cutKaonBB->SetCalibConstant(4, 1.9479);
-
-  // cuts on pairs:
-  // -- true daughters of a phi resonance (only for true pairs histogram)cutSetPairTrue->AddCut(cutTrue);
-  AliRsnCutStd *cutTruePair = new AliRsnCutStd("cutTrue", AliRsnCutStd::kTruePair, resonancePDG);
-
-  // cuts on event:
-  // -- none (specified for whole task)
-
-  // cut set definition for all pairs
-  AliRsnCutSet *cutSetParticle = new AliRsnCutSet("trackCuts");
-  //cutSetParticle->AddCut(cutKaonBB);
-  //cutSetParticle->SetCutScheme("cutKaonBB");
-
-  // cut set definition for true pairs
-  AliRsnCutSet *cutSetPairTrue = new AliRsnCutSet("truePairs");
-  //cutSetPairTrue->AddCut(cutTruePair);
-  //cutSetPairTrue->SetCutScheme("cutTrue");
-
-  // cut manager for all pairs
-  AliRsnCutMgr *cutMgrAll = new AliRsnCutMgr("std", "All");
-  cutMgrAll->SetCutSet(AliRsnCut::kParticle, cutSetParticle);
-
-  // cut manager for all pairs
-  AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True");
-  cutMgrTrue->SetCutSet(AliRsnCut::kParticle, cutSetParticle);
-  cutMgrTrue->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
-
-  for (i = 0; i < nArray; i++) {
-    //noPID[i][0]->SetCutMgr(cutMgrTrue);
-    noPID[i][0]->SetCutMgr(cutMgrAll);
-    for (j = 1; j < 4; j++) {
-      noPID[i][j]->SetCutMgr(cutMgrAll);
-    }
-  }
-
-  // === FUNCTIONS ================================================================================
-
-  AliRsnFunction *fcn   = DefineFunctionIM();
-  AliRsnFunction *fcnPP = DefineFunctionP1P2();
-
-  for (i = 0; i < nArray; i++) {
-    for (j = 0; j < 4; j++) {
-      noPID[i][j]->AddFunction(fcn);
-      if (j < 2) noPID[i][j]->AddFunction(fcnPP);
-    }
-  }
-
-  // === ADD TO PAIR MANAGER ======================================================================
-
-  for (i = 0; i < nArray; i++) {
-    for (j = 0; j < 4; j++) {
-      pairMgr->AddPair(noPID[i][j]);
-    }
-  }
-
-  return pairMgr;
-}
-
-AliRsnPairManager* CreatePairsPID
-(
-  const char            *pairMgrName,    // name for the pair manager
-  Int_t                  resonancePDG,   // PDG code of resonance (for true pairs)
-  AliPID::EParticleType  type1,          // PID of one member of decay (+)
-  AliPID::EParticleType  type2           // PID of other member of decay (-)
-)
-{
-//
-// Creates an AliRsnPairMgr for a specified resonance, which contains:
-// - signal (inv. mass)
-// - event mixing (inv. mass)
-// - like-sign (inv. mass)
-// - true pairs (inv. mass, resolution)
-//
-// For all pairs, a binning in Pt and Eta is provided, and a cut in multiplicity
-// which defines a multiplicity bin where the analysis is computed.
-//
-// Arguments define how the pair manager must be built, and are explained above
-//
-
-  AliRsnPairManager  *pairMgr  = new AliRsnPairManager(pairMgrName);
-
-  // === PAIR DEFINITIONS =========================================================================
-
-  // if particle #1 and #2 are different, two histograms must be built
-  // for each scheme (signal, true, mixed, like-sign) exchanging both particles and signs
-  Int_t i, j, nArray = 1;
-  if (type1 != type2) nArray = 2;
-
-  AliRsnPairDef *defUnlike[2] = {0, 0};
-  AliRsnPairDef *defLikePP[2] = {0, 0};
-  AliRsnPairDef *defLikeMM[2] = {0, 0};
-
-  defUnlike[0] = new AliRsnPairDef(type1, '+', type2, '-', resonancePDG);
-  defLikePP[0] = new AliRsnPairDef(type1, '+', type2, '+', resonancePDG);
-  defLikeMM[0] = new AliRsnPairDef(type1, '-', type2, '-', resonancePDG);
-
-  defUnlike[1] = new AliRsnPairDef(type2, '+', type1, '-', resonancePDG);
-  defLikePP[1] = new AliRsnPairDef(type2, '+', type1, '+', resonancePDG);
-  defLikeMM[1] = new AliRsnPairDef(type2, '-', type1, '-', resonancePDG);
-
-  // === PAIR ANALYSIS ENGINES ====================================================================
-
-  // define null (dummy) objects and initialize only the ones which are needed,
-  // depending again on particle types;
-  // array is organized as follows:
-  // [0] - true pairs
-  // [1] - signal
-  // [2] - like PP
-  // [3] - like MM
-  AliRsnPair *perfectPID[2][4]   = {0,0,0,0,0,0,0,0};
-  AliRsnPair *realisticPID[2][4] = {0,0,0,0,0,0,0,0};
-
-  for (i = 0; i < nArray; i++) {
-    perfectPID[i][0] = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike[i]);
-    perfectPID[i][1] = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike[i]);
-    perfectPID[i][2] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikePP[i]);
-    perfectPID[i][3] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikeMM[i]);
-
-    realisticPID[i][0] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
-    realisticPID[i][1] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
-    realisticPID[i][2] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikePP[i]);
-    realisticPID[i][3] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikeMM[i]);
-  }
-
-  // === CUTS =====================================================================================
-
-  // cuts for tracks:
-  // -- nothing
-
-  // cuts on pairs:
-  // -- true daughters of a phi resonance (only for true pairs histogram)cutSetPairTrue->AddCut(cutTrue);
-  AliRsnCutStd *cutTruePair = new AliRsnCutStd("cutTrue", AliRsnCutStd::kTruePair, resonancePDG);
-
-  // cut set definition for true pairs
-  AliRsnCutSet *cutSetPairTrue = new AliRsnCutSet("truePairs");
-  cutSetPairTrue->AddCut(cutTruePair);
-  cutSetPairTrue->SetCutScheme("cutTrue");
-
-  // cut manager for all pairs
-  AliRsnCutMgr *cutMgrAll = new AliRsnCutMgr("std", "All");
-
-  // cut manager for all pairs
-  AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True");
-  cutMgrTrue->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
-
-  for (i = 0; i < nArray; i++) {
-    perfectPID[i][0]->SetCutMgr(cutMgrTrue);
-    realisticPID[i][0]->SetCutMgr(cutMgrTrue);
-    for (j = 1; j < 4; j++) {
-      perfectPID[i][j]->SetCutMgr(cutMgrAll);
-      realisticPID[i][j]->SetCutMgr(cutMgrAll);
-    }
-  }
-
-  // === FUNCTIONS ================================================================================
-
-  AliRsnFunction *fcn   = DefineFunctionIM();
-  AliRsnFunction *fcnPP = DefineFunctionP1P2();
-
-  for (i = 0; i < nArray; i++) {
-    for (j = 0; j < 4; j++) {
-      perfectPID[i][j]->AddFunction(fcn);
-      realisticPID[i][j]->AddFunction(fcn);
-      if (j < 2) {
-        perfectPID[i][j]->AddFunction(fcnPP);
-        realisticPID[i][j]->AddFunction(fcnPP);
-      }
-    }
-  }
-
-  // === ADD TO PAIR MANAGER ======================================================================
-
-  for (i = 0; i < nArray; i++) {
-    for (j = 0; j < 4; j++) {
-      pairMgr->AddPair(perfectPID[i][j]);
-      pairMgr->AddPair(realisticPID[i][j]);
-    }
-  }
-
-  return pairMgr;
-}
-
diff --git a/PWG2/RESONANCES/macros/AliRsnLoad.C b/PWG2/RESONANCES/macros/AliRsnLoad.C
deleted file mode 100644 (file)
index ba439c9..0000000
+++ /dev/null
@@ -1,89 +0,0 @@
-//=============================================================================
-// Compilation of all PAR archives for resonance analysis.
-// Returns an integer error message if some compilation fails.
-//
-// Allowed options:
-// - "UNTAR"   --> explodes the .par files in the working directory
-// - "CLEAR"   --> removes the PAR archive directory and automatically
-//                 recreates it by exploding again the .par file
-//=============================================================================
-
-Int_t SetupPar(const char* parName, Bool_t untar = kTRUE)
-{
-//
-// Operations to set up the PAR archive
-//
-
-    if (!parName) {
-        Error("SetupPar", "NULL argument passed - Abort!");
-        return -1;
-    }
-
-    // if the directory does not exist, the package is
-    // un-tarred anyway
-    if (!gSystem->OpenDirectory(parName)) untar = kTRUE;
-
-    // unzip + untar (optional)
-    if (untar) {
-        Char_t processLine[1024];
-        sprintf(processLine, ".! tar xvzf ./%s.par", parName);
-        gROOT->ProcessLine(processLine);
-    }
-
-    // change from working directory to sub-dir containing PAR archive
-    const char* ocwd = gSystem->WorkingDirectory();
-    gSystem->ChangeDirectory(parName);
-
-    // check for existence of appropriate 'BUILD.sh' script (in PROOF-INF.<parName>)
-    // and execute it (non-zero return values mean that errors occurred)
-    if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
-        cout << "*** Building PAR archive \"" << parName << "\"" << endl;
-        if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
-            Error("SetupPar", "Cannot Build the PAR Archive - Abort!");
-            return -1;
-        }
-    }
-
-    // check for existence of appropriate 'SETUP.C' macro (in PROOF-INF.<parName>)
-    // and execute it
-    if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
-        cout << "*** Setting up PAR archive \"" << parName << "\"" << endl;
-        gROOT->Macro("PROOF-INF/SETUP.C");
-    }
-
-    // return to working directory
-    gSystem->ChangeDirectory("../");
-
-    // return 1 if everything is OK
-    return 1;
-}
-
-Int_t AliRsnLoad(Option_t *option = "BUILD+UNTAR")
-{
-//
-// Main function of this macro
-// Sets up all the packages useful for resonance analysis.
-// Depending on the support (PROOF / others), the functions are different.
-//
-
-    TString opt(option);
-    opt.ToUpper();
-
-    // check for the UNTAR option
-    Bool_t untar = opt.Contains("UNTAR");
-
-    // check for the CLEAR option
-    // if this is found automatically is required the UNTAR
-    if (opt.Contains("CLEAR")) {
-        gSystem->Exec("rm -rf STEERBase ESD AOD ANALYSIS ANALYSISalice PWG2resonances");
-        untar = kTRUE;
-    }
-
-    // build all libraries with the defined options
-    SetupPar("STEERBase", untar);
-    SetupPar("ESD", untar);
-    SetupPar("AOD", untar);
-    SetupPar("ANALYSIS", untar);
-    SetupPar("ANALYSISalice", untar);
-    SetupPar("PWG2resonances", untar);
-}
diff --git a/PWG2/RESONANCES/macros/AliRsnTaskAlien.C b/PWG2/RESONANCES/macros/AliRsnTaskAlien.C
deleted file mode 100644 (file)
index c40ec97..0000000
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// Example macro to run a full resonance analysis task in a local machine
-// using data taken from AliEn. This macro can be used as a template to create
-// an AliEn job which runs this analysis on a collection of source data files (ESD/AOD/MC).
-//
-// This macro does the following:
-//  - loads all required PAR libraries
-//  - creates a TChain of events to be analyzed (from an XML collection)
-//  - creates the AnalysisTask macro which does the job
-//
-// Since it is possible that all required libraries/macroes are stored in different
-// directories, for each one a variable must be initialized which gives the path,
-// but, in order to allow to explode (if necessary) some environment variables,
-// these variables are NOT arguments, but they are hard-coded in the macro at its
-// beginning, to allow a user to customize them.
-//
-// Arguments:
-//  - name of XM collection for source files
-//  - a flag to know it source data is ESD or AOD
-//  - maximum number of files to be analyzed
-//  - the number of files to be skipped starting from first one in collection.
-//
-Bool_t AliRsnTaskAlien
-(
-  const char *collectionFile = "wn.xml",
-  Bool_t      useESDsource   = kTRUE,
-  Int_t       maxFiles       = 1,
-  Int_t       skipFiles      = 0
-)
-{
-    // path for the "AliRsnLoad.C" macro which loads all libraries
-    TString strLoadPath(Form("%s/PWG2/RESONANCES/macros", getenv("ALICE_ROOT")));
-    strLoadPath.Append("/AliRsnLoad.C");
-    
-    // path for the "CreateAnalysisManager.C" macro which creates the AnalysisManager
-    TString strTaskPath(Form("%s/PWG2/RESONANCES/macros", getenv("ALICE_ROOT")));
-    strTaskPath.Append("/CreateAnalysisManager.C");
-    
-    // connect to grid
-    TGrid::Connect("alien://");
-
-    // load the macro for uploading packages;
-    // the unique assumption which must be done here is that the PAR libraries
-    // are in the working directory, which is the case in all kinds of analysis
-    gROOT->LoadMacro(strLoadPath.Data());
-    AliRsnLoad();
-    
-    // create the TChain of files to read
-    // its name depends on the kind of source to be read
-    char treeName[200];
-    if (useESDsource) {
-        sprintf(treeName, "esdTree");
-        Info("AliRsnSimpleTaskAlien", "Using ESD source data");
-    }
-    else {
-        sprintf(treeName, "aodTree");
-        Info("AliRsnSimpleTaskAlien", "Using AOD source data");
-    }
-    TChain* analysisChain = new TChain(treeName);
-    TAlienCollection *myCollection = TAlienCollection::Open(collectionFile);
-    if (!myCollection) {
-        Error("AliRsnSimpleTaskAlien", Form("Cannot create an AliEn collection from %s", collectionFile));
-        return kFALSE;
-    }
-    // add files to the TChain, keeping trace of their number with a counter
-    Int_t nfiles = 0;
-    char fileName[255];
-    myCollection->Reset();
-    while (myCollection->Next()) {
-        if (skipFiles) {
-            skipFiles--;
-            continue;
-        }
-        sprintf(fileName, "%s", myCollection->GetTURL(""));
-        Info("AliRsnSimpleTaskAlien", Form("Adding file '%s'", fileName));
-        analysisChain->Add(fileName);
-        nfiles++;
-        if (maxFiles > 0 && nfiles >= maxFiles) break;
-    }
-    Info("AliRsnSimpleTaskAlien", Form("# processed events = %d", (Int_t)analysisChain->GetEntries()));
-
-    // load and execute the macro which creates the AnalysisManager
-    // this macro is expected to define a function with the standard name
-    // *** "CreateAnalysisManager()" *** [without arguments],
-    // irrespectively of the filename of the macro itself,
-    // which returns an AliAnalysisManager object
-    gROOT->LoadMacro(strTaskPath.Data());
-    AliAnalysisManager *mgr = CreateAnalysisManager(kFALSE);
-    
-    // initialize analysis and run it in "local" mode
-    if (mgr->InitAnalysis()) {
-        mgr->PrintStatus();
-        return mgr->StartAnalysis("local", analysisChain);
-    }
-    return kTRUE;
-}
diff --git a/PWG2/RESONANCES/macros/AliRsnTaskProof.C b/PWG2/RESONANCES/macros/AliRsnTaskProof.C
deleted file mode 100644 (file)
index 476d2cf..0000000
+++ /dev/null
@@ -1,92 +0,0 @@
-//=========================================================================
-// This macro loops on a dataset in CAF and performs a single-step
-// resonance analysis, which reads the ESD events (with MC if available)
-// and saves directly the invariant mass spectra.
-//
-// All required configurations (reader, PID, pairs, dataSet) is defined
-// inside a macro which must be built in the same way as 
-// the example named "PhiExample.C" in the "macros/config" directory.
-//
-// The output file name is defined from the config file name
-// irrespectively of its location.
-//=========================================================================
-
-//
-// Macro to build an analysis chain from a dataset
-//
-TChain* CreateChainFromDataSet
-(TFileCollection* coll, const char* treeName, const Int_t nMaxFiles)
-{
-  TIter iter(coll->GetList());
-  TChain* target = new TChain(treeName);
-       
-  TFileInfo* fileInfo = 0;
-  Int_t nFilesAdded = 0;
-  while ((fileInfo = dynamic_cast<TFileInfo*> (iter())) && nFilesAdded < nMaxFiles)
-  {
-    if (fileInfo->GetFirstUrl()) {
-         target->Add(fileInfo->GetFirstUrl()->GetUrl());
-         nFilesAdded++;
-       }
-  }
-       
-  Printf("Added %d files to chain", target->GetListOfFiles()->GetEntries());
-  return target;
-}
-
-//
-// Core macro which executes analysis
-//
-void AliRsnTaskProof
-(
-  const char   *fileOut         = "rsn.root",
-  const char   *macro           = "CreateAnalysisManager.C",
-  Int_t         nFilesToProcess = 2,
-  const Char_t *dataSetName     = "/COMMON/COMMON/LHC08c11_10TeV_0.5T",
-  const Char_t *treeName        = "esdTree"
-)
-{
-  // path for the "CreateAnalysisManager.C" macro which creates the AnalysisManager
-  // in this case, assuming that one copies this in an area in lxplus, the path
-  // is set to the same directory
-  //TString strTaskPath(Form("%s/PWG2/RESONANCES/macros", getenv("ALICE_ROOT")));
-  TString strTaskPath(".");
-  
-  // connect to CAF
-  TProof::Open("alicecaf");
-
-  // upload packages
-  gProof->UploadPackage("STEERBase.par");
-  gProof->EnablePackage("STEERBase");
-  gProof->UploadPackage("ESD.par");
-  gProof->EnablePackage("ESD");
-  gProof->UploadPackage("AOD.par");
-  gProof->EnablePackage("AOD");
-  gProof->UploadPackage("ANALYSIS.par");
-  gProof->EnablePackage("ANALYSIS");
-  gProof->UploadPackage("ANALYSISalice.par");
-  gProof->EnablePackage("ANALYSISalice");
-  gProof->UploadPackage("PWG2resonances.par");
-  gProof->EnablePackage("PWG2resonances");
-       
-  // create chains for processing
-  TChain *analysisChain = 0;
-  TFileCollection *fc = gProof->GetDataSet(dataSetName)->GetStagedSubset();
-  if (nFilesToProcess <= 0) nFilesToProcess = 10000;
-  analysisChain = CreateChainFromDataSet(fc, treeName, nFilesToProcess);
-  Printf("Found %d entries", analysisChain->GetEntries());
-       
-  // load and execute the macro which creates the AnalysisManager
-  // this macro is expected to define a function with the standard name
-  // *** "CreateAnalysisManager()" *** [without arguments],
-  // irrespectively of the filename of the macro itself,
-  // which returns an AliAnalysisManager object
-  cout << Form("%s/%s", strTaskPath.Data(), macro) << endl;
-  gROOT->LoadMacro(Form("%s/%s", strTaskPath.Data(), macro));
-  AliAnalysisManager *mgr = CreateAnalysisManager(kTRUE);
-  if (!mgr) Error("", "no Analysis Mgr");
-       
-  if (!mgr->InitAnalysis()) return;
-  mgr->PrintStatus();
-  mgr->StartAnalysis("proof", analysisChain);
-}
diff --git a/PWG2/RESONANCES/macros/CreateAnalysisManager.C b/PWG2/RESONANCES/macros/CreateAnalysisManager.C
deleted file mode 100644 (file)
index 44f0883..0000000
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// This macro creates the AnalysisManager containing specific tasks for resonances.
-// The created object is used in another macro which runs effectively the analysis.
-//
-// Arguments:
-//  - a flag to know if the macro is being executed in PROOF or not (should not be touched)
-//  - output filename
-//  - a string containing all macroes which define pair manager for the analysis,
-//    which are supposed to be defined in the standard ROOT style, that is a macro
-//    with a function with the same name; they can be more than one, separated by colons (':')
-//
-// In this macro, the user should play with the following things:
-//  - what pairs to use (second argument)
-//  - what kind of source data to use (third argument)
-//
-
-AliAnalysisManager* CreateAnalysisManager
-(
-  Bool_t                             isProof,
-  const char                        *fileOut   = "rsn.root",
-  const char                        *macroList = "CreatePairsPhi.C",
-  AliRsnAnalysisTaskBase::EInputType inputType = AliRsnAnalysisTaskBase::kESDMC,
-)
-{
-  // default path containing all macroes described in 2nd argument:
-  // ...for local analysis, it goes to the AliRoot path:
-  TString strMacroListPath(Form("%s/PWG2/RESONANCES/macros", getenv("ALICE_ROOT")));
-  // ...for PROOF analysis from lxplus, the macro is probably in the same directory
-  if (isProof) strMacroListPath = ".";
-  // (of course one can play with this variable)
-  cout << "Loaded macro path: " << strMacroListPath.Data() << endl;
-  
-  // initialize analysis manager
-  AliAnalysisManager *mgr = new AliAnalysisManager("RsnTEST");
-  if (!mgr) AliError("no Analysis Mgr");
-
-  // initialize analysis task
-  // the method "SetInputType" is used to tell the task what kind of input is read;
-  // in this case we are reading ESD data with MC info, otherwise one must use
-  // kESD, kAOD, kMC or kRSN to read files already in the internal non-standard AOD of this package
-  AliRsnAnalysisSE *task = new AliRsnAnalysisSE("AliRsnAnalysisSE");
-  task->SetInputType(inputType, mgr, kTRUE);
-  task->SetNumOfEventsInBuffer(2000);
-  
-  // Settings for the ESD-to-RSN conversion
-  // in this case we reject splitted tracks (worst one)
-  AliRsnReader *reader = task->GetReader();
-  reader->SetCheckSplit(kTRUE);
-  
-  // PID settings:
-  // define prior probabilities
-  AliRsnPID *pid = task->GetPID();
-  pid->SetPriorProbability(AliRsnPID::kElectron, 0.02);
-  pid->SetPriorProbability(AliRsnPID::kMuon,     0.02);
-  pid->SetPriorProbability(AliRsnPID::kPion,     0.83);
-  pid->SetPriorProbability(AliRsnPID::kKaon,     0.07);
-  pid->SetPriorProbability(AliRsnPID::kProton,   0.06);
-  pid->SetMaxPt(10.0);
-  pid->SetMinProb(0.5);
-  
-  // tokenize the argument to retrieve all macroes which define pair managers
-  TString strMacros(macroList);
-  TObjArray *macros = strMacros.Tokenize(":");
-  TObjString *macro = 0x0;
-  TObjArrayIter next(macros);
-  while ( (macro = (TObjString*)next()) ) {
-    TString str = macro->GetString();
-    // different methods for PROOF and others
-    if (isProof) {
-      cout << "PROOF: loading " << str.Data() << endl;
-      gProof->Load(Form("%s/%s", strMacroListPath.Data(), str.Data())); 
-    }
-    else {
-      cout << "LOCAL: loading " << str.Data() << endl;
-      gROOT->LoadMacro(Form("%s/%s", strMacroListPath.Data(), str.Data()));
-    }
-    str.ReplaceAll(".C", "()");
-    AliRsnPairMgr *pairMgr = (AliRsnPairMgr*)gROOT->ProcessLine(str.Data());
-    task->AddPairMgr(pairMgr);
-  }
-
-  // define containers:
-  // the AOD container of the AliAnalysisTaskSE is created as required
-  // but is not used for output, while another output container for histograms is created
-  AliAnalysisDataContainer *input  = mgr->CreateContainer("in", TChain::Class(), AliAnalysisManager::kInputContainer);
-  AliAnalysisDataContainer *dummy  = mgr->CreateContainer("dummy", TTree::Class(), AliAnalysisManager::kOutputContainer, "default");
-  AliAnalysisDataContainer *output = mgr->CreateContainer("Histograms", TList::Class(), AliAnalysisManager::kOutputContainer, fileOut);
-
-  // connect containers to AnalysisManager and return it
-  mgr->AddTask(task);
-  mgr->ConnectInput(task, 0, input);
-  mgr->ConnectOutput(task, 0, dummy);
-  mgr->ConnectOutput(task, 1, output);
-
-  return mgr;
-}
diff --git a/PWG2/RESONANCES/macros/CreatePairsPhi.C b/PWG2/RESONANCES/macros/CreatePairsPhi.C
deleted file mode 100644 (file)
index 7a09d77..0000000
+++ /dev/null
@@ -1,164 +0,0 @@
-//
-// Creates an AliRsnPairMgr containing all invmass spectra
-// for the PHI --> K+ K- resonance:
-//
-// - signal
-// - event mixing
-// - like-sign
-// - true pairs
-//
-// When required, PDG code of phi is 333
-//
-// In order to allow analysis customization, some user-defined parameters
-// are listed at the beginning of this macro, to define some details like
-// the number of event mixing to do, and what PID to be used.
-// Since they are many, they are hard-coded in the macro and the user should
-// take care of them when launching it for an analysis.
-// Moreover, here some cuts are defined, which are very general: if a user
-// wants to add more specific cuts, he should take a look to the "CUTS" section
-// of this macro.
-//
-// The idea of this macro is to be loaded and launched from another
-// upper-level macro which prepares the AnalysisTask object to run it,
-// which is defined in "CreateAnalysisManager.C" macro in this directory
-//
-
-AliRsnPairMgr* CreatePairsPhi(const char *name = "PHI")
-{
-  AliRsnPairMgr  *pairMgr  = new AliRsnPairMgr(name);
-
-  // ========== USER CUSTOMIZATION VARIABLES ==========
-
-  Int_t   iResPDG             = 333;
-  Int_t   nMixEvents          = 10;
-  Bool_t  boolUseNoPID        = kTRUE;
-  Bool_t  boolUseRealisticPID = kTRUE;
-  Bool_t  boolUsePerfectPID   = kTRUE;
-
-  // ======= END USER CUSTOMIZATION VARIABLES =========
-
-  // =========== DEFINE PAIRS ==============
-
-  // decay tree definitions
-  // for a PHI resonance (PDG = 333) decaying into K+ K-
-  // and for related like-sign pairs
-  AliRsnPairDef *defUnlike = new AliRsnPairDef(AliRsnPID::kKaon, '+', AliRsnPID::kKaon, '-', iResPDG);
-  AliRsnPairDef *defLikePP = new AliRsnPairDef(AliRsnPID::kKaon, '+', AliRsnPID::kKaon, '+', iResPDG);
-  AliRsnPairDef *defLikeMM = new AliRsnPairDef(AliRsnPID::kKaon, '-', AliRsnPID::kKaon, '-', iResPDG);
-
-  // No PID
-  AliRsnPair *pairUnlike_NoPID_Signal = new AliRsnPair(AliRsnPair::kNoPID, defUnlike);
-  AliRsnPair *pairUnlike_NoPID_True   = new AliRsnPair(AliRsnPair::kNoPID, defUnlike);
-  AliRsnPair *pairUnlike_NoPID_Mix    = new AliRsnPair(AliRsnPair::kNoPIDMix, defUnlike);
-  AliRsnPair *pairLikePP_NoPID        = new AliRsnPair(AliRsnPair::kNoPID, defLikePP);
-  AliRsnPair *pairLikeMM_NoPID        = new AliRsnPair(AliRsnPair::kNoPID, defLikeMM);
-  // end No PID
-
-  // Perfect PID
-  AliRsnPair *pairUnlike_PerfectPID_Signal = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike);
-  AliRsnPair *pairUnlike_PerfectPID_True   = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike);
-  AliRsnPair *pairUnlike_PerfectPID_Mix    = new AliRsnPair(AliRsnPair::kPerfectPIDMix, defUnlike);
-  AliRsnPair *pairLikePP_PerfectPID        = new AliRsnPair(AliRsnPair::kPerfectPID, defLikePP);
-  AliRsnPair *pairLikeMM_PerfectPID        = new AliRsnPair(AliRsnPair::kPerfectPID, defLikeMM);
-  // end Perfect PID
-
-  // Perfect PID
-  AliRsnPair *pairUnlike_RealisticPID_Signal = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike);
-  AliRsnPair *pairUnlike_RealisticPID_True   = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike);
-  AliRsnPair *pairUnlike_RealisticPID_Mix    = new AliRsnPair(AliRsnPair::kRealisticPIDMix, defUnlike);
-  AliRsnPair *pairLikePP_RealisticPID        = new AliRsnPair(AliRsnPair::kRealisticPID, defLikePP);
-  AliRsnPair *pairLikeMM_RealisticPID        = new AliRsnPair(AliRsnPair::kRealisticPID, defLikeMM);
-  // end Realistic PID
-
-  // =========== END DEFINE PAIRS ==============
-
-  // =========== CUTS ==============
-
-  // cuts on tracks:
-  // - defined in 'AddRsnAnalysisTask.C' for single-step analysis
-
-  // cuts on pairs:
-  // - true daughters of a phi resonance (only for true pairs histogram)
-  AliRsnCut *cutTruePair = new AliRsnCut("cutTrue", "cutTrue", AliRsnCut::kIsTruePair, iResPDG);
-
-  // cut set definition for true pairs
-  AliRsnCutSet *cutSetPairTrue = new AliRsnCutSet("truePairs");
-  cutSetPairTrue->AddCut(cutTruePair);
-  cutSetPairTrue->SetCutScheme("cutTrue");
-
-  // define cut manager for true pairs
-  AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True pairs");
-  cutMgrTrue->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
-
-  // add cuts to pair analysis
-  pairUnlike_NoPID_True->SetCutMgr(cutMgrTrue);
-  pairUnlike_PerfectPID_True->SetCutMgr(cutMgrTrue);
-  pairUnlike_RealisticPID_True->SetCutMgr(cutMgrTrue);
-
-  // =========== END CUTS ==============
-
-  // =========== FUNCTIONS ==============
-
-  // define histogram templates
-  AliRsnHistoDef *hdIM  = new AliRsnHistoDef(800, 0.0, 2.0);     // invmass
-  AliRsnHistoDef *hdRES = new AliRsnHistoDef(200, -10.0, 10.0);  // resolution
-
-  // functions
-  AliRsnFunction *fcnIM  = new AliRsnFunction(AliRsnFunction::kInvMass, hdIM);      // invmass
-  AliRsnFunction *fcnRES = new AliRsnFunction(AliRsnFunction::kResolution, hdRES);    // IM resolution
-
-  // uncomment these lines when doing analysis in momentum bins
-  // in this case, take care of the dimension and values in the template array
-  Double_t mom[7] = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 10.0};
-  fcnIM->SetBinningCut(AliRsnCut::kTransMomentum, 7, mom);
-  fcnRES->SetBinningCut(AliRsnCut::kTransMomentum, 7, mom);
-
-  pairUnlike_NoPID_Signal->AddFunction(fcnIM);
-  pairUnlike_NoPID_True->AddFunction(fcnIM);
-  pairUnlike_NoPID_Mix->AddFunction(fcnIM);
-  pairLikePP_NoPID->AddFunction(fcnIM);
-  pairLikeMM_NoPID->AddFunction(fcnIM);
-
-  pairUnlike_PerfectPID_Signal->AddFunction(fcnIM);
-  pairUnlike_PerfectPID_True->AddFunction(fcnIM);
-  pairUnlike_PerfectPID_Mix->AddFunction(fcnIM);
-  pairLikePP_PerfectPID->AddFunction(fcnIM);
-  pairLikeMM_PerfectPID->AddFunction(fcnIM);
-
-  pairUnlike_RealisticPID_Signal->AddFunction(fcnIM);
-  pairUnlike_RealisticPID_True->AddFunction(fcnIM);
-  pairUnlike_RealisticPID_Mix->AddFunction(fcnIM);
-  pairLikePP_RealisticPID->AddFunction(fcnIM);
-  pairLikeMM_RealisticPID->AddFunction(fcnIM);
-
-  pairUnlike_NoPID_Signal->AddFunction(fcnRES);
-  pairUnlike_PerfectPID_Signal->AddFunction(fcnRES);
-  pairUnlike_RealisticPID_Signal->AddFunction(fcnRES);
-
-  // =========== END FUNCTIONS =============
-
-  if (boolUseNoPID) {
-    pairMgr->AddPair(pairUnlike_NoPID_Signal);
-    pairMgr->AddPair(pairUnlike_NoPID_True);
-    pairMgr->AddPair(pairUnlike_NoPID_Mix);
-    pairMgr->AddPair(pairLikePP_NoPID);
-    pairMgr->AddPair(pairLikeMM_NoPID);
-  }
-
-  if (boolUsePerfectPID) {
-    pairMgr->AddPair(pairUnlike_PerfectPID_Signal);
-    pairMgr->AddPair(pairUnlike_PerfectPID_True);
-    pairMgr->AddPair(pairUnlike_PerfectPID_Mix);
-    pairMgr->AddPair(pairLikePP_PerfectPID);
-    pairMgr->AddPair(pairLikeMM_PerfectPID);
-  }
-
-  if (boolUseRealisticPID) {
-    pairMgr->AddPair(pairUnlike_RealisticPID_Signal);
-    pairMgr->AddPair(pairUnlike_RealisticPID_True);
-    pairMgr->AddPair(pairUnlike_RealisticPID_Mix);
-    pairMgr->AddPair(pairLikePP_RealisticPID);
-    pairMgr->AddPair(pairLikeMM_RealisticPID);
-  }
-  return pairMgr;
-}
index c9e7dba906f31cc1e0d93c01917f249d310d71fb..450e8c1841f527f525859f220aadd50ba4fb923b 100644 (file)
-TObjArray DefineFunctions()
+AliRsnPairManager *RsnConfig_PHI(const char *name="PHI")
 {
-//
-// Here, all used AliRsnFunction objects should be defined.
-// Then, by keeping in mind the sorting order of each one,
-// they are recovered to be inserted in AliRanPairs
-//
-
-  TObjArray out(0);
-
-  // define axes
-  AliRsnFunctionAxis *axisIM   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairInvMass,    1000,  0.0,   2.0);
-  AliRsnFunctionAxis *axisPt   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairPt,           10,  0.0,  10.0);
-  AliRsnFunctionAxis *axisEta  = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairEta,          10, -1.0,   1.0);
-  AliRsnFunctionAxis *axisMult = new AliRsnFunctionAxis(AliRsnFunctionAxis::kEventMult,         8,  0.0, 200.0);
-
-  // function #0:
-  // invariant mass w.r. to kinematics variables
-
-
-AliRsnFunction* DefineFunctionIM()
-{
-//
-// In general, for all processed pairs in one analysis the same functions are computed.
-// Then, they are defined separately here and added in the same way to all pairs.
-//
-
-  // define all binnings
-  AliRsnFunctionAxis *axisIM   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairInvMass,    1000,  0.0,   2.0);
-  AliRsnFunctionAxis *axisP1   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kTrack1P,          50,  0.0,   5.0);
-  AliRsnFunctionAxis *axisP2   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kTrack2P,          50,  0.0,   5.0);
-  AliRsnFunctionAxis *axisPt   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairPt,           10,  0.0,  10.0);
-  AliRsnFunctionAxis *axisEta  = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairEta,          10, -1.0,   1.0);
-  AliRsnFunctionAxis *axisMult = new AliRsnFunctionAxis(AliRsnFunctionAxis::kEventMult,         8,  0.0, 200.0);
-
-  // function #0:
-  // inv. mass w.r. to momentum and multiplicity
-  AliRsnFunction *fcn0 = new AliRsnFunction;
-  fcn->AddAxis(axisIM);
-  fcn->AddAxis(axisPt);
-  fcn->AddAxis(axisMult);
-  out->AddLast(fcn0);
-
-  // function #1:
-  // inv. mass w.r. to eta and multiplicity
-  AliRsnFunction *fcn1 = new AliRsnFunction;
-  fcn->AddAxis(axisIM);
-  fcn->AddAxis(axisEta);
-  fcn->AddAxis(axisMult);
-  out->AddLast(fcn1);
-
-  // function #2:
-  // total daughter momenta w.r. to inv. mass
-  AliRsnFunction *fcn2 = new AliRsnFunction;
-  fcn->AddAxis(axisP1);
-  fcn->AddAxis(axisP2);
-  fcn->AddAxis(axisIM);
-  out->AddLast(fcn2);
-
-  return out;
+  return   CreatePairs(name, 333, AliAODTrack::kKaon, AliAODTrack::kKaon, 0, 10000);
 }
 
-AliRsnPairManager* CreatePairsNoPID
-(
-  const char            *pairMgrName,    // name for the pair manager
-  Int_t                  resonancePDG,   // PDG code of resonance (for true pairs)
-  AliPID::EParticleType  type1,          // PID of one member of decay (+)
-  AliPID::EParticleType  type2,          // PID of other member of decay (-)
-  Double_t               bbCut = 10000.0 // cut on Bethe-Bloch
-)
+AliRsnPairManager *RsnConfig_KSTAR(const char *name="KSTAR")
 {
-//
-// Creates an AliRsnPairMgr for a specified resonance, which contains:
-// - signal (inv. mass)
-// - event mixing (inv. mass)
-// - like-sign (inv. mass)
-// - true pairs (inv. mass, resolution)
-//
-// For all pairs, a binning in Pt and Eta is provided, and a cut in multiplicity
-// which defines a multiplicity bin where the analysis is computed.
-//
-// Arguments define how the pair manager must be built, and are explained above
-//
-
-  AliRsnPairManager  *pairMgr  = new AliRsnPairManager(pairMgrName);
-
-  // === PAIR DEFINITIONS =========================================================================
-
-  // if particle #1 and #2 are different, two histograms must be built
-  // for each scheme (signal, true, mixed, like-sign) exchanging both particles and signs
-  Int_t i, j, nArray = 1;
-  if (type1 != type2) nArray = 2;
-
-  AliRsnPairDef *defUnlike[2] = {0, 0};
-  AliRsnPairDef *defLikePP[2] = {0, 0};
-  AliRsnPairDef *defLikeMM[2] = {0, 0};
-
-  defUnlike[0] = new AliRsnPairDef(type1, '+', type2, '-', resonancePDG);
-  defLikePP[0] = new AliRsnPairDef(type1, '+', type2, '+', resonancePDG);
-  defLikeMM[0] = new AliRsnPairDef(type1, '-', type2, '-', resonancePDG);
-
-  defUnlike[1] = new AliRsnPairDef(type2, '+', type1, '-', resonancePDG);
-  defLikePP[1] = new AliRsnPairDef(type2, '+', type1, '+', resonancePDG);
-  defLikeMM[1] = new AliRsnPairDef(type2, '-', type1, '-', resonancePDG);
-
-  // === PAIR ANALYSIS ENGINES ====================================================================
-
-  // define null (dummy) objects and initialize only the ones which are needed,
-  // depending again on particle types;
-  // array is organized as follows:
-  // [0] - true pairs
-  // [1] - signal
-  // [2] - like PP
-  // [3] - like MM
-  AliRsnPair *noPID[2][4] = {0,0,0,0,0,0,0,0};
-
-  for (i = 0; i < nArray; i++) {
-    noPID[i][0] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
-    noPID[i][1] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
-    noPID[i][2] = new AliRsnPair(AliRsnPair::kNoPID, defLikePP[i]);
-    noPID[i][3] = new AliRsnPair(AliRsnPair::kNoPID, defLikeMM[i]);
-  }
-
-  // === CUTS =====================================================================================
-
-  // cuts for tracks:
-  // -- Bethe-Bloch & required kaon PID
-  AliRsnCutBetheBloch *cutKaonBB = new AliRsnCutBetheBloch("cutKaon", bbCut, AliPID::kKaon);
-  cutKaonBB->SetCalibConstant(0, 0.76176e-1);
-  cutKaonBB->SetCalibConstant(1, 10.632);
-  cutKaonBB->SetCalibConstant(2, 0.13279e-4);
-  cutKaonBB->SetCalibConstant(3, 1.8631);
-  cutKaonBB->SetCalibConstant(4, 1.9479);
-
-  // cuts on pairs:
-  // -- true daughters of a phi resonance (only for true pairs histogram)cutSetPairTrue->AddCut(cutTrue);
-  AliRsnCutStd *cutTruePair = new AliRsnCutStd("cutTrue", AliRsnCutStd::kTruePair, resonancePDG);
-
-  // cuts on event:
-  // -- none (specified for whole task)
-
-  // cut set definition for all pairs
-  AliRsnCutSet *cutSetParticle = new AliRsnCutSet("trackCuts");
-  cutSetParticle->AddCut(cutKaonBB);
-  cutSetParticle->SetCutScheme("cutKaonBB");
-
-  // cut set definition for true pairs
-  AliRsnCutSet *cutSetPairTrue = new AliRsnCutSet("truePairs");
-  cutSetPairTrue->AddCut(cutTruePair);
-  cutSetPairTrue->SetCutScheme("cutTrue");
-
-  // cut manager for all pairs
-  AliRsnCutMgr *cutMgrAll = new AliRsnCutMgr("std", "All");
-  cutMgrAll->SetCutSet(AliRsnCut::kParticle, cutSetParticle);
-
-  // cut manager for all pairs
-  AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True");
-  cutMgrTrue->SetCutSet(AliRsnCut::kParticle, cutSetParticle);
-  cutMgrTrue->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
-
-  for (i = 0; i < nArray; i++) {
-    noPID[i][0]->SetCutMgr(cutMgrTrue);
-    for (j = 1; j < 4; j++) {
-      noPID[i][j]->SetCutMgr(cutMgrAll);
-    }
-  }
-
-  // === FUNCTIONS ================================================================================
-
-  TObjArray list = DefineFunctions();
-  AliRsnFunction *fcn0  = (AliRsnFunction*)list[0];
-  AliRsnFunction *fcn1  = (AliRsnFunction*)list[1];
-  AliRsnFunction *fcn0  = (AliRsnFunction*)list[0];
-
-  for (i = 0; i < nArray; i++) {
-    for (j = 0; j < 4; j++) {
-      noPID[i][j]->AddFunction(fcn0);
-      noPID[i][j]->AddFunction(fcn1);
-      if (j < 2) noPID[i][j]->AddFunction(fcn2);
-    }
-  }
-
-  // === ADD TO PAIR MANAGER ======================================================================
-
-  for (i = 0; i < nArray; i++) {
-    for (j = 0; j < 4; j++) {
-      pairMgr->AddPair(noPID[i][j]);
-    }
-  }
-
-  return pairMgr;
+  return CreatePairs(name, 313, AliAODTrack::kPion, AliAODTrack::kKaon, 0, 10000);
 }
 
-AliRsnPairManager* CreatePairsPID
+
+AliRsnPairManager* CreatePairs
 (
-  const char            *pairMgrName,    // name for the pair manager
-  Int_t                  resonancePDG,   // PDG code of resonance (for true pairs)
-  AliPID::EParticleType  type1,          // PID of one member of decay (+)
-  AliPID::EParticleType  type2           // PID of other member of decay (-)
+  const char       *pairMgrName,    // name for the pair manager
+  Int_t             resonancePDG,   // PDG code of resonance (for true pairs)
+  AliAODTrack::AODTrkPID_t type1,          // PID of one member of decay (+)
+  AliAODTrack::AODTrkPID_t  type2,          // PID of other member of decay (-)
+  Int_t             multMin,        // lower edge of multiplicity cut
+  Int_t             multMax         // upper edge of multiplicity cut
 )
 {
 //
@@ -213,6 +33,9 @@ AliRsnPairManager* CreatePairsPID
 //
 
   AliRsnPairManager  *pairMgr  = new AliRsnPairManager(pairMgrName);
+  //cout << "Creating " << pairMgrName << endl;
+
+//   return pairMgr;
 
   // === PAIR DEFINITIONS =========================================================================
 
@@ -240,90 +63,137 @@ AliRsnPairManager* CreatePairsPID
   // array is organized as follows:
   // [0] - true pairs
   // [1] - signal
-  // [2] - like PP
-  // [3] - like MM
-  AliRsnPair *perfectPID[2][4]   = {0,0,0,0,0,0,0,0};
-  AliRsnPair *realisticPID[2][4] = {0,0,0,0,0,0,0,0};
+  // [2] - mixing
+  // [3] - like PP
+  // [4] - like MM
+  AliRsnPair *noPIDnoCut[2][5]   = {0,0,0,0,0,0,0,0,0,0};
+  AliRsnPair *noPIDwithCut[2][5] = {0,0,0,0,0,0,0,0,0,0};
+  AliRsnPair *realisticPID[2][5] = {0,0,0,0,0,0,0,0,0,0};
+  AliRsnPair *perfectPID[2][5]   = {0,0,0,0,0,0,0,0,0,0};
 
   for (i = 0; i < nArray; i++) {
-    perfectPID[i][0] = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike[i]);
-    perfectPID[i][1] = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike[i]);
-    perfectPID[i][2] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikePP[i]);
-    perfectPID[i][3] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikeMM[i]);
+    noPIDnoCut[i][0] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
+    noPIDnoCut[i][1] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
+    noPIDnoCut[i][2] = new AliRsnPair(AliRsnPair::kNoPIDMix, defUnlike[i]);
+    noPIDnoCut[i][3] = new AliRsnPair(AliRsnPair::kNoPID, defLikePP[i]);
+    noPIDnoCut[i][4] = new AliRsnPair(AliRsnPair::kNoPID, defLikeMM[i]);
+
+    noPIDwithCut[i][0] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
+    noPIDwithCut[i][1] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
+    noPIDwithCut[i][2] = new AliRsnPair(AliRsnPair::kNoPIDMix, defUnlike[i]);
+    noPIDwithCut[i][3] = new AliRsnPair(AliRsnPair::kNoPID, defLikePP[i]);
+    noPIDwithCut[i][4] = new AliRsnPair(AliRsnPair::kNoPID, defLikeMM[i]);
 
     realisticPID[i][0] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
     realisticPID[i][1] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
-    realisticPID[i][2] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikePP[i]);
-    realisticPID[i][3] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikeMM[i]);
+    realisticPID[i][2] = new AliRsnPair(AliRsnPair::kRealisticPIDMix, defUnlike[i]);
+    realisticPID[i][3] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikePP[i]);
+    realisticPID[i][4] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikeMM[i]);
+
+    perfectPID[i][0] = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike[i]);
+    perfectPID[i][1] = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike[i]);
+    perfectPID[i][2] = new AliRsnPair(AliRsnPair::kPerfectPIDMix, defUnlike[i]);
+    perfectPID[i][3] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikePP[i]);
+    perfectPID[i][4] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikeMM[i]);
   }
 
   // === CUTS =====================================================================================
 
+  /*
   // cuts for tracks:
-  // -- nothing
+  // - probability to be a kaon (only for kaons)
+  AliRsnCutStd *cutAssignedKaon = new AliRsnCut("cutAssignedKaon", "", AliRsnCut::kAssignedPID, AliAODTrack::kKaon);
+  AliRsnCutStd *cutProbKaon = new AliRsnCut("cutProbKaon", "", AliRsnCut::kPIDProbForSpecies, (Int_t)AliAODTrack::kKaon);
+  cutProbKaon->SetCutValues(AliRsnCut::kPIDProbForSpecies, 0.15, 1.0);
+  */
+  AliRsnCutSet *cutSetTrack = new AliRsnCutSet("tracks");
+  //cutSetTrack->AddCut(cutAssignedKaon);
+  //cutSetTrack->AddCut(cutProbKaon);
+  //cutSetTrack->SetCutScheme("(!cutAssignedKaon)|(cutAssignedKaon&cutProbKaon)");
 
   // cuts on pairs:
-  // -- true daughters of a phi resonance (only for true pairs histogram)cutSetPairTrue->AddCut(cutTrue);
-  AliRsnCutStd *cutTruePair = new AliRsnCutStd("cutTrue", AliRsnCutStd::kTruePair, resonancePDG);
-
-  // cut set definition for true pairs
+  // - true daughters of the defined resonance (only for true pairs histogram)
+  AliRsnCutStd *cutPairTrue    = new AliRsnCutStd("cutTrue", "", AliRsnCut::kTruePair, resonancePDG);
   AliRsnCutSet *cutSetPairTrue = new AliRsnCutSet("truePairs");
-  cutSetPairTrue->AddCut(cutTruePair);
+  cutSetPairTrue->AddCut(cutPairTrue);
   cutSetPairTrue->SetCutScheme("cutTrue");
 
-  // cut manager for all pairs
-  AliRsnCutMgr *cutMgrAll = new AliRsnCutMgr("std", "All");
+  // cuts on events:
+  // - multiplicity bin
+  AliRsnCutStd *cutEventMult = new AliRsnCutStd("cutMult", "", AliRsnCut::kMultiplicity, multMin, multMax);
+  AliRsnCutSet *cutSetEvent  = new AliRsnCutSet("multiplicity");
+  cutSetEvent->AddCut(cutEventMult);
+  cutSetEvent->SetCutScheme("cutMult");
 
-  // cut manager for all pairs
-  AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True");
+  // define cut manager for NOT true pairs
+  AliRsnCutMgr *cutMgr = new AliRsnCutMgr("default", "All pairs");
+  cutMgr->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
+
+  // define cut manager for true pairs
+  AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True pairs");
+  cutMgrTrue->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
   cutMgrTrue->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
 
+  // define cut manager for NOPID with kaon prob cut
+  // define cut manager for NOT true pairs
+  AliRsnCutMgr *cutMgrProb = new AliRsnCutMgr("probK", "All pairs with kaon probability cut");
+  cutMgrProb->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
+  cutMgrProb->SetCutSet(AliRsnCut::kParticle, cutSetTrack);
+
+  // define cut manager for true pairs
+  AliRsnCutMgr *cutMgrTrueProb = new AliRsnCutMgr("true+probK", "True pairs with kaon probability cut");
+  cutMgrTrueProb->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
+  cutMgrTrueProb->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
+  cutMgrTrueProb->SetCutSet(AliRsnCut::kParticle, cutSetTrack);
+
+  // add cuts to pair analysis
   for (i = 0; i < nArray; i++) {
-    perfectPID[i][0]->SetCutMgr(cutMgrTrue);
+    noPIDnoCut[i][0]->SetCutMgr(cutMgrTrue);
+    noPIDwithCut[i][0]->SetCutMgr(cutMgrTrueProb);
     realisticPID[i][0]->SetCutMgr(cutMgrTrue);
-    for (j = 1; j < 4; j++) {
-      perfectPID[i][j]->SetCutMgr(cutMgrAll);
-      realisticPID[i][j]->SetCutMgr(cutMgrAll);
+    perfectPID[i][0]->SetCutMgr(cutMgrTrue);
+    for (j = 1; j < 5; j++) {
+      noPIDnoCut[i][j]->SetCutMgr(cutMgr);
+      noPIDwithCut[i][j]->SetCutMgr(cutMgrProb);
+      realisticPID[i][j]->SetCutMgr(cutMgr);
+      perfectPID[i][j]->SetCutMgr(cutMgr);
     }
   }
 
   // === FUNCTIONS ================================================================================
 
-  TObjArray list = DefineFunctions();
-  AliRsnFunction *fcn0  = (AliRsnFunction*)list[0];
-  AliRsnFunction *fcn1  = (AliRsnFunction*)list[1];
-  AliRsnFunction *fcn0  = (AliRsnFunction*)list[0];
+  // define histogram templates
+  AliRsnFunctionAxis *axisIM   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairInvMass,    1000,  0.0,   2.0);
+  AliRsnFunctionAxis *axisPt   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairPt,           10,  0.0,  10.0);
+  AliRsnFunctionAxis *axisEta  = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairEta,          20, -1.0,   1.0);
+  AliRsnFunctionAxis *axisMult = new AliRsnFunctionAxis(AliRsnFunctionAxis::kEventMult,         8,  0.0, 200.0);
 
-  for (i = 0; i < nArray; i++) {
-    for (j = 0; j < 4; j++) {
-      noPID[i][j]->AddFunction(fcn0);
-      noPID[i][j]->AddFunction(fcn1);
-      if (j < 2) noPID[i][j]->AddFunction(fcn2);
-    }
-  }
+  // define functions axes
+  AliRsnFunction *fcnIM = new AliRsnFunction;
+  fcnIM->AddAxis(axisIM);
+  fcnIM->AddAxis(axisPt);
+  fcnIM->AddAxis(axisEta);
+  fcnIM->AddAxis(axisMult);
 
   for (i = 0; i < nArray; i++) {
-    for (j = 0; j < 4; j++) {
-      perfectPID[i][j]->AddFunction(fcn0);
-      realisticPID[i][j]->AddFunction(fcn0);
-      perfectPID[i][j]->AddFunction(fcn1);
-      realisticPID[i][j]->AddFunction(fcn1);
-      if (j < 2) {
-        perfectPID[i][j]->AddFunction(fcn2);
-        realisticPID[i][j]->AddFunction(fcn2);
-      }
+    for (j = 0; j < 5; j++) {
+      noPIDnoCut[i][j]->AddFunction(fcnIM);
+      noPIDwithCut[i][j]->AddFunction(fcnIM);
+      realisticPID[i][j]->AddFunction(fcnIM);
+      perfectPID[i][j]->AddFunction(fcnIM);
     }
   }
 
   // === ADD TO PAIR MANAGER ======================================================================
 
   for (i = 0; i < nArray; i++) {
-    for (j = 0; j < 4; j++) {
-      pairMgr->AddPair(perfectPID[i][j]);
+    for (j = 0; j < 5; j++) {
+      pairMgr->AddPair(noPIDnoCut[i][j]);
+      pairMgr->AddPair(noPIDwithCut[i][j]);
       pairMgr->AddPair(realisticPID[i][j]);
+      pairMgr->AddPair(perfectPID[i][j]);
     }
   }
 
   return pairMgr;
 }
-
diff --git a/PWG2/RESONANCES/macros/RsnConfigTest.C b/PWG2/RESONANCES/macros/RsnConfigTest.C
deleted file mode 100644 (file)
index 1bb37b2..0000000
+++ /dev/null
@@ -1,187 +0,0 @@
-AliRsnPairManager *RsnConfigTest(const char *name="PHI->KK")
-{
-  AliRsnPairManager  *pairMgr  = new AliRsnPairManager(name);
-
-  AliRsnPairDef *defKPKM = new AliRsnPairDef(AliAODTrack::kKaon, '+', AliAODTrack::kKaon, '-');
-  AliRsnPairDef *defKPKP = new AliRsnPairDef(AliAODTrack::kKaon, '+', AliAODTrack::kKaon, '+');
-  AliRsnPairDef *defKMKM = new AliRsnPairDef(AliAODTrack::kKaon, '-', AliAODTrack::kKaon, '-');
-
-  // =========== DEFINE PAIRS ==============
-
-  // NoPID
-  AliRsnPair *pairKPKM_N  = new AliRsnPair(AliRsnPair::kNoPID, defKPKM);
-  AliRsnPair *pairKPKM_NS = new AliRsnPair(AliRsnPair::kNoPID, defKPKM);
-  AliRsnPair *pairKPKM_NM = new AliRsnPair(AliRsnPair::kNoPIDMix, defKPKM/*, 5*/);
-  AliRsnPair *pairKPKP_N  = new AliRsnPair(AliRsnPair::kNoPID, defKPKP);
-  AliRsnPair *pairKMKM_N  = new AliRsnPair(AliRsnPair::kNoPID, defKMKM);
-  // end NoPID
-
-  // REALISTIC PID
-  AliRsnPair *pairKPKM_R = new AliRsnPair(AliRsnPair::kRealisticPID, defKPKM);
-  AliRsnPair *pairKPKP_R = new AliRsnPair(AliRsnPair::kRealisticPID, defKPKP);
-  AliRsnPair *pairKMKM_R = new AliRsnPair(AliRsnPair::kRealisticPID, defKMKM);
-  AliRsnPair *pairKPKM_RM = new AliRsnPair(AliRsnPair::kRealisticPIDMix, defKPKM/*,5*/);
-  // end REALISTIC PID
-
-  // REALISTIC PID Signal
-  AliRsnPair *pairKPKM_RS = new AliRsnPair(AliRsnPair::kRealisticPID, defKPKM);
-  AliRsnPair *pairKPKM_RS2 = new AliRsnPair(AliRsnPair::kRealisticPID, defKPKM);
-  // end REALISTIC PID Signal
-
-  // PERFECT PID
-  AliRsnPair *pairKPKM_P = new AliRsnPair(AliRsnPair::kPerfectPID, defKPKM);
-  // end PERFECT PID
-  // =========== END DEFINE PAIRS ==============
-
-//   // =========== CUTS ==============
-  ULong_t status = AliESDtrack::kESDpid;
-  // status |=| AliESDtrack::kITSpid | AliESDtrack::kTPCpid;
-  // status |= AliESDtrack::kTOFpid;
-
-  AliRsnCut *cutStatus = new AliRsnCut("statusCut_ITS_TPC",
-                                       "Status Cut for ITS and TPC",
-                                       AliRsnCut::kStatus,
-                                       status);
-  AliRsnCut *cutESDLabelEqual = new AliRsnCut("cutESDLabelEqual",
-                                              "cutESDLabelEqual",
-                                              AliRsnCut::kIsLabelEqual);
-  AliRsnCut *cutPtESDPart = new AliRsnCut("cutPtESDPart", "cutPtESDPart", AliRsnCut::kTransMomentum, 0.2, 10000.0);
-  AliRsnCut *cutEtaESDPart = new AliRsnCut("cutESDEta", "cutESDEta", AliRsnCut::kEta, -0.9,0.9);
-
-  AliRsnCutSet *cutSetParticleESD = new AliRsnCutSet("StatusCut");
-//   cutSetParticleESD->AddCut(cutStatus);
-//   cutSetParticleESD->SetCutScheme("statusCut_ITS_TPC");
-  cutSetParticleESD->AddCut(cutPtESDPart);
-  cutSetParticleESD->AddCut(cutEtaESDPart);
-//   cutSetParticleESD->AddCut(cutStatus);
-//   cutSetParticleESD->SetCutScheme("cutPtESDPart&statusCut_ITS_TPC");
-  cutSetParticleESD->SetCutScheme("cutPtESDPart&cutESDEta");
-
-  AliRsnCutSet *cutSetPairESD = new AliRsnCutSet("esdLabel");
-  cutSetPairESD->AddCut(cutESDLabelEqual);
-  cutSetPairESD->SetCutScheme("!cutESDLabelEqual");
-//
-  AliRsnCut *cutPtMCPart = new AliRsnCut("cutPtMCPart", "cutPtMCPart", AliRsnCut::kTransMomentumMC, 0.2, 10000.0);
-  AliRsnCut *cutEtaMCPart = new AliRsnCut("cutMcEta", "cutMcEta", AliRsnCut::kEtaMC, -0.9,0.9);
-  AliRsnCutSet *cutSetParticleMC = new AliRsnCutSet("MCCut");
-  cutSetParticleMC->AddCut(cutPtMCPart);
-  cutSetParticleMC->AddCut(cutEtaMCPart);
-  cutSetParticleMC->SetCutScheme("cutPtMCPart&cutMcEta");
-//
-  AliRsnCutMgr *cutMgrESD = new AliRsnCutMgr("cutMgr", "Cut Mgr");
-  cutMgrESD->SetCutSet(AliRsnCut::kParticle, cutSetParticleESD);
-  cutMgrESD->SetCutSet(AliRsnCut::kPair, cutSetPairESD);
-//
-  AliRsnCut *cutIsTruePair = new AliRsnCut("cutIsTruePair", "cutIsTruePair", AliRsnCut::kIsTruePair, 333);
-//
-  AliRsnCutSet *cutSetPairSignal = new AliRsnCutSet("cutSetPairSignal");
-  cutSetPairSignal->AddCut(cutIsTruePair);
-  cutSetPairSignal->SetCutScheme("cutIsTruePair");
-//
-  AliRsnCutMgr *cutMgrSignal = new AliRsnCutMgr("cutMgrESDSignal","Cut Mgr Signal");
-  cutMgrSignal->SetCutSet(AliRsnCut::kParticle,cutSetParticleESD);
-  cutMgrSignal->SetCutSet(AliRsnCut::kParticle,cutSetParticleMC);
-  cutMgrSignal->SetCutSet(AliRsnCut::kPair,cutSetPairSignal);
-
-  AliRsnCutMgr *cutMgrSignal2 = new AliRsnCutMgr("cutMgrESDSignalNoCut","Cut Mgr Signal");
-//   cutMgrSignal2->SetCutSet(AliRsnCut::kParticle,cutSetParticleESD);
-  cutMgrSignal2->SetCutSet(AliRsnCut::kPair,cutSetPairSignal);
-
-  AliRsnCutMgr *cutMgrSignalMC = new AliRsnCutMgr("cutMgrMCSignal","Cut Mgr Signal");
-//   cutMgrSignalMC->SetCutSet(AliRsnCut::kParticle,cutSetParticleMC);
-  cutMgrSignalMC->SetCutSet(AliRsnCut::kPair,cutSetPairSignal);
-
-//   pairKPKM_N->SetCutMgr(cutMgrESD);
-//   // pairKPKM_NS->SetCutMgr(cutMgrESD);
-//   pairKPKM_NM->SetCutMgr(cutMgrESD);
-//   pairKPKP_N->SetCutMgr(cutMgrESD);
-//   pairKMKM_N->SetCutMgr(cutMgrESD);
-  pairKPKM_R->SetCutMgr(cutMgrESD);
-//   // pairKPKM_RS->SetCutMgr(cutMgrESD);
-//   pairKPKM_RM->SetCutMgr(cutMgrESD);
-  pairKPKP_R->SetCutMgr(cutMgrESD);
-  pairKMKM_R->SetCutMgr(cutMgrESD);
-//   pairKPKM_P->SetCutMgr(cutMgrESD);
-  //
-// //  pairKPKM_N->SetCutMgr(cutMgrSignal);
-//   pairKPKM_NS->SetCutMgr(cutMgrSignal);
-// //  pairKPKM_NM->SetCutMgr(cutMgrSignal);
-// //  pairKPKP_N->SetCutMgr(cutMgrSignal);
-// //  pairKMKM_N->SetCutMgr(cutMgrSignal);
-// //  pairKPKM_R->SetCutMgr(cutMgrSignal);
-  pairKPKM_RS->SetCutMgr(cutMgrSignal);
-  pairKPKM_RS2->SetCutMgr(cutMgrSignal2);
-//  pairKPKM_RM->SetCutMgr(cutMgrSignal);
-//  pairKPKP_R->SetCutMgr(cutMgrSignal);
-//  pairKMKM_R->SetCutMgr(cutMgrSignal);
-  pairKPKM_P->SetCutMgr(cutMgrSignalMC);
-
-//   // =========== END CUTS ==============
-  
-  // =========== FUNCTIONS ==============
-
-  Double_t mom[11] = {0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0};
-  Double_t eta[10] = {-0.9,-0.7,-0.5,-0.3,-0.1,0.1,0.3,0.5,0.7,0.9};
-//     AliRsnHistoDef *hdInvMass = new AliRsnHistoDef(1400, 0.6, 2.0);
-  AliRsnHistoDef *hdInvMass = new AliRsnHistoDef(200,0.9,1.1);
-  AliRsnHistoDef *hdInvMassMC = new AliRsnHistoDef(200,0.9,1.1);
-
-  AliRsnHistoDef *hdPt = new AliRsnHistoDef(100,0.0,5.0);
-  AliRsnHistoDef *hdEta = new AliRsnHistoDef(100,-2.0,2.0);
-  
-  Int_t num=0;
-  AliRsnFunction *fcnIM[10];
-
-  fcnIM[num] = new AliRsnFunction(AliRsnFunction::kInvMass,hdInvMass,kTRUE);
-  fcnIM[num]->SetBinningCut(AliRsnCut::kTransMomentum, 11, mom,0);
-  fcnIM[num]->SetBinningCut(AliRsnCut::kEta, 10, eta,1);
-  num++;
-
-//   fcnIMMC[num] = new AliRsnFunction(AliRsnFunction::kInvMassMC,hdInvMassMC, kTRUE);
-//   fcnIMMC[num]->SetBinningCut(AliRsnCut::kTransMomentum, 9, mom);
-//   num++;
-
-//   fcnIM[num] = new AliRsnFunction(AliRsnFunction::kPtSpectrum,hdPt,kTRUE);
-//   fcnIM[num]->SetBinningCut(AliRsnCut::kTransMomentum, 11, mom);
-//   num++;
-  
-  fcnIM[num] = new AliRsnFunction(AliRsnFunction::kEtaSpectrum,hdEta,kTRUE);
-//   fcnIM[num]->SetBinningCut(AliRsnCut::kEta, 11, eta);
-  fcnIM[num]->SetBinningCut(AliRsnCut::kTransMomentum, 11, mom,0);
-//   fcnIM[num]->SetBinningCut(AliRsnCut::kEta, 10, eta,1);
-  num++;
-
-  Int_t i;
-  for (i=0;i<num ;i++)
-  {
-    pairKPKM_N->AddFunction(fcnIM[i]);
-    pairKPKM_NS->AddFunction(fcnIM[i]);
-    pairKPKM_NM->AddFunction(fcnIM[i]);
-    pairKPKP_N->AddFunction(fcnIM[i]);
-    pairKMKM_N->AddFunction(fcnIM[i]);
-    pairKPKM_R->AddFunction(fcnIM[i]);
-    pairKPKM_RS->AddFunction(fcnIM[i]);
-    pairKPKM_RS2->AddFunction(fcnIM[i]);
-    pairKPKM_RM->AddFunction(fcnIM[i]);
-    pairKPKP_R->AddFunction(fcnIM[i]);
-    pairKMKM_R->AddFunction(fcnIM[i]);
-    pairKPKM_P->AddFunction(fcnIM[i]);
-
-  }
-  // =========== END FUNCTIONS =============
-
-// //   pairMgr->AddPair(pairKPKM_N);
-// //   pairMgr->AddPair(pairKPKM_NS);
-// //   pairMgr->AddPair(pairKPKM_NM);
-// //   pairMgr->AddPair(pairKPKP_N);
-// //   pairMgr->AddPair(pairKMKM_N);
-   pairMgr->AddPair(pairKPKM_R);
-   pairMgr->AddPair(pairKPKM_RS);
-   pairMgr->AddPair(pairKPKM_RS2);
-// //   pairMgr->AddPair(pairKPKM_RM);
-   pairMgr->AddPair(pairKPKP_R);
-   pairMgr->AddPair(pairKMKM_R);
-   pairMgr->AddPair(pairKPKM_P);
-  return pairMgr;
-
-}
diff --git a/PWG2/RESONANCES/macros/alien/RsnMergeAlien.C b/PWG2/RESONANCES/macros/alien/RsnMergeAlien.C
deleted file mode 100644 (file)
index c99d4d0..0000000
+++ /dev/null
@@ -1,36 +0,0 @@
-void RsnMergeAlien()
-{
-  // evaluate necessary arguments
-  char   searchpath[1024];
-  char   searchpattern[1024];
-  char   outputfile[1024];
-  char   username[1024];
-  char   masterjob[1024];
-  for (int i=0; i< gApplication->Argc();i++)
-  {
-    if (!(strcmp(gApplication->Argv(i), "--path")))       sprintf(searchpath, "%s", gApplication->Argv(i+1));
-    if (!(strcmp(gApplication->Argv(i), "--name")))       sprintf(searchpattern,"%s", gApplication->Argv(i+1));
-    if (!(strcmp(gApplication->Argv(i), "--out")))        sprintf(outputfile, "%s", gApplication->Argv(i+1));
-    if (!(strcmp(gApplication->Argv(i), "--user")))       sprintf(username, "%s", gApplication->Argv(i+1));
-    if (!(strcmp(gApplication->Argv(i), "--masterjob")))  sprintf(masterjob, "%s", gApplication->Argv(i+1));
-  }
-
-  // connect to grid
-  TGrid::Connect("alien://");
-
-  // query the grid to find all files in a given pattern
-  TGridResult* result = gGrid->Query(searchpath, searchpattern);
-
-  // initialize the file merger
-  TFileMerger merger;
-  merger.OutputFile(outputfile);
-
-  // loop on query result to merge
-  Int_t nMerged = 0;
-  while (result->GetKey(nMerged, "turl"))
-  {
-    merger.AddFile(result->GetKey(nMerged, "turl"));
-    nMerged++;
-  }
-  if (nMerged) merger.Merge();
-}
diff --git a/PWG2/RESONANCES/macros/alien/rsn-merge.jdl b/PWG2/RESONANCES/macros/alien/rsn-merge.jdl
deleted file mode 100644 (file)
index e7d727e..0000000
+++ /dev/null
@@ -1,21 +0,0 @@
-#
-# Arguments are the ones which must be passed to script:
-# -- $1 = root path containing all sub-paths with files to merge
-# -- $2 = name of the files to be merged
-# -- $3 = name of output file
-#
-
-Executable="rsn-merge.sh";
-Arguments="$1 $2 $3";
-
-Packages={
-  "APISCONFIG::V2.4",
-  "VO_ALICE@ROOT::v5-23-02"
-};
-
-TTL="40000";
-
-InputFile="LF:/alice/cern.ch/user/p/pulvir/pdc09/RsnMergeAlien.C";
-
-OutputDir="/alice/cern.ch/user/p/pulvir/$1/merge";
-OutputArchive={"$3.zip:$3.*@ALICE::Catania::dpm"};
diff --git a/PWG2/RESONANCES/macros/alien/rsn-merge.sh b/PWG2/RESONANCES/macros/alien/rsn-merge.sh
deleted file mode 100755 (executable)
index 3b5e71f..0000000
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/bin/sh
-#
-# Calls the merging macro and passes to it the two required arguments
-# -- $1 = root path containing all sub-paths with files to merge
-# -- $2 = name of the files to be merged
-# -- $3 = name of output file
-
-path=/alice/cern.ch/user/p/pulvir/$1
-outName=$3.root
-logName=$3.log
-inName=$2.root
-
-exec root -b -q -l -x RsnMergeAlien.C --path "$path" --name "$inName" --out "$outName" >& $logName
-echo >> $logName
-echo >> $logName
-echo -n 'Executed in: ' >> $logName
-hostname -f >> $logName