PWGCF/Correlations/DPhi/AliLeadingV0Correlation.cxx

   1 //
   2 //            Class for Leading Charged Track+V0 Correlations Analysis
   3
   4 #include <TROOT.h>
   5 #include <TList.h>
   6 #include <TChain.h>
   7 #include <TFile.h>
   8 #include <TMath.h>
   9 #include <TTree.h>
  10 #include <TRandom.h>
  11 #include <TH1.h>
  12 #include <TH2.h>
  13 #include <TH3.h>
  14
  15
  16 #include "AliLog.h"
  17 #include "AliAnalysisManager.h"
  18 #include "AliAODTrack.h"
  19 #include "AliAODEvent.h"
  20 #include "AliAODv0.h"
  21 #include "AliAODcascade.h"
  22 #include "AliAODVertex.h"
  23 #include "AliAODPid.h"
  24 #include "AliPIDResponse.h"
  25 #include "AliEventPoolManager.h"
  26 #include "AliCentrality.h"
  27 #include "AliAnalyseLeadingTrackUE.h"
  28 #include "AliPhysicsSelectionTask.h"
  29 #include "AliAODHandler.h"
  30 #include "AliAODInputHandler.h"
  31 #include "AliAODMCParticle.h"
  32 #include "AliInputEventHandler.h"
  33 #include "AliLog.h"
  34 #include "AliMCEventHandler.h"
  35 #include "AliVParticle.h"
  36 #include "AliCFContainer.h"
  37 #include "AliMultiplicity.h"
  38 #include "AliStack.h"
  39 #include "AliAODMCHeader.h"
  40 #include "AliPID.h"
  41 #include "AliPIDResponse.h"
  42 #include "AliExternalTrackParam.h"
  43
  44 #include "AliLeadingV0Correlation.h"
  45
  46 #define CorrBinsX 26
  47 #define CorrBinsY 24
  48
  49 ClassImp(AliLeadingV0Correlation)
  50 ClassImp(AliLeadingBasicParticle)
  51
  52 //---------------------------------------------------------------------------------------
  53 AliLeadingV0Correlation::AliLeadingV0Correlation()
  54    : AliAnalysisTaskSE(),
  55   fAODEvent(0x0),
  56   fPoolMgr(0x0),
  57   fPoolK0(0x0),
  58   fPoolLambda(0x0),
  59   fPIDResponse(0x0),
  60   fPoolMaxNEvents(0),
  61   fPoolMinNTracks(0),
  62   fMinEventsToMix(0),
  63   fNzVtxBins(0),
  64   fNCentBins(0),
  65   fcollidingSys("PbPb"),
  66   fpvzcut(0),
  67   fTrackEtaCut(0),
  68   fFilterBit(128),
  69   ftrigPtLow(0),
  70   ftrigPtHigh(0),
  71   fassocPtLow(0),
  72   fassocPtHigh(0),
  73   fAnalysisMC(0),
  74   fUsePID(""),
  75   fRapidityCut(0.),
  76   fCutV0Radius(0.),
  77   fCutDCANegToPV(0.),
  78   fCutDCAPosToPV(0.),
  79   fCutDCAV0Daughters(0.),
  80   fCutV0CosPA(0.),
  81   fSpecialArmenterosCutK0s(0.),
  82   fPerformMultiplicityStudy(0),
  83   fLoMultBound(0),
  84   fHiMultBound(0),
  85   fOutputList(0),
  86   fHistMCPrimaryVertexX(0),
  87   fHistMCPrimaryVertexY(0),
  88   fHistMCPrimaryVertexZ(0),
  89   fHistMCtracksProdRadiusK0s(0),
  90   fHistMCtracksProdRadiusLambda(0),
  91   fHistMCtracksProdRadiusAntiLambda(0),
  92   fHistMCtracksDecayRadiusK0s(0),
  93   fHistMCtracksDecayRadiusLambda(0),
  94   fHistMCtracksDecayRadiusAntiLambda(0),
  95   fHistMCPtAllK0s(0),
  96   fHistMCPtAllLambda(0),
  97   fHistMCPtAllAntiLambda(0),
  98   fHistMCProdRadiusK0s(0),
  99   fHistMCProdRadiusLambda(0),
 100   fHistMCProdRadiusAntiLambda(0),
 101   fHistMCRapK0s(0),
 102   fHistMCRapLambda(0),
 103   fHistMCRapAntiLambda(0),
 104   fHistMCPtK0s(0),
 105   fHistMCPtLambda(0),
 106   fHistMCPtAntiLambda(0),
 107   fHistMCPtLambdaFromSigma(0),
 108   fHistMCPtAntiLambdaFromSigma(0),
 109   fHistNTimesRecK0s(0),
 110   fHistNTimesRecLambda(0),
 111   fHistNTimesRecAntiLambda(0),
 112   fHistNTimesRecK0sVsPt(0),
 113   fHistNTimesRecLambdaVsPt(0),
 114   fHistNTimesRecAntiLambdaVsPt(0),
 115   fHistMCDaughterTrack(0),
 116   fHistPrimRawPtVsYK0s(0),
 117   fHistPrimRawPtVsYLambda(0),
 118   fHistPrimRawPtVsYAntiLambda(0),
 119   fHistPrimaryVertexX(0),
 120   fHistPrimaryVertexY(0),
 121   fHistPrimaryVertexZ(0),
 122   fHistDcaPosToPrimVertexK0(0),
 123   fHistDcaNegToPrimVertexK0(0),
 124   fHistRadiusV0K0(0),
 125   fHistDecayLengthV0K0(0),
 126   fHistDcaV0DaughtersK0(0),
 127   fHistChi2K0(0),
 128   fHistCosPointAngleK0(0),
 129   fHistDcaPosToPrimVertexK0vsMassK0(0),
 130   fHistDcaNegToPrimVertexK0vsMassK0(0),
 131   fHistRadiusV0K0vsMassK0(0),
 132   fHistDecayLengthV0K0vsMassK0(0),
 133   fHistDcaV0DaughtersK0vsMassK0(0),
 134   fHistCosPointAngleK0vsMassK0(0),
 135   fHistDcaPosToPrimVertexL(0),
 136   fHistDcaNegToPrimVertexL(0),
 137   fHistRadiusV0L(0),
 138   fHistDecayLengthV0L(0),
 139   fHistDcaV0DaughtersL(0),
 140   fHistChi2L(0),
 141   fHistCosPointAngleL(0),
 142   fHistcTauL(0),
 143   fHistDcaPosToPrimVertexLvsMassL(0),
 144   fHistDcaNegToPrimVertexLvsMassL(0),
 145   fHistRadiusV0LvsMassL(0),
 146   fHistDecayLengthV0LvsMassL(0),
 147   fHistDcaV0DaughtersLvsMassL(0),
 148   fHistCosPointAngleLvsMassL(0),
 149   fHistCosPointAngleLVsMassVsPtsigL(0),
 150   fHistCosPointAngleLVsMassVsPtbackL(0),
 151   fHistDcaPosToPrimVertexAntiL(0),
 152   fHistDcaNegToPrimVertexAntiL(0),
 153   fHistRadiusV0AntiL(0),
 154   fHistDecayLengthV0AntiL(0),
 155   fHistDcaV0DaughtersAntiL(0),
 156   fHistChi2AntiL(0),
 157   fHistCosPointAngleAntiL(0),
 158   fHistDcaPosToPrimVertexAntiLvsMass(0),
 159   fHistDcaNegToPrimVertexAntiLvsMass(0),
 160   fHistRadiusV0AntiLvsMass(0),
 161   fHistDecayLengthV0AntiLvsMass(0),
 162   fHistDcaV0DaughtersAntiLvsMass(0),
 163   fHistCosPointAngleAntiLvsMass(0),
 164   fHistMassK0(0),
 165   fHistMassLambda(0),
 166   fHistMassAntiLambda(0),
 167   fHistMassVsRadiusK0(0),
 168   fHistMassVsRadiusLambda(0),
 169   fHistMassVsRadiusAntiLambda(0),
 170   fHistPtVsMassK0(0),
 171   fHistPtVsMassLambda(0),
 172   fHistPtVsMassAntiLambda(0),
 173   fHistArmenterosPodolanski(0),
 174   fHistNsigmaPosProtonLambda(0),
 175   fHistNsigmaNegPionLambda(0),
 176   fHistNsigmaPosProtonAntiLambda(0),
 177   fHistNsigmaNegPionAntiLambda(0),
 178   fHistNsigmaPosPionK0(0),
 179         fHistNsigmaNegPionK0(0),
 180         fHistAsMcPtK0(0),
 181         fHistAsMcPtLambda(0),
 182         fHistAsMcPtAntiLambda(0),
 183         fHistAsMcProdRadiusK0(0),
 184         fHistAsMcProdRadiusLambda(0),
 185         fHistAsMcProdRadiusAntiLambda(0),
 186         fHistAsMcProdRadiusXvsYK0s(0),
 187         fHistAsMcProdRadiusXvsYLambda(0),
 188         fHistAsMcProdRadiusXvsYAntiLambda(0),
 189         fHistPidMcMassK0(0),
 190         fHistPidMcMassLambda(0),
 191         fHistPidMcMassAntiLambda(0),
 192         fHistAsMcMassK0(0),
 193         fHistAsMcMassLambda(0),
 194         fHistAsMcMassAntiLambda(0),
 195         fHistAsMcPtVsMassK0(0),
 196         fHistAsMcPtVsMassLambda(0),
 197         fHistAsMcPtVsMassAntiLambda(0),
 198         fHistAsMcMassVsRadiusK0(0),
 199         fHistAsMcMassVsRadiusLambda(0),
 200         fHistAsMcMassVsRadiusAntiLambda(0),
 201         fHistAsMcResxK0(0),
 202         fHistAsMcResyK0(0),
 203         fHistAsMcReszK0(0),
 204         fHistAsMcResrVsRadiusK0(0),
 205         fHistAsMcReszVsRadiusK0(0),
 206         fHistAsMcResxLambda(0),
 207         fHistAsMcResyLambda(0),
 208         fHistAsMcReszLambda(0),
 209         fHistAsMcResrVsRadiusLambda(0),
 210         fHistAsMcReszVsRadiusLambda(0),
 211         fHistAsMcResxAntiLambda(0),
 212         fHistAsMcResyAntiLambda(0),
 213         fHistAsMcReszAntiLambda(0),
 214         fHistAsMcResrVsRadiusAntiLambda(0),
 215         fHistAsMcReszVsRadiusAntiLambda(0),
 216         fHistAsMcResPtK0(0),
 217         fHistAsMcResPtLambda(0),
 218         fHistAsMcResPtAntiLambda(0),
 219         fHistAsMcResPtVsRapK0(0),
 220         fHistAsMcResPtVsRapLambda(0),
 221         fHistAsMcResPtVsRapAntiLambda(0),
 222         fHistAsMcResPtVsPtK0(0),
 223         fHistAsMcResPtVsPtLambda(0),
 224         fHistAsMcResPtVsPtAntiLambda(0),
 225         fHistAsMcPtLambdaFromSigma(0),
 226         fHistAsMcPtAntiLambdaFromSigma(0),
 227         fHistAsMcSecondaryPtVsRapK0s(0),
 228         fHistAsMcSecondaryPtVsRapLambda(0),
 229         fHistAsMcSecondaryPtVsRapAntiLambda(0),
 230         fHistAsMcSecondaryProdRadiusK0s(0),
 231         fHistAsMcSecondaryProdRadiusLambda(0),
 232         fHistAsMcSecondaryProdRadiusAntiLambda(0),
 233         fHistAsMcSecondaryProdRadiusXvsYK0s(0),
 234         fHistAsMcSecondaryProdRadiusXvsYLambda(0),
 235         fHistAsMcSecondaryProdRadiusXvsYAntiLambda(0),
 236         fHistAsMcSecondaryPtLambdaFromSigma(0),
 237         fHistAsMcSecondaryPtAntiLambdaFromSigma(0),
 238         fHistSibK0(0),
 239         fHistMixK0(0),
 240         fHistSibLambda(0),
 241         fHistMixLambda(0),
 242         fHistSibK0MC(0),
 243         fHistMixK0MC(0),
 244         fHistSibLambdaMC(0),
 245         fHistMixLambdaMC(0)
 246
 247
 248 {
 249         fRapidityCut=0.75;
 250         fUsePID="withPID";
 251         fCutV0Radius=0.5;
 252         fCutDCANegToPV=0.06;
 253         fCutDCAPosToPV=0.06;
 254         fCutDCAV0Daughters=1.0;
 255         fCutV0CosPA=0.995;
 256         fSpecialArmenterosCutK0s=5;
 257
 258 }
 259 //---------------------------------------------------------------------------------------
 260 AliLeadingV0Correlation::AliLeadingV0Correlation(const char *name)
 261    : AliAnalysisTaskSE(name),
 262         fAODEvent(0x0),
 263         fPoolMgr(0x0),
 264         fPoolK0(0x0),
 265         fPoolLambda(0x0),
 266     fPIDResponse(0x0),
 267         fPoolMaxNEvents(0),
 268         fPoolMinNTracks(0),
 269         fMinEventsToMix(0),
 270         fNzVtxBins(0),
 271         fNCentBins(0),
 272         fcollidingSys("PbPb"),
 273         fpvzcut(0),
 274     fTrackEtaCut(0),
 275     fFilterBit(128),
 276   ftrigPtLow(0),
 277   ftrigPtHigh(0),
 278   fassocPtLow(0),
 279   fassocPtHigh(0),
 280   fAnalysisMC(0),
 281   fUsePID(""),
 282   fRapidityCut(0.),
 283   fCutV0Radius(0.),
 284   fCutDCANegToPV(0.),
 285   fCutDCAPosToPV(0.),
 286   fCutDCAV0Daughters(0.),
 287   fCutV0CosPA(0.),
 288   fSpecialArmenterosCutK0s(0.),
 289   fPerformMultiplicityStudy(0),
 290   fLoMultBound(0),
 291   fHiMultBound(0),
 292   fOutputList(0),
 293         fHistMCPrimaryVertexX(0),
 294         fHistMCPrimaryVertexY(0),
 295         fHistMCPrimaryVertexZ(0),
 296         fHistMCtracksProdRadiusK0s(0),
 297         fHistMCtracksProdRadiusLambda(0),
 298         fHistMCtracksProdRadiusAntiLambda(0),
 299         fHistMCtracksDecayRadiusK0s(0),
 300         fHistMCtracksDecayRadiusLambda(0),
 301         fHistMCtracksDecayRadiusAntiLambda(0),
 302         fHistMCPtAllK0s(0),
 303         fHistMCPtAllLambda(0),
 304         fHistMCPtAllAntiLambda(0),
 305         fHistMCProdRadiusK0s(0),
 306         fHistMCProdRadiusLambda(0),
 307         fHistMCProdRadiusAntiLambda(0),
 308         fHistMCRapK0s(0),
 309         fHistMCRapLambda(0),
 310         fHistMCRapAntiLambda(0),
 311         fHistMCPtK0s(0),
 312         fHistMCPtLambda(0),
 313         fHistMCPtAntiLambda(0),
 314         fHistMCPtLambdaFromSigma(0),
 315         fHistMCPtAntiLambdaFromSigma(0),
 316         fHistNTimesRecK0s(0),
 317         fHistNTimesRecLambda(0),
 318         fHistNTimesRecAntiLambda(0),
 319         fHistNTimesRecK0sVsPt(0),
 320         fHistNTimesRecLambdaVsPt(0),
 321         fHistNTimesRecAntiLambdaVsPt(0),
 322         fHistMCDaughterTrack(0),
 323         fHistPrimRawPtVsYK0s(0),
 324         fHistPrimRawPtVsYLambda(0),
 325         fHistPrimRawPtVsYAntiLambda(0),
 326         fHistPrimaryVertexX(0),
 327         fHistPrimaryVertexY(0),
 328         fHistPrimaryVertexZ(0),
 329         fHistDcaPosToPrimVertexK0(0),
 330         fHistDcaNegToPrimVertexK0(0),
 331         fHistRadiusV0K0(0),
 332         fHistDecayLengthV0K0(0),
 333         fHistDcaV0DaughtersK0(0),
 334         fHistChi2K0(0),
 335         fHistCosPointAngleK0(0),
 336         fHistDcaPosToPrimVertexK0vsMassK0(0),
 337         fHistDcaNegToPrimVertexK0vsMassK0(0),
 338         fHistRadiusV0K0vsMassK0(0),
 339         fHistDecayLengthV0K0vsMassK0(0),
 340         fHistDcaV0DaughtersK0vsMassK0(0),
 341         fHistCosPointAngleK0vsMassK0(0),
 342         fHistDcaPosToPrimVertexL(0),
 343         fHistDcaNegToPrimVertexL(0),
 344         fHistRadiusV0L(0),
 345         fHistDecayLengthV0L(0),
 346         fHistDcaV0DaughtersL(0),
 347         fHistChi2L(0),
 348         fHistCosPointAngleL(0),
 349         fHistcTauL(0),
 350         fHistDcaPosToPrimVertexLvsMassL(0),
 351         fHistDcaNegToPrimVertexLvsMassL(0),
 352         fHistRadiusV0LvsMassL(0),
 353         fHistDecayLengthV0LvsMassL(0),
 354         fHistDcaV0DaughtersLvsMassL(0),
 355         fHistCosPointAngleLvsMassL(0),
 356         fHistCosPointAngleLVsMassVsPtsigL(0),
 357         fHistCosPointAngleLVsMassVsPtbackL(0),
 358         fHistDcaPosToPrimVertexAntiL(0),
 359         fHistDcaNegToPrimVertexAntiL(0),
 360         fHistRadiusV0AntiL(0),
 361         fHistDecayLengthV0AntiL(0),
 362         fHistDcaV0DaughtersAntiL(0),
 363         fHistChi2AntiL(0),
 364         fHistCosPointAngleAntiL(0),
 365         fHistDcaPosToPrimVertexAntiLvsMass(0),
 366         fHistDcaNegToPrimVertexAntiLvsMass(0),
 367         fHistRadiusV0AntiLvsMass(0),
 368         fHistDecayLengthV0AntiLvsMass(0),
 369         fHistDcaV0DaughtersAntiLvsMass(0),
 370         fHistCosPointAngleAntiLvsMass(0),
 371         fHistMassK0(0),
 372         fHistMassLambda(0),
 373         fHistMassAntiLambda(0),
 374         fHistMassVsRadiusK0(0),
 375         fHistMassVsRadiusLambda(0),
 376         fHistMassVsRadiusAntiLambda(0),
 377         fHistPtVsMassK0(0),
 378         fHistPtVsMassLambda(0),
 379         fHistPtVsMassAntiLambda(0),
 380         fHistArmenterosPodolanski(0),
 381         fHistNsigmaPosProtonLambda(0),
 382         fHistNsigmaNegPionLambda(0),
 383         fHistNsigmaPosProtonAntiLambda(0),
 384         fHistNsigmaNegPionAntiLambda(0),
 385         fHistNsigmaPosPionK0(0),
 386         fHistNsigmaNegPionK0(0),
 387         fHistAsMcPtK0(0),
 388         fHistAsMcPtLambda(0),
 389         fHistAsMcPtAntiLambda(0),
 390         fHistAsMcProdRadiusK0(0),
 391         fHistAsMcProdRadiusLambda(0),
 392         fHistAsMcProdRadiusAntiLambda(0),
 393         fHistAsMcProdRadiusXvsYK0s(0),
 394         fHistAsMcProdRadiusXvsYLambda(0),
 395         fHistAsMcProdRadiusXvsYAntiLambda(0),
 396         fHistPidMcMassK0(0),
 397         fHistPidMcMassLambda(0),
 398         fHistPidMcMassAntiLambda(0),
 399         fHistAsMcMassK0(0),
 400         fHistAsMcMassLambda(0),
 401         fHistAsMcMassAntiLambda(0),
 402         fHistAsMcPtVsMassK0(0),
 403         fHistAsMcPtVsMassLambda(0),
 404         fHistAsMcPtVsMassAntiLambda(0),
 405         fHistAsMcMassVsRadiusK0(0),
 406         fHistAsMcMassVsRadiusLambda(0),
 407         fHistAsMcMassVsRadiusAntiLambda(0),
 408         fHistAsMcResxK0(0),
 409         fHistAsMcResyK0(0),
 410         fHistAsMcReszK0(0),
 411         fHistAsMcResrVsRadiusK0(0),
 412         fHistAsMcReszVsRadiusK0(0),
 413         fHistAsMcResxLambda(0),
 414         fHistAsMcResyLambda(0),
 415         fHistAsMcReszLambda(0),
 416         fHistAsMcResrVsRadiusLambda(0),
 417         fHistAsMcReszVsRadiusLambda(0),
 418         fHistAsMcResxAntiLambda(0),
 419         fHistAsMcResyAntiLambda(0),
 420         fHistAsMcReszAntiLambda(0),
 421         fHistAsMcResrVsRadiusAntiLambda(0),
 422         fHistAsMcReszVsRadiusAntiLambda(0),
 423         fHistAsMcResPtK0(0),
 424         fHistAsMcResPtLambda(0),
 425         fHistAsMcResPtAntiLambda(0),
 426         fHistAsMcResPtVsRapK0(0),
 427         fHistAsMcResPtVsRapLambda(0),
 428         fHistAsMcResPtVsRapAntiLambda(0),
 429         fHistAsMcResPtVsPtK0(0),
 430         fHistAsMcResPtVsPtLambda(0),
 431         fHistAsMcResPtVsPtAntiLambda(0),
 432         fHistAsMcPtLambdaFromSigma(0),
 433         fHistAsMcPtAntiLambdaFromSigma(0),
 434         fHistAsMcSecondaryPtVsRapK0s(0),
 435         fHistAsMcSecondaryPtVsRapLambda(0),
 436         fHistAsMcSecondaryPtVsRapAntiLambda(0),
 437         fHistAsMcSecondaryProdRadiusK0s(0),
 438         fHistAsMcSecondaryProdRadiusLambda(0),
 439         fHistAsMcSecondaryProdRadiusAntiLambda(0),
 440         fHistAsMcSecondaryProdRadiusXvsYK0s(0),
 441         fHistAsMcSecondaryProdRadiusXvsYLambda(0),
 442         fHistAsMcSecondaryProdRadiusXvsYAntiLambda(0),
 443         fHistAsMcSecondaryPtLambdaFromSigma(0),
 444         fHistAsMcSecondaryPtAntiLambdaFromSigma(0),
 445         fHistSibK0(0),
 446         fHistMixK0(0),
 447         fHistSibLambda(0),
 448         fHistMixLambda(0),
 449         fHistSibK0MC(0),
 450         fHistMixK0MC(0),
 451         fHistSibLambdaMC(0),
 452         fHistMixLambdaMC(0)
 453 {
 454         fRapidityCut=0.75;
 455         fUsePID="withPID";
 456         fCutV0Radius=0.5;
 457         fCutDCANegToPV=0.06;
 458         fCutDCAPosToPV=0.06;
 459         fCutDCAV0Daughters=1.0;
 460         fCutV0CosPA=0.995;
 461         fSpecialArmenterosCutK0s=5;
 462
 463    DefineOutput(1, TList::Class());
 464 }
 465
 466 //---------------------------------------------------------------------------------------
 467 AliLeadingV0Correlation::~AliLeadingV0Correlation()
 468 {
 469    // Destructor. Clean-up the output list, but not the histograms that are put inside
 470    // (the list is owner and will clean-up these histograms). Protect in PROOF case.
 471    if (fOutputList && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
 472       delete fOutputList;
 473    }
 474 }
 475 //---------------------------------------------------------------------------------------
 476 void AliLeadingV0Correlation::UserCreateOutputObjects()
 477 {
 478    fOutputList = new TList();
 479    fOutputList->SetOwner();
 480
 481         Int_t lCustomNBins = 200;
 482         Double_t lCustomPtUpperLimit = 20;
 483         //Int_t lCustomNBinsMultiplicity = 100;
 484
 485
 486         //---------------------------------------------- MC histograms -----------------------------------------------------//
 487
 488         // Primary Vertex:
 489         fHistMCPrimaryVertexX          = new TH1F("h1MCPrimaryVertexX", "MC Primary Vertex Position X;Primary Vertex Position X (cm);Events",100,-0.5,0.5);
 490         fOutputList->Add(fHistMCPrimaryVertexX);
 491
 492         fHistMCPrimaryVertexY          = new TH1F("h1MCPrimaryVertexY", "MC Primary Vertex Position Y;Primary Vertex Position Y (cm);Events",100,-0.5,0.5);
 493         fOutputList->Add(fHistMCPrimaryVertexY);
 494
 495         fHistMCPrimaryVertexZ          = new TH1F("h1MCPrimaryVertexZ", "MC Primary Vertex Position Z;Primary Vertex Position Z (cm);Events",200,-20,20);
 496         fOutputList->Add(fHistMCPrimaryVertexZ);
 497
 498
 499         // Production Radius of non-primary particles:
 500         fHistMCtracksProdRadiusK0s           = new TH2F("h2MCtracksProdRadiusK0s","Non-primary MC K^{0} Production Radius;x (cm); y (cm)",200,-50,50,200,-50,50);
 501         fOutputList->Add(fHistMCtracksProdRadiusK0s);
 502
 503         fHistMCtracksProdRadiusLambda        = new TH2F("h2MCtracksProdRadiusLambda","Non-primary MC #Lambda^{0} Production Radius;x (cm); y (cm)",200,-50,50,200,-50,50);
 504         fOutputList->Add(fHistMCtracksProdRadiusLambda);
 505
 506         fHistMCtracksProdRadiusAntiLambda    = new TH2F("h2MCtracksProdRadiusAntiLambda","Non-primary MC #bar{#Lambda}^{0} Production Radius;x (cm); y (cm)",200,-50,50,200,-50,50);
 507         fOutputList->Add(fHistMCtracksProdRadiusAntiLambda);
 508
 509         // Decay Radius of non-primary particles:
 510         fHistMCtracksDecayRadiusK0s          = new TH1F("h1MCtracksDecayRadiusK0s","Non-primary MC K^{0} Decay Radius;r (cm)",101,-1,100);
 511         fOutputList->Add(fHistMCtracksDecayRadiusK0s);
 512
 513         fHistMCtracksDecayRadiusLambda       = new TH1F("h1MCtracksDecayRadiusLambda","Non-primary MC #Lambda^{0} Decay Radius;r (cm)",101,-1,100);
 514         fOutputList->Add(fHistMCtracksDecayRadiusLambda);
 515
 516         fHistMCtracksDecayRadiusAntiLambda   = new TH1F("h1MCtracksDecayRadiusAntiLambda","Non-primary #bar{#Lambda}^{0} Decay Radius;r (cm)",100,1,101);
 517         fOutputList->Add(fHistMCtracksDecayRadiusAntiLambda);
 518
 519         // Rapidity distribution:
 520         fHistMCRapK0s                 = new TH1F("h1MCRapK0s", "K^{0};y",160,-4,4);
 521         fOutputList->Add(fHistMCRapK0s);
 522
 523         fHistMCRapLambda              = new TH1F("h1MCRapLambda", "#Lambda;y",160,-4,4);
 524         fOutputList->Add(fHistMCRapLambda);
 525
 526
 527         fHistMCRapAntiLambda          = new TH1F("h1MCRapAntiLambda", "#bar{#Lambda};y",160,-4,4);
 528         fOutputList->Add(fHistMCRapAntiLambda);
 529
 530
 531         // Production Radius
 532         fHistMCProdRadiusK0s                 = new TH1F("h1MCProdRadiusK0s", "MC K^{0} Production Radius;r (cm);Count", 400, -2, 2);
 533         fOutputList->Add(fHistMCProdRadiusK0s);
 534
 535         fHistMCProdRadiusLambda              = new TH1F("h1MCProdRadiusLambda", "MC #Lambda^{0} Production Radius;r (cm);Count", 400, -2, 2);
 536         fOutputList->Add(fHistMCProdRadiusLambda);
 537
 538         fHistMCProdRadiusAntiLambda         = new TH1F("h1MCProdRadiusAntiLambda", "MC #bar{#Lambda}^{0} Production Radius;r (cm);Count", 400, -2, 2);
 539         fOutputList->Add(fHistMCProdRadiusAntiLambda);
 540
 541
 542         // Pt distribution:
 543         fHistMCPtK0s               = new TH1F("h1MCPtK0s", "K^{0};p{t} (GeV/c)",240,0,12);
 544         fOutputList->Add(fHistMCPtK0s);
 545
 546         fHistMCPtLambda            = new TH1F("h1MCPtLambda", "#Lambda^{0};p{t} (GeV/c)",240,0,12);
 547         fOutputList->Add(fHistMCPtLambda);
 548
 549         fHistMCPtAntiLambda            = new TH1F("h1MCPtAntiLambda", "#AntiLambda^{0};p{t} (GeV/c)",240,0,12);
 550         fOutputList->Add(fHistMCPtAntiLambda);
 551
 552         // Pt distribution of Lambda coming from Sigma decay
 553         fHistMCPtLambdaFromSigma      = new TH1F("h1MCPtLambdaFromSigma", "#Lambda^{0};p{t} (GeV/c)",240,0,12);
 554         fOutputList->Add(fHistMCPtLambdaFromSigma);
 555
 556         fHistMCPtAntiLambdaFromSigma  = new TH1F("h1MCPtAntiLambdaFromSigma", "#Lambda^{0};p{t} (GeV/c)",240,0,12);
 557         fOutputList->Add(fHistMCPtAntiLambdaFromSigma);
 558
 559         // Multiple reconstruction studies
 560         fHistNTimesRecK0s             = new TH1F("h1NTimesRecK0s","number of times a K0s is reconstructed in -1<y<1;number of times;counts",500,-0.5,4.5);
 561         fOutputList->Add(fHistNTimesRecK0s);
 562
 563         fHistNTimesRecLambda          = new TH1F("h1NTimesRecLambda","number of times a Lambda is reconstructed in -1<y<1;number of times;counts",500,-0.5,4.5);
 564         fOutputList->Add(fHistNTimesRecLambda);
 565
 566         fHistNTimesRecAntiLambda      = new TH1F("h1NTimesRecAntiLambda","number of times an AntiLambda is reconstructed in -1<y<1;number of times;counts",500,-0.5,4.5);
 567         fOutputList->Add(fHistNTimesRecAntiLambda);
 568
 569         fHistNTimesRecK0sVsPt         = new TH2F("h2NTimesRecK0sVsPt","NTimes versus Pt, K^{0} in -1<y<1;p{t} (GeV/c);number of times",75,0,15,5,-0.5,4.5);
 570         fOutputList->Add(fHistNTimesRecK0sVsPt);
 571
 572         fHistNTimesRecLambdaVsPt      = new TH2F("h2NTimesRecLambdaVsPt","NTimes versus Pt, #Lambda^{0} in -1<y<1;p{t} (GeV/c);number of times",75,0,15,5,-0.5,4.5);
 573         fOutputList->Add(fHistNTimesRecLambdaVsPt);
 574
 575         fHistNTimesRecAntiLambdaVsPt  = new TH2F("h2NTimesRecAntiLambdaVsPt","NTimes versus Pt, #bar{#Lambda}^{0} in -1<y<1;p{t} (GeV/c);number of times",75,0,15,5,-0.5,4.5);
 576         fOutputList->Add(fHistNTimesRecAntiLambdaVsPt);
 577
 578         // Pt Distribution of non-primary particles:
 579         fHistMCPtAllK0s                      = new TH1F("h1MCPtAllK0s", "Non-primary MC K^{0};p{t} (GeV/c);Counts",240,0,12);
 580         fOutputList->Add(fHistMCPtAllK0s);
 581
 582         fHistMCPtAllLambda                   = new TH1F("h1MCPtAllLambda", "Non-primary MC #Lambda^{0};p{t} (GeV/c);Counts",240,0,12);
 583         fOutputList->Add(fHistMCPtAllLambda);
 584
 585         fHistMCPtAllAntiLambda               = new TH1F("h1MCPtAllAntiLambda", "Non-primary MC #bar{#Lambda}^{0};p{t} (GeV/c);Counts",240,0,12);
 586         fOutputList->Add(fHistMCPtAllAntiLambda);
 587
 588         fHistMCDaughterTrack         = new TH1F("h1MCDaughterTrack","Distribution of mc id for daughters;id tags;Counts",15,0,15);
 589         fOutputList->Add(fHistMCDaughterTrack);
 590
 591         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);
 592         fOutputList->Add(fHistPrimRawPtVsYK0s);
 593
 594
 595         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);
 596         fOutputList->Add(fHistPrimRawPtVsYLambda);
 597
 598
 599         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);
 600         fOutputList->Add(fHistPrimRawPtVsYAntiLambda);
 601
 602         //---------------------------------------------End Of MC Histos-----------------------------------------------------//
 603
 604         // Primary Vertex:
 605
 606         fHistPrimaryVertexX          = new TH1F("h1PrimaryVertexX", "Primary Vertex Position X;Primary Vertex Position X (cm);Events",100,-0.5,0.5);
 607         fOutputList->Add(fHistPrimaryVertexX);
 608
 609         fHistPrimaryVertexY          = new TH1F("h1PrimaryVertexY", "Primary Vertex Position Y;Primary Vertex Position Y (cm);Events",100,-0.5,0.5);
 610         fOutputList->Add(fHistPrimaryVertexY);
 611
 612         fHistPrimaryVertexZ          = new TH1F("h1PrimaryVertexZ", "Primary Vertex Position Z;Primary Vertex Position Z (cm);Events",200,-20,20);
 613         fOutputList->Add(fHistPrimaryVertexZ);
 614
 615         //////K0s///////////////// 2D histos: cut vs on fly status////
 616
 617         fHistDcaPosToPrimVertexK0      = new TH2F("h2DcaPosToPrimVertexK0", "Positive V0 daughter;dca(cm);Status",100,0,10,2,-0.5,1.5);
 618         fOutputList->Add(fHistDcaPosToPrimVertexK0);
 619
 620         fHistDcaNegToPrimVertexK0      = new TH2F("h2DcaNegToPrimVertexK0", "Negative V0 daughter;dca(cm);Status",100,0,10,2,-0.5,1.5);
 621         fOutputList->Add(fHistDcaNegToPrimVertexK0);
 622
 623
 624         fHistRadiusV0K0                = new TH2F("h2RadiusV0K0", "Radius;Radius(cm);Status",500,0,500,2,-0.5,1.5);
 625         fOutputList->Add(fHistRadiusV0K0);
 626
 627         fHistDecayLengthV0K0           = new TH2F("h2DecayLengthV0K0", "V0s decay Length;decay length(cm);Status", 500, 0, 500,2,-0.5,1.5);
 628         fOutputList->Add(fHistDecayLengthV0K0);
 629
 630         fHistDcaV0DaughtersK0          = new TH2F("h2DcaV0DaughtersK0", "DCA between daughters;dca(cm);Status", 300, 0, 3.0,2,-0.5,1.5);
 631         fOutputList->Add(fHistDcaV0DaughtersK0);
 632
 633         fHistChi2K0                    = new TH2F("h2Chi2K0", "V0s chi2;chi2;Status", 1000, 0, 0.1,2,-0.5,1.5);
 634         fOutputList->Add(fHistChi2K0);
 635
 636         fHistCosPointAngleK0           = new TH2F("h2CosPointAngleK0", "Cosine of V0's pointing angle", 200,0.99,1.01,2,-0.5,1.5);
 637         fOutputList->Add(fHistCosPointAngleK0);
 638
 639
 640         ////////////K0s///////////////// 2D histos: cut vs mass////
 641
 642
 643         fHistDcaPosToPrimVertexK0vsMassK0 = new TH2F("h2DcaPosToPrimVertexK0vsMassK0", "Positive V0 daughter;dca(cm);K0s inv. mass",500,0,10,200,0.4,0.6);
 644         fOutputList->Add(fHistDcaPosToPrimVertexK0vsMassK0);
 645
 646         fHistDcaNegToPrimVertexK0vsMassK0 = new TH2F("h2DcaNegToPrimVertexK0vsMassK0", "Negative V0 daughter;dca(cm);K0s inv. mass",500,0,10,200,0.4,0.6);
 647         fOutputList->Add(fHistDcaNegToPrimVertexK0vsMassK0);
 648
 649
 650         fHistRadiusV0K0vsMassK0           = new TH2F("h2RadiusV0K0vsMassK0", "Radius;Radius(cm);K0s inv. mass",110,0,110,200,0.4,0.6);
 651         fOutputList->Add(fHistRadiusV0K0vsMassK0);
 652
 653         fHistDecayLengthV0K0vsMassK0      = new TH2F("h2DecayLengthV0K0vsMassK0", "V0s decay Length;decay length(cm);K0s inv. mass", 100, 0, 100,200,0.4,0.6);
 654         fOutputList->Add(fHistDecayLengthV0K0vsMassK0);
 655
 656         fHistDcaV0DaughtersK0vsMassK0     = new TH2F("h2DcaV0DaughtersK0vsMassK0", "DCA between daughters;dca(cm);K0s inv. mass", 110, 0, 1.1,200,0.4,0.6);
 657         fOutputList->Add(fHistDcaV0DaughtersK0vsMassK0);
 658
 659
 660         fHistCosPointAngleK0vsMassK0      = new TH2F("h2CosPointAngleK0vsMassK0", "Cosine of V0's pointing angle", 200,0.997,1.007,200,0.4,0.6);
 661         fOutputList->Add(fHistCosPointAngleK0vsMassK0);
 662         //////////Lambda////////////// 2D histos: cut vs on fly status////
 663
 664         fHistDcaPosToPrimVertexL      = new TH2F("h2DcaPosToPrimVertexL", "Positive V0 daughter;dca(cm);Status",100,0,10,2,-0.5,1.5);
 665         fOutputList->Add(fHistDcaPosToPrimVertexL);
 666
 667         fHistDcaNegToPrimVertexL      = new TH2F("h2DcaNegToPrimVertexL", "Negative V0 daughter;dca(cm);Status",100,0,10,2,-0.5,1.5);
 668         fOutputList->Add(fHistDcaNegToPrimVertexL);
 669
 670         fHistRadiusV0L                = new TH2F("h2RadiusV0L", "Radius;Radius(cm);Status",100,0,110,2,-0.5,1.5);
 671         fOutputList->Add(fHistRadiusV0L);
 672
 673         fHistDecayLengthV0L           = new TH2F("h2DecayLengthV0L", "V0s decay Length;decay length(cm);Status", 500, 0, 500,2,-0.5,1.5);
 674         fOutputList->Add(fHistDecayLengthV0L);
 675
 676         fHistDcaV0DaughtersL          = new TH2F("h2DcaV0DaughtersL", "DCA between daughters;dca(cm);Status", 300, 0, 3.0,2,-0.5,1.5);
 677         fOutputList->Add(fHistDcaV0DaughtersL);
 678
 679         fHistChi2L                    = new TH2F("h2Chi2L", "V0s chi2;chi2;Status", 100, 0, 0.10,2,-0.5,1.5);
 680         fOutputList->Add(fHistChi2L);
 681
 682         fHistCosPointAngleL           = new TH2F("h2CosPointAngleL", "Cosine of V0's pointing angle", 200,0.99,1.01,2,-0.5,1.5);
 683         fOutputList->Add(fHistCosPointAngleL);
 684
 685         fHistcTauL                    = new TH1F("h1cTauL","cTaou of Lambdas",100,0,100);
 686         fOutputList->Add(fHistcTauL);
 687         //////////Lambda////////////// 2D histos: cut vs mass////
 688         fHistDcaPosToPrimVertexLvsMassL      = new TH2F("h2DcaPosToPrimVertexLvsMassL", "Positive V0 daughter;dca(cm);Status",100,0,10,140, 1.06, 1.2);
 689         fOutputList->Add(fHistDcaPosToPrimVertexLvsMassL);
 690
 691         fHistDcaNegToPrimVertexLvsMassL      = new TH2F("h2DcaNegToPrimVertexLvsMassL", "Negative V0 daughter;dca(cm);Status",100,0,10,140, 1.06, 1.2);
 692         fOutputList->Add(fHistDcaNegToPrimVertexLvsMassL);
 693
 694
 695         fHistRadiusV0LvsMassL                = new TH2F("h2RadiusV0LvsMassL", "Radius;Radius(cm);Status",110,0,110,140, 1.06, 1.2);
 696         fOutputList->Add(fHistRadiusV0LvsMassL);
 697
 698         fHistDecayLengthV0LvsMassL           = new TH2F("h2DecayLengthV0LvsMassL", "V0s decay Length;decay length(cm);Status", 120, 0, 120,140, 1.06, 1.2);
 699         fOutputList->Add(fHistDecayLengthV0LvsMassL);
 700
 701         fHistDcaV0DaughtersLvsMassL          = new TH2F("h2DcaV0DaughtersLvsMassL", "DCA between daughters;dca(cm);Status", 110, 0, 1.1,140, 1.06, 1.2);
 702         fOutputList->Add(fHistDcaV0DaughtersLvsMassL);
 703
 704         fHistCosPointAngleLvsMassL           = new TH2F("h2CosPointAngleLvsMassL", "Cosine of V0's pointing angle", 200,0.997,1.007,140, 1.06, 1.2);
 705         fOutputList->Add(fHistCosPointAngleLvsMassL);
 706
 707         fHistCosPointAngleLVsMassVsPtsigL           = new TH3F("h3McCosPointAngleLVsMassVsPtsigL", "Cosine of V0's pointing angle",3,0,12, 2,00.997,1.007,140, 1.06, 1.2);
 708         fOutputList->Add(fHistCosPointAngleLVsMassVsPtsigL);
 709
 710         fHistCosPointAngleLVsMassVsPtbackL           = new TH3F("h3McCosPointAngleLVsMassVsPtbackL", "Cosine of V0's pointing angle",3,0,12, 20,0.997,1.007,140, 1.06, 1.2);
 711         fOutputList->Add(fHistCosPointAngleLVsMassVsPtbackL);
 712
 713
 714         //////////AntiLambda////////////// 2D histos: cut vs on fly status////
 715
 716         fHistDcaPosToPrimVertexAntiL      = new TH2F("h2DcaPosToPrimVertexAntiL", "Positive V0 daughter;dca(cm);Status",100,0,10,2,-0.5,1.5);
 717         fOutputList->Add(fHistDcaPosToPrimVertexAntiL);
 718
 719         fHistDcaNegToPrimVertexAntiL      = new TH2F("h2DcaNegToPrimVertexAntiL", "Negative V0 daughter;dca(cm);Status",100,0,10,2,-0.5,1.5);
 720         fOutputList->Add(fHistDcaNegToPrimVertexAntiL);
 721
 722
 723         fHistRadiusV0AntiL                = new TH2F("h2RadiusV0AntiL", "Radius;Radius(cm);Status",100,0,110,2,-0.5,1.5);
 724         fOutputList->Add(fHistRadiusV0AntiL);
 725
 726         fHistDecayLengthV0AntiL           = new TH2F("h2DecayLengthV0AntiL", "V0s decay Length;decay length(cm);Status", 500, 0, 500,2,-0.5,1.5);
 727         fOutputList->Add(fHistDecayLengthV0AntiL);
 728
 729         fHistDcaV0DaughtersAntiL          = new TH2F("h2DcaV0DaughtersAntiL", "DCA between daughters;dca(cm);Status", 300, 0, 3.0,2,-0.5,1.5);
 730         fOutputList->Add(fHistDcaV0DaughtersAntiL);
 731
 732         fHistChi2AntiL                    = new TH2F("h2Chi2AntiL", "V0s chi2;chi2;Status", 100, 0, 0.10,2,-0.5,1.5);
 733         fOutputList->Add(fHistChi2AntiL);
 734
 735         fHistCosPointAngleAntiL           = new TH2F("h2CosPointAngleAntiL", "Cosine of V0's pointing angle", 200,0.99,1.01,2,-0.5,1.5);
 736         fOutputList->Add(fHistCosPointAngleAntiL);
 737
 738         //////////AntiLambda////////////// 2D histos: cut vs mass////
 739
 740         fHistDcaPosToPrimVertexAntiLvsMass      = new TH2F("h2DcaPosToPrimVertexAntiLvsMass", "Positive V0 daughter;dca(cm);Status",100,0,10,140, 1.06, 1.2);
 741         fOutputList->Add(fHistDcaPosToPrimVertexAntiLvsMass);
 742
 743         fHistDcaNegToPrimVertexAntiLvsMass      = new TH2F("h2DcaNegToPrimVertexAntiLvsMass", "Negative V0 daughter;dca(cm);Status",100,0,10,140, 1.06, 1.2);
 744         fOutputList->Add(fHistDcaNegToPrimVertexAntiLvsMass);
 745
 746
 747         fHistRadiusV0AntiLvsMass                = new TH2F("h2RadiusV0AntiLvsMass", "Radius;Radius(cm);Status",110,0,110,140, 1.06, 1.2);
 748         fOutputList->Add(fHistRadiusV0AntiLvsMass);
 749
 750         fHistDecayLengthV0AntiLvsMass           = new TH2F("h2DecayLengthV0AntiLvsMass", "V0s decay Length;decay length(cm);Status", 120, 0, 120,140, 1.06, 1.2);
 751         fOutputList->Add(fHistDecayLengthV0AntiLvsMass);
 752
 753         fHistDcaV0DaughtersAntiLvsMass          = new TH2F("h2DcaV0DaughtersAntiLvsMass", "DCA between daughters;dca(cm);Status", 110, 0, 1.1,140, 1.06, 1.2);
 754         fOutputList->Add(fHistDcaV0DaughtersAntiLvsMass);
 755
 756         fHistCosPointAngleAntiLvsMass           = new TH2F("h2CosPointAngleAntiLvsMass", "Cosine of V0's pointing angle", 200,0.997,1.007,140, 1.06, 1.2);
 757         fOutputList->Add(fHistCosPointAngleAntiLvsMass);
 758
 759         // Mass:
 760         fHistMassK0                   = new TH1F("h1MassK0", "K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts", 200, 0.4, 0.6);
 761         fOutputList->Add(fHistMassK0);
 762
 763         fHistMassLambda               = new TH1F("h1MassLambda", "#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});Counts", 150, 1.05, 1.2);
 764         fOutputList->Add(fHistMassLambda);
 765
 766         fHistMassAntiLambda           = new TH1F("h1MassAntiLambda", "#bar{#Lambda}^{0} candidates;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts", 150, 1.05, 1.2);
 767         fOutputList->Add(fHistMassAntiLambda);
 768
 769         fHistMassVsRadiusK0           = new TH2F("h2MassVsRadiusK0", "K^{0} candidates;radius (cm);M(#pi^{+}#pi^{-}) (GeV/c^{2})",200,0,200, 200, 0.4, 0.6);
 770         fOutputList->Add(fHistMassVsRadiusK0);
 771
 772         fHistMassVsRadiusLambda       = new TH2F("h2MassVsRadiusLambda", "#Lambda candidates;radius (cm);M(p#pi^{-}) (GeV/c^{2})",200,0,200, 140, 1.06, 1.2);
 773         fOutputList->Add(fHistMassVsRadiusLambda);
 774
 775         fHistMassVsRadiusAntiLambda   = new TH2F("h2MassVsRadiusAntiLambda", "#bar{#Lambda} candidates;radius (cm);M(#bar{p}#pi^{+}) (GeV/c^{2})",200,0,200, 140, 1.06, 1.2);
 776         fOutputList->Add(fHistMassVsRadiusAntiLambda);
 777
 778         // Pt Vs Mass
 779         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);
 780         fOutputList->Add(fHistPtVsMassK0);
 781
 782         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);
 783         fOutputList->Add(fHistPtVsMassLambda);
 784
 785         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);
 786         fOutputList->Add(fHistPtVsMassAntiLambda);
 787
 788         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 789
 790         ///Armenteros Podolansky
 791         fHistArmenterosPodolanski     = new TH2F("h2ArmenterosPodolanski","Armenteros-Podolanski phase space;#alpha;p{t} arm",100,-1.0,1.0,50,0,0.5);
 792         fOutputList->Add(fHistArmenterosPodolanski);
 793
 794         //PID
 795
 796         fHistNsigmaPosProtonLambda     = new TH1F("h1NsigmaPosProtonLambda", "Positive daughter of Lambda;NsigmaProton;Counts",25,0,5);
 797         fOutputList->Add(fHistNsigmaPosProtonLambda);
 798
 799         fHistNsigmaNegPionLambda       = new TH1F("h1NsigmaNegPionLambda", "Negative daughter of Lambda;NsigmaPion;Counts",25,0,5);
 800         fOutputList->Add(fHistNsigmaNegPionLambda);
 801
 802         fHistNsigmaPosProtonAntiLambda     = new TH1F("h1NsigmaPosProtonAntiLambda", "Positive daughter of AntiLambda;NsigmaProton;Counts",25,0,5);
 803         fOutputList->Add(fHistNsigmaPosProtonAntiLambda);
 804
 805         fHistNsigmaNegPionAntiLambda       = new TH1F("h1NsigmaNegPionAntiLambda", "Negative daughter of AntiLambda;NsigmaPion;Counts",25,0,5);
 806         fOutputList->Add(fHistNsigmaNegPionAntiLambda);
 807
 808         fHistNsigmaPosPionK0           = new TH1F("h1NsigmaPosPionK0", "Positive daughter of K0s;NsigmaPion;Counts",25,0,5);
 809         fOutputList->Add(fHistNsigmaPosPionK0);
 810
 811         fHistNsigmaNegPionK0           = new TH1F("h1NsigmaNegPionK0", "Negative daughter of K0s;NsigmaPion;Counts",25,0,5);
 812         fOutputList->Add(fHistNsigmaNegPionK0);
 813
 814
 815 //--------------------------------------------MC Associated histograms -----------------------------------------------------//
 816
 817         //Pt distribution
 818         fHistAsMcPtK0                = new TH1F("h1AsMcPtK0", "K^{0} associated;p{t} (GeV/c);Counts", 240,0,12);
 819         fOutputList->Add(fHistAsMcPtK0);
 820
 821         fHistAsMcPtLambda            = new TH1F("h1AsMcPtLambda", "#Lambda^{0} associated;p{t} (GeV/c);Counts", 240,0,12);
 822         fOutputList->Add(fHistAsMcPtLambda);
 823
 824         fHistAsMcPtAntiLambda            = new TH1F("h1AsMcPtAntiLambda", "#AntiLambda^{0} associated;p{t} (GeV/c);Counts", 240,0,12);
 825         fOutputList->Add(fHistAsMcPtAntiLambda);
 826
 827         // Radius distribution
 828         fHistAsMcProdRadiusK0               = new TH1F("h1AsMcProdRadiusK0", "K^{0} associated;r (cm);Counts", 500, 0, 100);
 829         fOutputList->Add(fHistAsMcProdRadiusK0);
 830
 831         fHistAsMcProdRadiusLambda           = new TH1F("h1AsMcProdRadiusLambda", "#Lambda^{0} associated;r (cm);Counts", 500, 0, 100);
 832         fOutputList->Add(fHistAsMcProdRadiusLambda);
 833
 834         fHistAsMcProdRadiusAntiLambda       = new TH1F("h1AsMcProdRadiusAntiLambda", "#bar{#Lambda}^{0} associated;r (cm);Counts", 500, 0, 100);
 835         fOutputList->Add(fHistAsMcProdRadiusAntiLambda);
 836
 837         fHistAsMcProdRadiusXvsYK0s          = new TH2F("h2AsMcProdRadiusXvsYK0s","Associated Secondary K^{0} Production Radius;x (cm); y (cm)",200,-50,50,200,-50,50);
 838         fOutputList->Add(fHistAsMcProdRadiusXvsYK0s);
 839
 840         fHistAsMcProdRadiusXvsYLambda       = new TH2F("h2AsMcProdRadiusXvsYLambda","Associated Secondary #Lambda^{0} Production Radius;x (cm); y (cm)",200,-50,50,200,-50,50);
 841         fOutputList->Add(fHistAsMcProdRadiusXvsYLambda);
 842
 843         fHistAsMcProdRadiusXvsYAntiLambda   = new TH2F("h2AsMcProdRadiusXvsYAntiLambda","Associated Secondary #bar{#Lambda}^{0} Production Radius;x (cm); y (cm)",200,-50,50,200,-50,50);
 844         fOutputList->Add(fHistAsMcProdRadiusXvsYAntiLambda);
 845
 846         // Mass
 847         fHistPidMcMassK0             = new TH1F("h1PidMcMassK0", "K^{0} MC PId checked;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts", 100, 0.4, 0.6);
 848         fOutputList->Add(fHistPidMcMassK0);
 849
 850         fHistPidMcMassLambda         = new TH1F("h1PidMcMassLambda", "#Lambda^{0} MC PId checked;M(p#pi^{-}) (GeV/c^{2});Counts", 75, 1.05, 1.2);
 851         fOutputList->Add(fHistPidMcMassLambda);
 852
 853         fHistPidMcMassAntiLambda     = new TH1F("h1PidMcMassAntiLambda", "#bar{#Lambda}^{0} MC PId checked;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts", 75, 1.05, 1.2);
 854         fOutputList->Add(fHistPidMcMassAntiLambda);
 855
 856         fHistAsMcMassK0              = new TH1F("h1AsMcMassK0", "K^{0} associated;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts", 100, 0.4, 0.6);
 857         fOutputList->Add(fHistAsMcMassK0);
 858
 859         fHistAsMcMassLambda          = new TH1F("h1AsMcMassLambda", "#Lambda^{0} associated;M(p#pi^{-}) (GeV/c^{2});Counts", 75, 1.05, 1.2);
 860         fOutputList->Add(fHistAsMcMassLambda);
 861
 862         fHistAsMcMassAntiLambda      = new TH1F("h1AsMcMassAntiLambda", "#bar{#Lambda}^{0} associated;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts", 75, 1.05, 1.2);
 863         fOutputList->Add(fHistAsMcMassAntiLambda);
 864
 865         //Pt versus Mass
 866         fHistAsMcPtVsMassK0               = new TH2F("h2AsMcPtVsMassK0","K^{0} associated;M(#pi^{+}#pi^{-}) (GeV/c^{2});p{t} (GeV/c)",200, 0.4, 0.6,240,0,12);
 867         fOutputList->Add(fHistAsMcPtVsMassK0);
 868
 869         fHistAsMcPtVsMassLambda           = new TH2F("h2AsMcPtVsMassLambda","#Lambda^{0} associated;M(p#pi^{-}) (GeV/c^{2});p{t} (GeV/c)",140, 1.06, 1.2,240,0,12);
 870         fOutputList->Add(fHistAsMcPtVsMassLambda);
 871
 872         fHistAsMcPtVsMassAntiLambda       = new TH2F("h2AsMcPtVsMassAntiLambda","#bar{#Lambda}^{0} associated;M(#bar{p}#pi^{+}) (GeV/c^{2});p{t} (GeV/c)",140, 1.06, 1.2,240,0,12);
 873         fOutputList->Add(fHistAsMcPtVsMassAntiLambda);
 874
 875
 876         // invariant mass vs radius
 877         fHistAsMcMassVsRadiusK0             = new TH2F("h2AsMcMassVsRadiusK0", "K^{0} associated;radius (cm);M(#pi^{+}#pi^{-}) (GeV/c^{2})",200,0,200, 500, 0.47, 0.52);
 878         fOutputList->Add(fHistAsMcMassVsRadiusK0);
 879
 880         fHistAsMcMassVsRadiusLambda         = new TH2F("h2AsMcMassVsRadiusLambda", "#Lambda associated;radius (cm);M(p#pi^{-}) (GeV/c^{2})",200,0,200, 1.10, 1.13);
 881         fOutputList->Add(fHistAsMcMassVsRadiusLambda);
 882
 883         fHistAsMcMassVsRadiusAntiLambda     = new TH2F("h2AsMcMassVsRadiusAntiLambda", "#bar{#Lambda} associated;radius (cm);M(#bar{p}#pi^{+}) (GeV/c^{2})",200,0,200 , 1.10, 1.13);
 884         fOutputList->Add(fHistAsMcMassVsRadiusAntiLambda);
 885
 886         // Position Resolution
 887         fHistAsMcResxK0                     = new TH1F("h1AsMcResxK0", "K^{0} associated;#Delta x (cm);Counts", 50, -0.25, 0.25);
 888         fOutputList->Add(fHistAsMcResxK0);
 889         fHistAsMcResyK0                     = new TH1F("h1AsMcResyK0", "K^{0} associated;#Delta y (cm);Counts", 50, -0.25, 0.25);
 890         fOutputList->Add(fHistAsMcResyK0);
 891         fHistAsMcReszK0                     = new TH1F("h1AsMcReszK0", "K^{0} associated;#Delta z (cm);Counts", 50, -0.25, 0.25);
 892         fOutputList->Add(fHistAsMcReszK0);
 893         fHistAsMcResrVsRadiusK0             = new TH2F("h2AsMcResrVsRadiusK0", "K^{0} associated;Radius (cm);#Delta r (cm)",200,0.0,50., 50, -0.25, 0.25);
 894         fOutputList->Add(fHistAsMcResrVsRadiusK0);
 895         fHistAsMcReszVsRadiusK0             = new TH2F("h2AsMcReszVsRadiusK0", "K^{0} associated;Radius (cm);#Delta z (cm)",200,0.0,50.0, 50, -0.25, 0.25);
 896         fOutputList->Add(fHistAsMcReszVsRadiusK0);
 897
 898         fHistAsMcResxLambda                 = new TH1F("h1AsMcResxLambda", "#Lambda^{0} associated;#Delta x (cm);Counts", 50, -0.25, 0.25);
 899         fOutputList->Add(fHistAsMcResxLambda);
 900         fHistAsMcResyLambda                 = new TH1F("h1AsMcResyLambda", "#Lambda^{0} associated;#Delta y (cm);Counts", 50, -0.25, 0.25);
 901         fOutputList->Add(fHistAsMcResyLambda);
 902         fHistAsMcReszLambda                 = new TH1F("h1AsMcReszLambda", "#Lambda^{0} associated;#Delta z (cm);Counts", 50, -0.25, 0.25);
 903         fOutputList->Add(fHistAsMcReszLambda);
 904         fHistAsMcResrVsRadiusLambda         = new TH2F("h2AsMcResrVsRadiusLambda", "#Lambda^{0} associated;Radius (cm);#Delta r (cm)",200,0.0,50.0, 50, -0.25, 0.25);
 905         fOutputList->Add(fHistAsMcResrVsRadiusLambda);
 906         fHistAsMcReszVsRadiusLambda         = new TH2F("h2AsMcReszVsRadiusLambda", "#Lambda^{0} associated;Radius (cm);#Delta z (cm)",200,0.0,50.0, 50, -0.25, 0.25);
 907         fOutputList->Add(fHistAsMcReszVsRadiusLambda);
 908
 909         fHistAsMcResxAntiLambda             = new TH1F("h1AsMcResxAntiLambda", "#bar{#Lambda}^{0} associated;#Delta x (cm);Counts", 50, -0.25, 0.25);
 910         fOutputList->Add(fHistAsMcResxAntiLambda);
 911         fHistAsMcResyAntiLambda             = new TH1F("h1AsMcResyAntiLambda", "#bar{#Lambda}^{0} associated;#Delta y (cm);Counts", 50, -0.25, 0.25);
 912         fOutputList->Add(fHistAsMcResyAntiLambda);
 913         fHistAsMcReszAntiLambda             = new TH1F("h1AsMcReszAntiLambda", "#bar{#Lambda}^{0} associated;#Delta z (cm);Counts", 50, -0.25, 0.25);
 914         fOutputList->Add(fHistAsMcReszAntiLambda);
 915         fHistAsMcResrVsRadiusAntiLambda     = new TH2F("h2AsMcResrVsRadiusAntiLambda", "#bar{#Lambda}^{0} associated;Radius (cm);#Delta r (cm)",200,0.0,50.0, 50, -0.25, 0.25);
 916         fOutputList->Add(fHistAsMcResrVsRadiusAntiLambda);
 917         fHistAsMcReszVsRadiusAntiLambda     = new TH2F("h2AsMcReszVsRadiusAntiLambda", "#bar{#Lambda}^{0} associated;Radius (cm);#Delta z (cm)",200,0.0,50.0, 50, -0.25, 0.25);
 918         fOutputList->Add(fHistAsMcReszVsRadiusAntiLambda);
 919
 920         // Pt Resolution
 921         fHistAsMcResPtK0                   = new TH1F("h1AsMcResPtK0","Pt Resolution K^{0};#Delta Pt;Counts",200,-1,1);
 922         fOutputList->Add(fHistAsMcResPtK0);
 923
 924         fHistAsMcResPtLambda               = new TH1F("h1AsMcResPtLambda","Pt Resolution #Lambda^{0};#Delta Pt;Counts",200,-1,1);
 925         fOutputList->Add(fHistAsMcResPtLambda);
 926
 927         fHistAsMcResPtAntiLambda           = new TH1F("h1AsMcResPtAntiLambda","Pt Resolution #bar{#Lambda}^{0};#Delta Pt;Counts",200,-1,1);
 928         fOutputList->Add(fHistAsMcResPtAntiLambda);
 929
 930
 931         fHistAsMcResPtVsRapK0              = new TH2F("h2AsMcResPtVsRapK0","Pt Resolution K^{0};#Delta Pt;Rap",200,-1,1,20,-1,1);
 932         fOutputList->Add(fHistAsMcResPtVsRapK0);
 933
 934         fHistAsMcResPtVsRapLambda          = new TH2F("h2AsMcResPtVsRapLambda","Pt Resolution #Lambda^{0};#Delta Pt;Rap",200,-1,1,20,-1,1);
 935         fOutputList->Add(fHistAsMcResPtVsRapLambda);
 936
 937         fHistAsMcResPtVsRapAntiLambda      = new TH2F("h2AsMcResPtVsRapAntiLambda","Pt Resolution #bar{#Lambda}^{0};#Delta Pt;Rap",200,-1,1,20,-1,1);
 938         fOutputList->Add(fHistAsMcResPtVsRapAntiLambda);
 939
 940         fHistAsMcResPtVsPtK0               = new TH2F("h2AsMcResPtVsPtK0","Pt Resolution K^{0};#Delta Pt;Pt",600,-0.15,0.15,240,0,12);
 941         fOutputList->Add(fHistAsMcResPtVsPtK0);
 942
 943         fHistAsMcResPtVsPtLambda           = new TH2F("h2AsMcResPtVsPtLambda","Pt Resolution #Lambda^{0};#Delta Pt;Pt",600,-0.15,0.15,240,0,12);
 944         fOutputList->Add(fHistAsMcResPtVsPtLambda);
 945
 946         fHistAsMcResPtVsPtAntiLambda       = new TH2F("h2AsMcResPtVsPtAntiLambda","Pt Resolution #bar{#Lambda}^{0};#Delta Pt;Pt",300,-0.15,0.15,240,0,12);
 947         fOutputList->Add(fHistAsMcResPtVsPtAntiLambda);
 948
 949         // Pt distribution Lambda from Sigma
 950         fHistAsMcPtLambdaFromSigma          = new TH1F("h1AsMcPtLambdaFromSigma","#Lambda}^{0} associated from Sigma;p{t} (GeV/c);Count",240,0,12);
 951         fOutputList->Add(fHistAsMcPtLambdaFromSigma);
 952
 953         fHistAsMcPtAntiLambdaFromSigma      = new TH1F("h1AsMcPtAntiLambdaFromSigma","#bar{#Lambda}^{0} associated from Sigma;p{t} (GeV/c);Count",240,0,12);
 954         fOutputList->Add(fHistAsMcPtAntiLambdaFromSigma);
 955
 956         // Associated secondary particles:
 957         // Pt and rapidity distribution
 958         fHistAsMcSecondaryPtVsRapK0s          = new TH2F("h2AsMcSecondaryPtVsRapK0s", "K^{0} associated secondary;p{t} (GeV/c);rapidity",240,0,12,30,-1.5,1.5);
 959         fOutputList->Add(fHistAsMcSecondaryPtVsRapK0s);
 960
 961         fHistAsMcSecondaryPtVsRapLambda       = new TH2F("h2AsMcSecondaryPtVsRapLambda", "#Lambda^{0} associated secondary;p{t} (GeV/c);rapidity",240,0,12,30,-1.5,1.5);
 962         fOutputList->Add(fHistAsMcSecondaryPtVsRapLambda);
 963
 964         fHistAsMcSecondaryPtVsRapAntiLambda   = new TH2F("h2AsMcSecondaryPtVsRapAntiLambda", "#bar{#Lambda}^{0} associated secondary;p{t} (GeV/c);rapidity",240,0,12,30,-1.5,1.5);
 965         fOutputList->Add(fHistAsMcSecondaryPtVsRapAntiLambda);
 966
 967         // Production radius
 968         fHistAsMcSecondaryProdRadiusK0s              = new TH1F("h1AsMcSecondaryProdRadiusK0s", "K^{0} Production Radius;r (cm);Count", 170, -2, 15);
 969         fOutputList->Add(fHistAsMcSecondaryProdRadiusK0s);
 970
 971         fHistAsMcSecondaryProdRadiusLambda           = new TH1F("h1AsMcSecondaryProdRadiusLambda", "#Lambda^{0} Production Radius;r (cm);Count", 170, -2, 15);
 972         fOutputList->Add(fHistAsMcSecondaryProdRadiusLambda);
 973
 974         fHistAsMcSecondaryProdRadiusAntiLambda       = new TH1F("h1AsMcSecondaryProdRadiusAntiLambda", "#bar{#Lambda}^{0} Production Radius;r (cm);Count", 170, -2, 15);
 975         fOutputList->Add(fHistAsMcSecondaryProdRadiusAntiLambda);
 976
 977         fHistAsMcSecondaryProdRadiusXvsYK0s          = new TH2F("h2AsMcSecondaryProdRadiusXvsYK0s","Associated Secondary K^{0} Production Radius;x (cm); y (cm)",200,-20,20,200,-20,20);
 978         fOutputList->Add(fHistAsMcSecondaryProdRadiusXvsYK0s);
 979
 980         fHistAsMcSecondaryProdRadiusXvsYLambda       = new TH2F("h2AsMcSecondaryProdRadiusXvsYLambda","Associated Secondary #Lambda^{0} Production Radius;x (cm); y (cm)",200,-20,20,200,-20,20);
 981         fOutputList->Add(fHistAsMcSecondaryProdRadiusXvsYLambda);
 982
 983         fHistAsMcSecondaryProdRadiusXvsYAntiLambda   = new TH2F("h2AsMcSecondaryProdRadiusXvsYAntiLambda","Associated Secondary #bar{#Lambda}^{0} Production Radius;x (cm); y (cm)",200,-20,20,200,-20,20);
 984         fOutputList->Add(fHistAsMcSecondaryProdRadiusXvsYAntiLambda);
 985
 986         // Pt distribution Lambda from Sigma
 987         fHistAsMcSecondaryPtLambdaFromSigma          = new TH1F("h1AsMcSecondaryPtLambdaFromSigma","#Lambda}^{0} associated from Sigma;p{t} (GeV/c);Count",240,0,12);
 988         fOutputList->Add(fHistAsMcSecondaryPtLambdaFromSigma);
 989
 990         fHistAsMcSecondaryPtAntiLambdaFromSigma      = new TH1F("h1AsMcSecondaryPtAntiLambdaFromSigma","#bar{#Lambda}^{0} associated from Sigma;p{t} (GeV/c);Count",240,0,12);
 991         fOutputList->Add(fHistAsMcSecondaryPtAntiLambdaFromSigma);
 992
 993
 994         //----------------------------------------------Correlation histograms -----------------------------------------------------//
 995
 996         fHistSibK0 = new TH2F("hfHistSibK0","",CorrBinsX,-2*fTrackEtaCut,2*fTrackEtaCut,CorrBinsY,-TMath::Pi()/2,3*TMath::Pi()/2);
 997         fHistSibK0->SetXTitle("#Delta #Phi");
 998         fHistSibK0->SetStats(0);
 999         fHistSibK0->Sumw2();
