PWGLF/STRANGENESS/Correlations/AliAnalysisTaskLambdaOverK0sJets.cxx

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