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