PWGLF/STRANGENESS/Correlations/AliAnalysisTaskLambdaOverK0sJets.cxx

   1 /*************************************************************************
   2  * Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: X. Sanchez Castro                                              *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 //git test
  17
  18 #include <TCanvas.h>
  19 #include <TTree.h>
  20 #include <TFile.h>
  21 #include <TH1F.h>
  22 #include <TH2F.h>
  23 #include <THnSparse.h>
  24 #include <TH3F.h>
  25 #include <TPDGCode.h>
  26 #include <TDatabasePDG.h>
  27 #include <TClonesArray.h>
  28 #include <TROOT.h>
  29
  30 #include "AliOADBContainer.h"
  31
  32 #include "AliAODMCHeader.h"
  33 #include "AliAODMCParticle.h"
  34 #include "AliGenHijingEventHeader.h"
  35
  36 #include "AliAODEvent.h"
  37 #include "AliAODv0.h"
  38 #include "AliAODcascade.h"
  39
  40 #include "AliCFContainer.h"
  41 #include "AliCentrality.h"
  42
  43 #include "AliPID.h"
  44 #include "AliPIDResponse.h"
  45 #include "AliAODPid.h"
  46
  47 #include "AliInputEventHandler.h"
  48 #include "AliAnalysisManager.h"
  49
  50 #include "AliAnalysisTaskLambdaOverK0sJets.h"
  51
  52 //extern TROOT *gROOT;
  53
  54
  55 ClassImp(AliAnalysisTaskLambdaOverK0sJets)
  56 ClassImp(AliMiniParticle)
  57
  58 // Global variables:
  59 static Int_t    nbins = 100;                 // Number of bins for l, pt, mass for V0
  60 static Int_t    nbinsPhi = 120;              // Number of bins for Phi
  61 static Int_t    nbinsdPhi = 20;              // Number of bins for dPhi
  62 static Int_t    nbinsdEta = 30;              // Number of bins for dEta
  63 static Int_t    nbinPtLP = 200;
  64 static Int_t    nbinsVtx = 20;
  65
  66 static Float_t pMin = 0.0;                  // Lower cut for transverse momentum
  67 static Float_t pMax = 10.;                  // Max cut for transverse momentum for V0
  68 static Float_t ptMaxLP = 50.;               // Max cut for transverse momentum LP
  69
  70 static Float_t lMin = 0.0;                  // Limits in the histo for fidutial volume
  71 static Float_t lMax = 100.;                 // Limits in the fidutial volume
  72
  73 static Int_t   nMaxEvMix = 250;
  74
  75 //
  76 //
  77 //
  78
  79 AliAnalysisTaskLambdaOverK0sJets::AliAnalysisTaskLambdaOverK0sJets(const char *name) :
  80   AliAnalysisTaskSE(name),
  81
  82   fAOD(0),  fCollision("PbPb2010"), fIsMC(kFALSE), fUsePID(kFALSE), fCentMin(0.), fCentMax(90.), fDoQA(kFALSE), fDoMixEvt(kFALSE), fTrigPtMin(5.), fTrigPtMax(10.), fTrigPtMCMin(5.), fTrigPtMCMax(10000.), fTrigEtaMax(0.8), fCheckIDTrig(kFALSE), fSeparateInjPart(kTRUE), fEndOfHijingEvent(-1),  fPIDResponse(0),
  83
  84   fMinPtDaughter(0.160), fMaxEtaDaughter(0.8), fMaxDCADaughter(1.0), fUseEtaCut(kFALSE), fYMax(0.7), fDCAToPrimVtx(0.1), fMinCPA(0.998), fNSigma(3.0), fDaugNClsTPC(70.), fMinCtau(0.), fMaxCtau(3.), fIdTrigger(-1), fIsV0LP(0), fPtV0LP(0.), fIsSndCheck(0),
  85
  86   fOutput(0), fOutputQA(0), fOutputME(0), fMEList(0x0), fTriggerParticles(0x0), fTriggerPartMC(0x0), fAssocParticles(0x0), fAssocPartMC(0x0), fEvents(0), fCentrality(0),  fCentrality2(0), fCentralityTrig(0), fPrimayVtxGlobalvsSPD(0), fPrimaryVertexX(0), fPrimaryVertexY(0), fPrimaryVertexZ(0),
  87
  88  fTriggerEventPlane(0),  fTriggerMCPtCent(0), fTriggerMCResPt(0), fTriggerMCResEta(0), fTriggerMCResPhi(0), fTriggerPtCent(0),  fTriggerPtCentCh(0), fNTrigPerEvt(0), fTriggerWiSPDHit(0), fTriggerEtaPhi(0), fCheckTriggerFromV0Daug(0), fTriggerComingFromDaug(0), fTriggerIsV0(0), fCheckIDTrigPtK0s(0), fCheckIDTrigPhiK0s(0), fCheckIDTrigEtaK0s(0), fCheckIDTrigNclsK0s(0), fCheckIDTrigPtLambda(0), fCheckIDTrigPhiLambda(0), fCheckIDTrigEtaLambda(0),  fCheckIDTrigNclsLambda(0), fCheckIDTrigPtAntiLambda(0), fCheckIDTrigPhiAntiLambda(0), fCheckIDTrigEtaAntiLambda(0), fCheckIDTrigNclsAntiLambda(0),
  89
  90 fInjectedParticles(0),
  91
  92 fK0sMCPt(0), fK0sMCPtRap(0), fK0sMCPtRap2(0),  fK0sMCPtRapEmbeded(0), fK0sAssocPt(0), fK0sAssocPtArm(0),  fK0sAssocPtRap(0), fK0sAssocPtRapEmbeded(0), fK0sMCResEta(0), fK0sMCResPhi(0), fLambdaMCPt(0), fLambdaMCPtRap(0), fLambdaMCPtRap2(0),  fLambdaMCPtRapEmbeded(0),  fLambdaMCFromXi(0), fLambdaAssocPt(0), fLambdaAssocPtRap(0), fLambdaAssocFromXi(0), fLambdaMCResEta(0), fLambdaMCResPhi(0), fAntiLambdaMCPt(0), fAntiLambdaMCPtRap(0), fAntiLambdaMCPtRap2(0), fAntiLambdaMCPtRapEmbeded(0), fAntiLambdaMCFromXi(0), fAntiLambdaAssocPt(0), fAntiLambdaAssocPtRap(0), fAntiLambdaAssocFromXi(0), fAntiLambdaMCResEta(0), fAntiLambdaMCResPhi(0),
  93
  94   fHistArmenterosPodolanski(0), fHistArmPodBckg(0),
  95
  96   fK0sMass(0), fK0sMassEmbeded(0), fK0sMassPtEta(0), fK0sMassPtPhi(0), fK0sDaughtersPt(0),  fSharedClsTrigDaug(0), fK0sPosDaugSplCheckCovMat(0x0), fK0sNegDaugSplCheckCovMat(0x0), fK0sDCADaugToPrimVtx(0), fK0sSpatialRes(0), fK0sBckgDecLength(0), fK0sBckgDCADaugToPrimVtx(0), fK0sBckgEtaPhi(0), fK0sBckgPhiRadio(0), fK0sBckgDCANegDaugToPrimVtx(0), fK0sBckgDCAPosDaugToPrimVtx(0), fV0MassCascade(0),
  97
  98   fLambdaMass(0), fLambdaMassEmbeded(0), fLambdaMass2(0), fLambdaMass2Embeded(0), fLambdaMassPtEta(0), fLambdaMassPtPhi(0), fLambdaDaughtersPt(0), fLambdaPosDaugSplCheckCovMat(0x0), fLambdaNegDaugSplCheckCovMat(0x0), fLambdaDCADaugToPrimVtx(0), fLambdaSpatialRes(0), fLambdaBckgDecLength(0), fLambdaBckgDCADaugToPrimVtx(0), fLambdaBckgEtaPhi(0), fLambdaBckgPhiRadio(0), fLambdaBckgDCANegDaugToPrimVtx(0), fLambdaBckgDCAPosDaugToPrimVtx(0),
  99
 100   fAntiLambdaMass(0), fAntiLambdaMassEmbeded(0), fAntiLambdaMass2(0), fAntiLambdaMass2Embeded(0), fAntiLambdaMassPtEta(0), fAntiLambdaMassPtPhi(0), fAntiLambdaDaughtersPt(0), fAntiLambdaPosDaugSplCheckCovMat(0x0), fAntiLambdaNegDaugSplCheckCovMat(0x0), fAntiLambdaDCADaugToPrimVtx(0), fAntiLambdaSpatialRes(0), fAntiLambdaBckgDecLength(0), fAntiLambdaBckgDCADaugToPrimVtx(0), fAntiLambdaBckgEtaPhi(0), fAntiLambdaBckgPhiRadio(0), fAntiLambdaBckgDCANegDaugToPrimVtx(0), fAntiLambdaBckgDCAPosDaugToPrimVtx(0),
 101
 102   fK0sPtPosDaug(0), fK0sPtNegDaug(0), fK0sBckgPtPosDaug(0), fK0sBckgPtNegDaug(0), fK0sPhiEtaPosDaug(0), fK0sPhiEtaNegDaug(0), fK0sBckgPhiEtaPosDaug(0), fK0sBckgPhiEtaNegDaug(0), fK0sDCAPosDaug(0), fK0sDCANegDaug(0), fK0sBckgDCAPosDaug(0), fK0sBckgDCANegDaug(0), fK0sDecayPos(0), fK0sBckgDecayPos(0), fK0sDecayVertex(0), fK0sBckgDecayVertex(0), fK0sCPA(0), fK0sBckgCPA(0), fK0sDCAV0Daug(0), fK0sBckgDCAV0Daug(0), fK0sNClustersTPC(0), fK0sBckgNClustersTPC(0), fK0sNClustersITSPos(0), fK0sNClustersITSNeg(0), fK0sBckgNClustersITSPos(0), fK0sBckgNClustersITSNeg(0),
 103
 104   fLambdaPtPosDaug(0), fLambdaPtNegDaug(0), fLambdaBckgPtPosDaug(0), fLambdaBckgPtNegDaug(0), fLambdaPhiEtaPosDaug(0),fLambdaPhiEtaNegDaug(0), fLambdaBckgPhiEtaPosDaug(0),fLambdaBckgPhiEtaNegDaug(0), fLambdaDCAPosDaug(0),fLambdaDCANegDaug(0), fLambdaBckgDCAPosDaug(0), fLambdaBckgDCANegDaug(0), fLambdaDecayPos(0), fLambdaBckgDecayPos(0), fLambdaDecayVertex(0), fLambdaBckgDecayVertex(0), fLambdaCPA(0), fLambdaBckgCPA(0), fLambdaDCAV0Daug(0), fLambdaBckgDCAV0Daug(0), fLambdaNClustersTPC(0), fLambdaBckgNClustersTPC(0), fLambdaNClustersITSPos(0), fLambdaNClustersITSNeg(0), fLambdaBckgNClustersITSPos(0),  fLambdaBckgNClustersITSNeg(0),
 105
 106   fAntiLambdaPtPosDaug(0), fAntiLambdaPtNegDaug(0), fAntiLambdaBckgPtPosDaug(0), fAntiLambdaBckgPtNegDaug(0), fAntiLambdaPhiEtaPosDaug(0),fAntiLambdaPhiEtaNegDaug(0), fAntiLambdaBckgPhiEtaPosDaug(0),fAntiLambdaBckgPhiEtaNegDaug(0), fAntiLambdaDCAPosDaug(0),fAntiLambdaDCANegDaug(0), fAntiLambdaBckgDCAPosDaug(0), fAntiLambdaBckgDCANegDaug(0), fAntiLambdaDecayPos(0), fAntiLambdaBckgDecayPos(0), fAntiLambdaDecayVertex(0), fAntiLambdaBckgDecayVertex(0), fAntiLambdaCPA(0), fAntiLambdaBckgCPA(0), fAntiLambdaDCAV0Daug(0), fAntiLambdaBckgDCAV0Daug(0), fAntiLambdaNClustersTPC(0), fAntiLambdaBckgNClustersTPC(0), fAntiLambdaNClustersITSPos(0), fAntiLambdaNClustersITSNeg(0), fAntiLambdaBckgNClustersITSPos(0),  fAntiLambdaBckgNClustersITSNeg(0)
 107
 108 {
 109   // Dummy Constructor
 110
 111   // Particles properties in MC
 112   for (Int_t i=0; i<kNCent; i++){
 113
 114     // K0s
 115     fK0sMCPtRapVtx[i] = 0;
 116     fK0sMCPtRapVtxEmbeded[i] = 0;
 117     fK0sMCPtPhiEta[i] = 0;
 118     fK0sAssocPtPhiEta[i] = 0;
 119     // -- Natural particles
 120     fK0sAssocPtMassArm[i] = 0;
 121     fK0sAssocMassPtVtx[i] = 0;
 122     fK0sAssocMassPtDCADaug[i] = 0;
 123     fK0sAssocMassPtCPA[i] = 0;
 124     fK0sAssocMassPtDCAPV[i] = 0;
 125     fK0sAssocMassPtDaugNClsTPC[i] = 0;
 126     // -- Embeded particles
 127     fK0sAssocPtMassArmEmbeded[i] = 0;
 128     fK0sAssocMassPtVtxEmbeded[i] = 0;
 129     fK0sAssocMassPtDCADaug[i] = 0;
 130     fK0sAssocMassPtCPAEmbeded[i] = 0;
 131     fK0sAssocMassPtDCAPVEmbeded[i] = 0;
 132     fK0sAssocMassPtDaugNClsTPCEmbeded[i] = 0;
 133     // -- Mass vs rapidity vs pt vs centrlaity
 134     fK0sMassPtRap[i] = 0;
 135
 136     // Lambda
 137     fLambdaMCPtRapVtx[i] = 0;
 138     fLambdaMCPtRapVtxEmbeded[i] = 0;
 139     fLambdaMCPtPhiEta[i] = 0;
 140     fLambdaAssocPtPhiEta[i] = 0;
 141     // -- Natural particles
 142     fLambdaAssocMassPtRap[i] = 0;
 143     fLambdaAssocMassPtRap2[i] = 0;
 144     fLambdaAssocMassPtVtx[i] = 0;
 145     fLambdaAssocMassPtDCADaug[i] = 0;
 146     fLambdaAssocMassPtCPA[i] = 0;
 147     fLambdaAssocMassPtDCAPV[i] = 0;
 148     fLambdaAssocMassPtDaugNClsTPC[i] = 0;
 149     // -- Embeded particles
 150     fLambdaAssocMassPtRapEmbeded[i] = 0;
 151     fLambdaAssocMassPtRapEmbeded2[i] = 0;
 152     fLambdaAssocMassPtVtxEmbeded[i] = 0;
 153     fLambdaAssocMassPtDCADaug[i] = 0;
 154     fLambdaAssocMassPtCPAEmbeded[i] = 0;
 155     fLambdaAssocMassPtDCAPVEmbeded[i] = 0;
 156     fLambdaAssocMassPtDaugNClsTPCEmbeded[i] = 0;
 157     // -- Mass vs rapidity vs pt vs centrlaity
 158     fLambdaMassPtRap[i] = 0;
 159
 160     // AntiLambda
 161     fAntiLambdaMCPtRapVtx[i] = 0;
 162     fAntiLambdaMCPtRapVtxEmbeded[i] = 0;
 163     fAntiLambdaMCPtPhiEta[i] = 0;
 164     fAntiLambdaAssocPtPhiEta[i] = 0;
 165     // -- Natural particles
 166     fAntiLambdaAssocMassPtRap[i] = 0;
 167     fAntiLambdaAssocMassPtRap2[i] = 0;
 168     fAntiLambdaAssocMassPtVtx[i] = 0;
 169     fAntiLambdaAssocMassPtDCADaug[i] = 0;
 170     fAntiLambdaAssocMassPtCPA[i] = 0;
 171     fAntiLambdaAssocMassPtDCAPV[i] = 0;
 172     fAntiLambdaAssocMassPtDaugNClsTPC[i] = 0;
 173     // -- Embeded particles
 174     fAntiLambdaAssocMassPtRapEmbeded[i] = 0;
 175     fAntiLambdaAssocMassPtRapEmbeded2[i] = 0;
 176     fAntiLambdaAssocMassPtVtxEmbeded[i] = 0;
 177     fAntiLambdaAssocMassPtDCADaug[i] = 0;
 178     fAntiLambdaAssocMassPtCPAEmbeded[i] = 0;
 179     fAntiLambdaAssocMassPtDCAPVEmbeded[i] = 0;
 180     fAntiLambdaAssocMassPtDaugNClsTPCEmbeded[i] = 0;
 181     // -- Mass vs rapidity vs pt vs centrlaity
 182     fAntiLambdaMassPtRap[i] = 0;
 183   }
 184
 185   // Correlations in MC
 186   for (Int_t i=0; i<kNCent*kN1; i++){
 187     // K0s
 188     fK0sdPhidEtaMC[i] = 0;
 189     // Lambda
 190     fLambdadPhidEtaMC[i] = 0;
 191     // AntiLambda
 192     fAntiLambdadPhidEtaMC[i] = 0;
 193   }
 194
 195   // Correlations
 196   for (Int_t i=0; i<(kNCent*kN1*kNVtxZ); i++){
 197     // K0s
 198     fK0sdPhidEtaPtL[i] = 0;
 199     // Lambda
 200     fLambdadPhidEtaPtL[i] = 0;
 201     // AntiLambda
 202     fAntiLambdadPhidEtaPtL[i] = 0;
 203   }
 204
 205   // Mixed events distributions
 206   for (Int_t i=0; i<(kN1*kNVtxZ*kNCent); i++){
 207     fK0sdPhidEtaME[i] = 0;
 208     fLambdadPhidEtaME[i] = 0;
 209     fAntiLambdadPhidEtaME[i] = 0;
 210   }
 211
 212   // Constructor. Initialization of pointers
 213   DefineOutput(1, TList::Class());
 214   DefineOutput(2, TList::Class());
 215   DefineOutput(3, TList::Class());
 216
 217
 218 }
 219
 220 //___________________________________________________________________________________________
 221
 222 AliAnalysisTaskLambdaOverK0sJets::~AliAnalysisTaskLambdaOverK0sJets()
 223 {
 224
 225   // Destructor
 226   if(fMEList){
 227
 228     for(Int_t icent=0; icent<kNCent; icent++){
 229       for(Int_t iz=0; iz<kNVtxZ; iz++){
 230         fMEList[icent*kNVtxZ+iz]->Delete();  delete fMEList[icent*kNVtxZ+iz];
 231       }
 232     }
 233     delete[] fMEList; fMEList=0x0;
 234   }
 235
 236   if(fTriggerParticles) {
 237     delete fTriggerParticles;
 238     fTriggerParticles=0x0;
 239   }
 240
 241   if(fTriggerPartMC) {
 242     delete fTriggerPartMC;
 243     fTriggerPartMC=0x0;
 244   }
 245
 246   if(fAssocParticles) {
 247     delete fAssocParticles;
 248     fAssocParticles=0x0;
 249   }
 250
 251   if(fAssocPartMC) {
 252     delete fAssocPartMC;
 253     fAssocPartMC=0x0;
 254   }
 255
 256
 257 }
 258
 259 //___________________________________________________________________________________________
 260
 261 void AliAnalysisTaskLambdaOverK0sJets::UserCreateOutputObjects()
 262 {
 263   // Creating the histograms that are needed for the output
 264
 265   fOutput = new TList();
 266   fOutput->SetOwner();
 267
 268   fOutputQA = new TList();
 269   fOutputQA->SetOwner();
 270
 271   fOutputME = new TList();
 272   fOutputME->SetOwner();
 273
 274   fMEList = new TList*[kNCent*kNVtxZ];
 275   for(Int_t icent=0; icent<kNCent; icent++){
 276     for(Int_t iz=0; iz<kNVtxZ; iz++){
 277       fMEList[icent*kNVtxZ+iz] = new TList();
 278       fMEList[icent*kNVtxZ+iz]->SetOwner(kFALSE);
 279     }
 280   }
 281
 282   char hNameHist[100];
 283
 284   // ====== General characteristics of the event and tracks ====== //
 285
 286   // Counter for the number of events in each step:
 287   fEvents=new TH1F("fEvents","Number of events",14,-0.5,13.5);
 288   fEvents->GetXaxis()->SetBinLabel(1,"calls to UserExec()");
 289   fEvents->GetXaxis()->SetBinLabel(2,"AOD available");
 290   fEvents->GetXaxis()->SetBinLabel(3,"CINT1B");
 291   fEvents->GetXaxis()->SetBinLabel(4,"V0M Cent");
 292   fEvents->GetXaxis()->SetBinLabel(5,"Global Vtx > 3 part");
 293   fEvents->GetXaxis()->SetBinLabel(6,"SPD Vtx > 3 part");
 294   fEvents->GetXaxis()->SetBinLabel(7,"|ZVtx Global - Zvtx SPD| < 0.5 cm");
 295   fEvents->GetXaxis()->SetBinLabel(8,"|VtxZ| < 10 cm");
 296   fEvents->GetXaxis()->SetBinLabel(9,"V0 is LP");
 297   fEvents->GetXaxis()->SetBinLabel(10," ");
 298   fEvents->GetXaxis()->SetBinLabel(11," ");
 299   fEvents->GetXaxis()->SetBinLabel(12,"Triggered");
 300   fEvents->GetXaxis()->SetBinLabel(13,"NOT Triggered");
 301   fEvents->GetXaxis()->SetBinLabel(14," ");
 302   fEvents->GetYaxis()->SetTitle("Counts");
 303   fOutput->Add(fEvents);
 304
 305   // Centrality:
 306   fCentrality = new TH1F("fCentrality","Centrality;Centrality (%);Events",100,0.,100.);
 307   fOutput->Add(fCentrality);
 308
 309   fCentrality2 = new TH1F("fCentrality2","Centrality in events with |VtxZ|<10 cm;Centrality (%);Events",100,0.,100.);
 310   fOutput->Add(fCentrality2);
 311
 312   fCentralityTrig = new TH2F("fCentralityTrig","Centrality in events per trigger selection;Centrality (%);Triger Selection",100,0.,100.,3,0.5,3.5);
 313   fCentralityTrig->GetYaxis()->SetBinLabel(1,"kCentral");
 314   fCentralityTrig->GetYaxis()->SetBinLabel(2,"kSemiCentral");
 315   fCentralityTrig->GetYaxis()->SetBinLabel(3,"kMB");
 316   fOutput->Add(fCentralityTrig);
 317
 318   // Primary Vertex:
 319   fPrimayVtxGlobalvsSPD = new TH2F("fPrimayVtxGlobalvsSPD",";Z_{vtx,tr} (cm);Z_{SPD,tr} (cm)",200,-20,20,200,-20,20);
 320   fOutput->Add(fPrimayVtxGlobalvsSPD);
 321
 322   fPrimaryVertexX = new TH1F("fPrimaryVertexX", "Primary Vertex Position X;Primary Vertex Position X (cm);Events",100,-0.5,0.5);
 323   fOutput->Add(fPrimaryVertexX);
 324
 325   fPrimaryVertexY = new TH1F("fPrimaryVertexY", "Primary Vertex Position Y;Primary Vertex Position Y (cm);Events",100,-0.5,0.5);
 326   fOutput->Add(fPrimaryVertexY);
 327
 328   fPrimaryVertexZ = new TH1F("fPrimaryVertexZ", "Primary Vertex Position Z;Primary Vertex Position Z (cm);Events",200,-20,20);
 329   fOutput->Add(fPrimaryVertexZ);
 330
 331
 332   // ====== Trigger Particle characteristics ====== //
 333
 334   // Difference between Event plane and the Trigger particles:
 335   fTriggerEventPlane = new TH1F("fTriggerEventPlane", ";#varphi_{EP}-#varphi_{Trig};Events",50,0.,TMath::Pi());
 336   fOutput->Add(fTriggerEventPlane);
 337
 338   // MC: Pt Trigger particle vs centrality:
 339   if(fIsMC){
 340     fTriggerMCPtCent = new TH2F("fTriggerMCPtCent","Trigger particle MC;#it{p}_{T} (GeV/#it{c});centrality (%)",2*nbinPtLP,pMin,2*ptMaxLP,100,0.,100.);
 341     fOutput->Add(fTriggerMCPtCent);
 342
 343     fTriggerMCResPt = new TH3F("fTriggerMCResPt","Trigger particle MC: p_{t} resolution;(p_{t,MC}-p_{t,Rec})/p_{t,Rec};p_{t} (GeV/#it{c});centrality",60,-0.3,0.3,2*nbinPtLP,pMin,ptMaxLP,100,0.,100.);
 344     fOutput->Add(fTriggerMCResPt);
 345
 346     fTriggerMCResEta = new TH3F("fTriggerMCResEta","Trigger particle MC: #eta resolution; #eta_{MC}-#eta_{Rec};p_{t} (GeV/#it{c}); centrality",40,-0.1,0.1,2*nbinPtLP,pMin,ptMaxLP,100,0.,100.);
 347     fOutput->Add(fTriggerMCResEta);
 348
 349     fTriggerMCResPhi = new TH3F("fTriggerMCResPhi","Trigger particle MC: #varphi resolution; #varphi_{MC}-#varphi_{Rec};p_{t} (GeV/#it{c}); centrality",40,-0.1,0.1,2*nbinPtLP,pMin,ptMaxLP,100,0.,100.);
 350     fOutput->Add(fTriggerMCResPhi);
 351   }
 352
 353   // Pt Trigger particle vs centrality:
 354   fTriggerPtCent = new TH3F("fTriggerPtCent","Trigger particle;#it{p}_{T} (GeV/#it{c});centrality (%);Vertex Z (cm)",nbinPtLP,pMin,ptMaxLP,100,0.,100.,nbinsVtx,-10.,10.);
 355   fOutput->Add(fTriggerPtCent);
 356
 357   fTriggerPtCentCh = new TH3F("fTriggerPtCentCh","Trigger particle;#it{p}_{T} (GeV/#it{c});centrality (%);Vertex Z (cm)",nbinPtLP,pMin,ptMaxLP,100,0.,100.,nbinsVtx,-10.,10.);
 358   fOutput->Add(fTriggerPtCentCh);
 359
 360   fNTrigPerEvt = new TH2F("fNTrigPerEvt","Number of Trigger Particles Per Event;Counts;Centrality",51,-0.5,50.5,100,0.,100);
 361   fOutput->Add(fNTrigPerEvt);
 362
 363   fTriggerWiSPDHit = new TH1F("fTriggerWiSPDHit","Number of Trigger Particles wi SPD Hits",3,0.,3.);
 364   fOutput->Add(fTriggerWiSPDHit);
 365
 366   // Phi vs pseudorapidity:
 367   fTriggerEtaPhi = new TH2F("fTriggerEtaPhi","Trigger particle;#varphi (rad);#eta",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.);
 368   fOutput->Add(fTriggerEtaPhi);
 369
 370   // Check if Trigger particle comes from a V0 daughter:
 371   fCheckTriggerFromV0Daug =
 372     new TH1F("fCheckTriggerFromV0Daug","Trigger particle from a V0 daughter;;Counts",4,-0.5,3.5);
 373   fCheckTriggerFromV0Daug->GetXaxis()->SetTitle("Flag");
 374   fCheckTriggerFromV0Daug->GetXaxis()->SetBinLabel(1,"NOT V0 daug");
 375   fCheckTriggerFromV0Daug->GetXaxis()->SetBinLabel(2,"V0 daug");
 376   fCheckTriggerFromV0Daug->GetXaxis()->SetBinLabel(3,"V0 daug & V0 LP");
 377   fOutput->Add(fCheckTriggerFromV0Daug);
 378
 379   fTriggerComingFromDaug = new TH1F("fTriggerComingFromDaug","Trigger particle from a V0 daughter;#it{p}_{T} (GeV/#it{c});Counts",240, 0, 12);
 380   fOutput->Add(fTriggerComingFromDaug);
 381
 382   fTriggerIsV0 = new TH1F("fTriggerIsV0","V0 candidate is a LP;#it{p}_{T} (GeV/#it{c});Counts",nbinPtLP,pMin,ptMaxLP);
 383   fOutput->Add(fTriggerIsV0);
 384
 385   // ------------------- > Comaring properties of this trigger with the daughters
 386   //   K0s
 387   fCheckIDTrigPtK0s = new TH3F("fCheckIDTrigPtK0s","K^{0}_{S};#deltap/p_{tri};;p_{V0}",40,-0.2,0.2,7,-0.5,6.5,100,1.,11.);
 388   fCheckIDTrigPtK0s->GetYaxis()->SetBinLabel(1,"Pos Daug X");
 389   fCheckIDTrigPtK0s->GetYaxis()->SetBinLabel(2,"Pos Daug Y");
 390   fCheckIDTrigPtK0s->GetYaxis()->SetBinLabel(3,"Pos Daug Z");
 391   fCheckIDTrigPtK0s->GetYaxis()->SetBinLabel(4,"Neg Daug X");
 392   fCheckIDTrigPtK0s->GetYaxis()->SetBinLabel(5,"Neg Daug Y");
 393   fCheckIDTrigPtK0s->GetYaxis()->SetBinLabel(6,"Neg Daug Z");
 394   fOutput->Add(fCheckIDTrigPtK0s);
 395
 396   fCheckIDTrigPhiK0s = new TH3F("fCheckIDTrigPhiK0s","K^{0}_{S};#delta#varphi;;p_{V0}",40,-0.1,0.1,3,-0.5,2.5,100,1.,11.);
 397   fCheckIDTrigPhiK0s->GetYaxis()->SetBinLabel(1,"Pos Daug");
 398   fCheckIDTrigPhiK0s->GetYaxis()->SetBinLabel(2,"Neg Daug");
 399   fOutput->Add(fCheckIDTrigPhiK0s);
 400
 401   fCheckIDTrigEtaK0s = new TH3F("fCheckIDTrigEtaK0s","K^{0}_{S};#delta#eta;;p_{V0}",40,-0.1,0.1,3,-0.5,2.5,100,1.,11.);
 402   fCheckIDTrigEtaK0s->GetYaxis()->SetBinLabel(1,"Pos Daug");
 403   fCheckIDTrigEtaK0s->GetYaxis()->SetBinLabel(2,"Neg Daug");
 404   fOutput->Add(fCheckIDTrigEtaK0s);
 405
 406   fCheckIDTrigNclsK0s = new TH3F("fCheckIDTrigNclsK0s","K^{0}_{S};NCls TPC;;p_{V0}",181,0.5,180.5,3,-0.5,2.5,100,1.,11.);
 407   fCheckIDTrigNclsK0s->GetYaxis()->SetBinLabel(1,"Pos Daug");
 408   fCheckIDTrigNclsK0s->GetYaxis()->SetBinLabel(2,"Neg Daug");
 409   fOutput->Add(fCheckIDTrigNclsK0s);
 410
 411   //   Lambda
 412   fCheckIDTrigPtLambda = new TH3F("fCheckIDTrigPtLambda","#Lambda",40,-0.1,0.1,7,-0.5,6.5,100,1.,11.);
 413   fCheckIDTrigPtLambda->GetYaxis()->SetBinLabel(1,"Pos Daug X");
 414   fCheckIDTrigPtLambda->GetYaxis()->SetBinLabel(2,"Pos Daug Y");
 415   fCheckIDTrigPtLambda->GetYaxis()->SetBinLabel(3,"Pos Daug Z");
 416   fCheckIDTrigPtLambda->GetYaxis()->SetBinLabel(4,"Neg Daug X");
 417   fCheckIDTrigPtLambda->GetYaxis()->SetBinLabel(5,"Neg Daug Y");
 418   fCheckIDTrigPtLambda->GetYaxis()->SetBinLabel(6,"Neg Daug Z");
 419   fOutput->Add(fCheckIDTrigPtLambda);
 420
 421   fCheckIDTrigPhiLambda  = new TH3F("fCheckIDTrigPhiLambda","#Lambda",40,-0.1,0.1,3,-0.5,2.5,100,1.,11.);
 422   fCheckIDTrigPhiLambda->GetYaxis()->SetBinLabel(1,"Pos Daug");
 423   fCheckIDTrigPhiLambda->GetYaxis()->SetBinLabel(2,"Neg Daug");
 424   fOutput->Add(fCheckIDTrigPhiLambda);
 425
 426   fCheckIDTrigEtaLambda  = new TH3F("fCheckIDTrigEtaLambda","#Lambda",40,-0.1,0.1,3,-0.5,2.5,100,1.,11.);
 427   fCheckIDTrigEtaLambda->GetYaxis()->SetBinLabel(1,"Pos Daug");
 428   fCheckIDTrigEtaLambda->GetYaxis()->SetBinLabel(2,"Neg Daug");
 429   fOutput->Add(fCheckIDTrigEtaLambda);
 430
 431   fCheckIDTrigNclsLambda = new TH3F("fCheckIDTrigNclsLambda","#Lambda;NCls TPC;;p_{V0}",181,0.5,180.5,3,-0.5,2.5,100,1.,11.);
 432   fCheckIDTrigNclsLambda->GetYaxis()->SetBinLabel(1,"Pos Daug");
 433   fCheckIDTrigNclsLambda->GetYaxis()->SetBinLabel(2,"Neg Daug");
 434   fOutput->Add(fCheckIDTrigNclsLambda);
 435
 436   //   AntiLambda
 437   fCheckIDTrigPtAntiLambda = new TH3F("fCheckIDTrigPtAntiLambda","#bar{#Lambda}",40,-0.2,0.2,7,-0.5,6.5,100,1.,11.);
 438   fCheckIDTrigPtAntiLambda->GetYaxis()->SetBinLabel(1,"Pos Daug X");
 439   fCheckIDTrigPtAntiLambda->GetYaxis()->SetBinLabel(2,"Pos Daug Y");
 440   fCheckIDTrigPtAntiLambda->GetYaxis()->SetBinLabel(3,"Pos Daug Z");
 441   fCheckIDTrigPtAntiLambda->GetYaxis()->SetBinLabel(4,"Neg Daug X");
 442   fCheckIDTrigPtAntiLambda->GetYaxis()->SetBinLabel(5,"Neg Daug Y");
 443   fCheckIDTrigPtAntiLambda->GetYaxis()->SetBinLabel(6,"Neg Daug Z");
 444   fOutput->Add(fCheckIDTrigPtAntiLambda);
 445
 446   fCheckIDTrigPhiAntiLambda  = new TH3F("fCheckIDTrigPhiAntiLambda","#bar{#Lambda}",40,-0.1,0.1,3,-0.5,2.5,100,1.,11.);
 447   fCheckIDTrigPhiAntiLambda->GetYaxis()->SetBinLabel(1,"Pos Daug");
 448   fCheckIDTrigPhiAntiLambda->GetYaxis()->SetBinLabel(2,"Neg Daug");
 449   fOutput->Add(fCheckIDTrigPhiAntiLambda);
 450
 451   fCheckIDTrigEtaAntiLambda  = new TH3F("fCheckIDTrigEtaAntiLambda","#bar{#Lambda}",40,-0.1,0.1,3,-0.5,2.5,100,1.,11.);
 452   fCheckIDTrigEtaAntiLambda->GetYaxis()->SetBinLabel(1,"Pos Daug");
 453   fCheckIDTrigEtaAntiLambda->GetYaxis()->SetBinLabel(2,"Neg Daug");
 454   fOutput->Add(fCheckIDTrigEtaAntiLambda);
 455
 456   fCheckIDTrigNclsAntiLambda = new TH3F("fCheckIDTrigNclsAntiLambda","#bar{#Lambda};NCls TPC;;p_{V0}",181,0.5,180.5,3,-0.5,2.5,100,1.,11.);
 457   fCheckIDTrigNclsAntiLambda->GetYaxis()->SetBinLabel(1,"Pos Daug");
 458   fCheckIDTrigNclsAntiLambda->GetYaxis()->SetBinLabel(2,"Neg Daug");
 459   fOutput->Add(fCheckIDTrigNclsAntiLambda);
 460
 461   // ====== MC-true and  MC-Association information ====== //
 462   if(fIsMC){
 463
 464     fInjectedParticles = new TH1F("fInjectedParticles","Injected particles;;Counts",2,0.,2.);
 465     fInjectedParticles->GetXaxis()->SetBinLabel(1,"Injected");
 466     fInjectedParticles->GetXaxis()->SetBinLabel(2,"Natural");
 467     fOutput->Add(fInjectedParticles);
 468
 469     // K0s MC-true:
 470     fK0sMCPt       = new TH1F("fK0sMCPt", "K^{0}_{S} MC;#it{p}_{T} (GeV/#it{c});Counts",nbins,pMin,pMax);
 471     fOutput->Add(fK0sMCPt);
 472
 473     fK0sMCPtRap    = new TH3F("fK0sMCPtRap", "K^{0}_{S} MC;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 474     fOutput->Add(fK0sMCPtRap);
 475
 476     fK0sMCPtRap2   = new TH3F("fK0sMCPtRap2", "K^{0}_{S} MC;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 477     fOutput->Add(fK0sMCPtRap2);
 478
 479     for(Int_t jj=0;jj<kNCent;jj++){
 480       snprintf(hNameHist,100, "fK0sMCPtRapVtx_Cent_%d",jj);
 481       fK0sMCPtRapVtx[jj] = new TH3F(hNameHist, "K^{0}_{S} MC  |VtxZ|;#it{p}_{T} (GeV/#it{c});y;VtxZ",nbins,pMin,pMax,20,-1.0,1.0,20,-10.,10.);
 482       fOutput->Add(fK0sMCPtRapVtx[jj]);
 483     }
 484
 485     fK0sMCPtRapEmbeded   = new TH3F("fK0sMCPtRapEmbeded", "K^{0}_{S} Embeded MC;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.,1.,100,0.,100.);
 486     fOutput->Add(fK0sMCPtRapEmbeded);
 487
 488     for(Int_t jj=0;jj<kNCent;jj++){
 489       snprintf(hNameHist,100, "fK0sMCPtRapVtxEmbeded_Cent_%d",jj);
 490       fK0sMCPtRapVtxEmbeded[jj] = new TH3F(hNameHist, "K^{0}_{S} Embeded MC |VtxZ|;#it{p}_{T} (GeV/#it{c});y;VtxZ",nbins,pMin,pMax,20,-1.0,1.0,20,-10.,10.);
 491       fOutput->Add(fK0sMCPtRapVtxEmbeded[jj]);
 492     }
 493
 494     for(Int_t jj=0;jj<kNCent;jj++){
 495       snprintf(hNameHist,100, "fK0sMCPtPhiEta_Cent_%d",jj);
 496       fK0sMCPtPhiEta[jj]    = new TH3F(hNameHist, "K^{0}_{S} MC;#varphi (rad);#eta;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),20,-1.,1.,nbins,pMin,pMax);
 497       fOutput->Add(fK0sMCPtPhiEta[jj]);
 498     }
 499
 500     // K0s MC-Association:
 501     fK0sAssocPt =
 502       new TH1F("fK0sAssocPt","K^{0}_{S} Assoc: L_{T} vs #it{p}_{T};#it{p}_{T} (GeV/#it{c});Counts",nbins,pMin,pMax);
 503     fOutput->Add(fK0sAssocPt);
 504
 505     fK0sAssocPtArm =
 506       new TH3F("fK0sAssocPtArm","K^{0}_{S} Assoc: #it{p}_{T} vs y vs centrality;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 507     fOutput->Add(fK0sAssocPtArm);
 508
 509     fK0sAssocPtRap    = new TH3F("fK0sAssocPtRap","K^{0}_{S} Assoc;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 510     fOutput->Add(fK0sAssocPtRap);
 511
 512     fK0sAssocPtRapEmbeded    = new TH3F("fK0sAssocPtRapEmbeded","K^{0}_{S} Assoc  - Embeded MC;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 513     fOutput->Add(fK0sAssocPtRapEmbeded);
 514
 515     for(Int_t jj=0;jj<kNCent;jj++){
 516       snprintf(hNameHist,100, "fK0sAssocPtPhiEta_Cent_%d",jj);
 517       fK0sAssocPtPhiEta[jj]    = new TH3F(hNameHist,"K^{0}_{S} Assoc;#varphi;#eta;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),20,-1.0,1.0,nbins,pMin,pMax);
 518       fOutput->Add(fK0sAssocPtPhiEta[jj]);
 519     }
 520
 521
 522     // Histogramas para estudios sistematicos de la eficiencia
 523     Int_t binsEff1[3] = {nbins,nbins,20};          Double_t xminEff1[3] = {0.398,pMin,-1.0};          Double_t xmaxEff1[3] = {0.598,pMax,1.0};             // gral efficiency
 524     Int_t binsEff2[4] = {nbins,nbins,20,10};       Double_t xminEff2[4] = {0.398,pMin,-1.0,-10.};     Double_t xmaxEff2[4] = {0.598,pMax,1.0,10.};         // vtx cut
 525     Int_t binsEff3[4] = {nbins,nbins,20,60};       Double_t xminEff3[4] = {0.398,pMin,-1.0,0.};       Double_t xmaxEff3[4] = {0.598,pMax,1.0,1.2};         // dca between daughters
 526     Int_t binsEff4[4] = {nbins,nbins,20,50};       Double_t xminEff4[4] = {0.398,pMin,-1.0,0.9975};   Double_t xmaxEff4[4] = {0.598,pMax,1.0,1.};          // cpa
 527     Int_t binsEff5[5] = {nbins,nbins,20,99,99};    Double_t xminEff5[5] = {0.398,pMin,-1.0,0.,0.};    Double_t xmaxEff5[5] = {0.598,pMax,1.0,3.3,3.3};     // dca to prim. vtx
 528     Int_t binsEff6[5] = {nbins,nbins,20,170,170};  Double_t xminEff6[5] = {0.398,pMin,-1.0,0.5,0.5};  Double_t xmaxEff6[5] = {0.598,pMax,1.0,170.5,170};   // No. TPC Cls
 529
 530     for(Int_t i=0; i<kNCent; i++){
 531
 532       /// ------- Natural particles
 533       snprintf(hNameHist,100, "fK0sAssocPtMassArm_Cent_%d",i);
 534       fK0sAssocPtMassArm[i]    = new THnSparseD(hNameHist,"K^{0}_{S} Assoc;Mass (GeV/c^{2});#it{p}_{T} (GeV/#it{c});rap;",3,binsEff1,xminEff1,xmaxEff1);
 535       fOutput->Add(fK0sAssocPtMassArm[i]);
 536
 537       snprintf(hNameHist,100, "fK0sAssocMassPtVtx_Cent_%d",i);
 538       fK0sAssocMassPtVtx[i]  = new THnSparseD(hNameHist, "K^{0}_{S}; Mass (GeV/c^{2}); #it{p}_{T}; rap; VtxZ;",4,binsEff2,xminEff2,xmaxEff2);
 539       fOutput->Add(fK0sAssocMassPtVtx[i]);
 540
 541       snprintf(hNameHist,100, "fK0sAssocMassPtDCADaug_Cent_%d",i);
 542       fK0sAssocMassPtDCADaug[i]  = new THnSparseD(hNameHist, "K^{0}_{S}; Mass (GeV/c^{2}); #it{p}_{T}; rap; DCADaug;",4,binsEff3,xminEff3,xmaxEff3);
 543       fOutput->Add(fK0sAssocMassPtDCADaug[i]);
 544
 545       snprintf(hNameHist,100, "fK0sAssocMassPtCPA_Cent_%d",i);
 546       fK0sAssocMassPtCPA[i]  = new THnSparseD(hNameHist, "K^{0}_{S}; Mass (GeV/c^{2}); #it{p}_{T}; rap; CPA;",4,binsEff4,xminEff4,xmaxEff4);
 547       fOutput->Add(fK0sAssocMassPtCPA[i]);
 548
 549       snprintf(hNameHist,100, "fK0sAssocMassPtDCAPV_Cent_%d",i);
 550       fK0sAssocMassPtDCAPV[i]  = new THnSparseD(hNameHist, "K^{0}_{S}; Mass (GeV/c^{2}); #it{p}_{T}; rap; Pos DCA to Prim. Vtx; Neg DCA to Prim. Vtx;",5,binsEff5,xminEff5,xmaxEff5);
 551       fOutput->Add(fK0sAssocMassPtDCAPV[i]);
 552
 553       snprintf(hNameHist,100, "fK0sAssocMassPtDaugNClsTPC_Cent_%d",i);
 554       fK0sAssocMassPtDaugNClsTPC[i]  = new THnSparseD(hNameHist, "K^{0}_{S}; Mass (GeV/c^{2}); #it{p}_{T}; rap; Pos # TPC Cls; Neg # TPC Cls;",5,binsEff6,xminEff6,xmaxEff6);
 555       fOutput->Add(fK0sAssocMassPtDaugNClsTPC[i]);
 556
 557       /// ----- Embeded particles
 558       snprintf(hNameHist,100, "fK0sAssocPtMassArmEmbeded_Cent_%d",i);
 559       fK0sAssocPtMassArmEmbeded[i]    = new THnSparseD(hNameHist,"K^{0}_{S} Assoc Embeded;Mass (GeV/c^{2});#it{p}_{T} (GeV/#it{c});rap;",3,binsEff1,xminEff1,xmaxEff1);
 560       fOutput->Add(fK0sAssocPtMassArmEmbeded[i]);
 561
 562       snprintf(hNameHist,100, "fK0sAssocMassPtVtxEmbeded_Cent_%d",i);
 563       fK0sAssocMassPtVtxEmbeded[i]  = new THnSparseD(hNameHist, "K^{0}_{S} Embeded; Mass (GeV/c^{2}); #it{p}_{T}; rap; VtxZ;",4,binsEff2,xminEff2,xmaxEff2);
 564       fOutput->Add(fK0sAssocMassPtVtxEmbeded[i]);
 565
 566       snprintf(hNameHist,100, "fK0sAssocMassPtDCADaugEmbeded_Cent_%d",i);
 567       fK0sAssocMassPtDCADaugEmbeded[i]  = new THnSparseD(hNameHist, "K^{0}_{S}; Mass (GeV/c^{2}); #it{p}_{T}; rap; DCADaug;",4,binsEff3,xminEff3,xmaxEff3);
 568       fOutput->Add(fK0sAssocMassPtDCADaugEmbeded[i]);
 569
 570       snprintf(hNameHist,100, "fK0sAssocMassPtCPAEmbeded_Cent_%d",i);
 571       fK0sAssocMassPtCPAEmbeded[i]  = new THnSparseD(hNameHist, "K^{0}_{S}; Mass (GeV/c^{2}); #it{p}_{T}; rap; CPA;",4,binsEff4,xminEff4,xmaxEff4);
 572       fOutput->Add(fK0sAssocMassPtCPAEmbeded[i]);
 573
 574       snprintf(hNameHist,100, "fK0sAssocMassPtDCAPVEmbeded_Cent_%d",i);
 575       fK0sAssocMassPtDCAPVEmbeded[i]  = new THnSparseD(hNameHist, "K^{0}_{S}; Mass (GeV/c^{2}); #it{p}_{T}; rap; Pos DCA to Prim. Vtx; Neg DCA to Prim. Vtx;",5,binsEff5,xminEff5,xmaxEff5);
 576       fOutput->Add(fK0sAssocMassPtDCAPVEmbeded[i]);
 577
 578       snprintf(hNameHist,100, "fK0sAssocMassPtDaugNClsTPCEmbeded_Cent_%d",i);
 579       fK0sAssocMassPtDaugNClsTPCEmbeded[i]  = new THnSparseD(hNameHist, "K^{0}_{S}; Mass (GeV/c^{2}); #it{p}_{T}; rap; Pos # TPC Cls; Neg # TPC Cls;",5,binsEff6,xminEff6,xmaxEff6);
 580       fOutput->Add(fK0sAssocMassPtDaugNClsTPCEmbeded[i]);
 581
 582     }
 583
 584     fK0sMCResEta     = new TH3F("fK0sMCResEta","K^{0}_{S} Assoc: #eta resolution; #eta_{MC}-#eta_{Rec};#it{p}_{T} (GeV/#it{c}); centrality",40,-0.1,0.1,nbins,pMin,pMax,100,0.,100.);
 585     fOutput->Add(fK0sMCResEta);
 586
 587     fK0sMCResPhi     = new TH3F("fK0sMCResPhi","K^{0}_{S} Assoc: #varphi resolution; #varphi_{MC}-#varphi_{Rec};#it{p}_{T} (GeV/#it{c}); centrality",40,-0.1,0.1,nbins,pMin,pMax,100,0.,100.);
 588     fOutput->Add(fK0sMCResPhi);
 589
 590     // Lambda MC-true:
 591     fLambdaMCPt = new TH1F("fLambdaMCPt","#Lambda MC;#it{p}_{T} (GeV/#it{c});Counts",nbins,pMin,pMax);
 592     fOutput->Add(fLambdaMCPt);
 593
 594     fLambdaMCPtRap = new TH3F("fLambdaMCPtRap","#Lambda MC;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 595     fOutput->Add(fLambdaMCPtRap);
 596
 597     fLambdaMCPtRap2 = new TH3F("fLambdaMCPtRap2","#Lambda MC;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 598     fOutput->Add(fLambdaMCPtRap2);
 599
 600     for(Int_t jj=0;jj<kNCent;jj++){
 601       snprintf(hNameHist,100, "fLambdaMCPtRapVtx_Cent_%d",jj);
 602       fLambdaMCPtRapVtx[jj] = new TH3F(hNameHist,"#Lambda MC  |VtxZ|<3 cm;#it{p}_{T} (GeV/#it{c});y;zv",nbins,pMin,pMax,20,-1.0,1.0,20,-10.,10.);
 603       fOutput->Add(fLambdaMCPtRapVtx[jj]);
 604     }
 605
 606     fLambdaMCPtRapEmbeded = new TH3F("fLambdaMCPtRapEmbeded","#Lambda Embeded MC;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 607     fOutput->Add(fLambdaMCPtRapEmbeded);
 608
 609     for(Int_t jj=0;jj<kNCent;jj++){
 610       snprintf(hNameHist,100, "fLambdaMCPtRapVtxEmbeded_Cent_%d",jj);
 611       fLambdaMCPtRapVtxEmbeded[jj] = new TH3F(hNameHist,"#Lambda Embeded MC |VtxZ|<3 cm;#it{p}_{T} (GeV/#it{c});y;zv",nbins,pMin,pMax,20,-1.0,1.0,20,-10.,10.);
 612       fOutput->Add(fLambdaMCPtRapVtxEmbeded[jj]);
 613     }
 614
 615     fLambdaMCFromXi  = new TH2F("fLambdaMCFromXi", "#Lambda from Xi MC;#it{p}_{T} (GeV/#it{c});centrality",nbins,pMin,pMax,100,0.,100.);
 616     fOutput->Add(fLambdaMCFromXi);
 617
 618     for(Int_t jj=0;jj<kNCent;jj++){
 619       snprintf(hNameHist,100, "fLambdaMCPtPhiEta_Cent_%d",jj);
 620       fLambdaMCPtPhiEta[jj] = new TH3F(hNameHist,"#Lambda MC;#varphi (rad);#eta;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),20,-1.0,1.0,nbins,pMin,pMax);
 621       fOutput->Add(fLambdaMCPtPhiEta[jj]);
 622     }
 623
 624     // Lambda MC-Association:
 625     fLambdaAssocPt =
 626       new TH1F("fLambdaAssocPt","#Lambda Assoc: L_{T} vs #it{p}_{T};#it{p}_{T} (GeV/#it{c});Counts",nbins,pMin,pMax);
 627     fOutput->Add(fLambdaAssocPt);
 628
 629     fLambdaAssocPtRap = new TH3F("fLambdaAssocPtRap", "#Lambda Assoc;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 630     fOutput->Add(fLambdaAssocPtRap);
 631
 632     fLambdaAssocFromXi  = new TH2F("fLambdaAssocFromXi", "#Lambda from Xi Assoc;#it{p}_{T} (GeV/#it{c});centrality",nbins,pMin,pMax,100,0.,100.);
 633     fOutput->Add(fLambdaAssocFromXi);
 634
 635     for(Int_t jj=0;jj<kNCent;jj++){
 636       snprintf(hNameHist,100, "fLambdaAssocPtPhiEta_Cent_%d",jj);
 637       fLambdaAssocPtPhiEta[jj] = new TH3F(hNameHist, "#Lambda Assoc;#varphi (rad);#eta;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),20,-1.0,1.0,nbins,pMin,pMax);
 638       fOutput->Add(fLambdaAssocPtPhiEta[jj]);
 639     }
 640
 641     // Histogramas para estudios sistematicos de la eficiencia
 642     Int_t binsEff7[3] = {nbins,nbins,20};          Double_t xminEff7[3] = {1.065,pMin,-1.0};           Double_t xmaxEff7[3] = {1.165,pMax,1.0};        // gral efficiency
 643     Int_t binsEff8[4] = {nbins,nbins,20,10};       Double_t xminEff8[4] = {1.065,pMin,-1.0,-10.};      Double_t xmaxEff8[4] = {1.165,pMax,1.0,10.};    // vtx
 644     Int_t binsEff9[4] = {nbins,nbins,20,60};       Double_t xminEff9[4] = {1.065,pMin,-1.0,0.};        Double_t xmaxEff9[4] = {1.165,pMax,1.0,1.2};    // dca between daughters
 645     Int_t binsEff10[4] = {nbins,nbins,20,50};      Double_t xminEff10[4] = {1.065,pMin,-1.0,0.9975};   Double_t xmaxEff10[4] = {1.165,pMax,1.0,1.};    // cpa
 646     Int_t binsEff11[5] = {nbins,nbins,20,99,99};   Double_t xminEff11[5] = {1.065,pMin,-1.0,0.,0.};    Double_t xmaxEff11[5] = {1.165,pMax,1.0,3.3,3.3};   // dca to prim. vtx
 647     Int_t binsEff12[5] = {nbins,nbins,20,170,170}; Double_t xminEff12[5] = {1.065,pMin,-1.0,0.5,0.5};  Double_t xmaxEff12[5] = {1.165,pMax,1.0,170.5,170.5};   // No. TPC Cls
 648
 649     for(Int_t i=0; i<kNCent; i++){
 650
 651       // --------- Natural particles
 652       snprintf(hNameHist,100, "fLambdaAssocMassPtRap_Cent_%d",i);
 653       fLambdaAssocMassPtRap[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap;",3,binsEff7,xminEff7,xmaxEff7);
 654       fOutput->Add(fLambdaAssocMassPtRap[i]);
 655
 656       snprintf(hNameHist,100, "fLambdaAssocMassPtRap2_Cent_%d",i);
 657       fLambdaAssocMassPtRap2[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap;",3,binsEff7,xminEff7,xmaxEff7);
 658       fOutput->Add(fLambdaAssocMassPtRap2[i]);
 659
 660       snprintf(hNameHist,100, "fLambdaAssocMassPtVtx_Cent_%d",i);
 661       fLambdaAssocMassPtVtx[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap; VtxZ;",4,binsEff8,xminEff8,xmaxEff8);
 662       fOutput->Add(fLambdaAssocMassPtVtx[i]);
 663
 664       snprintf(hNameHist,100, "fLambdaAssocMassPtDCADaug_Cent_%d",i);
 665       fLambdaAssocMassPtDCADaug[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap; DCADaug;",4,binsEff9,xminEff9,xmaxEff9);
 666       fOutput->Add(fLambdaAssocMassPtDCADaug[i]);
 667
 668       snprintf(hNameHist,100, "fLambdaAssocMassPtCPA_Cent_%d",i);
 669       fLambdaAssocMassPtCPA[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap; CPA;",4,binsEff10,xminEff10,xmaxEff10);
 670       fOutput->Add(fLambdaAssocMassPtCPA[i]);
 671
 672       snprintf(hNameHist,100, "fLambdaAssocMassPtDCAPV_Cent_%d",i);
 673       fLambdaAssocMassPtDCAPV[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap; Pos DCA to Prim. Vtx; Neg DCA to Prim. Vtx;",5,binsEff11,xminEff11,xmaxEff11);
 674       fOutput->Add(fLambdaAssocMassPtDCAPV[i]);
 675
 676       snprintf(hNameHist,100, "fLambdaAssocMassPtDaugNClsTPC_Cent_%d",i);
 677       fLambdaAssocMassPtDaugNClsTPC[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap; Pos # TPC Cls; Neg # TPC Cls;",5,binsEff12,xminEff12,xmaxEff12);
 678       fOutput->Add(fLambdaAssocMassPtDaugNClsTPC[i]);
 679
 680       // ------------ Embeded particles
 681       snprintf(hNameHist,100, "fLambdaAssocMassPtRapEmbeded_Cent_%d",i);
 682       fLambdaAssocMassPtRapEmbeded[i]  = new THnSparseD(hNameHist, "#Lambda Embeded; Mass (GeV/c^{2}); #it{p}_{T}; rap;",3,binsEff7,xminEff7,xmaxEff7);
 683       fOutput->Add(fLambdaAssocMassPtRapEmbeded[i]);
 684
 685       snprintf(hNameHist,100, "fLambdaAssocMassPtRapEmbeded2_Cent_%d",i);
 686       fLambdaAssocMassPtRapEmbeded2[i]  = new THnSparseD(hNameHist, "#Lambda Embeded; Mass (GeV/c^{2}); #it{p}_{T}; rap;",3,binsEff7,xminEff7,xmaxEff7);
 687       fOutput->Add(fLambdaAssocMassPtRapEmbeded2[i]);
 688
 689       snprintf(hNameHist,100, "fLambdaAssocMassPtVtxEmbeded_Cent_%d",i);
 690       fLambdaAssocMassPtVtxEmbeded[i]  = new THnSparseD(hNameHist, "#Lambda Embeded; Mass (GeV/c^{2}); #it{p}_{T}; rap; VtxZ;",4,binsEff8,xminEff8,xmaxEff8);
 691       fOutput->Add(fLambdaAssocMassPtVtxEmbeded[i]);
 692
 693       snprintf(hNameHist,100, "fLambdaAssocMassPtDCADaugEmbeded_Cent_%d",i);
 694       fLambdaAssocMassPtDCADaugEmbeded[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap; DCADaug;",4,binsEff9,xminEff9,xmaxEff9);
 695       fOutput->Add(fLambdaAssocMassPtDCADaugEmbeded[i]);
 696
 697       snprintf(hNameHist,100, "fLambdaAssocMassPtCPAEmbeded_Cent_%d",i);
 698       fLambdaAssocMassPtCPAEmbeded[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap; CPA;",4,binsEff10,xminEff10,xmaxEff10);
 699       fOutput->Add(fLambdaAssocMassPtCPAEmbeded[i]);
 700
 701       snprintf(hNameHist,100, "fLambdaAssocMassPtDCAPVEmbeded_Cent_%d",i);
 702       fLambdaAssocMassPtDCAPVEmbeded[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap; Pos DCA to Prim. Vtx; Neg DCA to Prim. Vtx;",5,binsEff11,xminEff11,xmaxEff11);
 703       fOutput->Add(fLambdaAssocMassPtDCAPVEmbeded[i]);
 704
 705       snprintf(hNameHist,100, "fLambdaAssocMassPtDaugNClsTPCEmbeded_Cent_%d",i);
 706       fLambdaAssocMassPtDaugNClsTPCEmbeded[i]  = new THnSparseD(hNameHist, "#Lambda; Mass (GeV/c^{2}); #it{p}_{T}; rap;  Pos # TPC Cls; Neg # TPC Cls;",5,binsEff12,xminEff12,xmaxEff12);
 707       fOutput->Add(fLambdaAssocMassPtDaugNClsTPCEmbeded[i]);
 708     }
 709
 710     fLambdaMCResEta     = new TH3F("fLambdaMCResEta","#Lambda Assoc: #eta resolution; #eta_{MC}-#eta_{Rec};#it{p}_{T} (GeV/#it{c}); centrality",40,-0.1,0.1,nbins,pMin,pMax,100,0.,100.);
 711     fOutput->Add(fLambdaMCResEta);
 712
 713     fLambdaMCResPhi     = new TH3F("fLambdaMCResPhi","#Lambda Assoc: #varphi resolution; #varphi_{MC}-#varphi_{Rec};#it{p}_{T} (GeV/#it{c}); centrality",40,-0.1,0.1,nbins,pMin,pMax,100,0.,100.);
 714     fOutput->Add(fLambdaMCResPhi);
 715
 716     // AntiLambda MC-true:
 717     fAntiLambdaMCPt = new TH1F("fAntiLambdaMCPt","#bar{#Lambda} MC;#it{p}_{T} (GeV/#it{c});Counts",nbins,pMin,pMax);
 718     fOutput->Add(fAntiLambdaMCPt);
 719
 720     fAntiLambdaMCPtRap = new TH3F("fAntiLambdaMCPtRap","#bar{#Lambda} MC;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 721     fOutput->Add(fAntiLambdaMCPtRap);
 722
 723     fAntiLambdaMCPtRap2 = new TH3F("fAntiLambdaMCPtRap2","#bar{#Lambda} MC;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 724     fOutput->Add(fAntiLambdaMCPtRap2);
 725
 726     for(Int_t jj=0;jj<kNCent;jj++){
 727       snprintf(hNameHist,100, "fAntiLambdaMCPtRapVtx_Cent_%d",jj);
 728       fAntiLambdaMCPtRapVtx[jj] = new TH3F(hNameHist,"#bar{#Lambda} MC |VtxZ|;#it{p}_{T} (GeV/#it{c});y;zv",nbins,pMin,pMax,20,-1.0,1.0,20,-10.,10.);
 729       fOutput->Add(fAntiLambdaMCPtRapVtx[jj]);
 730     }
 731
 732     fAntiLambdaMCPtRapEmbeded = new TH3F("fAntiLambdaMCPtRapEmbeded","#bar{#Lambda} Embeded MC;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 733     fOutput->Add(fAntiLambdaMCPtRapEmbeded);
 734
 735     for(Int_t jj=0;jj<kNCent;jj++){
 736       snprintf(hNameHist,100, "fAntiLambdaMCPtRapVtxEmbeded_Cent_%d",jj);
 737       fAntiLambdaMCPtRapVtxEmbeded[jj] = new TH3F(hNameHist,"#bar{#Lambda} Embeded MC |VtxZ|;#it{p}_{T} (GeV/#it{c});y;zv",nbins,pMin,pMax,20,-1.0,1.0,20,-10.,10.);
 738       fOutput->Add(fAntiLambdaMCPtRapVtxEmbeded[jj]);
 739     }
 740
 741     fAntiLambdaMCFromXi  = new TH2F("fAntiLambdaMCFromXi", "#bar{#Lambda} from Xi MC;#it{p}_{T} (GeV/#it{c});centrality",nbins,pMin,pMax,100,0.,100.);
 742     fOutput->Add(fAntiLambdaMCFromXi);
 743
 744     for(Int_t jj=0;jj<kNCent;jj++){
 745       snprintf(hNameHist,100, "fAntiLambdaMCPtPhiEta_Cent_%d",jj);
 746       fAntiLambdaMCPtPhiEta[jj] = new TH3F(hNameHist,"#bar{#Lambda} MC;#varphi (rad);#eta;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),20,-1.0,1.0,nbins,pMin,pMax);
 747       fOutput->Add(fAntiLambdaMCPtPhiEta[jj]);
 748     }
 749
 750     // AntiLambda MC-Association:
 751     fAntiLambdaAssocPt =
 752       new TH1F("fAntiLambdaAssocPt","#bar{#Lambda} Assoc: L_{T} vs #it{p}_{T};#it{p}_{T} (GeV/#it{c})",nbins,pMin,pMax);
 753     fOutput->Add(fAntiLambdaAssocPt);
 754
 755     fAntiLambdaAssocPtRap = new TH3F("fAntiLambdaAssocPtRap", "#bar{#Lambda} Assoc;#it{p}_{T} (GeV/#it{c});y;centrality",nbins,pMin,pMax,20,-1.0,1.0,100,0.,100.);
 756     fOutput->Add(fAntiLambdaAssocPtRap);
 757
 758     fAntiLambdaAssocFromXi  = new TH2F("fAntiLambdaAssocFromXi", "#bar{#Lambda} from Xi MC;#it{p}_{T} (GeV/#it{c});centrality",nbins,pMin,pMax,100,0.,100.);
 759     fOutput->Add(fAntiLambdaAssocFromXi);
 760
 761     for(Int_t jj=0;jj<kNCent;jj++){
 762       snprintf(hNameHist,100, "fAntiLambdaAssocPtPhiEta_Cent_%d",jj);
 763       fAntiLambdaAssocPtPhiEta[jj] = new TH3F(hNameHist, "#Lambda Assoc;#varphi (rad);#eta;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),20,-1.0,1.0,nbins,pMin,pMax);
 764       fOutput->Add(fAntiLambdaAssocPtPhiEta[jj]);
 765     }
 766
 767     // Histogramas para estudios sistematicos de la eficiencia
 768     Int_t binsEff13[3] = {nbins,nbins,20};          Double_t xminEff13[3] = {1.065,pMin,-1.0};          Double_t xmaxEff13[3] = {1.165,pMax,1.0};              // gral efficiency
 769     Int_t binsEff14[4] = {nbins,nbins,20,10};       Double_t xminEff14[4] = {1.065,pMin,-1.0,-10.};     Double_t xmaxEff14[4] = {1.165,pMax,1.0,10.};          // vtx
 770     Int_t binsEff15[4] = {nbins,nbins,20,60};       Double_t xminEff15[4] = {1.065,pMin,-1.0,0.};       Double_t xmaxEff15[4] = {1.165,pMax,1.0,1.2};          // dca between daug
 771     Int_t binsEff16[4] = {nbins,nbins,20,50};       Double_t xminEff16[4] = {1.065,pMin,-1.0,0.9975};   Double_t xmaxEff16[4] = {1.165,pMax,1.0,1.};           // cpa
 772     Int_t binsEff17[5] = {nbins,nbins,20,99,99};    Double_t xminEff17[5] = {1.065,pMin,-1.0,0.,0.};    Double_t xmaxEff17[5] = {1.165,pMax,1.0,3.3,3.3};      // dca to prim. vtx
 773     Int_t binsEff18[5] = {nbins,nbins,20,170,170};  Double_t xminEff18[5] = {1.065,pMin,-1.0,0.5,0.5};  Double_t xmaxEff18[5] = {1.165,pMax,1.0,170.5,170.5};  // No. TPC Cls
 774
 775     for(Int_t i=0; i<kNCent; i++){
 776       // --------- Natural particles
 777       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtRap_Cent_%d",i);
 778       fAntiLambdaAssocMassPtRap[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap;",3,binsEff13,xminEff13,xmaxEff13);
 779       fOutput->Add(fAntiLambdaAssocMassPtRap[i]);
 780
 781       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtRap2_Cent_%d",i);
 782       fAntiLambdaAssocMassPtRap2[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap;",3,binsEff13,xminEff13,xmaxEff13);
 783       fOutput->Add(fAntiLambdaAssocMassPtRap2[i]);
 784
 785       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtVtx_Cent_%d",i);
 786       fAntiLambdaAssocMassPtVtx[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap; VtxZ;",4,binsEff14,xminEff14,xmaxEff14);
 787       fOutput->Add(fAntiLambdaAssocMassPtVtx[i]);
 788
 789       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtDCADaug_Cent_%d",i);
 790       fAntiLambdaAssocMassPtDCADaug[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap; DCADaug;",4,binsEff15,xminEff15,xmaxEff15);
 791       fOutput->Add(fAntiLambdaAssocMassPtDCADaug[i]);
 792
 793       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtCPA_Cent_%d",i);
 794       fAntiLambdaAssocMassPtCPA[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap; CPA;",4,binsEff16,xminEff16,xmaxEff16);
 795       fOutput->Add(fAntiLambdaAssocMassPtCPA[i]);
 796
 797       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtDCAPV_Cent_%d",i);
 798       fAntiLambdaAssocMassPtDCAPV[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap; Pos DCA to Prim. Vtx; Neg DCA to Prim. Vtx;",5,binsEff17,xminEff17,xmaxEff17);
 799       fOutput->Add(fAntiLambdaAssocMassPtDCAPV[i]);
 800
 801       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtDaugNClsTPC_Cent_%d",i);
 802       fAntiLambdaAssocMassPtDaugNClsTPC[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap;  Pos # TPC Cls; Neg # TPC Cls;",5,binsEff18,xminEff18,xmaxEff18);
 803       fOutput->Add(fAntiLambdaAssocMassPtDaugNClsTPC[i]);
 804
 805       // ------------ Embeded particles
 806       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtRapEmbeded_Cent_%d",i);
 807       fAntiLambdaAssocMassPtRapEmbeded[i]  = new THnSparseD(hNameHist, "#bar{#Lambda} Embeded; Mass (GeV/c^{2}); #it{p}_{T}; rap;",3,binsEff13,xminEff13,xmaxEff13);
 808       fOutput->Add(fAntiLambdaAssocMassPtRapEmbeded[i]);
 809
 810       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtRapEmbeded2_Cent_%d",i);
 811       fAntiLambdaAssocMassPtRapEmbeded2[i]  = new THnSparseD(hNameHist, "#bar{#Lambda} Embeded; Mass (GeV/c^{2}); #it{p}_{T}; rap;",3,binsEff13,xminEff13,xmaxEff13);
 812       fOutput->Add(fAntiLambdaAssocMassPtRapEmbeded2[i]);
 813
 814       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtVtxEmbeded_Cent_%d",i);
 815       fAntiLambdaAssocMassPtVtxEmbeded[i]  = new THnSparseD(hNameHist, "#bar{#Lambda} Embeded; Mass (GeV/c^{2}); #it{p}_{T}; rap; VtxZ;",4,binsEff14,xminEff14,xmaxEff14);
 816       fOutput->Add(fAntiLambdaAssocMassPtVtxEmbeded[i]);
 817
 818       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtDCADaugEmbeded_Cent_%d",i);
 819       fAntiLambdaAssocMassPtDCADaugEmbeded[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap; DCADaug;",4,binsEff15,xminEff15,xmaxEff15);
 820       fOutput->Add(fAntiLambdaAssocMassPtDCADaugEmbeded[i]);
 821
 822       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtCPAEmbeded_Cent_%d",i);
 823       fAntiLambdaAssocMassPtCPAEmbeded[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap; CPA;",4,binsEff16,xminEff16,xmaxEff16);
 824       fOutput->Add(fAntiLambdaAssocMassPtCPAEmbeded[i]);
 825
 826       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtDCAPVEmbeded_Cent_%d",i);
 827       fAntiLambdaAssocMassPtDCAPVEmbeded[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap; Pos DCA to Prim. Vtx; Neg DCA to Prim. Vtx;",5,binsEff17,xminEff17,xmaxEff17);
 828       fOutput->Add(fAntiLambdaAssocMassPtDCAPVEmbeded[i]);
 829
 830       snprintf(hNameHist,100, "fAntiLambdaAssocMassPtDaugNClsTPCEmbeded_Cent_%d",i);
 831       fAntiLambdaAssocMassPtDaugNClsTPCEmbeded[i]  = new THnSparseD(hNameHist, "#bar{#Lambda}; Mass (GeV/c^{2}); #it{p}_{T}; rap;  Pos # TPC Cls; Neg # TPC Cls;",5,binsEff18,xminEff18,xmaxEff18);
 832       fOutput->Add(fAntiLambdaAssocMassPtDaugNClsTPCEmbeded[i]);
 833     }
 834
 835     fAntiLambdaMCResEta     = new TH3F("fAntiLambdaMCResEta","#bar{#Lambda} Assoc: #eta resolution; #eta_{MC}-#eta_{Rec};#it{p}_{T} (GeV/#it{c}); centrality",40,-0.1,0.1,nbins,pMin,pMax,100,0.,100.);
 836     fOutput->Add(fAntiLambdaMCResEta);
 837
 838     fAntiLambdaMCResPhi     = new TH3F("fAntiLambdaMCResPhi","#bar{#Lambda} Assoc: #varphi resolution; #varphi_{MC}-#varphi_{Rec};#it{p}_{T} (GeV/#it{c}); centrality",40,-0.1,0.1,nbins,pMin,pMax,100,0.,100.);
 839     fOutput->Add(fAntiLambdaMCResPhi);
 840
 841   } //End MC
 842
 843   // ======================================================== //
 844   // ========== Reconstruction information in AOD =========== //
 845   fHistArmenterosPodolanski  =
 846     new TH3F("fHistArmenterosPodolanski","Armenteros-Podolanski phase space;#alpha;p_{t} arm",
 847              100,-1.0,1.0,50,0,0.5,7,-0.5,6.5);
 848   fHistArmenterosPodolanski->GetZaxis()->SetBinLabel(1,"K^{0}_{S} Inv. Mass Peak");
 849   fHistArmenterosPodolanski->GetZaxis()->SetBinLabel(2,"K^{0}_{S} Bckg");
 850   fHistArmenterosPodolanski->GetZaxis()->SetBinLabel(3,"#Lambda Inv. Mass Peak");
 851   fHistArmenterosPodolanski->GetZaxis()->SetBinLabel(4,"#Lambda Bckg");
 852   fHistArmenterosPodolanski->GetZaxis()->SetBinLabel(5,"#bar{#Lambda} Inv. Mass Peak");
 853   fHistArmenterosPodolanski->GetZaxis()->SetBinLabel(6,"#bar{#Lambda} Bckg");
 854   fOutput->Add(fHistArmenterosPodolanski);
 855
 856   fHistArmPodBckg =
 857     new TH3F("fHistArmPodBckg","Armenteros-Podolanski phase space for correlations;#alpha;p_{t} arm",
 858              100,-1.0,1.0,50,0,0.5,6,-0.5,5.5);
 859   fHistArmPodBckg->GetZaxis()->SetBinLabel(1,"K^{0}_{S} SigBck: Trig events");
 860   fHistArmPodBckg->GetZaxis()->SetBinLabel(2,"K^{0}_{S} Bck: Trig events");
 861   fHistArmPodBckg->GetZaxis()->SetBinLabel(3,"#Lambda SigBck: Trig events");
 862   fHistArmPodBckg->GetZaxis()->SetBinLabel(4,"#Lambda Bck: Trig events");
 863   fHistArmPodBckg->GetZaxis()->SetBinLabel(5,"#bar{#Lambda} SigBck: Trig events");
 864   fHistArmPodBckg->GetZaxis()->SetBinLabel(6,"#bar{#Lambda} Bck: Trig events");
 865   fOutput->Add(fHistArmPodBckg);
 866
 867   // ****** K0s ******
 868   fK0sMass =
 869     new TH3F("fK0sMass", "K^{0}_{s}: mass vs #it{p}_{T};Mass (GeV/#it{c}^2);#it{p}_{T} (GeV/#it{c});centrality",nbins,0.398,0.598,nbins,pMin,pMax,100,0.,100.);
 870   fOutput->Add(fK0sMass);
 871
 872   fK0sMassEmbeded =
 873     new TH3F("fK0sMassEmbeded", "K^{0}_{s} Embeded: mass vs #it{p}_{T}",nbins,0.398,0.598,nbins,pMin,pMax,100,0.,100.);
 874   fK0sMassEmbeded->GetXaxis()->SetTitle("Mass (GeV/c^2)");
 875   fK0sMassEmbeded->GetYaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
 876   fK0sMassEmbeded->GetZaxis()->SetTitle("centrality");
 877   fOutput->Add(fK0sMassEmbeded);
 878
 879   fK0sMassPtEta =
 880     new TH3F("fK0sMassPtEta","K^{0}_{s}: Mass vs #it{p}_{T} vs #eta;Mass (GeV/C^{2});#it{p}_{T} (GeV/#it{c});#eta",
 881              nbins,0.398,0.598,nbins,pMin,pMax,20,-1.0,1.0);
 882   fOutput->Add(fK0sMassPtEta);
 883
 884   for(Int_t i=0; i<kNCent; i++){
 885     fK0sMassPtRap[i] =
 886       new TH3F(Form("fK0sMassPtRap_cent_%.0lf_%.0lf",kBinCent[i],kBinCent[i+1]),"K^{0}_{s}: mass vs #it{p}_{T} vs y;Mass (GeV/C^{2});#it{p}_{T} (GeV/#it{c});y",
 887                nbins,0.398,0.598,nbins,pMin,pMax,20,-1.0,1.0);
 888     fOutput->Add(fK0sMassPtRap[i]);
 889   }
 890
 891   fK0sMassPtPhi  =
 892     new TH3F("fK0sMassPtPhi","K^{0}_{s}: mass vs #it{p}_{T} vs #varphi;Mass (GeV/c^2);#it{p}_{T} (GeV/#it{c});#varphi (rad)",
 893              nbins,0.398,0.598,nbins,pMin,pMax,nbinsPhi,0.,2.*TMath::Pi());
 894   fOutput->Add(fK0sMassPtPhi);
 895
 896   // ================== Correlations =================
 897
 898   // ----------------Splitting:
 899   //    Shared TPC clusters status between trigger and daughter tracks
 900   fSharedClsTrigDaug = new TH3F("fSharedClsTrigDaug","Splitting chech with TPC map;",100,0.,10.,100,0.,10.,6,0.,6.);
 901   fOutput->Add(fSharedClsTrigDaug);
 902
 903   //-----
 904   Double_t binsDev[120];
 905   binsDev[0] = 0;
 906
 907   for (Int_t k=0;k<=11;k++)
 908     for (Int_t j=1;j<=10;j++)
 909       binsDev[k*10+j] = j*TMath::Power(10,k);
 910
 911   Int_t binsSplit[4] = {100,100,120,7};   Double_t xminSplit[4] = {pMin,pMin,0,0.}; Double_t xmaxSplit[4] = {pMax,pMax,1e+12,7.0};
 912
 913   // positive daughter
 914   fK0sPosDaugSplCheckCovMat  = new THnSparseD("fK0sPosDaugSplCheckCovMat", "K^{0}_{S} Pos. daughter; #it{p}_{T,V0} (GeV/#it{c}); #it{p}_{Daug} (GeV/#it{c});  X-X'/( #sigma^{2} - #sigma'^{2} ); Variables;",4,binsSplit,xminSplit,xmaxSplit);
 915   fK0sPosDaugSplCheckCovMat->SetBinEdges(2,binsDev);
 916   fOutput->Add(fK0sPosDaugSplCheckCovMat);
 917
 918   // negative daughter
 919   fK0sNegDaugSplCheckCovMat  = new THnSparseD("fK0sNegDaugSplCheckCovMat", "K^{0}_{S} Neg. daughter; #it{p}_{T,V0} (GeV/#it{c}); #it{p}_{Daug} (GeV/#it{c});  X-X'/( #sigma^{2} - #sigma'^{2} ); Variables;",4,binsSplit,xminSplit,xmaxSplit);
 920   fK0sNegDaugSplCheckCovMat->SetBinEdges(2,binsDev);
 921   fOutput->Add(fK0sNegDaugSplCheckCovMat);
 922
 923   //    DCA to prim vertex
 924   fK0sDCADaugToPrimVtx
 925     = new TH3F("fK0sDCADaugToPrimVtx","K^{0}_{S} Bckg: dca daughter vs. p_{T,l};DCA Pos daug (cm);DCA Neg daug (cm);p_{T,l} (GeV/#it{c})",
 926                90,0.,3.3,90,0.,3.3,nbinPtLP,pMin,ptMaxLP);
 927   fOutput->Add(fK0sDCADaugToPrimVtx);
 928
 929   //    Spatial Resoltuion between trigger- and asosciated- particles
 930   fK0sSpatialRes = new TH3F("fK0sSpatialRes","K^{0}_{S}: Spatial resolution;#Delta#varphi (rad);trig-assoc. resolution (cm);dec. length (cm)",
 931                             20,-0.1,0.1,100,0.,10,2*nbins,lMin,lMax);
 932   fOutput->Add(fK0sSpatialRes);
 933
 934   for(Int_t jj=0;jj<kNCent;jj++){
 935     for(Int_t k=0;k<kN1;k++){
 936
 937       // Monte-Carlo level:
 938       if(fIsMC){
 939         snprintf(hNameHist,100, "fK0sdPhidEtaMC_%.2f_%.2f_Cent_%.0f_%.0f",kPtBinV0[k],kPtBinV0[k+1],kBinCent[jj],kBinCent[jj+1]);
 940         fK0sdPhidEtaMC[jj*kN1+k] = new TH3F(hNameHist,"K^{0}_{S} MC: #Delta#varphi vs #Delta#eta vs p_{T,l}",
 941                                             nbinsdPhi,-TMath::PiOver2(),3*TMath::PiOver2(),
 942                                             nbinsdEta,-1.5,1.5,
 943                                             nbinsVtx,-10.,10.);
 944         fK0sdPhidEtaMC[jj*kN1+k]->GetXaxis()->SetTitle("#Delta#varphi (rad)");
 945         fK0sdPhidEtaMC[jj*kN1+k]->GetYaxis()->SetTitle("#Delta#eta");
 946         fK0sdPhidEtaMC[jj*kN1+k]->GetZaxis()->SetTitle("Vertex Z (cm)");
 947         fOutput->Add(fK0sdPhidEtaMC[jj*kN1+k]);
 948       }
 949
 950       // Reconstruction level:
 951       for(Int_t ll=0;ll<kNVtxZ;ll++){
 952         snprintf(hNameHist,100, "fK0sdPhidEtaPtL_%.2f_%.2f_Cent_%.0f_%.0f_%d",kPtBinV0[k],kPtBinV0[k+1],kBinCent[jj],kBinCent[jj+1],ll);
 953         fK0sdPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll] = new TH3F(hNameHist,"K^{0}_{S}: #Delta#varphi vs #Delta#eta vs Inv. Mass",
 954                                              nbinsdPhi,-TMath::PiOver2(),3*TMath::PiOver2(),
 955                                              nbinsdEta,-1.5,1.5,
 956                                              nbins,0.398,0.598);
 957         fK0sdPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]->GetXaxis()->SetTitle("#Delta#varphi (rad)");
 958         fK0sdPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]->GetYaxis()->SetTitle("#Delta#eta");
 959         fK0sdPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]->GetZaxis()->SetTitle("Inv. Mass");
 960         fOutput->Add(fK0sdPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]);
 961       }
 962     }
 963   }
 964
 965   // Correlations (side-band):
 966   fK0sBckgDecLength
 967     = new TH2F("fK0sBckgDecLength","K^{0}_{S} Bckg: c#tau vs. p_{T,l}",
 968                100,0.,15.,nbinPtLP,pMin,ptMaxLP);
 969   fK0sBckgDecLength->GetXaxis()->SetTitle("c#tau (cm)");
 970   fK0sBckgDecLength->GetYaxis()->SetTitle("p_{T,l} (GeV/#it{c})");
 971   fOutput->Add(fK0sBckgDecLength);
 972
 973   fK0sBckgDCADaugToPrimVtx
 974     = new TH3F("fK0sBckgDCADaugToPrimVtx","K^{0}_{S} Bckg: dca daughter vs. p_{T,l}",
 975                90,0.,3.3,90,0.,3.3,nbinPtLP,pMin,ptMaxLP);
 976   fK0sBckgDCADaugToPrimVtx->GetXaxis()->SetTitle("DCA Pos daug (cm)");
 977   fK0sBckgDCADaugToPrimVtx->GetYaxis()->SetTitle("DCA Neg daug (cm)");
 978   fK0sBckgDCADaugToPrimVtx->GetZaxis()->SetTitle("p_{T,l} (GeV/#it{c})");
 979   fOutput->Add(fK0sBckgDCADaugToPrimVtx);
 980
 981   fK0sBckgEtaPhi =
 982     new TH2F("fK0sBckgEtaPhi","K^{0}_{s} Bckg: #varphi vs #eta",
 983              nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.);
 984   fK0sBckgEtaPhi->GetXaxis()->SetTitle("#varphi (rad)");
 985   fK0sBckgEtaPhi->GetYaxis()->SetTitle("#eta");
 986   fOutput->Add(fK0sBckgEtaPhi);
 987
 988   fK0sBckgPhiRadio
 989     = new TH2F("fK0sBckgPhiRadio","K^{0}_{S} Bckg: #varphi vs l_{T}",
 990                nbinsPhi,0.,2.*TMath::Pi(),2*nbins,lMin,lMax);
 991   fK0sBckgPhiRadio->GetXaxis()->SetTitle("#varphi (rad)");
 992   fK0sBckgPhiRadio->GetYaxis()->SetTitle("l_{T} (cm)");
 993   fOutput->Add(fK0sBckgPhiRadio);
 994
 995   fK0sBckgDCANegDaugToPrimVtx
 996     = new TH2F("fK0sBckgDCANegDaugToPrimVtx","K^{0}_{S} Bckg: dca NegDaughter",
 997                7,-0.5,6.5,90,0.,3.3);
 998   fK0sBckgDCANegDaugToPrimVtx->GetXaxis()->SetTitle("MC Production");
 999   fK0sBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(1,"Rec");
1000   fK0sBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(2,"Primary");
1001   fK0sBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(3,"V0's");
1002   fK0sBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(4,"Cascades");
1003   fK0sBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(5,"Gamma conv.");
1004   fK0sBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(6,"Unidentified mother");
1005   fK0sBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(7,"Other");
1006   fK0sBckgDCANegDaugToPrimVtx->GetYaxis()->SetTitle("DCA Neg Daug (cm)");
1007   fOutput->Add(fK0sBckgDCANegDaugToPrimVtx);
1008
1009   fK0sBckgDCAPosDaugToPrimVtx
1010     = new TH2F("fK0sBckgDCAPosDaugToPrimVtx","K^{0}_{S} Bckg: dca PosDaughter",
1011                7,-0.5,6.5,90,0.,3.3);
1012   fK0sBckgDCAPosDaugToPrimVtx->GetXaxis()->SetTitle("MC Production");
1013   fK0sBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(1,"Rec");
1014   fK0sBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(2,"Primary");
1015   fK0sBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(3,"V0's");
1016   fK0sBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(4,"Cascades");
1017   fK0sBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(5,"Gamma conv.");
1018   fK0sBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(6,"Unidentified mother");
1019   fK0sBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(7,"Other");
1020   fK0sBckgDCAPosDaugToPrimVtx->GetYaxis()->SetTitle("DCA Pos Daug (cm)");
1021   fOutput->Add(fK0sBckgDCAPosDaugToPrimVtx);
1022
1023   fV0MassCascade
1024     = new TH2F("fV0MassCascade","Cascade Reconstruction wi V0's candiates;Invariant Mass (GeV/c^{2});Cascade type",650, 1.2, 2.5,12,0.5,12.5);
1025   fOutput->Add(fV0MassCascade);
1026
1027
1028   // ****** Lambda ******
1029   fLambdaMass =
1030     new TH3F("fLambdaMass","Mass vs #it{p}_{T} for \\Lambda",nbins,1.065,1.165,nbins,pMin,pMax,100,0.,100.);
1031   fLambdaMass->GetXaxis()->SetTitle("Mass (GeV/c^2)");
1032   fLambdaMass->GetYaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
1033   fLambdaMass->GetZaxis()->SetTitle("centrality");
1034   fOutput->Add(fLambdaMass);
1035
1036   fLambdaMassEmbeded =
1037     new TH3F("fLambdaMassEmbeded","Mass vs #it{p}_{T} for \\Lambda Embeded",nbins,1.065,1.165,nbins,pMin,pMax,100,0.,100.);
1038   fLambdaMassEmbeded->GetXaxis()->SetTitle("Mass (GeV/c^2)");
1039   fLambdaMassEmbeded->GetYaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
1040   fLambdaMassEmbeded->GetZaxis()->SetTitle("centrality");
1041   fOutput->Add(fLambdaMassEmbeded);
1042
1043   fLambdaMass2 =
1044     new TH3F("fLambdaMass2","Mass vs #it{p}_{T} for \\Lambda",nbins,1.065,1.165,nbins,pMin,pMax,100,0.,100.);
1045   fLambdaMass2->GetXaxis()->SetTitle("Mass (GeV/c^2)");
1046   fLambdaMass2->GetYaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
1047   fLambdaMass2->GetZaxis()->SetTitle("centrality");
1048   fOutput->Add(fLambdaMass2);
1049
1050   fLambdaMass2Embeded =
1051     new TH3F("fLambdaMass2Embeded","Mass vs #it{p}_{T} for \\Lambda Embeded",nbins,1.065,1.165,nbins,pMin,pMax,100,0.,100.);
1052   fLambdaMass2Embeded->GetXaxis()->SetTitle("Mass (GeV/c^2)");
1053   fLambdaMass2Embeded->GetYaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
1054   fLambdaMass2Embeded->GetZaxis()->SetTitle("centrality");
1055   fOutput->Add(fLambdaMass2Embeded);
1056
1057   fLambdaMassPtEta =
1058     new TH3F("fLambdaMassPtEta","\\Lambda: mass vs #it{p}_{T} vs #eta;Mass (GeV/#it{c}^2);#it{p}_{T} (GeV/#it{c});#eta",
1059              nbins,1.065,1.165,nbins,pMin,pMax,20,-1.0,1.0);
1060   fOutput->Add(fLambdaMassPtEta);
1061
1062   for(Int_t i=0; i<kNCent; i++){
1063     fLambdaMassPtRap[i] =
1064       new TH3F(Form("fLambdaMassPtRap_cent_%.0lf_%.0lf",kBinCent[i],kBinCent[i+1]),"\\Lambda: mass vs #it{p}_{T} vs y;Mass (GeV/#it{c}^2);#it{p}_{T} (GeV/#it{c});y",
1065                nbins,1.065,1.165,nbins,pMin,pMax,20,-1.0,1.0);
1066     fOutput->Add(fLambdaMassPtRap[i]);
1067   }
1068
1069   fLambdaMassPtPhi  =
1070     new TH3F("fLambdaMassPtPhi","#Lambda: mass vs #it{p}_{T} vs #varphi;Mass (GeV/#it{c}^2);#it{p}_{T} (GeV/#it{c});#varphi (rad)",
1071              nbins,1.065,1.165,nbins,pMin,pMax,nbinsPhi,0.,2.*TMath::Pi());
1072   fOutput->Add(fLambdaMassPtPhi);
1073
1074   // ================== Correlations =================
1075
1076   // ----------------Splitting:
1077
1078   // positive daughter
1079   fLambdaPosDaugSplCheckCovMat  = new THnSparseD("fLambdaPosDaugSplCheckCovMat", "#Lambda Pos. daughter; #it{p}_{T,V0} (GeV/#it{c}); #it{p}_{Daug} (GeV/#it{c});  X-X'/( #sigma^{2} - #sigma'^{2} ); Variables;",4,binsSplit,xminSplit,xmaxSplit);
1080   fLambdaPosDaugSplCheckCovMat->SetBinEdges(2,binsDev);
1081   fOutput->Add(fLambdaPosDaugSplCheckCovMat);
1082
1083   // negative daughter
1084   fLambdaNegDaugSplCheckCovMat  = new THnSparseD("fLambdaNegDaugSplCheckCovMat", "#Lambda Neg. daughter; #it{p}_{T,V0} (GeV/#it{c}); #it{p}_{Daug} (GeV/#it{c});  X-X'/( #sigma^{2} - #sigma'^{2} ); Variables;",4,binsSplit,xminSplit,xmaxSplit);
1085   fLambdaNegDaugSplCheckCovMat->SetBinEdges(2,binsDev);
1086   fOutput->Add(fLambdaNegDaugSplCheckCovMat);
1087
1088   //    DCA to prim vertex
1089   fLambdaDCADaugToPrimVtx
1090     = new TH3F("fLambdaDCADaugToPrimVtx","#Lambda Bckg: dca daughter vs. p_{T,l}",
1091                90,0.,3.3,90,0.,3.3,nbinPtLP,pMin,ptMaxLP);
1092   fLambdaDCADaugToPrimVtx->GetXaxis()->SetTitle("DCA Pos daug (cm)");
1093   fLambdaDCADaugToPrimVtx->GetYaxis()->SetTitle("DCA Neg daug (cm)");
1094   fLambdaDCADaugToPrimVtx->GetZaxis()->SetTitle("p_{T,l} (GeV/#it{c})");
1095   fOutput->Add(fLambdaDCADaugToPrimVtx);
1096
1097   //    Spatial Resoltuion between trigger- and asosciated- particles
1098   fLambdaSpatialRes = new TH3F("fLambdaSpatialRes","#Lambda: Spatial resolution;#Delta#varphi (rad);trig-assoc. resolution (cm);dec. length (cm)",
1099                                20,-0.1,0.1,100,0.,10,2*nbins,lMin,lMax);
1100   fOutput->Add(fLambdaSpatialRes);
1101
1102
1103   for(Int_t jj=0;jj<kNCent;jj++){
1104     for(Int_t k=0;k<kN1;k++){
1105
1106       // Monte-Carlo level:
1107       if(fIsMC){
1108         snprintf(hNameHist,100, "fLambdadPhidEtaMC_%.2f_%.2f_Cent_%.0f_%.0f",kPtBinV0[k],kPtBinV0[k+1],kBinCent[jj],kBinCent[jj+1]);
1109         fLambdadPhidEtaMC[jj*kN1+k] = new TH3F(hNameHist,"#Lambda MC: #Delta#varphi vs #Delta#eta vs p_{T,l}",
1110                                                nbinsdPhi,-TMath::PiOver2(),3*TMath::PiOver2(),
1111                                                nbinsdEta,-1.5,1.5,
1112                                                nbinsVtx,-10.,10.);
1113         fLambdadPhidEtaMC[jj*kN1+k]->GetXaxis()->SetTitle("#Delta#varphi (rad)");
1114         fLambdadPhidEtaMC[jj*kN1+k]->GetYaxis()->SetTitle("#Delta#eta");
1115         fLambdadPhidEtaMC[jj*kN1+k]->GetZaxis()->SetTitle("Vertex Z (cm)");
1116         fOutput->Add(fLambdadPhidEtaMC[jj*kN1+k]);
1117       }
1118
1119       // Reconstruction level:
1120       for(Int_t ll=0;ll<kNVtxZ;ll++){
1121         snprintf(hNameHist,100, "fLambdadPhidEtaPtL_%.2f_%.2f_Cent_%.0f_%.0f_%d",kPtBinV0[k],kPtBinV0[k+1],kBinCent[jj],kBinCent[jj+1],ll);
1122         fLambdadPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll] = new TH3F(hNameHist,"#Lambda: #Delta#varphi vs #Delta#eta vs p_{T,l}",
1123                                                                       nbinsdPhi,-TMath::PiOver2(),3*TMath::PiOver2(),
1124                                                                       nbinsdEta,-1.5,1.5,
1125                                                                       nbins,1.065,1.165);
1126         fLambdadPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]->GetXaxis()->SetTitle("#Delta#varphi (rad)");
1127         fLambdadPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]->GetYaxis()->SetTitle("#Delta#eta");
1128         fLambdadPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]->GetZaxis()->SetTitle("Inv. Mass");
1129         fOutput->Add(fLambdadPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]);
1130       }
1131     }
1132   }
1133
1134   // Correlations (side-band):
1135   fLambdaBckgDecLength
1136     = new TH2F("fLambdaBckgDecLength","#Lambda Bckg: c#tau vs. p_{T,l}",
1137                100,0.,25.,nbinPtLP,pMin,ptMaxLP);
1138   fLambdaBckgDecLength->GetXaxis()->SetTitle("c#tau (cm)");
1139   fLambdaBckgDecLength->GetYaxis()->SetTitle("p_{T,l} (GeV/#it{c})");
1140   fOutput->Add(fLambdaBckgDecLength);
1141
1142   fLambdaBckgDCADaugToPrimVtx
1143     = new TH3F("fLambdaBckgDCADaugToPrimVtx","#Lambda Bckg: dca daughter vs. p_{T,l}",
1144                90,0.,3.3,90,0.,3.3,nbinPtLP,pMin,ptMaxLP);
1145   fLambdaBckgDCADaugToPrimVtx->GetXaxis()->SetTitle("DCA Pos daug (cm)");
1146   fLambdaBckgDCADaugToPrimVtx->GetYaxis()->SetTitle("DCA Neg daug (cm)");
1147   fLambdaBckgDCADaugToPrimVtx->GetZaxis()->SetTitle("p_{T,l} (GeV/#it{c})");
1148   fOutput->Add(fLambdaBckgDCADaugToPrimVtx);
1149
1150   fLambdaBckgEtaPhi =
1151     new TH2F("fLambdaBckgEtaPhi","#Lambda Bckg: #varphi vs #eta",
1152              nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.);
1153   fLambdaBckgEtaPhi->GetXaxis()->SetTitle("#varphi (rad)");
1154   fLambdaBckgEtaPhi->GetYaxis()->SetTitle("#eta");
1155   fOutput->Add(fLambdaBckgEtaPhi);
1156
1157   fLambdaBckgPhiRadio
1158     = new TH2F("fLambdaBckgPhiRadio","#Lambda Bckg: #varphi vs l_{T}",
1159                nbinsPhi,0.,2.*TMath::Pi(),2*nbins,lMin,lMax);
1160   fLambdaBckgPhiRadio->GetXaxis()->SetTitle("#varphi (rad)");
1161   fLambdaBckgPhiRadio->GetYaxis()->SetTitle("l_{T} (cm)");
1162   fOutput->Add(fLambdaBckgPhiRadio);
1163
1164
1165   fLambdaBckgDCANegDaugToPrimVtx
1166     = new TH2F("fLambdaBckgDCANegDaugToPrimVtx","#Lambda Bckg: dca NegDaughter",
1167                7,-0.5,6.5,90,0.,3.3);
1168   fLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetTitle("MC Production");
1169   fLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(1,"Rec");
1170   fLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(2,"Primary");
1171   fLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(3,"V0's");
1172   fLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(4,"Cascades");
1173   fLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(5,"Gamma conv.");
1174   fLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(6,"Unidentified mother");
1175   fLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(7,"Other");
1176   fLambdaBckgDCANegDaugToPrimVtx->GetYaxis()->SetTitle("DCA Neg Daug (cm)");
1177   fOutput->Add(fLambdaBckgDCANegDaugToPrimVtx);
1178
1179
1180   fLambdaBckgDCAPosDaugToPrimVtx
1181     = new TH2F("fLambdaBckgDCAPosDaugToPrimVtx","#Lambda Bckg: dca PosDaughter",
1182                7,-0.5,6.5,90,0.,3.3);
1183   fLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetTitle("MC Production");
1184   fLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(1,"Rec");
1185   fLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(2,"Primary");
1186   fLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(3,"V0's");
1187   fLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(4,"Cascades");
1188   fLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(5,"Gamma conv.");
1189   fLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(6,"Unidentified mother");
1190   fLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(7,"Other");
1191   fLambdaBckgDCAPosDaugToPrimVtx->GetYaxis()->SetTitle("DCA Pos Daug (cm)");
1192   fOutput->Add(fLambdaBckgDCAPosDaugToPrimVtx);
1193
1194
1195   // ****** AntiLambda ******
1196   fAntiLambdaMass =
1197     new TH3F("fAntiLambdaMass","Mass vs #it{p}_{T} for #bar{#Lambda}",nbins,1.065,1.165,nbins,pMin,pMax,100,0.,100.);
1198   fAntiLambdaMass->GetXaxis()->SetTitle("Mass (GeV/c^2)");
1199   fAntiLambdaMass->GetYaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
1200   fAntiLambdaMass->GetZaxis()->SetTitle("centrality");
1201   fOutput->Add(fAntiLambdaMass);
1202
1203   fAntiLambdaMassEmbeded =
1204     new TH3F("fAntiLambdaMassEmbeded","Mass vs #it{p}_{T} for #bar{#Lambda} Embeded",nbins,1.065,1.165,nbins,pMin,pMax,100,0.,100.);
1205   fAntiLambdaMassEmbeded->GetXaxis()->SetTitle("Mass (GeV/c^2)");
1206   fAntiLambdaMassEmbeded->GetYaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
1207   fAntiLambdaMassEmbeded->GetZaxis()->SetTitle("centrality");
1208   fOutput->Add(fAntiLambdaMassEmbeded);
1209
1210   fAntiLambdaMass2 =
1211     new TH3F("fAntiLambdaMass2","Mass vs #it{p}_{T} for #bar{#Lambda}",nbins,1.065,1.165,nbins,pMin,pMax,100,0.,100.);
1212   fAntiLambdaMass2->GetXaxis()->SetTitle("Mass (GeV/c^2)");
1213   fAntiLambdaMass2->GetYaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
1214   fAntiLambdaMass2->GetZaxis()->SetTitle("centrality");
1215   fOutput->Add(fAntiLambdaMass2);
1216
1217   fAntiLambdaMass2Embeded =
1218     new TH3F("fAntiLambdaMass2Embeded","Mass vs #it{p}_{T} for #bar{#Lambda} Embeded",nbins,1.065,1.165,nbins,pMin,pMax,100,0.,100.);
1219   fAntiLambdaMass2Embeded->GetXaxis()->SetTitle("Mass (GeV/c^2)");
1220   fAntiLambdaMass2Embeded->GetYaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
1221   fAntiLambdaMass2Embeded->GetZaxis()->SetTitle("centrality");
1222   fOutput->Add(fAntiLambdaMass2Embeded);
1223
1224   fAntiLambdaMassPtEta =
1225     new TH3F("fAntiLambdaMassPtEta","#bar{#Lambda}: mass vs #it{p}_{T} vs #eta;Mass (GeV/#it{c}^2);#it{p}_{T} (GeV/#it{c});#eta",nbins,1.065,1.165,nbins,pMin,pMax,20,-1.0,1.0);
1226   fOutput->Add(fAntiLambdaMassPtEta);
1227
1228   for(Int_t i=0; i<kNCent; i++){
1229     fAntiLambdaMassPtRap[i] =
1230       new TH3F(Form("fAntiLambdaMassPtRap_cent_%.0lf_%.0lf",kBinCent[i],kBinCent[i+1]),"#bar{#Lambda}: mass vs #it{p}_{T} vs y;Mass (GeV/#it{c}^2);#it{p}_{T} (GeV/#it{c});y",nbins,1.065,1.165,nbins,pMin,pMax,20,-1.0,1.0);
1231     fOutput->Add(fAntiLambdaMassPtRap[i]);
1232   }
1233
1234   fAntiLambdaMassPtPhi  =
1235     new TH3F("fAntiLambdaMassPtPhi","#bar{#Lambda}: mass vs #it{p}_{T} vs #varphi;Mass (GeV/#it{c}^2);#it{p}_{T} (GeV/#it{c});#varphi (rad)",
1236              nbins,1.065,1.165,nbins,pMin,pMax,nbinsPhi,0.,2.*TMath::Pi());
1237   fOutput->Add(fAntiLambdaMassPtPhi);
1238
1239
1240
1241   // ================== Correlations =================
1242
1243   // ----------------Splitting:
1244
1245   // positive daughter
1246   fAntiLambdaPosDaugSplCheckCovMat  = new THnSparseD("fAntiLambdaPosDaugSplCheckCovMat", "#bar{#Lambda} Pos. daughter; #it{p}_{T,V0} (GeV/#it{c}); #it{p}_{Daug} (GeV/#it{c});  X-X'/( #sigma^{2} - #sigma'^{2} ); Variables;",4,binsSplit,xminSplit,xmaxSplit);
1247   fAntiLambdaPosDaugSplCheckCovMat->SetBinEdges(2,binsDev);
1248   fOutput->Add(fAntiLambdaPosDaugSplCheckCovMat);
1249
1250   // negative daughter
1251   fAntiLambdaNegDaugSplCheckCovMat  = new THnSparseD("fAntiLambdaNegDaugSplCheckCovMat", "#bar{#Lambda} Neg. daughter; #it{p}_{T,V0} (GeV/#it{c}); #it{p}_{Daug} (GeV/#it{c});  X-X'/( #sigma^{2} - #sigma'^{2} ); Variables;",4,binsSplit,xminSplit,xmaxSplit);
1252   fAntiLambdaNegDaugSplCheckCovMat->SetBinEdges(2,binsDev);
1253   fOutput->Add(fAntiLambdaNegDaugSplCheckCovMat);
1254
1255   //    DCA to prim vertex
1256   fAntiLambdaDCADaugToPrimVtx
1257     = new TH3F("fAntiLambdaDCADaugToPrimVtx","#bar{#Lambda} Bckg: dca daughter vs. p_{T,l}",
1258                90,0.,3.3,90,0.,3.3,nbinPtLP,pMin,ptMaxLP);
1259   fAntiLambdaDCADaugToPrimVtx->GetXaxis()->SetTitle("DCA Pos daug (cm)");
1260   fAntiLambdaDCADaugToPrimVtx->GetYaxis()->SetTitle("DCA Neg daug (cm)");
1261   fAntiLambdaDCADaugToPrimVtx->GetZaxis()->SetTitle("p_{T,l} (GeV/#it{c})");
1262   fOutput->Add(fAntiLambdaDCADaugToPrimVtx);
1263
1264   //    Spatial Resoltuion between trigger- and asosciated- particles
1265   fAntiLambdaSpatialRes = new TH3F("fAntiLambdaSpatialRes","#bar{#Lambda}: Spatial resolution;#Delta#varphi (rad);trig-assoc. resolution (cm);dec. length (cm)",
1266                                    20,-0.1,0.1,100,0.,10,2*nbins,lMin,lMax);
1267   fOutput->Add(fAntiLambdaSpatialRes);
1268
1269   for(Int_t jj=0;jj<kNCent;jj++){
1270     for(Int_t k=0;k<kN1;k++){
1271
1272       // Monte-Carlo level:
1273       if(fIsMC){
1274         snprintf(hNameHist,100, "fAntiLambdadPhidEtaMC_%.2f_%.2f_Cent_%.0f_%.0f",kPtBinV0[k],kPtBinV0[k+1],kBinCent[jj],kBinCent[jj+1]);
1275         fAntiLambdadPhidEtaMC[jj*kN1+k] = new TH3F(hNameHist,"#bar{#Lambda} MC: #Delta#varphi vs #Delta#eta vs p_{T,l}",
1276                                                    nbinsdPhi,-TMath::PiOver2(),3*TMath::PiOver2(),
1277                                                    nbinsdEta,-1.5,1.5,
1278                                                    nbinsVtx,-10.,10.);
1279         fAntiLambdadPhidEtaMC[jj*kN1+k]->GetXaxis()->SetTitle("#Delta#varphi (rad)");
1280         fAntiLambdadPhidEtaMC[jj*kN1+k]->GetYaxis()->SetTitle("#Delta#eta");
1281         fAntiLambdadPhidEtaMC[jj*kN1+k]->GetZaxis()->SetTitle("Vertex Z (cm)");
1282         fOutput->Add(fAntiLambdadPhidEtaMC[jj*kN1+k]);
1283       }
1284
1285       // Reconstruction level:
1286       for(Int_t ll=0;ll<kNVtxZ;ll++){
1287         snprintf(hNameHist,100, "fAntiLambdadPhidEtaPtL_%.2f_%.2f_Cent_%.0f_%.0f_%d",kPtBinV0[k],kPtBinV0[k+1],kBinCent[jj],kBinCent[jj+1],ll);
1288         fAntiLambdadPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll] = new TH3F(hNameHist,"#bar{#Lambda}: #Delta#varphi vs #Delta#eta vs p_{T,l}",
1289                                                                           nbinsdPhi,-TMath::PiOver2(),3*TMath::PiOver2(),
1290                                                                           nbinsdEta,-1.5,1.5,
1291                                                                           nbins,1.065,1.165);
1292         fAntiLambdadPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]->GetXaxis()->SetTitle("#Delta#varphi (rad)");
1293         fAntiLambdadPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]->GetYaxis()->SetTitle("#Delta#eta");
1294         fAntiLambdadPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]->GetZaxis()->SetTitle("Inv. Mass");
1295         fOutput->Add(fAntiLambdadPhidEtaPtL[jj*kN1*kNVtxZ  + k*kNVtxZ + ll]);
1296       }
1297     }
1298   }
1299
1300   // Correlations (side-band):
1301   fAntiLambdaBckgDecLength
1302     = new TH2F("fAntiLambdaBckgDecLength","#bar{#Lambda} Bckg: c#tau vs. p_{T,l}",
1303                100,0.,25.,nbinPtLP,pMin,ptMaxLP);
1304   fAntiLambdaBckgDecLength->GetXaxis()->SetTitle("c#tau (cm)");
1305   fAntiLambdaBckgDecLength->GetYaxis()->SetTitle("p_{T,l} (GeV/#it{c})");
1306   fOutput->Add(fAntiLambdaBckgDecLength);
1307
1308   fAntiLambdaBckgDCADaugToPrimVtx
1309     = new TH3F("fAntiLambdaBckgDCADaugToPrimVtx","#bar{#Lambda} Bckg: dca daughter vs. p_{T,l}",
1310                90,0.,3.3,90,0.,3.3,nbinPtLP,pMin,ptMaxLP);
1311   fAntiLambdaBckgDCADaugToPrimVtx->GetXaxis()->SetTitle("DCA Pos daug (cm)");
1312   fAntiLambdaBckgDCADaugToPrimVtx->GetYaxis()->SetTitle("DCA Neg daug (cm)");
1313   fAntiLambdaBckgDCADaugToPrimVtx->GetZaxis()->SetTitle("p_{T,l} (GeV/#it{c})");
1314   fOutput->Add(fAntiLambdaBckgDCADaugToPrimVtx);
1315
1316   fAntiLambdaBckgEtaPhi =
1317     new TH2F("fAntiLambdaBckgEtaPhi","#bar{#Lambda} Bckg: #varphi vs #eta;#varphi (rad);l_{T} (cm)",
1318              nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.);
1319   fOutput->Add(fAntiLambdaBckgEtaPhi);
1320
1321   fAntiLambdaBckgPhiRadio
1322     = new TH2F("fAntiLambdaBckgPhiRadio","#bar{#Lambda} Bckg: #varphi vs l_{T};#varphi (rad);l_{T} (cm)",
1323                nbinsPhi,0.,2.*TMath::Pi(),2*nbins,lMin,lMax);
1324   fOutput->Add(fAntiLambdaBckgPhiRadio);
1325
1326
1327   fAntiLambdaBckgDCANegDaugToPrimVtx
1328     = new TH2F("fAntiLambdaBckgDCANegDaugToPrimVtx","#bar{#Lambda} Bckg: dca NegDaughter",
1329                7,-0.5,6.5,90,0.,3.3);
1330   fAntiLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetTitle("MC Production");
1331   fAntiLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(1,"Rec");
1332   fAntiLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(2,"Primary");
1333   fAntiLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(3,"V0's");
1334   fAntiLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(4,"Cascades");
1335   fAntiLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(5,"Gamma conv.");
1336   fAntiLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(6,"Unidentified mother");
1337   fAntiLambdaBckgDCANegDaugToPrimVtx->GetXaxis()->SetBinLabel(7,"Other");
1338   fAntiLambdaBckgDCANegDaugToPrimVtx->GetYaxis()->SetTitle("DCA Neg Daug (cm)");
1339   fOutput->Add(fAntiLambdaBckgDCANegDaugToPrimVtx);
1340
1341
1342   fAntiLambdaBckgDCAPosDaugToPrimVtx
1343     = new TH2F("fAntiLambdaBckgDCAPosDaugToPrimVtx","#bar{#Lambda} Bckg: dca PosDaughter",
1344                7,-0.5,6.5,90,0.,3.3);
1345   fAntiLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetTitle("MC Production");
1346   fAntiLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(1,"Rec");
1347   fAntiLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(2,"Primary");
1348   fAntiLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(3,"V0's");
1349   fAntiLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(4,"Cascades");
1350   fAntiLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(5,"Gamma conv.");
1351   fAntiLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(6,"Unidentified mother");
1352   fAntiLambdaBckgDCAPosDaugToPrimVtx->GetXaxis()->SetBinLabel(7,"Other");
1353   fAntiLambdaBckgDCAPosDaugToPrimVtx->GetYaxis()->SetTitle("DCA Pos Daug (cm)");
1354   fOutput->Add(fAntiLambdaBckgDCAPosDaugToPrimVtx);
1355
1356
1357   // ============================================================= //
1358
1359   // K0s in ME:
1360   for(Int_t ll=0;ll<kNCent;ll++){
1361     for(Int_t k=0;k<kN1;k++){
1362       for(Int_t j=0;j<kNVtxZ;j++){
1363
1364         snprintf(hNameHist,100,"fK0sdPhidEtaME_%.2f_%.2f_%.0f_%.0f_%d",kPtBinV0[k],kPtBinV0[k+1],kBinCent[ll],kBinCent[ll+1],j);
1365         fK0sdPhidEtaME[ll*kN1*kNVtxZ + k*kNVtxZ + j] = new TH2F(hNameHist,"K^{0}_{S}: #Delta#varphi vs #Delta#eta in ME;#Delta#varphi (rad);#Delta#eta",
1366                                                                 nbinsdPhi,-TMath::PiOver2(),3*TMath::PiOver2(),
1367                                                                 nbinsdEta,-1.5,1.5);
1368         fOutputME->Add(fK0sdPhidEtaME[ll*kN1*kNVtxZ + k*kNVtxZ + j]);
1369       }
1370     }
1371   }
1372
1373   // Lambda in ME:
1374   for(Int_t ll=0;ll<kNCent;ll++){
1375     for(Int_t k=0;k<kN1;k++){
1376       for(Int_t j=0;j<kNVtxZ;j++){
1377
1378         snprintf(hNameHist,100,"fLambdadPhidEtaME_%.2f_%.2f_%.0lf_%.0lf_%d",kPtBinV0[k],kPtBinV0[k+1],kBinCent[ll],kBinCent[ll+1],j);
1379         fLambdadPhidEtaME[ll*kN1*kNVtxZ + k*kNVtxZ + j] = new TH2F(hNameHist,"#Lambda: #Delta#varphi vs #Delta#eta in ME;#Delta#varphi (rad);#Delta#eta",
1380                                                                    nbinsdPhi,-TMath::PiOver2(),3*TMath::PiOver2(),
1381                                                                    nbinsdEta,-1.5,1.5);
1382         fOutputME->Add(fLambdadPhidEtaME[ll*kN1*kNVtxZ + k*kNVtxZ + j]);
1383       }
1384     }
1385   }
1386
1387   // AntiLambda in ME:
1388   for(Int_t ll=0;ll<kNCent;ll++){
1389     for(Int_t k=0;k<kN1;k++){
1390       for(Int_t j=0;j<kNVtxZ;j++){
1391
1392         snprintf(hNameHist,100,"fAntiLambdadPhidEtaME_%.2f_%.2f_%.0lf_%.0lf_%d",kPtBinV0[k],kPtBinV0[k+1],kBinCent[ll],kBinCent[ll+1],j);
1393         fAntiLambdadPhidEtaME[ll*kN1*kNVtxZ + k*kNVtxZ + j] = new TH2F(hNameHist,"#bar{#Lambda}: #Delta#varphi vs #Delta#eta in ME;#Delta#varphi (rad);#Delta#eta",
1394                                                                        nbinsdPhi,-TMath::PiOver2(),3*TMath::PiOver2(),
1395                                                                        nbinsdEta,-1.5,1.5);
1396         fOutputME->Add(fAntiLambdadPhidEtaME[ll*kN1*kNVtxZ + k*kNVtxZ + j]);
1397       }
1398     }
1399   }
1400
1401
1402   // ============================================================= //
1403
1404   if(fDoQA){
1405
1406     // ----------------------------
1407     // Quality Assurance K0s:
1408
1409     // Transverse momentum:
1410     //     --- signal ---
1411     fK0sPtPosDaug =
1412       new TH2F("fK0sPtPosDaug","K^{0}_{S}: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1413     fOutputQA->Add(fK0sPtPosDaug);
1414
1415     fK0sPtNegDaug =
1416       new TH2F("fK0sPtNegDaug","K^{0}_{S}: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1417     fOutputQA->Add(fK0sPtNegDaug);
1418
1419     //     --- background ---
1420     fK0sBckgPtPosDaug =
1421       new TH2F("fK0sBckgPtPosDaug","K^{0}_{S}: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1422     fOutputQA->Add(fK0sBckgPtPosDaug);
1423
1424     fK0sBckgPtNegDaug =
1425       new TH2F("fK0sBckgPtNegDaug","K^{0}_{S}: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1426     fOutputQA->Add(fK0sBckgPtNegDaug);
1427
1428     // Phi Eta
1429     //     --- signal ---
1430     fK0sPhiEtaPosDaug =
1431       new TH3F("fK0sPhiEtaPosDaug","K^{0}_{S}: #varphi vs #eta Pos. Daug.;#varphi;#eta;#it{p}_{T} V0",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1432     fOutputQA->Add(fK0sPhiEtaPosDaug);
1433
1434     fK0sPhiEtaNegDaug  =
1435       new TH3F("fK0sPhiEtaNegDaug","K^{0}_{S}: #varphi vs #eta Neg. Daug.;#varphi;#eta;#it{p}_{T} V0",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1436     fOutputQA->Add(fK0sPhiEtaNegDaug);
1437
1438     //     --- background ---
1439     fK0sBckgPhiEtaPosDaug =
1440       new TH3F("fK0sBckgPhiEtaPosDaug","K^{0}_{S} Bckg: #varphi vs #eta Pos. Daug.;#varphi;#eta;#it{p}_{T} V0",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1441     fOutputQA->Add(fK0sBckgPhiEtaPosDaug);
1442
1443     fK0sBckgPhiEtaNegDaug  =
1444       new TH3F("fK0sBckgPhiEtaNegDaug","K^{0}_{S} Bckg: #varphi vs #eta Neg. Daug.;#varphi;#eta;#it{p}_{T} V0",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1445     fOutputQA->Add(fK0sBckgPhiEtaNegDaug);
1446
1447     // Distance of closest approach:
1448     //     --- signal ---
1449     fK0sDCAPosDaug =
1450       new TH2F("fK0sDCAPosDaug","K^{0}_{S}: dca Pos;dca;#it{p}_{T} V0",66,0.,3.3,nbins,pMin,pMax);
1451     fOutputQA->Add(fK0sDCAPosDaug);
1452
1453     fK0sDCANegDaug =
1454       new TH2F("fK0sDCANegDaug","K^{0}_{S}: dca Neg;dca;#it{p}_{T} V0",66,0.,3.3,nbins,pMin,pMax);
1455     fOutputQA->Add(fK0sDCANegDaug);
1456
1457     //     --- background ---
1458     fK0sBckgDCAPosDaug =
1459       new TH2F("fK0sBckgDCAPosDaug","K^{0}_{S} Bckg: dca Pos;dca;#it{p}_{T} V0",66,0.,3.3,nbins,pMin,pMax);
1460     fOutputQA->Add(fK0sBckgDCAPosDaug);
1461
1462     fK0sBckgDCANegDaug =
1463       new TH2F("fK0sBckgDCANegDaug","K^{0}_{S} Bckg: dca Neg;dca;#it{p}_{T} V0",66,0.,3.3,nbins,pMin,pMax);
1464     fOutputQA->Add(fK0sBckgDCANegDaug);
1465
1466     // Decay vertex reconstruction:
1467     //     --- signal ---
1468     fK0sDecayPos  =
1469       new TH3F("fK0sDecayPos","K^{0}_{S}: Position of Dec. Vtx",200,-100.,100.,200,-100.,100.,nbins,pMin,pMax);
1470     fK0sDecayPos->GetXaxis()->SetTitle("Pos. X");
1471     fK0sDecayPos->GetYaxis()->SetTitle("Pos. Y");
1472     fK0sDecayPos->GetZaxis()->SetTitle("#it{p}_{T} V0");
1473     fOutputQA->Add(fK0sDecayPos);
1474
1475     fK0sDecayVertex  =
1476       new TH2F("fK0sDecayVertex","K^{0}_{S}: decay length",100,0.,100.,nbins,pMin,pMax);
1477     fK0sDecayVertex->GetXaxis()->SetTitle("l_{T}");
1478     fK0sDecayVertex->GetYaxis()->SetTitle("#it{p}_{T} V0");
1479     fOutputQA->Add(fK0sDecayVertex);
1480
1481     //     --- background ---
1482     fK0sBckgDecayPos  =
1483       new TH3F("fK0sBckgDecayPos","K^{0}_{S}: Position of Dec. Vtx",200,-100.,100.,200,-100.,100.,nbins,pMin,pMax);
1484     fK0sBckgDecayPos->GetXaxis()->SetTitle("Pos. X");
1485     fK0sBckgDecayPos->GetYaxis()->SetTitle("Pos. Y");
1486     fK0sBckgDecayPos->GetZaxis()->SetTitle("#it{p}_{T} V0");
1487     fOutputQA->Add(fK0sBckgDecayPos);
1488
1489     fK0sBckgDecayVertex  =
1490       new TH2F("fK0sBckgDecayVertex","K^{0}_{S} Bckg: decay vertex",100,0.,100.,nbins,pMin,pMax);
1491     fK0sBckgDecayVertex->GetXaxis()->SetTitle("l_{T}");
1492     fK0sBckgDecayVertex->GetYaxis()->SetTitle("#it{p}_{T} V0");
1493     fOutputQA->Add(fK0sBckgDecayVertex);
1494
1495     // Cosine of the Pointing Angle:
1496     //     --- signal ---
1497     fK0sCPA  =
1498       new TH2F("fK0sCPA","K^{0}_{S}: cosine of the pointing angle",100,0.98,1.,nbins,pMin,pMax);
1499     fK0sCPA->GetXaxis()->SetTitle("cpa");
1500     fK0sCPA->GetYaxis()->SetTitle("#it{p}_{T} V0");
1501     fOutputQA->Add(fK0sCPA);
1502     //     --- background ---
1503     fK0sBckgCPA  =
1504       new TH2F("fK0sBckgCPA","K^{0}_{S} Bckg: cosine of the pointing angle",100,0.98,1.,nbins,pMin,pMax);
1505     fK0sBckgCPA->GetXaxis()->SetTitle("cpa");
1506     fK0sBckgCPA->GetYaxis()->SetTitle("#it{p}_{T} V0");
1507     fOutputQA->Add(fK0sBckgCPA);
1508
1509     // DCA between daughters:
1510     //     --- signal ---
1511     fK0sDCAV0Daug  =
1512       new TH2F("fK0sDCAV0Daug","K^{0}_{S}: DCA daughters",60,0,1.2,nbins,pMin,pMax);
1513     fK0sDCAV0Daug->GetXaxis()->SetTitle("dca between daughters");
1514     fK0sDCAV0Daug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1515     fOutputQA->Add(fK0sDCAV0Daug);
1516     //     --- background ---
1517     fK0sBckgDCAV0Daug  =
1518       new TH2F("fK0sBckgDCAV0Daug","K^{0}_{S} Bckg: DCA daughters",60,0,1.2,nbins,pMin,pMax);
1519     fK0sBckgDCAV0Daug->GetXaxis()->SetTitle("dca between daughters");
1520     fK0sBckgDCAV0Daug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1521     fOutputQA->Add(fK0sBckgDCAV0Daug);
1522
1523     // Number of TPC clusters:
1524     //     --- signal ---
1525     fK0sNClustersTPC =  // Positive momentum to positive daugther - Negative momentum to negative daugther
1526       new TH3F("fK0sNClustersTPC","K^{0}_{S};#varphi;Num. TPC Clusters; #it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),181,0.5,180.5,nbins,-pMax,pMax);
1527     fOutputQA->Add(fK0sNClustersTPC);
1528     //     --- background ---
1529     fK0sBckgNClustersTPC =  // Positive momentum to positive daugther - Negative momentum to negative daugther
1530       new TH3F("fK0sBckgNClustersTPC","K^{0}_{S} Bckg;#varphi;Num. TPC Clusters; #it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),181,0.5,180.5,nbins,-pMax,pMax);
1531     fOutputQA->Add(fK0sBckgNClustersTPC);
1532
1533     // Number of ITS clusters:
1534     //     --- signal ---
1535     fK0sNClustersITSPos =
1536       new TH3F("fK0sNClustersITSPos","K^{0}_{S}: Pos. Daug;#varphi;Num. ITS Clusters;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1537     fOutputQA->Add(fK0sNClustersITSPos);
1538
1539     fK0sNClustersITSNeg =
1540       new TH3F("fK0sNClustersITSNeg","K^{0}_{S}: Neg. Daug;#varphi;Num. ITS Clusters;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1541     fOutputQA->Add(fK0sNClustersITSNeg);
1542     //     --- background ---
1543     fK0sBckgNClustersITSPos =
1544       new TH3F("fK0sBckgNClustersITSPos","K^{0}_{S} Bckg: Pos. Daug;#varphi;Num. ITS Clusters;;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1545     fOutputQA->Add(fK0sBckgNClustersITSPos);
1546
1547     fK0sBckgNClustersITSNeg =
1548       new TH3F("fK0sBckgNClustersITSNeg","K^{0}_{S} Bckg: Neg. Daug;#varphi;Num. ITS Clusters;;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1549     fOutputQA->Add(fK0sBckgNClustersITSNeg);
1550
1551     // ----------------------------
1552     // Quality Assurance Lambda:
1553
1554     // Transverse momentum:
1555     //     --- signal ---
1556     fLambdaPtPosDaug =
1557       new TH2F("fLambdaPtPosDaug","#Lambda: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1558     fOutputQA->Add(fLambdaPtPosDaug);
1559
1560     fLambdaPtNegDaug =
1561       new TH2F("fLambdaPtNegDaug","#Lambda: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1562     fOutputQA->Add(fLambdaPtNegDaug);
1563
1564     //     --- background ---
1565     fLambdaBckgPtPosDaug =
1566       new TH2F("fLambdaBckgPtPosDaug","#Lambda: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1567     fOutputQA->Add(fLambdaBckgPtPosDaug);
1568
1569     fLambdaBckgPtNegDaug =
1570       new TH2F("fLambdaBckgPtNegDaug","#Lambda: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1571     fOutputQA->Add(fLambdaBckgPtNegDaug);
1572
1573     // Phi Eta
1574     //     --- signal ---
1575     fLambdaPhiEtaPosDaug =
1576       new TH3F("fLambdaPhiEtaPosDaug","#Lambda: #varphi vs #eta Pos. Daug.",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1577     fLambdaPhiEtaPosDaug->GetXaxis()->SetTitle("#varphi");
1578     fLambdaPhiEtaPosDaug->GetYaxis()->SetTitle("#eta");
1579     fLambdaPhiEtaPosDaug->GetZaxis()->SetTitle("#it{p}_{T} V0");
1580     fOutputQA->Add(fLambdaPhiEtaPosDaug);
1581
1582     fLambdaPhiEtaNegDaug  =
1583       new TH3F("fLambdaPhiEtaNegDaug","#Lambda: #varphi vs #eta Neg. Daug.",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1584     fLambdaPhiEtaNegDaug->GetXaxis()->SetTitle("#varphi");
1585     fLambdaPhiEtaNegDaug->GetYaxis()->SetTitle("#eta");
1586     fLambdaPhiEtaNegDaug->GetZaxis()->SetTitle("#it{p}_{T} V0");
1587     fOutputQA->Add(fLambdaPhiEtaNegDaug);
1588
1589     //     --- background ---
1590     fLambdaBckgPhiEtaPosDaug =
1591       new TH3F("fLambdaBckgPhiEtaPosDaug","#Lambda: #varphi vs #eta Pos. Daug.",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1592     fLambdaBckgPhiEtaPosDaug->GetXaxis()->SetTitle("#varphi");
1593     fLambdaBckgPhiEtaPosDaug->GetYaxis()->SetTitle("#eta");
1594     fLambdaBckgPhiEtaPosDaug->GetZaxis()->SetTitle("#it{p}_{T} V0");
1595     fOutputQA->Add(fLambdaBckgPhiEtaPosDaug);
1596
1597     fLambdaBckgPhiEtaNegDaug  =
1598       new TH3F("fLambdaBckgPhiEtaNegDaug","#Lambda: #varphi vs #eta Neg. Daug.",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1599     fLambdaBckgPhiEtaNegDaug->GetXaxis()->SetTitle("#varphi");
1600     fLambdaBckgPhiEtaNegDaug->GetYaxis()->SetTitle("#eta");
1601     fLambdaBckgPhiEtaNegDaug->GetZaxis()->SetTitle("#it{p}_{T} V0");
1602     fOutputQA->Add(fLambdaBckgPhiEtaNegDaug);
1603
1604     // Distance of closest approach
1605     //     --- signal ---
1606     fLambdaDCAPosDaug =
1607       new TH2F("fLambdaDCAPosDaug","#Lambda: dca Pos",66,0.,3.3,nbins,pMin,pMax);
1608     fLambdaDCAPosDaug->GetXaxis()->SetTitle("dca");
1609     fLambdaDCAPosDaug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1610     fOutputQA->Add(fLambdaDCAPosDaug);
1611
1612     fLambdaDCANegDaug =
1613       new TH2F("fLambdaDCANegDaug","#Lambda: dca Neg",66,0.,3.3,nbins,pMin,pMax);
1614     fLambdaDCANegDaug->GetXaxis()->SetTitle("dca");
1615     fLambdaDCANegDaug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1616     fOutputQA->Add(fLambdaDCANegDaug);
1617
1618     //     --- background ---
1619     fLambdaBckgDCAPosDaug =
1620       new TH2F("fLambdaBckgDCAPosDaug","#Lambda Bckg: dca Pos",66,0.,3.3,nbins,pMin,pMax);
1621     fLambdaBckgDCAPosDaug->GetXaxis()->SetTitle("dca");
1622     fLambdaBckgDCAPosDaug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1623     fOutputQA->Add(fLambdaBckgDCAPosDaug);
1624
1625     fLambdaBckgDCANegDaug =
1626       new TH2F("fLambdaBckgDCANegDaug","#Lambda Bckg: dca Neg",66,0.,3.3,nbins,pMin,pMax);
1627     fLambdaBckgDCANegDaug->GetXaxis()->SetTitle("dca");
1628     fLambdaBckgDCANegDaug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1629     fOutputQA->Add(fLambdaBckgDCANegDaug);
1630
1631
1632     // Decay vertex reconstruction
1633     //     --- signal ---
1634     fLambdaDecayPos  =
1635       new TH3F("fLambdaDecayPos","#Lambda: Position of Dec. Vtx",200,-100.,100.,200,-100.,100.,nbins,pMin,pMax);
1636     fLambdaDecayPos->GetXaxis()->SetTitle("Pos. X");
1637     fLambdaDecayPos->GetYaxis()->SetTitle("Pos. Y");
1638     fLambdaDecayPos->GetZaxis()->SetTitle("#it{p}_{T} V0");
1639     fOutputQA->Add(fLambdaDecayPos);
1640
1641     fLambdaDecayVertex  =
1642       new TH2F("fLambdaDecayVertex","#Lambda: decay length",100,0.,100.,nbins,pMin,pMax);
1643     fLambdaDecayVertex->GetXaxis()->SetTitle("l_{T}");
1644     fLambdaDecayVertex->GetYaxis()->SetTitle("#it{p}_{T} V0");
1645     fOutputQA->Add(fLambdaDecayVertex);
1646
1647     //     --- background ---
1648     fLambdaBckgDecayPos  =
1649       new TH3F("fLambdaBckgDecayPos","#Lambda Bckg: Position of Dec. Vtx",200,-100.,100.,200,-100.,100.,nbins,pMin,pMax);
1650     fLambdaBckgDecayPos->GetXaxis()->SetTitle("Pos. X");
1651     fLambdaBckgDecayPos->GetYaxis()->SetTitle("Pos. Y");
1652     fLambdaBckgDecayPos->GetZaxis()->SetTitle("#it{p}_{T} V0");
1653     fOutputQA->Add(fLambdaBckgDecayPos);
1654
1655     fLambdaBckgDecayVertex  =
1656       new TH2F("fLambdaBckgDecayVertex","#Lambda Bckg: decay length",100,0.,100.,nbins,pMin,pMax);
1657     fLambdaBckgDecayVertex->GetXaxis()->SetTitle("l_{T}");
1658     fLambdaBckgDecayVertex->GetYaxis()->SetTitle("#it{p}_{T} V0");
1659     fOutputQA->Add(fLambdaBckgDecayVertex);
1660
1661     // Cosine of the Pointing Angle
1662     //     --- signal ---
1663     fLambdaCPA  =
1664       new TH2F("fLambdaCPA","#Lambda: cosine of the pointing angle",100,0.98,1.,nbins,pMin,pMax);
1665     fLambdaCPA->GetXaxis()->SetTitle("cpa");
1666     fLambdaCPA->GetYaxis()->SetTitle("#it{p}_{T} V0");
1667     fOutputQA->Add(fLambdaCPA);
1668     //     --- background ---
1669     fLambdaBckgCPA  =
1670       new TH2F("fLambdaBckgCPA","#Lambda Bckg: cosine of the pointing angle",100,0.98,1.,nbins,pMin,pMax);
1671     fLambdaBckgCPA->GetXaxis()->SetTitle("cpa");
1672     fLambdaBckgCPA->GetYaxis()->SetTitle("#it{p}_{T} V0");
1673     fOutputQA->Add(fLambdaBckgCPA);
1674
1675     // DCA between daughters
1676     //     --- signal ---
1677     fLambdaDCAV0Daug  =
1678       new TH2F("fLambdaDCAV0Daug","#Lambda: DCA daughters",60,0,1.2,nbins,pMin,pMax);
1679     fLambdaDCAV0Daug->GetXaxis()->SetTitle("dca between daughters");
1680     fLambdaDCAV0Daug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1681     fOutputQA->Add(fLambdaDCAV0Daug);
1682     //     --- background ---
1683     fLambdaBckgDCAV0Daug  =
1684       new TH2F("fLambdaBckgDCAV0Daug","#Lambda Bckg: DCA daughters",60,0,1.2,nbins,pMin,pMax);
1685     fLambdaBckgDCAV0Daug->GetXaxis()->SetTitle("dca between daughters");
1686     fLambdaBckgDCAV0Daug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1687     fOutputQA->Add(fLambdaBckgDCAV0Daug);
1688
1689     // Number of TPC clusters:
1690     //     --- signal ---
1691     fLambdaNClustersTPC =
1692       new TH3F("fLambdaNClustersTPC","#Lambda;#varphi;Num. TPC Clusters;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),181,0.5,180.5,nbins,-pMax,pMax);
1693     fOutputQA->Add(fLambdaNClustersTPC);
1694     //     --- background ---
1695     fLambdaBckgNClustersTPC =
1696       new TH3F("fLambdaBckgNClustersTPC","#Lambda Bckg;#varphi;Num. TPC Clusters;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),181,0.5,180.5,nbins,-pMax,pMax);
1697     fOutputQA->Add(fLambdaBckgNClustersTPC);
1698
1699     // Number of ITS clusters:
1700     //     --- signal ---
1701     fLambdaNClustersITSPos =
1702       new TH3F("fLambdaNClustersITSPos","#Lambda: Pos. Daug;#varphi;Num. ITS Clusters;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1703     fOutputQA->Add(fLambdaNClustersITSPos);
1704
1705     fLambdaNClustersITSNeg =
1706       new TH3F("fLambdaNClustersITSNeg","#Lambda: Neg. Daug;#varphi;Num. ITS Clusters;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1707     fOutputQA->Add(fLambdaNClustersITSNeg);
1708     //     --- background ---
1709     fLambdaBckgNClustersITSPos =
1710       new TH3F("fLambdaBckgNClustersITSPos","#Lambda Bckg: Pos. Daug;#varphi;Num. ITS Clusters;;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1711     fOutputQA->Add(fLambdaBckgNClustersITSPos);
1712
1713     fLambdaBckgNClustersITSNeg =
1714       new TH3F("fLambdaBckgNClustersITSNeg","#Lambda Bckg: Neg. Daug;#varphi;Num. ITS Clusters;;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1715     fOutputQA->Add(fLambdaBckgNClustersITSNeg);
1716
1717
1718     // ----------------------------
1719     // Quality Assurance AntiLambda:
1720     // Transverse momentum:
1721     //     --- signal ---
1722     fAntiLambdaPtPosDaug =
1723       new TH2F("fAntiLambdaPtPosDaug","#bar{#Lambda}: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1724     fOutputQA->Add(fAntiLambdaPtPosDaug);
1725
1726     fAntiLambdaPtNegDaug =
1727       new TH2F("fAntiLambdaPtNegDaug","#bar{#Lambda}: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1728     fOutputQA->Add(fAntiLambdaPtNegDaug);
1729
1730     //     --- background ---
1731     fAntiLambdaBckgPtPosDaug =
1732       new TH2F("fAntiLambdaBckgPtPosDaug","#bar{#Lambda}: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1733     fOutputQA->Add(fAntiLambdaBckgPtPosDaug);
1734
1735     fAntiLambdaBckgPtNegDaug =
1736       new TH2F("fAntiLambdaBckgPtNegDaug","#bar{#Lambda}: #it{p}_{T};#it{p}_{T};#it{p}_{T} V0",nbins,pMin,pMax,nbins,pMin,pMax);
1737     fOutputQA->Add(fAntiLambdaBckgPtNegDaug);
1738
1739     // Phi Eta
1740     //     --- signal ---
1741     fAntiLambdaPhiEtaPosDaug =
1742       new TH3F("fAntiLambdaPhiEtaPosDaug","#bar{#Lambda}: #varphi vs #eta Pos. Daug.",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1743     fAntiLambdaPhiEtaPosDaug->GetXaxis()->SetTitle("#varphi");
1744     fAntiLambdaPhiEtaPosDaug->GetYaxis()->SetTitle("#eta");
1745     fAntiLambdaPhiEtaPosDaug->GetZaxis()->SetTitle("#it{p}_{T} V0");
1746     fOutputQA->Add(fAntiLambdaPhiEtaPosDaug);
1747
1748     fAntiLambdaPhiEtaNegDaug  =
1749       new TH3F("fAntiLambdaPhiEtaNegDaug","#bar{#Lambda}: #varphi vs #eta Neg. Daug.",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1750     fAntiLambdaPhiEtaNegDaug->GetXaxis()->SetTitle("#varphi");
1751     fAntiLambdaPhiEtaNegDaug->GetYaxis()->SetTitle("#eta");
1752     fAntiLambdaPhiEtaNegDaug->GetZaxis()->SetTitle("#it{p}_{T} V0");
1753     fOutputQA->Add(fAntiLambdaPhiEtaNegDaug);
1754
1755     //     --- background ---
1756     fAntiLambdaBckgPhiEtaPosDaug =
1757       new TH3F("fAntiLambdaBckgPhiEtaPosDaug","#bar{#Lambda}: #varphi vs #eta Pos. Daug.",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1758     fAntiLambdaBckgPhiEtaPosDaug->GetXaxis()->SetTitle("#varphi");
1759     fAntiLambdaBckgPhiEtaPosDaug->GetYaxis()->SetTitle("#eta");
1760     fAntiLambdaBckgPhiEtaPosDaug->GetZaxis()->SetTitle("#it{p}_{T} V0");
1761     fOutputQA->Add(fAntiLambdaBckgPhiEtaPosDaug);
1762
1763     fAntiLambdaBckgPhiEtaNegDaug  =
1764       new TH3F("fAntiLambdaBckgPhiEtaNegDaug","#bar{#Lambda}: #varphi vs #eta Neg. Daug.",nbinsPhi,0.,2.*TMath::Pi(),100,-1.,1.,nbins,pMin,pMax);
1765     fAntiLambdaBckgPhiEtaNegDaug->GetXaxis()->SetTitle("#varphi");
1766     fAntiLambdaBckgPhiEtaNegDaug->GetYaxis()->SetTitle("#eta");
1767     fAntiLambdaBckgPhiEtaNegDaug->GetZaxis()->SetTitle("#it{p}_{T} V0");
1768     fOutputQA->Add(fAntiLambdaBckgPhiEtaNegDaug);
1769
1770     // Distance of closest approach
1771     //     --- signal ---
1772     fAntiLambdaDCAPosDaug =
1773       new TH2F("fAntiLambdaDCAPosDaug","#bar{#Lambda}: dca Pos",66,0.,3.3,nbins,pMin,pMax);
1774     fAntiLambdaDCAPosDaug->GetXaxis()->SetTitle("dca");
1775     fAntiLambdaDCAPosDaug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1776     fOutputQA->Add(fAntiLambdaDCAPosDaug);
1777
1778     fAntiLambdaDCANegDaug =
1779       new TH2F("fAntiLambdaDCANegDaug","#bar{#Lambda}: dca Neg",66,0.,3.3,nbins,pMin,pMax);
1780     fAntiLambdaDCANegDaug->GetXaxis()->SetTitle("dca");
1781     fAntiLambdaDCANegDaug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1782     fOutputQA->Add(fAntiLambdaDCANegDaug);
1783
1784     //     --- background ---
1785     fAntiLambdaBckgDCAPosDaug =
1786       new TH2F("fAntiLambdaBckgDCAPosDaug","#bar{#Lambda} Bckg: dca Pos",66,0.,3.3,nbins,pMin,pMax);
1787     fAntiLambdaBckgDCAPosDaug->GetXaxis()->SetTitle("dca");
1788     fAntiLambdaBckgDCAPosDaug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1789     fOutputQA->Add(fAntiLambdaBckgDCAPosDaug);
1790
1791     fAntiLambdaBckgDCANegDaug =
1792       new TH2F("fAntiLambdaBckgDCANegDaug","#bar{#Lambda} Bckg: dca Neg",66,0.,3.3,nbins,pMin,pMax);
1793     fAntiLambdaBckgDCANegDaug->GetXaxis()->SetTitle("dca");
1794     fAntiLambdaBckgDCANegDaug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1795     fOutputQA->Add(fAntiLambdaBckgDCANegDaug);
1796
1797     // Decay vertex reconstruction
1798     //     --- signal ---
1799     fAntiLambdaDecayPos  =
1800       new TH3F("fAntiLambdaDecayPos","#bar{#Lambda}: Position of Dec. Vtx",200,-100.,100.,200,-100.,100.,nbins,pMin,pMax);
1801     fAntiLambdaDecayPos->GetXaxis()->SetTitle("Pos. X");
1802     fAntiLambdaDecayPos->GetYaxis()->SetTitle("Pos. Y");
1803     fAntiLambdaDecayPos->GetZaxis()->SetTitle("#it{p}_{T} V0");
1804     fOutputQA->Add(fAntiLambdaDecayPos);
1805
1806     fAntiLambdaDecayVertex  =
1807       new TH2F("fAntiLambdaDecayVertex","#bar{#Lambda}: decay length",100,0.,100.,nbins,pMin,pMax);
1808     fAntiLambdaDecayVertex->GetXaxis()->SetTitle("l_{T}");
1809     fAntiLambdaDecayVertex->GetYaxis()->SetTitle("#it{p}_{T} V0");
1810     fOutputQA->Add(fAntiLambdaDecayVertex);
1811
1812     //     --- background ---
1813     fAntiLambdaBckgDecayPos  =
1814       new TH3F("fAntiLambdaBckgDecayPos","#bar{#Lambda} Bckg: Position of Dec. Vtx",200,-100.,100.,200,-100.,100.,nbins,pMin,pMax);
1815     fAntiLambdaBckgDecayPos->GetXaxis()->SetTitle("Pos. X");
1816     fAntiLambdaBckgDecayPos->GetYaxis()->SetTitle("Pos. Y");
1817     fAntiLambdaBckgDecayPos->GetZaxis()->SetTitle("#it{p}_{T} V0");
1818     fOutputQA->Add(fAntiLambdaBckgDecayPos);
1819
1820     fAntiLambdaBckgDecayVertex  =
1821       new TH2F("fAntiLambdaBckgDecayVertex","#bar{#Lambda} Bckg: decay length",100,0.,100.,nbins,pMin,pMax);
1822     fAntiLambdaBckgDecayVertex->GetXaxis()->SetTitle("l_{T}");
1823     fAntiLambdaBckgDecayVertex->GetYaxis()->SetTitle("#it{p}_{T} V0");
1824     fOutputQA->Add(fAntiLambdaBckgDecayVertex);
1825
1826     // Cosine of the Pointing Angle
1827     //     --- signal ---
1828     fAntiLambdaCPA  =
1829       new TH2F("fAntiLambdaCPA","#bar{#Lambda}: cosine of the pointing angle",100,0.98,1.,nbins,pMin,pMax);
1830     fAntiLambdaCPA->GetXaxis()->SetTitle("cpa");
1831     fAntiLambdaCPA->GetYaxis()->SetTitle("#it{p}_{T} V0");
1832     fOutputQA->Add(fAntiLambdaCPA);
1833     //     --- background ---
1834     fAntiLambdaBckgCPA  =
1835       new TH2F("fAntiLambdaBckgCPA","#bar{#Lambda} Bckg: cosine of the pointing angle",100,0.98,1.,nbins,pMin,pMax);
1836     fAntiLambdaBckgCPA->GetXaxis()->SetTitle("cpa");
1837     fAntiLambdaBckgCPA->GetYaxis()->SetTitle("#it{p}_{T} V0");
1838     fOutputQA->Add(fAntiLambdaBckgCPA);
1839
1840     // DCA between daughters
1841     //     --- signal ---
1842     fAntiLambdaDCAV0Daug  =
1843       new TH2F("fAntiLambdaDCAV0Daug","#bar{#Lambda}: DCA daughters",60,0,1.2,nbins,pMin,pMax);
1844     fAntiLambdaDCAV0Daug->GetXaxis()->SetTitle("dca between daughters");
1845     fAntiLambdaDCAV0Daug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1846     fOutputQA->Add(fAntiLambdaDCAV0Daug);
1847     //     --- background ---
1848     fAntiLambdaBckgDCAV0Daug  =
1849       new TH2F("fAntiLambdaBckgDCAV0Daug","#bar{#Lambda} Bckg: DCA daughters",60,0,1.2,nbins,pMin,pMax);
1850     fAntiLambdaBckgDCAV0Daug->GetXaxis()->SetTitle("dca between daughters");
1851     fAntiLambdaBckgDCAV0Daug->GetYaxis()->SetTitle("#it{p}_{T} V0");
1852     fOutputQA->Add(fAntiLambdaBckgDCAV0Daug);
1853
1854     // Number of TPC clusters:
1855     //     --- signal ---
1856     fAntiLambdaNClustersTPC =
1857       new TH3F("fAntiLambdaNClustersTPC","#bar{#Lambda};#varphi;Num. TPC Clusters;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),181,0.5,180.5,nbins,-pMax,pMax);
1858     fOutputQA->Add(fAntiLambdaNClustersTPC);
1859     //     --- background ---
1860     fAntiLambdaBckgNClustersTPC =
1861       new TH3F("fAntiLambdaBckgNClustersTPC","#bar{#Lambda} Bckg;#varphi;Num. TPC Clusters;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),181,0.5,180.5,nbins,-pMax,pMax);
1862     fOutputQA->Add(fAntiLambdaBckgNClustersTPC);
1863
1864     // Number of ITS clusters:
1865     //     --- signal ---
1866     fAntiLambdaNClustersITSPos =
1867       new TH3F("fAntiLambdaNClustersITSPos","#bar{#Lambda}: Pos. Daug;#varphi;Num. ITS Clusters;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1868     fOutputQA->Add(fAntiLambdaNClustersITSPos);
1869
1870     fAntiLambdaNClustersITSNeg =
1871       new TH3F("fAntiLambdaNClustersITSNeg","#bar{#Lambda}: Neg. Daug;#varphi;Num. ITS Clusters;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1872     fOutputQA->Add(fAntiLambdaNClustersITSNeg);
1873     //     --- background ---
1874     fAntiLambdaBckgNClustersITSPos =
1875       new TH3F("fAntiLambdaBckgNClustersITSPos","#bar{#Lambda} Bckg: Pos. Daug;#varphi;Num. ITS Clusters;;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1876     fOutputQA->Add(fAntiLambdaBckgNClustersITSPos);
1877
1878     fAntiLambdaBckgNClustersITSNeg =
1879       new TH3F("fAntiLambdaBckgNClustersITSNeg","#bar{#Lambda} Bckg: Neg. Daug;#varphi;Num. ITS Clusters;;#it{p}_{T} (GeV/#it{c})",nbinsPhi,0.,2.*TMath::Pi(),7,-0.5,6.5,nbins,pMin,pMax);
1880     fOutputQA->Add(fAntiLambdaBckgNClustersITSNeg);
1881
1882   }
1883
1884   // ============================================================= //
1885
1886   PostData(1, fOutput);
1887   PostData(2, fOutputME);
1888   PostData(3, fOutputQA);
1889
1890 }
1891
1892 //___________________________________________________________________________________________
1893
1894 static Int_t VtxBin(Double_t vtx)
1895 {
1896   // Bin in vertez position Z
1897   Int_t bin = -1;
1898   for(Int_t i=0;i<kNVtxZ;i++)
1899     if ( (vtx>=kBinVtxZ[i]) && (vtx<kBinVtxZ[i+1]) )
1900       bin = i;
1901
1902   return bin;
1903
1904 }
1905
1906 //___________________________________________________________________________________________
1907
1908 static Int_t PtBin(Double_t pt)
1909 {
1910   // Bin in pt
1911   Int_t bin = -1;
1912   for(Int_t i=0;i<kN1;i++)
1913     if ( (pt>=kPtBinV0[i]) && (pt<kPtBinV0[i+1]) )
1914       bin = i;
1915
1916   return bin;
1917
1918 }
1919
1920 //___________________________________________________________________________________________
1921
1922 static Int_t CentBin(Double_t cent)
1923 {
1924   // Bin in pt
1925   Int_t bin = -1;
1926   for(Int_t i=0;i<kNCent;i++)
1927     if ( (cent>=kBinCent[i]) && (cent<kBinCent[i+1]) )
1928       bin = i;
1929
1930   return bin;
1931
1932 }
1933
1934 //___________________________________________________________________________________________
1935
1936 Bool_t AliAnalysisTaskLambdaOverK0sJets::AcceptTrack(AliAODTrack *t)
1937 {
1938   // Track criteria for primaries particles
1939
1940   // TPC only tracks
1941   if (TMath::Abs(t->Eta())>0.8 )  return kFALSE;
1942   if (!(t->TestFilterMask(1<<7))) return kFALSE;
1943
1944   Float_t nCrossedRowsTPC = t->GetTPCClusterInfo(2,1);
1945   if (nCrossedRowsTPC < 70) return kFALSE;
1946
1947
1948   // Hybrid tracks
1949   //if( !(t->TestFilterBit(272)) )  return kFALSE;
1950   //if(!t->IsHybridGlobalConstrainedGlobal()) return kFALSE;
1951
1952   // Point in the SPD
1953   Int_t SPDHits = t->HasPointOnITSLayer(0) + t->HasPointOnITSLayer(1);
1954   if( SPDHits )
1955     fTriggerWiSPDHit->Fill(1.5);
1956
1957   return kTRUE;
1958 }
1959
1960 //___________________________________________________________________________________________
1961
1962 Bool_t AliAnalysisTaskLambdaOverK0sJets::AcceptTrackV0(const AliAODTrack *t)
1963 {
1964   // Track criteria for daughter particles of V0 candidate
1965   if (!t->IsOn(AliAODTrack::kTPCrefit)) return kFALSE;
1966   Float_t nCrossedRowsTPC = t->GetTPCClusterInfo(2,1);
1967   if (nCrossedRowsTPC<fDaugNClsTPC) return kFALSE;
1968
1969   return kTRUE;
1970 }
1971
1972 //___________________________________________________________________________________________
1973
1974 Bool_t AliAnalysisTaskLambdaOverK0sJets::AcceptV0(AliAODVertex *vtx, const AliAODv0 *v1)
1975 {
1976   // Selection for accepting V0 candidates
1977
1978   if (v1->GetOnFlyStatus()) return kFALSE;
1979
1980   //if (v1->Pt() < pMin) return kFALSE; ***
1981
1982   const AliAODTrack *ntrack1=(AliAODTrack *)v1->GetDaughter(1);
1983   const AliAODTrack *ptrack1=(AliAODTrack *)v1->GetDaughter(0);
1984
1985   if( !ntrack1 || !ptrack1 ) return kFALSE;
1986   if( !AcceptTrackV0(ntrack1) ) return kFALSE;
1987   if( !AcceptTrackV0(ptrack1) ) return kFALSE;
1988
1989   if( ntrack1->Charge() == ptrack1->Charge())
1990     return kFALSE;
1991
1992   // Daughters: pseudo-rapidity cut
1993   if ( TMath::Abs(ntrack1->Eta()) > fMaxEtaDaughter  ||
1994        TMath::Abs(ptrack1->Eta()) > fMaxEtaDaughter  )
1995     return kFALSE;
1996
1997   // Daughters: transverse momentum cut
1998   if ( ( ntrack1->Pt() < fMinPtDaughter ) ||
1999        ( ptrack1->Pt() < fMinPtDaughter )  )
2000     return kFALSE;
2001
2002   // Daughters: Impact parameter of daughter to prim vtx
2003   Float_t xy = v1->DcaNegToPrimVertex();
2004   if (TMath::Abs(xy)<fDCAToPrimVtx) return kFALSE;
2005   xy = v1->DcaPosToPrimVertex();
2006   if (TMath::Abs(xy)<fDCAToPrimVtx) return kFALSE;
2007
2008   // Daughters: DCA
2009   Float_t dca = v1->DcaV0Daughters();
2010   if (dca>fMaxDCADaughter) return kFALSE;
2011
2012   // V0: Cosine of the pointing angle
2013   Float_t cpa=v1->CosPointingAngle(vtx);
2014   if (cpa<fMinCPA) return kFALSE;
2015
2016   // V0: Fiducial volume
2017   Double_t xyz[3]; v1->GetSecondaryVtx(xyz);
2018   Float_t r2=xyz[0]*xyz[0] + xyz[1]*xyz[1];
2019   if (r2<5.*5.) return kFALSE;
2020   if (r2>lMax*lMax) return kFALSE;
2021
2022   return kTRUE;
2023 }
2024
2025 //___________________________________________________________________________________________
2026
2027 static Float_t dPHI(Float_t phi1, Float_t phi2)
2028 {
2029   // Calculate the phi difference between two tracks
2030   Float_t deltaPhi = phi1 - phi2;
2031
2032   if (deltaPhi<-TMath::PiOver2())    deltaPhi = deltaPhi + 2*(TMath::Pi());
2033   if (deltaPhi>(3*TMath::PiOver2()))  deltaPhi = deltaPhi - 2*(TMath::Pi());
2034   return deltaPhi;
2035 }
2036
2037 //___________________________________________________________________________________________
2038
2039 static Float_t MyRapidity(Float_t rE, Float_t rPz)
2040 {
2041   // Local method for rapidity
2042   return 0.5*TMath::Log((rE+rPz)/(rE-rPz+1.e-13));
2043 }
2044
2045 //___________________________________________________________________________________________
2046
2047 static Int_t SameTrack(AliAODTrack *trk, const AliAODTrack *daugTrk)
2048 {
2049   // Local method to compaire the momentum between two tracks
2050
2051   //double const kEpsilon = 0.01;
2052   Int_t    isSamePt = 0;
2053
2054   /*
2055     Float_t p[3];     trk->GetPxPyPz(p);
2056     Float_t pNegTrk[3]; nTrk->GetPxPyPz(pNegTrk);
2057     Float_t pPosTrk[3]; pTrk->GetPxPyPz(pPosTrk);
2058
2059     if( (  fabs(p[0]-pNegTrk[0])<kEpsilon &&
2060     fabs(p[1]-pNegTrk[1])<kEpsilon &&
2061     fabs(p[2]-pNegTrk[2])<kEpsilon )
2062     isSamePt = 1;
2063   */
2064
2065   if(  (TMath::Abs(daugTrk->GetID())+1)==(TMath::Abs(trk->GetID()))  )
2066     isSamePt = 1;
2067
2068
2069   return isSamePt;
2070
2071 }
2072
2073 //___________________________________________________________________________________________
2074
2075 static Float_t SpatialResolution(Float_t p1x,Float_t p1y,Float_t p2x,Float_t p2y,Float_t dist)
2076 {
2077   // Obtains the spacial resolution between trigger and V0
2078   // within a distance in (deltaPhi,deltaEta) < 0.1
2079
2080   Float_t res = -100.;
2081
2082   res = TMath::Sqrt( p1x*p1x + p1y*p1y )*TMath::Sqrt( p2x*p2x + p2y*p2y );
2083   res = (p1x*p2x + p1y*p2y)/res;
2084
2085   res = TMath::ACos(res);
2086
2087   return res = TMath::Sin(res)*dist;
2088
2089 }
2090
2091 //___________________________________________________________________________________________
2092
2093 Bool_t AliAnalysisTaskLambdaOverK0sJets::GoodTPCSharedMap(const AliAODTrack *track){
2094   // Rejects tracks with shared clusters after filling a control histogram
2095   // This overload is used for primaries
2096
2097   // Get the shared maps
2098   const TBits sharedMap = track->GetTPCSharedMap();
2099   // Fill a control histogram
2100   //fPriHistShare->Fill(sharedMap.CountBits());
2101   // Reject shared clusters
2102   if((sharedMap.CountBits()) >= 1){
2103     // Bad track, has too many shared clusters!
2104     return kFALSE;
2105   }
2106   return kTRUE;
2107 }
2108
2109 //___________________________________________________________________________________________
2110
2111 Bool_t AliAnalysisTaskLambdaOverK0sJets::GoodTPCSharedMap(AliAODTrack *track){
2112   // Rejects tracks with shared clusters after filling a control histogram
2113   // This overload is used for primaries
2114
2115   // Get the shared maps
2116   const TBits sharedMap = track->GetTPCSharedMap();
2117   // Fill a control histogram
2118   //fPriHistShare->Fill(sharedMap.CountBits());
2119   // Reject shared clusters
2120   if((sharedMap.CountBits()) >= 1){
2121     // Bad track, has too many shared clusters!
2122     return kFALSE;
2123   }
2124   return kTRUE;
2125 }
2126
2127 //___________________________________________________________________________________________
2128 /*   under developing
2129 Float_t AliAnalysisTaskLambdaOverK0sJets::GetFractionTPCSharedCls(AliAODTrack *track1,const AliAODTrack *track2){
2130   // Rejects tracks with shared clusters after filling a control histogram
2131   // This overload is used for primaries
2132
2133   // Get the shared maps
2134   const TBits fTPCClusterMap1 = track1->GetTPCClusterMap();
2135   const TBits fTPCClusterMap2 = track2->GetTPCClusterMap();
2136   // Fill a control histogram
2137   //fPriHistShare->Fill(sharedMap.CountBits());
2138   // Reject shared clusters
2139
2140   for(Int_t i=0; i<=159; i++)
2141     cout << fTPCClusterMap1.CountBits(i) << "    " << fTPCClusterMap2.CountBits(i) << endl;
2142
2143   return 1.;
2144
2145 }
2146 */
2147 //___________________________________________________________________________________________
2148
2149 void AliAnalysisTaskLambdaOverK0sJets::RecCascade(AliAODTrack *trk1,const AliAODTrack *trk2,const AliAODTrack *trkBch,TString histo)
2150 {
2151   // Local method to reconstruct cascades candidates from the combinations of three tracks
2152   // The input tracks correspond to the trigger particle and the daughter tracks of the V0 candidate (correlation step)
2153   // The trigger particle track will be always consider as a possible daughter of the V0 which coming from the Cascade decay.
2154   // The daughters of the V0 candidates are switched to be the bachelor track for the Cascade reconstruction.
2155
2156   Float_t lMassBach=0., lPtot2Bach=0., lEBach=0.;
2157   Float_t lMassLambda=0., lPtot2Lambda=0., lELambda = 0.;
2158   Float_t pLambda[3] = {0.,0.,0.};
2159   Float_t pCascade[3] = {0.,0.,0.};
2160   Float_t lMassCascade = 0., lPtot2Cascade=0.;
2161
2162   // Two loops are done to consider the posibility to reconstruct a Xi or an Omega
2163   for(Int_t i=0;i<2;i++){
2164
2165     // 0. Check the charge for both tracks: trk1 & trk2.
2166     //    Usefull in the Lambda step.
2167     if( trk1->Charge() == trk2->Charge() )
2168       continue;
2169
2170     // 1. Bachelor: Allocation for the track
2171     if(i==0) // Xi
2172       lMassBach = TDatabasePDG::Instance()->GetParticle(kPiMinus)->Mass();
2173     else if(i==1) //Omega
2174       lMassBach = TDatabasePDG::Instance()->GetParticle(kKMinus)->Mass();
2175
2176     lPtot2Bach = TMath::Power(trkBch->P(),2);
2177
2178     lEBach = TMath::Sqrt(lPtot2Bach + lMassBach*lMassBach);
2179
2180     // 2. Lambda: Kinematical properties
2181     lMassLambda = TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass();
2182
2183     pLambda[0] = trk1->Px() + trk2->Px();
2184     pLambda[1] = trk1->Py() + trk2->Py();
2185     pLambda[2] = trk1->Pz() + trk2->Pz();
2186
2187     lPtot2Lambda = pLambda[0]*pLambda[0] +  pLambda[1]*pLambda[1] +  pLambda[2]*pLambda[2];
2188
2189     lELambda = TMath::Sqrt(lPtot2Lambda + lMassLambda*lMassLambda);
2190
2191     // 3. Cascade: Reconstruction
2192     pCascade[0] = pLambda[0] + trkBch->Px();
2193     pCascade[1] = pLambda[1] + trkBch->Py();
2194     pCascade[2] = pLambda[2] + trkBch->Pz();
2195
2196     lPtot2Cascade = pCascade[0]*pCascade[0] + pCascade[1]*pCascade[1] + pCascade[2]*pCascade[2];
2197
2198     lMassCascade = TMath::Sqrt( TMath::Power(lEBach+lELambda,2) - lPtot2Cascade );
2199
2200     // 4. Filling histograms
2201     if( histo.Contains("K0s") ) {
2202       if(i==0) // Xi
2203         fV0MassCascade->Fill(lMassCascade,1);
2204       else if(i==1) //Omega
2205         fV0MassCascade->Fill(lMassCascade,3);
2206     }
2207     else if( histo.Contains("AntiLambda") ) {
2208       if(i==0) // Xi
2209         fV0MassCascade->Fill(lMassCascade,9);
2210       else if(i==1) //Omega
2211         fV0MassCascade->Fill(lMassCascade,11);
2212     }
2213     else if( histo.Contains("Lambda") ) {
2214       if(i==0) // Xi
2215         fV0MassCascade->Fill(lMassCascade,5);
2216       else if(i==1) //Omega
2217         fV0MassCascade->Fill(lMassCascade,7);
2218     }
2219
2220   }
2221
2222 }
2223
2224 //___________________________________________________________________________________________
2225
2226 void AliAnalysisTaskLambdaOverK0sJets::V0Loop(V0LoopStep_t step, Bool_t isTriggered, Int_t iArray, Int_t idTrig)
2227 {
2228   // Three options for the 'step' variable:
2229   // 1) TriggerCheck
2230   // 2) Reconstruction
2231
2232   AliAODTrack *trkTrig = 0x0;
2233   Float_t  ptTrig  = -100.;
2234   Float_t  phiTrig = -100.;
2235   Float_t  etaTrig = -100.;
2236   Double_t pTrig[3];
2237
2238   if( (step==kTriggerCheck || isTriggered) && idTrig>=0 ){
2239     trkTrig = (AliAODTrack*)fAOD->GetTrack(idTrig);
2240     ptTrig  = trkTrig->Pt();
2241     phiTrig = trkTrig->Phi();
2242     etaTrig = trkTrig->Eta();
2243     trkTrig->GetPxPyPz(pTrig);
2244   }
2245
2246   // *************************************************
2247   // Centrality selection
2248   AliCentrality *cent = fAOD->GetCentrality();
2249   Float_t centrality = cent->GetCentralityPercentile("V0M");
2250   Int_t curCentBin = CentBin(centrality);
2251
2252   // *************************************************
2253   // MC Event
2254   TClonesArray *stackMC = 0x0;
2255   Float_t mcXv=0., mcYv=0., mcZv=0.;
2256
2257   if(fIsMC){
2258     TList *lst = fAOD->GetList();
2259     stackMC = (TClonesArray*)lst->FindObject(AliAODMCParticle::StdBranchName());
2260     if (!stackMC) {
2261       Printf("ERROR: stack not available");
2262     }
2263
2264     AliAODMCHeader *mcHdr =
2265       (AliAODMCHeader*)lst->FindObject(AliAODMCHeader::StdBranchName());
2266
2267     mcXv=mcHdr->GetVtxX(); mcYv=mcHdr->GetVtxY(); mcZv=mcHdr->GetVtxZ();
2268   }
2269
2270   // *************************************************
2271   // V0 loop - AOD
2272   const AliAODVertex *vtx=fAOD->GetPrimaryVertex();
2273   Float_t xv=vtx->GetX(), yv=vtx->GetY(), zv=vtx->GetZ();
2274   Int_t nV0sTot = fAOD->GetNumberOfV0s();
2275
2276   for (Int_t iV0 = 0; iV0 < nV0sTot; iV0++) {
2277
2278     AliAODv0 *v0=fAOD->GetV0(iV0);
2279     if (!v0) continue;
2280     if (!AcceptV0(fAOD->GetPrimaryVertex(),v0)) continue;
2281
2282     const AliAODTrack *ntrack=(AliAODTrack *)v0->GetDaughter(1);
2283     const AliAODTrack *ptrack=(AliAODTrack *)v0->GetDaughter(0);
2284
2285     // Decay vertex
2286     Double_t xyz[3]; v0->GetSecondaryVtx(xyz);
2287     Float_t dx=xyz[0]-xv, dy=xyz[1]-yv;//, dz=xyz[2]-zv;
2288
2289     // Momentum: 2D & 3D
2290     Float_t pt=TMath::Sqrt(v0->Pt2V0());
2291     //Float_t p=v0->P();
2292
2293     // Decay length: 2D & 3D
2294     Float_t lt=TMath::Sqrt(dx*dx + dy*dy);
2295     //Float_t dl=TMath::Sqrt(dx*dx + dy*dy + dz*dz);
2296
2297     Float_t dlK = 0.4977*lt/pt;
2298     Float_t dlL = 1.1157*lt/pt;
2299     /*
2300       Float_t dlK  = v0->MassK0Short()*dl/p;
2301       Float_t dlL  = v0->MassLambda()*dl/p;
2302       Float_t dlAL = v0->MassAntiLambda()*dl/p;
2303     */
2304
2305     // ctau
2306     Bool_t ctK=kTRUE;  if (dlK > fMaxCtau*2.68 || dlK < fMinCtau*2.68) ctK=kFALSE;
2307     Bool_t ctL=kTRUE;  if (dlL > fMaxCtau*7.89 || dlL < fMinCtau*7.89) ctL=kFALSE;
2308     Bool_t ctAL=kTRUE; if (dlL > fMaxCtau*7.89 || dlL < fMinCtau*7.89) ctAL=kFALSE;
2309
2310     //  ---- Daughter tracks properties:
2311     // Pt
2312     Float_t lPtNeg = ntrack->Pt();
2313     Float_t lPtPos = ptrack->Pt();
2314     // Momentum
2315     Double_t pNegDaug[3];  ntrack->GetPxPyPz(pNegDaug);
2316     Double_t pPosDaug[3];  ptrack->GetPxPyPz(pPosDaug);
2317     // Phi
2318     Float_t phiNeg = ntrack->Phi();
2319     Float_t phiPos = ptrack->Phi();
2320     // Eta
2321     Float_t etaNeg = ntrack->Eta();
2322     Float_t etaPos = ptrack->Eta();
2323     //  Number of TPC Clusters
2324     Float_t nClsTPCPos = ptrack->GetTPCClusterInfo(2,1);
2325     Float_t nClsTPCNeg = ntrack->GetTPCClusterInfo(2,1);
2326     // Number of clusters of ITS
2327     Double_t posITSNcls = ptrack->GetITSNcls();
2328     Double_t negITSNcls = ntrack->GetITSNcls();
2329
2330     //  ---- V0 candidate properties:
2331     // Armenteros variables:
2332     Float_t lAlphaV0      =  v0->AlphaV0();
2333     Float_t lPtArmV0      =  v0->PtArmV0();
2334     // dca to primary vertex
2335     Float_t dcaNeg = v0->DcaNegToPrimVertex();
2336     Float_t dcaPos = v0->DcaPosToPrimVertex();
2337     // dca between daughters
2338     Float_t dca   = v0->DcaV0Daughters();
2339     // cpa
2340     Float_t cpa   = v0->CosPointingAngle(fAOD->GetPrimaryVertex());
2341     // eta
2342     Float_t lEta  = v0->PseudoRapV0();
2343     // phi
2344     Float_t lPhi  = v0->Phi();
2345     //lPhi  = ( (lPhi < 0) ? lPhi + 2*TMath::Pi() : lPhi );
2346
2347     // rapidity
2348     Float_t rapK0s = v0->RapK0Short();
2349     Float_t rapLambda = v0->RapLambda();
2350
2351     if(fUseEtaCut){
2352       rapK0s = lEta;
2353       rapLambda = lEta;
2354     }
2355
2356     // **********************************
2357     // PID - tracks
2358     Float_t pPos = -100.;
2359     Float_t pNeg = -100.;
2360
2361     //Float_t dedxPos = -1000.;
2362     //Float_t dedxNeg = -1000.;
2363     //Float_t nsigPosPion   = 0.;
2364     //Float_t nsigNegPion   = 0.;
2365     Float_t nsigPosProton = 0.;
2366     Float_t nsigNegProton = 0.;
2367
2368     if(fUsePID && !fIsMC) {
2369       const AliAODPid *pidNeg = ntrack->GetDetPid();
2370       const AliAODPid *pidPos = ptrack->GetDetPid();
2371
2372       if (pidNeg && pidPos) {
2373         pPos = pidPos->GetTPCmomentum();
2374         pNeg = pidNeg->GetTPCmomentum();
2375         //dedxPos = pidPos->GetTPCsignal()/47.;
2376         //dedxNeg = pidNeg->GetTPCsignal()/47.;
2377
2378
2379         if(pPos<1.){
2380           //nsigPosPion   = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(ptrack,AliPID::kPion));
2381           nsigPosProton = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(ptrack,AliPID::kProton));
2382         }
2383         if(pNeg<1.){
2384           //nsigNegPion   = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(ntrack,AliPID::kPion));
2385           nsigNegProton = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(ntrack,AliPID::kProton));
2386         }
2387
2388       }
2389
2390     }
2391
2392     // **********************************
2393     // Disentangle the V0 candidate
2394     Float_t massK0s = 0., mK0s = 0., sK0s = 0.;
2395     Float_t massLambda = 0., mLambda = 0., sL = 0.;
2396     Float_t massAntiLambda = 0., sAL = 0.;
2397
2398     Bool_t isCandidate2K0s = kFALSE;
2399     massK0s = v0->MassK0Short();
2400     mK0s = TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass();
2401     if( fCollision.Contains("PbPb2010") )
2402       sK0s = kCteK0s2010[curCentBin] + kLinearK0s2010[curCentBin]*pt;
2403     else if( fCollision.Contains("PbPb2011") )
2404       sK0s = kCteK0s2011[curCentBin] + kLinearK0s2011[curCentBin]*pt;
2405     if ( TMath::Abs(mK0s-massK0s) < 3*sK0s )  isCandidate2K0s = kTRUE;
2406
2407     Bool_t isCandidate2Lambda = kFALSE;
2408     massLambda = v0->MassLambda();
2409     mLambda = TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass();
2410     if( fCollision.Contains("PbPb2010") )
2411       sL = kCteLambda2010[curCentBin] + kLinearLambda2010[curCentBin]*pt;
2412     else if( fCollision.Contains("PbPb2011") )
2413       sL = kCteLambda2011[curCentBin] + kLinearLambda2011[curCentBin]*pt;
2414     if (TMath::Abs(mLambda-massLambda) < 3*sL)  isCandidate2Lambda = kTRUE;
2415
2416     Bool_t isCandidate2LambdaBar = kFALSE;
2417     massAntiLambda = v0->MassAntiLambda();
2418     if( fCollision.Contains("PbPb2010") )
2419       sAL = kCteAntiLambda2010[curCentBin] + kLinearAntiLambda2010[curCentBin]*pt;
2420     else if( fCollision.Contains("PbPb2011") )
2421       sAL = kCteAntiLambda2011[curCentBin] + kLinearAntiLambda2011[curCentBin]*pt;
2422     if (TMath::Abs(mLambda-massAntiLambda) < 3*sAL)  isCandidate2LambdaBar = kTRUE;
2423
2424     // **********************************
2425     // MC Association:
2426     Bool_t lComeFromSigma     = kTRUE;
2427     Bool_t lCheckMcK0Short    = kTRUE;
2428     Bool_t lCheckMcLambda     = kTRUE;
2429     Bool_t lCheckMcAntiLambda = kTRUE;
2430     Bool_t lComeFromXi        = kTRUE;
2431
2432     Int_t lMCAssocNegDaug = -100;
2433     Int_t lMCAssocPosDaug = -100;
2434
2435     // ********* MC - Association *********
2436     // In case of injected-MC, the correlations might be done with only natural particles
2437     Bool_t isNaturalPart = kTRUE;
2438     if(step==kReconstruction){
2439
2440       if(fIsMC){
2441         if(!stackMC) goto noas;
2442
2443         isNaturalPart = kFALSE;
2444
2445         lComeFromSigma     = kFALSE;
2446         lCheckMcK0Short    = kFALSE;
2447         lCheckMcLambda     = kFALSE;
2448         lCheckMcAntiLambda = kFALSE;
2449         lComeFromXi        = kFALSE;
2450
2451         Int_t ntrkMC=stackMC->GetEntriesFast();
2452
2453         Int_t nlab = TMath::Abs(ntrack->GetLabel());//** UInt_t
2454         Int_t plab = TMath::Abs(ptrack->GetLabel());
2455
2456         // To avoid futher problems
2457         if ( (nlab<0 || plab<0) ||
2458              (nlab>=ntrkMC || plab>=ntrkMC) )
2459           goto noas;
2460
2461         AliAODMCParticle *nPart=(AliAODMCParticle*)stackMC->UncheckedAt(nlab);
2462         AliAODMCParticle *pPart=(AliAODMCParticle*)stackMC->UncheckedAt(plab);
2463
2464         if(!nPart || !pPart)   goto noas;
2465
2466         // MC origin of daughters: Primaries?
2467         if( nPart->IsPhysicalPrimary() ) lMCAssocNegDaug = 1;
2468         if( pPart->IsPhysicalPrimary() ) lMCAssocPosDaug = 1;
2469
2470         /*
2471         if ( TMath::Abs(nPart->Eta()) > fMaxEtaDaughter ||
2472              TMath::Abs(pPart->Eta()) > fMaxEtaDaughter )
2473           goto noas;
2474         */
2475         /*
2476         // Daughter momentum cut
2477         if ( ( nPart->Pt() < fMinPtDaughter ) ||
2478         ( pPart->Pt() < fMinPtDaughter )  )
2479         goto noas;
2480         */
2481
2482         // ----------------------------------------
2483
2484         Int_t lPDGCodeNegDaughter = nPart->GetPdgCode();
2485         Int_t lPDGCodePosDaughter = pPart->GetPdgCode();
2486
2487         Int_t ipMother = pPart->GetMother();
2488         Int_t inMother = nPart->GetMother();
2489
2490         if(inMother<0 || inMother>=ntrkMC) lMCAssocNegDaug = 6;
2491         if(ipMother<0 || ipMother>=ntrkMC) lMCAssocPosDaug = 6;
2492
2493         if(inMother<0 || inMother>=ntrkMC) {  goto noas;}
2494         if(inMother != ipMother) { // did the negative daughter decay ?
2495           AliAODMCParticle *negMotherOfMotherPart = (AliAODMCParticle*)stackMC->UncheckedAt(inMother);
2496           if (negMotherOfMotherPart->GetMother() != ipMother)
2497             goto noas;
2498         }
2499
2500         if (ipMother<0 || ipMother>=ntrkMC)
2501           goto noas;
2502
2503         AliAODMCParticle *p0=(AliAODMCParticle*)stackMC->UncheckedAt(ipMother);
2504         if(!p0)
2505           goto noas;
2506
2507         // ----------------------------------------
2508
2509         if ( (ipMother>=fEndOfHijingEvent) &&
2510              (fEndOfHijingEvent!=-1)     &&
2511              (p0->GetMother()<0) )
2512           isNaturalPart = kFALSE;
2513         else  isNaturalPart = kTRUE;
2514
2515         // ----------------------------------------
2516
2517         if(fSeparateInjPart && !isNaturalPart) goto noas;
2518
2519         Int_t lPDGCodeV0 = p0->GetPdgCode();
2520
2521         // MC origin of daughters:
2522         //Decay from Weak Decay?
2523         if( (TMath::Abs(lPDGCodeV0) == kK0Short) || (TMath::Abs(lPDGCodeV0) == kLambda0) ||
2524             (TMath::Abs(lPDGCodeV0) == kSigmaMinus) || (TMath::Abs(lPDGCodeV0) == kSigmaPlus) ||
2525             (TMath::Abs(lPDGCodeV0) == kSigma0) )
2526           { lMCAssocNegDaug = 2;          lMCAssocPosDaug = 2; }
2527         // Cascade Gamma conversion
2528         if( (TMath::Abs(lPDGCodeV0) == kXiMinus) ||
2529             (TMath::Abs(lPDGCodeV0) == kOmegaMinus) )
2530           { lMCAssocNegDaug = 3;          lMCAssocPosDaug = 3; }
2531         // Gamma conversion
2532         else if( TMath::Abs(lPDGCodeV0) == kGamma )
2533           { lMCAssocNegDaug = 4;          lMCAssocPosDaug = 4; }
2534         // Unidentied mother:
2535         else
2536           { lMCAssocNegDaug = 5;          lMCAssocPosDaug = 5; }
2537
2538
2539         Int_t lIndexMotherOfMother   = p0->GetMother();
2540         Int_t lPdgcodeMotherOfMother = 0;
2541         if (lIndexMotherOfMother != -1) {
2542           AliAODMCParticle *lMCAODMotherOfMother=(AliAODMCParticle*)stackMC->UncheckedAt(lIndexMotherOfMother);
2543           if (lMCAODMotherOfMother) {lPdgcodeMotherOfMother = lMCAODMotherOfMother->GetPdgCode();}
2544         }
2545
2546         /*
2547         // Daughter momentum cut: ! FIX it in case of AOD ! //MC or REc
2548         if ( (nPart->Pt()  < fMinPtDaughter ) ||
2549         (pPart->Pt()  < fMinPtDaughter ) )
2550         goto noas;
2551         */
2552
2553         if( (lPDGCodeV0 != kK0Short) &&
2554             (lPDGCodeV0 != kLambda0) &&
2555             (lPDGCodeV0 != kLambda0Bar) )
2556           goto noas;
2557
2558
2559         // ----------------------------------------
2560
2561         // K0s
2562         if( (lPDGCodePosDaughter==+211) && (lPDGCodeNegDaughter==-211) &&
2563             (inMother==ipMother) && (lPDGCodeV0==310) ) {
2564
2565           if ( ((AliAODMCParticle*)stackMC->UncheckedAt(ipMother))->IsPrimary()  )
2566             lCheckMcK0Short  = kTRUE;
2567
2568         }
2569         // Lambda
2570         else if( (lPDGCodePosDaughter==+2212) && (lPDGCodeNegDaughter==-211)  &&
2571                  (inMother==ipMother) && (lPDGCodeV0==3122)  ){
2572
2573           if ( ( TMath::Abs(lPdgcodeMotherOfMother) == 3212) /*||
2574                ( TMath::Abs(lPdgcodeMotherOfMother) == 3224) ||
2575                ( TMath::Abs(lPdgcodeMotherOfMother) == 3214) ||
2576                ( TMath::Abs(lPdgcodeMotherOfMother) == 3114)*/
2577                ) lComeFromSigma = kTRUE;
2578           else lComeFromSigma = kFALSE;
2579
2580           if ( ((AliAODMCParticle*)stackMC->UncheckedAt(ipMother))->IsPrimary() ||
2581                ( !(((AliAODMCParticle*)stackMC->UncheckedAt(ipMother))->IsPrimary() )
2582                  && (lComeFromSigma==kTRUE) )
2583                ) lCheckMcLambda  = kTRUE;
2584
2585
2586           if ( TMath::Abs(lPdgcodeMotherOfMother) == 3312)
2587             lComeFromXi = kTRUE;
2588
2589         }
2590         // AntiLambda
2591         else if( (lPDGCodePosDaughter==211) && (lPDGCodeNegDaughter==-2212) &&
2592                  (inMother==ipMother) && (lPDGCodeV0==-3122) ) {
2593
2594
2595           if ( ( TMath::Abs(lPdgcodeMotherOfMother) == 3212) /*||
2596                ( TMath::Abs(lPdgcodeMotherOfMother) == 3224) ||
2597                ( TMath::Abs(lPdgcodeMotherOfMother) == 3214) ||
2598                ( TMath::Abs(lPdgcodeMotherOfMother) == 3114)*/
2599                ) lComeFromSigma = kTRUE;
2600           else lComeFromSigma = kFALSE;
2601
2602           if ( ((AliAODMCParticle*)stackMC->UncheckedAt(ipMother))->IsPrimary() ||
2603                ( (!((AliAODMCParticle*)stackMC->UncheckedAt(ipMother))->IsPrimary())
2604                  && (lComeFromSigma==kTRUE) )
2605                ) lCheckMcAntiLambda  = kTRUE;
2606
2607           if ( TMath::Abs(lPdgcodeMotherOfMother) == 3312 || TMath::Abs(lPdgcodeMotherOfMother) == 3322 )
2608             lComeFromXi = kTRUE;
2609
2610         }
2611
2612         //  ----------------------------------------
2613
2614         if ((p0->Pt())<pMin) goto noas;
2615         if (TMath::Abs(p0->Y())>fYMax ) goto noas;
2616
2617         Float_t dxAs = mcXv - p0->Xv(),  dyAs = mcYv - p0->Yv(),  dzAs = mcZv - p0->Zv();
2618         Float_t l = TMath::Sqrt(dxAs*dxAs + dyAs*dyAs + dzAs*dzAs);
2619
2620         dxAs = mcXv - pPart->Xv(); dyAs = mcYv - pPart->Yv();
2621         //Float_t ltAs = TMath::Sqrt(dxAs*dxAs + dyAs*dyAs);
2622         Float_t ptAs = p0->Pt();
2623         Float_t rapAs = p0->Y();
2624         Float_t etaAs = p0->Eta();
2625
2626         if(fUseEtaCut){
2627           rapAs = etaAs;
2628         }
2629
2630         // phi resolution for V0-reconstruction
2631         Float_t resEta = p0->Eta() - v0->Eta();
2632         Float_t resPhi = p0->Phi() - v0->Phi();
2633
2634         if ( (l < 0.01)  &&  (ptAs<10.) ) { // Primary V0
2635
2636           // K0s:
2637           if(ctK && lCheckMcK0Short){
2638
2639             // Natural particles
2640             if(isNaturalPart){
2641
2642               if( (dcaPos>0.1) && (dcaNeg>0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2643
2644                 fK0sAssocPt->Fill(ptAs);
2645                 fK0sAssocPtRap->Fill(ptAs,rapAs,centrality);
2646                 fK0sAssocPtPhiEta[curCentBin]->Fill(p0->Phi(),etaAs,ptAs);
2647
2648                 // Armenteros Pod.  and rapidity cut
2649                 if( (lPtArmV0 > TMath::Abs(0.2*lAlphaV0) ) && TMath::Abs(rapAs)<fYMax ){
2650
2651                   Double_t effK0sArm[3] = {v0->MassK0Short(),ptAs,rapAs};
2652                   Double_t effK0sVtx[4] = {v0->MassK0Short(),ptAs,rapAs,zv};
2653                   Double_t effK0sDCA[4] = {v0->MassK0Short(),ptAs,rapAs,dca};
2654                   Double_t effK0sCPA[4] = {v0->MassK0Short(),ptAs,rapAs,cpa};
2655
2656                   // Distributions for the efficiency (systematics chechks)
2657                   fK0sAssocPtMassArm[curCentBin]->Fill(effK0sArm);
2658                   fK0sAssocMassPtVtx[curCentBin]->Fill(effK0sVtx);
2659                   fK0sAssocMassPtDCADaug[curCentBin]->Fill(effK0sDCA);
2660                   fK0sAssocMassPtCPA[curCentBin]->Fill(effK0sCPA);
2661                 }
2662
2663                 fK0sMCResEta->Fill(resEta,pt,centrality);
2664                 fK0sMCResPhi->Fill(resPhi,pt,centrality);
2665
2666               } // End selection in the dca to prim. vtx and the number of clusters
2667
2668               // Distributions for the efficiency (Systematic checks)
2669               if( (lPtArmV0 > TMath::Abs(0.2*lAlphaV0) ) && TMath::Abs(rapAs)<fYMax ){
2670
2671                 //  Cut in the DCA ToPrim Vtx
2672                 if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2673
2674                   Double_t effK0sdcaPV[5] = {v0->MassK0Short(),ptAs,rapAs,dcaPos,dcaNeg};
2675                   fK0sAssocMassPtDCAPV[curCentBin]->Fill(effK0sdcaPV);
2676                 }
2677
2678                 // cut in the number of tpc clusters
2679                 if( (dcaPos>0.1) && (dcaNeg>0.1) && TMath::Abs(rapAs)<fYMax ){
2680
2681                   Double_t effK0sTPCcls[5]  = {v0->MassK0Short(),ptAs,rapAs,nClsTPCPos,nClsTPCNeg};
2682                   fK0sAssocMassPtDaugNClsTPC[curCentBin]->Fill(effK0sTPCcls);
2683
2684                 }
2685
2686               } // End selection for systematics
2687
2688             } // End natural particle selection
2689             // Embeded particles
2690             if(!isNaturalPart){
2691
2692               if( (dcaPos>0.1) && (dcaNeg>0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2693
2694                 fK0sAssocPtRapEmbeded->Fill(ptAs,rapAs,centrality);
2695
2696                 if( (lPtArmV0 > TMath::Abs(0.2*lAlphaV0)) && TMath::Abs(rapAs)<fYMax ){
2697
2698                   Double_t effK0sArm[3] = {v0->MassK0Short(),ptAs,rapAs};
2699                   Double_t effK0sVtx[4] = {v0->MassK0Short(),ptAs,rapAs,zv};
2700                   Double_t effK0sDCA[4] = {v0->MassK0Short(),ptAs,rapAs,dca};
2701                   Double_t effK0sCPA[4] = {v0->MassK0Short(),ptAs,rapAs,cpa};
2702
2703                   // Distributions for the efficiency (systematics chechks)
2704                   fK0sAssocPtMassArmEmbeded[curCentBin]->Fill(effK0sArm);
2705                   fK0sAssocMassPtVtxEmbeded[curCentBin]->Fill(effK0sVtx);
2706                   fK0sAssocMassPtDCADaugEmbeded[curCentBin]->Fill(effK0sDCA);
2707                   fK0sAssocMassPtCPAEmbeded[curCentBin]->Fill(effK0sCPA);
2708                 }
2709
2710               } // End selection in the dca to prim. vtx and the number of clusters
2711
2712               // Distributions for the efficiency (Systematic checks)
2713               if( (lPtArmV0 > TMath::Abs(0.2*lAlphaV0) ) && TMath::Abs(rapAs)<fYMax ){
2714
2715                 //  Cut in the DCA ToPrim Vtx
2716                 if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2717
2718                   Double_t effK0sdcaPV[5] = {v0->MassK0Short(),ptAs,rapAs,dcaPos,dcaNeg};
2719                   fK0sAssocMassPtDCAPVEmbeded[curCentBin]->Fill(effK0sdcaPV);
2720                 }
2721
2722                 // cut in the number of tpc clusters
2723                 if( (dcaPos>0.1) && (dcaNeg>0.1) && TMath::Abs(rapAs)<fYMax ){
2724
2725                   Double_t effK0sTPCcls[5]  = {v0->MassK0Short(),ptAs,rapAs,nClsTPCPos,nClsTPCNeg};
2726                   fK0sAssocMassPtDaugNClsTPCEmbeded[curCentBin]->Fill(effK0sTPCcls);
2727                 }
2728
2729               } // End selection for systematics
2730
2731             } // End embeded particle selection
2732
2733           }  // End K0s selection
2734
2735           // Lambda:
2736           if(ctL && lCheckMcLambda && (TMath::Abs(nsigPosProton)<fNSigma) ) {
2737
2738             // Natural particles
2739             if(isNaturalPart){
2740
2741               if( (dcaPos>0.1) && (dcaNeg>0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2742
2743                 fLambdaAssocPt->Fill(ptAs);
2744                 fLambdaAssocPtRap->Fill(ptAs,rapAs,centrality);
2745                 fLambdaAssocPtPhiEta[curCentBin]->Fill(p0->Phi(),etaAs,ptAs);
2746
2747                 // Rapidity cut
2748                 if(TMath::Abs(rapAs)<fYMax)  {
2749
2750                   Double_t effLambda[3] = {v0->MassLambda(),ptAs,rapAs};
2751                   Double_t effLambdaVtx[4] = {v0->MassLambda(),ptAs,rapAs,zv};
2752                   Double_t effLambdaDCA[4] = {v0->MassLambda(),ptAs,rapAs,dca};
2753                   Double_t effLambdaCPA[4] = {v0->MassLambda(),ptAs,rapAs,cpa};
2754
2755                   // Distributions for the efficiency (systematics chechks)
2756                   fLambdaAssocMassPtRap[curCentBin]->Fill(effLambda);
2757                   fLambdaAssocMassPtVtx[curCentBin]->Fill(effLambdaVtx);
2758                   fLambdaAssocMassPtDCADaug[curCentBin]->Fill(effLambdaDCA);
2759                   fLambdaAssocMassPtCPA[curCentBin]->Fill(effLambdaCPA);
2760
2761                   if( !isCandidate2K0s && !isCandidate2LambdaBar)
2762                     fLambdaAssocMassPtRap2[curCentBin]->Fill(effLambda);
2763
2764                 }
2765
2766                 fLambdaMCResEta->Fill(resEta,pt,centrality);
2767                 fLambdaMCResPhi->Fill(resPhi,pt,centrality);
2768
2769               } // End selection in the dca to prim. vtx and the number of clusters
2770
2771               // Distributions for the efficiency (Systematic checks)
2772               if( TMath::Abs(rapAs)<fYMax ){
2773
2774                 //  Cut in the DCA ToPrim Vtx
2775                 if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2776
2777                   Double_t effLambdadcaPV[5] = {v0->MassLambda(),ptAs,rapAs,dcaPos,dcaNeg};
2778                   fLambdaAssocMassPtDCAPV[curCentBin]->Fill(effLambdadcaPV);
2779                 }
2780
2781                 // cut in the number of tpc clusters
2782                 if( (dcaPos>0.1) && (dcaNeg>0.1) && TMath::Abs(rapAs)<fYMax){
2783
2784                   Double_t effLambdaTPCcls[5]  = {v0->MassLambda(),ptAs,rapAs,nClsTPCPos,nClsTPCNeg};
2785                   fLambdaAssocMassPtDaugNClsTPC[curCentBin]->Fill(effLambdaTPCcls);
2786                 }
2787
2788               } // End selection for systematics
2789
2790             } // End natural particle selection
2791             // Embeded particles
2792             if(!isNaturalPart){
2793
2794               if( (dcaPos>0.1) && (dcaNeg>0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2795
2796                 if( TMath::Abs(rapAs)<fYMax ){
2797
2798                   Double_t effLambda[3] = {v0->MassLambda(),ptAs,rapAs};
2799                   Double_t effLambdaVtx[4] = {v0->MassLambda(),ptAs,rapAs,zv};
2800                   Double_t effLambdaDCA[4] = {v0->MassLambda(),ptAs,rapAs,dca};
2801                   Double_t effLambdaCPA[4] = {v0->MassLambda(),ptAs,rapAs,cpa};
2802
2803                   // Distributions for the efficiency (systematics chechks)
2804                   fLambdaAssocMassPtRapEmbeded[curCentBin]->Fill(effLambda);
2805                   fLambdaAssocMassPtVtxEmbeded[curCentBin]->Fill(effLambdaVtx);
2806                   fLambdaAssocMassPtDCADaugEmbeded[curCentBin]->Fill(effLambdaDCA);
2807                   fLambdaAssocMassPtCPAEmbeded[curCentBin]->Fill(effLambdaCPA);
2808
2809                   if( !isCandidate2K0s && !isCandidate2LambdaBar)
2810                     fLambdaAssocMassPtRapEmbeded2[curCentBin]->Fill(effLambda);
2811                 }
2812
2813               } // End selection in the dca to prim. vtx and the number of clusters
2814
2815               // Distributions for the efficiency (Systematic checks)
2816               if( TMath::Abs(rapAs)<fYMax ){
2817
2818                 //  Cut in the DCA ToPrim Vtx
2819                 if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2820                   Double_t effLambdadcaPV[5] = {v0->MassLambda(),ptAs,rapAs,dcaPos,dcaNeg};
2821                   fLambdaAssocMassPtDCAPVEmbeded[curCentBin]->Fill(effLambdadcaPV);
2822                 }
2823
2824                 // cut in the number of tpc clusters
2825                 if( (dcaPos>0.1) && (dcaNeg>0.1) ){
2826                   Double_t effLambdaTPCcls[5]  = {v0->MassLambda(),ptAs,rapAs,nClsTPCPos,nClsTPCNeg};
2827                   fLambdaAssocMassPtDaugNClsTPCEmbeded[curCentBin]->Fill(effLambdaTPCcls);
2828                 }
2829
2830               } // End selection for systematics
2831
2832             }  // End embeded particle selection
2833
2834           } // End Lambda selection
2835
2836           // AntiLambda:
2837           if (ctAL && lCheckMcAntiLambda  && (TMath::Abs(nsigNegProton)<fNSigma) ){
2838
2839             if(isNaturalPart){
2840
2841               if( (dcaPos>0.1) && (dcaNeg>0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2842
2843                 fAntiLambdaAssocPt->Fill(ptAs);
2844                 fAntiLambdaAssocPtRap->Fill(ptAs,rapAs,centrality);
2845                 fAntiLambdaAssocPtPhiEta[curCentBin]->Fill(p0->Phi(),etaAs,ptAs);
2846
2847                 // Rapidity cut
2848                 if(TMath::Abs(rapAs)<fYMax)  {
2849
2850                   Double_t effAntiLambda[3] = {v0->MassAntiLambda(),ptAs,rapAs};
2851                   Double_t effAntiLambdaVtx[4] = {v0->MassAntiLambda(),ptAs,rapAs,zv};
2852                   Double_t effAntiLambdaDCA[4] = {v0->MassAntiLambda(),ptAs,rapAs,dca};
2853                   Double_t effAntiLambdaCPA[4] = {v0->MassAntiLambda(),ptAs,rapAs,cpa};
2854
2855                   // Distributions for the efficiency (systematics chechks)
2856                   fAntiLambdaAssocMassPtRap[curCentBin]->Fill(effAntiLambda);
2857                   fAntiLambdaAssocMassPtVtx[curCentBin]->Fill(effAntiLambdaVtx);
2858                   fAntiLambdaAssocMassPtDCADaug[curCentBin]->Fill(effAntiLambdaDCA);
2859                   fAntiLambdaAssocMassPtCPA[curCentBin]->Fill(effAntiLambdaCPA);
2860
2861                   if( !isCandidate2K0s && !isCandidate2Lambda )
2862                     fAntiLambdaAssocMassPtRap2[curCentBin]->Fill(effAntiLambda);
2863                 }
2864
2865                 fAntiLambdaMCResEta->Fill(resEta,pt,centrality);
2866                 fAntiLambdaMCResPhi->Fill(resPhi,pt,centrality);
2867
2868               } // End selection in the dca to prim. vtx and the number of clusters
2869
2870               // Distributions for the efficiency (Systematic checks)
2871               if( TMath::Abs(rapAs)<fYMax ){
2872
2873                 //  Cut in the DCA ToPrim Vtx
2874                 if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2875
2876                   Double_t effAntiLambdadcaPV[5] = {v0->MassAntiLambda(),ptAs,rapAs,dcaPos,dcaNeg};
2877                   fAntiLambdaAssocMassPtDCAPV[curCentBin]->Fill(effAntiLambdadcaPV);
2878                 }
2879
2880                 // cut in the number of tpc clusters
2881                 if( (dcaPos>0.1) && (dcaNeg>0.1) && TMath::Abs(rapAs)<fYMax){
2882                   Double_t effAntiLambdaTPCcls[5]  = {v0->MassAntiLambda(),ptAs,rapAs,nClsTPCPos,nClsTPCNeg};
2883                   fAntiLambdaAssocMassPtDaugNClsTPC[curCentBin]->Fill(effAntiLambdaTPCcls);
2884                 }
2885
2886               } // End selection for systematics
2887
2888             }  // End natural particle selection
2889             // Embeded particles
2890             if(!isNaturalPart){
2891
2892               if( (dcaPos>0.1) && (dcaNeg>0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2893
2894                 if( TMath::Abs(rapAs)<fYMax ){
2895
2896                   Double_t effAntiLambda[3] = {v0->MassAntiLambda(),ptAs,rapAs};
2897                   Double_t effAntiLambdaVtx[4] = {v0->MassAntiLambda(),ptAs,rapAs,zv};
2898                   Double_t effAntiLambdaDCA[4] = {v0->MassAntiLambda(),ptAs,rapAs,dca};
2899                   Double_t effAntiLambdaCPA[4] = {v0->MassAntiLambda(),ptAs,rapAs,cpa};
2900
2901                   // Distributions for the efficiency (systematics chechks)
2902                   fAntiLambdaAssocMassPtRapEmbeded[curCentBin]->Fill(effAntiLambda);
2903                   fAntiLambdaAssocMassPtVtxEmbeded[curCentBin]->Fill(effAntiLambdaVtx);
2904                   fAntiLambdaAssocMassPtDCADaugEmbeded[curCentBin]->Fill(effAntiLambdaDCA);
2905                   fAntiLambdaAssocMassPtCPAEmbeded[curCentBin]->Fill(effAntiLambdaCPA);
2906
2907                   if( !isCandidate2K0s && !isCandidate2Lambda )
2908                     fAntiLambdaAssocMassPtRapEmbeded2[curCentBin]->Fill(effAntiLambda);
2909                 }
2910
2911               } // End selection in the dca to prim. vtx and the number of clusters
2912
2913
2914               // Distributions for the efficiency (Systematic checks)
2915               if( TMath::Abs(rapAs)<fYMax ){
2916
2917                 //  Cut in the DCA ToPrim Vtx
2918                 if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2919
2920                   Double_t effAntiLambdadcaPV[5] = {v0->MassAntiLambda(),ptAs,rapAs,dcaPos,dcaNeg};
2921                   fAntiLambdaAssocMassPtDCAPVEmbeded[curCentBin]->Fill(effAntiLambdadcaPV);
2922                 }
2923
2924                 // cut in the number of tpc ckusters
2925                 if( (dcaPos>0.1) && (dcaNeg>0.1) ){
2926
2927                   Double_t effAntiLambdaTPCcls[5]  = {v0->MassAntiLambda(),ptAs,rapAs,nClsTPCPos,nClsTPCNeg};
2928                   fAntiLambdaAssocMassPtDaugNClsTPCEmbeded[curCentBin]->Fill(effAntiLambdaTPCcls);
2929                 }
2930
2931               } // End selection for systematics
2932
2933             }  // End embeded particle selection
2934
2935             } // End AntiLambda
2936           // Xi decay:
2937           if( lComeFromXi && isNaturalPart ){
2938             if(lPDGCodeV0==3122) { fLambdaAssocFromXi->Fill(ptAs,centrality); }
2939             else if(lPDGCodeV0==-3122) { fAntiLambdaAssocFromXi->Fill(ptAs,centrality); }
2940           }
2941
2942         } // End Primary V0 selection
2943
2944         // After the kinematical selection of K0s and Lambdas
2945         // it might be that the daugthers are not identified through MC Association
2946         if(lMCAssocNegDaug==0)
2947           lMCAssocNegDaug = 6;
2948         if(lMCAssocPosDaug==0)
2949           lMCAssocPosDaug = 6;
2950
2951       } // End MC-Association
2952
2953     }// End Correlation Step
2954
2955     // ************************************
2956
2957   noas:
2958
2959     // Comparing the pt of the trigger particle wrt the v0-candidate's daughter:
2960     // It is used as well for the side-band subtraction
2961     Int_t isSameTrkPosDaug = -1;
2962     Int_t isSameTrkNegDaug = -1;
2963     if( step==kTriggerCheck ){
2964       isSameTrkPosDaug = SameTrack(trkTrig,ptrack);
2965       isSameTrkNegDaug = SameTrack(trkTrig,ntrack);
2966     }
2967
2968     // *******************
2969     //   K0s selection
2970     // *******************
2971     if (ctK && (TMath::Abs(rapK0s)<fYMax) && ( lPtArmV0 > TMath::Abs(0.2*lAlphaV0) ) && ( massK0s > 0.3979 && massK0s < 0.5981 ) ) {
2972
2973       switch(step) {
2974       case kTriggerCheck:
2975
2976         if (isCandidate2K0s && (dcaPos>0.1) && (dcaNeg>0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
2977
2978           if(pt>ptTrig){
2979             fIsV0LP = 1;
2980             fPtV0LP = pt;
2981           }
2982
2983           if( isSameTrkPosDaug==1 || isSameTrkNegDaug==1){
2984             Printf("  The LP has the same momentum in X and Y as one of the K0s daughters *** iV0 %d",iV0);
2985
2986             if(fCheckIDTrig){  // Compare properties of daughters nad
2987               Float_t difNegP[3];
2988               difNegP[0] = (pTrig[0]-pNegDaug[0])/pTrig[0];  difNegP[1] = (pTrig[1]-pNegDaug[1])/pTrig[1]; difNegP[2] = (pTrig[2]-pNegDaug[2])/pTrig[2];
2989               Float_t difPosP[3];
2990               difPosP[0] = (pTrig[0]-pPosDaug[0])/pTrig[0];  difPosP[1] = (pTrig[1]-pPosDaug[1])/pTrig[1]; difPosP[2] = (pTrig[2]-pPosDaug[2])/pTrig[2];
2991               Float_t posDeltaPhi =  phiTrig - phiPos, negDeltaPhi =  phiTrig - phiNeg;
2992               Float_t posDeltaEta =  etaTrig - etaPos, negDeltaEta =  etaTrig - etaNeg;
2993
2994               /*
2995                 Printf("  The LP has the same momentum in X and Y as one of the K0s daughters *** iV0 %d \n\t\t %d %d %d \n\t\t %lf %lf %lf \n\t\t %lf %lf %lf \n\t\t %lf %lf \n\t\t %lf %lf ",
2996                 iV0, TMath::Abs( trkTrig->GetID() ), ntrack->GetID() ,  ptrack->GetID() ,
2997                 TMath::Abs( difNegP[1] ), TMath::Abs( difNegP[2] ), TMath::Abs( difNegP[0] ),
2998                 TMath::Abs( difPosP[1] ), TMath::Abs( difPosP[2] ), TMath::Abs( difPosP[0] ),
2999                 TMath::Abs( negDeltaPhi ), TMath::Abs( negDeltaEta ),
3000                 TMath::Abs( posDeltaPhi ), TMath::Abs( posDeltaEta )
3001                 );
3002               */
3003
3004               // Positive daughter
3005               if( isSameTrkPosDaug==1 ){
3006                 for(Int_t i=0;i<3;i++)
3007                   fCheckIDTrigPtK0s->Fill(difPosP[i],i,pt);
3008                 fCheckIDTrigPhiK0s->Fill(posDeltaPhi,0.,pt);
3009                 fCheckIDTrigEtaK0s->Fill(posDeltaEta,0.,pt);
3010                 fCheckIDTrigNclsK0s->Fill(nClsTPCPos,0.,pt);
3011               }
3012               // Negative daughter
3013               if( isSameTrkNegDaug==1 ){
3014                 for(Int_t i=0;i<3;i++)
3015                   fCheckIDTrigPtK0s->Fill(difNegP[i],i+3,pt);
3016                 fCheckIDTrigPhiK0s->Fill(negDeltaPhi,2.,pt);
3017                 fCheckIDTrigEtaK0s->Fill(negDeltaEta,2.,pt);
3018                 fCheckIDTrigNclsK0s->Fill(nClsTPCNeg,2.,pt);
3019               }
3020
3021             } // End check ID
3022
3023
3024             fTriggerParticles->RemoveAt(iArray);
3025             fTriggerParticles->AddAt( new AliMiniParticle(centrality, zv, idTrig, ptTrig, phiTrig, etaTrig, 0, 0, 0), iArray);
3026
3027
3028           } // Close isTrigFromV0daug
3029
3030         }// End K0s Mass cut
3031
3032         break; // End K0s selection for TriggerCheck
3033       case kReconstruction:
3034
3035         if( (dcaPos > 0.1) && (dcaNeg > 0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) && (pt<10.) ){
3036
3037           if(isNaturalPart) fK0sMass->Fill(massK0s,pt,centrality);
3038           else fK0sMassEmbeded->Fill(massK0s,pt,centrality);
3039
3040           fK0sMassPtEta->Fill(massK0s,pt,lEta);
3041           fK0sMassPtRap[curCentBin]->Fill(massK0s,pt,rapK0s);
3042           fK0sMassPtPhi->Fill(massK0s,pt,lPhi);
3043
3044
3045           if( (pt>kPtBinV0[0]) && (pt<kPtBinV0[kN1]) && isNaturalPart )
3046             fAssocParticles->Add( new AliMiniParticle(centrality, zv, iV0, pt, lPhi, lEta, lMCAssocNegDaug, lMCAssocPosDaug, 3) );
3047
3048
3049         }
3050
3051         if( fDoQA && lCheckMcK0Short && isNaturalPart && (pt<10.) ){ // Quality Assurance
3052
3053           // Invariant Mass cut
3054           if (TMath::Abs(mK0s-massK0s) < 3*sK0s) {
3055
3056             if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3057               fK0sDCAPosDaug->Fill(dcaPos,pt);
3058               fK0sDCANegDaug->Fill(dcaNeg,pt);
3059             }
3060
3061             if( (dcaPos > 0.1) && (dcaNeg > 0.1) ){
3062
3063               if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC ) ){
3064                 fK0sPtPosDaug->Fill(pt,lPtPos);
3065                 fK0sPtNegDaug->Fill(pt,lPtNeg);
3066
3067                 fK0sPhiEtaPosDaug->Fill(phiPos,etaPos,pt);
3068                 fK0sPhiEtaNegDaug->Fill(phiNeg,etaNeg,pt);
3069
3070                 fK0sDecayPos->Fill(dx,dy,pt);
3071                 fK0sDecayVertex->Fill(lt,pt);
3072
3073                 fK0sCPA->Fill(cpa,pt);
3074                 fK0sDCAV0Daug->Fill(dca,pt);
3075
3076                 fK0sNClustersITSPos->Fill(phiPos,posITSNcls,pt);
3077                 fK0sNClustersITSNeg->Fill(phiNeg,negITSNcls,pt);
3078               }
3079
3080               fK0sNClustersTPC->Fill(phiPos,nClsTPCPos,pt);
3081               fK0sNClustersTPC->Fill(phiNeg,nClsTPCNeg,-pt);
3082             }
3083
3084           } // End selection in mass
3085
3086           if( TMath::Abs(mK0s-massK0s + 6.5*sK0s) < 1.5*sK0s ||
3087               TMath::Abs(mK0s-massK0s - 6.5*sK0s) < 1.5*sK0s  ) {
3088
3089             if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3090               fK0sBckgDCAPosDaug->Fill(dcaPos,pt);
3091               fK0sBckgDCANegDaug->Fill(dcaNeg,pt);
3092             }
3093
3094             if( (dcaPos > 0.1) && (dcaNeg > 0.1) ){
3095
3096               if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3097                 fK0sBckgPtPosDaug->Fill(pt,lPtPos);
3098                 fK0sBckgPtNegDaug->Fill(pt,lPtNeg);
3099
3100                 fK0sBckgPhiEtaPosDaug->Fill(phiPos,etaPos,pt);
3101                 fK0sBckgPhiEtaNegDaug->Fill(phiNeg,etaNeg,pt);
3102
3103                 fK0sBckgDecayPos->Fill(dx,dy,pt);
3104                 fK0sBckgDecayVertex->Fill(lt,pt);
3105
3106                 fK0sBckgCPA->Fill(cpa,pt);
3107                 fK0sBckgDCAV0Daug->Fill(dca,pt);
3108
3109                 fK0sBckgNClustersITSPos->Fill(phiPos,posITSNcls,pt);
3110                 fK0sBckgNClustersITSNeg->Fill(phiNeg,negITSNcls,pt);
3111               }
3112
3113               fK0sBckgNClustersTPC->Fill(phiPos,nClsTPCPos,pt);
3114               fK0sBckgNClustersTPC->Fill(phiNeg,nClsTPCNeg,-pt);
3115
3116             }
3117
3118           }// End selection in outside the mass cut
3119
3120         } // End QA
3121
3122         break; // End K0s selection for Corrleation
3123       default:
3124         Printf( " Selection of 'step' is not set properly");
3125         break;
3126
3127       }// End switch
3128
3129     } // End K0s selection
3130
3131     // *******************
3132     // Lambda selection
3133     // *******************
3134     if ( ctL && (TMath::Abs(rapLambda)<fYMax) && (massLambda > 1.0649 && massLambda < 1.1651 ) && (TMath::Abs(nsigPosProton)<fNSigma) ){
3135
3136       switch(step) {
3137       case kTriggerCheck:
3138
3139         if (isCandidate2Lambda && (dcaPos>0.1) && (dcaNeg>0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) && !isCandidate2K0s && !isCandidate2LambdaBar ){
3140
3141           if(pt>ptTrig) {
3142             fIsV0LP = 1;
3143             fPtV0LP = pt;
3144           }
3145
3146           if( isSameTrkPosDaug==1 || isSameTrkNegDaug==1 ){
3147             Printf("  The LP has the same momentum in X and Y as one of the Lambda daughters *** iV0 %d",iV0);
3148
3149             if(fCheckIDTrig){  // Compare properties of daughters nad
3150               Float_t difNegP[3];
3151               difNegP[0] = (pTrig[0]-pNegDaug[0])/pTrig[0];  difNegP[1] = (pTrig[1]-pNegDaug[1])/pTrig[1]; difNegP[2] = (pTrig[2]-pNegDaug[2])/pTrig[2];
3152               Float_t difPosP[3];
3153               difPosP[0] = (pTrig[0]-pPosDaug[0])/pTrig[0];  difPosP[1] = (pTrig[1]-pPosDaug[1])/pTrig[1]; difPosP[2] = (pTrig[2]-pPosDaug[2])/pTrig[2];
3154               Float_t posDeltaPhi =  phiTrig - phiPos, negDeltaPhi =  phiTrig - phiNeg;
3155               Float_t posDeltaEta =  etaTrig - etaPos, negDeltaEta =  etaTrig - etaNeg;
3156
3157               /*
3158                 Printf("  The LP has the same momentum in X and Y as one of the Lambda daughters *** iV0 %d \n\t\t %d %d %d \n\t\t %lf %lf %lf \n\t\t %lf %lf %lf \n\t\t %lf %lf \n\t\t %lf %lf ",
3159                 iV0, TMath::Abs( trkTrig->GetID() ), ntrack->GetID() ,  ptrack->GetID() ,
3160                 TMath::Abs( difNegP[1] ), TMath::Abs( difNegP[2] ), TMath::Abs( difNegP[0] ),
3161                 TMath::Abs( difPosP[1] ), TMath::Abs( difPosP[2] ), TMath::Abs( difPosP[0] ),
3162                 TMath::Abs( negDeltaPhi ), TMath::Abs( negDeltaEta ),
3163                 TMath::Abs( posDeltaPhi ), TMath::Abs( posDeltaEta )
3164                 );
3165               */
3166
3167               // Positive daughter
3168               if( isSameTrkPosDaug==1 ){
3169                 for(Int_t i=0;i<3;i++)
3170                   fCheckIDTrigPtLambda->Fill(difPosP[i],i,pt);
3171                 fCheckIDTrigPhiLambda->Fill(posDeltaPhi,0.,pt);
3172                 fCheckIDTrigEtaLambda->Fill(posDeltaEta,0.,pt);
3173                 fCheckIDTrigNclsLambda->Fill(nClsTPCPos,0.,pt);
3174               }
3175               // Negative daughter
3176               if( isSameTrkNegDaug==1 ){
3177                 for(Int_t i=0;i<3;i++)
3178                   fCheckIDTrigPtLambda->Fill(difNegP[i],i+3,pt);
3179                 fCheckIDTrigPhiLambda->Fill(negDeltaPhi,2.,pt);
3180                 fCheckIDTrigEtaLambda->Fill(negDeltaEta,2.,pt);
3181                 fCheckIDTrigNclsLambda->Fill(nClsTPCNeg,2.,pt);
3182               }
3183
3184             } // End check ID
3185
3186             fTriggerParticles->RemoveAt(iArray);
3187             fTriggerParticles->AddAt( new AliMiniParticle(centrality, zv, idTrig, ptTrig, phiTrig, etaTrig, 0, 0, 0), iArray);
3188
3189           } // Close isTrigFromV0daug
3190
3191         } // End Lambda Mass cut
3192         break; // End Lambda selection for TriggerCheck
3193       case kReconstruction:
3194
3195         if( (dcaPos > 0.1) && (dcaNeg > 0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) && (pt<10.) ){
3196
3197           if(isNaturalPart) fLambdaMass->Fill(massLambda,pt,centrality);
3198           else  fLambdaMassEmbeded->Fill(massLambda,pt,centrality);
3199
3200           if( !isCandidate2K0s && !isCandidate2LambdaBar){
3201             if(isNaturalPart) fLambdaMass2->Fill(massLambda,pt,centrality);
3202             else fLambdaMass2Embeded->Fill(massLambda,pt,centrality);
3203           }
3204
3205           fLambdaMassPtEta->Fill(massLambda,pt,lEta);
3206           fLambdaMassPtRap[curCentBin]->Fill(massLambda,pt,rapLambda);
3207           fLambdaMassPtPhi->Fill(massLambda,pt,lPhi);
3208
3209
3210           if( (pt>kPtBinV0[0]) && (pt<kPtBinV0[kN1]) && isNaturalPart )
3211             fAssocParticles->Add( new AliMiniParticle(centrality, zv, iV0, pt, lPhi, lEta, lMCAssocNegDaug, lMCAssocPosDaug, 4) );
3212
3213
3214         }
3215
3216         // Invariant Mass cut
3217         if(fDoQA && lCheckMcLambda && isNaturalPart && (pt<10.)){ // Quality Assurance
3218
3219           // Invariant Mass cut
3220           if (TMath::Abs(mLambda-massLambda) < 3*sL) {
3221
3222             if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3223               fLambdaDCAPosDaug->Fill(dcaPos,pt);
3224               fLambdaDCANegDaug->Fill(dcaNeg,pt);
3225             }
3226
3227             if( (dcaPos > 0.1) && (dcaNeg > 0.1) ){
3228
3229               if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3230                 fLambdaPtPosDaug->Fill(pt,lPtPos);
3231                 fLambdaPtNegDaug->Fill(pt,lPtNeg);
3232
3233                 fLambdaPhiEtaPosDaug->Fill(phiPos,etaPos,pt);
3234                 fLambdaPhiEtaNegDaug->Fill(phiNeg,etaNeg,pt);
3235
3236                 fLambdaDecayPos->Fill(dx,dy,pt);
3237                 fLambdaDecayVertex->Fill(lt,pt);
3238
3239                 fLambdaCPA->Fill(cpa,pt);
3240                 fLambdaDCAV0Daug->Fill(dca,pt);
3241
3242                 fLambdaNClustersITSPos->Fill(phiPos,posITSNcls,pt);
3243                 fLambdaNClustersITSNeg->Fill(phiNeg,negITSNcls,pt);
3244               }
3245
3246               fLambdaNClustersTPC->Fill(phiPos,nClsTPCPos,pt);
3247               fLambdaNClustersTPC->Fill(phiNeg,nClsTPCNeg,-pt);
3248
3249             }
3250
3251           } // End selection in mass
3252
3253           if( (TMath::Abs(mLambda-massLambda + 6.5*sL) < 1.5*sL) ||
3254               (TMath::Abs(mLambda-massLambda - 6.5*sL) < 1.5*sL) ){
3255
3256             if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3257               fLambdaBckgDCAPosDaug->Fill(dcaPos,pt);
3258               fLambdaBckgDCANegDaug->Fill(dcaNeg,pt);
3259             }
3260
3261             if( (dcaPos > 0.1) && (dcaNeg > 0.1) ){
3262
3263               if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3264                 fLambdaBckgPtPosDaug->Fill(pt,lPtPos);
3265                 fLambdaBckgPtNegDaug->Fill(pt,lPtNeg);
3266
3267                 fLambdaBckgPhiEtaPosDaug->Fill(phiPos,etaPos,pt);
3268                 fLambdaBckgPhiEtaNegDaug->Fill(phiNeg,etaNeg,pt);
3269
3270                 fLambdaBckgDecayPos->Fill(dx,dy,pt);
3271                 fLambdaBckgDecayVertex->Fill(lt,pt);
3272
3273                 fLambdaBckgCPA->Fill(cpa,pt);
3274                 fLambdaBckgDCAV0Daug->Fill(dca,pt);
3275
3276                 fLambdaBckgNClustersITSPos->Fill(phiPos,posITSNcls,pt);
3277                 fLambdaBckgNClustersITSNeg->Fill(phiNeg,negITSNcls,pt);
3278               }
3279
3280               fLambdaBckgNClustersTPC->Fill(phiPos,nClsTPCPos,pt);
3281               fLambdaBckgNClustersTPC->Fill(phiNeg,nClsTPCNeg,-pt);
3282             }
3283
3284           }// End selection in outside the mass cut
3285
3286         } // End QA
3287
3288         break; // End Lambda selection for Correlation
3289       default:
3290         Printf(" Selection of 'step' is not set properly");
3291         break;
3292
3293       }// End switch
3294
3295     } // End Lambda selection
3296
3297     // *******************
3298     // AntiLambda selection
3299     // *******************
3300     if ( ctAL && (TMath::Abs(rapLambda)<fYMax)  && (massAntiLambda > 1.0649 && massAntiLambda < 1.1651 ) && (TMath::Abs(nsigNegProton)<fNSigma) ) {
3301
3302       switch(step) {
3303       case kTriggerCheck:
3304
3305         if (isCandidate2LambdaBar && (dcaPos>0.1) && (dcaNeg>0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) &&  !isCandidate2K0s && !isCandidate2Lambda ){
3306
3307           if(pt>ptTrig) {
3308             fIsV0LP = 1;
3309             fPtV0LP = pt;
3310           }
3311
3312           if( isSameTrkPosDaug==1 || isSameTrkNegDaug==1 ){
3313             Printf("  The LP has the same momentum in X and Y as one of the AntiLambda daughters *** iV0 %d",iV0);
3314
3315             if(fCheckIDTrig){  // Compare properties of daughters nad
3316               Float_t difNegP[3];
3317               difNegP[0] = (pTrig[0]-pNegDaug[0])/pTrig[0];  difNegP[1] = (pTrig[1]-pNegDaug[1])/pTrig[1]; difNegP[2] = (pTrig[2]-pNegDaug[2])/pTrig[2];
3318               Float_t difPosP[3];
3319               difPosP[0] = (pTrig[0]-pPosDaug[0])/pTrig[0];  difPosP[1] = (pTrig[1]-pPosDaug[1])/pTrig[1]; difPosP[2] = (pTrig[2]-pPosDaug[2])/pTrig[2];
3320               Float_t posDeltaPhi =  phiTrig - phiPos, negDeltaPhi =  phiTrig - phiNeg;
3321               Float_t posDeltaEta =  etaTrig - etaPos, negDeltaEta =  etaTrig - etaNeg;
3322
3323               /*
3324                 Printf("  The LP has the same momentum in X and Y as one of the AntiLambda daughters *** iV0 %d \n\t\t %d %d %d \n\t\t %lf %lf %lf \n\t\t %lf %lf %lf \n\t\t %lf %lf \n\t\t %lf %lf ",
3325                 iV0, TMath::Abs( trkTrig->GetID() ), ntrack->GetID() ,  ptrack->GetID() ,
3326                 TMath::Abs( difNegP[1] ), TMath::Abs( difNegP[2] ), TMath::Abs( difNegP[0] ),
3327                 TMath::Abs( difPosP[1] ), TMath::Abs( difPosP[2] ), TMath::Abs( difPosP[0] ),
3328                 TMath::Abs( negDeltaPhi ), TMath::Abs( negDeltaEta ),
3329                 TMath::Abs( posDeltaPhi ), TMath::Abs( posDeltaEta )
3330                 );
3331               */
3332
3333               // Positive daughter
3334               if( isSameTrkPosDaug==1 ){
3335                 for(Int_t i=0;i<3;i++)
3336                   fCheckIDTrigPtAntiLambda->Fill(difPosP[i],i,pt);
3337                 fCheckIDTrigPhiAntiLambda->Fill(posDeltaPhi,0.,pt);
3338                 fCheckIDTrigEtaAntiLambda->Fill(posDeltaEta,0.,pt);
3339                 fCheckIDTrigNclsAntiLambda->Fill(nClsTPCPos,0.,pt);
3340               }
3341               // Negative daughter
3342               if( isSameTrkNegDaug==1 ){
3343                 for(Int_t i=0;i<3;i++)
3344                   fCheckIDTrigPtAntiLambda->Fill(difNegP[i],i+3,pt);
3345                 fCheckIDTrigPhiAntiLambda->Fill(negDeltaPhi,2.,pt);
3346                 fCheckIDTrigEtaAntiLambda->Fill(negDeltaEta,2.,pt);
3347                 fCheckIDTrigNclsAntiLambda->Fill(nClsTPCNeg,2.,pt);
3348               }
3349
3350             } // End check ID
3351
3352
3353             fTriggerParticles->RemoveAt(iArray);
3354             fTriggerParticles->AddAt( new AliMiniParticle(centrality, zv, idTrig, ptTrig, phiTrig, etaTrig, 0, 0, 0), iArray);
3355
3356           }// Close isTrigFromV0daug
3357
3358         }// End AntiLambda Mass cut
3359         break; // End AntiLambda selection for CheckTrigger
3360       case kReconstruction:
3361
3362         if( (dcaPos > 0.1) && (dcaNeg > 0.1) && (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) && (pt<10.) ) {
3363
3364           if(isNaturalPart)  fAntiLambdaMass->Fill(massAntiLambda,pt,centrality);
3365           else fAntiLambdaMassEmbeded->Fill(massAntiLambda,pt,centrality);
3366
3367           if( !isCandidate2K0s && !isCandidate2Lambda) {
3368             if(isNaturalPart) fAntiLambdaMass2->Fill(massAntiLambda,pt,centrality);
3369             else fAntiLambdaMass2Embeded->Fill(massAntiLambda,pt,centrality);
3370           }
3371
3372           fAntiLambdaMassPtEta->Fill(massAntiLambda,pt,lEta);
3373           fAntiLambdaMassPtRap[curCentBin]->Fill(massAntiLambda,pt,rapLambda);
3374           fAntiLambdaMassPtPhi->Fill(massAntiLambda,pt,lPhi);
3375
3376
3377           if( (pt>kPtBinV0[0]) && (pt<kPtBinV0[kN1]) && isNaturalPart )
3378             fAssocParticles->Add( new AliMiniParticle(centrality, zv, iV0, pt, lPhi, lEta, lMCAssocNegDaug, lMCAssocPosDaug, 5) );
3379
3380
3381         }
3382
3383         if( fDoQA && lCheckMcAntiLambda && isNaturalPart && (pt<10.) ){ // Quality Assurance
3384
3385           // Invariant Mass cut
3386           if (TMath::Abs(mLambda-massAntiLambda) < 3*sAL) {
3387
3388             if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3389               fAntiLambdaDCAPosDaug->Fill(dcaPos,pt);
3390               fAntiLambdaDCANegDaug->Fill(dcaNeg,pt);
3391             }
3392
3393             if( (dcaPos>0.1) && (dcaNeg>0.1) ){
3394
3395               if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3396                   fAntiLambdaPtPosDaug->Fill(pt,lPtPos);
3397                   fAntiLambdaPtNegDaug->Fill(pt,lPtNeg);
3398
3399                   fAntiLambdaPhiEtaPosDaug->Fill(phiPos,etaPos,pt);
3400                   fAntiLambdaPhiEtaNegDaug->Fill(phiNeg,etaNeg,pt);
3401
3402                   fAntiLambdaDecayPos->Fill(dx,dy,pt);
3403                   fAntiLambdaDecayVertex->Fill(lt,pt);
3404
3405                   fAntiLambdaCPA->Fill(cpa,pt);
3406                   fAntiLambdaDCAV0Daug->Fill(dca,pt);
3407
3408                   fAntiLambdaNClustersITSPos->Fill(phiPos,posITSNcls,pt);
3409                   fAntiLambdaNClustersITSNeg->Fill(phiNeg,negITSNcls,pt);
3410                 }
3411
3412               fAntiLambdaNClustersTPC->Fill(phiPos,nClsTPCPos,pt);
3413               fAntiLambdaNClustersTPC->Fill(phiNeg,nClsTPCNeg,-pt);
3414             }
3415
3416           } // End selection in mass
3417
3418           if( (TMath::Abs(mLambda-massAntiLambda + 6.5*sAL) < 1.5*sAL) ||
3419               (TMath::Abs(mLambda-massAntiLambda - 6.5*sAL) < 1.5*sAL) ){
3420
3421             if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3422               fAntiLambdaBckgDCAPosDaug->Fill(dcaPos,pt);
3423               fAntiLambdaBckgDCANegDaug->Fill(dcaNeg,pt);
3424             }
3425
3426             if( (dcaPos>0.1) && (dcaNeg>0.1) ){
3427
3428               if( (nClsTPCPos>fDaugNClsTPC) && (nClsTPCNeg>fDaugNClsTPC) ){
3429                 fAntiLambdaBckgPtPosDaug->Fill(pt,lPtPos);
3430                 fAntiLambdaBckgPtNegDaug->Fill(pt,lPtNeg);
3431
3432                 fAntiLambdaBckgPhiEtaPosDaug->Fill(phiPos,etaPos,pt);
3433                 fAntiLambdaBckgPhiEtaNegDaug->Fill(phiNeg,etaNeg,pt);
3434
3435                 fAntiLambdaBckgDecayPos->Fill(dx,dy,pt);
3436                 fAntiLambdaBckgDecayVertex->Fill(lt,pt);
3437
3438                 fAntiLambdaBckgCPA->Fill(cpa,pt);
3439                 fAntiLambdaBckgDCAV0Daug->Fill(dca,pt);
3440
3441                 fAntiLambdaBckgNClustersITSPos->Fill(phiPos,posITSNcls,pt);
3442                 fAntiLambdaBckgNClustersITSNeg->Fill(phiNeg,negITSNcls,pt);
3443               }
3444
3445               fAntiLambdaBckgNClustersTPC->Fill(phiPos,nClsTPCPos,pt);
3446               fAntiLambdaBckgNClustersTPC->Fill(phiNeg,nClsTPCNeg,-pt);
3447
3448             }
3449
3450           }// End selection in outside the mass cut
3451
3452         } // End QA
3453
3454         break;
3455       default:
3456         Printf( " Selection of 'step' is not set properly");
3457         break;
3458       }// End switch
3459
3460     } // End AntiLambda selection
3461
3462   } // End V0 loop
3463
3464 }
3465
3466 //___________________________________________________________________________________________
3467
3468 void AliAnalysisTaskLambdaOverK0sJets::TriggerParticle()
3469 {
3470   // Obtain the trigger particles of the event to perform the correlations in phi and eta
3471
3472   // ----------------------------
3473   // 1. Trigger particles
3474   TClonesArray *stack = 0x0;
3475   if(fIsMC){
3476     TList *lst = fAOD->GetList();
3477     stack = (TClonesArray*)lst->FindObject(AliAODMCParticle::StdBranchName());
3478     if (!stack) {
3479       Printf("ERROR: stack not available");
3480       return;
3481     }
3482   }
3483
3484   Int_t nTrk= fAOD->GetNumberOfTracks();
3485   AliCentrality *cent = fAOD->GetCentrality();
3486   Float_t centrality = cent->GetCentralityPercentile("V0M");
3487   const AliAODVertex *vtx = fAOD->GetPrimaryVertex();
3488   Float_t zv=vtx->GetZ();
3489   Double_t pt  = -1000.;
3490   Double_t eta = -1000.;
3491   Double_t phi = -1000.;
3492   Float_t resPt = -1000.;
3493   Float_t resEta = -1000.;
3494   Float_t resPhi = -1000.;
3495
3496   for (Int_t i=0; i<nTrk; i++) {
3497     AliAODTrack *t = fAOD->GetTrack(i);
3498     if(!AcceptTrack(t)) continue;
3499     pt=t->Pt();
3500     eta=t->Eta();
3501
3502     if( (pt>fTrigPtMin)  && (pt<fTrigPtMax) &&  (TMath::Abs(eta)<fTrigEtaMax) ) {
3503
3504       phi=t->Phi();
3505       fTriggerParticles->Add( new AliMiniParticle(centrality, zv, i, pt, phi, eta, 0, 0, 1) );
3506
3507       if(fIsMC){
3508         Int_t lab = TMath::Abs(t->GetLabel());
3509         AliAODMCParticle *part=(AliAODMCParticle*)stack->UncheckedAt(lab);
3510
3511         resPt  = (part->Pt()  - pt)/pt;
3512         resEta = part->Eta() - eta;
3513         resPhi = part->Phi() - phi;
3514
3515         fTriggerMCResPt->Fill(resPt,pt,centrality);
3516         fTriggerMCResEta->Fill(resEta,pt,centrality);
3517         fTriggerMCResPhi->Fill(resPhi,pt,centrality);
3518       }
3519
3520     }
3521   }
3522
3523   // ----------------------------
3524   // 2. Checking if the trigger particle
3525   // might be a daughter from the V0-candidate
3526
3527   for (Int_t i=0; i<(fTriggerParticles->GetEntriesFast()); i++){
3528     AliMiniParticle* trig = (AliMiniParticle*) fTriggerParticles->At(i);
3529     Int_t id = trig->ID();
3530     V0Loop(kTriggerCheck,kFALSE,i,id);
3531   }
3532
3533
3534 }
3535
3536 //___________________________________________________________________________________________
3537
3538 void AliAnalysisTaskLambdaOverK0sJets::UserExec(Option_t *)
3539 {
3540   // Main loop for the Analysis
3541
3542   // Initializing global variables for the correlation studies (mandatory for each event).
3543   // ---- 1) Trigger Particle: id track
3544   fIdTrigger  = -1;
3545   // ---- 2) TriggerCheck: Variables used to crosscheck if trigger particle is a V0 daughter ---- //
3546   fIsV0LP     = 0;
3547   fPtV0LP     = -10.;
3548   fIsSndCheck = 0;
3549
3550   // Getting AOD Event
3551   fAOD = (AliAODEvent *)InputEvent();
3552   fEvents->Fill(0); //event counter
3553
3554   if (!fAOD) {
3555     Printf("ERROR: aod not available");
3556     return;
3557   }
3558   fEvents->Fill(1);
3559
3560   // Physics selection
3561   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
3562   AliInputEventHandler *hdr=(AliInputEventHandler*)mgr->GetInputEventHandler();
3563   UInt_t maskIsSelected = hdr->IsEventSelected();
3564   Bool_t isSelected = kFALSE;
3565
3566   Bool_t isSelectedCentral     = kFALSE;
3567   Bool_t isSelectedSemiCentral = kFALSE;
3568   Bool_t isSelectedMB          = kFALSE;
3569   if( fCollision.Contains("PbPb2010") )
3570     isSelected = (maskIsSelected & AliVEvent::kMB);
3571   else if( fCollision.Contains("PbPb2011") ){
3572     isSelectedCentral   =  maskIsSelected  &  AliVEvent::kCentral;
3573     isSelectedSemiCentral   =  maskIsSelected  &  AliVEvent::kSemiCentral;
3574     isSelectedMB   =  maskIsSelected   &  AliVEvent::kMB;
3575     if( isSelectedCentral || isSelectedSemiCentral || isSelectedMB )    isSelected = kTRUE;
3576   }
3577
3578   if(!isSelected) return;
3579   fEvents->Fill(2);
3580
3581   // Centrality selection
3582   AliCentrality *cent = fAOD->GetCentrality();
3583   Float_t centrality = cent->GetCentralityPercentile("V0M");
3584   fCentrality->Fill(centrality);
3585
3586   if (!cent->IsEventInCentralityClass(fCentMin,fCentMax,"V0M")) return;
3587   fEvents->Fill(3);
3588
3589   // Global primary vertex
3590   const AliAODVertex *vtx = fAOD->GetPrimaryVertex();
3591   if (vtx->GetNContributors()<3) return;
3592   fEvents->Fill(4);
3593
3594   // SPD primary vertex
3595   const AliAODVertex *vtxSPD = fAOD->GetPrimaryVertexSPD();
3596   if (vtxSPD->GetNContributors()<3) return;
3597   fEvents->Fill(5);
3598
3599   // Correlaiton between global Zvtx and SPD Zvtx
3600   Float_t zv=vtx->GetZ(), zvSPD=vtxSPD->GetZ();
3601   fPrimayVtxGlobalvsSPD->Fill(zv,zvSPD);
3602
3603   if( TMath::Abs( zv - zvSPD ) > 0.5) return;
3604   fEvents->Fill(6);
3605
3606   Float_t xv=vtx->GetX(), yv=vtx->GetY();
3607
3608   if (TMath::Abs(zv) > 10.) return;
3609   fEvents->Fill(7);
3610
3611   fPrimaryVertexX->Fill(xv);
3612   fPrimaryVertexY->Fill(yv);
3613   fPrimaryVertexZ->Fill(zv);
3614
3615   fCentrality2->Fill(centrality);
3616
3617   if(isSelectedCentral) fCentralityTrig->Fill(centrality,1);
3618   if(isSelectedSemiCentral) fCentralityTrig->Fill(centrality,2);
3619   if(isSelectedMB) fCentralityTrig->Fill(centrality,3);
3620
3621
3622   // Protect the code: only interested in events with centrality < 40%
3623   if(centrality>=40.) return;
3624
3625   //  Event plane
3626   AliEventplane *EventPlane = InputEvent()->GetEventplane();
3627   Double_t eventPlane = EventPlane->GetEventplane("V0",InputEvent(),2);
3628
3629   eventPlane = ( (eventPlane < 0) ? eventPlane + TMath::Pi() : eventPlane );
3630   eventPlane = ( ( eventPlane > TMath::Pi() ) ? eventPlane - TMath::Pi() : eventPlane );
3631
3632   // Getting PID Response
3633   fPIDResponse = hdr->GetPIDResponse();
3634
3635   Int_t curVtxBin = VtxBin(zv);
3636   Int_t curCentBin = CentBin(centrality);
3637
3638   // **********************************************
3639   // Triggered Particle -  Trigger Particle
3640   fTriggerParticles = new TObjArray();
3641   fTriggerParticles->SetOwner(kTRUE);
3642   TriggerParticle();
3643
3644   // V0-candidate is the highest particle in the event:
3645   if(fIsV0LP) { fEvents->Fill(8); fTriggerIsV0->Fill(fPtV0LP);}
3646
3647   Int_t NtrigPerEvnt = 0;
3648   Float_t phi2 = -100.;
3649   for (Int_t i=0; i<(fTriggerParticles->GetEntriesFast()); i++){
3650     AliMiniParticle* trig = (AliMiniParticle*) fTriggerParticles->At(i);
3651
3652     if(trig->WhichCandidate()==0){
3653       fTriggerComingFromDaug->Fill(trig->Pt());
3654       fCheckTriggerFromV0Daug->Fill(1);
3655       fTriggerPtCentCh->Fill(trig->Pt(),centrality,zv);
3656       if(fIsV0LP)  fCheckTriggerFromV0Daug->Fill(2);
3657     }
3658     else if( trig->WhichCandidate()==1){
3659       fTriggerEtaPhi->Fill(trig->Phi(),trig->Eta());
3660       fTriggerPtCent->Fill(trig->Pt(),centrality,zv);
3661       fTriggerPtCentCh->Fill(trig->Pt(),centrality,zv);
3662       fCheckTriggerFromV0Daug->Fill(0);
3663
3664       phi2 = ( (trig->Phi() > TMath::Pi()) ? trig->Phi() - TMath::Pi() : trig->Phi() )  ;
3665       fTriggerEventPlane->Fill(phi2);
3666
3667       NtrigPerEvnt++;
3668
3669     }
3670
3671   }
3672
3673   if(NtrigPerEvnt>0) fEvents->Fill(11);
3674   else fEvents->Fill(12);
3675
3676   fNTrigPerEvt->Fill(NtrigPerEvnt,centrality);
3677
3678   // ******************************************
3679   // Start loop over MC particles
3680   fTriggerPartMC = new TObjArray();
3681   fTriggerPartMC->SetOwner(kTRUE);
3682   fAssocPartMC = new TObjArray();
3683   fAssocPartMC->SetOwner(kTRUE);
3684
3685   fEndOfHijingEvent = -1;
3686   TClonesArray *stack = 0x0;
3687   Float_t mcXv=0., mcYv=0., mcZv=0.;
3688
3689   if(fIsMC) {
3690
3691     TList *lst = fAOD->GetList();
3692     stack = (TClonesArray*)lst->FindObject(AliAODMCParticle::StdBranchName());
3693     if (!stack) {
3694       Printf("ERROR: stack not available");
3695       return;
3696     }
3697
3698     AliAODMCHeader *mcHdr =
3699       (AliAODMCHeader*)lst->FindObject(AliAODMCHeader::StdBranchName());
3700
3701     mcXv=mcHdr->GetVtxX(); mcYv=mcHdr->GetVtxY(); mcZv=mcHdr->GetVtxZ();
3702
3703     Int_t nTrkMC = stack->GetEntriesFast();
3704     // -----------------------------------------
3705     // --------- Trigger particle --------------
3706     // -----------------------------------------
3707     for (Int_t iTrkMC = 0; iTrkMC < nTrkMC; iTrkMC++){
3708       AliAODMCParticle *p0 = (AliAODMCParticle*)stack->At(iTrkMC);
3709       if(!p0) continue;
3710
3711       // ----------------------------------------
3712       // For injected MC: it determines where HIJING event ends
3713       if (fEndOfHijingEvent==-1) {
3714         if ( ( p0->GetStatus() == 21 ) ||
3715              ( (p0->GetPdgCode() == 443) &&
3716                (p0->GetMother() == -1)   &&
3717                (p0->GetDaughter(0) ==  (iTrkMC+1))) ) {
3718           fEndOfHijingEvent = iTrkMC;
3719         }
3720       }
3721
3722       // ----------------------------------------
3723       Int_t isNaturalPart = 1;
3724       if ( (iTrkMC>=fEndOfHijingEvent) &&
3725            (fEndOfHijingEvent!=-1)     &&
3726            (p0->GetMother()<0) )
3727         isNaturalPart = 0;
3728
3729       // ----------------------------------------
3730       if(p0->Charge()==0) continue;
3731       if(isNaturalPart == 0) continue;
3732       if( !p0->IsPhysicalPrimary() ) continue;
3733
3734       if(TMath::Abs(p0->Eta())>fTrigEtaMax) continue;
3735       if( ( p0->Pt() < fTrigPtMCMin )  || ( p0->Pt() > fTrigPtMCMax ) ) continue;
3736
3737       fTriggerPartMC->Add( new AliMiniParticle(centrality, zv, iTrkMC, p0->Pt(), p0->Phi(), p0->Eta(), 0, 0, 1) );
3738
3739     } // End loop over charged particles
3740
3741     // -----------------------------------------
3742     // ---------- Strange particles ------------
3743     // -----------------------------------------
3744     //fEndOfHijingEvent = -1;
3745     for (Int_t iTrkMC = 0; iTrkMC < nTrkMC; iTrkMC++){
3746       AliAODMCParticle *p0 = (AliAODMCParticle*)stack->At(iTrkMC);
3747       if(!p0) continue;
3748
3749       // ----------------------------------------
3750       Int_t lPdgcodeCurrentPart = p0->GetPdgCode();
3751       if ( (lPdgcodeCurrentPart != kK0Short) &&
3752            (lPdgcodeCurrentPart != kLambda0) &&
3753            (lPdgcodeCurrentPart != kLambda0Bar) &&
3754            //Adding Xi- and Xi0 particles
3755            (lPdgcodeCurrentPart != kXiMinus) &&
3756            (lPdgcodeCurrentPart != 3322) ) continue;
3757
3758       // ----------------------------------------
3759       Int_t isNaturalPart = 1;
3760       if ( (iTrkMC>=fEndOfHijingEvent) &&
3761            (fEndOfHijingEvent!=-1)     &&
3762            (p0->GetMother()<0) )
3763         isNaturalPart = 0;
3764
3765       if( lPdgcodeCurrentPart != kXiMinus )
3766         fInjectedParticles->Fill(isNaturalPart);
3767
3768       if(fSeparateInjPart && !isNaturalPart) continue;
3769
3770       // ----------------------------------------
3771       Float_t lRapCurrentPart = MyRapidity(p0->E(),p0->Pz());
3772       Float_t lEtaCurrentPart = p0->Eta();
3773       Float_t lPhiCurrentPart = p0->Phi();
3774       Float_t lPtCurrentPart  = p0->Pt();
3775
3776       if(fUseEtaCut){
3777         lRapCurrentPart = lEtaCurrentPart;
3778       }
3779
3780       Int_t iCurrentMother = p0->GetMother();
3781       AliAODMCParticle *pCurrentMother = (AliAODMCParticle *)stack->At(iCurrentMother);
3782       Int_t lPdgCurrentMother = 0;
3783       if (iCurrentMother == -1) { lPdgCurrentMother = 0;}
3784       else { lPdgCurrentMother = pCurrentMother->GetPdgCode(); }
3785
3786       Int_t id0  = p0->GetDaughter(0);
3787       Int_t id1  = p0->GetDaughter(1);
3788
3789       //if ( id0 ==  id1 ) continue;
3790       if ( (id0 < 0 || id1 < 0) ||
3791            (id0 >=nTrkMC  || id1 >= nTrkMC) ) continue;
3792
3793       AliAODMCParticle *pDaughter0 = (AliAODMCParticle *)stack->UncheckedAt(id0);
3794       AliAODMCParticle *pDaughter1 = (AliAODMCParticle *)stack->UncheckedAt(id1);
3795       if (!pDaughter0 || !pDaughter1) continue;
3796
3797       /*
3798       if ( TMath::Abs(pDaughter0->Eta()) > fMaxEtaDaughter ||
3799            TMath::Abs(pDaughter1->Eta()) > fMaxEtaDaughter )
3800         continue;
3801       */
3802       // Daughter momentum cut: ! FIX it in case of AOD !
3803       /*
3804       if ( ( pDaughter0->Pt() < fMinPtDaughter ) ||
3805            ( pDaughter1->Pt() < fMinPtDaughter )  )
3806            continue;
3807       */
3808
3809       if ((p0->Pt())<pMin || (p0->Pt())>100. ) continue;
3810       if (TMath::Abs(lRapCurrentPart) > fYMax)  continue;
3811
3812       Float_t dx = mcXv-p0->Xv(),  dy = mcYv-p0->Yv(),  dz = mcZv-p0->Zv();
3813       Float_t l = TMath::Sqrt(dx*dx + dy*dy + dz*dz);
3814
3815       //Cut in the 3D-distance of the secondary vertex to primary vertex
3816       if (l > 0.01) continue; // secondary V0
3817
3818       //Transverse distance to vertex
3819       dx = mcXv-pDaughter0->Xv(); dy = mcYv-pDaughter0->Yv();
3820       //Float_t lt=TMath::Sqrt(dx*dx + dy*dy);
3821
3822       // Pt Selection
3823       if((p0->Pt())<10.) {
3824
3825         // K0s
3826         if (lPdgcodeCurrentPart == kK0Short) {
3827
3828
3829           fK0sMCPt->Fill(lPtCurrentPart);
3830           fK0sMCPtRap->Fill(lPtCurrentPart,lRapCurrentPart,centrality);
3831
3832           if(isNaturalPart){
3833             fK0sMCPtRap2->Fill(lPtCurrentPart,lRapCurrentPart,centrality);
3834             fK0sMCPtPhiEta[curCentBin]->Fill(lPhiCurrentPart,lEtaCurrentPart,lPtCurrentPart);
3835
3836             if(TMath::Abs(lRapCurrentPart)<fYMax)  fK0sMCPtRapVtx[curCentBin]->Fill(lPtCurrentPart,lRapCurrentPart,zv);
3837
3838             if( (lPtCurrentPart>kPtBinV0[0]) && (lPtCurrentPart<kPtBinV0[kN1]) && isNaturalPart )
3839               fAssocPartMC->Add( new AliMiniParticle(centrality, zv, iTrkMC, lPtCurrentPart, lPhiCurrentPart, lEtaCurrentPart, 0, 0, 3) );
3840           }
3841           else{
3842             fK0sMCPtRapEmbeded->Fill(lPtCurrentPart,lRapCurrentPart,centrality);
3843             if(TMath::Abs(lRapCurrentPart)<fYMax)  fK0sMCPtRapVtxEmbeded[curCentBin]->Fill(lPtCurrentPart,lRapCurrentPart,zv);
3844           }
3845
3846         } // End K0s selection
3847         // Lambda
3848         if (lPdgcodeCurrentPart == kLambda0) {
3849
3850           fLambdaMCPt->Fill(lPtCurrentPart);
3851           fLambdaMCPtRap->Fill(lPtCurrentPart,lRapCurrentPart,centrality);
3852
3853           if(isNaturalPart){
3854             fLambdaMCPtRap2->Fill(lPtCurrentPart,lRapCurrentPart,centrality);
3855             fLambdaMCPtPhiEta[curCentBin]->Fill(lPhiCurrentPart,lEtaCurrentPart,lPtCurrentPart);
3856
3857             if(TMath::Abs(lRapCurrentPart)<fYMax) fLambdaMCPtRapVtx[curCentBin]->Fill(lPtCurrentPart,lRapCurrentPart,zv);
3858
3859             if( (lPtCurrentPart>kPtBinV0[0]) && (lPtCurrentPart<kPtBinV0[kN1]) && isNaturalPart )
3860               fAssocPartMC->Add( new AliMiniParticle(centrality, zv, iTrkMC, lPtCurrentPart, lPhiCurrentPart, lEtaCurrentPart, 0, 0, 4) );
3861           }
3862           else{
3863             fLambdaMCPtRapEmbeded->Fill(lPtCurrentPart,lRapCurrentPart,centrality);
3864             fLambdaMCPtRapVtxEmbeded[curCentBin]->Fill(lPtCurrentPart,lRapCurrentPart,zv);
3865           }
3866
3867           if ( isNaturalPart && TMath::Abs(lPdgCurrentMother) == 3312 )
3868             fLambdaMCFromXi->Fill(lPtCurrentPart,centrality);
3869
3870         } // End Lambda
3871         // AntiLambda
3872         if (lPdgcodeCurrentPart == kLambda0Bar) {
3873
3874           fAntiLambdaMCPt->Fill(lPtCurrentPart);
3875           fAntiLambdaMCPtRap->Fill(lPtCurrentPart,lRapCurrentPart,centrality);
3876
3877           if(isNaturalPart){
3878             fAntiLambdaMCPtRap2->Fill(lPtCurrentPart,lRapCurrentPart,centrality);
3879             fAntiLambdaMCPtPhiEta[curCentBin]->Fill(lPhiCurrentPart,lEtaCurrentPart,lPtCurrentPart);
3880
3881             if(TMath::Abs(lRapCurrentPart)<fYMax) fAntiLambdaMCPtRapVtx[curCentBin]->Fill(lPtCurrentPart,lRapCurrentPart,zv);
3882
3883             if( (lPtCurrentPart>kPtBinV0[0]) && (lPtCurrentPart<kPtBinV0[kN1]) && isNaturalPart )
3884               fAssocPartMC->Add( new AliMiniParticle(centrality, zv, iTrkMC, lPtCurrentPart, lPhiCurrentPart, lEtaCurrentPart, 0, 0, 5) );
3885           }
3886           else{
3887             fAntiLambdaMCPtRapEmbeded->Fill(lPtCurrentPart,lRapCurrentPart,centrality);
3888             if(TMath::Abs(lRapCurrentPart)<fYMax) fAntiLambdaMCPtRapVtxEmbeded[curCentBin]->Fill(lPtCurrentPart,lRapCurrentPart,zv);
3889           }
3890
3891           if ( isNaturalPart && TMath::Abs(lPdgCurrentMother) == 3312 )
3892             fAntiLambdaMCFromXi->Fill(lPtCurrentPart,centrality);
3893
3894         } // End AntiLambda
3895
3896       } // End pt selection
3897       // Xi-
3898       /*
3899       if(lPdgcodeCurrentPart == kXiMinus || lPdgcodeCurrentPart == 3322){
3900
3901         if( isNaturalPart )
3902           fAssocPartMC->Add( new AliMiniParticle(centrality, zv, iTrkMC, lPtCurrentPart, lPhiCurrentPart, lEtaCurrentPart, 0, 0, 6) );
3903
3904       } //End Xi
3905      */
3906
3907     } // End loop over MC
3908
3909     // -----------------------------------------
3910     // ---------- MC Correlations --------------
3911     // -----------------------------------------
3912
3913     Float_t triggerMCPt   = -1000.;
3914     Float_t triggerMCPhi  = -1000.;
3915     Float_t triggerMCEta  = -1000.;
3916
3917     Float_t dPhiMC = -100.;
3918     Float_t dEtaMC = -100.;
3919
3920     for(Int_t ii=0; ii<(fTriggerPartMC->GetEntriesFast()); ii++){
3921       AliMiniParticle* trigMC = (AliMiniParticle*) fTriggerPartMC->At(ii);
3922
3923       triggerMCPt  = trigMC->Pt();
3924       triggerMCPhi = trigMC->Phi();
3925       triggerMCEta = trigMC->Eta();
3926
3927       fTriggerMCPtCent->Fill(triggerMCPt,centrality);
3928
3929       for(Int_t jj=0; jj<(fAssocPartMC->GetEntriesFast()); jj++){
3930
3931         AliMiniParticle* assocMC = (AliMiniParticle*) fAssocPartMC->At(jj);
3932         if(assocMC->Pt()>triggerMCPt) continue;
3933
3934         dPhiMC = dPHI(triggerMCPhi,assocMC->Phi());
3935         dEtaMC = triggerMCEta - assocMC->Eta();
3936
3937         // K0s, Lambdas and AntiLambdas (h-V0 correlations)
3938         if( (triggerMCPt<fTrigPtMax) && ( (assocMC->WhichCandidate()==3) || (assocMC->WhichCandidate()==4) || (assocMC->WhichCandidate()==5) ) )
3939           for(Int_t k=0;k<kN1;k++)   // Pt bin
3940             if( (assocMC->Pt()>=kPtBinV0[k]) && (assocMC->Pt()<kPtBinV0[k+1]) ){
3941               if(assocMC->WhichCandidate()==3)
3942                 fK0sdPhidEtaMC[curCentBin*kN1+k]->Fill(dPhiMC,dEtaMC,zv);
3943               if(assocMC->WhichCandidate()==4)
3944                 fLambdadPhidEtaMC[curCentBin*kN1+k]->Fill(dPhiMC,dEtaMC,zv);
3945               if(assocMC->WhichCandidate()==5)
3946                 fAntiLambdadPhidEtaMC[curCentBin*kN1+k]->Fill(dPhiMC,dEtaMC,zv);
3947             } // End pt bin
3948
3949       } // End loop over trigger particles
3950
3951     } // End loop over trigger particles
3952
3953   } // End MC condition
3954
3955   // *************************************************
3956   // V0 loop - AOD
3957   fAssocParticles = new TObjArray();
3958   fAssocParticles->SetOwner(kTRUE);
3959   if(NtrigPerEvnt>0)
3960     V0Loop(kReconstruction,kTRUE,-1,-1);
3961   else
3962     V0Loop(kReconstruction,kFALSE,-1,-1);
3963
3964   //-------------------------------------------------------------
3965   // Correlations
3966   //-------------------------------------------------------------
3967   Float_t ptTrig=0., pxTrig=0., pyTrig=0.;
3968   Float_t massK0s=0., mK0s=0., sK0s=0.;
3969   Float_t massL=0.,   mL=0.,   sL=0.;
3970   Float_t massAL=0.; //,  mAL=0.,  sAL=0.;
3971   Float_t pt=-100., pxAssoc=-1000., pyAssoc=-1000.;
3972   Float_t lPhi=0., lEta=0.;
3973   Float_t lAlphaV0=0., lPtArmV0=0, dcaPos=0., dcaNeg=0.;
3974   Float_t dx=-100., dy=-100., lt=-100., res=-100.;
3975   Float_t dlK=-100., dlL=-100.;
3976   Float_t dPhi=-100., dEta=-100., radio=-100.;
3977   Bool_t  trigTPCMapOk=kTRUE, posDaugTPCMapOk=kTRUE, negDaugTPCMapOk=kTRUE;
3978   Float_t  fracPosDaugTPCMap =0., fracNegDaugTPCMap =0., den=1.;
3979   Double_t trigCov[21], posDaugCov[21], negDaugCov[21];
3980   Double_t trigPos[6], posDaugPos[6], negDaugPos[6];
3981   Double_t trigXYZ[3], posDaugXYZ[3], negDaugXYZ[3];
3982   Double_t devPosDaugTrig[7], devNegDaugTrig[7], splitCont[4];
3983
3984   // --------------------------------
3985   // h-V0 correlations
3986   for (Int_t i=0; i<(fTriggerParticles->GetEntriesFast()); i++){
3987     AliMiniParticle* trig = (AliMiniParticle*) fTriggerParticles->At(i);
3988     if( trig->WhichCandidate() == 0 ) continue;
3989
3990     AliAODTrack *tTrig = (AliAODTrack*)fAOD->GetTrack(trig->ID());
3991     ptTrig = tTrig->Pt();  pxTrig = tTrig->Px();  pyTrig = tTrig->Py();
3992
3993     for(Int_t j=0; j<fAssocParticles->GetEntriesFast(); j++){
3994       AliMiniParticle* trackAssocME = (AliMiniParticle*) (fAssocParticles->At(j));
3995       AliAODv0 *tAssoc=fAOD->GetV0(trackAssocME->ID());
3996       const AliAODTrack *ntrack=(AliAODTrack *)tAssoc->GetDaughter(1);
3997       const AliAODTrack *ptrack=(AliAODTrack *)tAssoc->GetDaughter(0);
3998
3999       if( SameTrack(tTrig,ntrack) || SameTrack(tTrig,ptrack) )
4000         continue;
4001
4002       if( ptTrig < trackAssocME->Pt() ) continue;
4003
4004       lPhi = trackAssocME->Phi();
4005       lEta = trackAssocME->Eta();
4006
4007       // Correlation in deltaPhi & deltaEta
4008       dPhi = dPHI(trig->Phi(),lPhi);
4009       dEta = trig->Eta() - lEta;
4010       radio    = TMath::Sqrt(dPhi*dPhi + dEta*dEta);
4011
4012       // Armenteros variables:
4013       lAlphaV0      =  tAssoc->AlphaV0();
4014       lPtArmV0      =  tAssoc->PtArmV0();
4015
4016       // 2D momentum
4017       pt = trackAssocME->Pt(); pxAssoc = tAssoc->Px(); pyAssoc = tAssoc->Py();
4018       // Decay vertex
4019       Double_t xyz[3]; tAssoc->GetSecondaryVtx(xyz);
4020       dx=xyz[0]-xv; dy=xyz[1]-yv; //dz=xyz[2]-zv;
4021       // Decay length: 2D
4022       lt=TMath::Sqrt(dx*dx + dy*dy);
4023       // Spatial resolution trigger-V0 point decay
4024       res = SpatialResolution(pxTrig,pyTrig,pxAssoc,pyAssoc,lt);
4025       // Ctau
4026       dlK = 0.4977*lt/pt;
4027       dlL = 1.1157*lt/pt;
4028
4029       Int_t binPtv0 = PtBin( pt );
4030       if(binPtv0==-1) continue;
4031
4032       Int_t lMCAssocNegDaug = trackAssocME->NegDaugMCLabel();
4033       Int_t lMCAssocPosDaug = trackAssocME->PosDaugMCLabel();
4034
4035       // ------------------------------------------
4036       // Track splitting check
4037       // ------------------------------------------
4038
4039       trigTPCMapOk=kTRUE; posDaugTPCMapOk=kTRUE; negDaugTPCMapOk=kTRUE;
4040       if(TMath::Abs(dPhi)<0.06 && TMath::Abs(dEta)<0.06){
4041
4042         // TPC Shared Map
4043         trigTPCMapOk    = GoodTPCSharedMap(tTrig);
4044         posDaugTPCMapOk = GoodTPCSharedMap(ptrack);
4045         negDaugTPCMapOk = GoodTPCSharedMap(ntrack);
4046
4047         // fraction of shared clusters
4048         //if(!trigTPCMapOk && !posDaugTPCMapOk) fracPosDaugTPCMap = GetFractionTPCSharedCls(tTrig,ptrack);
4049         //if(!trigTPCMapOk && !negDaugTPCMapOk) fracNegDaugTPCMap = GetFractionTPCSharedCls(tTrig,ntrack);
4050
4051         // get position
4052         tTrig->GetXYZ(trigXYZ);
4053         ptrack->GetXYZ(posDaugXYZ);
4054         ntrack->GetXYZ(negDaugXYZ);
4055
4056         // Covaraince matrix for the tracks
4057         tTrig->GetCovarianceXYZPxPyPz(trigCov);
4058         ptrack->GetCovarianceXYZPxPyPz(posDaugCov);
4059         ntrack->GetCovarianceXYZPxPyPz(negDaugCov);
4060
4061         // position and momentum
4062         // trigger particle
4063         trigPos[0] = trigXYZ[0];        trigPos[1] = trigXYZ[1];        trigPos[2] = trigXYZ[2];
4064         trigPos[3] = tTrig->Px();       trigPos[4] = tTrig->Py();       trigPos[5] = tTrig->Pz();
4065
4066         // positive daughter
4067         posDaugPos[0] = posDaugXYZ[0];  posDaugPos[1] = posDaugXYZ[1];  posDaugPos[2] = posDaugXYZ[2];
4068         posDaugPos[3] = ptrack->Px();   posDaugPos[4] = ptrack->Py();   posDaugPos[5] = ptrack->Pz();
4069
4070         // negative daughter
4071         negDaugPos[0] = negDaugXYZ[0];  negDaugPos[1] = negDaugXYZ[1];  negDaugPos[2] = negDaugXYZ[2];
4072         negDaugPos[3] = ntrack->Px();   negDaugPos[4] = ntrack->Py();   negDaugPos[5] = ntrack->Pz();
4073
4074
4075         // deviation between the two tracks
4076         for(Int_t ll=0;ll<6;ll++){
4077           den = trigCov[ll*(ll+1)/2+ll]*trigCov[ll*(ll+1)/2+ll]  +  posDaugCov[ll*(ll+1)/2+ll]* posDaugCov[ll*(ll+1)/2+ll] ;
4078           devPosDaugTrig[ll] = 0.;
4079
4080           if(den>0)  devPosDaugTrig[ll] = TMath::Power( trigPos[ll] - posDaugPos[ll] ,2) / den;
4081
4082           devPosDaugTrig[6] +=  devPosDaugTrig[ll];
4083         }
4084
4085
4086         for(Int_t ll=0;ll<6;ll++){
4087           den = trigCov[ll*(ll+1)/2+ll]*trigCov[ll*(ll+1)/2+ll]  +  negDaugCov[ll*(ll+1)/2+ll]* negDaugCov[ll*(ll+1)/2+ll] ;
4088           devNegDaugTrig[ll] = 0;
4089
4090           if(den>0)  devNegDaugTrig[ll] = TMath::Power( trigPos[ll] - negDaugPos[ll] ,2) / den;
4091
4092           devNegDaugTrig[6] +=  devNegDaugTrig[ll];
4093         }
4094
4095       }
4096
4097       // ----------------------------------------------------------------------------
4098
4099       // *******************
4100       //   K0s selection
4101       // *******************
4102       if( trackAssocME->WhichCandidate() == 3 ){
4103
4104         massK0s = tAssoc->MassK0Short();
4105         mK0s = TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass();
4106         if( fCollision.Contains("PbPb2010") )
4107           sK0s = kCteK0s2010[curCentBin] + kLinearK0s2010[curCentBin]*pt;
4108         else if( fCollision.Contains("PbPb2011") )
4109           sK0s = kCteK0s2011[curCentBin] + kLinearK0s2011[curCentBin]*pt;
4110
4111         // ==== Correlations K0s invariant mass peak ==== //
4112         // +++++++++++ Pt bin & centrality
4113         if(trigTPCMapOk && posDaugTPCMapOk && negDaugTPCMapOk) // splitting rejection according to the TPC shared map
4114           fK0sdPhidEtaPtL[curCentBin*kN1*kNVtxZ + binPtv0*kNVtxZ + curVtxBin]->Fill(dPhi,dEta,massK0s);
4115
4116         // ==== Correlations K0s invariant mass peak ==== //
4117         if (TMath::Abs(mK0s-massK0s) < 3*sK0s) {
4118
4119           // -------------- splitting checks ---------------
4120           if(TMath::Abs(dPhi)<0.06 && TMath::Abs(dEta)<0.06){
4121
4122             //// -------- TPC Map ------- ////
4123             if(!trigTPCMapOk && !posDaugTPCMapOk)
4124               fSharedClsTrigDaug->Fill(pt,ptrack->P(),0.5);
4125             if(!trigTPCMapOk && !negDaugTPCMapOk)
4126               fSharedClsTrigDaug->Fill(pt,ntrack->P(),1.5);
4127
4128             //// -------- Covariance matrix ------- ////
4129             // positive daughter
4130             splitCont[0] = pt;  splitCont[1] = ptrack->P();
4131             for(Int_t ll=0; ll<=6; ll++){
4132               splitCont[2] = devPosDaugTrig[ll]; splitCont[3] = ll;
4133               fK0sPosDaugSplCheckCovMat->Fill(splitCont);
4134             }
4135
4136             // negative daughter
4137             splitCont[0] = pt;  splitCont[1] = ntrack->P();
4138             for(Int_t ll=0; ll<=6; ll++){
4139               splitCont[2] = devNegDaugTrig[ll]; splitCont[3] = ll;
4140               fK0sNegDaugSplCheckCovMat->Fill(splitCont);
4141             }
4142
4143           }
4144
4145           // ----------------------------------------------
4146
4147           if(radio<0.1){
4148             fK0sSpatialRes->Fill(dPhi,res,lt);
4149           }
4150           if(radio < 0.4){
4151             fHistArmPodBckg->Fill(lAlphaV0,lPtArmV0,0);
4152             fK0sDCADaugToPrimVtx->Fill(dcaPos,dcaNeg,ptTrig);
4153             RecCascade(tTrig,ntrack,ptrack,"K0s");
4154             RecCascade(tTrig,ptrack,ntrack,"K0s");
4155           }
4156
4157
4158         }
4159         // ==== Correlations K0s background ==== //
4160         if( TMath::Abs(mK0s-massK0s + 6.5*sK0s) < 1.5*sK0s ||
4161             TMath::Abs(mK0s-massK0s - 6.5*sK0s) < 1.5*sK0s  ) {
4162
4163           // Only fills the histograms when it is a triggered event
4164           if(j==0){
4165             fHistArmenterosPodolanski->Fill(lAlphaV0,lPtArmV0,1);
4166             // MC Association of daughter particles
4167             fK0sBckgDCANegDaugToPrimVtx->Fill(lMCAssocNegDaug,dcaNeg);
4168             fK0sBckgDCAPosDaugToPrimVtx->Fill(lMCAssocPosDaug,dcaPos);
4169           }
4170
4171           // Pt bin & centrality
4172           //fK0sdPhidEtaPtLBckg[curCentBin*kN1+binPtv0]->Fill(dPhi,dEta,zv);
4173
4174           if(radio < 0.4){ // Under the correlation peak
4175             fHistArmPodBckg->Fill(lAlphaV0,lPtArmV0,1);
4176             fK0sBckgDecLength->Fill(dlK,ptTrig);
4177             fK0sBckgDCADaugToPrimVtx->Fill(dcaPos,dcaNeg,ptTrig);
4178             fK0sBckgEtaPhi->Fill(lPhi,lEta);
4179             fK0sBckgPhiRadio->Fill(lPhi,lt);
4180
4181             //RecCascade(trkTrig,ntrack,ptrack,"K0s");
4182             //RecCascade(trkTrig,ptrack,ntrack,"K0s");
4183
4184           }// End selection in the correlation peak
4185
4186         } // End background selection
4187
4188       } // End K0s selection
4189
4190       // *******************
4191       // Lambda selection
4192       // *******************
4193       if( trackAssocME->WhichCandidate() == 4 ){
4194         massL = tAssoc->MassLambda();
4195         mL = TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass();
4196         if( fCollision.Contains("PbPb2010") )
4197           sL = kCteLambda2010[curCentBin] + kLinearLambda2010[curCentBin]*pt;
4198         else if( fCollision.Contains("PbPb2011") )
4199           sL = kCteLambda2011[curCentBin] + kLinearLambda2011[curCentBin]*pt;
4200
4201         // ==== Correlations Lambda invariant mass peak ==== //
4202         // +++++++++++ Pt bin & centrality
4203         if(trigTPCMapOk && posDaugTPCMapOk && negDaugTPCMapOk) // splitting rejection according to the TPC shared map
4204           fLambdadPhidEtaPtL[curCentBin*kN1*kNVtxZ + binPtv0*kNVtxZ + curVtxBin]->Fill(dPhi,dEta,massL);
4205
4206         // ==== Correlations Lambda invariant mass peak ==== //
4207         if (TMath::Abs(mL-massL) < 3*sL) {
4208
4209           // -------------- splitting checks ---------------
4210           if(TMath::Abs(dPhi)<0.06 && TMath::Abs(dEta)<0.06){
4211
4212             //// -------- TPC Map ------- ////
4213             if(!trigTPCMapOk && !posDaugTPCMapOk)
4214               fSharedClsTrigDaug->Fill(pt,ptrack->P(),2.5);
4215             if(!trigTPCMapOk && !negDaugTPCMapOk)
4216               fSharedClsTrigDaug->Fill(pt,ntrack->P(),3.5);
4217
4218             //// -------- Covariance matrix ------- ////
4219             // positive daughter
4220             splitCont[0] = pt;  splitCont[1] = ptrack->P();
4221             for(Int_t ll=0; ll<=6; ll++){
4222               splitCont[2] = devPosDaugTrig[ll]; splitCont[3] = ll;
4223               fLambdaPosDaugSplCheckCovMat->Fill(splitCont);
4224             }
4225
4226             // negative daughter
4227             splitCont[0] = pt;  splitCont[1] = ntrack->P();
4228             for(Int_t ll=0; ll<=6; ll++){
4229               splitCont[2] = devNegDaugTrig[ll]; splitCont[3] = ll;
4230               fLambdaNegDaugSplCheckCovMat->Fill(splitCont);
4231             }
4232
4233           }
4234
4235           // ----------------------------------------------
4236
4237           if(radio<0.1)
4238             fLambdaSpatialRes->Fill(dPhi,res,lt);
4239           if(radio < 0.4){
4240             fHistArmPodBckg->Fill(lAlphaV0,lPtArmV0,2);
4241             fLambdaDCADaugToPrimVtx->Fill(dcaPos,dcaNeg,ptTrig);
4242             RecCascade(tTrig,ntrack,ptrack,"Lambda");
4243             RecCascade(tTrig,ptrack,ntrack,"Lambda");
4244           }
4245
4246         } // End mass peak selection
4247         // ==== Correlations Lambda background ==== //
4248         if( TMath::Abs(mL-massL + 6.5*sL) < 1.5*sL ||
4249             TMath::Abs(mL-massL - 6.5*sL) < 1.5*sL ) {
4250
4251           // Only fills the histograms when it is a triggered event
4252           if(j==0){
4253             fHistArmenterosPodolanski->Fill(lAlphaV0,lPtArmV0,3);
4254             // MC Association of daughter particles
4255             fLambdaBckgDCANegDaugToPrimVtx->Fill(lMCAssocNegDaug,dcaNeg);
4256             fLambdaBckgDCAPosDaugToPrimVtx->Fill(lMCAssocPosDaug,dcaPos);
4257           }
4258
4259           // Pt bin & centrality
4260           //fLambdadPhidEtaPtLBckg[curCentBin*kN1+binPtv0]->Fill(dPhi,dEta,zv);
4261
4262           if(radio < 0.4){ // Under the peak
4263             fHistArmPodBckg->Fill(lAlphaV0,lPtArmV0,3);
4264             fLambdaBckgDecLength->Fill(dlL,ptTrig);
4265             fLambdaBckgDCADaugToPrimVtx->Fill(dcaPos,dcaNeg,ptTrig);
4266             fLambdaBckgEtaPhi->Fill(lPhi,lEta);
4267             fLambdaBckgPhiRadio->Fill(lPhi,lt);
4268
4269             //RecCascade(trkTrig,ntrack,ptrack,"Lambda");
4270             //RecCascade(trkTrig,ptrack,ntrack,"Lambda");
4271
4272           }// End selection in the correlation peak
4273
4274         } // End bacground selection
4275
4276       }// End Lambda selection
4277        // *******************
4278       // AntiLambda selection
4279       // *******************
4280       if( trackAssocME->WhichCandidate() == 5 ){
4281         massAL = tAssoc->MassAntiLambda();
4282         mL = TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass();
4283         if( fCollision.Contains("PbPb2010") )
4284           sL = kCteAntiLambda2010[curCentBin] + kLinearAntiLambda2010[curCentBin]*pt;
4285         else if( fCollision.Contains("PbPb2011") )
4286           sL = kCteAntiLambda2011[curCentBin] + kLinearAntiLambda2011[curCentBin]*pt;
4287
4288
4289         // ==== Correlations Lambda invariant mass peak ==== //
4290         // +++++++++++ Pt bin & centrality
4291         if(trigTPCMapOk && posDaugTPCMapOk && negDaugTPCMapOk)  // splitting rejection according to the TPC shared map
4292           fAntiLambdadPhidEtaPtL[curCentBin*kN1*kNVtxZ + binPtv0*kNVtxZ + curVtxBin]->Fill(dPhi,dEta,massAL);
4293
4294         // ==== Correlations AntiLambda invariant mass peak ==== //
4295         if (TMath::Abs(mL-massAL) < 3*sL) {
4296
4297           // -------------- splitting checks ---------------
4298           if(TMath::Abs(dPhi)<0.06 && TMath::Abs(dEta)<0.06){
4299
4300             //// -------- TPC Map ------- ////
4301             if(!trigTPCMapOk && !posDaugTPCMapOk)
4302               fSharedClsTrigDaug->Fill(pt,ptrack->P(),4.5);
4303             if(!trigTPCMapOk && !negDaugTPCMapOk)
4304               fSharedClsTrigDaug->Fill(pt,ntrack->P(),5.5);
4305
4306             //// -------- Covariance matrix ------- ////
4307             // positive daughter
4308             splitCont[0] = pt;  splitCont[1] = ptrack->P();
4309             for(Int_t ll=0; ll<=6; ll++){
4310               splitCont[2] = devPosDaugTrig[ll]; splitCont[3] = ll;
4311               fAntiLambdaPosDaugSplCheckCovMat->Fill(splitCont);
4312             }
4313
4314             // negative daughter
4315             splitCont[0] = pt;  splitCont[1] = ntrack->P();
4316             for(Int_t ll=0; ll<=6; ll++){
4317               splitCont[2] = devNegDaugTrig[ll]; splitCont[3] = ll;
4318               fAntiLambdaNegDaugSplCheckCovMat->Fill(splitCont);
4319             }
4320
4321           }
4322
4323           // ----------------------------------------------
4324
4325           if(radio<0.1)
4326             fAntiLambdaSpatialRes->Fill(dPhi,res,lt);
4327           if(radio < 0.4){
4328             fHistArmPodBckg->Fill(lAlphaV0,lPtArmV0,4);
4329             fAntiLambdaDCADaugToPrimVtx->Fill(dcaPos,dcaNeg,ptTrig);
4330             RecCascade(tTrig,ntrack,ptrack,"AntiLambda");
4331             RecCascade(tTrig,ptrack,ntrack,"AntiLambda");
4332           }
4333
4334         } // End AntiLambda mass peak
4335         // ==== Correlations AntiLambda background ==== //
4336         if( (TMath::Abs(mL-massAL + 6.5*sL) < 1.5*sL) ||
4337             (TMath::Abs(mL-massAL - 6.5*sL) < 1.5*sL) ){
4338
4339           // Only fills the histograms when it is a triggered event
4340           if(j==0){
4341             fHistArmenterosPodolanski->Fill(lAlphaV0,lPtArmV0,5);
4342             // MC Association of daughter particles
4343             fAntiLambdaBckgDCANegDaugToPrimVtx->Fill(lMCAssocNegDaug,dcaNeg);
4344             fAntiLambdaBckgDCAPosDaugToPrimVtx->Fill(lMCAssocPosDaug,dcaPos);
4345           }
4346
4347           // Pt bin & centrality
4348           //fAntiLambdadPhidEtaPtLBckg[curCentBin*kN1+binPtv0]->Fill(dPhi,dEta,zv);
4349
4350           if(radio < 0.4){ // Under the peak
4351             fHistArmPodBckg->Fill(lAlphaV0,lPtArmV0,5);
4352             fAntiLambdaBckgDecLength->Fill(dlL,ptTrig);
4353             fAntiLambdaBckgDCADaugToPrimVtx->Fill(dcaPos,dcaNeg,ptTrig);
4354             fAntiLambdaBckgEtaPhi->Fill(lPhi,lEta);
4355             fAntiLambdaBckgPhiRadio->Fill(lPhi,lt);
4356
4357             //RecCascade(trkTrig,ntrack,ptrack,"AntiLambda");
4358             //RecCascade(trkTrig,ptrack,ntrack,"AntiLambda");
4359
4360           }// End selection in the correlation peak
4361
4362         }// End AntiLambda background
4363
4364       } // End AntiLambda selection
4365
4366     } // End loop over associated particles
4367
4368   } // End loop over trigger particles
4369
4370
4371   //-------------------------------------------------------------
4372   // Mixing
4373   //-------------------------------------------------------------
4374   Double_t phiTrigME=0, etaTrigME=0, phiAssocME=0, etaAssocME=0;
4375   Double_t deltaPhi=0, deltaEta=0;
4376
4377   TList *evMixList = fMEList[curCentBin*kNVtxZ+curVtxBin];
4378   Int_t nMixed = evMixList->GetSize();
4379
4380   if( nMixed>0 && fAssocParticles->GetEntriesFast() >= 0 ){
4381
4382     for(Int_t ii=0; ii<nMixed; ii++){
4383
4384       AliMiniParticle* trackTriggerME = (AliMiniParticle*) (evMixList->At(ii));
4385       phiTrigME = trackTriggerME->Phi();
4386       etaTrigME = trackTriggerME->Eta();
4387
4388       // --- V0 associated particles
4389       for(Int_t j=0; j<fAssocParticles->GetEntriesFast(); j++){
4390
4391         AliMiniParticle* trackAssocME = (AliMiniParticle*) (fAssocParticles->At(j));
4392         if( CentBin(trackTriggerME->Centrality()) != CentBin(trackAssocME->Centrality()) ) continue;
4393         if( VtxBin(trackTriggerME->VtxZ()) != VtxBin(trackAssocME->VtxZ()) ) continue;
4394         if( trackAssocME->WhichCandidate() ==  2 ) continue;
4395
4396         AliAODv0 *tAssoc=fAOD->GetV0(trackAssocME->ID());
4397         pt = tAssoc->Pt();
4398
4399         Bool_t IsSelected = kFALSE;
4400         // K0s
4401         if( trackAssocME->WhichCandidate() == 3 ){
4402           massK0s = tAssoc->MassK0Short();
4403           mK0s = TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass();
4404           if( fCollision.Contains("PbPb2010") )
4405             sK0s = kCteK0s2010[curCentBin] + kLinearK0s2010[curCentBin]*pt;
4406           else if( fCollision.Contains("PbPb2011") )
4407             sK0s = kCteK0s2011[curCentBin] + kLinearK0s2011[curCentBin]*pt;
4408
4409           if (TMath::Abs(mK0s-massK0s) < 3*sK0s) IsSelected = kTRUE;
4410         }
4411         // Lambda
4412         if( trackAssocME->WhichCandidate() == 4 ){
4413           massL = tAssoc->MassLambda();
4414           mL = TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass();
4415           if( fCollision.Contains("PbPb2010") )
4416             sL = kCteLambda2010[curCentBin] + kLinearLambda2010[curCentBin]*pt;
4417           else if( fCollision.Contains("PbPb2011") )
4418             sL = kCteLambda2011[curCentBin] + kLinearLambda2011[curCentBin]*pt;
4419
4420           if (TMath::Abs(mL-massL) < 3*sL) IsSelected = kTRUE;
4421         }
4422         // AntiLambda
4423         if( trackAssocME->WhichCandidate() == 5 ){
4424           massAL = tAssoc->MassAntiLambda();
4425           mL = TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass();
4426           if( fCollision.Contains("PbPb2010") )
4427             sL = kCteAntiLambda2010[curCentBin] + kLinearAntiLambda2010[curCentBin]*pt;
4428           else if( fCollision.Contains("PbPb2011") )
4429             sL = kCteAntiLambda2011[curCentBin] + kLinearAntiLambda2011[curCentBin]*pt;
4430
4431           if (TMath::Abs(mL-massAL) < 3*sL) IsSelected = kTRUE;
4432         }
4433
4434         if(!IsSelected) continue;
4435
4436         phiAssocME = trackAssocME->Phi();
4437         etaAssocME = trackAssocME->Eta();
4438
4439         deltaPhi = dPHI(phiTrigME,phiAssocME);
4440         deltaEta = etaTrigME - etaAssocME;
4441
4442         Int_t binPtv0 = PtBin( trackAssocME->Pt() );
4443         if(binPtv0==-1) continue;
4444
4445         if( trackAssocME->WhichCandidate() == 3 ) {
4446           fK0sdPhidEtaME[curCentBin*kN1*kNVtxZ + binPtv0*kNVtxZ + curVtxBin]->Fill(deltaPhi,deltaEta);}
4447         else if( trackAssocME->WhichCandidate() == 4 )
4448           fLambdadPhidEtaME[curCentBin*kN1*kNVtxZ + binPtv0*kNVtxZ + curVtxBin]->Fill(deltaPhi,deltaEta);
4449         else if( trackAssocME->WhichCandidate() == 5 )
4450           fAntiLambdadPhidEtaME[curCentBin*kN1*kNVtxZ + binPtv0*kNVtxZ + curVtxBin]->Fill(deltaPhi,deltaEta);
4451
4452       } // End loop over V0's
4453
4454     }
4455
4456   }
4457
4458   //--------------------------------------------------------
4459   //Add the current event to the list of events for mixing
4460   //--------------------------------------------------------
4461
4462   //Add current  event to buffer and Remove redundant events
4463   if(fTriggerParticles->GetEntriesFast()>=0){
4464
4465     for(Int_t ii=0; ii<(fTriggerParticles->GetEntriesFast()); ii++){
4466       AliMiniParticle* trkTrig = (AliMiniParticle*) fTriggerParticles->At(ii);
4467       //cout << trkTrig->Pt() << "          " << ii << endl;
4468
4469       if(evMixList->GetSize() < nMaxEvMix)
4470         evMixList->AddFirst(trkTrig);
4471       /*
4472       if(evMixList->GetSize() >= nMaxEvMix) {
4473         AliMiniParticle *tmp = (AliMiniParticle*) (evMixList->Last()) ;
4474         evMixList->RemoveLast();
4475         delete tmp;
4476       }
4477       */
4478
4479     }// End loop over fTriggerParticles
4480
4481   }// End adding trigger particles to buffers
4482
4483 }
4484
4485 //___________________________________________________________________________________________
4486
4487 void AliAnalysisTaskLambdaOverK0sJets::Terminate(Option_t *)
4488 {
4489   // The Terminate() function is the last function to be called during
4490   // a query. It always runs on the client, it can be used to present
4491   // the results graphically or save the results to file.
4492
4493   fOutput=(TList*)GetOutputData(1);
4494   fOutputME=(TList*)GetOutputData(2);
4495   fOutputQA=(TList*)GetOutputData(3);
4496
4497   if (fOutput || fOutputME || fOutputQA) {
4498
4499     if(fOutput)
4500       Printf("\n\t *** DONE: fOutput available *** \n");
4501     if(fOutputME)
4502       Printf("\n\t *** DONE: fOutputME available *** \n");
4503     if (fOutputQA)
4504       Printf("\n\t *** DONE: fOutputQA available *** \n");
4505   }
4506   if (!fOutput || !fOutputME || !fOutputQA) {
4507
4508     if(!fOutput)
4509       Printf("\n\t *** ERROR: fOutput not available *** \n");
4510     if(!fOutputME)
4511       Printf("\n\t *** ERROR: fOutputME available *** \n");
4512     if(!fOutputQA)
4513       Printf("\n\t *** ERROR: fOutputQA not available  *** \n");
4514   }
4515
4516
4517   return;
4518
4519 }