PWGCF/Correlations/DPhi/AliLeadingV0Correlation.cxx

   1 /* Leading Charged Track+V0 Correlation.(Works for Real,Monte Carlo Data)
   2  *                            Sandun Jayarathna
   3  *                          University of Houston
   4  *                      sandun.pahula.hewage@cern.ch
   5  *****************************************************************************************/
   6 #include <TROOT.h>
   7 #include <TList.h>
   8 #include <TChain.h>
   9 #include <TFile.h>
  10 #include <TMath.h>
  11 #include <TTree.h>
  12 #include <TRandom.h>
  13 #include <TH1.h>
  14 #include <TH2.h>
  15 #include <TH3.h>
  16
  17
  18 #include "AliLog.h"
  19 #include "AliAnalysisManager.h"
  20 #include "AliAODTrack.h"
  21 #include "AliAODEvent.h"
  22 #include "AliAODv0.h"
  23 #include "AliAODVertex.h"
  24 #include "AliAODPid.h"
  25 #include "AliPIDResponse.h"
  26 #include "AliEventPoolManager.h"
  27 #include "AliCentrality.h"
  28 #include "AliAODHandler.h"
  29 #include "AliAODInputHandler.h"
  30 #include "AliAODMCParticle.h"
  31 #include "AliInputEventHandler.h"
  32 #include "AliVParticle.h"
  33 #include "AliMultiplicity.h"
  34 #include "AliAODMCHeader.h"
  35 #include "AliPID.h"
  36 #include "AliExternalTrackParam.h"
  37
  38 #include "AliLeadingV0Correlation.h"
  39
  40 #define CorrBinsX 24
  41 #define CorrBinsY 26
  42
  43 ClassImp(AliLeadingV0Correlation)
  44 ClassImp(AliLeadingBasicParticle)
  45
  46 //---------------------------------------------------------------------------------------
  47 AliLeadingV0Correlation::AliLeadingV0Correlation()
  48    : AliAnalysisTaskSE(),
  49         fAODEvent(0x0),
  50         fPoolMgr(0x0),
  51         fPoolMgrMC(0x0),
  52         fPoolK0(0x0),
  53         fPoolLambda(0x0),
  54         fPoolK0MC(0x0),
  55         fPoolLambdaMC(0x0),
  56         fPIDResponse(0x0),
  57         fPoolMaxNEvents(0),
  58         fPoolMinNTracks(0),
  59         fMinEventsToMix(0),
  60         fNzVtxBins(0),
  61         fNCentBins(0),
  62         fcollidingSys(""),
  63         fTriggerMask(""),
  64         fpvzcut(0),
  65         fTrackEtaCut(0),
  66         fFilterBit(128),
  67         ftrigPtLow(0),
  68         ftrigPtHigh(0),
  69         fassocPtLow(0),
  70         fassocPtHigh(0),
  71         fAnalysisMC(0),
  72         fUsePID(""),
  73         fRapidityCut(0),
  74         fCutV0Radius(0.),
  75         fCutDCANegToPV(0.),
  76         fCutDCAPosToPV(0.),
  77         fCutDCAV0Daughters(0.),
  78         fCutV0CosPA(0.),
  79         fSpecialArmenterosCutK0s(0.),
  80         fCTauK0(0.),
  81         fCTauLambda(0.),
  82         fOutputList(0),
  83         fHistMCPrimaryVertexX(0),
  84         fHistMCPrimaryVertexY(0),
  85         fHistMCPrimaryVertexZ(0),
  86         fHistMCPtAllK0s(0),
  87         fHistMCPtAllLambda(0),
  88         fHistMCPtAllAntiLambda(0),
  89         fHistMCRapK0s(0),
  90         fHistMCRapLambda(0),
  91         fHistMCRapAntiLambda(0),
  92         fHistMCPtK0s(0),
  93         fHistMCPtLambda(0),
  94         fHistMCPtAntiLambda(0),
  95         fHistMCPtLambdaFromSigma(0),
  96         fHistMCPtAntiLambdaFromSigma(0),
  97         fHistPrimRawPtVsYK0s(0),
  98         fHistPrimRawPtVsYLambda(0),
  99         fHistPrimRawPtVsYAntiLambda(0),
 100         fHistPrimaryVertexX(0),
 101         fHistPrimaryVertexY(0),
 102         fHistPrimaryVertexZ(0),
 103         fHistDcaPosToPrimVertexK0vsMassK0(0),
 104         fHistDcaNegToPrimVertexK0vsMassK0(0),
 105         fHistRadiusV0K0vsMassK0(0),
 106         fHistDecayLengthV0K0vsMassK0(0),
 107         fHistDcaV0DaughtersK0vsMassK0(0),
 108         fHistCosPointAngleK0vsMassK0(0),
 109         fHistDcaPosToPrimVertexLvsMassL(0),
 110         fHistDcaNegToPrimVertexLvsMassL(0),
 111         fHistRadiusV0LvsMassL(0),
 112         fHistDecayLengthV0LvsMassL(0),
 113         fHistDcaV0DaughtersLvsMassL(0),
 114         fHistCosPointAngleLvsMassL(0),
 115         fHistDcaPosToPrimVertexAntiLvsMass(0),
 116         fHistDcaNegToPrimVertexAntiLvsMass(0),
 117         fHistRadiusV0AntiLvsMass(0),
 118         fHistDecayLengthV0AntiLvsMass(0),
 119         fHistDcaV0DaughtersAntiLvsMass(0),
 120         fHistCosPointAngleAntiLvsMass(0),
 121         fHistMassK0(0),
 122         fHistMassLambda(0),
 123         fHistMassAntiLambda(0),
 124         fHistPtVsMassK0(0),
 125         fHistPtVsMassLambda(0),
 126         fHistPtVsMassAntiLambda(0),
 127         fHistArmenterosPodolanskiK0(0),
 128         fHistArmenterosPodolanskiLambda(0),
 129         fHistArmenterosPodolanskiAntiLambda(0),
 130         fHistAsMcPtK0(0),
 131         fHistAsMcPtLambda(0),
 132         fHistAsMcPtAntiLambda(0),
 133         fHistAsMcProdRadiusK0(0),
 134         fHistAsMcProdRadiusLambda(0),
 135         fHistAsMcProdRadiusAntiLambda(0),
 136         fHistAsMcProdRadiusXvsYK0s(0),
 137         fHistAsMcProdRadiusXvsYLambda(0),
 138         fHistAsMcProdRadiusXvsYAntiLambda(0),
 139         fHistPidMcMassK0(0),
 140         fHistPidMcMassLambda(0),
 141         fHistPidMcMassAntiLambda(0),
 142         fHistAsMcPtLambdaFromSigma(0),
 143         fHistAsMcPtAntiLambdaFromSigma(0),
 144         fHistAsMcSecondaryPtVsRapK0s(0),
 145         fHistAsMcSecondaryPtVsRapLambda(0),
 146         fHistAsMcSecondaryPtVsRapAntiLambda(0),
 147         fHistAsMcSecondaryProdRadiusK0s(0),
 148         fHistAsMcSecondaryProdRadiusLambda(0),
 149         fHistAsMcSecondaryProdRadiusAntiLambda(0),
 150         fHistAsMcSecondaryProdRadiusXvsYK0s(0),
 151         fHistAsMcSecondaryProdRadiusXvsYLambda(0),
 152         fHistAsMcSecondaryProdRadiusXvsYAntiLambda(0),
 153         fHistAsMcSecondaryPtLambdaFromSigma(0),
 154         fHistAsMcSecondaryPtAntiLambdaFromSigma(0),
 155         fHistSibK0(0),
 156         fHistMixK0(0),
 157         fHistSibLambda(0),
 158         fHistMixLambda(0),
 159         fHistSibK0MC(0),
 160         fHistMixK0MC(0),
 161         fHistSibLambdaMC(0),
 162         fHistMixLambdaMC(0),
 163     fHistLeadInfo(0),
 164     fHistLeadInfoMC(0),
 165         fHistLeadInfoMix(0),
 166         fHistLeadInfoMixMC(0)
 167 {
 168
 169   for(Int_t iBin = 0; iBin < 100; iBin++){
 170     fZvtxBins[iBin] = 0.;
 171     fCentBins[iBin] = 0.;
 172   }
 173
 174 }
 175 //---------------------------------------------------------------------------------------
 176 AliLeadingV0Correlation::AliLeadingV0Correlation(const char *name)
 177    : AliAnalysisTaskSE(name),
 178         fAODEvent(0x0),
 179         fPoolMgr(0x0),
 180         fPoolMgrMC(0x0),
 181         fPoolK0(0x0),
 182         fPoolLambda(0x0),
 183         fPoolK0MC(0x0),
 184         fPoolLambdaMC(0x0),
 185     fPIDResponse(0x0),
 186         fPoolMaxNEvents(0),
 187         fPoolMinNTracks(0),
 188         fMinEventsToMix(0),
 189         fNzVtxBins(0),
 190         fNCentBins(0),
 191         fcollidingSys(""),
 192         fTriggerMask(""),
 193         fpvzcut(0),
 194     fTrackEtaCut(0),
 195     fFilterBit(128),
 196         ftrigPtLow(0),
 197         ftrigPtHigh(0),
 198         fassocPtLow(0),
 199         fassocPtHigh(0),
 200         fAnalysisMC(0),
 201         fUsePID(""),
 202     fRapidityCut(0),
 203         fCutV0Radius(0.),
 204         fCutDCANegToPV(0.),
 205         fCutDCAPosToPV(0.),
 206         fCutDCAV0Daughters(0.),
 207         fCutV0CosPA(0.),
 208         fSpecialArmenterosCutK0s(0.),
 209     fCTauK0(0.),
 210     fCTauLambda(0.),
 211         fOutputList(0),
 212         fHistMCPrimaryVertexX(0),
 213         fHistMCPrimaryVertexY(0),
 214         fHistMCPrimaryVertexZ(0),
 215         fHistMCPtAllK0s(0),
 216         fHistMCPtAllLambda(0),
 217         fHistMCPtAllAntiLambda(0),
 218         fHistMCRapK0s(0),
 219         fHistMCRapLambda(0),
 220         fHistMCRapAntiLambda(0),
 221         fHistMCPtK0s(0),
 222         fHistMCPtLambda(0),
 223         fHistMCPtAntiLambda(0),
 224         fHistMCPtLambdaFromSigma(0),
 225         fHistMCPtAntiLambdaFromSigma(0),
 226         fHistPrimRawPtVsYK0s(0),
 227         fHistPrimRawPtVsYLambda(0),
 228         fHistPrimRawPtVsYAntiLambda(0),
 229         fHistPrimaryVertexX(0),
 230         fHistPrimaryVertexY(0),
 231         fHistPrimaryVertexZ(0),
 232         fHistDcaPosToPrimVertexK0vsMassK0(0),
 233         fHistDcaNegToPrimVertexK0vsMassK0(0),
 234         fHistRadiusV0K0vsMassK0(0),
 235         fHistDecayLengthV0K0vsMassK0(0),
 236         fHistDcaV0DaughtersK0vsMassK0(0),
 237         fHistCosPointAngleK0vsMassK0(0),
 238         fHistDcaPosToPrimVertexLvsMassL(0),
 239         fHistDcaNegToPrimVertexLvsMassL(0),
 240         fHistRadiusV0LvsMassL(0),
 241         fHistDecayLengthV0LvsMassL(0),
 242         fHistDcaV0DaughtersLvsMassL(0),
 243         fHistCosPointAngleLvsMassL(0),
 244         fHistDcaPosToPrimVertexAntiLvsMass(0),
 245         fHistDcaNegToPrimVertexAntiLvsMass(0),
 246         fHistRadiusV0AntiLvsMass(0),
 247         fHistDecayLengthV0AntiLvsMass(0),
 248         fHistDcaV0DaughtersAntiLvsMass(0),
 249         fHistCosPointAngleAntiLvsMass(0),
 250         fHistMassK0(0),
 251         fHistMassLambda(0),
 252         fHistMassAntiLambda(0),
 253         fHistPtVsMassK0(0),
 254         fHistPtVsMassLambda(0),
 255         fHistPtVsMassAntiLambda(0),
 256         fHistArmenterosPodolanskiK0(0),
 257         fHistArmenterosPodolanskiLambda(0),
 258         fHistArmenterosPodolanskiAntiLambda(0),
 259         fHistAsMcPtK0(0),
 260         fHistAsMcPtLambda(0),
 261         fHistAsMcPtAntiLambda(0),
 262         fHistAsMcProdRadiusK0(0),
 263         fHistAsMcProdRadiusLambda(0),
 264         fHistAsMcProdRadiusAntiLambda(0),
 265         fHistAsMcProdRadiusXvsYK0s(0),
 266         fHistAsMcProdRadiusXvsYLambda(0),
 267         fHistAsMcProdRadiusXvsYAntiLambda(0),
 268         fHistPidMcMassK0(0),
 269         fHistPidMcMassLambda(0),
 270         fHistPidMcMassAntiLambda(0),
 271         fHistAsMcPtLambdaFromSigma(0),
 272         fHistAsMcPtAntiLambdaFromSigma(0),
 273         fHistAsMcSecondaryPtVsRapK0s(0),
 274         fHistAsMcSecondaryPtVsRapLambda(0),
 275         fHistAsMcSecondaryPtVsRapAntiLambda(0),
 276         fHistAsMcSecondaryProdRadiusK0s(0),
 277         fHistAsMcSecondaryProdRadiusLambda(0),
 278         fHistAsMcSecondaryProdRadiusAntiLambda(0),
 279         fHistAsMcSecondaryProdRadiusXvsYK0s(0),
 280         fHistAsMcSecondaryProdRadiusXvsYLambda(0),
 281         fHistAsMcSecondaryProdRadiusXvsYAntiLambda(0),
 282         fHistAsMcSecondaryPtLambdaFromSigma(0),
 283         fHistAsMcSecondaryPtAntiLambdaFromSigma(0),
 284         fHistSibK0(0),
 285         fHistMixK0(0),
 286         fHistSibLambda(0),
 287         fHistMixLambda(0),
 288         fHistSibK0MC(0),
 289         fHistMixK0MC(0),
 290         fHistSibLambdaMC(0),
 291         fHistMixLambdaMC(0),
 292         fHistLeadInfo(0),
 293         fHistLeadInfoMC(0),
 294         fHistLeadInfoMix(0),
 295         fHistLeadInfoMixMC(0)
 296 {
 297
 298   for(Int_t iBin = 0; iBin < 100; iBin++){
 299     fZvtxBins[iBin] = 0.;
 300     fCentBins[iBin] = 0.;
 301   }
 302
 303   DefineOutput(1, TList::Class());
 304 }
 305
 306 //---------------------------------------------------------------------------------------
 307 AliLeadingV0Correlation::~AliLeadingV0Correlation()
 308 {
 309    // Destructor. Clean-up the output list, but not the histograms that are put inside
 310    // (the list is owner and will clean-up these histograms). Protect in PROOF case.
 311    if (fOutputList && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
 312       delete fOutputList;
 313    }
 314 }
 315 //---------------------------------------------------------------------------------------
 316 void AliLeadingV0Correlation::UserCreateOutputObjects()
 317 {
 318         fOutputList = new TList();
 319         fOutputList->SetOwner();
 320
 321         Int_t lCustomNBins = 200;
 322         Double_t lCustomPtUpperLimit = 20;
 323
 324         //---------------------------------------------- MC histograms -----------------------------------------------------//
 325         fHistMCPrimaryVertexX         = new TH1F("h1MCPrimaryVertexX", "MC Primary Vertex Position X;Primary Vertex Position X (cm);Events",100,-0.5,0.5);
 326         fOutputList->Add(fHistMCPrimaryVertexX);
 327
 328         fHistMCPrimaryVertexY         = new TH1F("h1MCPrimaryVertexY", "MC Primary Vertex Position Y;Primary Vertex Position Y (cm);Events",100,-0.5,0.5);
 329         fOutputList->Add(fHistMCPrimaryVertexY);
 330
 331         fHistMCPrimaryVertexZ         = new TH1F("h1MCPrimaryVertexZ", "MC Primary Vertex Position Z;Primary Vertex Position Z (cm);Events",200,-20,20);
 332         fOutputList->Add(fHistMCPrimaryVertexZ);
 333
 334         fHistMCRapK0s                 = new TH1F("h1MCRapK0s", "K^{0};y",160,-4,4);
 335         fOutputList->Add(fHistMCRapK0s);
 336
 337         fHistMCRapLambda              = new TH1F("h1MCRapLambda", "#Lambda;y",160,-4,4);
 338         fOutputList->Add(fHistMCRapLambda);
 339
 340         fHistMCRapAntiLambda          = new TH1F("h1MCRapAntiLambda", "#bar{#Lambda};y",160,-4,4);
 341         fOutputList->Add(fHistMCRapAntiLambda);
 342
 343         fHistMCPtK0s                  = new TH1F("h1MCPtK0s", "K^{0};p{t} (GeV/c)",240,0,12);
 344         fOutputList->Add(fHistMCPtK0s);
 345
 346         fHistMCPtLambda               = new TH1F("h1MCPtLambda", "#Lambda^{0};p{t} (GeV/c)",240,0,12);
 347         fOutputList->Add(fHistMCPtLambda);
 348
 349         fHistMCPtAntiLambda           = new TH1F("h1MCPtAntiLambda", "#AntiLambda^{0};p{t} (GeV/c)",240,0,12);
 350         fOutputList->Add(fHistMCPtAntiLambda);
 351
 352         fHistMCPtLambdaFromSigma      = new TH1F("h1MCPtLambdaFromSigma", "#Lambda^{0};p{t} (GeV/c)",240,0,12);
 353         fOutputList->Add(fHistMCPtLambdaFromSigma);
 354
 355         fHistMCPtAntiLambdaFromSigma  = new TH1F("h1MCPtAntiLambdaFromSigma", "#Lambda^{0};p{t} (GeV/c)",240,0,12);
 356         fOutputList->Add(fHistMCPtAntiLambdaFromSigma);
 357
 358         fHistMCPtAllK0s               = new TH1F("h1MCPtAllK0s", "Non-primary MC K^{0};p{t} (GeV/c);Counts",240,0,12);
 359         fOutputList->Add(fHistMCPtAllK0s);
 360
 361         fHistMCPtAllLambda            = new TH1F("h1MCPtAllLambda", "Non-primary MC #Lambda^{0};p{t} (GeV/c);Counts",240,0,12);
 362         fOutputList->Add(fHistMCPtAllLambda);
 363
 364         fHistMCPtAllAntiLambda        = new TH1F("h1MCPtAllAntiLambda", "Non-primary MC #bar{#Lambda}^{0};p{t} (GeV/c);Counts",240,0,12);
 365         fOutputList->Add(fHistMCPtAllAntiLambda);
 366
 367         fHistPrimRawPtVsYK0s          = new TH2F( "f3dHistPrimRawPtVsYVsMultK0Short", "Pt{K0S} Vs Y{K0S} Vs Multiplicity; Pt{K0S} (GeV/c); Y{K0S} ; Mult", lCustomNBins, 0., lCustomPtUpperLimit, 48, -1.2,1.2);
 368         fOutputList->Add(fHistPrimRawPtVsYK0s);
 369
 370
 371         fHistPrimRawPtVsYLambda       = new TH2F( "f3dHistPrimRawPtVsYVsMultLambda", "Pt{lambda} Vs Y{#Lambda} Vs Multiplicity; Pt{lambda} (GeV/c); Y{#Lambda} ; Mult", lCustomNBins, 0., lCustomPtUpperLimit, 48, -1.2,1.2);
 372         fOutputList->Add(fHistPrimRawPtVsYLambda);
 373
 374         fHistPrimRawPtVsYAntiLambda   = new TH2F( "f3dHistPrimRawPtVsYVsMultAntiLambda", "Pt{antilambda} Vs Y{#Lambda} Vs Multiplicity; Pt{antilambda} (GeV/c); Y{#Lambda} ; Mult", lCustomNBins, 0., lCustomPtUpperLimit, 48, -1.2,1.2);
 375         fOutputList->Add(fHistPrimRawPtVsYAntiLambda);
 376
 377         //---------------------------------------------End Of MC Histos-----------------------------------------------------//
 378
 379         fHistPrimaryVertexX           = new TH1F("h1PrimaryVertexX", "Primary Vertex Position X;Primary Vertex Position X (cm);Events",100,-0.5,0.5);
 380         fOutputList->Add(fHistPrimaryVertexX);
 381
 382         fHistPrimaryVertexY           = new TH1F("h1PrimaryVertexY", "Primary Vertex Position Y;Primary Vertex Position Y (cm);Events",100,-0.5,0.5);
 383         fOutputList->Add(fHistPrimaryVertexY);
 384
 385         fHistPrimaryVertexZ           = new TH1F("h1PrimaryVertexZ", "Primary Vertex Position Z;Primary Vertex Position Z (cm);Events",200,-20,20);
 386         fOutputList->Add(fHistPrimaryVertexZ);
 387
 388         fHistDcaPosToPrimVertexK0vsMassK0 = new TH2F("h2DcaPosToPrimVertexK0vsMassK0", "Positive V0 daughter;dca(cm);K0s inv. mass",500,0,10,200,0.4,0.6);
 389         fOutputList->Add(fHistDcaPosToPrimVertexK0vsMassK0);
 390
 391         fHistDcaNegToPrimVertexK0vsMassK0 = new TH2F("h2DcaNegToPrimVertexK0vsMassK0", "Negative V0 daughter;dca(cm);K0s inv. mass",500,0,10,200,0.4,0.6);
 392         fOutputList->Add(fHistDcaNegToPrimVertexK0vsMassK0);
 393
 394         fHistRadiusV0K0vsMassK0           = new TH2F("h2RadiusV0K0vsMassK0", "Radius;Radius(cm);K0s inv. mass",110,0,110,200,0.4,0.6);
 395         fOutputList->Add(fHistRadiusV0K0vsMassK0);
 396
 397         fHistDecayLengthV0K0vsMassK0      = new TH2F("h2DecayLengthV0K0vsMassK0", "V0s decay Length;decay length(cm);K0s inv. mass", 100, 0, 100,200,0.4,0.6);
 398         fOutputList->Add(fHistDecayLengthV0K0vsMassK0);
 399
 400         fHistDcaV0DaughtersK0vsMassK0     = new TH2F("h2DcaV0DaughtersK0vsMassK0", "DCA between daughters;dca(cm);K0s inv. mass", 110, 0, 1.1,200,0.4,0.6);
 401         fOutputList->Add(fHistDcaV0DaughtersK0vsMassK0);
 402
 403         fHistCosPointAngleK0vsMassK0      = new TH2F("h2CosPointAngleK0vsMassK0", "Cosine of V0's pointing angle", 200,0.997,1.007,200,0.4,0.6);
 404         fOutputList->Add(fHistCosPointAngleK0vsMassK0);
 405
 406         fHistDcaPosToPrimVertexLvsMassL   = new TH2F("h2DcaPosToPrimVertexLvsMassL", "Positive V0 daughter;dca(cm);Status",100,0,10,140, 1.06, 1.2);
 407         fOutputList->Add(fHistDcaPosToPrimVertexLvsMassL);
 408
 409         fHistDcaNegToPrimVertexLvsMassL   = new TH2F("h2DcaNegToPrimVertexLvsMassL", "Negative V0 daughter;dca(cm);Status",100,0,10,140, 1.06, 1.2);
 410         fOutputList->Add(fHistDcaNegToPrimVertexLvsMassL);
 411
 412         fHistRadiusV0LvsMassL             = new TH2F("h2RadiusV0LvsMassL", "Radius;Radius(cm);Status",110,0,110,140, 1.06, 1.2);
 413         fOutputList->Add(fHistRadiusV0LvsMassL);
 414
 415         fHistDecayLengthV0LvsMassL        = new TH2F("h2DecayLengthV0LvsMassL", "V0s decay Length;decay length(cm);Status", 120, 0, 120,140, 1.06, 1.2);
 416         fOutputList->Add(fHistDecayLengthV0LvsMassL);
 417
 418         fHistDcaV0DaughtersLvsMassL        = new TH2F("h2DcaV0DaughtersLvsMassL", "DCA between daughters;dca(cm);Status", 110, 0, 1.1,140, 1.06, 1.2);
 419         fOutputList->Add(fHistDcaV0DaughtersLvsMassL);
 420
 421         fHistCosPointAngleLvsMassL         = new TH2F("h2CosPointAngleLvsMassL", "Cosine of V0's pointing angle", 200,0.997,1.007,140, 1.06, 1.2);
 422         fOutputList->Add(fHistCosPointAngleLvsMassL);
 423
 424         fHistDcaPosToPrimVertexAntiLvsMass   = new TH2F("h2DcaPosToPrimVertexAntiLvsMass", "Positive V0 daughter;dca(cm);Status",100,0,10,140, 1.06, 1.2);
 425         fOutputList->Add(fHistDcaPosToPrimVertexAntiLvsMass);
 426
 427         fHistDcaNegToPrimVertexAntiLvsMass   = new TH2F("h2DcaNegToPrimVertexAntiLvsMass", "Negative V0 daughter;dca(cm);Status",100,0,10,140, 1.06, 1.2);
 428         fOutputList->Add(fHistDcaNegToPrimVertexAntiLvsMass);
 429
 430         fHistRadiusV0AntiLvsMass             = new TH2F("h2RadiusV0AntiLvsMass", "Radius;Radius(cm);Status",110,0,110,140, 1.06, 1.2);
 431         fOutputList->Add(fHistRadiusV0AntiLvsMass);
 432
 433         fHistDecayLengthV0AntiLvsMass        = new TH2F("h2DecayLengthV0AntiLvsMass", "V0s decay Length;decay length(cm);Status", 120, 0, 120,140, 1.06, 1.2);
 434         fOutputList->Add(fHistDecayLengthV0AntiLvsMass);
 435
 436         fHistDcaV0DaughtersAntiLvsMass       = new TH2F("h2DcaV0DaughtersAntiLvsMass", "DCA between daughters;dca(cm);Status", 110, 0, 1.1,140, 1.06, 1.2);
 437         fOutputList->Add(fHistDcaV0DaughtersAntiLvsMass);
 438
 439         fHistCosPointAngleAntiLvsMass        = new TH2F("h2CosPointAngleAntiLvsMass", "Cosine of V0's pointing angle", 200,0.997,1.007,140, 1.06, 1.2);
 440         fOutputList->Add(fHistCosPointAngleAntiLvsMass);
 441
 442         fHistMassK0                          = new TH1F("h1MassK0", "K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts", 200, 0.4, 0.6);
 443         fOutputList->Add(fHistMassK0);
 444
 445         fHistMassLambda                      = new TH1F("h1MassLambda", "#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});Counts", 150, 1.05, 1.2);
 446         fOutputList->Add(fHistMassLambda);
 447
 448         fHistMassAntiLambda                  = new TH1F("h1MassAntiLambda", "#bar{#Lambda}^{0} candidates;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts", 150, 1.05, 1.2);
 449         fOutputList->Add(fHistMassAntiLambda);
 450
 451         fHistPtVsMassK0                      = new TH2F("h2PtVsMassK0","K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});p{t} (GeV/c)",400, 0.4, 0.6,240,0,12);
 452         fOutputList->Add(fHistPtVsMassK0);
 453
 454         fHistPtVsMassLambda                  = new TH2F("h2PtVsMassLambda","#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});p{t} (GeV/c)",280, 1.06, 1.2,240,0,12);
 455         fOutputList->Add(fHistPtVsMassLambda);
 456
 457         fHistPtVsMassAntiLambda              = new TH2F("h2PtVsMassAntiLambda","#AntiLambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});p{t} (GeV/c)",280, 1.06, 1.2,240,0,12);
 458         fOutputList->Add(fHistPtVsMassAntiLambda);
 459
 460         fHistArmenterosPodolanskiK0          = new TH2F("h2ArmenterosPodolanskiK0","Armenteros-Podolanski phase space;#alpha;p{t} arm",100,-1.0,1.0,50,0,0.5);
 461         fOutputList->Add(fHistArmenterosPodolanskiK0);
 462
 463         fHistArmenterosPodolanskiLambda      = new TH2F("h2ArmenterosPodolanskiLambda","Armenteros-Podolanski phase space;#alpha;p{t} arm",100,-1.0,1.0,50,0,0.5);
 464         fOutputList->Add(fHistArmenterosPodolanskiLambda);
 465
 466         fHistArmenterosPodolanskiAntiLambda  = new TH2F("h2ArmenterosPodolanskiAntiLambda","Armenteros-Podolanski phase space;#alpha;p{t} arm",100,-1.0,1.0,50,0,0.5);
 467         fOutputList->Add(fHistArmenterosPodolanskiAntiLambda);
 468
 469 //--------------------------------------------MC Associated histograms -----------------------------------------------------//
 470
 471         fHistAsMcPtK0                        = new TH1F("h1AsMcPtK0", "K^{0} associated;p{t} (GeV/c);Counts", 240,0,12);
 472         fOutputList->Add(fHistAsMcPtK0);
 473
 474         fHistAsMcPtLambda                    = new TH1F("h1AsMcPtLambda", "#Lambda^{0} associated;p{t} (GeV/c);Counts", 240,0,12);
 475         fOutputList->Add(fHistAsMcPtLambda);
 476
 477         fHistAsMcPtAntiLambda                = new TH1F("h1AsMcPtAntiLambda", "#AntiLambda^{0} associated;p{t} (GeV/c);Counts", 240,0,12);
 478         fOutputList->Add(fHistAsMcPtAntiLambda);
 479
 480         fHistAsMcProdRadiusK0                = new TH1F("h1AsMcProdRadiusK0", "K^{0} associated;r (cm);Counts", 500, 0, 100);
 481         fOutputList->Add(fHistAsMcProdRadiusK0);
 482
 483         fHistAsMcProdRadiusLambda            = new TH1F("h1AsMcProdRadiusLambda", "#Lambda^{0} associated;r (cm);Counts", 500, 0, 100);
 484         fOutputList->Add(fHistAsMcProdRadiusLambda);
 485
 486         fHistAsMcProdRadiusAntiLambda        = new TH1F("h1AsMcProdRadiusAntiLambda", "#bar{#Lambda}^{0} associated;r (cm);Counts", 500, 0, 100);
 487         fOutputList->Add(fHistAsMcProdRadiusAntiLambda);
 488
 489         fHistAsMcProdRadiusXvsYK0s           = new TH2F("h2AsMcProdRadiusXvsYK0s","Associated Secondary K^{0} Production Radius;x (cm); y (cm)",200,-50,50,200,-50,50);
 490         fOutputList->Add(fHistAsMcProdRadiusXvsYK0s);
 491
 492         fHistAsMcProdRadiusXvsYLambda        = new TH2F("h2AsMcProdRadiusXvsYLambda","Associated Secondary #Lambda^{0} Production Radius;x (cm); y (cm)",200,-50,50,200,-50,50);
 493         fOutputList->Add(fHistAsMcProdRadiusXvsYLambda);
 494
 495         fHistAsMcProdRadiusXvsYAntiLambda    = new TH2F("h2AsMcProdRadiusXvsYAntiLambda","Associated Secondary #bar{#Lambda}^{0} Production Radius;x (cm); y (cm)",200,-50,50,200,-50,50);
 496         fOutputList->Add(fHistAsMcProdRadiusXvsYAntiLambda);
 497
 498         fHistPidMcMassK0                     = new TH1F("h1PidMcMassK0", "K^{0} MC PId checked;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts", 100, 0.4, 0.6);
 499         fOutputList->Add(fHistPidMcMassK0);
 500
 501         fHistPidMcMassLambda                 = new TH1F("h1PidMcMassLambda", "#Lambda^{0} MC PId checked;M(p#pi^{-}) (GeV/c^{2});Counts", 75, 1.05, 1.2);
 502         fOutputList->Add(fHistPidMcMassLambda);
 503
 504         fHistPidMcMassAntiLambda             = new TH1F("h1PidMcMassAntiLambda", "#bar{#Lambda}^{0} MC PId checked;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts", 75, 1.05, 1.2);
 505         fOutputList->Add(fHistPidMcMassAntiLambda);
 506
 507         fHistAsMcPtLambdaFromSigma           = new TH1F("h1AsMcPtLambdaFromSigma","#Lambda}^{0} associated from Sigma;p{t} (GeV/c);Count",240,0,12);
 508         fOutputList->Add(fHistAsMcPtLambdaFromSigma);
 509
 510         fHistAsMcPtAntiLambdaFromSigma       = new TH1F("h1AsMcPtAntiLambdaFromSigma","#bar{#Lambda}^{0} associated from Sigma;p{t} (GeV/c);Count",240,0,12);
 511         fOutputList->Add(fHistAsMcPtAntiLambdaFromSigma);
 512
 513         fHistAsMcSecondaryPtVsRapK0s         = new TH2F("h2AsMcSecondaryPtVsRapK0s", "K^{0} associated secondary;p{t} (GeV/c);rapidity",240,0,12,30,-1.5,1.5);
 514         fOutputList->Add(fHistAsMcSecondaryPtVsRapK0s);
 515
 516         fHistAsMcSecondaryPtVsRapLambda      = new TH2F("h2AsMcSecondaryPtVsRapLambda", "#Lambda^{0} associated secondary;p{t} (GeV/c);rapidity",240,0,12,30,-1.5,1.5);
 517         fOutputList->Add(fHistAsMcSecondaryPtVsRapLambda);
 518
 519         fHistAsMcSecondaryPtVsRapAntiLambda  = new TH2F("h2AsMcSecondaryPtVsRapAntiLambda", "#bar{#Lambda}^{0} associated secondary;p{t} (GeV/c);rapidity",240,0,12,30,-1.5,1.5);
 520         fOutputList->Add(fHistAsMcSecondaryPtVsRapAntiLambda);
 521
 522         fHistAsMcSecondaryProdRadiusK0s      = new TH1F("h1AsMcSecondaryProdRadiusK0s", "K^{0} Production Radius;r (cm);Count", 170, -2, 15);
 523         fOutputList->Add(fHistAsMcSecondaryProdRadiusK0s);
 524
 525         fHistAsMcSecondaryProdRadiusLambda   = new TH1F("h1AsMcSecondaryProdRadiusLambda", "#Lambda^{0} Production Radius;r (cm);Count", 170, -2, 15);
 526         fOutputList->Add(fHistAsMcSecondaryProdRadiusLambda);
 527
 528         fHistAsMcSecondaryProdRadiusAntiLambda       = new TH1F("h1AsMcSecondaryProdRadiusAntiLambda", "#bar{#Lambda}^{0} Production Radius;r (cm);Count", 170, -2, 15);
 529         fOutputList->Add(fHistAsMcSecondaryProdRadiusAntiLambda);
 530
 531         fHistAsMcSecondaryProdRadiusXvsYK0s          = new TH2F("h2AsMcSecondaryProdRadiusXvsYK0s","Associated Secondary K^{0} Production Radius;x (cm); y (cm)",200,-20,20,200,-20,20);
 532         fOutputList->Add(fHistAsMcSecondaryProdRadiusXvsYK0s);
 533
 534         fHistAsMcSecondaryProdRadiusXvsYLambda       = new TH2F("h2AsMcSecondaryProdRadiusXvsYLambda","Associated Secondary #Lambda^{0} Production Radius;x (cm); y (cm)",200,-20,20,200,-20,20);
 535         fOutputList->Add(fHistAsMcSecondaryProdRadiusXvsYLambda);
 536
 537         fHistAsMcSecondaryProdRadiusXvsYAntiLambda   = new TH2F("h2AsMcSecondaryProdRadiusXvsYAntiLambda","Associated Secondary #bar{#Lambda}^{0} Production Radius;x (cm); y (cm)",200,-20,20,200,-20,20);
 538         fOutputList->Add(fHistAsMcSecondaryProdRadiusXvsYAntiLambda);
 539
 540         fHistAsMcSecondaryPtLambdaFromSigma          = new TH1F("h1AsMcSecondaryPtLambdaFromSigma","#Lambda}^{0} associated from Sigma;p{t} (GeV/c);Count",240,0,12);
 541         fOutputList->Add(fHistAsMcSecondaryPtLambdaFromSigma);
 542
 543         fHistAsMcSecondaryPtAntiLambdaFromSigma      = new TH1F("h1AsMcSecondaryPtAntiLambdaFromSigma","#bar{#Lambda}^{0} associated from Sigma;p{t} (GeV/c);Count",240,0,12);
 544         fOutputList->Add(fHistAsMcSecondaryPtAntiLambdaFromSigma);
 545
 546         //----------------------------------------------Correlation histograms -----------------------------------------------------//
 547
 548         fHistSibK0       = new TH3F("hfHistSibK0","",CorrBinsX,-TMath::Pi()/2,3*TMath::Pi()/2,CorrBinsY,-2*fTrackEtaCut,2*fTrackEtaCut,30,0,6);
 549         fHistSibK0->SetStats(0);
 550         fHistSibK0->Sumw2();
 551         fOutputList->Add(fHistSibK0);
 552
 553         fHistMixK0       = new TH3F("hfHistMixK0","",CorrBinsX,-TMath::Pi()/2,3*TMath::Pi()/2,CorrBinsY,-2*fTrackEtaCut,2*fTrackEtaCut,30,0,6);
 554         fHistMixK0->SetStats(0);
 555         fHistMixK0->Sumw2();
 556         fOutputList->Add(fHistMixK0);
 557
 558         fHistSibLambda   = new TH3F("hfHistSibLambda","",CorrBinsX,-TMath::Pi()/2,3*TMath::Pi()/2,CorrBinsY,-2*fTrackEtaCut,2*fTrackEtaCut,30,0,6);
 559         fHistSibLambda->SetStats(0);
 560         fHistSibLambda->Sumw2();
 561         fOutputList->Add(fHistSibLambda);
 562
 563         fHistMixLambda   = new TH3F("hfHistMixLambda","",CorrBinsX,-TMath::Pi()/2,3*TMath::Pi()/2,CorrBinsY,-2*fTrackEtaCut,2*fTrackEtaCut,30,0,6);
 564         fHistMixLambda->SetXTitle("#Delta #Phi");
 565         fHistMixLambda->SetStats(0);
 566         fHistMixLambda->Sumw2();
 567         fOutputList->Add(fHistMixLambda);
 568
 569         fHistSibK0MC     = new TH3F("hfHistSibK0MC","",CorrBinsX,-TMath::Pi()/2,3*TMath::Pi()/2,CorrBinsY,-2*fTrackEtaCut,2*fTrackEtaCut,30,0,6);
 570         fHistSibK0MC->SetStats(0);
 571         fHistSibK0MC->Sumw2();
 572         fOutputList->Add(fHistSibK0MC);
 573
 574         fHistMixK0MC     = new TH3F("hfHistMixK0MC","",CorrBinsX,-TMath::Pi()/2,3*TMath::Pi()/2,CorrBinsY,-2*fTrackEtaCut,2*fTrackEtaCut,30,0,6);
 575         fHistMixK0MC->SetStats(0);
 576         fHistMixK0MC->Sumw2();
 577         fOutputList->Add(fHistMixK0MC);
 578
 579         fHistSibLambdaMC = new TH3F("hfHistSibLambdaMC","",CorrBinsX,-TMath::Pi()/2,3*TMath::Pi()/2,CorrBinsY,-2*fTrackEtaCut,2*fTrackEtaCut,30,0,6);
 580         fHistSibLambdaMC->SetStats(0);
 581         fHistSibLambdaMC->Sumw2();
 582         fOutputList->Add(fHistSibLambdaMC);
 583
 584         fHistMixLambdaMC = new TH3F("hfHistMixLambdaMC","",CorrBinsX,-TMath::Pi()/2,3*TMath::Pi()/2,CorrBinsY,-2*fTrackEtaCut,2*fTrackEtaCut,30,0,6);
 585         fHistMixLambdaMC->SetStats(0);
 586         fHistMixLambdaMC->Sumw2();
 587         fOutputList->Add(fHistMixLambdaMC);
 588
 589         fHistLeadInfo = new TH3F("hfHistLeadInfo","",60,0,12,CorrBinsY/2,-fTrackEtaCut,fTrackEtaCut,CorrBinsX/2,0,3*TMath::Pi());
 590         fOutputList->Add(fHistLeadInfo);
 591
 592         fHistLeadInfoMC = new TH3F("hfHistLeadInfoMC","",60,0,12,CorrBinsY/2,-fTrackEtaCut,fTrackEtaCut,CorrBinsX/2,0,3*TMath::Pi());
 593         fOutputList->Add(fHistLeadInfoMC);
 594
 595         fHistLeadInfoMix = new TH3F("hfHistLeadInfoMix","",60,0,12,CorrBinsY/2,-fTrackEtaCut,fTrackEtaCut,CorrBinsX/2,0,3*TMath::Pi());
 596         fOutputList->Add(fHistLeadInfoMix);
 597
 598         fHistLeadInfoMixMC = new TH3F("hfHistLeadInfoMixMC","",60,0,12,CorrBinsY/2,-fTrackEtaCut,fTrackEtaCut,CorrBinsX/2,0,3*TMath::Pi());
 599         fOutputList->Add(fHistLeadInfoMixMC);
 600
 601         //----------------------------------------------Event Pool-----------------------------------------------------//
 602
 603         fPoolMgr = new AliEventPoolManager(fPoolMaxNEvents, fPoolMinNTracks, fNCentBins, fCentBins, fNzVtxBins, fZvtxBins);
 604         if(!fPoolMgr) return;
 605
 606         if(fAnalysisMC){
 607         fPoolMgrMC = new AliEventPoolManager(fPoolMaxNEvents, fPoolMinNTracks, fNCentBins, fCentBins, fNzVtxBins, fZvtxBins);
 608         if(!fPoolMgr) return;
 609         }
 610
 611         PostData(1, fOutputList);
 612
 613 }
 614 //---------------------------------------------------------------------------------------
 615 void AliLeadingV0Correlation::UserExec(Option_t *)
 616 {
 617
 618     AliAnalysisManager   *mgr      = AliAnalysisManager::GetAnalysisManager();
 619     AliInputEventHandler *inEvMain = (AliInputEventHandler*)(mgr->GetInputEventHandler());
 620         if (!inEvMain) return;
 621
 622         // Pointers to PID Response objects.
 623         fPIDResponse = inEvMain->GetPIDResponse();
 624         if(!fPIDResponse) return;
 625
 626     fAODEvent = dynamic_cast<AliAODEvent*>(inEvMain->GetEvent());
 627         if(!fAODEvent) return;
 628
 629         // physics selection
 630         UInt_t maskIsSelected = inEvMain->IsEventSelected();
 631         Bool_t isSelected = 0;
 632
 633         if( fTriggerMask == "kMB" )
 634             isSelected = (maskIsSelected & AliVEvent::kMB)     == AliVEvent::kMB;
 635         if( fTriggerMask == "kINT7" )
 636                 isSelected = (maskIsSelected & AliVEvent::kINT7)   == AliVEvent::kINT7;
 637         if( fTriggerMask == "kINT8" )
 638                 isSelected = (maskIsSelected & AliVEvent::kINT8)   == AliVEvent::kINT8;
 639         if( fTriggerMask == "kAnyINT" )
 640                 isSelected = (maskIsSelected & AliVEvent::kAnyINT) == AliVEvent::kAnyINT;
 641         if ( ! isSelected )return;
 642
 643         //-----------------------------MC Accsess------------------------------------------------
 644         TClonesArray *stack = 0x0;
 645         Double_t mcXv=0., mcYv=0., mcZv=0.;
 646         Int_t ntrk =0, ntrk0=0;
 647
 648         TObjArray *selectedTracksLeadingMC =0x0;
 649
 650         TObjArray * selectedK0MC =new TObjArray;
 651         selectedK0MC->SetOwner(kTRUE);
 652
 653         TObjArray * selectedLambdaMC =new TObjArray;
 654         selectedLambdaMC->SetOwner(kTRUE);
 655
 656         if (fAnalysisMC) {
 657
 658                 TList *lst = fAODEvent->GetList();
 659                 stack = (TClonesArray*)lst->FindObject(AliAODMCParticle::StdBranchName());
 660                 if (!stack) {Printf("ERROR: stack not available");return;}
 661
 662                 AliAODMCHeader *mcHdr=(AliAODMCHeader*)lst->FindObject(AliAODMCHeader::StdBranchName());
 663                 mcXv=mcHdr->GetVtxX(); mcYv=mcHdr->GetVtxY(); mcZv=mcHdr->GetVtxZ();
 664                 ntrk=stack->GetEntriesFast(), ntrk0=ntrk;
 665                 if(TMath::Abs(mcZv)>fpvzcut)return;
 666
 667                 selectedTracksLeadingMC = FindLeadingObjectsMC(stack);
 668                 if(!selectedTracksLeadingMC) return;
 669                 selectedTracksLeadingMC->SetOwner(kTRUE);
 670         }
 671
 672         // If PID is used:
 673         Double_t lLimitPPID          = 1.0;
 674         Float_t  cutNSigmaLowP       = 3.0;
 675         Float_t  cutNSigmaHighP      = 3.0;
 676         Int_t    lPdgcodeCurrentPart = 0;
 677         Double_t lRapCurrentPart     = 0;
 678         Double_t lPtCurrentPart          = 0;
 679         Double_t lPhiCurrentPart         = 0;
 680         Double_t lEtaCurrentPart         = 0;
 681         Int_t    lComeFromSigma      = 0;
 682
 683         // PID flags:
 684         Int_t LambdaPID = 0;
 685         Int_t AntiLambdaPID = 0;
 686
 687         // current mc particle 's mother
 688         Int_t iCurrentMother  = 0, lPdgCurrentMother    = 0;
 689
 690         // Start loop over MC particles
 691         if (fAnalysisMC) {
 692
 693                 fHistMCPrimaryVertexX->Fill(mcXv);
 694                 fHistMCPrimaryVertexY->Fill(mcYv);
 695                 fHistMCPrimaryVertexZ->Fill(mcZv);
 696
 697                 for (Int_t iMc = 0; iMc < (ntrk); iMc++) {
 698                         AliAODMCParticle *p0=(AliAODMCParticle*)stack->UncheckedAt(iMc);
 699                         if (!p0) continue;
 700
 701                         lPdgcodeCurrentPart = p0->GetPdgCode();
 702
 703                         // Keep only K0s, Lambda and AntiLambda, Xi and Phi:
 704                         if ( (lPdgcodeCurrentPart != 310 ) && (lPdgcodeCurrentPart != 3122 ) && (lPdgcodeCurrentPart != -3122 ) && (lPdgcodeCurrentPart != 3312 ) && (lPdgcodeCurrentPart != -3312) && (lPdgcodeCurrentPart != -333) ) continue;
 705
 706                         lRapCurrentPart   = p0->Y();
 707                         lPtCurrentPart    = p0->Pt();
 708                         lPhiCurrentPart   = p0->Phi();
 709                         lEtaCurrentPart   = p0->Eta();
 710                         iCurrentMother    = p0->GetMother();
 711
 712                         AliAODMCParticle *Mother = (AliAODMCParticle*)stack->UncheckedAt(iCurrentMother);
 713                         if (iCurrentMother == -1){lPdgCurrentMother=0; } else {lPdgCurrentMother = Mother->GetPdgCode();}
 714
 715                         if (( ( TMath::Abs(lPdgCurrentMother)  == 3212)  ||
 716                                   ( TMath::Abs(lPdgCurrentMother)  == 3224)  ||
 717                                   ( TMath::Abs(lPdgCurrentMother)  == 3214)  ||
 718                                   ( TMath::Abs(lPdgCurrentMother)  == 3114) )
 719                            && ( Mother->GetMother() == -1)
 720                                 ) lComeFromSigma = 1;
 721                         else lComeFromSigma  = 0;
 722
 723                         Bool_t isPrimary=p0->IsPhysicalPrimary();
 724                         if (!isPrimary)continue; //keep only primary particles
 725
 726                         // Rapidity Cut
 727                         if (TMath::Abs(lRapCurrentPart) > fRapidityCut) continue;
 728
 729                         if (lPdgcodeCurrentPart==310) {
 730                                 fHistMCRapK0s->Fill(lRapCurrentPart);
 731                                 fHistMCPtK0s->Fill(lPtCurrentPart);
 732                                 fHistPrimRawPtVsYK0s->Fill(lPtCurrentPart,lRapCurrentPart);
 733                                 fHistMCPtAllK0s->Fill(lPtCurrentPart);
 734                                 selectedK0MC->Add(new AliLeadingBasicParticle(lEtaCurrentPart,lPhiCurrentPart,lPtCurrentPart));
 735                         }
 736                         else
 737                         if (lPdgcodeCurrentPart==3122) {
 738                                     fHistMCRapLambda->Fill(lRapCurrentPart);
 739                                         fHistMCPtLambda->Fill(lPtCurrentPart);
 740                                     fHistPrimRawPtVsYLambda->Fill(lPtCurrentPart,lRapCurrentPart);
 741                                         fHistMCPtAllLambda->Fill(lPtCurrentPart);
 742                                         if (lComeFromSigma) fHistMCPtLambdaFromSigma->Fill(lPtCurrentPart);
 743                                     selectedLambdaMC->Add(new AliLeadingBasicParticle(lEtaCurrentPart,lPhiCurrentPart,lPtCurrentPart));
 744
 745                                 }
 746                         else
 747                         if (lPdgcodeCurrentPart==-3122) {
 748                                         fHistMCRapAntiLambda->Fill(lRapCurrentPart);
 749                                                 fHistMCPtAntiLambda->Fill(lPtCurrentPart);
 750                                                 fHistPrimRawPtVsYAntiLambda->Fill(lPtCurrentPart,lRapCurrentPart);
 751                                                 fHistMCPtAllAntiLambda->Fill(lPtCurrentPart);
 752                                                 if (lComeFromSigma) fHistMCPtAntiLambdaFromSigma->Fill(lPtCurrentPart);
 753                                         }
 754
 755                 } // end loop AOD MC
 756         } // End Loop over MC condition
 757
 758         //-----------------------------------------------------------------------------------------
 759
 760         // Vertex cut
 761         Double_t  lPrimaryVtxPosition[3];
 762         AliAODVertex *myPrimVertex = fAODEvent->GetPrimaryVertex();
 763         if (!myPrimVertex) return;
 764         myPrimVertex->GetXYZ(lPrimaryVtxPosition);
 765
 766         Double_t lPVx = lPrimaryVtxPosition[0];
 767         Double_t lPVy = lPrimaryVtxPosition[1];
 768         Double_t lPVz = lPrimaryVtxPosition[2];
 769         if ((TMath::Abs(lPVz)) >= fpvzcut) return ;
 770
 771         if (TMath::Abs(lPVx)<10e-5 && TMath::Abs(lPVy)<10e-5 && TMath::Abs(lPVz)<10e-5) return;
 772
 773         fHistPrimaryVertexX->Fill(lPVx);
 774     fHistPrimaryVertexY->Fill(lPVy);
 775     fHistPrimaryVertexZ->Fill(lPVz);
 776
 777         // Centrality definition
 778         AliCentrality *centralityObj = 0;
 779         Int_t multiplicity = -1;
 780         Double_t MultipOrCent = -1;
 781
 782         // initialize the pool for event mixing
 783         if(fcollidingSys=="PP"){
 784                 multiplicity = fAODEvent->GetNTracks();
 785                 MultipOrCent = multiplicity; // convert from Int_t to Double_t
 786         }
 787         if(fcollidingSys=="PbPb"){
 788                 centralityObj = fAODEvent->GetHeader()->GetCentralityP();
 789                 MultipOrCent  = centralityObj->GetCentralityPercentileUnchecked("V0M");
 790                 if ((MultipOrCent < 0.)||(MultipOrCent > 90.)) return;
 791         }
 792
 793         Double_t * CentBins = fCentBins;
 794         Double_t poolmin    = CentBins[0];
 795         Double_t poolmax    = CentBins[fNCentBins];
 796
 797         TObjArray *selectedTracksLeading = FindLeadingObjects(fAODEvent);
 798         if(!selectedTracksLeading) return;
 799         selectedTracksLeading->SetOwner(kTRUE);
 800
 801         // -------------------------------------V0 loop for reconstructed event------------------------
 802         Double_t lPLambda     = 0;
 803         Double_t lPAntiLambda = 0;
 804         Double_t lPK0s        = 0;
 805
 806         // Variables:
 807         Double_t  lV0Position[3];
 808
 809         Double_t lDcaPosToPrimVertex = 0;
 810         Double_t lDcaNegToPrimVertex = 0;
 811         Double_t lDcaV0Daughters     = 0;
 812         Double_t lV0cosPointAngle    = 0;
 813         Double_t lV0DecayLength      = 0;
 814         Double_t lV0Radius           = 0;
 815         Double_t lDcaV0ToPrimVertex  = 0;
 816         Double_t lcTauLambda         = 0;
 817         Double_t lcTauAntiLambda     = 0;
 818         Double_t lcTauK0s            = 0;
 819
 820         Double_t lInvMassK0   = 0, lInvMassLambda = 0, lInvMassAntiLambda = 0;
 821         Double_t lPtK0s       = 0, lPtLambda      = 0, lPtAntiLambda      = 0;
 822         Double_t lPhiK0s      = 0, lPhiLambda     = 0, lPhiAntiLambda     = 0;
 823         Double_t lEtaK0s      = 0, lEtaLambda     = 0, lEtaAntiLambda     = 0;
 824         Double_t lRapK0s      = 0, lRapLambda     = 0, lRapAntiLambda     = 0;
 825         Double_t lPzK0s       = 0, lPzLambda      = 0, lPzAntiLambda      = 0;
 826         Double_t lAlphaV0     = 0, lPtArmV0       = 0;
 827
 828         //Associated V0s:
 829
 830         UInt_t   lLabelTrackPos       = 0, lLabelTrackNeg         = 0;
 831         Int_t    lCheckPIdK0Short     = 0, lCheckMcK0Short        = 0;
 832         Int_t    lCheckPIdLambda      = 0, lCheckMcLambda         = 0;
 833         Int_t    lCheckPIdAntiLambda  = 0, lCheckMcAntiLambda     = 0;
 834         Int_t    lCheckSecondaryK0s   = 0, lCheckSecondaryLambda  = 0, lCheckSecondaryAntiLambda  = 0;
 835         Double_t mcPosMotherX         = 0, mcPosMotherY           = 0, mcPosMotherZ  = 0;
 836         Double_t mcPosMotherR         = 0;
 837         Double_t mcMotherPt           = 0;
 838
 839         Int_t lIndexPosMother         = 0;
 840         Int_t lIndexNegMother         = 0;
 841         Int_t lIndexMotherOfMother    = 0;
 842         Int_t lPDGCodePosDaughter     = 0;
 843         Int_t lPDGCodeNegDaughter     = 0;
 844         Int_t lPdgcodeMother          = 0;
 845         Int_t lPdgcodeMotherOfMother  = 0;
 846
 847         // Daughters' momentum:
 848         Double_t  lMomPos[3] = {999,999,999};
 849         Double_t  lMomNeg[3] = {999,999,999};
 850         Double_t  lPtPos = 999, lPtNeg = 999;
 851
 852         // Inner Wall parameters:
 853         Double_t  lMomInnerWallPos =999, lMomInnerWallNeg = 999;
 854         Double_t  ldEdxPos         =0.0, ldEdxNeg         = 0.0;
 855
 856         // PID
 857         Float_t nSigmaPosPion   = 0;
 858         Float_t nSigmaNegPion   = 0;
 859         Float_t nSigmaPosProton = 0;
 860         Float_t nSigmaNegProton = 0;
 861
 862
 863         Int_t lCheckPIDK0sPosDaughter        = 0, lCheckPIDK0sNegDaughter        = 0;
 864         Int_t lCheckPIDLambdaPosDaughter     = 0, lCheckPIDLambdaNegDaughter     = 0;
 865         Int_t lCheckPIDAntiLambdaPosDaughter = 0, lCheckPIDAntiLambdaNegDaughter = 0;
 866
 867         //---------------------------------------------------------------------------------------------
 868         TObjArray * selectedK0 = new TObjArray;
 869         selectedK0->SetOwner(kTRUE);
 870
 871         TObjArray * selectedLambda = new TObjArray;
 872         selectedLambda->SetOwner(kTRUE);
 873
 874         Int_t nV0s = fAODEvent->GetNumberOfV0s();
 875
 876         for (Int_t i = 0; i < nV0s; i++)
 877         { // start of V0 slection loop
 878                 AliAODv0* aodV0 = dynamic_cast<AliAODv0 *>(fAODEvent->GetV0(i));
 879                 if (!aodV0) {AliError(Form("ERROR: Could not retrieve aodaodV0 %d", i));continue;}
 880
 881                 lIndexPosMother     = 0; lIndexNegMother     = 0; lIndexMotherOfMother       = 0;
 882                 lCheckPIdK0Short    = 0; lCheckMcK0Short     = 0; lCheckSecondaryK0s         = 0;
 883                 lCheckPIdLambda     = 0; lCheckMcLambda      = 0; lCheckSecondaryLambda      = 0;
 884                 lCheckPIdAntiLambda = 0; lCheckMcAntiLambda  = 0; lCheckSecondaryAntiLambda  = 0;
 885                 lComeFromSigma      = -1;
 886
 887         // get daughters
 888
 889             AliAODTrack *myTrackPos=(AliAODTrack *)(aodV0->GetDaughter(0));
 890         AliAODTrack *myTrackNeg=(AliAODTrack *)(aodV0->GetDaughter(1));
 891
 892                 if (!myTrackPos || !myTrackNeg) {Printf("ERROR: Could not retreive one of the daughter track");continue;}
 893         if (!IsAcseptedV0(fAODEvent,aodV0,myTrackPos,myTrackNeg)) continue;
 894
 895                 // VO's main characteristics to check the reconstruction cuts
 896                 lDcaV0Daughters    = aodV0->DcaV0Daughters();
 897                 lDcaV0ToPrimVertex = aodV0->DcaV0ToPrimVertex();
 898                 lV0cosPointAngle   = aodV0->CosPointingAngle(lPrimaryVtxPosition);
 899
 900                 aodV0->GetXYZ(lV0Position);
 901
 902                 lV0Radius      = TMath::Sqrt(lV0Position[0]*lV0Position[0]+lV0Position[1]*lV0Position[1]);
 903                 lV0DecayLength = TMath::Sqrt(TMath::Power(lV0Position[0] - lPrimaryVtxPosition[0],2) +
 904                                                                          TMath::Power(lV0Position[1] - lPrimaryVtxPosition[1],2) +
 905                                                                          TMath::Power(lV0Position[2] - lPrimaryVtxPosition[2],2 ));
 906
 907                 lLabelTrackPos = (UInt_t)TMath::Abs(myTrackPos->GetLabel());
 908                 lLabelTrackNeg = (UInt_t)TMath::Abs(myTrackNeg->GetLabel());
 909
 910                 // Daughters Pt and P:
 911                 lPtPos = TMath::Sqrt(lMomPos[0]*lMomPos[0] + lMomPos[1]*lMomPos[1]);
 912                 lPtNeg = TMath::Sqrt(lMomNeg[0]*lMomNeg[0] + lMomNeg[1]*lMomNeg[1]);
 913
 914                 // Inner Wall parameter:
 915                 const AliAODPid *pidPos=myTrackPos->GetDetPid();
 916                 const AliAODPid *pidNeg=myTrackNeg->GetDetPid();
 917
 918                 // innerWall momentum
 919                 lMomInnerWallPos = pidPos->GetTPCmomentum();
 920                 lMomInnerWallNeg = pidNeg->GetTPCmomentum();
 921
 922                 ldEdxPos = pidPos->GetTPCsignal();
 923                 ldEdxNeg = pidNeg->GetTPCsignal();
 924
 925                 // DCA between daughter and Primary Vertex:
 926                 if (myTrackPos) lDcaPosToPrimVertex = aodV0->DcaPosToPrimVertex();
 927                 if (myTrackNeg) lDcaNegToPrimVertex = aodV0->DcaNegToPrimVertex();
 928
 929                 // Quality tracks cuts:
 930                 if ( !(IsAcseptedDaughterTrack(myTrackPos)) || !(IsAcseptedDaughterTrack(myTrackNeg)) ) { continue;}
 931
 932                 // Armenteros variables:
 933                 lAlphaV0      =  aodV0->AlphaV0();
 934                 lPtArmV0      =  aodV0->PtArmV0();
 935
 936                 // Invariant mass
 937                 lInvMassK0 = aodV0->MassK0Short();
 938                 lPtK0s = aodV0->Pt();
 939                 lPhiK0s= aodV0->Phi();
 940                 lEtaK0s= aodV0->Eta();
 941                 lPzK0s = aodV0->Pz();
 942
 943                 lInvMassLambda = aodV0->MassLambda();
 944                 lPtLambda = aodV0->Pt();
 945                 lPhiLambda= aodV0->Phi();
 946                 lEtaLambda= aodV0->Eta();
 947                 lPzLambda = aodV0->Pz();
 948
 949                 lInvMassAntiLambda = aodV0->MassAntiLambda();
 950                 lPtAntiLambda      = aodV0->Pt();
 951                 lPhiAntiLambda     = aodV0->Phi();
 952                 lEtaAntiLambda     = aodV0->Eta();
 953                 lPzAntiLambda      = aodV0->Pz();
 954
 955                 // Rapidity:
 956                 lRapK0s    = aodV0->RapK0Short();
 957                 lRapLambda = aodV0->RapLambda();
 958                 lRapAntiLambda = aodV0->Y(-3122);
 959
 960                 if (lPtK0s==0) {continue;}
 961                 if (lPtLambda==0) {continue;}
 962                 if (lPtAntiLambda==0) {continue;}
 963
 964                 if (fUsePID=="withPID") {
 965                         nSigmaPosPion   = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(myTrackPos, AliPID::kPion));
 966                         nSigmaNegPion   = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(myTrackNeg, AliPID::kPion));
 967                         nSigmaPosProton = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(myTrackPos, AliPID::kProton));
 968                         nSigmaNegProton = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(myTrackNeg, AliPID::kProton));
 969                 }
 970                 else {nSigmaPosPion = 0; nSigmaNegPion =0; nSigmaPosProton = 0; nSigmaNegProton= 0;}
 971
 972                 // Monte-Carlo particle associated to reconstructed particles:
 973                 if (fAnalysisMC) {
 974
 975                         AliAODMCParticle *pp=(AliAODMCParticle*)stack->UncheckedAt(lLabelTrackPos);
 976                         if(!pp) { continue;}
 977                         AliAODMCParticle *np=(AliAODMCParticle*)stack->UncheckedAt(lLabelTrackNeg);
 978                         if (!np)        { continue;}
 979
 980                         lPDGCodePosDaughter = pp->GetPdgCode();
 981                         lPDGCodeNegDaughter = np->GetPdgCode();
 982                         lIndexPosMother = pp->GetMother();
 983                         lIndexNegMother = np->GetMother();
 984
 985                         if (lIndexPosMother == -1) {
 986
 987                                 lPdgcodeMother = 0;
 988                                 lIndexMotherOfMother = 0;
 989                                 mcPosMotherX = 0;
 990                                 mcPosMotherY = 0;
 991                                 mcPosMotherZ = 0;
 992                                 mcPosMotherR = 0;
 993                                 mcMotherPt = 1;
 994                         }
 995
 996                         else {
 997                                 AliAODMCParticle *lMCAODMother=(AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother);
 998                                 if (!lMCAODMother)      { continue;}
 999                                 lPdgcodeMother         = lMCAODMother->GetPdgCode();
1000                                 lIndexMotherOfMother   = lMCAODMother->GetMother();
1001                                 if (lIndexMotherOfMother ==-1) lPdgcodeMotherOfMother = 0;
1002                                 else {
1003                                         AliAODMCParticle *lMCAODMotherOfMother=(AliAODMCParticle*)stack->UncheckedAt(lIndexMotherOfMother);
1004                                         if (!lMCAODMotherOfMother)      {continue;}
1005                                         lPdgcodeMotherOfMother = lMCAODMotherOfMother->GetPdgCode();
1006                                 }
1007                                 mcPosMotherX = lMCAODMother->Xv();
1008                                 mcPosMotherY = lMCAODMother->Yv();
1009                                 mcPosMotherZ = lMCAODMother->Zv();
1010                                 mcPosMotherR = TMath::Sqrt(mcPosMotherX*mcPosMotherX+mcPosMotherY*mcPosMotherY);
1011
1012                                 mcMotherPt   = lMCAODMother->Pt();
1013                         }
1014                 }
1015
1016         }
1017
1018         if (fAnalysisMC) {
1019                 if(((lPDGCodePosDaughter==+211) && (lPDGCodeNegDaughter==-211))){lCheckPIdK0Short = 1;
1020                         if ( (lIndexPosMother==lIndexNegMother) &&(lPdgcodeMother==310) ){
1021                                 if (((AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother))->IsPrimary()) lCheckMcK0Short  = 1;
1022                                 else lCheckSecondaryK0s = 1;
1023                         }
1024                 }
1025                 else if(((lPDGCodePosDaughter==+2212) && (lPDGCodeNegDaughter==-211))){lCheckPIdLambda = 1;
1026                         if ((lIndexPosMother==lIndexNegMother) &&(lPdgcodeMother==3122)  ){
1027                                 if ( ( TMath::Abs(lPdgcodeMotherOfMother) == 3212) ||
1028                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3224) ||
1029                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3214) ||
1030                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3114))lComeFromSigma = 1;
1031                                 else lComeFromSigma = 0;
1032                                 if (((AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother))->IsPrimary()||
1033                                    (!(((AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother))->IsPrimary() )&&
1034                                    (lComeFromSigma)))lCheckMcLambda  = 1;
1035                                 else lCheckSecondaryLambda    = 1;
1036                         }
1037                 }
1038                 else if(((lPDGCodePosDaughter==211) && (lPDGCodeNegDaughter==-2212))){lCheckPIdAntiLambda = 1;
1039                         if ( (lIndexPosMother==lIndexNegMother) &&
1040                                 (lPdgcodeMother==-3122) ) {
1041                                 if ( ( TMath::Abs(lPdgcodeMotherOfMother) == 3212) ||
1042                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3224) ||
1043                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3214) ||
1044                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3114)
1045                                         )lComeFromSigma = 1;
1046                                 else lComeFromSigma = 0;
1047                                 if (((AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother))->IsPrimary() ||
1048                                    ((!((AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother))->IsPrimary())&&
1049                                    (lComeFromSigma)))lCheckMcAntiLambda  = 1;
1050                                 else lCheckSecondaryAntiLambda = 1;
1051                         }
1052                 }
1053         } // end "look for associated particles
1054
1055         // PID condition:
1056         lCheckPIDK0sPosDaughter        = 0, lCheckPIDK0sNegDaughter        = 0;
1057         lCheckPIDLambdaPosDaughter     = 0, lCheckPIDLambdaNegDaughter     = 0;
1058         lCheckPIDAntiLambdaPosDaughter = 0, lCheckPIDAntiLambdaNegDaughter = 0;
1059
1060         if (lMomInnerWallPos < lLimitPPID) {
1061                 if (nSigmaPosPion < cutNSigmaLowP){
1062                         lCheckPIDK0sPosDaughter        = 1;
1063                         lCheckPIDAntiLambdaPosDaughter = 1;
1064                 }
1065                 if (nSigmaPosProton < cutNSigmaLowP) lCheckPIDLambdaPosDaughter    = 1;
1066         }
1067
1068         else if (lMomInnerWallPos > lLimitPPID) {
1069                 if (nSigmaPosPion < cutNSigmaHighP)   {
1070                         lCheckPIDK0sPosDaughter        = 1;
1071                         lCheckPIDAntiLambdaPosDaughter = 1;
1072                 }
1073                 if (nSigmaPosProton < cutNSigmaHighP) lCheckPIDLambdaPosDaughter    = 1;
1074         }
1075
1076         if (lMomInnerWallNeg < lLimitPPID) {
1077                 if (nSigmaNegPion < cutNSigmaLowP){
1078                         lCheckPIDK0sNegDaughter       = 1;
1079                         lCheckPIDLambdaNegDaughter    = 1;
1080                 }
1081                 if (nSigmaNegProton < cutNSigmaLowP)  lCheckPIDAntiLambdaNegDaughter = 1;
1082
1083         }
1084         else if (lMomInnerWallNeg > lLimitPPID) {
1085                 if (nSigmaNegPion < cutNSigmaHighP){
1086                         lCheckPIDK0sNegDaughter       = 1;
1087                         lCheckPIDLambdaNegDaughter    = 1;
1088                 }
1089                 if (nSigmaNegProton < cutNSigmaHighP) lCheckPIDAntiLambdaNegDaughter = 1;
1090         }
1091
1092         //************************************filling histograms********************************//
1093
1094         if((fUsePID=="withPID") && (lCheckPIDAntiLambdaNegDaughter==0) && lCheckPIDLambdaPosDaughter==1) LambdaPID = 1;
1095         else LambdaPID =0;
1096         if((fUsePID=="withPID") && (lCheckPIDLambdaPosDaughter==0) && lCheckPIDAntiLambdaNegDaughter==1) AntiLambdaPID = 1;
1097         else AntiLambdaPID =0;
1098
1099         lPLambda = TMath::Sqrt(lPzLambda*lPzLambda + lPtLambda*lPtLambda);
1100         lPAntiLambda = TMath::Sqrt(lPzAntiLambda*lPzAntiLambda + lPtAntiLambda*lPtAntiLambda);
1101         lPK0s = TMath::Sqrt(lPzK0s*lPzK0s + lPtK0s*lPtK0s);
1102
1103         if(lPLambda > 0)     lcTauLambda     = (lV0DecayLength*lInvMassLambda)/lPLambda;
1104         if(lPAntiLambda > 0) lcTauAntiLambda = (lV0DecayLength*lInvMassAntiLambda)/lPAntiLambda;
1105         if(lPK0s > 0)        lcTauK0s        = (lV0DecayLength*lInvMassK0)/lPK0s;
1106         //--------------------------------------------K0s---------------------------------//
1107     if(!fAnalysisMC){
1108         if (lcTauK0s< fCTauK0){
1109                 if (TMath::Abs(lRapK0s) < fRapidityCut ){
1110                         if(lPtArmV0*fSpecialArmenterosCutK0s>(TMath::Abs(lAlphaV0))){
1111                                 fHistMassK0->Fill(lInvMassK0);
1112                                 fHistPtVsMassK0->Fill(lInvMassK0,lPtK0s);
1113                                 fHistDcaPosToPrimVertexK0vsMassK0->Fill(lDcaPosToPrimVertex,lInvMassK0);
1114                                 fHistDcaNegToPrimVertexK0vsMassK0->Fill(lDcaNegToPrimVertex,lInvMassK0);
1115                                 fHistRadiusV0K0vsMassK0->Fill(lV0Radius,lInvMassK0);
1116                                 fHistDecayLengthV0K0vsMassK0->Fill(lV0DecayLength,lInvMassK0);
1117                                 fHistDcaV0DaughtersK0vsMassK0->Fill(lDcaV0Daughters,lInvMassK0);
1118                                 fHistCosPointAngleK0vsMassK0->Fill(lV0cosPointAngle,lInvMassK0);
1119                                 fHistArmenterosPodolanskiK0->Fill(lAlphaV0,lPtArmV0);
1120                         if(IsK0InvMass(lInvMassK0)){selectedK0->Add(new AliLeadingBasicParticle(lEtaK0s,lPhiK0s,lPtK0s));}
1121                   }//Special Armesto Cut for K0
1122                 } // if rap. condition
1123         } // end cTau condition
1124         //-----------------------------------------Lambda---------------------------------//
1125         if (lcTauLambda < fCTauLambda){
1126                 if ((LambdaPID==1 && lMomInnerWallPos  <=1 ) || (lMomInnerWallPos >1 ) ||  !(fUsePID=="withPID")){
1127                         if (TMath::Abs(lRapLambda) <fRapidityCut) {
1128                                         fHistMassLambda->Fill(lInvMassLambda);
1129                                         fHistPtVsMassLambda->Fill(lInvMassLambda,lPtLambda);
1130                                         fHistDcaPosToPrimVertexLvsMassL->Fill(lDcaPosToPrimVertex,lInvMassLambda);
1131                                         fHistDcaNegToPrimVertexLvsMassL->Fill(lDcaNegToPrimVertex,lInvMassLambda);
1132                                         fHistRadiusV0LvsMassL->Fill(lV0Radius,lInvMassLambda);
1133                                         fHistDecayLengthV0LvsMassL->Fill(lV0DecayLength,lInvMassLambda);
1134                                         fHistDcaV0DaughtersLvsMassL->Fill(lDcaV0Daughters,lInvMassLambda);
1135                                         fHistCosPointAngleLvsMassL->Fill(lV0cosPointAngle,lInvMassLambda);
1136                                         fHistArmenterosPodolanskiLambda->Fill(lAlphaV0,lPtArmV0);
1137                                 if(IsLambdaInvMass(lInvMassLambda)){selectedLambda->Add(new AliLeadingBasicParticle(lEtaLambda,lPhiLambda,lPtLambda));}
1138                         } //end of Rap condition
1139                 }//End PID
1140         }  //end cTau condition
1141
1142         //--------------------------------------AntiLambda---------------------------------//
1143         if (lcTauAntiLambda < fCTauLambda){
1144                 if ((AntiLambdaPID==1 && lMomInnerWallNeg <=1) || (lMomInnerWallNeg >1) ||  !(fUsePID=="withPID")){
1145                         if (TMath::Abs(lRapAntiLambda) < fRapidityCut) {
1146                                         fHistMassAntiLambda->Fill(lInvMassAntiLambda);
1147                                         fHistPtVsMassAntiLambda->Fill(lInvMassAntiLambda,lPtAntiLambda);
1148                                         fHistDcaPosToPrimVertexAntiLvsMass->Fill(lDcaPosToPrimVertex,lInvMassAntiLambda);
1149                                         fHistDcaNegToPrimVertexAntiLvsMass->Fill(lDcaNegToPrimVertex,lInvMassAntiLambda);
1150                                         fHistRadiusV0AntiLvsMass->Fill(lV0Radius,lInvMassAntiLambda);
1151                                         fHistDecayLengthV0AntiLvsMass->Fill(lV0DecayLength,lInvMassAntiLambda);
1152                                         fHistDcaV0DaughtersAntiLvsMass->Fill(lDcaV0Daughters,lInvMassAntiLambda);
1153                                         fHistCosPointAngleAntiLvsMass->Fill(lV0cosPointAngle,lInvMassAntiLambda);
1154                                         fHistArmenterosPodolanskiAntiLambda->Fill(lAlphaV0,lPtArmV0);
1155                         } //end of Rap condition
1156                 } // end of PID condition
1157         } //end cTau condition
1158 }
1159         if(fAnalysisMC) {
1160         //--------------------------------------K0s Associated---------------------------------//
1161
1162         if (lcTauK0s< fCTauK0) {
1163                 if (TMath::Abs(lRapK0s) < fRapidityCut) {
1164                                         if(lCheckPIdK0Short) fHistPidMcMassK0->Fill(lInvMassK0);
1165                                         if(lCheckMcK0Short) {
1166                                                 fHistAsMcPtK0->Fill(lPtK0s);
1167                                                 fHistAsMcProdRadiusK0->Fill(mcPosMotherR);
1168                                                 fHistAsMcProdRadiusXvsYK0s->Fill(mcPosMotherX,mcPosMotherY);
1169                                         if(lPtArmV0*fSpecialArmenterosCutK0s>(TMath::Abs(lAlphaV0))){
1170                                                 fHistMassK0->Fill(lInvMassK0);
1171                                                 fHistPtVsMassK0->Fill(lInvMassK0,lPtK0s);
1172                                                 fHistDcaPosToPrimVertexK0vsMassK0->Fill(lDcaPosToPrimVertex,lInvMassK0);
1173                                                 fHistDcaNegToPrimVertexK0vsMassK0->Fill(lDcaNegToPrimVertex,lInvMassK0);
1174                                                 fHistRadiusV0K0vsMassK0->Fill(lV0Radius,lInvMassK0);
1175                                                 fHistDecayLengthV0K0vsMassK0->Fill(lV0DecayLength,lInvMassK0);
1176                                                 fHistDcaV0DaughtersK0vsMassK0->Fill(lDcaV0Daughters,lInvMassK0);
1177                                                 fHistCosPointAngleK0vsMassK0->Fill(lV0cosPointAngle,lInvMassK0);
1178                                                 fHistArmenterosPodolanskiK0->Fill(lAlphaV0,lPtArmV0);
1179                                         if(IsK0InvMass(lInvMassK0)){selectedK0->Add(new AliLeadingBasicParticle(lEtaK0s,lPhiK0s,lPtK0s));}
1180                                                         }
1181                                         }
1182                                         if (lCheckSecondaryK0s) {
1183                                                 fHistAsMcSecondaryPtVsRapK0s->Fill(lPtK0s,lRapK0s);
1184                                                 fHistAsMcSecondaryProdRadiusK0s->Fill(mcPosMotherR);
1185                                                 fHistAsMcSecondaryProdRadiusXvsYK0s->Fill(mcPosMotherX,mcPosMotherY);
1186                                         }
1187                 } // end rapidity condition
1188         } //end cTau condition
1189         //-----------------------------------Lambda Associated---------------------------------//
1190         if (lcTauLambda < fCTauLambda){
1191                 if (TMath::Abs(lRapLambda) < fRapidityCut) {
1192                                         if(lCheckPIdLambda) fHistPidMcMassLambda->Fill(lInvMassLambda);
1193                                         if(lCheckMcLambda) {
1194                                                 fHistAsMcPtLambda->Fill(lPtLambda);
1195                                                 fHistAsMcProdRadiusLambda->Fill(mcPosMotherR);
1196                                                 fHistAsMcProdRadiusXvsYLambda->Fill(mcPosMotherX,mcPosMotherY);
1197                                         if (lComeFromSigma) fHistAsMcPtLambdaFromSigma->Fill(lPtLambda);
1198                                                 fHistMassLambda->Fill(lInvMassLambda);
1199                                                 fHistPtVsMassLambda->Fill(lInvMassLambda,lPtLambda);
1200                                                 fHistDcaPosToPrimVertexLvsMassL->Fill(lDcaPosToPrimVertex,lInvMassLambda);
1201                                                 fHistDcaNegToPrimVertexLvsMassL->Fill(lDcaNegToPrimVertex,lInvMassLambda);
1202                                                 fHistRadiusV0LvsMassL->Fill(lV0Radius,lInvMassLambda);
1203                                                 fHistDecayLengthV0LvsMassL->Fill(lV0DecayLength,lInvMassLambda);
1204                                                 fHistDcaV0DaughtersLvsMassL->Fill(lDcaV0Daughters,lInvMassLambda);
1205                                                 fHistCosPointAngleLvsMassL->Fill(lV0cosPointAngle,lInvMassLambda);
1206                                                 fHistArmenterosPodolanskiLambda->Fill(lAlphaV0,lPtArmV0);
1207                                         if(IsLambdaInvMass(lInvMassLambda)){selectedLambda->Add(new AliLeadingBasicParticle(lEtaLambda,lPhiLambda,lPtLambda));}
1208                                         }
1209                                         if (lCheckSecondaryLambda) {
1210                                                 fHistAsMcSecondaryPtVsRapLambda->Fill(lPtLambda,lRapLambda);
1211                                                 fHistAsMcSecondaryProdRadiusLambda->Fill(mcPosMotherR);
1212                                                 fHistAsMcSecondaryProdRadiusXvsYLambda->Fill(mcPosMotherX,mcPosMotherY);
1213                                         if (lComeFromSigma) fHistAsMcSecondaryPtLambdaFromSigma->Fill(lPtLambda);
1214                                         }
1215                 } // end rapidity condition
1216         }//end cTau condition
1217 //------------------------------AntiLambda Associated---------------------------------//
1218         if (lcTauAntiLambda < fCTauLambda){
1219                 if (TMath::Abs(lRapAntiLambda) < fRapidityCut) {
1220                                         if(lCheckPIdAntiLambda) fHistPidMcMassAntiLambda->Fill(lInvMassAntiLambda);
1221                                         if(lCheckMcAntiLambda) {
1222                                                 fHistAsMcPtAntiLambda->Fill(lPtAntiLambda);
1223                                                 fHistAsMcProdRadiusAntiLambda->Fill(mcPosMotherR);
1224                                                 fHistAsMcProdRadiusXvsYAntiLambda->Fill(mcPosMotherX,mcPosMotherY);
1225                                         if (lComeFromSigma) fHistAsMcPtAntiLambdaFromSigma->Fill(lPtAntiLambda);
1226                                                         fHistMassAntiLambda->Fill(lInvMassAntiLambda);
1227                                                         fHistPtVsMassAntiLambda->Fill(lInvMassAntiLambda,lPtAntiLambda);
1228                                                         fHistDcaPosToPrimVertexAntiLvsMass->Fill(lDcaPosToPrimVertex,lInvMassAntiLambda);
1229                                                         fHistDcaNegToPrimVertexAntiLvsMass->Fill(lDcaNegToPrimVertex,lInvMassAntiLambda);
1230                                                         fHistRadiusV0AntiLvsMass->Fill(lV0Radius,lInvMassAntiLambda);
1231                                                         fHistDecayLengthV0AntiLvsMass->Fill(lV0DecayLength,lInvMassAntiLambda);
1232                                                         fHistDcaV0DaughtersAntiLvsMass->Fill(lDcaV0Daughters,lInvMassAntiLambda);
1233                                                         fHistCosPointAngleAntiLvsMass->Fill(lV0cosPointAngle,lInvMassAntiLambda);
1234                                                         fHistArmenterosPodolanskiAntiLambda->Fill(lAlphaV0,lPtArmV0);
1235                                         }
1236                                         if (lCheckSecondaryAntiLambda) {
1237                                                 fHistAsMcSecondaryPtVsRapAntiLambda->Fill(lPtAntiLambda,lRapAntiLambda);
1238                                                 fHistAsMcSecondaryProdRadiusAntiLambda->Fill(mcPosMotherR);
1239                                                 fHistAsMcSecondaryProdRadiusXvsYAntiLambda->Fill(mcPosMotherX,mcPosMotherY);
1240                                         if (lComeFromSigma) fHistAsMcSecondaryPtAntiLambdaFromSigma->Fill(lPtAntiLambda);
1241                                         }
1242                 } // end rapidity condition
1243         }//end cTau condition
1244
1245         // Correlation part
1246         FillCorrelations(selectedTracksLeadingMC,selectedK0MC,fHistSibK0MC,fHistLeadInfoMC);
1247         FillCorrelations(selectedTracksLeadingMC,selectedLambdaMC,fHistSibLambdaMC,0);
1248
1249         // Mixing part
1250         if(TMath::Abs(lPVz)>=10 || MultipOrCent>poolmax || MultipOrCent < poolmin) {
1251                 if(fcollidingSys=="PP")AliInfo(Form("pp Event with Zvertex = %.2f cm and multiplicity = %.0f out of pool bounds, SKIPPING",mcZv,MultipOrCent));
1252                 if(fcollidingSys=="PbPb") AliInfo(Form("PbPb Event with Zvertex = %.2f cm and centrality = %.1f  out of pool bounds, SKIPPING",mcZv,MultipOrCent));
1253                 return;
1254         }
1255
1256         fPoolK0MC = fPoolMgrMC->GetEventPool(MultipOrCent, mcZv);
1257         if (!fPoolK0MC){AliInfo(Form("No pool found for multiplicity = %f, zVtx = %f cm", MultipOrCent, mcZv));return;}
1258
1259         if (fPoolK0MC->IsReady() || fPoolK0MC->NTracksInPool() > fPoolMinNTracks  || fPoolK0MC->GetCurrentNEvents() >= fMinEventsToMix)
1260         {
1261                 for (Int_t jMix=0; jMix<fPoolK0MC->GetCurrentNEvents(); jMix++)
1262                 FillCorrelations(selectedTracksLeadingMC, fPoolK0MC->GetEvent(jMix),fHistMixK0MC,fHistLeadInfoMixMC);
1263                 fPoolK0MC->UpdatePool(CloneAndReduceTrackList(selectedK0MC));
1264         }
1265
1266         fPoolLambdaMC = fPoolMgrMC->GetEventPool(MultipOrCent, mcZv);
1267         if (!fPoolLambdaMC){AliInfo(Form("No pool found for multiplicity = %f, zVtx = %f cm", MultipOrCent, mcZv));return;}
1268
1269         if (fPoolLambdaMC->IsReady() || fPoolLambdaMC->NTracksInPool() > fPoolMinNTracks  || fPoolLambdaMC->GetCurrentNEvents() >= fMinEventsToMix)
1270         {
1271                 for (Int_t jMix=0; jMix<fPoolLambdaMC->GetCurrentNEvents(); jMix++)
1272                 FillCorrelations(selectedTracksLeadingMC, fPoolLambdaMC->GetEvent(jMix),fHistMixLambdaMC,0);
1273                 fPoolLambdaMC->UpdatePool(CloneAndReduceTrackList(selectedLambdaMC));
1274         }
1275 }
1276
1277         FillCorrelations(selectedTracksLeading,selectedK0,fHistSibK0,fHistLeadInfo);
1278         FillCorrelations(selectedTracksLeading,selectedLambda,fHistSibLambda,0);
1279
1280         // Mixing part
1281         if(TMath::Abs(lPVz)>=10 || MultipOrCent>poolmax || MultipOrCent < poolmin) {
1282                 if(fcollidingSys=="PP")AliInfo(Form("pp Event with Zvertex = %.2f cm and multiplicity = %.0f out of pool bounds, SKIPPING",lPVz,MultipOrCent));
1283                 if(fcollidingSys=="PbPb") AliInfo(Form("PbPb Event with Zvertex = %.2f cm and centrality = %.1f  out of pool bounds, SKIPPING",lPVz,MultipOrCent));
1284                 return;
1285         }
1286
1287         fPoolK0 = fPoolMgr->GetEventPool(MultipOrCent, lPVz);
1288         if (!fPoolK0){AliInfo(Form("No pool found for multiplicity = %f, zVtx = %f cm", MultipOrCent, lPVz));return;}
1289
1290     if (fPoolK0->IsReady() || fPoolK0->NTracksInPool() > fPoolMinNTracks  || fPoolK0->GetCurrentNEvents() >= fMinEventsToMix)
1291         {
1292                 for (Int_t jMix=0; jMix<fPoolK0->GetCurrentNEvents(); jMix++)
1293                         FillCorrelations(selectedTracksLeading, fPoolK0->GetEvent(jMix),fHistMixK0,fHistLeadInfoMix);
1294                 fPoolK0->UpdatePool(CloneAndReduceTrackList(selectedK0));
1295         }
1296
1297         fPoolLambda = fPoolMgr->GetEventPool(MultipOrCent, lPVz);
1298         if (!fPoolLambda){AliInfo(Form("No pool found for multiplicity = %f, zVtx = %f cm", MultipOrCent, lPVz));return;}
1299
1300     if (fPoolLambda->IsReady() || fPoolLambda->NTracksInPool() > fPoolMinNTracks  || fPoolLambda->GetCurrentNEvents() >= fMinEventsToMix)
1301         {
1302                 for (Int_t jMix=0; jMix<fPoolLambda->GetCurrentNEvents(); jMix++)
1303                         FillCorrelations(selectedTracksLeading, fPoolLambda->GetEvent(jMix),fHistMixLambda,0);
1304                 fPoolLambda->UpdatePool(CloneAndReduceTrackList(selectedLambda));
1305         }
1306
1307         PostData(1, fOutputList);
1308 }
1309 //---------------------------------------------------------------------------------------
1310 TObjArray* AliLeadingV0Correlation::CloneAndReduceTrackList(TObjArray* tracks)
1311 {
1312         // clones a track list for mixing
1313         TObjArray* tracksClone = new TObjArray;
1314         tracksClone->SetOwner(kTRUE);
1315
1316         for (Int_t i=0; i<tracks->GetEntriesFast(); i++)
1317         {
1318                 AliVParticle* particle = (AliVParticle*) tracks->At(i);
1319                 tracksClone->Add(new AliLeadingBasicParticle(particle->Eta(), particle->Phi(), particle->Pt()));
1320         }
1321
1322         return tracksClone;
1323 }
1324 //---------------------------------------------------------------------------------------
1325 Int_t  AliLeadingV0Correlation::NParticles(TObject* obj)
1326 {
1327         Int_t nTracks;
1328
1329         if (obj->InheritsFrom("TClonesArray")){ // MC particles
1330                 TClonesArray *arrayMC = static_cast<TClonesArray*>(obj);
1331         nTracks = arrayMC->GetEntriesFast();
1332         }else if (obj->InheritsFrom("TObjArray")){ // list of AliVParticle
1333                 TObjArray *array = static_cast<TObjArray*>(obj);
1334         nTracks = array->GetEntriesFast();
1335         }else if (obj->InheritsFrom("AliAODEvent")){  // RECO AOD tracks
1336                 AliAODEvent *aodEvent = static_cast<AliAODEvent*>(obj);
1337         nTracks = aodEvent->GetNTracks();
1338         }else {
1339                 if (fDebug > 1) AliFatal(" Analysis type not defined !!! ");
1340                 return 0;
1341         }
1342
1343         return nTracks;
1344 }
1345 //---------------------------------------------------------------------------------------
1346 Bool_t AliLeadingV0Correlation::IsAcseptedPrimaryTrack(const AliAODTrack *itrack)
1347 {
1348         if (TMath::Abs(itrack->Eta())>fTrackEtaCut) return kFALSE;
1349     if (!itrack->TestFilterBit(fFilterBit)) return kFALSE;
1350         return kTRUE;
1351 }
1352 //---------------------------------------------------------------------------------------
1353 Bool_t AliLeadingV0Correlation::IsAcseptedDaughterTrack(const AliAODTrack *itrack)
1354 {
1355         if(TMath::Abs(itrack->Eta())>fTrackEtaCut)return kFALSE;
1356
1357         if (!itrack->IsOn(AliAODTrack::kTPCrefit)) return kFALSE;
1358
1359         Float_t nCrossedRowsTPC = itrack->GetTPCClusterInfo(2,1);
1360         if (nCrossedRowsTPC < 70) return kFALSE;
1361
1362         Int_t findable=itrack->GetTPCNclsF();
1363         if (findable <= 0) return kFALSE;
1364
1365         if (nCrossedRowsTPC/findable < 0.8) return kFALSE;
1366
1367         return kTRUE;
1368 }
1369 //---------------------------------------------------------------------------------------
1370 Double_t AliLeadingV0Correlation::RangePhi(Double_t DPhi)
1371 {
1372         if (DPhi < -TMath::Pi()/2)  DPhi += 2*TMath::Pi();
1373         if (DPhi > 3*TMath::Pi()/2) DPhi -= 2*TMath::Pi();
1374         return DPhi;
1375 }
1376 //---------------------------------------------------------------------------------------
1377 void AliLeadingV0Correlation::FillCorrelations(TObjArray* particles, TObjArray* mixed,TH3F*histo,TH3F*leadinfo)
1378 {
1379  TObjArray* input = (mixed) ? mixed : particles;
1380  TArrayF eta(input->GetEntriesFast());
1381    for (Int_t i=0; i<input->GetEntriesFast(); i++) eta[i] = ((AliVParticle*) input->At(i))->Eta();
1382                 if (particles)
1383                  {
1384                    Int_t jMax = particles->GetEntriesFast();
1385                    if (mixed) jMax = mixed->GetEntriesFast();
1386                         for (Int_t i=0; i<particles->GetEntriesFast(); i++)
1387                         {
1388                                 AliVParticle* triggerParticle = (AliVParticle*) particles->At(0); //For leading Track
1389                                 // some optimization
1390                                 Float_t triggerEta = triggerParticle->Eta();
1391
1392                                 for (Int_t j=0; j<jMax; j++)
1393                                 {
1394                                   if (!mixed && i == j)continue;
1395                                         AliVParticle* particle = 0;
1396                                         if (!mixed)particle = (AliVParticle*) particles->At(0); //For leading Track
1397                                         else particle = (AliVParticle*) mixed->At(j);
1398
1399                                         // check if both particles point to the same element (does not occur for mixed events, but if subsets are mixed within the same event for cross-checks)
1400                                         if (mixed && triggerParticle == particle)continue;
1401
1402                                         if (particle->Pt() > triggerParticle->Pt())continue;
1403
1404                                         if (((particle->Pt())<fassocPtLow)||((particle->Pt())>fassocPtHigh)) continue;
1405                                         if (((triggerParticle->Pt())<ftrigPtLow)||((triggerParticle->Pt())>ftrigPtHigh)) continue;
1406
1407                                         Double_t vars[4];
1408                                         vars[0] = triggerEta - eta[j];
1409                                         vars[1] = particle->Pt();         //Associated Pt
1410                                         vars[2] = triggerParticle->Pt();  //Triger Pt
1411                                         vars[3] = RangePhi(triggerParticle->Phi() - particle->Phi());
1412
1413                                         histo->Fill(vars[3],vars[0],vars[1]);
1414                                         if(leadinfo)leadinfo->Fill(vars[2],triggerEta,triggerParticle->Phi());
1415
1416                    }
1417                 }
1418         }
1419 }
1420 //---------------------------------------------------------------------------------------
1421 TObjArray*  AliLeadingV0Correlation::FindLeadingObjects(TObject *obj)
1422 {
1423
1424         Int_t nTracks = NParticles(obj);
1425         if( !nTracks ) return 0;
1426
1427         // Define array of AliVParticle objects
1428         TObjArray* tracks = new TObjArray(nTracks);
1429
1430         // Loop over tracks or jets
1431         for (Int_t ipart=0; ipart<nTracks; ++ipart) {
1432         AliVParticle* part = ParticleWithCuts( obj,ipart);
1433         if (!part) continue;
1434
1435                 if(!IsAcseptedPrimaryTrack(((AliAODTrack*)part)))continue;
1436                 if(!IsTrackNotFromV0(((AliAODTrack*)part)))continue;
1437
1438                 tracks->AddLast( part );
1439         }
1440         // Order tracks by pT
1441         QSortTracks( *tracks, 0, tracks->GetEntriesFast() );
1442
1443         nTracks = tracks->GetEntriesFast();
1444         if( !nTracks ) return 0;
1445
1446         return tracks;
1447 }
1448 //---------------------------------------------------------------------------------------
1449 TObjArray*  AliLeadingV0Correlation::FindLeadingObjectsMC(TObject *obj)
1450 {
1451
1452         Int_t nTracks = NParticles(obj);
1453         if( !nTracks ) return 0;
1454
1455         // Define array of AliVParticle objects
1456         TObjArray* tracks = new TObjArray(nTracks);
1457
1458         // Loop over tracks or jets
1459         for (Int_t ipart=0; ipart<nTracks; ++ipart) {
1460         AliVParticle* part = ParticleWithCuts( obj,ipart);
1461         if (!part) continue;
1462                 Int_t pdgCodeCurrent = ((AliAODMCParticle*)part)->GetPdgCode();
1463                 Bool_t isHadron = TMath::Abs(pdgCodeCurrent)==211 ||  // Pion
1464                 TMath::Abs(pdgCodeCurrent)==2212 || // Proton
1465                 TMath::Abs(pdgCodeCurrent)==321;    // Kaon
1466                 if (!isHadron) continue;
1467                 tracks->AddLast( part );
1468         }
1469         // Order tracks by pT
1470         QSortTracks( *tracks, 0, tracks->GetEntriesFast() );
1471
1472         nTracks = tracks->GetEntriesFast();
1473         if( !nTracks ) return 0;
1474
1475         return tracks;
1476 }
1477 //---------------------------------------------------------------------------------------
1478 void AliLeadingV0Correlation::QSortTracks(TObjArray &a, Int_t first, Int_t last)
1479 {
1480         // Sort array of TObjArray of tracks by Pt using a quicksort algorithm.
1481
1482         static TObject *tmp;
1483         static int i;           // "static" to save stack space
1484         int j;
1485
1486         while (last - first > 1) {
1487                 i = first;
1488                 j = last;
1489                 for (;;) {
1490                         while (++i < last && ((AliVParticle*)a[i])->Pt() > ((AliVParticle*)a[first])->Pt() )
1491                                 ;
1492                         while (--j > first && ((AliVParticle*)a[j])->Pt() < ((AliVParticle*)a[first])->Pt() )
1493                                 ;
1494                         if (i >= j)
1495                                 break;
1496
1497                         tmp  = a[i];
1498                         a[i] = a[j];
1499                         a[j] = tmp;
1500                 }
1501                 if (j == first) {
1502                         ++first;
1503                         continue;
1504                 }
1505                 tmp = a[first];
1506                 a[first] = a[j];
1507                 a[j] = tmp;
1508                 if (j - first < last - (j + 1)) {
1509                         QSortTracks(a, first, j);
1510                         first = j + 1;   // QSortTracks(j + 1, last);
1511                 } else {
1512                         QSortTracks(a, j + 1, last);
1513                         last = j;        // QSortTracks(first, j);
1514                 }
1515         }
1516 }
1517 //---------------------------------------------------------------------------------------
1518 AliVParticle*  AliLeadingV0Correlation::ParticleWithCuts(TObject* obj, Int_t ipart)
1519 {
1520         AliVParticle *part=0;
1521         if (obj->InheritsFrom("AliAODEvent")){ // RECO AOD TRACKS
1522                 AliAODEvent *aodEvent = static_cast<AliAODEvent*>(obj);
1523         part = aodEvent->GetTrack(ipart);
1524                 // track selection cuts
1525                 if ( !(((AliAODTrack*)part)->TestFilterBit(fFilterBit))) return 0;
1526         }
1527         else if(obj->InheritsFrom("TClonesArray")){ // AOD-MC PARTICLE
1528                 TClonesArray *arrayMC = static_cast<TClonesArray*>(obj);
1529         part = (AliVParticle*)arrayMC->At( ipart );
1530                 if (!part)return 0;
1531                 // eventually only primaries
1532                 if (!( ((AliAODMCParticle*)part)->IsPhysicalPrimary()) )return 0;
1533         // eventually only hadrons
1534                 Int_t pdgCode = ((AliAODMCParticle*)part)->GetPdgCode();
1535                         Bool_t isHadron = TMath::Abs(pdgCode)==211 ||  // Pion
1536                         TMath::Abs(pdgCode)==2212 || // Proton
1537                         TMath::Abs(pdgCode)==321;    // Kaon
1538                         if (!isHadron) return 0;
1539         }
1540         else {return 0;}
1541         // only charged
1542         if (!part->Charge())return 0;
1543         return part;
1544 }
1545 //---------------------------------------------------------------------------------------
1546 Bool_t AliLeadingV0Correlation::IsK0InvMass(const Double_t mass) const
1547 {
1548
1549         const Float_t massK0            = 0.497;
1550         const Float_t sigmaK0           = 0.003;
1551         const Float_t nSigmaSignal      = 3.5;
1552
1553         return ((massK0-nSigmaSignal*sigmaK0)<=mass && mass<=(massK0 + nSigmaSignal*sigmaK0))?1:0;
1554 }
1555 //---------------------------------------------------------------------------------------
1556 Bool_t AliLeadingV0Correlation::IsLambdaInvMass(const Double_t mass) const
1557 {
1558
1559         const Float_t massLambda        = 1.116;
1560         const Float_t sigmaLambda       = 0.003;
1561         const Float_t nSigmaSignal      = 3.5;
1562
1563         return ((massLambda-nSigmaSignal*sigmaLambda)<=mass && mass<=(massLambda + nSigmaSignal*sigmaLambda))?1:0;
1564 }
1565 //---------------------------------------------------------------------------------------
1566 Bool_t AliLeadingV0Correlation::IsTrackNotFromV0(AliAODTrack* track)
1567 {
1568         Int_t atrID = track->GetID();
1569
1570         for(int i=0; i<fAODEvent->GetNumberOfV0s(); i++){ // loop over V0s
1571                 AliAODv0* aodV0 = fAODEvent->GetV0(i);
1572
1573                 AliAODTrack *trackPos=(AliAODTrack *)(aodV0->GetDaughter(0));
1574         AliAODTrack *trackNeg=(AliAODTrack *)(aodV0->GetDaughter(1));
1575
1576                 if ( !(IsAcseptedDaughterTrack(trackPos)) || !(IsAcseptedDaughterTrack(trackNeg)) ) continue;
1577                 //----------------------------------
1578                 Int_t negID = trackNeg->GetID();
1579                 Int_t posID = trackPos->GetID();
1580
1581                 if ((TMath::Abs(negID)+1)==(TMath::Abs(atrID))){ return kFALSE;}
1582                 if ((TMath::Abs(posID)+1)==(TMath::Abs(atrID))){ return kFALSE;}
1583                 //----------------------------------
1584         }
1585         return kTRUE;
1586 }
1587 //---------------------------------------------------------------------------------------
1588 Bool_t AliLeadingV0Correlation::IsAcseptedV0(const AliAODEvent*aod, const AliAODv0* aodV0, const AliAODTrack* myTrackPos, const AliAODTrack* myTrackNeg)
1589 {
1590         if (!aodV0) return kFALSE;
1591
1592         // Offline reconstructed V0 only
1593     if (aodV0->GetOnFlyStatus()) return kFALSE;
1594
1595     // DCA of daughter track to Primary Vertex
1596     Float_t dcaNP=aodV0->DcaNegToPrimVertex();
1597     if (TMath::Abs(dcaNP)<fCutDCANegToPV) return kFALSE;
1598     Float_t dcaPP=aodV0->DcaPosToPrimVertex();
1599     if (TMath::Abs(dcaPP)<fCutDCAPosToPV) return kFALSE;
1600
1601         // DCA of daughter tracks
1602     Double_t dcaD=aodV0->DcaV0Daughters();
1603     if (dcaD>fCutDCAV0Daughters) return kFALSE;
1604
1605         // Cosinus of pointing angle
1606     Double_t cpa=aodV0->CosPointingAngle(aod->GetPrimaryVertex());
1607     if (cpa<fCutV0CosPA) return kFALSE;
1608
1609         // Decay Radius Cut
1610     Double_t xyz[3]; aodV0->GetSecondaryVtx(xyz);
1611     Double_t r2=xyz[0]*xyz[0] + xyz[1]*xyz[1];
1612     if (r2<fCutV0Radius) return kFALSE;
1613
1614     // Get daughters and check them
1615         myTrackPos=(AliAODTrack *)(aodV0->GetDaughter(0));
1616         myTrackNeg=(AliAODTrack *)(aodV0->GetDaughter(1));
1617
1618         if (!myTrackPos||!myTrackNeg) return kFALSE;
1619         // Unlike signs of daughters
1620     if (myTrackPos->Charge() == myTrackNeg->Charge()) return kFALSE;
1621
1622         // Track cuts for daughers
1623     if ( !(IsAcseptedDaughterTrack(myTrackPos)) || !(IsAcseptedDaughterTrack(myTrackNeg)) ) return kFALSE;
1624
1625         // Minimum pt of daughters
1626     Double_t  lMomPos[3] = {999,999,999};
1627         Double_t  lMomNeg[3] = {999,999,999};
1628
1629         lMomPos[0] = aodV0->MomPosX();
1630     lMomPos[1] = aodV0->MomPosY();
1631     lMomPos[2] = aodV0->MomPosZ();
1632
1633     lMomNeg[0] = aodV0->MomNegX();
1634     lMomNeg[1] = aodV0->MomNegY();
1635     lMomNeg[2] = aodV0->MomNegZ();
1636
1637     Double_t lPtPos = TMath::Sqrt(lMomPos[0]*lMomPos[0] + lMomPos[1]*lMomPos[1]);
1638     Double_t lPtNeg = TMath::Sqrt(lMomNeg[0]*lMomNeg[0] + lMomNeg[1]*lMomNeg[1]);
1639
1640         Double_t cutMinPtDaughter = 0.150;
1641         if (lPtPos<cutMinPtDaughter || lPtNeg<cutMinPtDaughter) return kFALSE;
1642
1643         return kTRUE;
1644 }
1645 //---------------------------------------------------------------------------------------
1646 void AliLeadingV0Correlation::Terminate(Option_t *)
1647 {
1648         //No need in the grid
1649 }
1650 //---------------------------------------------------------------------------------------