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