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