PWGLF/RESONANCES/macros/mini/ConfigSigmaStarPbPb.C

   1 //
   2 // *** Configuration script for Sigma*->Lambda-Pi 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 ConfigSigmaStarPbPb
  12 (
  13    AliRsnMiniAnalysisTask *task,
  14    Bool_t                  isPP,
  15    Bool_t                  isMC,
  16    Float_t                 piPIDCut,
  17    Float_t                 pPIDCut,
  18    Int_t                   aodFilterBit,
  19    Float_t                 trackDCAcut,
  20    Float_t                 massTol,
  21    Float_t                 lambdaDCA,
  22    Float_t                 lambdaCosPoinAn,
  23    Float_t                 lambdaDaughDCA,
  24    Int_t                   NTPCcluster,
  25    const char             *suffix,
  26    AliRsnCutSet           *cutsPair
  27 )
  28 {
  29    // manage suffix
  30    if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
  31
  32    //
  33    // -- Define track cuts -------------------------------------------------------------------------
  34    //
  35
  36    TString s = ""; s+=trackDCAcut; s+="*(0.0026+0.0050/pt^1.01)";
  37
  38    const char *formula = s;
  39
  40    // integrated pion cut
  41    AliRsnCutDaughterSigmaStar2010PP *cutPi = new AliRsnCutDaughterSigmaStar2010PP("cutPionForSigmaStar", AliPID::kPion);
  42    cutPi->SetPIDCut(piPIDCut);
  43    cutPi->SetMinTPCcluster(NTPCcluster);
  44    AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutPi->CutQuality();
  45    cutQuality->SetAODTestFilterBit(aodFilterBit);
  46    cutQuality->SetDCARPtFormula(formula);
  47
  48    // cut set
  49    AliRsnCutSet *cutSetPi = new AliRsnCutSet("setPionForSigmaStar", AliRsnTarget::kDaughter);
  50    cutSetPi->AddCut(cutPi);
  51    cutSetPi->SetCutScheme(cutPi->GetName());
  52    // add to task
  53    Int_t iCutPi = task->AddTrackCuts(cutSetPi);
  54
  55    // quality cuts
  56    AliESDtrackCuts *esdTrackCuts = new AliESDtrackCuts("qualityDaughterLambda");
  57
  58    esdTrackCuts->SetAcceptKinkDaughters(0); // 0 = kFalse
  59    esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
  60    esdTrackCuts->SetMaxChi2PerClusterTPC(4);
  61    esdTrackCuts->SetMinNClustersTPC(NTPCcluster);
  62    esdTrackCuts->SetRequireTPCRefit();
  63
  64    // cut lambda
  65    AliRsnCutV0 *cutLambda = new AliRsnCutV0("cutLambda", kLambda0, AliPID::kProton, AliPID::kPion);
  66    cutLambda->SetESDtrackCuts(esdTrackCuts);
  67    cutLambda->SetTolerance(massTol);
  68    cutLambda->SetMaxDCAVertex(lambdaDCA);
  69    cutLambda->SetMinCosPointingAngle(lambdaCosPoinAn);
  70    cutLambda->SetMaxDaughtersDCA(lambdaDaughDCA);
  71    cutLambda->SetMinTPCcluster(NTPCcluster);
  72    cutLambda->SetMaxRapidity(0.8);
  73    cutLambda->SetDCARPtFormula(formula);
  74    cutLambda->SetAODTestFilterBit(aodFilterBit);
  75    cutLambda->SetPIDCutProton(pPIDCut);
  76    cutLambda->SetPIDCutPion(piPIDCut);
  77
  78    // cut set
  79    AliRsnCutSet *cutSetLambda = new AliRsnCutSet("setLambda", AliRsnTarget::kDaughter);
  80    cutSetLambda->AddCut(cutLambda);
  81    cutSetLambda->SetCutScheme(cutLambda->GetName());
  82
  83    // add to task
  84    Int_t iCutLambda = task->AddTrackCuts(cutSetLambda);
  85
  86    // cut anti-AntiLambda
  87    AliRsnCutV0 *cutAntiLambda = new AliRsnCutV0("cutAntiLambda", kLambda0Bar, AliPID::kProton, AliPID::kPion);
  88    cutAntiLambda->SetESDtrackCuts(esdTrackCuts);
  89    cutAntiLambda->SetTolerance(massTol);
  90    cutAntiLambda->SetMaxDCAVertex(lambdaDCA);
  91    cutAntiLambda->SetMinCosPointingAngle(lambdaCosPoinAn);
  92    cutAntiLambda->SetMaxDaughtersDCA(lambdaDaughDCA);
  93    cutAntiLambda->SetMinTPCcluster(NTPCcluster);
  94    cutAntiLambda->SetMaxRapidity(0.8);
  95    cutAntiLambda->SetDCARPtFormula(formula);
  96    cutAntiLambda->SetAODTestFilterBit(aodFilterBit);
  97    cutAntiLambda->SetPIDCutProton(pPIDCut);
  98    cutAntiLambda->SetPIDCutPion(piPIDCut);
  99
 100    // cut set
 101    AliRsnCutSet *cutSetAntiLambda = new AliRsnCutSet("setAntiLambda", AliRsnTarget::kDaughter);
 102    cutSetAntiLambda->AddCut(cutAntiLambda);
 103    cutSetAntiLambda->SetCutScheme(cutAntiLambda->GetName());
 104    // add to task
 105    Int_t iCutAntiLambda = task->AddTrackCuts(cutSetAntiLambda);
 106
 107
 108    //######################################################################################################
 109
 110    //
 111    // -- Values ------------------------------------------------------------------------------------
 112    //
 113
 114    /* invariant mass   */ Int_t imID   = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
 115    /* transv. momentum */ Int_t ptID   = task->CreateValue(AliRsnMiniValue::kPt, kFALSE);
 116    /* centrality       */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
 117
 118    //
 119    // -- Create all needed outputs -----------------------------------------------------------------
 120    //
 121
 122    // use an array for more compact writing, which are different on mixing and charges
 123    // [0] = unlike
 124    // [1] = mixing
 125    // [2] = like ++
 126    // [3] = like --
 127    Bool_t   use     [18] = { 1         ,  1         ,  1             ,  1             ,  1         ,  1         ,  1             ,  1             ,  1         ,  1         ,  1             ,  1             ,  1          ,  1              ,  1              ,  1              ,  1              ,  1              };
 128    Bool_t   useIM   [18] = { 1         ,  1         ,  1             ,  1             ,  1         ,  1         ,  1             ,  1             ,  1         ,  1         ,  1             ,  1             ,  1          ,  1              ,  1              ,  1              ,  1              ,  1              };
 129    TString  name    [18] = {"SigmaP"   , "SigmaM"   , "ASigmaP"      , "ASigmaM"      , "SigmaPmix", "SigmaMmix", "ASigmaPmix"   , "ASigmaMmix"   , "SigmaPt"  , "SigmaMt"  , "ASigmaPt"     , "ASigmaMt"     , "XiM"       , "XiP"           , "Lambda1520P"   , "Lambda1520M"   , "Lambda1520PBar", "Lambda1520MBar"};
 130    TString  comp    [18] = {"PAIR"     , "PAIR"     , "PAIR"         , "PAIR"         , "MIX"      , "MIX"      , "MIX"          , "MIX"          , "TRUE"     , "TRUE"     , "TRUE"         , "TRUE"         , "TRUE"      , "TRUE"          , "TRUE"          , "TRUE"          , "TRUE"          , "TRUE"          };
 131    TString  output  [18] = {"HIST"     , "HIST"     , "HIST"         , "HIST"         , "HIST"     , "HIST"     , "HIST"         , "HIST"         , "HIST"     , "HIST"     , "HIST"         , "HIST"         , "HIST"      , "HIST"          , "HIST"          , "HIST"          , "HIST"          , "HIST"          };
 132    Char_t   charge1 [18] = {'0'        , '0'        , '0'            , '0'            , '0'        , '0'        , '0'            , '0'            , '0'        , '0'        , '0'            , '0'            , '0'         , '0'             , '0'             , '0'             , '0'             , '0'             };
 133    Char_t   charge2 [18] = {'+'        , '-'        , '-'            , '+'            , '+'        , '-'        , '-'            , '+'            , '+'        , '-'        , '-'            , '+'            , '-'         , '+'             , '+'             , '-'             , '-'             , '+'             };
 134    Int_t    cutID1  [18] = { iCutLambda,  iCutLambda,  iCutAntiLambda,  iCutAntiLambda,  iCutLambda,  iCutLambda,  iCutAntiLambda,  iCutAntiLambda,  iCutLambda,  iCutLambda,  iCutAntiLambda,  iCutAntiLambda,  iCutLambda ,  iCutAntiLambda ,  iCutLambda     ,  iCutLambda     ,  iCutAntiLambda ,  iCutAntiLambda };
 135    Int_t    cutID2  [18] = { iCutPi    ,  iCutPi    ,  iCutPi        ,  iCutPi        ,  iCutPi    ,  iCutPi    ,  iCutPi        ,  iCutPi        ,  iCutPi    ,  iCutPi    ,  iCutPi        ,  iCutPi        ,  iCutPi     ,  iCutPi         ,  iCutPi         ,  iCutPi         ,  iCutPi         ,  iCutPi         };
 136    Int_t    ipdg    [18] = { 3224      ,  3114      , -3224          , -3114          ,  3224      ,  3114      , -3224          , -3114          ,  3224      ,  3114      , -3224          , -3114          ,  3312       , -3312           ,  3124           ,  3124           , -3124           , -3124           };
 137    Double_t mass    [18] = { 1.3828    ,  1.3872    ,  1.3828        ,  1.3872        ,  1.3828    ,  1.3872    ,  1.3828        ,  1.3872        ,  1.3828    ,  1.3872    ,  1.3828        ,  1.3872        ,  1.32171    ,  1.32171        ,  1.5195         ,  1.5195         ,  1.5195         ,  1.5195         };
 138
 139    for (Int_t i = 0; i < 18; i++) {
 140       if (!use[i]) continue;
 141       if (!isPP) output[i] = "SPARSE";
 142       // create output
 143       AliRsnMiniOutput *out = task->CreateOutput(Form("sigmastar_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
 144       // selection settings
 145       out->SetCutID(0, cutID1[i]);
 146       out->SetCutID(1, cutID2[i]);
 147       out->SetDaughter(0, AliRsnDaughter::kLambda);
 148       out->SetDaughter(1, AliRsnDaughter::kPion);
 149       out->SetCharge(0, charge1[i]);
 150       out->SetCharge(1, charge2[i]);
 151       out->SetMotherPDG(ipdg[i]);
 152       out->SetMotherMass(mass[i]);
 153       // pair cuts
 154       out->SetPairCuts(cutsPair);
 155       // axis X: invmass
 156       if (useIM[i])
 157          out->AddAxis(imID, 800, 1.2, 2.0);
 158       // axis Y: transverse momentum
 159          out->AddAxis(ptID, 100, 0.0, 10.0);
 160
 161       if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 162
 163     }
 164
 165    AddMonitorOutput_PionDCA(cutSetPi->GetMonitorOutput());
 166    AddMonitorOutput_PionPIDCut(cutSetPi->GetMonitorOutput());
 167    AddMonitorOutput_PionNTPC(cutSetPi->GetMonitorOutput());
 168
 169    AddMonitorOutput_LambdaMass(cutSetLambda->GetMonitorOutput());
 170    AddMonitorOutput_LambdaDCA(cutSetLambda->GetMonitorOutput());
 171    AddMonitorOutput_LambdaDaughterDCA(cutSetLambda->GetMonitorOutput());
 172    AddMonitorOutput_LambdaCosPointAngle(cutSetLambda->GetMonitorOutput());
 173    AddMonitorOutput_LambdaProtonPID(cutSetLambda->GetMonitorOutput());
 174    AddMonitorOutput_LambdaPionPID(cutSetLambda->GetMonitorOutput());
 175
 176    AddMonitorOutput_LambdaMass(cutSetAntiLambda->GetMonitorOutput());
 177    AddMonitorOutput_LambdaDCA(cutSetAntiLambda->GetMonitorOutput());
 178    AddMonitorOutput_LambdaDaughterDCA(cutSetAntiLambda->GetMonitorOutput());
 179    AddMonitorOutput_LambdaCosPointAngle(cutSetAntiLambda->GetMonitorOutput());
 180    AddMonitorOutput_LambdaAntiProtonPID(cutSetAntiLambda->GetMonitorOutput());
 181    AddMonitorOutput_LambdaAntiPionPID(cutSetAntiLambda->GetMonitorOutput());
 182
 183    if (isMC) {
 184
 185    TString mode = "HIST";
 186    if (!isPP) mode = "SPARSE";
 187
 188    // create output
 189    AliRsnMiniOutput *out = task->CreateOutput(Form("sigmastarP_TrueMC%s", suffix), mode.Data(), "MOTHER");
 190    // selection settings
 191    out->SetDaughter(0, AliRsnDaughter::kLambda);
 192    out->SetDaughter(1, AliRsnDaughter::kPion);
 193    out->SetMotherPDG(3224);
 194    out->SetMotherMass(1.3828);
 195    // pair cuts
 196    out->SetPairCuts(cutsPair);
 197    // binnings
 198    out->AddAxis(imID, 800, 1.2, 2.0);
 199    out->AddAxis(ptID, 100, 0.0, 10.0);
 200
 201    if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 202
 203    // create output
 204    AliRsnMiniOutput *out = task->CreateOutput(Form("sigmastarM_TrueMC%s", suffix), mode.Data(), "MOTHER");
 205    // selection settings
 206    out->SetDaughter(0, AliRsnDaughter::kLambda);
 207    out->SetDaughter(1, AliRsnDaughter::kPion);
 208    out->SetMotherPDG(3114);
 209    out->SetMotherMass(1.3872);
 210    // pair cuts
 211    out->SetPairCuts(cutsPair);
 212    // binnings
 213    out->AddAxis(imID, 800, 1.2, 2.0);
 214    out->AddAxis(ptID, 100, 0.0, 10.0);
 215
 216    if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 217
 218    // create output
 219    AliRsnMiniOutput *out = task->CreateOutput(Form("sigmastarPBar_TrueMC%s", suffix), mode.Data(), "MOTHER");
 220    // selection settings
 221    out->SetDaughter(0, AliRsnDaughter::kLambda);
 222    out->SetDaughter(1, AliRsnDaughter::kPion);
 223    out->SetMotherPDG(-3224);
 224    out->SetMotherMass(1.3828);
 225    // pair cuts
 226    out->SetPairCuts(cutsPair);
 227    // binnings
 228    out->AddAxis(imID, 800, 1.2, 2.0);
 229    out->AddAxis(ptID, 100, 0.0, 10.0);
 230
 231    if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 232
 233
 234    // create output
 235    AliRsnMiniOutput *out = task->CreateOutput(Form("sigmastarMBar_TrueMC%s", suffix), mode.Data(), "MOTHER");
 236    // selection settings
 237    out->SetDaughter(0, AliRsnDaughter::kLambda);
 238    out->SetDaughter(1, AliRsnDaughter::kPion);
 239    out->SetMotherPDG(-3114);
 240    out->SetMotherMass(1.3872);
 241    // pair cuts
 242    out->SetPairCuts(cutsPair);
 243    // binnings
 244    out->AddAxis(imID, 800, 1.2, 2.0);
 245    out->AddAxis(ptID, 100, 0.0, 10.0);
 246
 247    if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 248
 249    // create output
 250    AliRsnMiniOutput *out = task->CreateOutput(Form("XiP_TrueMC%s", suffix), mode.Data(), "MOTHER");
 251    // selection settings
 252    out->SetDaughter(0, AliRsnDaughter::kLambda);
 253    out->SetDaughter(1, AliRsnDaughter::kPion);
 254    out->SetMotherPDG(-3312);
 255    out->SetMotherMass(1.32171);
 256    // pair cuts
 257    out->SetPairCuts(cutsPair);
 258    // binnings
 259    out->AddAxis(imID, 800, 1.2, 2.0);
 260    out->AddAxis(ptID, 100, 0.0, 10.0);
 261
 262    if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 263
 264
 265    // create output
 266    AliRsnMiniOutput *out = task->CreateOutput(Form("XiM_TrueMC%s", suffix), mode.Data(), "MOTHER");
 267    // selection settings
 268    out->SetDaughter(0, AliRsnDaughter::kLambda);
 269    out->SetDaughter(1, AliRsnDaughter::kPion);
 270    out->SetMotherPDG(3312);
 271    out->SetMotherMass(1.32171);
 272    // pair cuts
 273    out->SetPairCuts(cutsPair);
 274    // binnings
 275    out->AddAxis(imID, 800, 1.2, 2.0);
 276    out->AddAxis(ptID, 100, 0.0, 10.0);
 277
 278    if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 279
 280
 281    AliRsnMiniOutput *out = task->CreateOutput(Form("Lambda1520P_TrueMC%s", suffix), mode.Data(), "MOTHER");
 282    // selection settings
 283    out->SetDaughter(0, AliRsnDaughter::kLambda);
 284    out->SetDaughter(1, AliRsnDaughter::kPion);
 285    out->SetCharge(0, 0);
 286    out->SetCharge(1, 1);
 287    out->SetMotherPDG(3124);
 288    out->SetMotherMass(1.5195);
 289    // pair cuts
 290    out->SetPairCuts(cutsPair);
 291    // binnings
 292    out->AddAxis(imID, 800, 1.2, 2.0);
 293    out->AddAxis(ptID, 100, 0.0, 10.0);
 294
 295    if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 296
 297    AliRsnMiniOutput *out = task->CreateOutput(Form("Lambda1520M_TrueMC%s", suffix), mode.Data(), "MOTHER");
 298    // selection settings
 299    out->SetDaughter(0, AliRsnDaughter::kLambda);
 300    out->SetDaughter(1, AliRsnDaughter::kPion);
 301    out->SetCharge(0, 0);
 302    out->SetCharge(1, -1);
 303    out->SetMotherPDG(3124);
 304    out->SetMotherMass(1.5195);
 305    // pair cuts
 306    out->SetPairCuts(cutsPair);
 307    // binnings
 308    out->AddAxis(imID, 800, 1.2, 2.0);
 309    out->AddAxis(ptID, 100, 0.0, 10.0);
 310
 311    if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 312
 313
 314    // create output
 315    AliRsnMiniOutput *out = task->CreateOutput(Form("Lambda1520PBar_TrueMC%s", suffix), mode.Data(), "MOTHER");
 316    // selection settings
 317    out->SetDaughter(0, AliRsnDaughter::kLambda);
 318    out->SetDaughter(1, AliRsnDaughter::kPion);
 319    out->SetCharge(0, 0);
 320    out->SetCharge(1, 1);
 321    out->SetMotherPDG(-3124);
 322    out->SetMotherMass(1.5195);
 323    // pair cuts
 324    out->SetPairCuts(cutsPair);
 325    // binnings
 326    out->AddAxis(imID, 800, 1.2, 2.0);
 327    out->AddAxis(ptID, 100, 0.0, 10.0);
 328
 329    if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 330
 331    AliRsnMiniOutput *out = task->CreateOutput(Form("Lambda1520MBar_TrueMC%s", suffix), mode.Data(), "MOTHER");
 332    // selection settings
 333    out->SetDaughter(0, AliRsnDaughter::kLambda);
 334    out->SetDaughter(1, AliRsnDaughter::kPion);
 335    out->SetCharge(0, 0);
 336    out->SetCharge(1, -1);
 337    out->SetMotherPDG(-3124);
 338    out->SetMotherMass(1.5195);
 339    // pair cuts
 340    out->SetPairCuts(cutsPair);
 341    // binnings
 342    out->AddAxis(imID, 800, 1.2, 2.0);
 343    out->AddAxis(ptID, 100, 0.0, 10.0);
 344
 345    if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
 346
 347
 348
 349    }
 350
 351    return kTRUE;
 352 }
 353
 354 void AddMonitorOutput_PionDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *pdca=0)
 355 {
 356
 357    // PionDCA
 358    AliRsnValueDaughter *axisPionDCA = new AliRsnValueDaughter("pion_dca", AliRsnValueDaughter::kDCAXY);
 359    axisPionDCA->SetBins(0.0,1,0.001);
 360
 361    // output: 2D histogram
 362    AliRsnListOutput *outMonitorPionDCA = new AliRsnListOutput("Pion_DCA", AliRsnListOutput::kHistoDefault);
 363    outMonitorPionDCA->AddValue(axisPionDCA);
 364
 365    // add outputs to loop
 366    if (mon) mon->Add(outMonitorPionDCA);
 367    if (pdca) pdca->AddOutput(outMonitorPionDCA);
 368
 369 }
 370
 371 void AddMonitorOutput_PionPIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piPID=0)
 372 {
 373
 374    // Pion PID Cut
 375    AliRsnValueDaughter *axisPionPIDCut = new AliRsnValueDaughter("pionPID", AliRsnValueDaughter::kTPCnsigmaPi);
 376    axisPionPIDCut->SetBins(0.0,5,0.01);
 377
 378    // output: 2D histogram
 379    AliRsnListOutput *outMonitorPionPIDCut = new AliRsnListOutput("Pion_PID_Cut", AliRsnListOutput::kHistoDefault);
 380    outMonitorPionPIDCut->AddValue(axisPionPIDCut);
 381
 382    // add outputs to loop
 383    if (mon) mon->Add(outMonitorPionPIDCut);
 384    if (piPID) piPID->AddOutput(outMonitorPionPIDCut);
 385
 386 }
 387
 388 void AddMonitorOutput_PionNTPC(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piNTPC=0)
 389 {
 390
 391    // Pion PID Cut
 392    AliRsnValueDaughter *axisPionNTPC = new AliRsnValueDaughter("pionNTPC", AliRsnValueDaughter::kNTPCclusters);
 393    axisPionNTPC->SetBins(0.0,200,1);
 394
 395    // output: 2D histogram
 396    AliRsnListOutput *outMonitorPionNTPC = new AliRsnListOutput("Pion_NTPC", AliRsnListOutput::kHistoDefault);
 397    outMonitorPionNTPC->AddValue(axisPionNTPC);
 398
 399    // add outputs to loop
 400    if (mon) mon->Add(outMonitorPionNTPC);
 401    if (piNTPC) pNTPC->AddOutput(outMonitorPionNTPC);
 402
 403 }
 404
 405
 406 void AddMonitorOutput_LambdaMass(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lm=0)
 407 {
 408
 409    // Mass
 410    AliRsnValueDaughter *axisMass = new AliRsnValueDaughter("lambda_mass", AliRsnValueDaughter::kMass);
 411    axisMass->SetBins(0.7,1.5,0.001);
 412
 413    // output: 2D histogram
 414    AliRsnListOutput *outMonitorM = new AliRsnListOutput("Lambda_Mass", AliRsnListOutput::kHistoDefault);
 415    outMonitorM->AddValue(axisMass);
 416
 417    // add outputs to loop
 418    if (mon) mon->Add(outMonitorM);
 419    if (lm) lm->AddOutput(outMonitorM);
 420
 421 }
 422
 423 void AddMonitorOutput_LambdaDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ldca=0)
 424 {
 425
 426    // Lambda DCA
 427    AliRsnValueDaughter *axisLambdaDCA = new AliRsnValueDaughter("lambda_dca", AliRsnValueDaughter::kV0DCA);
 428    axisLambdaDCA->SetBins(0.0,1,0.001);
 429
 430    // output: 2D histogram
 431    AliRsnListOutput *outMonitorLambdaDCA = new AliRsnListOutput("Lambda_DCA", AliRsnListOutput::kHistoDefault);
 432    outMonitorLambdaDCA->AddValue(axisLambdaDCA);
 433
 434    // add outputs to loop
 435    if (mon) mon->Add(outMonitorLambdaDCA);
 436    if (ldca) ldca->AddOutput(outMonitorLambdaDCA);
 437
 438 }
 439
 440 void AddMonitorOutput_LambdaDaughterDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ldaugdca=0)
 441 {
 442
 443    // Lambda Daughter DCA
 444    AliRsnValueDaughter *axisLambdaDDCA = new AliRsnValueDaughter("lambda_daughterDCA", AliRsnValueDaughter::kDaughterDCA);
 445    axisLambdaDDCA->SetBins(0.0,1,0.001);
 446
 447    // output: 2D histogram
 448    AliRsnListOutput *outMonitorLambdaDDCA = new AliRsnListOutput("Lambda_DaughterDCA", AliRsnListOutput::kHistoDefault);
 449    outMonitorLambdaDDCA->AddValue(axisLambdaDDCA);
 450
 451    // add outputs to loop
 452    if (mon) mon->Add(outMonitorLambdaDDCA);
 453    if (ldaugdca) ldaugdca->AddOutput(outMonitorLambdaDDCA);
 454
 455 }
 456
 457 void AddMonitorOutput_LambdaCosPointAngle(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lcpa=0)
 458 {
 459
 460    // Lambda Cosine of the Pointing Angle
 461    AliRsnValueDaughter *axisLambdaCPA = new AliRsnValueDaughter("lambda_cospointang", AliRsnValueDaughter::kCosPointAng);
 462    axisLambdaCPA->SetBins(0.97,1,0.0001);
 463
 464    // output: 2D histogram
 465    AliRsnListOutput *outMonitorLambdaCPA = new AliRsnListOutput("Lambda_CosineOfPointingAngle", AliRsnListOutput::kHistoDefault);
 466    outMonitorLambdaCPA->AddValue(axisLambdaCPA);
 467
 468    // add outputs to loop
 469    if (mon) mon->Add(outMonitorLambdaCPA);
 470    if (lcpa) lcpa->AddOutput(outMonitorLambdaCPA);
 471
 472 }
 473
 474 void AddMonitorOutput_LambdaProtonPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lpPID=0)
 475 {
 476
 477    // Lambda Cosine of the Pointing Angle
 478    AliRsnValueDaughter *axisLambdaProtonPID = new AliRsnValueDaughter("lambda_protonPID", AliRsnValueDaughter::kLambdaProtonPIDCut);
 479    axisLambdaProtonPID->SetBins(0.0,5,0.01);
 480
 481    // output: 2D histogram
 482    AliRsnListOutput *outMonitorLambdaProtonPID = new AliRsnListOutput("Lambda_ProtonPID", AliRsnListOutput::kHistoDefault);
 483    outMonitorLambdaProtonPID->AddValue(axisLambdaProtonPID);
 484
 485    // add outputs to loop
 486    if (mon) mon->Add(outMonitorLambdaProtonPID);
 487    if (lpPID) lpPID->AddOutput(outMonitorLambdaProtonPID);
 488
 489 }
 490
 491 void AddMonitorOutput_LambdaPionPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lpiPID=0)
 492 {
 493
 494    // Lambda Cosine of the Pointing Angle
 495    AliRsnValueDaughter *axisLambdaPionPID = new AliRsnValueDaughter("lambda_pionPID", AliRsnValueDaughter::kLambdaPionPIDCut);
 496    axisLambdaPionPID->SetBins(0.0,5,0.01);
 497
 498    // output: 2D histogram
 499    AliRsnListOutput *outMonitorLambdaPionPID = new AliRsnListOutput("Lambda_PionPID", AliRsnListOutput::kHistoDefault);
 500    outMonitorLambdaPionPID->AddValue(axisLambdaPionPID);
 501
 502    // add outputs to loop
 503    if (mon) mon->Add(outMonitorLambdaPionPID);
 504    if (lpiPID) lpiPID->AddOutput(outMonitorLambdaPionPID);
 505
 506 }
 507
 508 void AddMonitorOutput_LambdaAntiProtonPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lapPID=0)
 509 {
 510
 511    // Lambda Cosine of the Pointing Angle
 512    AliRsnValueDaughter *axisLambdaAntiProtonPID = new AliRsnValueDaughter("lambda_antiprotonPID", AliRsnValueDaughter::kAntiLambdaAntiProtonPIDCut);
 513    axisLambdaAntiProtonPID->SetBins(0.0,5,0.01);
 514
 515    // output: 2D histogram
 516    AliRsnListOutput *outMonitorLambdaAntiProtonPID = new AliRsnListOutput("Lambda_AntiProtonPID", AliRsnListOutput::kHistoDefault);
 517    outMonitorLambdaAntiProtonPID->AddValue(axisLambdaAntiProtonPID);
 518
 519    // add outputs to loop
 520    if (mon) mon->Add(outMonitorLambdaAntiProtonPID);
 521    if (lapPID) lapPID->AddOutput(outMonitorLambdaAntiProtonPID);
 522
 523 }
 524
 525 void AddMonitorOutput_LambdaAntiPionPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lapiPID=0)
 526 {
 527
 528    // Lambda Cosine of the Pointing Angle
 529    AliRsnValueDaughter *axisLambdaAntiPionPID = new AliRsnValueDaughter("lambda_antipionPID", AliRsnValueDaughter::kAntiLambdaAntiPionPIDCut);
 530    axisLambdaAntiPionPID->SetBins(0.0,5,0.01);
 531
 532    // output: 2D histogram
 533    AliRsnListOutput *outMonitorLambdaAntiPionPID = new AliRsnListOutput("Lambda_AntiPionPID", AliRsnListOutput::kHistoDefault);
 534    outMonitorLambdaAntiPionPID->AddValue(axisLambdaAntiPionPID);
 535
 536    // add outputs to loop
 537    if (mon) mon->Add(outMonitorLambdaAntiPionPID);
 538    if (lapiPID) lpiPID->AddOutput(outMonitorLambdaAntiPionPID);
 539
 540 }