PWGLF/RESONANCES/macros/mini/ConfigD0.C

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