PWGLF/RESONANCES/macros/mini/ConfigD0.C

   1 //
   2 // *** Configuration script for D0 analysis ***
   3 //
   4 // A configuration script for RSN package needs to define the followings:
   5 //
   6 // (1) decay tree of each resonance to be studied, which is needed to select
   7 //     true pairs and to assign the right mass to all candidate daughters
   8 // (2) cuts at all levels: single daughters, tracks, events
   9 // (3) output objects: histograms or trees
  10 //
  11 Bool_t ConfigD0
  12 (
  13    AliRsnMiniAnalysisTask *task,
  14    Bool_t                  isPP,
  15    Bool_t                  isMC,
  16    Bool_t                  monitor = kTRUE,
  17    Bool_t                  centortracklets = kTRUE,
  18    Bool_t                  sanityhistos = kTRUE,
  19    Float_t                 nsigmaTPCPi = 3.0,
  20    Float_t                 nsigmaTPCKa = 3.0,
  21    Float_t                 nsigmaTOFPi = 2.0,
  22    Float_t                 nsigmaTOFKa = 2.0,
  23    Int_t                   aodFilterBit = 5,
  24    Float_t                 trackDCAcutMax = 7.0,
  25    Float_t                 trackDCAcutMin = 0.0,
  26    Float_t                 trackDCAZcutMax = 2.0,
  27    Int_t                   NTPCcluster = 70,
  28    Double_t                NTPCcrratio = 0.8,
  29    Int_t                   minSPDclt = 0,
  30    Double_t                minpt = 0.15,
  31    Short_t                 maxSisters = 2,
  32    Bool_t                  checkP = kTRUE,
  33    Bool_t                  useNTPCclt = kTRUE,
  34    Bool_t                  minDCAcutFixed = kFALSE,
  35    Bool_t                  maxDCAcutFixed = kFALSE,
  36    Bool_t                  ptdepPIDcut = kFALSE,
  37    Bool_t                  checkFeedDown = kTRUE,
  38    Bool_t                  checkQuark = kTRUE,
  39    Bool_t                  doCalculationInMC = kTRUE,
  40    UShort_t                originDselection = 0,
  41    Float_t                 mineta = -0.8,
  42    Float_t                 maxeta = 0.8,
  43    Float_t                 min_inv_mass = 0.6,
  44    Float_t                 max_inv_mass = 2.2,
  45    Int_t                   bins = 320,
  46    const char             *suffix,
  47    AliRsnCutSet           *cutsPairY,
  48    AliRsnCutSet           *cutsPair
  49 )
  50 {
  51    // manage suffix
  52    if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
  53
  54    TString s = ""; s+=trackDCAcutMax; s+="*(0.0015+0.0050/pt^1.01)";
  55
  56    const char *formula = s;
  57
  58    TString s2 = ""; s2+=trackDCAcutMin; s2+="*(0.0015+0.0050/pt^1.01)";
  59
  60    const char *formulaMin = s2;
  61
  62
  63    //
  64    // -- Define track cuts -------------------------------------------------------------------------
  65    //
  66
  67    // integrated pion cut
  68    AliRsnCutDaughterD0 *cutPi = new AliRsnCutDaughterD0("cutPionForD0", AliPID::kPion);
  69    //cutPi->SetNoPID(kTRUE);
  70    cutPi->SetTPCPionPIDCut(nsigmaTPCPi);
  71    cutPi->SetTOFPionPIDCut(nsigmaTOFPi);
  72    cutPi->SetPtDependentPIDCut(ptdepPIDcut);
  73    AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutPi->CutQuality();
  74    cutQuality->SetCheckOnlyFilterBit(kFALSE);
  75    cutQuality->SetAODTestFilterBit(aodFilterBit);
  76    if(maxDCAcutFixed)cutQuality->SetDCARmax(trackDCAcutMax);
  77    else cutQuality->SetDCARPtFormula(formula);
  78    if(minDCAcutFixed) cutQuality->SetDCARmin(trackDCAcutMin);
  79    else cutQuality->SetDCARPtFormulaMin(formulaMin);
  80    if(useNTPCclt)cutQuality->SetTPCminNClusters(NTPCcluster);
  81    if(!useNTPCclt)cutQuality->SetMinNCrossedRowsTPC(NTPCcluster,kTRUE);
  82    if(!useNTPCclt)cutQuality->SetMinNCrossedRowsOverFindableClsTPC(NTPCcrratio,kTRUE);
  83    cutQuality->SetPtRange(minpt,1E20);
  84    cutQuality->SetEtaRange(mineta, maxeta);
  85    cutQuality->SetDCAZmax(trackDCAZcutMax);
  86    cutQuality->SetSPDminNClusters(minSPDclt);
  87    cutQuality->SetITSminNClusters(0);
  88    cutQuality->SetITSmaxChi2(1E20);
  89    cutQuality->SetTPCmaxChi2(1E20);
  90    cutQuality->SetRejectKinkDaughters();
  91    cutQuality->Print();
  92
  93
  94
  95    // cut set
  96    AliRsnCutSet *cutSetPi = new AliRsnCutSet("setPionD0", AliRsnTarget::kDaughter);
  97    cutSetPi->AddCut(cutPi);
  98    cutSetPi->SetCutScheme(cutPi->GetName());
  99    // add to task
 100    Int_t iCutPi = task->AddTrackCuts(cutSetPi);
 101
 102
 103
 104    // integrated kaon cut
 105    AliRsnCutDaughterD0 *cutK = new AliRsnCutDaughterD0("cutKaonForD0", AliPID::kKaon);
 106    //cutK->SetNoPID(kTRUE);
 107    cutK->SetTPCKaonPIDCut(nsigmaTPCKa);
 108    cutK->SetTOFKaonPIDCut(nsigmaTOFKa);
 109    cutK->SetPtDependentPIDCut(ptdepPIDcut);
 110    AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutK->CutQuality();
 111    cutQuality->SetCheckOnlyFilterBit(kFALSE);
 112    cutQuality->SetAODTestFilterBit(aodFilterBit);
 113    if(maxDCAcutFixed)cutQuality->SetDCARmax(trackDCAcutMax);
 114    else cutQuality->SetDCARPtFormula(formula);
 115    if(minDCAcutFixed) cutQuality->SetDCARmin(trackDCAcutMin);
 116    else cutQuality->SetDCARPtFormulaMin(formulaMin);
 117    if(useNTPCclt)cutQuality->SetTPCminNClusters(NTPCcluster);
 118    if(!useNTPCclt)cutQuality->SetMinNCrossedRowsTPC(NTPCcluster,kTRUE);
 119    if(!useNTPCclt)cutQuality->SetMinNCrossedRowsOverFindableClsTPC(NTPCcrratio,kTRUE);
 120    cutQuality->SetPtRange(minpt,1E20);
 121    cutQuality->SetEtaRange(mineta, maxeta);
 122    cutQuality->SetDCAZmax(trackDCAZcutMax);
 123    cutQuality->SetSPDminNClusters(minSPDclt);
 124    cutQuality->SetITSminNClusters(0);
 125    cutQuality->SetITSmaxChi2(1E20);
 126    cutQuality->SetTPCmaxChi2(1E20);
 127    cutQuality->SetRejectKinkDaughters();
 128    cutQuality->Print();
 129
 130
 131
 132    // cut set
 133    AliRsnCutSet *cutSetK = new AliRsnCutSet("setKaonD0", AliRsnTarget::kDaughter);
 134    cutSetK->AddCut(cutK);
 135    cutSetK->SetCutScheme(cutK->GetName());
 136    // add to task
 137    Int_t iCutK = task->AddTrackCuts(cutSetK);
 138
 139
 140
 141    ////////////////////////////////////////////////////////////////////////////////////////////////
 142
 143   // -- Values ------------------------------------------------------------------------------------
 144   /* invariant mass     */ Int_t imID       = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
 145   /* IM resolution      */ Int_t resID      = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
 146   /* transv. momentum   */ Int_t ptID       = task->CreateValue(AliRsnMiniValue::kPt, kFALSE);
 147   /* centrality         */ Int_t centID     = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
 148   /* pseudorapidity     */ Int_t etaID      = task->CreateValue(AliRsnMiniValue::kEta, kFALSE);
 149   /* rapidity           */ Int_t yID        = task->CreateValue(AliRsnMiniValue::kY, kFALSE);
 150   /* dca product        */ Int_t dcapID     = task->CreateValue(AliRsnMiniValue::kDCAproduct, kFALSE);
 151   /* first daughter pt  */ Int_t daug1ptID  = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kFALSE);
 152   /* second daughter pt */ Int_t daug2ptID  = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kFALSE);
 153   /* first daughter dca */ Int_t daug1dcaID = task->CreateValue(AliRsnMiniValue::kFirstDaughterDCA, kFALSE);
 154   /* second daughter dca*/ Int_t daug2dcaID = task->CreateValue(AliRsnMiniValue::kSecondDaughterDCA, kFALSE);
 155   /* number of Sisters  */ Int_t nsistID    = task->CreateValue(AliRsnMiniValue::kNSisters, kFALSE);
 156   /* number of trackl.  */ Int_t trackletsID = task->CreateValue(AliRsnMiniValue::kTracklets, kFALSE);
 157
 158    //
 159    // -- Create all needed outputs -----------------------------------------------------------------
 160    //
 161
 162    // use an array for more compact writing, which are different on mixing and charges
 163    // [0] = unlike
 164    // [1] = mixing
 165    // [2] = like ++
 166    // [3] = like --
 167
 168
 169    if(!isMC || doCalculationInMC == kTRUE){
 170
 171    Bool_t   use     [8] = { 1       ,  1       ,  1       ,  1       ,  1        ,  1        ,  1       ,  1      };
 172    Bool_t   useIM   [8] = { 1       ,  1       ,  1       ,  1       ,  1        ,  1        ,  1       ,  1      };
 173    TString  name    [8] = {"Unlike1", "Unlike2", "Mixing1", "Mixing2", "RotateK1", "RotateK2", "LikePP" , "LikeMM"};
 174    TString  comp    [8] = {"PAIR"   , "PAIR"   , "MIX"    , "MIX"    , "ROTATE1" , "ROTATE1" , "PAIR"   , "PAIR"  };
 175    TString  output  [8] = {"SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE"  , "SPARSE"  , "SPARSE" , "SPARSE"};
 176    Char_t   charge1 [8] = {'-'      , '+'      , '-'      , '+'      , '-'       , '+'       , '+'      , '-'     };
 177    Char_t   charge2 [8] = {'+'      , '-'      , '+'      , '-'      , '+'       , '-'       , '+'      , '-'     };
 178    Int_t    cutID1  [8] = { iCutK   ,  iCutK   ,  iCutK   ,  iCutK   ,  iCutK    ,  iCutK    ,  iCutK   ,  iCutK  };
 179    Int_t    cutID2  [8] = { iCutPi  ,  iCutPi  ,  iCutPi  ,  iCutPi  ,  iCutPi   ,  iCutPi   ,  iCutPi  ,  iCutPi };
 180    Int_t    ipdg    [8] = { 421     , -421     ,  421     , -421     ,  421      , -421      ,  421     , -421    };
 181    Double_t mass    [8] = { 1.86486 ,  1.86486 ,  1.86486 ,  1.86486 ,  1.86486  ,  1.86486  ,  1.86486 ,  1.86486};
 182
 183    for (Int_t i = 0; i < 8; i++) {
 184       if (!use[i]) continue;
 185
 186       // create output
 187       AliRsnMiniOutput *out = task->CreateOutput(Form("D0_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
 188       // selection settings
 189       out->SetCutID(0, cutID1[i]);
 190       out->SetCutID(1, cutID2[i]);
 191       out->SetDaughter(0, AliRsnDaughter::kKaon);
 192       out->SetDaughter(1, AliRsnDaughter::kPion);
 193       out->SetCharge(0, charge1[i]);
 194       out->SetCharge(1, charge2[i]);
 195       out->SetMotherPDG(ipdg[i]);
 196       out->SetMotherMass(mass[i]);
 197       // pair cuts
 198       out->SetPairCuts(cutsPair);
 199
 200       // axis X: invmass (or resolution)
 201       //if (useIM[i])
 202          out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
 203       //else
 204       //   out->AddAxis(resID, 200, -0.02, 0.02);
 205       // axis Y: transverse momentum
 206       out->AddAxis(ptID, 200, 0.0, 20.0);
 207
 208       // axiz Z: pseudorapidity
 209       //if(sanityhistos==kTRUE) out->AddAxis(etaID, 100, -1, 1);
 210
 211
 212       if (!isPP)  {if(!centortracklets) out->AddAxis(centID, 100, 0.0, 100.0);
 213                    else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 214       else {if(!centortracklets) out->AddAxis(centID, 400, 0.0, 400.0);
 215         else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 216    }
 217
 218    if(sanityhistos==kTRUE){
 219
 220    // SANITY CHECK HISTOS
 221
 222    TString mode = "SPARSE";
 223
 224    // create output
 225    AliRsnMiniOutput *out = task->CreateOutput("D0_MixingPP", mode.Data(), "MIX");
 226    // selection settings
 227    out->SetCutID(0, iCutK);
 228    out->SetCutID(1, iCutPi);
 229    out->SetDaughter(0, AliRsnDaughter::kKaon);
 230    out->SetDaughter(1, AliRsnDaughter::kPion);
 231    out->SetCharge(0, '+');
 232    out->SetCharge(1, '+');
 233    out->SetMotherPDG(421);
 234    out->SetMotherMass(1.86486);
 235    // pair cuts
 236    out->SetPairCuts(cutsPair);
 237
 238    // binnings
 239    out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
 240    out->AddAxis(ptID, 200, 0.0, 20.0);
 241    //out->AddAxis(etaID, 100, -1, 1);
 242
 243
 244    if (!isPP)  {if(!centortracklets) out->AddAxis(centID, 100, 0.0, 100.0);
 245                 else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 246    else {if(!centortracklets) out->AddAxis(centID, 400, 0.0, 400.0);
 247         else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 248
 249    // create output
 250    AliRsnMiniOutput *out = task->CreateOutput("D0_MixingMM", mode.Data(), "MIX");
 251    // selection settings
 252    out->SetCutID(0, iCutK);
 253    out->SetCutID(1, iCutPi);
 254    out->SetDaughter(0, AliRsnDaughter::kKaon);
 255    out->SetDaughter(1, AliRsnDaughter::kPion);
 256    out->SetCharge(0, '-');
 257    out->SetCharge(1, '-');
 258    out->SetMotherPDG(-421);
 259    out->SetMotherMass(1.86486);
 260    // pair cuts
 261    out->SetPairCuts(cutsPair);
 262
 263    // binnings
 264    out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
 265    out->AddAxis(ptID, 200, 0.0, 20.0);
 266    //out->AddAxis(etaID, 100, -1, 1);
 267
 268    if (!isPP)  {if(!centortracklets) out->AddAxis(centID, 100, 0.0, 100.0);
 269                 else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 270    else {if(!centortracklets) out->AddAxis(centID, 400, 0.0, 400.0);
 271         else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 272
 273
 274    }
 275
 276
 277    }
 278
 279    if(monitor == kTRUE){
 280    AddMonitorOutput_PionEta(cutSetPi->GetMonitorOutput());
 281    AddMonitorOutput_PionY(cutSetPi->GetMonitorOutput());
 282    AddMonitorOutput_PionMinPt(cutSetPi->GetMonitorOutput());
 283    AddMonitorOutput_PionDCA(cutSetPi->GetMonitorOutput());
 284    AddMonitorOutput_PionTPC_PIDCut(cutSetPi->GetMonitorOutput());
 285    AddMonitorOutput_PionTOF_PIDCut(cutSetPi->GetMonitorOutput());
 286    AddMonitorOutput_PionNTPC(cutSetPi->GetMonitorOutput());
 287
 288    AddMonitorOutput_KaonEta(cutSetK->GetMonitorOutput());
 289    AddMonitorOutput_KaonY(cutSetK->GetMonitorOutput());
 290    AddMonitorOutput_KaonMinPt(cutSetK->GetMonitorOutput());
 291    AddMonitorOutput_KaonDCA(cutSetK->GetMonitorOutput());
 292    AddMonitorOutput_KaonTPC_PIDCut(cutSetK->GetMonitorOutput());
 293    AddMonitorOutput_KaonTOF_PIDCut(cutSetK->GetMonitorOutput());
 294    AddMonitorOutput_KaonNTPC(cutSetK->GetMonitorOutput());
 295    }
 296
 297
 298    if (isMC) {
 299
 300    // TRUE RECONSTRUCTED PAIRS
 301
 302    TString mode = "SPARSE";
 303
 304    // create output
 305    AliRsnMiniOutput *out = task->CreateOutput("D0_True1", mode.Data(), "TRUE");
 306    // selection settings
 307    out->SetCutID(0, iCutK);
 308    out->SetCutID(1, iCutPi);
 309    out->SetDaughter(0, AliRsnDaughter::kKaon);
 310    out->SetDaughter(1, AliRsnDaughter::kPion);
 311    out->SetCharge(0, '-');
 312    out->SetCharge(1, '+');
 313    out->SetMotherPDG(421);
 314    out->SetMotherMass(1.86486);
 315    // pair cuts
 316    out->SetPairCuts(cutsPair);
 317    out->SetMaxNSisters(maxSisters);
 318    out->SetCheckMomentumConservation(checkP);
 319    out->SetCheckFeedDown(checkFeedDown);
 320    out->SetRejectCandidateIfNotFromQuark(checkQuark);
 321    out->SetDselection(originDselection);
 322    // binnings
 323    out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
 324    out->AddAxis(ptID, 200, 0.0, 20.0);
 325    //out->AddAxis(yID, 100, -1, 1);
 326    //out->AddAxis(dcapID, 100, -0.001, 0.001);
 327    //out->AddAxis(nsistID, 10, 0, 5);
 328
 329    if (!isPP)  {if(!centortracklets) out->AddAxis(centID, 100, 0.0, 100.0);
 330                 else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 331    else {if(!centortracklets) out->AddAxis(centID, 400, 0.0, 400.0);
 332         else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 333
 334    // create output
 335    AliRsnMiniOutput *out = task->CreateOutput("D0_True2", mode.Data(), "TRUE");
 336    // selection settings
 337    out->SetCutID(0, iCutK);
 338    out->SetCutID(1, iCutPi);
 339    out->SetDaughter(0, AliRsnDaughter::kKaon);
 340    out->SetDaughter(1, AliRsnDaughter::kPion);
 341    out->SetCharge(0, '+');
 342    out->SetCharge(1, '-');
 343    out->SetMotherPDG(-421);
 344    out->SetMotherMass(1.86486);
 345    // pair cuts
 346    out->SetPairCuts(cutsPair);
 347    out->SetMaxNSisters(maxSisters);
 348    out->SetCheckMomentumConservation(checkP);
 349    out->SetCheckFeedDown(checkFeedDown);
 350    out->SetRejectCandidateIfNotFromQuark(checkQuark);
 351    out->SetDselection(originDselection);
 352    // binnings
 353    out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
 354    out->AddAxis(ptID, 200, 0.0, 20.0);
 355    //out->AddAxis(yID, 100, -1, 1);
 356    //out->AddAxis(dcapID, 100, -0.001, 0.001);
 357    //out->AddAxis(nsistID, 10, 0, 5);
 358
 359    if (!isPP)  {if(!centortracklets) out->AddAxis(centID, 100, 0.0, 100.0);
 360                 else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 361    else {if(!centortracklets) out->AddAxis(centID, 400, 0.0, 400.0);
 362         else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 363
 364
 365    // GENERATED MOTHERS
 366
 367    TString mode = "SPARSE";
 368
 369    // create output
 370    AliRsnMiniOutput *out = task->CreateOutput("D0_TrueMC1", mode.Data(), "MOTHER");
 371    // selection settings
 372    out->SetDaughter(0, AliRsnDaughter::kKaon);
 373    out->SetDaughter(1, AliRsnDaughter::kPion);
 374    out->SetMotherPDG(421);
 375    out->SetMotherMass(1.86486);
 376    // pair cuts
 377    out->SetPairCuts(cutsPairY);
 378    // binnings
 379    out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
 380    out->AddAxis(ptID, 200, 0.0, 20.0);
 381    //out->AddAxis(yID, 100, -1, 1);
 382
 383    if (!isPP)  {if(!centortracklets) out->AddAxis(centID, 100, 0.0, 100.0);
 384                 else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 385    else {if(!centortracklets) out->AddAxis(centID, 400, 0.0, 400.0);
 386         else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 387
 388    // create output
 389    AliRsnMiniOutput *out = task->CreateOutput("D0_TrueMC2", mode.Data(), "MOTHER");
 390    // selection settings
 391    out->SetDaughter(0, AliRsnDaughter::kKaon);
 392    out->SetDaughter(1, AliRsnDaughter::kPion);
 393    out->SetMotherPDG(-421);
 394    out->SetMotherMass(1.86486);
 395    // pair cuts
 396    out->SetPairCuts(cutsPairY);
 397    // binnings
 398    out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
 399    out->AddAxis(ptID, 200, 0.0, 20.0);
 400    //out->AddAxis(yID, 100, -1, 1);
 401
 402    if (!isPP)  {if(!centortracklets) out->AddAxis(centID, 100, 0.0, 100.0);
 403                 else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 404    else {if(!centortracklets) out->AddAxis(centID, 400, 0.0, 400.0);
 405         else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 406
 407
 408    // GENERATED MOTHERS IN THE ACCEPTANCE
 409
 410    TString mode = "SPARSE";
 411
 412    // create output
 413    AliRsnMiniOutput *out = task->CreateOutput("D0_TrueMC_InAcc1", mode.Data(), "MOTHER_IN_ACC");
 414    // selection settings
 415    out->SetDaughter(0, AliRsnDaughter::kKaon);
 416    out->SetDaughter(1, AliRsnDaughter::kPion);
 417    out->SetMotherPDG(421);
 418    out->SetMotherMass(1.86486);
 419    // pair cuts
 420    out->SetPairCuts(cutsPairY);
 421    // binnings
 422    out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
 423    out->AddAxis(ptID, 200, 0.0, 20.0);
 424    //out->AddAxis(yID, 100, -1, 1);
 425
 426   if (!isPP)  {if(!centortracklets) out->AddAxis(centID, 100, 0.0, 100.0);
 427                else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 428    else {if(!centortracklets) out->AddAxis(centID, 400, 0.0, 400.0);
 429         else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 430
 431    // create output
 432    AliRsnMiniOutput *out = task->CreateOutput("D0_TrueMC_InAcc2", mode.Data(), "MOTHER_IN_ACC");
 433    // selection settings
 434    out->SetDaughter(0, AliRsnDaughter::kKaon);
 435    out->SetDaughter(1, AliRsnDaughter::kPion);
 436    out->SetMotherPDG(-421);
 437    out->SetMotherMass(1.86486);
 438    // pair cuts
 439    out->SetPairCuts(cutsPairY);
 440    // binnings
 441    out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
 442    out->AddAxis(ptID, 200, 0.0, 20.0);
 443    //out->AddAxis(yID, 100, -1, 1);
 444
 445    if (!isPP)  {if(!centortracklets) out->AddAxis(centID, 100, 0.0, 100.0);
 446                 else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 447    else {if(!centortracklets) out->AddAxis(centID, 400, 0.0, 400.0);
 448         else out->AddAxis(trackletsID, 250, -0.5, 249.5);}
 449
 450
 451    }
 452
 453
 454    return kTRUE;
 455 }
 456
 457
 458 void AddMonitorOutput_PionEta(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *peta=0)
 459 {
 460
 461    // PionEta
 462    AliRsnValueDaughter *axisPionEta = new AliRsnValueDaughter("pion_eta", AliRsnValueDaughter::kEta);
 463    axisPionEta->SetBins(-1.0,1.0,0.05);
 464
 465    // output: 2D histogram
 466    AliRsnListOutput *outMonitorPionEta = new AliRsnListOutput("Pion_Eta", AliRsnListOutput::kHistoDefault);
 467    outMonitorPionEta->AddValue(axisPionEta);
 468
 469    // add outputs to loop
 470    if (mon) mon->Add(outMonitorPionEta);
 471    if (peta) peta->AddOutput(outMonitorPionEta);
 472
 473 }
 474
 475 void AddMonitorOutput_PionY(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *py=0)
 476 {
 477
 478    // PionY
 479    AliRsnValueDaughter *axisPionY = new AliRsnValueDaughter("pion_y", AliRsnValueDaughter::kY);
 480    axisPionY->SetBins(-1.0,1.0,0.05);
 481
 482    // output: 2D histogram
 483    AliRsnListOutput *outMonitorPionY = new AliRsnListOutput("Pion_Y", AliRsnListOutput::kHistoDefault);
 484    outMonitorPionY->AddValue(axisPionY);
 485
 486    // add outputs to loop
 487    if (mon) mon->Add(outMonitorPionY);
 488    if (py) py->AddOutput(outMonitorPionY);
 489
 490 }
 491
 492 void AddMonitorOutput_PionMinPt(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *pmpt=0)
 493 {
 494
 495    // PionMinPt
 496    AliRsnValueDaughter *axisPionMinPt = new AliRsnValueDaughter("pion_minpt", AliRsnValueDaughter::kPt);
 497    axisPionMinPt->SetBins(0.0,1,0.05);
 498
 499    // output: 2D histogram
 500    AliRsnListOutput *outMonitorPionMinPt = new AliRsnListOutput("Pion_MinPt", AliRsnListOutput::kHistoDefault);
 501    outMonitorPionMinPt->AddValue(axisPionMinPt);
 502
 503    // add outputs to loop
 504    if (mon) mon->Add(outMonitorPionMinPt);
 505    if (pmpt) pmpt->AddOutput(outMonitorPionMinPt);
 506
 507 }
 508
 509 void AddMonitorOutput_PionDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *pdca=0)
 510 {
 511
 512    // PionDCA
 513    AliRsnValueDaughter *axisPionDCA = new AliRsnValueDaughter("pion_dca", AliRsnValueDaughter::kDCAXY);
 514    axisPionDCA->SetBins(-1.0,1,0.05);
 515
 516    // output: 2D histogram
 517    AliRsnListOutput *outMonitorPionDCA = new AliRsnListOutput("Pion_DCA", AliRsnListOutput::kHistoDefault);
 518    outMonitorPionDCA->AddValue(axisPionDCA);
 519
 520    // add outputs to loop
 521    if (mon) mon->Add(outMonitorPionDCA);
 522    if (pdca) pdca->AddOutput(outMonitorPionDCA);
 523
 524 }
 525
 526 void AddMonitorOutput_PionTPC_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piTPCPID=0)
 527 {
 528
 529    // Pion PID Cut
 530    AliRsnValueDaughter *axisPionTPCPIDCut = new AliRsnValueDaughter("pionTPCPID", AliRsnValueDaughter::kTPCnsigmaPi);
 531    axisPionTPCPIDCut->SetBins(0.0,5,0.1);
 532
 533    // output: 2D histogram
 534    AliRsnListOutput *outMonitorPionTPCPIDCut = new AliRsnListOutput("Pion_TPC_PID_Cut", AliRsnListOutput::kHistoDefault);
 535    outMonitorPionTPCPIDCut->AddValue(axisPionTPCPIDCut);
 536
 537    // add outputs to loop
 538    if (mon) mon->Add(outMonitorPionTPCPIDCut);
 539    if (piTPCPID) piTPCPID->AddOutput(outMonitorPionPIDCut);
 540
 541 }
 542
 543 void AddMonitorOutput_PionTOF_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piTOFPID=0)
 544 {
 545
 546    // Pion PID Cut
 547    AliRsnValueDaughter *axisPionTOFPIDCut = new AliRsnValueDaughter("pionTOFPID", AliRsnValueDaughter::kTOFnsigmaPi);
 548    axisPionTOFPIDCut->SetBins(0.0,5,0.1);
 549
 550    // output: 2D histogram
 551    AliRsnListOutput *outMonitorPionTOFPIDCut = new AliRsnListOutput("Pion_TOF_PID_Cut", AliRsnListOutput::kHistoDefault);
 552    outMonitorPionTOFPIDCut->AddValue(axisPionTOFPIDCut);
 553
 554    // add outputs to loop
 555    if (mon) mon->Add(outMonitorPionTOFPIDCut);
 556    if (piTOFPID) piTOFPID->AddOutput(outMonitorPionTOFPIDCut);
 557
 558 }
 559
 560 void AddMonitorOutput_PionNTPC(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piNTPC=0)
 561 {
 562
 563    // Pion PID Cut
 564    AliRsnValueDaughter *axisPionNTPC = new AliRsnValueDaughter("pionNTPC", AliRsnValueDaughter::kNTPCclusters);
 565    axisPionNTPC->SetBins(0.0,200,1);
 566
 567    // output: 2D histogram
 568    AliRsnListOutput *outMonitorPionNTPC = new AliRsnListOutput("Pion_NTPC", AliRsnListOutput::kHistoDefault);
 569    outMonitorPionNTPC->AddValue(axisPionNTPC);
 570
 571    // add outputs to loop
 572    if (mon) mon->Add(outMonitorPionNTPC);
 573    if (piNTPC) piNTPC->AddOutput(outMonitorPionNTPC);
 574
 575 }
 576
 577 void AddMonitorOutput_KaonEta(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *keta=0)
 578 {
 579
 580    // KaonEta
 581    AliRsnValueDaughter *axisKaonEta = new AliRsnValueDaughter("kaon_eta", AliRsnValueDaughter::kEta);
 582    axisKaonEta->SetBins(-1.0,1.0,0.05);
 583
 584    // output: 2D histogram
 585    AliRsnListOutput *outMonitorKaonEta = new AliRsnListOutput("Kaon_Eta", AliRsnListOutput::kHistoDefault);
 586    outMonitorKaonEta->AddValue(axisKaonEta);
 587
 588    // add outputs to loop
 589    if (mon) mon->Add(outMonitorKaonEta);
 590    if (keta) keta->AddOutput(outMonitorKaonEta);
 591
 592 }
 593
 594 void AddMonitorOutput_KaonY(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ky=0)
 595 {
 596
 597    // KaonY
 598    AliRsnValueDaughter *axisKaonY = new AliRsnValueDaughter("kaon_y", AliRsnValueDaughter::kY);
 599    axisKaonY->SetBins(-1.0,1.0,0.05);
 600
 601    // output: 2D histogram
 602    AliRsnListOutput *outMonitorKaonY = new AliRsnListOutput("Kaon_Y", AliRsnListOutput::kHistoDefault);
 603    outMonitorKaonY->AddValue(axisKaonY);
 604
 605    // add outputs to loop
 606    if (mon) mon->Add(outMonitorKaonY);
 607    if (ky) ky->AddOutput(outMonitorKaonY);
 608
 609 }
 610
 611 void AddMonitorOutput_KaonMinPt(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kmpt=0)
 612 {
 613
 614    // KaonMinPt
 615    AliRsnValueDaughter *axisKaonMinPt = new AliRsnValueDaughter("kaon_minpt", AliRsnValueDaughter::kPt);
 616    axisKaonMinPt->SetBins(0.0,1,0.05);
 617
 618    // output: 2D histogram
 619    AliRsnListOutput *outMonitorKaonMinPt = new AliRsnListOutput("Kaon_MinPt", AliRsnListOutput::kHistoDefault);
 620    outMonitorKaonMinPt->AddValue(axisKaonMinPt);
 621
 622    // add outputs to loop
 623    if (mon) mon->Add(outMonitorKaonMinPt);
 624    if (kmpt) kmpt->AddOutput(outMonitorKaonMinPt);
 625
 626 }
 627
 628 void AddMonitorOutput_KaonDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kdca=0)
 629 {
 630
 631    // KaonDCA
 632    AliRsnValueDaughter *axisKaonDCA = new AliRsnValueDaughter("kaon_dca", AliRsnValueDaughter::kDCAXY);
 633    axisKaonDCA->SetBins(-1.0,1,0.05);
 634
 635    // output: 2D histogram
 636    AliRsnListOutput *outMonitorKaonDCA = new AliRsnListOutput("Kaon_DCA", AliRsnListOutput::kHistoDefault);
 637    outMonitorKaonDCA->AddValue(axisKaonDCA);
 638
 639    // add outputs to loop
 640    if (mon) mon->Add(outMonitorKaonDCA);
 641    if (kdca) kdca->AddOutput(outMonitorKaonDCA);
 642
 643 }
 644
 645 void AddMonitorOutput_KaonTPC_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kTPCPID=0)
 646 {
 647
 648    // Kaon TPC PID Cut
 649    AliRsnValueDaughter *axisKaonTPCPIDCut = new AliRsnValueDaughter("kaonTPCPID", AliRsnValueDaughter::kTPCnsigmaK);
 650    axisKaonTPCPIDCut->SetBins(0.0,5,0.1);
 651
 652    // output: 2D histogram
 653    AliRsnListOutput *outMonitorKaonTPCPIDCut = new AliRsnListOutput("Kaon_TPC_PID_Cut", AliRsnListOutput::kHistoDefault);
 654    outMonitorKaonTPCPIDCut->AddValue(axisKaonTPCPIDCut);
 655
 656    // add outputs to loop
 657    if (mon) mon->Add(outMonitorKaonTPCPIDCut);
 658    if (kTPCPID) kTPCPID->AddOutput(outMonitorKaonTPCPIDCut);
 659
 660 }
 661
 662 void AddMonitorOutput_KaonTOF_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kTOFPID=0)
 663 {
 664
 665    // Kaon TOF PID Cut
 666    AliRsnValueDaughter *axisKaonTOFPIDCut = new AliRsnValueDaughter("kaonTOFPID", AliRsnValueDaughter::kTOFnsigmaK);
 667    axisKaonTOFPIDCut->SetBins(0.0,5,0.1);
 668
 669    // output: 2D histogram
 670    AliRsnListOutput *outMonitorKaonTOFPIDCut = new AliRsnListOutput("Kaon_TOF_PID_Cut", AliRsnListOutput::kHistoDefault);
 671    outMonitorKaonTOFPIDCut->AddValue(axisKaonTOFPIDCut);
 672
 673    // add outputs to loop
 674    if (mon) mon->Add(outMonitorKaonTOFPIDCut);
 675    if (kTOFPID) kTOFPID->AddOutput(outMonitorKaonTOFPIDCut);
 676
 677 }
 678
 679 void AddMonitorOutput_KaonNTPC(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kNTPC=0)
 680 {
 681
 682    // Kaon PID Cut
 683    AliRsnValueDaughter *axisKaonNTPC = new AliRsnValueDaughter("kaonNTPC", AliRsnValueDaughter::kNTPCclusters);
 684    axisKaonNTPC->SetBins(0.0,200,1);
 685
 686    // output: 2D histogram
 687    AliRsnListOutput *outMonitorKaonNTPC = new AliRsnListOutput("Kaon_NTPC", AliRsnListOutput::kHistoDefault);
 688    outMonitorKaonNTPC->AddValue(axisKaonNTPC);
 689
 690    // add outputs to loop
 691    if (mon) mon->Add(outMonitorKaonNTPC);
 692    if (kNTPC) kNTPC->AddOutput(outMonitorKaonNTPC);
 693
 694 }
 695