Synchronized with current package version.
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 2 Jul 2009 08:17:01 +0000 (08:17 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 2 Jul 2009 08:17:01 +0000 (08:17 +0000)
PWG2/RESONANCES/macros/AddAnalysisTaskRsn.C
PWG2/RESONANCES/macros/RsnConfig.C

index 44628bb..37d6969 100644 (file)
@@ -20,7 +20,7 @@ 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
+  Bool_t           sourceESD  = kTRUE,         // if true, the source of data is ESD, otherwise is AOD from filter task
 )
 {
   // retrieve analysis manager
@@ -79,16 +79,11 @@ Bool_t AddAnalysisTaskRsn
   cout << "SET PID SCHEME" << endl;
 
   // setup cuts for events (good primary vertex)
-  /* Commented out by AK - not working 
   AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 3);
   AliRsnCutSet *cutSetEvent = new AliRsnCutSet("eventCuts");
-  */
-
-  /* Commented out by AK - not working 
   cutSetEvent->AddCut(cutVertex);
   cutSetEvent->SetCutScheme("cutVertex");
   task->SetEventCuts(cutSetEvent);
-  */
   cout << "SET EVENT CUT SCHEME" << endl;
 
   // add the task to manager
@@ -129,7 +124,6 @@ AliRsnFunction* DefineFunctionIM()
   return fcn;
 }
 
-/* Commented out by AK - not working 
 AliRsnFunction* DefineFunctionP1P2()
 {
 //
@@ -154,7 +148,6 @@ AliRsnFunction* DefineFunctionP1P2()
 
   return fcn;
 }
-*/
 
 AliRsnPairManager* CreatePairsNoPID
 (
@@ -264,15 +257,12 @@ AliRsnPairManager* CreatePairsNoPID
   // === FUNCTIONS ================================================================================
 
   AliRsnFunction *fcn   = DefineFunctionIM();
-  /* Commented out by AK - not working 
   AliRsnFunction *fcnPP = DefineFunctionP1P2();
-  */
+
   for (i = 0; i < nArray; i++) {
     for (j = 0; j < 4; j++) {
       noPID[i][j]->AddFunction(fcn);
-  /* Commented out by AK - not working 
       if (j < 2) noPID[i][j]->AddFunction(fcnPP);
-  */
     }
   }
 
@@ -386,21 +376,16 @@ AliRsnPairManager* CreatePairsPID
   // === FUNCTIONS ================================================================================
 
   AliRsnFunction *fcn   = DefineFunctionIM();
-  /* Commented out by AK - not working 
   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);
-      /* Commented out by AK - not working 
-        if (j < 2) {
+      if (j < 2) {
         perfectPID[i][j]->AddFunction(fcnPP);
         realisticPID[i][j]->AddFunction(fcnPP);
       }
-      */
-      
     }
   }
 
index 450e8c1..c9e7dba 100644 (file)
@@ -1,22 +1,72 @@
-AliRsnPairManager *RsnConfig_PHI(const char *name="PHI")
+TObjArray DefineFunctions()
 {
-  return   CreatePairs(name, 333, AliAODTrack::kKaon, AliAODTrack::kKaon, 0, 10000);
-}
+//
+// 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);
 
-AliRsnPairManager *RsnConfig_KSTAR(const char *name="KSTAR")
+  // function #0:
+  // invariant mass w.r. to kinematics variables
+
+
+AliRsnFunction* DefineFunctionIM()
 {
-  return CreatePairs(name, 313, AliAODTrack::kPion, AliAODTrack::kKaon, 0, 10000);
-}
+//
+// 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;
+}
 
-AliRsnPairManager* CreatePairs
+AliRsnPairManager* CreatePairsNoPID
 (
-  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
+  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
 )
 {
 //
@@ -33,9 +83,6 @@ AliRsnPairManager* CreatePairs
 //
 
   AliRsnPairManager  *pairMgr  = new AliRsnPairManager(pairMgrName);
-  //cout << "Creating " << pairMgrName << endl;
-
-//   return pairMgr;
 
   // === PAIR DEFINITIONS =========================================================================
 
@@ -63,137 +110,220 @@ AliRsnPairManager* CreatePairs
   // array is organized as follows:
   // [0] - true pairs
   // [1] - signal
-  // [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};
+  // [2] - like PP
+  // [3] - like MM
+  AliRsnPair *noPID[2][4] = {0,0,0,0,0,0,0,0};
 
   for (i = 0; i < nArray; 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]);
+    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]);
+  }
 
-    realisticPID[i][0] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
-    realisticPID[i][1] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[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]);
+  // === 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;
+}
+
+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::kPerfectPIDMix, defUnlike[i]);
-    perfectPID[i][3] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikePP[i]);
-    perfectPID[i][4] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikeMM[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:
-  // - 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)");
+  // -- nothing
 
   // cuts on pairs:
-  // - true daughters of the defined resonance (only for true pairs histogram)
-  AliRsnCutStd *cutPairTrue    = new AliRsnCutStd("cutTrue", "", AliRsnCut::kTruePair, resonancePDG);
+  // -- 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(cutPairTrue);
+  cutSetPairTrue->AddCut(cutTruePair);
   cutSetPairTrue->SetCutScheme("cutTrue");
 
-  // 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 *cutMgrAll = new AliRsnCutMgr("std", "All");
 
-  // 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);
+  // cut manager for all pairs
+  AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True");
   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++) {
-    noPIDnoCut[i][0]->SetCutMgr(cutMgrTrue);
-    noPIDwithCut[i][0]->SetCutMgr(cutMgrTrueProb);
-    realisticPID[i][0]->SetCutMgr(cutMgrTrue);
     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);
+    realisticPID[i][0]->SetCutMgr(cutMgrTrue);
+    for (j = 1; j < 4; j++) {
+      perfectPID[i][j]->SetCutMgr(cutMgrAll);
+      realisticPID[i][j]->SetCutMgr(cutMgrAll);
     }
   }
 
   // === FUNCTIONS ================================================================================
 
-  // 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);
+  TObjArray list = DefineFunctions();
+  AliRsnFunction *fcn0  = (AliRsnFunction*)list[0];
+  AliRsnFunction *fcn1  = (AliRsnFunction*)list[1];
+  AliRsnFunction *fcn0  = (AliRsnFunction*)list[0];
 
-  // 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++) {
+      noPID[i][j]->AddFunction(fcn0);
+      noPID[i][j]->AddFunction(fcn1);
+      if (j < 2) noPID[i][j]->AddFunction(fcn2);
+    }
+  }
 
   for (i = 0; i < nArray; i++) {
-    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);
+    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);
+      }
     }
   }
 
   // === ADD TO PAIR MANAGER ======================================================================
 
   for (i = 0; i < nArray; i++) {
-    for (j = 0; j < 5; j++) {
-      pairMgr->AddPair(noPIDnoCut[i][j]);
-      pairMgr->AddPair(noPIDwithCut[i][j]);
-      pairMgr->AddPair(realisticPID[i][j]);
+    for (j = 0; j < 4; j++) {
       pairMgr->AddPair(perfectPID[i][j]);
+      pairMgr->AddPair(realisticPID[i][j]);
     }
   }
 
   return pairMgr;
 }
+