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