1000         fOutputList->Add(fHistSibK0);
1001
1002         fHistMixK0 = new TH2F("hfHistMixK0","",CorrBinsX,-2*fTrackEtaCut,2*fTrackEtaCut,CorrBinsY,-TMath::Pi()/2,3*TMath::Pi()/2);
1003         fHistMixK0->SetXTitle("#Delta #Phi");
1004         fHistMixK0->SetStats(0);
1005         fHistMixK0->Sumw2();
1006         fOutputList->Add(fHistMixK0);
1007
1008         fHistSibLambda = new TH2F("hfHistSibLambda","",CorrBinsX,-2*fTrackEtaCut,2*fTrackEtaCut,CorrBinsY,-TMath::Pi()/2,3*TMath::Pi()/2);
1009         fHistSibLambda->SetXTitle("#Delta #Phi");
1010         fHistSibLambda->SetStats(0);
1011         fHistSibLambda->Sumw2();
1012         fOutputList->Add(fHistSibLambda);
1013
1014         fHistMixLambda= new TH2F("hfHistMixLambda","",CorrBinsX,-2*fTrackEtaCut,2*fTrackEtaCut,CorrBinsY,-TMath::Pi()/2,3*TMath::Pi()/2);
1015         fHistMixLambda->SetXTitle("#Delta #Phi");
1016         fHistMixLambda->SetStats(0);
1017         fHistMixLambda->Sumw2();
1018         fOutputList->Add(fHistMixLambda);
1019
1020         fHistSibK0MC = new TH2F("hfHistSibK0MC","",CorrBinsX,-2*fTrackEtaCut,2*fTrackEtaCut,CorrBinsY,-TMath::Pi()/2,3*TMath::Pi()/2);
1021         fHistSibK0MC->SetXTitle("#Delta #Phi");
1022         fHistSibK0MC->SetStats(0);
1023         fHistSibK0MC->Sumw2();
1024         fOutputList->Add(fHistSibK0MC);
1025
1026         fHistMixK0MC = new TH2F("hfHistMixK0MC","",CorrBinsX,-2*fTrackEtaCut,2*fTrackEtaCut,CorrBinsY,-TMath::Pi()/2,3*TMath::Pi()/2);
1027         fHistMixK0MC->SetXTitle("#Delta #Phi");
1028         fHistMixK0MC->SetStats(0);
1029         fHistMixK0MC->Sumw2();
1030         fOutputList->Add(fHistMixK0MC);
1031
1032         fHistSibLambdaMC = new TH2F("hfHistSibLambdaMC","",CorrBinsX,-2*fTrackEtaCut,2*fTrackEtaCut,CorrBinsY,-TMath::Pi()/2,3*TMath::Pi()/2);
1033         fHistSibLambdaMC->SetXTitle("#Delta #Phi");
1034         fHistSibLambdaMC->SetStats(0);
1035         fHistSibLambdaMC->Sumw2();
1036         fOutputList->Add(fHistSibLambdaMC);
1037
1038         fHistMixLambdaMC= new TH2F("hfHistMixLambdaMC","",CorrBinsX,-2*fTrackEtaCut,2*fTrackEtaCut,CorrBinsY,-TMath::Pi()/2,3*TMath::Pi()/2);
1039         fHistMixLambdaMC->SetXTitle("#Delta #Phi");
1040         fHistMixLambdaMC->SetStats(0);
1041         fHistMixLambdaMC->Sumw2();
1042         fOutputList->Add(fHistMixLambdaMC);
1043
1044         //----------------------------------------------Event Pool-----------------------------------------------------//
1045
1046         fPoolMgr = new AliEventPoolManager(fPoolMaxNEvents, fPoolMinNTracks, fNCentBins, fCentBins, fNzVtxBins, fZvtxBins);
1047         if(!fPoolMgr) return;
1048
1049         PostData(1, fOutputList);
1050
1051 }
1052 //---------------------------------------------------------------------------------------
1053 void AliLeadingV0Correlation::UserExec(Option_t *)
1054 {
1055
1056     AliAnalysisManager   *mgr      = AliAnalysisManager::GetAnalysisManager();
1057     AliInputEventHandler *inEvMain = (AliInputEventHandler*)(mgr->GetInputEventHandler());
1058         if (!inEvMain) return;
1059
1060         // Pointers to PID Response objects.
1061         fPIDResponse = inEvMain->GetPIDResponse();
1062         //cout << "PID Response object: " << fPIDResponse << endl;
1063
1064     fAODEvent = dynamic_cast<AliAODEvent*>(inEvMain->GetEvent());
1065         if(!fAODEvent) return;
1066
1067
1068         // physics selection
1069         UInt_t maskIsSelected = inEvMain->IsEventSelected();
1070     Bool_t isSelected = ((maskIsSelected & AliVEvent::kMB) || (maskIsSelected & AliVEvent::kCentral) || (maskIsSelected & AliVEvent::kSemiCentral));
1071     if (!isSelected) return;
1072
1073         //-----------------------------MC Accsess------------------------------------------------
1074         TClonesArray *stack = 0x0;
1075         Double_t mcXv=0., mcYv=0., mcZv=0.;
1076         Int_t ntrk =0, ntrk0=0;
1077
1078         TObjArray *selectedTracksLeadingK0MC =0x0;
1079     TObjArray *selectedTracksLeadingLambdaMC = 0x0;
1080
1081         TObjArray * selectedK0MC =new TObjArray;
1082         selectedK0MC->SetOwner(kTRUE);
1083
1084         TObjArray * selectedLambdaMC =new TObjArray;
1085         selectedLambdaMC->SetOwner(kTRUE);
1086
1087         if (fAnalysisMC) {
1088                 TList *lst = fAODEvent->GetList();
1089                 stack = (TClonesArray*)lst->FindObject(AliAODMCParticle::StdBranchName());
1090                 if (!stack) {Printf("ERROR: stack not available");return;}
1091
1092                 AliAODMCHeader *mcHdr=(AliAODMCHeader*)lst->FindObject(AliAODMCHeader::StdBranchName());
1093                 mcXv=mcHdr->GetVtxX(); mcYv=mcHdr->GetVtxY(); mcZv=mcHdr->GetVtxZ();
1094                 ntrk=stack->GetEntriesFast(), ntrk0=ntrk;
1095                 if(TMath::Abs(mcZv)>fpvzcut)return;
1096
1097                 selectedTracksLeadingK0MC = FindLeadingObjectsK0MC(stack);
1098                 if(!selectedTracksLeadingK0MC) return;
1099                 selectedTracksLeadingK0MC->SetOwner(kTRUE);
1100
1101                 selectedTracksLeadingLambdaMC = FindLeadingObjectsLambdaMC(stack);
1102                 if(!selectedTracksLeadingLambdaMC) return;
1103                 selectedTracksLeadingLambdaMC->SetOwner(kTRUE);
1104
1105         }
1106
1107         // If PID is used:
1108         Double_t lLimitPPID    = 0.7;
1109         Float_t cutNSigmaLowP  = 1E3;
1110         Float_t cutNSigmaHighP = 1E3;
1111         if (fUsePID=="withPID") {
1112                 cutNSigmaLowP  = 3.0;
1113                 cutNSigmaHighP = 3.0;
1114         }
1115
1116         Double_t lmcPrimVtxR      = 0;
1117
1118         Int_t lPdgcodeCurrentPart = 0;
1119         Double_t lRapCurrentPart  = 0;
1120         Double_t lPtCurrentPart   = 0;
1121         Double_t lPhiCurrentPart  = 0;
1122         Double_t lEtaCurrentPart  = 0;
1123         Int_t lComeFromSigma      = 0;
1124
1125         // PID flags:
1126         Int_t LambdaPID = 0;
1127         Int_t AntiLambdaPID = 0;
1128
1129
1130         // Production Radius
1131         Double_t mcPosX     = 0.0,  mcPosY      = 0.0,  mcPosZ      = 0.0;
1132         Double_t mcPosR     = 0.0;
1133
1134         // Decay Radius
1135         Double_t mcDecayPosX = 0, mcDecayPosY = 0, mcDecayPosR = 0;
1136
1137         // current mc particle 's mother
1138         Int_t iCurrentMother  = 0, lPdgCurrentMother    = 0;
1139
1140         // current mc particles 's daughter:
1141         Int_t lPdgCurrentDaughter0 = 0, lPdgCurrentDaughter1 = 0;
1142
1143         // variables for multiple reconstruction studies:
1144         Int_t id0           = 0, id1          = 0;
1145         Int_t lNtimesReconstructedK0s   = 0, lNtimesReconstructedLambda   = 0, lNtimesReconstructedAntiLambda   = 0;
1146
1147
1148         // Start loop over MC particles
1149         if (fAnalysisMC) {
1150
1151                 // Primary vertex
1152                 fHistMCPrimaryVertexX->Fill(mcXv);
1153                 fHistMCPrimaryVertexY->Fill(mcYv);
1154                 fHistMCPrimaryVertexZ->Fill(mcZv);
1155
1156                 lmcPrimVtxR = TMath::Sqrt(mcXv*mcXv+mcYv*mcYv);
1157
1158
1159                 for (Int_t iMc = 0; iMc < (ntrk); iMc++) {
1160                         AliAODMCParticle *p0=(AliAODMCParticle*)stack->UncheckedAt(iMc);
1161                         if (!p0) continue;
1162
1163                         lPdgcodeCurrentPart = p0->GetPdgCode();
1164
1165                         // Keep only K0s, Lambda and AntiLambda, Xi and Phi:
1166                         if ( (lPdgcodeCurrentPart != 310 ) && (lPdgcodeCurrentPart != 3122 ) && (lPdgcodeCurrentPart != -3122 ) && (lPdgcodeCurrentPart != 3312 ) && (lPdgcodeCurrentPart != -3312) && (lPdgcodeCurrentPart != -333) ) continue;
1167
1168                         lRapCurrentPart   = p0->Y();
1169                         lPtCurrentPart    = p0->Pt();
1170                         lPhiCurrentPart   = p0->Phi();
1171                         lEtaCurrentPart   = p0->Eta();
1172                         iCurrentMother    = p0->GetMother();
1173
1174                         AliAODMCParticle *Mother = (AliAODMCParticle*)stack->UncheckedAt(iCurrentMother);
1175                         if (iCurrentMother == -1){lPdgCurrentMother=0; } else {lPdgCurrentMother = Mother->GetPdgCode();}
1176
1177                         mcPosX = p0->Xv();
1178                         mcPosY = p0->Yv();
1179                         mcPosZ = p0->Zv();
1180                         mcPosR = TMath::Sqrt(mcPosX*mcPosX+mcPosY*mcPosY);
1181
1182                         id0  = p0->GetDaughter(0);
1183                         id1  = p0->GetDaughter(1);
1184
1185                         // Decay Radius and Production Radius
1186                         if ( id0 <= ntrk && id0 > 0 && id1 <= ntrk && id1 > 0) {
1187                                 AliAODMCParticle *pDaughter0 = (AliAODMCParticle*)stack->UncheckedAt(id0);
1188                                 AliAODMCParticle *pDaughter1 = (AliAODMCParticle*)stack->UncheckedAt(id1);
1189                                 lPdgCurrentDaughter0 = pDaughter0->GetPdgCode();
1190                                 lPdgCurrentDaughter1 = pDaughter1->GetPdgCode();
1191
1192                                 mcDecayPosX = pDaughter0->Xv();
1193                                 mcDecayPosY = pDaughter0->Yv();
1194                                 mcDecayPosR = TMath::Sqrt(mcDecayPosX*mcDecayPosX+mcDecayPosY*mcDecayPosY);
1195                         }
1196                         else  {mcDecayPosR = -1.0;}
1197
1198                         if (lPdgcodeCurrentPart==310)   {
1199                                 fHistMCtracksProdRadiusK0s->Fill(mcPosX,mcPosY);
1200                                 fHistMCtracksDecayRadiusK0s->Fill(mcDecayPosR);
1201                                 if (TMath::Abs(lRapCurrentPart) < fRapidityCut) fHistMCPtAllK0s->Fill(lPtCurrentPart);
1202                         }
1203                         else if (lPdgcodeCurrentPart==3122)  {
1204                                 fHistMCtracksProdRadiusLambda->Fill(mcPosX,mcPosY);
1205                                 fHistMCtracksDecayRadiusLambda->Fill(mcDecayPosR);
1206                                 if (TMath::Abs(lRapCurrentPart) < fRapidityCut) fHistMCPtAllLambda->Fill(lPtCurrentPart);
1207                         }
1208                         else if (lPdgcodeCurrentPart==-3122) {
1209                                 fHistMCtracksProdRadiusAntiLambda->Fill(mcPosX,mcPosY);
1210                                 fHistMCtracksDecayRadiusAntiLambda->Fill(mcDecayPosR);
1211                                 if (TMath::Abs(lRapCurrentPart) < fRapidityCut) fHistMCPtAllAntiLambda->Fill(lPtCurrentPart);
1212                         }
1213
1214                         if ( ( ( TMath::Abs(lPdgCurrentMother) == 3212)  ||
1215                                   ( TMath::Abs(lPdgCurrentMother) == 3224)  ||
1216                                   ( TMath::Abs(lPdgCurrentMother) == 3214)  ||
1217                                   ( TMath::Abs(lPdgCurrentMother) == 3114) )
1218                            && ( Mother->GetMother() == -1)
1219                                 ) lComeFromSigma = 1;
1220                         else lComeFromSigma = 0;
1221
1222                         Double_t dx = 0;
1223                         Double_t dy = 0;
1224                         Double_t dz = 0;
1225                         Double_t ProdDistance = 0;
1226
1227
1228                         dx = ( ( mcXv) - (mcPosX) );
1229                         dy = ( ( mcYv) - (mcPosY) );
1230                         dz = ( ( mcZv) - (mcPosZ) );
1231
1232                         ProdDistance = TMath::Sqrt(dx*dx + dy*dy + dz*dz);
1233                         if (ProdDistance > 0.001) continue; // secondary V0
1234
1235                         //********************************************
1236
1237                         lNtimesReconstructedK0s   = 0; lNtimesReconstructedLambda   = 0; lNtimesReconstructedAntiLambda   = 0;
1238
1239                         // Rapidity Cut
1240                         if (TMath::Abs(lRapCurrentPart) > fRapidityCut) continue;
1241
1242                         if (lPdgcodeCurrentPart==310) {
1243                                 fHistMCRapK0s->Fill(lRapCurrentPart);
1244                                 fHistMCProdRadiusK0s->Fill(mcPosR);
1245                                 fHistMCPtK0s->Fill(lPtCurrentPart);
1246                                 fHistNTimesRecK0s->Fill(lNtimesReconstructedK0s);
1247                                 fHistNTimesRecK0sVsPt->Fill(lPtCurrentPart,lNtimesReconstructedK0s);
1248                                 fHistPrimRawPtVsYK0s->Fill(lPtCurrentPart,lRapCurrentPart);
1249                                 selectedK0MC->Add(new AliLeadingBasicParticle(lEtaCurrentPart,lPhiCurrentPart,lPtCurrentPart));
1250                         }
1251                         else
1252                         if (lPdgcodeCurrentPart==3122) {
1253                                     fHistMCRapLambda->Fill(lRapCurrentPart);
1254                                         fHistMCProdRadiusLambda->Fill(mcPosR);
1255                                         fHistMCPtLambda->Fill(lPtCurrentPart);
1256                                         fHistNTimesRecLambda->Fill(lNtimesReconstructedLambda);
1257                                         fHistNTimesRecLambdaVsPt->Fill(lPtCurrentPart,lNtimesReconstructedLambda);
1258                                     fHistPrimRawPtVsYLambda->Fill(lPtCurrentPart,lRapCurrentPart);
1259                                         if (lComeFromSigma) fHistMCPtLambdaFromSigma->Fill(lPtCurrentPart);
1260                                     selectedLambdaMC->Add(new AliLeadingBasicParticle(lEtaCurrentPart,lPhiCurrentPart,lPtCurrentPart));
1261
1262                                 }
1263                         else
1264                         if (lPdgcodeCurrentPart==-3122) {
1265                                         fHistMCRapAntiLambda->Fill(lRapCurrentPart);
1266                                                 fHistMCProdRadiusAntiLambda->Fill(mcPosR);
1267                                                 fHistMCPtAntiLambda->Fill(lPtCurrentPart);
1268                                                 fHistNTimesRecAntiLambda->Fill(lNtimesReconstructedAntiLambda);
1269                                                 fHistNTimesRecAntiLambdaVsPt->Fill(lPtCurrentPart,lNtimesReconstructedAntiLambda);
1270                                                 fHistPrimRawPtVsYAntiLambda->Fill(lPtCurrentPart,lRapCurrentPart);
1271                                                 if (lComeFromSigma) fHistMCPtAntiLambdaFromSigma->Fill(lPtCurrentPart);
1272                                         }
1273
1274                 } // end loop AOD MC
1275
1276         } // End Loop over MC condition
1277
1278         //-----------------------------------------------------------------------------------------
1279
1280         // Vertex cut
1281         Double_t  lPrimaryVtxPosition[3];
1282         AliAODVertex *myPrimVertex = fAODEvent->GetPrimaryVertex();
1283         if (!myPrimVertex) return;
1284         myPrimVertex->GetXYZ(lPrimaryVtxPosition);
1285
1286         Double_t lPVx = lPrimaryVtxPosition[0];
1287         Double_t lPVy = lPrimaryVtxPosition[1];
1288         Double_t lPVz = lPrimaryVtxPosition[2];
1289         if ((TMath::Abs(lPVz)) >= fpvzcut) return ;
1290
1291         if (TMath::Abs(lPVx)<10e-5 && TMath::Abs(lPVy)<10e-5 && TMath::Abs(lPVz)<10e-5) return;
1292
1293
1294         fHistPrimaryVertexX->Fill(lPVx);
1295     fHistPrimaryVertexY->Fill(lPVy);
1296     fHistPrimaryVertexZ->Fill(lPVz);
1297
1298         // Centrality definition
1299         AliCentrality *centralityObj = 0;
1300         Int_t multiplicity = -1;
1301         Double_t MultipOrCent = -1;
1302
1303         // initialize the pool for event mixing
1304         if(fcollidingSys=="PP"){
1305                 multiplicity = fAODEvent->GetNTracks();
1306                 MultipOrCent = multiplicity; // convert from Int_t to Double_t
1307         }
1308         if(fcollidingSys=="PbPb"){
1309                 centralityObj = fAODEvent->GetHeader()->GetCentralityP();
1310                 MultipOrCent  = centralityObj->GetCentralityPercentileUnchecked("V0M");
1311         }
1312
1313         Double_t * CentBins = fCentBins;
1314         Double_t poolmin=CentBins[0];
1315         Double_t poolmax=CentBins[fNCentBins];
1316
1317         TObjArray *selectedTracksLeadingK0 = FindLeadingObjectsK0(fAODEvent);
1318         if(!selectedTracksLeadingK0) return;
1319         selectedTracksLeadingK0->SetOwner(kTRUE);
1320
1321         TObjArray *selectedTracksLeadingLambda = FindLeadingObjectsLambda(fAODEvent);
1322         if(!selectedTracksLeadingLambda) return;
1323         selectedTracksLeadingLambda->SetOwner(kTRUE);
1324
1325         // -------------------------------------V0 loop for reconstructed event------------------------
1326
1327         Double_t cutcTauL   = 3*7.89;
1328         Double_t cutcTauK0  = 3*2.68;
1329
1330         Double_t lPLambda = 0;
1331         Double_t lPAntiLambda = 0;
1332         Double_t lPK0s = 0;
1333
1334         // Variables:
1335         Double_t  lV0Position[3];
1336
1337         Double_t lDcaPosToPrimVertex = 0;
1338         Double_t lDcaNegToPrimVertex = 0;
1339         Double_t lDcaV0Daughters     = 0;
1340         Double_t lV0cosPointAngle    = 0;
1341         Double_t lChi2V0             = 0;
1342         Double_t lV0DecayLength      = 0;
1343         Double_t lV0Radius           = 0;
1344         Double_t lDcaV0ToPrimVertex  = 0;
1345         Double_t lcTauLambda         = 0;
1346         Double_t lcTauAntiLambda     = 0;
1347         Double_t lcTauK0s            = 0;
1348         Int_t    lOnFlyStatus        = 0;
1349
1350         Double_t lInvMassK0   = 0, lInvMassLambda = 0, lInvMassAntiLambda = 0;
1351         Double_t lPtK0s       = 0, lPtLambda      = 0, lPtAntiLambda      = 0;
1352         Double_t lPhiK0s      = 0, lPhiLambda     = 0, lPhiAntiLambda     = 0;
1353         Double_t lEtaK0s      = 0, lEtaLambda     = 0, lEtaAntiLambda     = 0;
1354         Double_t lRapK0s      = 0, lRapLambda     = 0, lRapAntiLambda     = 0;
1355         Double_t lPzK0s       = 0, lPzLambda      = 0, lPzAntiLambda      = 0;
1356         Double_t lAlphaV0     = 0, lPtArmV0       = 0;
1357
1358
1359
1360         Double_t lV0Eta = 999;
1361
1362         //Associated V0s:
1363
1364         UInt_t   lLabelTrackPos       = 0, lLabelTrackNeg         = 0;
1365         Int_t    lCheckPIdK0Short     = 0, lCheckMcK0Short        = 0;
1366         Int_t    lCheckPIdLambda      = 0, lCheckMcLambda         = 0;
1367         Int_t    lCheckPIdAntiLambda  = 0, lCheckMcAntiLambda     = 0;
1368         Int_t    lCheckSecondaryK0s   = 0, lCheckSecondaryLambda  = 0, lCheckSecondaryAntiLambda  = 0;
1369         Int_t    lCheckGamma          = 0;
1370         Double_t mcPosMotherX         = 0, mcPosMotherY           = 0, mcPosMotherZ  = 0;
1371         Double_t mcPosMotherR         = 0;
1372         Double_t mcMotherPt           = 0;
1373
1374         Int_t lIndexPosMother         = 0;
1375         Int_t lIndexNegMother         = 0;
1376         Int_t lIndexMotherOfMother    = 0;
1377         Int_t lPDGCodePosDaughter     = 0;
1378         Int_t lPDGCodeNegDaughter     = 0;
1379         Int_t lPdgcodeMother          = 0;
1380         Int_t lPdgcodeMotherOfMother  = 0;
1381
1382         // Reconstructed position
1383         Double_t rcPosXK0s        = 0,  rcPosYK0s        = 0, rcPosZK0s        = 0;
1384         Double_t rcPosRK0s        = 0;
1385         Double_t rcPosXLambda     = 0,  rcPosYLambda     = 0, rcPosZLambda     = 0;
1386         Double_t rcPosRLambda     = 0;
1387         Double_t rcPosXAntiLambda = 0,  rcPosYAntiLambda = 0, rcPosZAntiLambda = 0;
1388         Double_t rcPosRAntiLambda = 0;
1389
1390         // Pt resolution
1391         Double_t deltaPtK0s  = 0, deltaPtLambda  = 0, deltaPtAntiLambda  = 0;
1392
1393         //  V0 momentum
1394         //  Double_t V0mom[3] = {999,999,999};
1395         Double_t lPosMom = 0;
1396         Double_t lNegMom = 0;
1397
1398         // Daughters' momentum:
1399         Double_t  lMomPos[3] = {999,999,999};
1400         Double_t  lMomNeg[3] = {999,999,999};
1401         Double_t  lPtPos = 999, lPtNeg = 999;
1402         Double_t  lPPos = 999, lPNeg = 999;
1403
1404         // Inner Wall parameters:
1405         Double_t  lMomInnerWallPos =999, lMomInnerWallNeg = 999;
1406         Double_t        ldEdxPos =0.0,       ldEdxNeg=0.0;
1407
1408         // PID
1409         Float_t nSigmaPosPion   = 0;
1410         Float_t nSigmaNegPion   = 0;
1411
1412         Float_t nSigmaPosProton = 0;
1413         Float_t nSigmaNegProton = 0;
1414
1415
1416         Int_t lCheckPIDK0sPosDaughter        = 0, lCheckPIDK0sNegDaughter        = 0;
1417         Int_t lCheckPIDLambdaPosDaughter     = 0, lCheckPIDLambdaNegDaughter     = 0;
1418         Int_t lCheckPIDAntiLambdaPosDaughter = 0, lCheckPIDAntiLambdaNegDaughter = 0;
1419
1420         //---------------------------------------------------------------------------------------------
1421         TObjArray * selectedK0 = new TObjArray;
1422         selectedK0->SetOwner(kTRUE);
1423
1424         TObjArray * selectedLambda = new TObjArray;
1425         selectedLambda->SetOwner(kTRUE);
1426
1427         Int_t nV0s = fAODEvent->GetNumberOfV0s();
1428
1429         for (Int_t i = 0; i < nV0s; i++)
1430         { // start of V0 slection loop
1431                 AliAODv0* aodV0 = dynamic_cast<AliAODv0 *>(fAODEvent->GetV0(i));
1432                 if (!aodV0) {AliError(Form("ERROR: Could not retrieve aodaodV0 %d", i));continue;}
1433
1434                 lIndexPosMother     = 0; lIndexNegMother     = 0; lIndexMotherOfMother       = 0;
1435                 lCheckPIdK0Short    = 0; lCheckMcK0Short     = 0; lCheckSecondaryK0s         = 0;
1436                 lCheckPIdLambda     = 0; lCheckMcLambda      = 0; lCheckSecondaryLambda      = 0;
1437                 lCheckPIdAntiLambda = 0; lCheckMcAntiLambda  = 0; lCheckSecondaryAntiLambda  = 0;
1438                 lComeFromSigma      = -1;lCheckGamma = 0;
1439
1440         // get daughters
1441
1442             AliAODTrack *myTrackPos=(AliAODTrack *)(aodV0->GetDaughter(0));
1443         AliAODTrack *myTrackNeg=(AliAODTrack *)(aodV0->GetDaughter(1));
1444
1445                 if (!myTrackPos || !myTrackNeg) {Printf("ERROR: Could not retreive one of the daughter track");continue;}
1446
1447         if (!IsAcseptedV0(fAODEvent,aodV0,myTrackPos,myTrackNeg)) continue;
1448
1449                 // VO's main characteristics to check the reconstruction cuts
1450                 lOnFlyStatus       = aodV0->GetOnFlyStatus();
1451                 lChi2V0            = aodV0->Chi2V0();
1452                 lDcaV0Daughters    = aodV0->DcaV0Daughters();
1453                 lDcaV0ToPrimVertex = aodV0->DcaV0ToPrimVertex();
1454                 lV0cosPointAngle   = aodV0->CosPointingAngle(lPrimaryVtxPosition);
1455
1456                 aodV0->GetXYZ(lV0Position);
1457
1458                 lV0Radius      = TMath::Sqrt(lV0Position[0]*lV0Position[0]+lV0Position[1]*lV0Position[1]);
1459                 lV0DecayLength = TMath::Sqrt(TMath::Power(lV0Position[0] - lPrimaryVtxPosition[0],2) +
1460                                                                          TMath::Power(lV0Position[1] - lPrimaryVtxPosition[1],2) +
1461                                                                          TMath::Power(lV0Position[2] - lPrimaryVtxPosition[2],2 ));
1462
1463                 lLabelTrackPos = (UInt_t)TMath::Abs(myTrackPos->GetLabel());
1464                 lLabelTrackNeg = (UInt_t)TMath::Abs(myTrackNeg->GetLabel());
1465
1466                 // Daughters Pt and P:
1467                 lPtPos = TMath::Sqrt(lMomPos[0]*lMomPos[0] + lMomPos[1]*lMomPos[1]);
1468                 lPtNeg = TMath::Sqrt(lMomNeg[0]*lMomNeg[0] + lMomNeg[1]*lMomNeg[1]);
1469
1470                 lPPos = TMath::Sqrt(lMomPos[0]*lMomPos[0] + lMomPos[1]*lMomPos[1] + lMomPos[2]*lMomPos[2]);
1471                 lPNeg = TMath::Sqrt(lMomNeg[0]*lMomNeg[0] + lMomNeg[1]*lMomNeg[1] + lMomNeg[2]*lMomNeg[2]);
1472
1473                 // V0 momentum
1474                 lPosMom = lPPos;
1475                 lNegMom = lPNeg;
1476
1477                 // Inner Wall parameter:
1478                 const AliAODPid *pidPos=myTrackPos->GetDetPid();
1479                 const AliAODPid *pidNeg=myTrackNeg->GetDetPid();
1480
1481                 // innerWall momentum
1482                 lMomInnerWallPos = pidPos->GetTPCmomentum();
1483                 lMomInnerWallNeg = pidNeg->GetTPCmomentum();
1484
1485                 ldEdxPos = pidPos->GetTPCsignal();
1486                 ldEdxNeg = pidNeg->GetTPCsignal();
1487
1488                 // DCA between daughter and Primary Vertex:
1489                 if (myTrackPos) lDcaPosToPrimVertex = aodV0->DcaPosToPrimVertex();
1490                 if (myTrackNeg) lDcaNegToPrimVertex = aodV0->DcaNegToPrimVertex();
1491
1492                 // Quality tracks cuts:
1493                 if ( !(IsAcseptedDaughterTrack(myTrackPos)) || !(IsAcseptedDaughterTrack(myTrackNeg)) ) { continue;}
1494
1495                 // Armenteros variables:
1496                 lAlphaV0      =  aodV0->AlphaV0();
1497                 lPtArmV0      =  aodV0->PtArmV0();
1498
1499                 // Pseudorapidity:
1500                 lV0Eta = aodV0->PseudoRapV0();
1501                 //////////////////////////////////////////////////////////////////////////
1502                 // Invariant mass
1503                 lInvMassK0 = aodV0->MassK0Short();
1504                 lPtK0s = aodV0->Pt();
1505                 lPhiK0s= aodV0->Phi();
1506                 lEtaK0s= aodV0->Eta();
1507                 lPzK0s = aodV0->Pz();
1508
1509                 lInvMassLambda = aodV0->MassLambda();
1510                 lPtLambda = aodV0->Pt();
1511                 lPhiLambda= aodV0->Phi();
1512                 lEtaLambda= aodV0->Eta();
1513                 lPzLambda = aodV0->Pz();
1514
1515                 lInvMassAntiLambda = aodV0->MassAntiLambda();
1516                 lPtAntiLambda = aodV0->Pt();
1517                 lPhiAntiLambda= aodV0->Phi();
1518                 lEtaAntiLambda= aodV0->Eta();
1519                 lPzAntiLambda = aodV0->Pz();
1520
1521                 // Rapidity:
1522                 lRapK0s    = aodV0->RapK0Short();
1523                 lRapLambda = aodV0->RapLambda();
1524                 lRapAntiLambda = aodV0->Y(-3122);
1525
1526                 if (lPtK0s==0) {continue;}
1527                 if (lPtLambda==0) {continue;}
1528                 if (lPtAntiLambda==0) {continue;}
1529
1530
1531                 // PID  new method July 2011
1532                 if (fUsePID=="withPID") {
1533                         nSigmaPosPion = TMath::Abs(IsAccepteddEdx(lPPos,ldEdxPos,AliPID::kPion));
1534                         nSigmaNegPion = TMath::Abs(IsAccepteddEdx(lPNeg,ldEdxNeg,AliPID::kPion));
1535                         nSigmaPosProton = TMath::Abs(IsAccepteddEdx(lPPos,ldEdxPos,AliPID::kProton));
1536                         nSigmaNegProton = TMath::Abs(IsAccepteddEdx(lPNeg,ldEdxNeg,AliPID::kProton));
1537                 }
1538                 else {nSigmaPosPion = 0; nSigmaNegPion =0; nSigmaPosProton = 0; nSigmaNegProton= 0;}
1539
1540                 // Monte-Carlo particle associated to reconstructed particles:
1541                 if (fAnalysisMC) {
1542
1543                         AliAODMCParticle *pp=(AliAODMCParticle*)stack->UncheckedAt(lLabelTrackPos);
1544                         if(!pp) { continue;}
1545                         AliAODMCParticle *np=(AliAODMCParticle*)stack->UncheckedAt(lLabelTrackNeg);
1546                         if (!np)        { continue;}
1547
1548                         lPDGCodePosDaughter = pp->GetPdgCode();
1549                         lPDGCodeNegDaughter = np->GetPdgCode();
1550                         lIndexPosMother = pp->GetMother();
1551                         lIndexNegMother = np->GetMother();
1552
1553                         if (lIndexPosMother == -1) {
1554
1555                                 lPdgcodeMother = 0;
1556                                 lIndexMotherOfMother = 0;
1557                                 mcPosX = 0;
1558                                 mcPosY = 0;
1559                                 mcPosZ = 0;
1560                                 mcPosR = 0;
1561                                 mcPosMotherX = 0;
1562                                 mcPosMotherY = 0;
1563                                 mcPosMotherZ = 0;
1564                                 mcPosMotherR = 0;
1565                                 mcMotherPt = 1;
1566                         }
1567
1568                         else {
1569                                 AliAODMCParticle *lMCAODMother=(AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother);
1570                                 if (!lMCAODMother)      { continue;}
1571                                 lPdgcodeMother         = lMCAODMother->GetPdgCode();
1572                                 lIndexMotherOfMother   = lMCAODMother->GetMother();
1573                                 if (lIndexMotherOfMother ==-1) lPdgcodeMotherOfMother = 0;
1574                                 else {
1575                                         AliAODMCParticle *lMCAODMotherOfMother=(AliAODMCParticle*)stack->UncheckedAt(lIndexMotherOfMother);
1576                                         if (!lMCAODMotherOfMother)      {continue;}
1577                                         lPdgcodeMotherOfMother = lMCAODMotherOfMother->GetPdgCode();
1578                                 }
1579
1580                                 mcPosX = pp->Xv();
1581                                 mcPosY = pp->Yv();
1582                                 mcPosZ = pp->Zv();
1583                                 mcPosR = TMath::Sqrt(mcPosX*mcPosX+mcPosY*mcPosY);
1584                                 mcPosMotherX = lMCAODMother->Xv();
1585                                 mcPosMotherY = lMCAODMother->Yv();
1586                                 mcPosMotherZ = lMCAODMother->Zv();
1587                                 mcPosMotherR = TMath::Sqrt(mcPosMotherX*mcPosMotherX+mcPosMotherY*mcPosMotherY);
1588
1589                                 mcMotherPt   = lMCAODMother->Pt();
1590                         }
1591                 }
1592
1593         }
1594
1595         if (fAnalysisMC) {
1596                 if( (lIndexPosMother==-1) || (lIndexNegMother==-1) ) {
1597                         fHistMCDaughterTrack->Fill(1);
1598                 }
1599
1600                 else if( ( (lPDGCodePosDaughter==+211) && (lPDGCodeNegDaughter==-211) )
1601                                 ) {
1602                         lCheckPIdK0Short    = 1;
1603                         fHistMCDaughterTrack->Fill(3);
1604                         if ( (lIndexPosMother==lIndexNegMother) &&
1605                                 (lPdgcodeMother==310) ) {
1606                                 if (((AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother))->IsPrimary()) lCheckMcK0Short  = 1;
1607                                 else lCheckSecondaryK0s = 1;
1608                         }
1609                 }
1610                 else if( ( (lPDGCodePosDaughter==+2212) && (lPDGCodeNegDaughter==-211)  )
1611                                 ) {
1612                         lCheckPIdLambda     = 1;
1613                         fHistMCDaughterTrack->Fill(5);
1614                         if ( (lIndexPosMother==lIndexNegMother) &&
1615                                 (lPdgcodeMother==3122)  ){
1616                                 if ( ( TMath::Abs(lPdgcodeMotherOfMother) == 3212) ||
1617                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3224) ||
1618                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3214) ||
1619                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3114)
1620                                         ) lComeFromSigma = 1;
1621                                 else lComeFromSigma = 0;
1622                                 if ( ((AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother))->IsPrimary() ||
1623                                         (!(((AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother))->IsPrimary() ) && (lComeFromSigma) )
1624                                         ) lCheckMcLambda  = 1;
1625                                 else lCheckSecondaryLambda    = 1;
1626                         }
1627                 }
1628                 else if( ( (lPDGCodePosDaughter==211)   && (lPDGCodeNegDaughter==-2212) )
1629                                 ) {
1630                         lCheckPIdAntiLambda = 1;
1631                         fHistMCDaughterTrack->Fill(7);
1632                         if ( (lIndexPosMother==lIndexNegMother) &&
1633                                 (lPdgcodeMother==-3122) ) {
1634                                 if ( ( TMath::Abs(lPdgcodeMotherOfMother) == 3212) ||
1635                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3224) ||
1636                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3214) ||
1637                                         ( TMath::Abs(lPdgcodeMotherOfMother)  == 3114)
1638                                         ) lComeFromSigma = 1;
1639                                 else lComeFromSigma = 0;
1640                                 if ( ((AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother))->IsPrimary() ||
1641                                         ( (!((AliAODMCParticle*)stack->UncheckedAt(lIndexPosMother))->IsPrimary()) && (lComeFromSigma) )
1642                                         ) lCheckMcAntiLambda  = 1;
1643                                 else lCheckSecondaryAntiLambda = 1;
1644                         }
1645                 }
1646
1647                 // Gamma conversion
1648                 else if ((lPDGCodePosDaughter==-11) &&
1649                                  (lPDGCodeNegDaughter==11) &&
1650                                  (lPdgcodeMother==22 ) )
1651                         lCheckGamma = 1;
1652         } // end "look for associated particles
1653
1654         // PID condition:
1655         lCheckPIDK0sPosDaughter        = 0, lCheckPIDK0sNegDaughter        = 0;
1656         lCheckPIDLambdaPosDaughter     = 0, lCheckPIDLambdaNegDaughter     = 0;
1657         lCheckPIDAntiLambdaPosDaughter = 0, lCheckPIDAntiLambdaNegDaughter = 0;
1658
1659         if (lMomInnerWallPos < lLimitPPID) {
1660                 if (nSigmaPosPion < cutNSigmaLowP)   {
1661                         lCheckPIDK0sPosDaughter        = 1;
1662                         lCheckPIDAntiLambdaPosDaughter = 1;
1663                 }
1664                 if (nSigmaPosProton < cutNSigmaLowP) lCheckPIDLambdaPosDaughter    = 1;
1665         }
1666
1667         else if (lMomInnerWallPos > lLimitPPID) {
1668                 if (nSigmaPosPion < cutNSigmaHighP)   {
1669                         lCheckPIDK0sPosDaughter        = 1;
1670                         lCheckPIDAntiLambdaPosDaughter = 1;
1671                 }
1672                 if (nSigmaPosProton < cutNSigmaHighP) lCheckPIDLambdaPosDaughter    = 1;
1673         }
1674
1675         if (lMomInnerWallNeg < lLimitPPID) {
1676                 if (nSigmaNegPion < cutNSigmaLowP)    {
1677                         lCheckPIDK0sNegDaughter       = 1;
1678                         lCheckPIDLambdaNegDaughter    = 1;
1679                 }
1680                 if (nSigmaNegProton < cutNSigmaLowP)  lCheckPIDAntiLambdaNegDaughter = 1;
1681
1682         }
1683         else if (lMomInnerWallNeg > lLimitPPID) {
1684                 if (nSigmaNegPion < cutNSigmaHighP)   {
1685                         lCheckPIDK0sNegDaughter       = 1;
1686                         lCheckPIDLambdaNegDaughter    = 1;
1687                 }
1688                 if (nSigmaNegProton < cutNSigmaHighP) lCheckPIDAntiLambdaNegDaughter = 1;
1689         }
1690
1691         //************************************filling histograms********************************//
1692
1693         if((fUsePID=="withPID") && (lCheckPIDAntiLambdaNegDaughter==0) && lCheckPIDLambdaPosDaughter==1) LambdaPID = 1;
1694         else LambdaPID =0;
1695         if((fUsePID=="withPID") && (lCheckPIDLambdaPosDaughter==0) && lCheckPIDAntiLambdaNegDaughter==1) AntiLambdaPID = 1;
1696         else AntiLambdaPID =0;
1697
1698         lPLambda = TMath::Sqrt(lPzLambda*lPzLambda + lPtLambda*lPtLambda);
1699         lPAntiLambda = TMath::Sqrt(lPzAntiLambda*lPzAntiLambda + lPtAntiLambda*lPtAntiLambda);
1700         lPK0s = TMath::Sqrt(lPzK0s*lPzK0s + lPtK0s*lPtK0s);
1701
1702
1703         lcTauLambda     = (lV0DecayLength*lInvMassLambda)/lPLambda;
1704         lcTauAntiLambda = (lV0DecayLength*lInvMassAntiLambda)/lPAntiLambda;
1705         lcTauK0s        = (lV0DecayLength*lInvMassK0)/lPK0s;
1706
1707         if (lPLambda <1 && lOnFlyStatus==0 ){
1708         fHistcTauL->Fill(lcTauLambda);
1709         }
1710
1711         //--------------------------------------------K0s---------------------------------//
1712
1713         if (lcTauK0s< cutcTauK0){
1714                 if (TMath::Abs(lRapK0s) < fRapidityCut ){
1715                         if(lPtArmV0*fSpecialArmenterosCutK0s>(TMath::Abs(lAlphaV0))){
1716
1717                         //////2D histos: cut vs on fly status/////////////////////
1718
1719                         fHistDcaPosToPrimVertexK0->Fill(lDcaPosToPrimVertex,lOnFlyStatus);
1720                         fHistDcaNegToPrimVertexK0->Fill(lDcaNegToPrimVertex,lOnFlyStatus);
1721                         fHistRadiusV0K0->Fill(lV0Radius,lOnFlyStatus);
1722                         fHistDecayLengthV0K0->Fill(lV0DecayLength,lOnFlyStatus);
1723                         fHistDcaV0DaughtersK0->Fill(lDcaV0Daughters,lOnFlyStatus);
1724                         fHistChi2K0->Fill(lChi2V0,lOnFlyStatus);
1725                         fHistCosPointAngleK0->Fill(lV0cosPointAngle,lOnFlyStatus);
1726
1727                         //////2D histos: cut vs mass/////////////////////
1728
1729                         if (lOnFlyStatus==0){
1730                                 fHistMassK0->Fill(lInvMassK0);
1731                                 fHistMassVsRadiusK0->Fill(rcPosRK0s,lInvMassK0);
1732                                 fHistPtVsMassK0->Fill(lInvMassK0,lPtK0s);
1733                                 fHistDcaPosToPrimVertexK0vsMassK0->Fill(lDcaPosToPrimVertex,lInvMassK0);
1734                                 fHistDcaNegToPrimVertexK0vsMassK0->Fill(lDcaNegToPrimVertex,lInvMassK0);
1735                                 fHistRadiusV0K0vsMassK0->Fill(lV0Radius,lInvMassK0);
1736                                 fHistDecayLengthV0K0vsMassK0->Fill(lV0DecayLength,lInvMassK0);
1737                                 fHistDcaV0DaughtersK0vsMassK0->Fill(lDcaV0Daughters,lInvMassK0);
1738                                 fHistCosPointAngleK0vsMassK0->Fill(lV0cosPointAngle,lInvMassK0);
1739                                 fHistArmenterosPodolanski->Fill(lAlphaV0,lPtArmV0);
1740                                 if(IsK0InvMass(lInvMassK0)){selectedK0->Add(new AliLeadingBasicParticle(lEtaK0s,lPhiK0s,lPtK0s));}
1741                         }
1742                   }//Special Armesto Cut for K0
1743                 } // if rap. condition
1744         } // end cTau condition
1745
1746         //-----------------------------------------Lambda---------------------------------//
1747         if (lcTauLambda < cutcTauL){
1748                 if ((LambdaPID==1 && lMomInnerWallPos  <=1 ) || (lMomInnerWallPos >1 ) ||  !(fUsePID=="withPID")){
1749                         if (TMath::Abs(lRapLambda) <fRapidityCut) {
1750
1751                                 //////2D histos: cut vs on fly status/////////////////////
1752
1753                                 fHistDcaPosToPrimVertexL->Fill(lDcaPosToPrimVertex,lOnFlyStatus);
1754                                 fHistDcaNegToPrimVertexL->Fill(lDcaNegToPrimVertex,lOnFlyStatus);
1755                                 fHistRadiusV0L->Fill(lV0Radius,lOnFlyStatus);
1756                                 fHistDecayLengthV0L->Fill(lV0DecayLength,lOnFlyStatus);
1757                                 fHistDcaV0DaughtersL->Fill(lDcaV0Daughters,lOnFlyStatus);
1758                                 fHistChi2L->Fill(lChi2V0,lOnFlyStatus);
1759                                 fHistCosPointAngleL->Fill(lV0cosPointAngle,lOnFlyStatus);
1760
1761                                 //////2D histos: cut vs mass/////////////////////
1762
1763                                 if (lOnFlyStatus==0){
1764                                         fHistMassLambda->Fill(lInvMassLambda);
1765                                         fHistMassVsRadiusLambda->Fill(rcPosRLambda,lInvMassLambda);
1766                                         fHistPtVsMassLambda->Fill(lInvMassLambda,lPtLambda);
1767
1768                                         fHistDcaPosToPrimVertexLvsMassL->Fill(lDcaPosToPrimVertex,lInvMassLambda);
1769                                         fHistDcaNegToPrimVertexLvsMassL->Fill(lDcaNegToPrimVertex,lInvMassLambda);
1770                                         fHistRadiusV0LvsMassL->Fill(lV0Radius,lInvMassLambda);
1771                                         fHistDecayLengthV0LvsMassL->Fill(lV0DecayLength,lInvMassLambda);
1772                                         fHistDcaV0DaughtersLvsMassL->Fill(lDcaV0Daughters,lInvMassLambda);
1773                                         fHistCosPointAngleLvsMassL->Fill(lV0cosPointAngle,lInvMassLambda);
1774                                         if(IsLambdaInvMass(lInvMassLambda)){selectedLambda->Add(new AliLeadingBasicParticle(lEtaLambda,lPhiLambda,lPtLambda));}
1775                                 }
1776                         } //end of Rap condition
1777                 }
1778         }  //end cTau condition
1779
1780         //--------------------------------------AntiLambda---------------------------------//
1781
1782         if (lcTauAntiLambda < cutcTauL){
1783
1784                 if ((AntiLambdaPID==1 && lMomInnerWallNeg <=1) || (lMomInnerWallNeg >1) ||  !(fUsePID=="withPID")){
1785                         if (TMath::Abs(lRapAntiLambda) < fRapidityCut) {
1786
1787                                 //////2D histos: cut vs on fly status/////////////////////
1788
1789                                 fHistDcaPosToPrimVertexAntiL->Fill(lDcaPosToPrimVertex,lOnFlyStatus);
1790                                 fHistDcaNegToPrimVertexAntiL->Fill(lDcaNegToPrimVertex,lOnFlyStatus);
1791                                 fHistRadiusV0AntiL->Fill(lV0Radius,lOnFlyStatus);
1792                                 fHistDecayLengthV0AntiL->Fill(lV0DecayLength,lOnFlyStatus);
1793                                 fHistDcaV0DaughtersAntiL->Fill(lDcaV0Daughters,lOnFlyStatus);
1794                                 fHistChi2AntiL->Fill(lChi2V0,lOnFlyStatus);
1795                                 fHistCosPointAngleAntiL->Fill(lV0cosPointAngle,lOnFlyStatus);
1796
1797                                 //////2D histos: cut vs mass/////////////////////
1798
1799                                 if (lOnFlyStatus==0){
1800
1801                                         fHistMassAntiLambda->Fill(lInvMassAntiLambda);
1802                                         fHistMassVsRadiusAntiLambda->Fill(rcPosRAntiLambda,lInvMassAntiLambda);
1803                                         fHistPtVsMassAntiLambda->Fill(lInvMassAntiLambda,lPtAntiLambda);
1804                                         fHistDcaPosToPrimVertexAntiLvsMass->Fill(lDcaPosToPrimVertex,lInvMassAntiLambda);
1805                                         fHistDcaNegToPrimVertexAntiLvsMass->Fill(lDcaNegToPrimVertex,lInvMassAntiLambda);
1806                                         fHistRadiusV0AntiLvsMass->Fill(lV0Radius,lInvMassAntiLambda);
1807                                         fHistDecayLengthV0AntiLvsMass->Fill(lV0DecayLength,lInvMassAntiLambda);
1808                                         fHistDcaV0DaughtersAntiLvsMass->Fill(lDcaV0Daughters,lInvMassAntiLambda);
1809                                         fHistCosPointAngleAntiLvsMass->Fill(lV0cosPointAngle,lInvMassAntiLambda);
1810                                 }
1811                         } //end of Rap condition
1812                 } // end of PID condition
1813         } //end cTau condition
1814
1815         //--------------------------------------K0s Associated---------------------------------//
1816
1817         if (lcTauK0s< cutcTauK0) {
1818                 if (TMath::Abs(lRapK0s) < fRapidityCut) {
1819                         fHistNsigmaPosPionK0->Fill(nSigmaPosPion);
1820                         fHistNsigmaNegPionK0->Fill(nSigmaNegPion);
1821                         if(lOnFlyStatus==0){
1822                                         if(lCheckPIdK0Short) fHistPidMcMassK0->Fill(lInvMassK0);
1823                                         if(lCheckMcK0Short) {
1824                                                 fHistAsMcMassK0->Fill(lInvMassK0);
1825                                                 fHistAsMcPtK0->Fill(lPtK0s);
1826                                                 fHistAsMcPtVsMassK0->Fill(lInvMassK0,lPtK0s);
1827                                                 fHistAsMcMassVsRadiusK0->Fill(rcPosRK0s,lInvMassK0);
1828                                                 fHistAsMcResxK0->Fill(rcPosXK0s-mcPosX);
1829                                                 fHistAsMcResyK0->Fill(rcPosYK0s-mcPosY);
1830                                                 fHistAsMcReszK0->Fill(rcPosZK0s-mcPosZ);
1831                                                 fHistAsMcResrVsRadiusK0->Fill(rcPosRK0s,rcPosRK0s-mcPosR);
1832                                                 fHistAsMcReszVsRadiusK0->Fill(rcPosZK0s,rcPosZK0s-mcPosZ);
1833                                                 fHistAsMcProdRadiusK0->Fill(mcPosMotherR);
1834                                                 fHistAsMcProdRadiusXvsYK0s->Fill(mcPosMotherX,mcPosMotherY);
1835                                                 fHistAsMcResPtK0->Fill(deltaPtK0s);
1836                                                 fHistAsMcResPtVsRapK0->Fill(deltaPtK0s,lRapK0s);
1837                                                 fHistAsMcResPtVsPtK0->Fill(deltaPtK0s,lPtK0s);
1838                                         }
1839                                         if (lCheckSecondaryK0s) {
1840                                                 fHistAsMcSecondaryPtVsRapK0s->Fill(lPtK0s,lRapK0s);
1841                                                 fHistAsMcSecondaryProdRadiusK0s->Fill(mcPosMotherR);
1842                                                 fHistAsMcSecondaryProdRadiusXvsYK0s->Fill(mcPosMotherX,mcPosMotherY);
1843                                         }
1844                         }
1845                 } // end rapidity condition
1846         } //end cTau condition
1847
1848
1849         //-----------------------------------Lambda Associated---------------------------------//
1850         if (lcTauLambda < cutcTauL){
1851                 if (TMath::Abs(lRapLambda) < fRapidityCut) {
1852                         fHistNsigmaPosProtonLambda->Fill(nSigmaPosProton);
1853                         fHistNsigmaNegPionLambda->Fill(nSigmaNegPion);
1854                         if(lOnFlyStatus==0){
1855                                         if(lCheckPIdLambda) fHistPidMcMassLambda->Fill(lInvMassLambda);
1856                                         if(lCheckMcLambda) {
1857                                                 fHistAsMcMassLambda->Fill(lInvMassLambda);
1858                                                 fHistAsMcPtLambda->Fill(lPtLambda);
1859                                                 fHistCosPointAngleLVsMassVsPtsigL->Fill(lPtLambda,lV0cosPointAngle,lInvMassLambda);
1860                                                 fHistAsMcPtVsMassLambda->Fill(lInvMassLambda,lPtLambda);
1861                                                 fHistAsMcMassVsRadiusLambda->Fill(rcPosRLambda,lInvMassLambda);
1862                                                 fHistAsMcResxLambda->Fill(rcPosXLambda-mcPosX);
1863                                                 fHistAsMcResyLambda->Fill(rcPosYLambda-mcPosY);
1864                                                 fHistAsMcReszLambda->Fill(rcPosZLambda-mcPosZ);
1865                                                 fHistAsMcResrVsRadiusLambda->Fill(rcPosRLambda,rcPosRLambda-mcPosR);
1866                                                 fHistAsMcReszVsRadiusLambda->Fill(rcPosZLambda,rcPosZLambda-mcPosZ);
1867                                                 fHistAsMcProdRadiusLambda->Fill(mcPosMotherR);
1868                                                 fHistAsMcProdRadiusXvsYLambda->Fill(mcPosMotherX,mcPosMotherY);
1869                                                 fHistAsMcResPtLambda->Fill(deltaPtLambda);
1870                                                 fHistAsMcResPtVsRapLambda->Fill(deltaPtLambda,lRapLambda);
1871                                                 fHistAsMcResPtVsPtLambda->Fill(deltaPtLambda,lPtLambda);
1872                                                 if (lComeFromSigma) fHistAsMcPtLambdaFromSigma->Fill(lPtLambda);
1873                                         }
1874
1875                                         if (lCheckSecondaryLambda) {
1876                                                 fHistAsMcSecondaryPtVsRapLambda->Fill(lPtLambda,lRapLambda);
1877                                                 fHistAsMcSecondaryProdRadiusLambda->Fill(mcPosMotherR);
1878                                                 fHistAsMcSecondaryProdRadiusXvsYLambda->Fill(mcPosMotherX,mcPosMotherY);
1879                                                 if (lComeFromSigma) fHistAsMcSecondaryPtLambdaFromSigma->Fill(lPtLambda);
1880                                         }
1881                                         if(!lCheckMcLambda)fHistCosPointAngleLVsMassVsPtbackL->Fill(lPtLambda,lV0cosPointAngle,lInvMassLambda);
1882                         }
1883                 } // end rapidity condition
1884         }//end cTau condition
1885
1886 //------------------------------AntiLambda Associated---------------------------------//
1887         if (lcTauAntiLambda < cutcTauL){
1888                 if (TMath::Abs(lRapAntiLambda) < fRapidityCut) {
1889                         fHistNsigmaPosProtonAntiLambda->Fill(nSigmaPosProton);
1890                         fHistNsigmaNegPionAntiLambda->Fill(nSigmaNegPion);
1891                         if(lOnFlyStatus==0){
1892                                         if(lCheckPIdAntiLambda) fHistPidMcMassAntiLambda->Fill(lInvMassAntiLambda);
1893                                         if(lCheckMcAntiLambda) {
1894                                                 fHistAsMcMassAntiLambda->Fill(lInvMassAntiLambda);
1895                                                 fHistAsMcPtAntiLambda->Fill(lPtAntiLambda);
1896                                                 fHistAsMcPtVsMassAntiLambda->Fill(lInvMassAntiLambda,lPtAntiLambda);
1897                                                 fHistAsMcMassVsRadiusAntiLambda->Fill(rcPosRAntiLambda,lInvMassAntiLambda);
1898                                                 fHistAsMcResxAntiLambda->Fill(rcPosXAntiLambda-mcPosX);
1899                                                 fHistAsMcResyAntiLambda->Fill(rcPosYAntiLambda-mcPosY);
1900                                                 fHistAsMcReszAntiLambda->Fill(rcPosZAntiLambda-mcPosZ);
1901                                                 fHistAsMcResrVsRadiusAntiLambda->Fill(rcPosRAntiLambda,rcPosRAntiLambda-mcPosR);
1902                                                 fHistAsMcReszVsRadiusAntiLambda->Fill(rcPosZAntiLambda,rcPosZAntiLambda-mcPosZ);
1903                                                 fHistAsMcProdRadiusAntiLambda->Fill(mcPosMotherR);
1904                                                 fHistAsMcProdRadiusXvsYAntiLambda->Fill(mcPosMotherX,mcPosMotherY);
1905                                                 fHistAsMcResPtAntiLambda->Fill(deltaPtAntiLambda);
1906                                                 fHistAsMcResPtVsRapAntiLambda->Fill(deltaPtAntiLambda,lRapAntiLambda);
1907                                                 fHistAsMcResPtVsPtAntiLambda->Fill(deltaPtAntiLambda,lPtAntiLambda);
1908                                                 if (lComeFromSigma) fHistAsMcPtAntiLambdaFromSigma->Fill(lPtAntiLambda);
1909
1910                                         }
1911
1912                                         if (lCheckSecondaryAntiLambda) {
1913                                                 fHistAsMcSecondaryPtVsRapAntiLambda->Fill(lPtAntiLambda,lRapAntiLambda);
1914                                                 fHistAsMcSecondaryProdRadiusAntiLambda->Fill(mcPosMotherR);
1915                                                 fHistAsMcSecondaryProdRadiusXvsYAntiLambda->Fill(mcPosMotherX,mcPosMotherY);
1916                                                 if (lComeFromSigma) fHistAsMcSecondaryPtAntiLambdaFromSigma->Fill(lPtAntiLambda);
1917                                         }
1918                         }
1919                 } // end rapidity condition
1920         }//end cTau condition
1921
1922         // Correlation part
1923         if(fAnalysisMC){
1924         FillCorrelations(selectedTracksLeadingK0MC,selectedK0MC,fHistSibK0MC);
1925         FillCorrelations(selectedTracksLeadingLambdaMC,selectedLambdaMC,fHistSibLambdaMC);
1926         }
1927
1928         FillCorrelations(selectedTracksLeadingK0,selectedK0,fHistSibK0);
1929         FillCorrelations(selectedTracksLeadingLambda,selectedLambda,fHistSibLambda);
1930
1931         // Mixing part
1932         if(TMath::Abs(lPVz)>=10 || MultipOrCent>poolmax || MultipOrCent < poolmin) {
1933                 if(fcollidingSys=="PP")AliInfo(Form("pp Event with Zvertex = %.2f cm and multiplicity = %.0f out of pool bounds, SKIPPING",lPVz,MultipOrCent));
1934                 if(fcollidingSys=="PbPb") AliInfo(Form("PbPb Event with Zvertex = %.2f cm and centrality = %.1f  out of pool bounds, SKIPPING",lPVz,MultipOrCent));
1935                 return;
1936         }
1937
1938         fPoolK0 = fPoolMgr->GetEventPool(MultipOrCent, lPVz);
1939         if (!fPoolK0){AliInfo(Form("No pool found for multiplicity = %f, zVtx = %f cm", MultipOrCent, lPVz));return;}
1940
1941     if (fPoolK0->IsReady() || fPoolK0->NTracksInPool() > fPoolMinNTracks  || fPoolK0->GetCurrentNEvents() >= fMinEventsToMix)
1942         {
1943                 for (Int_t jMix=0; jMix<fPoolK0->GetCurrentNEvents(); jMix++)
1944                         FillCorrelations(selectedTracksLeadingK0, fPoolK0->GetEvent(jMix),fHistMixK0);
1945                 fPoolK0->UpdatePool(CloneAndReduceTrackList(selectedK0));
1946         }
1947
1948         fPoolLambda = fPoolMgr->GetEventPool(MultipOrCent, lPVz);
1949         if (!fPoolLambda){AliInfo(Form("No pool found for multiplicity = %f, zVtx = %f cm", MultipOrCent, lPVz));return;}
1950
1951     if (fPoolLambda->IsReady() || fPoolLambda->NTracksInPool() > fPoolMinNTracks  || fPoolLambda->GetCurrentNEvents() >= fMinEventsToMix)
1952         {
1953                 for (Int_t jMix=0; jMix<fPoolLambda->GetCurrentNEvents(); jMix++)
1954                         FillCorrelations(selectedTracksLeadingLambda, fPoolLambda->GetEvent(jMix),fHistMixLambda);
1955                 fPoolLambda->UpdatePool(CloneAndReduceTrackList(selectedLambda));
1956         }
1957
1958         PostData(1, fOutputList);
1959
1960 }
1961 //---------------------------------------------------------------------------------------
1962 TObjArray* AliLeadingV0Correlation::CloneAndReduceTrackList(TObjArray* tracks)
1963 {
1964         // clones a track list for mixing
1965         TObjArray* tracksClone = new TObjArray;
1966         tracksClone->SetOwner(kTRUE);
1967
1968         for (Int_t i=0; i<tracks->GetEntriesFast(); i++)
1969         {
1970                 AliVParticle* particle = (AliVParticle*) tracks->At(i);
1971                 tracksClone->Add(new AliLeadingBasicParticle(particle->Eta(), particle->Phi(), particle->Pt()));
1972         }
1973
1974         return tracksClone;
1975 }
1976 //---------------------------------------------------------------------------------------
1977 Int_t  AliLeadingV0Correlation::NParticles(TObject* obj)
1978 {
1979         Int_t nTracks;
1980
1981         if (obj->InheritsFrom("TClonesArray")){ // MC particles
1982                 TClonesArray *arrayMC = static_cast<TClonesArray*>(obj);
1983         nTracks = arrayMC->GetEntriesFast();
1984         }else if (obj->InheritsFrom("TObjArray")){ // list of AliVParticle
1985                 TObjArray *array = static_cast<TObjArray*>(obj);
1986         nTracks = array->GetEntriesFast();
1987         }else if (obj->InheritsFrom("AliAODEvent")){  // RECO AOD tracks
1988                 AliAODEvent *aodEvent = static_cast<AliAODEvent*>(obj);
1989         nTracks = aodEvent->GetNTracks();
1990         }else if (obj->InheritsFrom("AliMCEvent")){  // RECO ESD tracks
1991                 AliMCEvent *mcEvent = static_cast<AliMCEvent*>(obj);
1992         nTracks = mcEvent->GetNumberOfTracks();
1993         }else {
1994                 if (fDebug > 1) AliFatal(" Analysis type not defined !!! ");
1995                 return 0;
1996         }
1997
1998         return nTracks;
1999 }
2000 //---------------------------------------------------------------------------------------
2001 Bool_t AliLeadingV0Correlation::IsAcseptedPrimaryTrack(const AliAODTrack *itrack)
2002 {
2003         if (TMath::Abs(itrack->Eta())>fTrackEtaCut) return kFALSE;
2004     if (!itrack->TestFilterBit(fFilterBit)) return kFALSE;
2005         return kTRUE;
2006 }
2007 //---------------------------------------------------------------------------------------
2008 Bool_t AliLeadingV0Correlation::IsAcseptedDaughterTrack(const AliAODTrack *itrack)
2009 {
2010         if(TMath::Abs(itrack->Eta())>fTrackEtaCut)return kFALSE;
2011
2012         if (!itrack->IsOn(AliAODTrack::kTPCrefit)) return kFALSE;
2013
2014         Float_t nCrossedRowsTPC = itrack->GetTPCClusterInfo(2,1);
2015         if (nCrossedRowsTPC < 70) return kFALSE;
2016
2017         Int_t findable=itrack->GetTPCNclsF();
2018         if (findable <= 0) return kFALSE;
2019
2020         if (nCrossedRowsTPC/findable < 0.8) return kFALSE;
2021
2022         return kTRUE;
2023 }
2024 //---------------------------------------------------------------------------------------
2025 Double_t AliLeadingV0Correlation::RangePhi(Double_t DPhi)
2026 {
2027         if (DPhi < -TMath::Pi()/2)  DPhi += 2*TMath::Pi();
2028         if (DPhi > 3*TMath::Pi()/2) DPhi -= 2*TMath::Pi();
2029         return DPhi;
2030 }
2031 //---------------------------------------------------------------------------------------
2032 void AliLeadingV0Correlation::FillCorrelations(TObjArray* particles, TObjArray* mixed,TH2F*histo)
2033 {
2034  TObjArray* input = (mixed) ? mixed : particles;
2035  TArrayF eta(input->GetEntriesFast());
2036    for (Int_t i=0; i<input->GetEntriesFast(); i++) eta[i] = ((AliVParticle*) input->At(i))->Eta();
2037                 if (particles)
2038                  {
2039                    Int_t jMax = particles->GetEntriesFast();
2040                    if (mixed) jMax = mixed->GetEntriesFast();
2041                         for (Int_t i=0; i<particles->GetEntriesFast(); i++)
2042                         {
2043                                 AliVParticle* triggerParticle = (AliVParticle*) particles->At(0); //For leading Track
2044                                 // some optimization
2045                                 Float_t triggerEta = triggerParticle->Eta();
2046
2047                                 for (Int_t j=0; j<jMax; j++)
2048                                 {
2049                                   if (!mixed && i == j)continue;
2050                                         AliVParticle* particle = 0;
2051                                         if (!mixed)particle = (AliVParticle*) particles->At(0); //For leading Track
2052                                         else particle = (AliVParticle*) mixed->At(j);
2053
2054                                         // 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)
2055                                         if (mixed && triggerParticle == particle)continue;
2056
2057                                         if (particle->Pt() > triggerParticle->Pt())continue;
2058
2059                                         if (((particle->Pt())<fassocPtLow)||((particle->Pt())>fassocPtHigh)) continue;
2060                                         if (((triggerParticle->Pt())<ftrigPtLow)||((triggerParticle->Pt())>ftrigPtHigh)) continue;
2061
2062                                         Double_t vars[4];
2063                                         vars[0] = triggerEta - eta[j];
2064                                         vars[1] = particle->Pt();         //Associated Pt
2065                                         vars[2] = triggerParticle->Pt();  //Triger Pt
2066                                         vars[3] = RangePhi(triggerParticle->Phi() - particle->Phi());
2067
2068                                         histo->Fill(vars[0],vars[3]);
2069
2070                    }
2071                 }
2072         }
2073 }
2074 //---------------------------------------------------------------------------------------
2075 TObjArray*  AliLeadingV0Correlation::FindLeadingObjectsK0(TObject *obj)
2076 {
2077
2078         Int_t nTracks = NParticles(obj);
2079         if( !nTracks ) return 0;
2080
2081         // Define array of AliVParticle objects
2082         TObjArray* tracks = new TObjArray(nTracks);
2083
2084         // Loop over tracks or jets
2085         for (Int_t ipart=0; ipart<nTracks; ++ipart) {
2086         AliVParticle* part = ParticleWithCuts( obj,ipart);
2087         if (!part) continue;
2088
2089                 if(!IsAcseptedPrimaryTrack(((AliAODTrack*)part)))continue;
2090                 if(!IsTrackNotFromK0(ipart))continue;
2091
2092                 tracks->AddLast( part );
2093         }
2094         // Order tracks by pT
2095         QSortTracks( *tracks, 0, tracks->GetEntriesFast() );
2096
2097         nTracks = tracks->GetEntriesFast();
2098         if( !nTracks ) return 0;
2099
2100         return tracks;
2101 }
2102 //---------------------------------------------------------------------------------------
2103 TObjArray*  AliLeadingV0Correlation::FindLeadingObjectsLambda(TObject *obj)
2104 {
2105
2106         Int_t nTracks = NParticles(obj);
2107         if( !nTracks ) return 0;
2108
2109         // Define array of AliVParticle objects
2110         TObjArray* tracks = new TObjArray(nTracks);
2111
2112         // Loop over tracks or jets
2113         for (Int_t ipart=0; ipart<nTracks; ++ipart) {
2114         AliVParticle* part = ParticleWithCuts( obj,ipart);
2115         if (!part) continue;
2116
2117                 if(!IsAcseptedPrimaryTrack(((AliAODTrack*)part)))continue;
2118                 if(!IsTrackNotFromLambda(ipart))continue;
2119
2120                 tracks->AddLast( part );
2121         }
2122         // Order tracks by pT
2123         QSortTracks( *tracks, 0, tracks->GetEntriesFast() );
2124
2125         nTracks = tracks->GetEntriesFast();
2126         if( !nTracks ) return 0;
2127
2128         return tracks;
2129 }
2130 //---------------------------------------------------------------------------------------
2131 TObjArray*  AliLeadingV0Correlation::FindLeadingObjectsK0MC(TObject *obj)
2132 {
2133
2134         Int_t nTracks = NParticles(obj);
2135         if( !nTracks ) return 0;
2136
2137         // Define array of AliVParticle objects
2138         TObjArray* tracks = new TObjArray(nTracks);
2139
2140         // Loop over tracks or jets
2141         for (Int_t ipart=0; ipart<nTracks; ++ipart) {
2142         AliVParticle* part = ParticleWithCuts( obj,ipart);
2143         if (!part) continue;
2144                 Int_t pdgCodeCurrent = ((AliAODMCParticle*)part)->GetPdgCode();
2145                 if(pdgCodeCurrent==310)continue;
2146                 tracks->AddLast( part );
2147         }
2148         // Order tracks by pT
2149         QSortTracks( *tracks, 0, tracks->GetEntriesFast() );
2150
2151         nTracks = tracks->GetEntriesFast();
2152         if( !nTracks ) return 0;
2153
2154         return tracks;
2155 }
2156 //---------------------------------------------------------------------------------------
2157 TObjArray*  AliLeadingV0Correlation::FindLeadingObjectsLambdaMC(TObject *obj)
2158 {
2159
2160         Int_t nTracks = NParticles(obj);
2161         if( !nTracks ) return 0;
2162
2163         // Define array of AliVParticle objects
2164         TObjArray* tracks = new TObjArray(nTracks);
2165
2166         // Loop over tracks or jets
2167         for (Int_t ipart=0; ipart<nTracks; ++ipart) {
2168         AliVParticle* part = ParticleWithCuts( obj,ipart);
2169         if (!part) continue;
2170                 Int_t pdgCodeCurrent = ((AliAODMCParticle*)part)->GetPdgCode();
2171                 if(pdgCodeCurrent==3122)continue;
2172                 tracks->AddLast( part );
2173         }
2174         // Order tracks by pT
2175         QSortTracks( *tracks, 0, tracks->GetEntriesFast() );
2176
2177         nTracks = tracks->GetEntriesFast();
2178         if( !nTracks ) return 0;
2179
2180         return tracks;
2181 }
2182 //---------------------------------------------------------------------------------------
2183 void  AliLeadingV0Correlation::QSortTracks(TObjArray &a, Int_t first, Int_t last)
2184 {
2185         // Sort array of TObjArray of tracks by Pt using a quicksort algorithm.
2186
2187         static TObject *tmp;
2188         static int i;           // "static" to save stack space
2189         int j;
2190
2191         while (last - first > 1) {
2192                 i = first;
2193                 j = last;
2194                 for (;;) {
2195                         while (++i < last && ((AliVParticle*)a[i])->Pt() > ((AliVParticle*)a[first])->Pt() )
2196                                 ;
2197                         while (--j > first && ((AliVParticle*)a[j])->Pt() < ((AliVParticle*)a[first])->Pt() )
2198                                 ;
2199                         if (i >= j)
2200                                 break;
2201
2202                         tmp  = a[i];
2203                         a[i] = a[j];
2204                         a[j] = tmp;
2205                 }
2206                 if (j == first) {
2207                         ++first;
2208                         continue;
2209                 }
2210                 tmp = a[first];
2211                 a[first] = a[j];
2212                 a[j] = tmp;
2213                 if (j - first < last - (j + 1)) {
2214                         QSortTracks(a, first, j);
2215                         first = j + 1;   // QSortTracks(j + 1, last);
2216                 } else {
2217                         QSortTracks(a, j + 1, last);
2218                         last = j;        // QSortTracks(first, j);
2219                 }
2220         }
2221 }
2222 //---------------------------------------------------------------------------------------
2223 AliVParticle*  AliLeadingV0Correlation::ParticleWithCuts(TObject* obj, Int_t ipart)
2224 {
2225         AliVParticle *part=0;
2226         if (obj->InheritsFrom("AliAODEvent")){ // RECO AOD TRACKS
2227                 AliAODEvent *aodEvent = static_cast<AliAODEvent*>(obj);
2228         part = aodEvent->GetTrack(ipart);
2229                 // track selection cuts
2230                 if ( !(((AliAODTrack*)part)->TestFilterBit(fFilterBit))) return 0;
2231         }
2232         else if(obj->InheritsFrom("TClonesArray")){ // AOD-MC PARTICLE
2233                 TClonesArray *arrayMC = static_cast<TClonesArray*>(obj);
2234         part = (AliVParticle*)arrayMC->At( ipart );
2235                 if (!part)return 0;
2236                 // eventually only primaries
2237                 if (!( ((AliAODMCParticle*)part)->IsPhysicalPrimary()) )return 0;
2238         // eventually only hadrons
2239                 Int_t pdgCode = ((AliAODMCParticle*)part)->GetPdgCode();
2240                         Bool_t isHadron = TMath::Abs(pdgCode)==211 ||  // Pion
2241                         TMath::Abs(pdgCode)==2212 || // Proton
2242                         TMath::Abs(pdgCode)==321;    // Kaon
2243                         if (!isHadron) return 0;
2244         }
2245         else {return 0;}
2246         // only charged
2247         if (!part->Charge())return 0;
2248         return part;
2249 }
2250 //---------------------------------------------------------------------------------------
2251 Bool_t   AliLeadingV0Correlation::IsK0InvMass(const Double_t mass) const {
2252
2253         const Float_t massK0            = 0.497;
2254         const Float_t sigmaK0           = 0.003;
2255         const Float_t nSigmaSignal      = 3.5;
2256
2257         return ((massK0-nSigmaSignal*sigmaK0)<=mass && mass<=(massK0 + nSigmaSignal*sigmaK0))?1:0;
2258 }
2259 //---------------------------------------------------------------------------------------
2260 Bool_t   AliLeadingV0Correlation::IsLambdaInvMass(const Double_t mass) const {
2261
2262         const Float_t massLambda        = 1.116;
2263         const Float_t sigmaLambda       = 0.003;
2264         const Float_t nSigmaSignal      = 3.5;
2265
2266         return ((massLambda-nSigmaSignal*sigmaLambda)<=mass && mass<=(massLambda + nSigmaSignal*sigmaLambda))?1:0;
2267 }
2268 //---------------------------------------------------------------------------------------
2269 Bool_t   AliLeadingV0Correlation::IsTrackNotFromLambda(const Int_t indexTrack){
2270         // check wether track with index is from Lambda (= V0 with proper inv mass)
2271         TClonesArray* tracks = fAODEvent->GetTracks();
2272         for(int i=0; i<fAODEvent->GetNumberOfV0s(); i++){ // loop over V0s
2273                 AliAODv0* aodV0 = fAODEvent->GetV0(i);
2274                 Float_t massLambda         = aodV0->MassLambda();
2275                 if(IsLambdaInvMass(massLambda)){
2276                         AliAODTrack *trackPos = (AliAODTrack *) (aodV0->GetSecondaryVtx()->GetDaughter(0));
2277                         AliAODTrack *trackNeg = (AliAODTrack *) (aodV0->GetSecondaryVtx()->GetDaughter(1));
2278
2279                         if ( !(IsAcseptedDaughterTrack(trackPos)) || !(IsAcseptedDaughterTrack(trackNeg)) ) continue;
2280
2281                         Int_t indexPos = tracks->IndexOf(trackPos);
2282                         Int_t indexNeg = tracks->IndexOf(trackNeg);
2283                         if(indexPos == indexTrack){ return kFALSE;}
2284                         if(indexNeg == indexTrack){ return kFALSE;}
2285                 }
2286         }
2287         return kTRUE;
2288 }
2289 //---------------------------------------------------------------------------------------
2290 Bool_t   AliLeadingV0Correlation::IsTrackNotFromK0(const Int_t indexTrack){
2291         // check wether track with index is from K0 (= V0 with proper inv mass)
2292         TClonesArray* tracks = fAODEvent->GetTracks();
2293         for(int i=0; i<fAODEvent->GetNumberOfV0s(); i++){ // loop over V0s
2294                 AliAODv0* aodV0 = fAODEvent->GetV0(i);
2295                 Float_t massK0         = aodV0->MassK0Short();
2296                 if(IsK0InvMass(massK0)){
2297                         AliAODTrack *trackPos = (AliAODTrack *) (aodV0->GetSecondaryVtx()->GetDaughter(0));
2298                         AliAODTrack *trackNeg = (AliAODTrack *) (aodV0->GetSecondaryVtx()->GetDaughter(1));
2299
2300                         if ( !(IsAcseptedDaughterTrack(trackPos)) || !(IsAcseptedDaughterTrack(trackNeg)) ) continue;
2301
2302                         Int_t indexPos = tracks->IndexOf(trackPos);
2303                         Int_t indexNeg = tracks->IndexOf(trackNeg);
2304                         if(indexPos == indexTrack){ return kFALSE;}
2305                     if(indexNeg == indexTrack){ return kFALSE;}
2306                 }
2307         }
2308         return kTRUE;
2309 }
2310 //---------------------------------------------------------------------------------------
2311 Bool_t AliLeadingV0Correlation::IsAcseptedV0(const AliAODEvent*aod, const AliAODv0* aodV0, const AliAODTrack* myTrackPos, const AliAODTrack* myTrackNeg)
2312 {
2313         if (!aodV0) return kFALSE;
2314
2315         Double_t lRapK0s = aodV0->Y(310);
2316         Double_t lRapLambda = aodV0->Y(3122);
2317         Double_t lRapAntiLambda = aodV0->Y(-3122);
2318
2319         if (TMath::Abs(lRapK0s)>=fRapidityCut) return kFALSE;
2320         if (TMath::Abs(lRapLambda)>=fRapidityCut) return kFALSE;
2321         if (TMath::Abs(lRapAntiLambda)>=fRapidityCut) return kFALSE;
2322
2323         // Offline reconstructed V0 only
2324     if (aodV0->GetOnFlyStatus()) return kFALSE;
2325
2326     // DCA of daughter track to Primary Vertex
2327     Float_t dcaNP=aodV0->DcaNegToPrimVertex();
2328     if (TMath::Abs(dcaNP)<fCutDCANegToPV) return kFALSE;
2329     Float_t dcaPP=aodV0->DcaPosToPrimVertex();
2330     if (TMath::Abs(dcaPP)<fCutDCAPosToPV) return kFALSE;
2331
2332         // DCA of daughter tracks
2333     Double_t dcaD=aodV0->DcaV0Daughters();
2334     if (dcaD>fCutDCAV0Daughters) return kFALSE;
2335
2336         // Cosinus of pointing angle
2337     Double_t cpa=aodV0->CosPointingAngle(aod->GetPrimaryVertex());
2338     if (cpa<fCutV0CosPA) return kFALSE;
2339
2340         // Decay Radius Cut
2341     Double_t xyz[3]; aodV0->GetSecondaryVtx(xyz);
2342     Double_t r2=xyz[0]*xyz[0] + xyz[1]*xyz[1];
2343     if (r2<fCutV0Radius) return kFALSE;
2344
2345     // Get daughters and check them
2346         myTrackPos=(AliAODTrack *)(aodV0->GetDaughter(0));
2347         myTrackNeg=(AliAODTrack *)(aodV0->GetDaughter(1));
2348
2349         if (!myTrackPos||!myTrackNeg) return kFALSE;
2350         // Unlike signs of daughters
2351     if (myTrackPos->Charge() == myTrackNeg->Charge()) return kFALSE;
2352
2353         // Track cuts for daughers
2354     if ( !(IsAcseptedDaughterTrack(myTrackPos)) || !(IsAcseptedDaughterTrack(myTrackNeg)) ) return kFALSE;
2355
2356         // Minimum pt of daughters
2357     Double_t  lMomPos[3] = {999,999,999};
2358         Double_t  lMomNeg[3] = {999,999,999};
2359
2360         lMomPos[0] = aodV0->MomPosX();
2361     lMomPos[1] = aodV0->MomPosY();
2362     lMomPos[2] = aodV0->MomPosZ();
2363
2364     lMomNeg[0] = aodV0->MomNegX();
2365     lMomNeg[1] = aodV0->MomNegY();
2366     lMomNeg[2] = aodV0->MomNegZ();
2367
2368     Double_t lPtPos = TMath::Sqrt(lMomPos[0]*lMomPos[0] + lMomPos[1]*lMomPos[1]);
2369     Double_t lPtNeg = TMath::Sqrt(lMomNeg[0]*lMomNeg[0] + lMomNeg[1]*lMomNeg[1]);
2370
2371         Double_t cutMinPtDaughter = 0.150;
2372         if (lPtPos<cutMinPtDaughter || lPtNeg<cutMinPtDaughter) return kFALSE;
2373
2374         return kTRUE;
2375 }
2376 //---------------------------------------------------------------------------------------
2377 Double_t AliLeadingV0Correlation::IsAccepteddEdx(const Double_t mom,const Double_t signal, AliPID::EParticleType n){
2378
2379         const Double_t kBBMIP(50.);
2380         const Double_t kBBRes(0.07);
2381         const Double_t kBBp1(0.76176e-1);
2382         const Double_t kBBp2(10.632);
2383         const Double_t kBBp3(0.13279e-4);
2384         const Double_t kBBp4(1.8631);
2385         const Double_t kBBp5(1.9479);
2386
2387         Double_t mass=AliPID::ParticleMass(n);
2388         Double_t betaGamma = mom/mass;
2389
2390         const Float_t kmeanCorrection =0.1;
2391         Double_t bb = AliExternalTrackParam::BetheBlochAleph(betaGamma,kBBp1,kBBp2,kBBp3,kBBp4,kBBp5);
2392         Double_t meanCorrection =(1+(bb-1)*kmeanCorrection);
2393         Double_t bethe = bb * meanCorrection;
2394         Double_t sigma = bethe * kBBRes;
2395
2396         Double_t dedx = signal/kBBMIP;
2397         Double_t nSig = (TMath::Abs(dedx - bethe))/sigma;
2398
2399         return nSig;
2400 }
2401
2402 //---------------------------------------------------------------------------------------
2403 void AliLeadingV0Correlation::Terminate(Option_t *)
2404 {
2405         //No need in the grid
2406 }
2407 //---------------------------------------------------------------------------------------