PWGCF/Correlations/DPhi/AliLeadingV0Correlation.cxx

   1 /* Leading Charged Track+V0 Correlation.(Works for Real,Monte Carlo Data)
   2  *                            Sandun Jayarathna
   3  *                          University of Houston
   4  *                      sandun.pahula.hewage@cern.ch
   5  *****************************************************************************************/
   6 #include <TROOT.h>
   7 #include <TList.h>
   8 #include <TChain.h>
   9 #include <TFile.h>
  10 #include <TMath.h>
  11 #include <TH1.h>
  12 #include <TTree.h>
  13 #include <TRandom.h>
  14 #include <THnSparse.h>
  15 #include <TPDGCode.h>
  16 #include <TDatabasePDG.h>
  17
  18 #include "AliLog.h"
  19 #include "AliAnalysisManager.h"
  20 #include "AliAODTrack.h"
  21 #include "AliAODEvent.h"
  22 #include "AliAODv0.h"
  23 #include "AliAODVertex.h"
  24 #include "AliAODPid.h"
  25 #include "AliPIDResponse.h"
  26 #include "AliEventPoolManager.h"
  27 #include "AliCentrality.h"
  28 #include "AliAODHandler.h"
  29 #include "AliAODInputHandler.h"
  30 #include "AliAODMCParticle.h"
  31 #include "AliInputEventHandler.h"
  32 #include "AliVParticle.h"
  33 #include "AliMultiplicity.h"
  34 #include "AliAODMCHeader.h"
  35 #include "AliPID.h"
  36 #include "AliExternalTrackParam.h"
  37 #include "AliAnalyseLeadingTrackUE.h"
  38
  39 #include "AliLeadingV0Correlation.h"
  40
  41 #define CorrBinsX 24
  42 #define CorrBinsY 26
  43
  44
  45 Double_t PI =TMath::Pi();
  46
  47 ClassImp(AliLeadingV0Correlation)
  48 ClassImp(V0Correlationparticle)
  49
  50 //---------------------------------------------------------------------------------------
  51 AliLeadingV0Correlation::AliLeadingV0Correlation()
  52    : AliAnalysisTaskSE(),
  53         fAODEvent                                       (0x0),
  54         fPoolMgr                                        (0x0),
  55         fPIDResponse                            (0x0),
  56         fAnalyseUE                                      (0x0),
  57         fPoolMaxNEvents                         (0),
  58         fPoolMinNTracks                         (0),
  59         fMinEventsToMix                         (0),
  60         fNzVtxBins                                      (0),
  61         fNCentBins                                      (0),
  62         fcollidingSys                           (""),
  63         fpvzcut                                         (0),
  64         fTrackEtaCut                            (0.9),
  65         fFilterBit                                      (128),
  66         fAnalysisMC                                     (0),
  67         fCase                                           (0),
  68         fRemoveAutoCorr                         (0),
  69         fRapidityCut                            (0),
  70         fV0radius                                       (0),
  71         fV0PostoPVz                                     (0),
  72         fV0NegtoPVz                                     (0),
  73         fDCAV0Daughters                         (0),
  74         fCPAK0                                          (0),
  75         fCPALam                                         (0),
  76         fRejectLamK0                            (0),
  77         fRejectK0Lam                            (0),
  78     fSigmaPID                                   (0),
  79         fCutCTK0                                        (0),
  80         fCutCTLa                                        (0),
  81         fMassCutK0                                      (0),
  82         fMassCutLa                                      (0),
  83         fTriglow                                        (0),
  84         fTrighigh                                       (0),
  85         fUseChargeHadrons                       (kTRUE),
  86         fPtMin                                          (0.15),
  87         fOutputList                                     (0),
  88         fHist_Mult_B4_Trg_Sel           (0),
  89         fHist_Mult_Af_Trg_Sel           (0),
  90         fHist_Mult_PVz_Cut                      (0),
  91         fHist_Mult_SPD_PVz                      (0),
  92         fHist_Mult_SPD_PVz_Pileup       (0),
  93         fHistPVx                                        (0),
  94         fHistPVy                                        (0),
  95         fHistPVz                                        (0),
  96         fHistPVxAnalysis                        (0),
  97         fHistPVyAnalysis                        (0),
  98         fHistPVzAnalysis                        (0),
  99         fHistEventViceGen                       (0),
 100         fHistEventViceReconst           (0),
 101         fHistMCGenK0                            (0),
 102         fHistMCGenLAM                           (0),
 103         fHistMCGenALAM                          (0),
 104         fHistReconstK0                          (0),
 105         fHistReconstLA                          (0),
 106         fHistReconstALA                         (0),
 107         fHistMCAssoK0                           (0),
 108         fHistMCAssoLA                           (0),
 109         fHistMCAssoALA                          (0),
 110         fHistReconstSib                         (0),
 111         fHistReconstMix                         (0),
 112         fHistTriggerSib                         (0),
 113         fHistTriggerMix                         (0)
 114 {
 115
 116   for(Int_t iBin = 0; iBin < 100; iBin++){
 117     fZvtxBins[iBin] = 0.;
 118     fCentBins[iBin] = 0.;
 119   }
 120 }
 121 //---------------------------------------------------------------------------------------
 122 AliLeadingV0Correlation::AliLeadingV0Correlation(const char *name)
 123    : AliAnalysisTaskSE(name),
 124         fAODEvent                                       (0x0),
 125         fPoolMgr                                        (0x0),
 126     fPIDResponse                                (0x0),
 127         fAnalyseUE                                      (0x0),
 128         fPoolMaxNEvents                         (0),
 129         fPoolMinNTracks                         (0),
 130         fMinEventsToMix                         (0),
 131         fNzVtxBins                                      (0),
 132         fNCentBins                                      (0),
 133         fcollidingSys                           (""),
 134         fpvzcut                                         (0),
 135     fTrackEtaCut                                (0.9),
 136     fFilterBit                                  (128),
 137         fAnalysisMC                                     (0),
 138         fCase                                           (0),
 139         fRemoveAutoCorr                         (0),
 140     fRapidityCut                                (0),
 141         fV0radius                                       (0),
 142         fV0PostoPVz                                     (0),
 143         fV0NegtoPVz                                     (0),
 144         fDCAV0Daughters                         (0),
 145         fCPAK0                                          (0),
 146         fCPALam                                         (0),
 147         fRejectLamK0                            (0),
 148         fRejectK0Lam                            (0),
 149     fSigmaPID                                   (0),
 150         fCutCTK0                                        (0),
 151         fCutCTLa                                        (0),
 152         fMassCutK0                                      (0),
 153         fMassCutLa                                      (0),
 154         fTriglow                                        (0),
 155         fTrighigh                                       (0),
 156         fUseChargeHadrons                       (kTRUE),
 157         fPtMin                                          (0.15),
 158         fOutputList                                     (0),
 159         fHist_Mult_B4_Trg_Sel           (0),
 160         fHist_Mult_Af_Trg_Sel           (0),
 161         fHist_Mult_PVz_Cut                      (0),
 162         fHist_Mult_SPD_PVz                      (0),
 163         fHist_Mult_SPD_PVz_Pileup       (0),
 164         fHistPVx                                        (0),
 165         fHistPVy                                        (0),
 166         fHistPVz                                        (0),
 167         fHistPVxAnalysis                        (0),
 168         fHistPVyAnalysis                        (0),
 169         fHistPVzAnalysis                        (0),
 170         fHistEventViceGen                       (0),
 171         fHistEventViceReconst           (0),
 172         fHistMCGenK0                            (0),
 173         fHistMCGenLAM                           (0),
 174         fHistMCGenALAM                          (0),
 175         fHistReconstK0                          (0),
 176         fHistReconstLA                          (0),
 177         fHistReconstALA                         (0),
 178         fHistMCAssoK0                           (0),
 179         fHistMCAssoLA                           (0),
 180         fHistMCAssoALA                          (0),
 181         fHistReconstSib                         (0),
 182         fHistReconstMix                         (0),
 183         fHistTriggerSib                         (0),
 184         fHistTriggerMix                         (0)
 185
 186 {
 187   for(Int_t iBin = 0; iBin < 100; iBin++){
 188     fZvtxBins[iBin] = 0.;
 189     fCentBins[iBin] = 0.;
 190   }
 191   DefineOutput(1, TList::Class());
 192 }
 193
 194 //---------------------------------------------------------------------------------------
 195 AliLeadingV0Correlation::~AliLeadingV0Correlation()
 196 {
 197    if (fOutputList && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
 198       delete fOutputList;
 199    }
 200 }
 201 //---------------------------------------------------------------------------------------
 202 void AliLeadingV0Correlation::UserCreateOutputObjects()
 203 {
 204         fAnalyseUE =new AliAnalyseLeadingTrackUE();
 205         if(!fAnalysisMC)
 206         {
 207         fAnalyseUE->SetParticleSelectionCriteria(fFilterBit,fUseChargeHadrons,fTrackEtaCut,fPtMin);
 208         fAnalyseUE->DefineESDCuts(fFilterBit);
 209         }
 210
 211         fOutputList = new TList();
 212         fOutputList->SetOwner();
 213
 214         fHist_Mult_B4_Trg_Sel = new TH1F("fHist_Mult_B4_Trg_Sel","Tracks per event;Nbr of Tracks;Events", 1000, 0, 10000);
 215         fOutputList->Add(fHist_Mult_B4_Trg_Sel);
 216
 217         fHist_Mult_Af_Trg_Sel = new TH1F("fHist_Mult_Af_Trg_Sel","Tracks per event;Nbr of Tracks;Events",1000, 0, 10000);
 218         fOutputList->Add(fHist_Mult_Af_Trg_Sel);
 219
 220         fHist_Mult_PVz_Cut = new TH1F("fHist_Mult_PVz_Cut","Tracks per event;Nbr of Tracks;Events",1000, 0, 10000);
 221         fOutputList->Add(fHist_Mult_PVz_Cut);
 222
 223         fHist_Mult_SPD_PVz = new TH1F("fHist_Mult_SPD_PVz","Tracks per event;Nbr of Tracks;Events",1000, 0, 10000);
 224         fOutputList->Add(fHist_Mult_SPD_PVz);
 225
 226         fHist_Mult_SPD_PVz_Pileup = new TH1F("fHist_Mult_SPD_PVz_Pileup","Tracks per event;Nbr of Tracks;Events",1000, 0, 10000);
 227         fOutputList->Add(fHist_Mult_SPD_PVz_Pileup);
 228
 229         fHistPVx = new TH1F("fHistPVx","PV x position;Nbr of Evts;x", 200, -0.5, 0.5);
 230         fOutputList->Add(fHistPVx);
 231
 232         fHistPVy = new TH1F("fHistPVy","PV y position;Nbr of Evts;y",200, -0.5, 0.5);
 233         fOutputList->Add(fHistPVy);
 234
 235         fHistPVz = new TH1F("fHistPVz","PV z position;Nbr of Evts;z",400, -20, 20);
 236         fOutputList->Add(fHistPVz);
 237
 238         fHistPVxAnalysis = new TH1F("fHistPVxAnalysis","PV x position;Nbr of Evts;x", 200, -0.5, 0.5);
 239         fOutputList->Add(fHistPVxAnalysis);
 240
 241         fHistPVyAnalysis = new TH1F("fHistPVyAnalysis","PV y position;Nbr of Evts;y",200, -0.5, 0.5);
 242         fOutputList->Add(fHistPVyAnalysis);
 243
 244         fHistPVzAnalysis = new TH1F("fHistPVzAnalysis","PV z position;Nbr of Evts;z",400, -20, 20);
 245         fOutputList->Add(fHistPVzAnalysis);
 246
 247         //---------------------------------------------- Events histograms -----------------------------------------------------//
 248         //0-PVx,1-PVy,2-PVz,3-MULT,4-CENT
 249         const Int_t ndimsEV = 3;
 250         Int_t    binsEV[ndimsEV] = { 200,  100,100};
 251         Double_t xminEV[ndimsEV] = {-20 ,    0,  0};
 252         Double_t xmaxEV[ndimsEV] = { 20 ,  300,100};
 253
 254         fHistEventViceGen= new THnSparseD("fHistEventViceGen", "fHistEventViceGen", ndimsEV, binsEV, xminEV, xmaxEV);
 255         fOutputList->Add(fHistEventViceGen);
 256
 257         fHistEventViceReconst= new THnSparseD("fHistEventViceReconst", "fHistEventViceReconst", ndimsEV, binsEV, xminEV, xmaxEV);
 258         fOutputList->Add(fHistEventViceReconst);
 259
 260         //0-YK0,1-Pt
 261         const Int_t ndimsGenMC = 3;
 262         Int_t    binsGenMCLA[ndimsGenMC] = {120, 140,100};
 263         Double_t xminGenMCLA[ndimsGenMC] = {  0,1.06,  0};
 264         Double_t xmaxGenMCLA[ndimsGenMC] = {  6, 1.2,100};
 265
 266         Int_t    binsGenMCK0[ndimsGenMC] = {120, 200,100};
 267         Double_t xminGenMCK0[ndimsGenMC] = {  0, 0.4,  0};
 268         Double_t xmaxGenMCK0[ndimsGenMC] = {  6, 0.6,100};
 269
 270         fHistMCGenLAM  = new THnSparseD("fHistMCGenLAM" , "fHistMCGenLAM" , ndimsGenMC, binsGenMCLA, xminGenMCLA, xmaxGenMCLA);
 271         fOutputList->Add(fHistMCGenLAM);
 272
 273         fHistMCGenALAM = new THnSparseD("fHistMCGenALAM", "fHistMCGenALAM", ndimsGenMC, binsGenMCLA, xminGenMCLA, xmaxGenMCLA);
 274         fOutputList->Add(fHistMCGenALAM);
 275
 276         fHistMCGenK0   = new THnSparseD("fHistMCGenK0"  , "fHistMCGenK0"  , ndimsGenMC, binsGenMCK0, xminGenMCK0, xmaxGenMCK0);
 277         fOutputList->Add(fHistMCGenK0);
 278
 279         const Int_t ndims=3;    //MK0  mLA  MALA PT   cent
 280         Int_t    binsK0[ndims] = {  200, 120  ,100};
 281         Double_t xminK0[ndims] = {  0.4,   0  ,  0};
 282         Double_t xmaxK0[ndims] = {  0.6,   6  ,100};
 283
 284         Int_t    binsLA[ndims] = {  140, 120  ,100};
 285         Double_t xminLA[ndims] = { 1.06,   0  ,  0};
 286         Double_t xmaxLA[ndims] = {  1.2,   6  ,100};
 287
 288
 289         fHistReconstK0= new THnSparseD("fHistReconstK0"  , "fHistReconstK0",  ndims, binsK0, xminK0, xmaxK0);
 290         fHistReconstK0->Sumw2();
 291         fOutputList->Add(fHistReconstK0);
 292
 293         fHistReconstLA= new THnSparseD("fHistReconstLA"  , "fHistReconstLA",  ndims, binsLA, xminLA, xmaxLA);
 294         fHistReconstLA->Sumw2();
 295         fOutputList->Add(fHistReconstLA);
 296
 297         fHistReconstALA= new THnSparseD("fHistReconstALA", "fHistReconstALA", ndims, binsLA, xminLA, xmaxLA);
 298         fHistReconstALA->Sumw2();
 299         fOutputList->Add(fHistReconstALA);
 300
 301         fHistMCAssoK0= new THnSparseD("fHistMCAssoK0"   , "fHistMCAssoK0"   , ndims, binsK0, xminK0, xmaxK0);
 302         fHistMCAssoK0->Sumw2();
 303         fOutputList->Add(fHistMCAssoK0);
 304
 305         fHistMCAssoLA= new THnSparseD("fHistMCAssoLA"   , "fHistMCAssoLA"   , ndims, binsLA, xminLA, xmaxLA);
 306         fHistMCAssoLA->Sumw2();
 307         fOutputList->Add(fHistMCAssoLA);
 308
 309         fHistMCAssoALA= new THnSparseD("fHistMCAssoALA" , "fHistMCAssoALA" ,  ndims, binsLA, xminLA, xmaxLA);
 310         fHistMCAssoALA->Sumw2();
 311         fOutputList->Add(fHistMCAssoALA);
 312
 313         //--------------------------------------------Correlation Histos -----------------------------------------------------//
 314
 315         //0-pTK0,1-PhiK0,2-EtaK0,3-DPhiK0,4-DEtaK0,5-TYPE,6-CutSet
 316         const Int_t ndimsv0CORR = 7;
 317         Int_t    binsv0CORR[ndimsv0CORR] = {120, 200,          200,CorrBinsX,      CorrBinsY,4,100};
 318
 319         Double_t xminv0CORR[ndimsv0CORR] = {  0,   0,-fTrackEtaCut,    -PI/2,-2*fTrackEtaCut,0,0};
 320
 321         Double_t xmaxv0CORR[ndimsv0CORR] = {  6,2*PI, fTrackEtaCut,   3*PI/2, 2*fTrackEtaCut,4,100};
 322
 323         fHistReconstSib= new THnSparseD("fHistReconstSib", "fHistReconstSib", ndimsv0CORR, binsv0CORR, xminv0CORR, xmaxv0CORR);
 324         fHistReconstSib->Sumw2();
 325         fOutputList->Add(fHistReconstSib);
 326
 327         fHistReconstMix= new THnSparseD("fHistReconstMix", "fHistReconstMix", ndimsv0CORR, binsv0CORR, xminv0CORR, xmaxv0CORR);
 328         fHistReconstMix->Sumw2();
 329         fOutputList->Add(fHistReconstMix);
 330
 331         //0-pt,1-PHI,2-Eta
 332         const Int_t triggerdims       =2;
 333         Int_t binsTrig[triggerdims]   ={       100, 100};
 334         Double_t xminTrig[triggerdims]={  fTriglow,   0};
 335         Double_t xmaxTrig[triggerdims]={ fTrighigh, 100};
 336
 337         fHistTriggerSib= new THnSparseD("fHistTriggerSib", "fHistTriggerSib", triggerdims, binsTrig, xminTrig, xmaxTrig);
 338         fHistTriggerSib->Sumw2();
 339         fOutputList->Add(fHistTriggerSib);
 340
 341         fHistTriggerMix= new THnSparseD("fHistTriggerMix", "fHistTriggerMix", triggerdims, binsTrig, xminTrig, xmaxTrig);
 342         fHistTriggerMix->Sumw2();
 343         fOutputList->Add(fHistTriggerMix);
 344
 345
 346         //----------------------------------------------Event Pool-----------------------------------------------------//
 347         fPoolMgr = new AliEventPoolManager(fPoolMaxNEvents, fPoolMinNTracks, fNCentBins, fCentBins, fNzVtxBins, fZvtxBins);
 348         if(!fPoolMgr) return;
 349
 350         PostData(1, fOutputList);
 351 }
 352 //---------------------------------------------------------------------------------------
 353 void AliLeadingV0Correlation::UserExec(Option_t *)
 354 {
 355
 356     AliAnalysisManager   *mgr      = AliAnalysisManager::GetAnalysisManager();
 357     AliInputEventHandler *inEvMain = (AliInputEventHandler*)(mgr->GetInputEventHandler());
 358         if (!inEvMain) return;
 359
 360         // Pointers to PID Response objects.
 361         fPIDResponse = inEvMain->GetPIDResponse();
 362         if(!fPIDResponse) return;
 363
 364     fAODEvent = dynamic_cast<AliAODEvent*>(inEvMain->GetEvent());
 365         if(!fAODEvent) return;
 366
 367         Int_t multiplicity    = -1;
 368         Int_t multiplicityMC  = -1;
 369         Double_t MultipOrCent = -1;
 370         Double_t CentPecentMC = -1;
 371         Double_t CentPecentAfterPhySel    = -1;
 372         Int_t    nTrackMultiplicity       = -1;
 373         Float_t lPrimaryTrackMultiplicity = 0;
 374
 375         nTrackMultiplicity              = (InputEvent())->GetNumberOfTracks();
 376     for (Int_t itrack = 0; itrack<nTrackMultiplicity; itrack++) {
 377                 AliAODTrack* track = fAODEvent->GetTrack(itrack);
 378                 if(!fAnalysisMC) if (track->TestFilterBit(fFilterBit)) lPrimaryTrackMultiplicity++;
 379                 lPrimaryTrackMultiplicity++;
 380     }
 381
 382         fHist_Mult_B4_Trg_Sel->Fill(lPrimaryTrackMultiplicity);
 383
 384         if(fcollidingSys=="PbPb"){
 385         AliCentrality *centralityObjMC = fAODEvent->GetHeader()->GetCentralityP();
 386                 CentPecentMC  = centralityObjMC->GetCentralityPercentileUnchecked("V0M");
 387                 if ((CentPecentMC < 0.)||(CentPecentMC > 90)) return;
 388         }
 389
 390         Double_t * CentBins = fCentBins;
 391         Double_t poolmin    = CentBins[0];
 392         Double_t poolmax    = CentBins[fNCentBins];
 393
 394         //----------------------------------------------------------
 395         // Efficency denomenator comes before the physics selection
 396         //----------------------------------------------------------
 397
 398         Double_t  dimEventviceMC[3];
 399         if(fAnalysisMC)    //Efficency denomenator comes before the physics selection
 400         {
 401                 AliAODMCHeader *aodMCheader = (AliAODMCHeader*)fAODEvent->FindListObject(AliAODMCHeader::StdBranchName());
 402                 Float_t mcZv = aodMCheader->GetVtxZ();
 403
 404                 if (TMath::Abs(mcZv) >= fpvzcut) return;
 405
 406                 dimEventviceMC[0]=aodMCheader->GetVtxZ();
 407
 408                 TClonesArray *mcArray = (TClonesArray*)fAODEvent->FindListObject(AliAODMCParticle::StdBranchName());
 409                 if(!mcArray)return;
 410
 411                 Int_t nMCTracks = mcArray->GetEntriesFast();
 412
 413                 if(fcollidingSys=="PbPb") multiplicityMC=CentPecentMC;
 414                 if(fcollidingSys=="PP")   multiplicityMC=nMCTracks;
 415
 416                 dimEventviceMC[1]=nMCTracks;
 417                 dimEventviceMC[2]=CentPecentMC;
 418                 fHistEventViceGen->Fill(dimEventviceMC);
 419
 420                 for (Int_t iMC = 0; iMC<nMCTracks; iMC++)
 421                 {
 422                         AliAODMCParticle *mcTrack = (AliAODMCParticle*)mcArray->At(iMC);
 423                         if (!mcTrack) continue;
 424                         // Charged track Generated level
 425                         Double_t mcTrackPt  = mcTrack->Pt();
 426                         if ((mcTrackPt<fPtMin)||(mcTrackPt>6.0)) continue;
 427
 428                         //Double_t mcTrackEta = mcTrack->Eta();
 429                         //Double_t mcTrackPhi = mcTrack->Phi();
 430                         Bool_t TrIsPrime    = mcTrack->IsPhysicalPrimary();
 431                         Bool_t TrPtMin      = mcTrackPt>fPtMin;
 432                         Bool_t TrCharge     = (mcTrack->Charge())!=0;
 433
 434                         if (!TrIsPrime  && !TrPtMin && !TrCharge) continue;  //Check Point 1
 435
 436                         // V0 Generated level
 437                         Int_t mcPartPdg           = mcTrack->GetPdgCode();
 438
 439                         Double_t mcRapidity   = mcTrack->Y();
 440                         Bool_t V0RapMax       = TMath::Abs(mcRapidity)<fRapidityCut;
 441                         Double_t mcMass       = mcTrack->M();
 442
 443                         Double_t mcK0[3] = {mcTrackPt,mcMass,multiplicityMC};
 444                         Double_t mcLa[3] = {mcTrackPt,mcMass,multiplicityMC};
 445                         Double_t mcAl[3] = {mcTrackPt,mcMass,multiplicityMC};
 446
 447
 448                         Bool_t IsK0 = mcPartPdg==310;
 449                         if (IsK0 && V0RapMax && TrIsPrime)
 450                         {
 451                                 fHistMCGenK0->Fill(mcK0);
 452                         }
 453
 454                         Bool_t IsLambda = mcPartPdg==3122;
 455                         if (IsLambda && V0RapMax && TrIsPrime)
 456                         {
 457                                 fHistMCGenLAM->Fill(mcLa);
 458                         }
 459
 460                         Bool_t IsAntiLambda = mcPartPdg==-3122;
 461                         if (IsAntiLambda && V0RapMax && TrIsPrime)
 462                         {
 463                                 fHistMCGenALAM->Fill(mcAl);
 464                         }
 465                 }
 466     }
 467
 468         // End Loop over MC condition
 469
 470         //------------------------------------------------
 471         // Physics Selection
 472         //------------------------------------------------
 473         UInt_t maskIsSelected = inEvMain->IsEventSelected();
 474         Bool_t isSelected = ((maskIsSelected & AliVEvent::kMB)== AliVEvent::kMB
 475                                           || (maskIsSelected & AliVEvent::kCentral)== AliVEvent::kCentral
 476                                           || (maskIsSelected & AliVEvent::kSemiCentral)== AliVEvent::kSemiCentral);
 477     if (!isSelected) return;
 478
 479         //------------------------------------------------
 480         // After Trigger Selection
 481         //------------------------------------------------
 482
 483         fHist_Mult_Af_Trg_Sel->Fill(lPrimaryTrackMultiplicity);
 484
 485         //------------------------------------------------
 486         // Getting: Primary Vertex + MagField Info
 487         //------------------------------------------------
 488         Double_t  dimEventviceReal[3];
 489         Double_t  lBestPrimaryVtxPos[3];
 490         Double_t  tPrimaryVtxPosition[3];
 491         Double_t  lV0Position[3];
 492
 493
 494         if(fcollidingSys=="PbPb"){  //
 495         AliCentrality *centralityObj = fAODEvent->GetHeader()->GetCentralityP();
 496                 CentPecentAfterPhySel  = centralityObj->GetCentralityPercentileUnchecked("V0M");
 497                 if ((CentPecentAfterPhySel < 0.)||(CentPecentAfterPhySel > 90)) return;
 498         } //
 499
 500         AliAODVertex *lPrimaryBestAODVtx = fAODEvent->GetPrimaryVertex();
 501         if (!lPrimaryBestAODVtx) return;
 502         // get the best primary vertex available for the event
 503         // As done in AliCascadeVertexer, we keep the one which is the best one available.
 504         // between : Tracking vertex > SPD vertex > TPC vertex > default SPD vertex
 505         // This one will be used for next calculations (DCA essentially)
 506         lPrimaryBestAODVtx->GetXYZ(lBestPrimaryVtxPos);
 507
 508         const AliVVertex *primaryVtx = fAODEvent->GetPrimaryVertex();
 509         tPrimaryVtxPosition[0] = primaryVtx->GetX();
 510         tPrimaryVtxPosition[1] = primaryVtx->GetY();
 511         tPrimaryVtxPosition[2] = primaryVtx->GetZ();
 512         fHistPVx->Fill( tPrimaryVtxPosition[0] );
 513         fHistPVy->Fill( tPrimaryVtxPosition[1] );
 514         fHistPVz->Fill( tPrimaryVtxPosition[2] );
 515
 516         //------------------------------------------------
 517         // Primary Vertex Z position: SKIP
 518         //------------------------------------------------
 519
 520         Double_t lPVx = lBestPrimaryVtxPos[0];
 521         Double_t lPVy = lBestPrimaryVtxPos[1];
 522         Double_t lPVz = lBestPrimaryVtxPos[2];
 523
 524         if ((TMath::Abs(lPVz)) >= fpvzcut) return ;
 525         if (TMath::Abs(lPVx)<10e-5 && TMath::Abs(lPVy)<10e-5 && TMath::Abs(lPVz)<10e-5) return;
 526         fHist_Mult_PVz_Cut->Fill(lPrimaryTrackMultiplicity);
 527
 528         //------------------------------------------------
 529         // Only look at events with well-established PV
 530         //------------------------------------------------
 531
 532         const AliAODVertex *lPrimaryTrackingAODVtxCheck = fAODEvent->GetPrimaryVertex();
 533         const AliAODVertex *lPrimarySPDVtx = fAODEvent->GetPrimaryVertexSPD();
 534         if (!lPrimarySPDVtx && !lPrimaryTrackingAODVtxCheck )return;
 535
 536         fHist_Mult_SPD_PVz->Fill(lPrimaryTrackMultiplicity);
 537
 538
 539         //------------------------------------------------
 540         // Pileup Rejection
 541         //------------------------------------------------
 542
 543         // FIXME : quality selection regarding pile-up rejection
 544         if(fAODEvent->IsPileupFromSPD()) return;
 545         fHist_Mult_SPD_PVz_Pileup->Fill(lPrimaryTrackMultiplicity);
 546
 547         fHistPVxAnalysis->Fill(tPrimaryVtxPosition[0]);
 548         fHistPVyAnalysis->Fill(tPrimaryVtxPosition[1]);
 549         fHistPVzAnalysis->Fill(tPrimaryVtxPosition[2]);
 550
 551     dimEventviceReal[0]=tPrimaryVtxPosition[2];
 552         multiplicity       = fAODEvent->GetNTracks();
 553
 554         dimEventviceReal[1]=multiplicity;
 555         dimEventviceReal[2]=CentPecentAfterPhySel;
 556
 557         fHistEventViceReconst->Fill(dimEventviceReal);
 558
 559         if(fcollidingSys=="PP")MultipOrCent=multiplicity;
 560         if(fcollidingSys=="PbPb")MultipOrCent=CentPecentAfterPhySel;
 561
 562         //---------------------------------------------------------------------------------------------
 563
 564         Double_t lDcaPosToPrimVertex = 0;Double_t lDcaNegToPrimVertex = 0;Double_t lDcaV0Daughters     = 0;
 565         Double_t lV0cosPointAngle    = 0;Double_t lV0DecayLength      = 0;Double_t lV0Radius           = 0;
 566         Double_t lcTauLambda         = 0;Double_t lcTauAntiLambda     = 0;
 567         Double_t lcTauK0s            = 0;
 568
 569         Double_t lInvMassK0   = 0, lInvMassLambda    = 0, lInvMassAntiLambda = 0;
 570         Double_t lPtV0s       = 0; Double_t lPhiV0s  = 0; Double_t lEtaV0s   = 0;
 571         Double_t lRapK0s      = 0, lRapLambda        = 0, lRapAntiLambda     = 0;
 572         Double_t lPzV0s       = 0; Double_t lAlphaV0 = 0, lPtArmV0           = 0;
 573         Double_t lPV0s        = 0;
 574
 575         TObjArray *selectedTracksLeading=0;
 576         selectedTracksLeading=fAnalyseUE->FindLeadingObjects(fAODEvent);
 577         if(!selectedTracksLeading) return;
 578         selectedTracksLeading->SetOwner(kTRUE);
 579
 580         TObjArray * selectedV0s = new TObjArray;
 581         selectedV0s->SetOwner(kTRUE);
 582
 583         Int_t nV0s = fAODEvent->GetNumberOfV0s();
 584         cout << nV0s <<endl;
 585         for (Int_t i = 0; i < nV0s; i++)
 586         { // start of V0 slection loop
 587                 AliAODv0* aodV0 = dynamic_cast<AliAODv0 *>(fAODEvent->GetV0(i));
 588                 if (!aodV0) continue;
 589
 590                 if (((aodV0->Pt())<fPtMin)||((aodV0->Pt())>6.0)) continue;
 591
 592                 // get daughters
 593             AliAODTrack *myTrackPos=(AliAODTrack *)(aodV0->GetDaughter(0));
 594         AliAODTrack *myTrackNeg=(AliAODTrack *)(aodV0->GetDaughter(1));
 595
 596                 if (!myTrackPos || !myTrackNeg) {Printf("ERROR: Could not retreive one of the daughter track");continue;}
 597
 598         if (!IsAcseptedV0(aodV0,myTrackPos,myTrackNeg)) continue;
 599
 600                 // VO's main characteristics to check the reconstruction cuts
 601                 lDcaV0Daughters    = aodV0->DcaV0Daughters();
 602                 lV0cosPointAngle   = aodV0->CosPointingAngle(lBestPrimaryVtxPos);
 603
 604                 aodV0->GetXYZ(lV0Position);
 605
 606                 lV0Radius      = TMath::Sqrt(lV0Position[0]*lV0Position[0]+lV0Position[1]*lV0Position[1]);
 607                 lV0DecayLength = TMath::Sqrt(TMath::Power(lV0Position[0] - tPrimaryVtxPosition[0],2) +
 608                                                                          TMath::Power(lV0Position[1] - tPrimaryVtxPosition[1],2) +
 609                                                                          TMath::Power(lV0Position[2] - tPrimaryVtxPosition[2],2));
 610
 611                 // DCA between daughter and Primary Vertex:
 612                 if (myTrackPos) lDcaPosToPrimVertex = aodV0->DcaPosToPrimVertex();
 613                 if (myTrackNeg) lDcaNegToPrimVertex = aodV0->DcaNegToPrimVertex();
 614
 615                 // Quality tracks cuts:
 616                 if ( !(IsAcseptedDaughterTrack(myTrackPos)) || !(IsAcseptedDaughterTrack(myTrackNeg)) ) { continue;}
 617
 618                 // Armenteros variables:
 619                 lAlphaV0      =  aodV0->AlphaV0();
 620                 lPtArmV0      =  aodV0->PtArmV0();
 621
 622                 // Invariant mass
 623                 lInvMassK0         = aodV0->MassK0Short();
 624                 lInvMassLambda     = aodV0->MassLambda();
 625                 lInvMassAntiLambda = aodV0->MassAntiLambda();
 626
 627                 lPtV0s = aodV0->Pt();
 628                 lPhiV0s= aodV0->Phi();
 629                 lEtaV0s= aodV0->Eta();
 630                 lPzV0s = aodV0->Pz();
 631
 632                 // Rapidity:
 633                 lRapK0s    = aodV0->RapK0Short();
 634                 lRapLambda = aodV0->RapLambda();
 635                 lRapAntiLambda = aodV0->Y(-3122);
 636
 637                 if (lPtV0s==0) {continue;}
 638
 639         Float_t nSigmaPosPion   = 0.;
 640         Float_t nSigmaNegPion   = 0.;
 641         Float_t nSigmaPosProton = 0.;
 642         Float_t nSigmaNegProton = 0.;
 643
 644         const AliAODPid *pPid = myTrackPos->GetDetPid();
 645         const AliAODPid *nPid = myTrackNeg->GetDetPid();
 646
 647         if (pPid)
 648         {
 649             Double_t pdMom = pPid->GetTPCmomentum();
 650             if (pdMom<1.0 && (fcollidingSys=="PbPb"))
 651             {
 652                 nSigmaPosPion   = fPIDResponse->NumberOfSigmasTPC(myTrackPos, AliPID::kPion);
 653                 nSigmaPosProton = fPIDResponse->NumberOfSigmasTPC(myTrackPos, AliPID::kProton);
 654             }
 655
 656                         if (fcollidingSys=="PP")
 657             {
 658                 nSigmaPosPion   = fPIDResponse->NumberOfSigmasTPC(myTrackPos, AliPID::kPion);
 659                 nSigmaPosProton = fPIDResponse->NumberOfSigmasTPC(myTrackPos, AliPID::kProton);
 660             }
 661         }
 662
 663         if (nPid)
 664         {
 665             Double_t ndMom = nPid->GetTPCmomentum();
 666             if (ndMom<1.0 && (fcollidingSys=="PbPb"))
 667             {
 668                 nSigmaNegPion   = fPIDResponse->NumberOfSigmasTPC(myTrackNeg, AliPID::kPion);
 669                 nSigmaNegProton = fPIDResponse->NumberOfSigmasTPC(myTrackNeg, AliPID::kProton);
 670             }
 671
 672                         if (fcollidingSys=="PP")
 673             {
 674                 nSigmaNegPion   = fPIDResponse->NumberOfSigmasTPC(myTrackNeg, AliPID::kPion);
 675                 nSigmaNegProton = fPIDResponse->NumberOfSigmasTPC(myTrackNeg, AliPID::kProton);
 676             }
 677         }
 678                 Bool_t bpPion   = TMath::Abs(nSigmaPosPion)   <= fSigmaPID;
 679         Bool_t bpProton = TMath::Abs(nSigmaPosProton) <= fSigmaPID;
 680         Bool_t bnPion   = TMath::Abs(nSigmaNegPion)   <= fSigmaPID;
 681         Bool_t bnProton = TMath::Abs(nSigmaNegProton) <= fSigmaPID;
 682
 683         Bool_t cutK0Pid         = (bpPion   && bnPion)  ;
 684         Bool_t cutLambdaPid     = (bpProton && bnPion)  ;
 685         Bool_t cutAntiLambdaPid = (bpPion   && bnProton);
 686         //--------------------------------------------------
 687
 688                 lPV0s = TMath::Sqrt(lPzV0s*lPzV0s + lPtV0s*lPtV0s);
 689
 690                 if(lPV0s > 0) lcTauLambda     = (lV0DecayLength*lInvMassLambda)/lPV0s;
 691                 if(lPV0s > 0) lcTauAntiLambda = (lV0DecayLength*lInvMassAntiLambda)/lPV0s;
 692                 if(lPV0s > 0) lcTauK0s        = (lV0DecayLength*lInvMassK0)/lPV0s;
 693
 694                 Bool_t k0ctcut = (lcTauK0s        < fCutCTK0);
 695                 Bool_t lactcut = (lcTauLambda     < fCutCTLa);
 696                 Bool_t alactcut= (lcTauAntiLambda < fCutCTLa);
 697
 698                 Bool_t k0APcut = (lPtArmV0>(TMath::Abs(0.2*lAlphaV0)));
 699
 700                 Bool_t k0Rapcut = (TMath::Abs(lRapK0s)        < fRapidityCut);
 701                 Bool_t laRapcut = (TMath::Abs(lRapLambda)     < fRapidityCut);
 702                 Bool_t alaRapcut= (TMath::Abs(lRapAntiLambda) < fRapidityCut);
 703
 704                 if(fcollidingSys=="PbPb")if(lV0Radius>=100) continue;
 705
 706                 Bool_t k0cutset = IsAcseptedK0(lV0Radius,lDcaPosToPrimVertex,lDcaNegToPrimVertex,lDcaV0Daughters,lV0cosPointAngle,lInvMassLambda,lInvMassAntiLambda);
 707                 Bool_t lacutset = IsAcseptedLA(lV0Radius,lDcaPosToPrimVertex,lDcaNegToPrimVertex,lDcaV0Daughters,lV0cosPointAngle,lInvMassK0);
 708                 Bool_t alacutset= IsAcseptedLA(lV0Radius,lDcaNegToPrimVertex,lDcaPosToPrimVertex,lDcaV0Daughters,lV0cosPointAngle,lInvMassK0);
 709
 710                 Double_t spK0[3] = {lInvMassK0, lPtV0s,MultipOrCent};
 711                 Double_t spLa[3] = {lInvMassLambda,lPtV0s,MultipOrCent};
 712                 Double_t spAl[3] = {lInvMassAntiLambda,lPtV0s,MultipOrCent};
 713
 714                 switch (fCase) {
 715                         case 1:
 716                                 fHistReconstK0->Fill(spK0);
 717                                 if(IsK0InvMass(lInvMassK0))selectedV0s->Add(new V0Correlationparticle(lEtaV0s,lPhiV0s,lPtV0s,1));
 718
 719                                 fHistReconstLA->Fill(spLa);
 720                                 if(IsLambdaInvMass(lInvMassLambda))selectedV0s->Add(new V0Correlationparticle(lEtaV0s,lPhiV0s,lPtV0s,2));
 721
 722                                 fHistReconstALA->Fill(spAl);
 723                                 if(IsLambdaInvMass(lInvMassAntiLambda))selectedV0s->Add(new V0Correlationparticle(lEtaV0s,lPhiV0s,lPtV0s,3));
 724
 725                                 break;
 726
 727                         case 2:
 728                                 if(k0ctcut && k0Rapcut && k0cutset && cutK0Pid)
 729                                 {
 730                                         fHistReconstK0->Fill(spK0);
 731                                         if(IsK0InvMass(lInvMassK0))selectedV0s->Add(new V0Correlationparticle(lEtaV0s,lPhiV0s,lPtV0s,1));
 732                                 }
 733
 734                                 if (lactcut && laRapcut && lacutset && cutLambdaPid)
 735                                 {
 736                                         fHistReconstLA->Fill(spLa);
 737                                         if(IsLambdaInvMass(lInvMassLambda))selectedV0s->Add(new V0Correlationparticle(lEtaV0s,lPhiV0s,lPtV0s,2));
 738                                 }
 739
 740                                 if (alactcut && alaRapcut && alacutset && cutAntiLambdaPid)
 741                                 {
 742                                         fHistReconstALA->Fill(spAl);
 743                                         if(IsLambdaInvMass(lInvMassAntiLambda))selectedV0s->Add(new V0Correlationparticle(lEtaV0s,lPhiV0s,lPtV0s,3));
 744                                 }
 745
 746                                 break;
 747
 748                         case 3:
 749                                 if(k0ctcut && k0Rapcut && k0cutset && cutK0Pid && k0APcut)
 750                                 {
 751                                         fHistReconstK0->Fill(spK0);
 752                                         if(IsK0InvMass(lInvMassK0))selectedV0s->Add(new V0Correlationparticle(lEtaV0s,lPhiV0s,lPtV0s,1));
 753                                 }
 754
 755                                 if (lactcut && laRapcut && lacutset && cutLambdaPid)
 756                                 {
 757                                         fHistReconstLA->Fill(spLa);
 758                                         if(IsLambdaInvMass(lInvMassLambda))selectedV0s->Add(new V0Correlationparticle(lEtaV0s,lPhiV0s,lPtV0s,2));
 759                                 }
 760
 761                                 if (alactcut && alaRapcut && alacutset && cutAntiLambdaPid)
 762                                 {
 763                                         fHistReconstALA->Fill(spAl);
 764                                         if(IsLambdaInvMass(lInvMassAntiLambda))selectedV0s->Add(new V0Correlationparticle(lEtaV0s,lPhiV0s,lPtV0s,3));
 765                                 }
 766                                 break;
 767
 768                         default:
 769                                 AliInfo(Form("No case selected"));
 770                                 break;
 771                 }
 772
 773         if (fAnalysisMC)
 774         {
 775                 TClonesArray *mcArray = (TClonesArray*)fAODEvent->FindListObject(AliAODMCParticle::StdBranchName());
 776                 if(!mcArray)return;
 777
 778                         Int_t myTrackPosLabel        = TMath::Abs(myTrackPos->GetLabel());
 779                         Int_t myTrackNegLabel        = TMath::Abs(myTrackNeg->GetLabel());
 780
 781                         AliAODMCParticle *mcPosTrack = (AliAODMCParticle*)mcArray->At(myTrackPosLabel);
 782                         AliAODMCParticle *mcNegTrack = (AliAODMCParticle*)mcArray->At(myTrackNegLabel);
 783
 784                         Int_t PosDaughterPdg = mcPosTrack->GetPdgCode();
 785                         Int_t NegDaughterPdg = mcNegTrack->GetPdgCode();
 786
 787                         Int_t myTrackPosMotherLabel = mcPosTrack->GetMother();
 788                         Int_t myTrackNegMotherLabel = mcNegTrack->GetMother();
 789
 790                         if ((myTrackPosMotherLabel==-1)||(myTrackNegMotherLabel==-1)) continue;
 791                         if (myTrackPosMotherLabel!=myTrackNegMotherLabel) continue;
 792
 793                         AliAODMCParticle *mcPosMother = (AliAODMCParticle*)mcArray->At(myTrackPosMotherLabel);
 794                         Int_t MotherPdg  = mcPosMother->GetPdgCode();
 795                         Bool_t IsPrime   = mcPosMother->IsPhysicalPrimary();
 796
 797                         Double_t rcK0[3] = {lInvMassK0, lPtV0s,MultipOrCent};
 798                         Double_t rcLa[3] = {lInvMassLambda,lPtV0s,MultipOrCent};
 799                         Double_t rcAl[3] = {lInvMassAntiLambda,lPtV0s,MultipOrCent};
 800
 801                         switch (fCase) {
 802                                 case 1:
 803                                         fHistMCAssoK0->Fill(rcK0);
 804                                         fHistMCAssoLA->Fill(rcLa);
 805                                         fHistMCAssoALA->Fill(rcAl);
 806
 807                                         break;
 808
 809                                 case 2:
 810                                         if ((k0ctcut && k0Rapcut && k0cutset)&&(MotherPdg     ==  310 &&
 811                                                                                                                         PosDaughterPdg==  211 &&
 812                                                                                                                         NegDaughterPdg== -211 &&
 813                                                                                                                         IsPrime))
 814                                         {
 815                                                 fHistMCAssoK0->Fill(rcK0);
 816                                         }
 817
 818                                         if ((lactcut && laRapcut && lacutset)&&(MotherPdg     == 3122 &&
 819                                                                                                                         PosDaughterPdg== 2212 &&
 820                                                                                                                         NegDaughterPdg== -211 &&
 821                                                                                                                         IsPrime))
 822                                         {
 823                                                 fHistMCAssoLA->Fill(rcLa);
 824                                         }
 825
 826                                         if ((alactcut && alaRapcut && alacutset)&&(MotherPdg     == -3122 &&
 827                                                                                                                            PosDaughterPdg==   211 &&
 828                                                                                                                            NegDaughterPdg== -2212 &&
 829                                                                                                                            IsPrime))
 830                                         {
 831                                                 fHistMCAssoALA->Fill(rcAl);
 832                                         }
 833
 834                                         break;
 835
 836                                 case 3:
 837                                         if ((k0ctcut && k0Rapcut && k0cutset && k0APcut)&&(MotherPdg     ==  310 &&
 838                                                                                                                                            PosDaughterPdg==  211 &&
 839                                                                                                                                            NegDaughterPdg== -211 &&
 840                                                                                                                                            IsPrime))
 841                                         {
 842                                                 fHistMCAssoK0->Fill(rcK0);
 843                                         }
 844
 845                                         if ((lactcut && laRapcut && lacutset)&&(MotherPdg     == 3122 &&
 846                                                                                                                         PosDaughterPdg== 2212 &&
 847                                                                                                                         NegDaughterPdg== -211 &&
 848                                                                                                                         IsPrime))
 849                                         {
 850                                                 fHistMCAssoLA->Fill(rcLa);
 851                                         }
 852
 853                                         if ((alactcut && alaRapcut && alacutset)&&(MotherPdg     == -3122 &&
 854                                                                                                                            PosDaughterPdg==   211 &&
 855                                                                                                                            NegDaughterPdg== -2212 &&
 856                                                                                                                            IsPrime))
 857                                         {
 858                                                 fHistMCAssoALA->Fill(rcAl);
 859                                         }
 860                                         break;
 861
 862                                 default:
 863                                         AliInfo(Form("No case selected"));
 864                                         break;
 865                         }
 866         }
 867         }
 868
 869         FillCorrelationSibling(MultipOrCent,selectedTracksLeading,selectedV0s,fHistTriggerSib,fHistReconstSib);
 870         FillCorrelationMixing(MultipOrCent,tPrimaryVtxPosition[2],poolmax,poolmin,selectedTracksLeading,selectedV0s,fHistTriggerMix,fHistReconstMix);
 871
 872         PostData(1,fOutputList);
 873 }
 874 //---------------------------------------------------------------------------------------
 875 void AliLeadingV0Correlation::Terminate(Option_t *)
 876 {
 877         //No need in the grid
 878 }
 879 //---------------------------------------------------------------------------------------
 880 Bool_t AliLeadingV0Correlation::IsAcseptedDaughterTrack(const AliAODTrack *itrack)
 881 {
 882         if(TMath::Abs(itrack->Eta())>fTrackEtaCut)return kFALSE;
 883
 884         if (!itrack->IsOn(AliAODTrack::kTPCrefit)) return kFALSE;
 885
 886         Float_t nCrossedRowsTPC = itrack->GetTPCClusterInfo(2,1);
 887         if (nCrossedRowsTPC < 70) return kFALSE;
 888
 889         Int_t findable=itrack->GetTPCNclsF();
 890         if (findable <= 0) return kFALSE;
 891
 892         if (nCrossedRowsTPC/findable < 0.8) return kFALSE;
 893         return kTRUE;
 894 }
 895 //---------------------------------------------------------------------------------------
 896 Bool_t AliLeadingV0Correlation::IsAcseptedV0(const AliAODv0* aodV0, const AliAODTrack* myTrackPos, const AliAODTrack* myTrackNeg)
 897 {
 898         if (!aodV0) return kFALSE;
 899
 900         // Offline reconstructed V0 only
 901     if (aodV0->GetOnFlyStatus()) return kFALSE;
 902
 903     // Get daughters and check them
 904         myTrackPos=(AliAODTrack *)(aodV0->GetDaughter(0));
 905         myTrackNeg=(AliAODTrack *)(aodV0->GetDaughter(1));
 906
 907         if (!myTrackPos||!myTrackNeg) return kFALSE;
 908         // Unlike signs of daughters
 909     if (myTrackPos->Charge() == myTrackNeg->Charge()) return kFALSE;
 910
 911         // Track cuts for daughers
 912     if ( !(IsAcseptedDaughterTrack(myTrackPos)) || !(IsAcseptedDaughterTrack(myTrackNeg)) ) return kFALSE;
 913
 914         // Minimum pt of daughters
 915     Double_t lPtPos = myTrackPos->Pt();
 916     Double_t lPtNeg = myTrackNeg->Pt();
 917
 918         if (lPtPos<fPtMin || lPtNeg<fPtMin) return kFALSE;
 919
 920         return kTRUE;
 921 }
 922 //---------------------------------------------------------------------------------------
 923 Bool_t AliLeadingV0Correlation::IsAcseptedK0(Double_t v0rad,
 924                                                         Double_t dcaptp,
 925                                                         Double_t dcantp,
 926                                                         Double_t dcav0d,
 927                                                         Double_t cpa,
 928                                                         Double_t massLa,
 929                                                         Double_t massALa)
 930 {
 931                         if(v0rad  >=fV0radius           &&
 932                            dcaptp >=fV0PostoPVz         &&
 933                            dcantp >=fV0NegtoPVz         &&
 934                            dcav0d <=fDCAV0Daughters     &&
 935                            cpa    >=fCPAK0                      &&
 936                            TMath::Abs(massLa  - 1.115683) > fRejectLamK0 &&
 937                            TMath::Abs(massALa - 1.115683) > fRejectLamK0 )return kTRUE;
 938         return kFALSE;
 939 }
 940 //---------------------------------------------------------------------------------------
 941 Bool_t AliLeadingV0Correlation::IsAcseptedLA(Double_t v0rad,
 942                                                         Double_t dcaptp,
 943                                                         Double_t dcantp,
 944                                                         Double_t dcav0d,
 945                                                         Double_t cpa,
 946                                                         Double_t massK0)
 947 {
 948         if(v0rad  >=fV0radius           &&
 949            dcaptp >=fV0PostoPVz         &&
 950            dcantp >=fV0NegtoPVz         &&
 951            dcav0d <=fDCAV0Daughters     &&
 952            cpa    >=fCPALam                     &&
 953            TMath::Abs(massK0  - 0.4976) > fRejectK0Lam &&
 954            TMath::Abs(massK0  - 0.4976) > fRejectK0Lam )return kTRUE;
 955         return kFALSE;
 956 }
 957 //---------------------------------------------------------------------------------------
 958 Bool_t AliLeadingV0Correlation::IsK0InvMass(const Double_t mass) const
 959 {
 960         const Float_t massK0            = 0.497;
 961
 962         return ((massK0-fMassCutK0)<=mass && mass<=(massK0 + fMassCutK0))?1:0;
 963 }
 964 //---------------------------------------------------------------------------------------
 965 Bool_t AliLeadingV0Correlation::IsLambdaInvMass(const Double_t mass) const
 966 {
 967         const Float_t massLambda        = 1.116;
 968
 969         return ((massLambda-fMassCutLa)<=mass && mass<=(massLambda + fMassCutLa))?1:0;
 970 }
 971 //---------------------------------------------------------------------------------------
 972 Double_t AliLeadingV0Correlation::RangePhi(Double_t DPhi)
 973 {
 974         if (DPhi < -TMath::Pi()/2)  DPhi += 2*TMath::Pi();
 975         if (DPhi > 3*TMath::Pi()/2) DPhi -= 2*TMath::Pi();
 976         return DPhi;
 977 }
 978 //---------------------------------------------------------------------------------------
 979 Bool_t AliLeadingV0Correlation::IsTrackFromV0(AliAODTrack* track)
 980 {
 981         Int_t atrID = track->GetID();
 982
 983         for(int i=0; i<fAODEvent->GetNumberOfV0s(); i++){ // loop over V0s
 984                 AliAODv0* aodV0 = fAODEvent->GetV0(i);
 985
 986                 AliAODTrack *trackPos=(AliAODTrack *)(aodV0->GetDaughter(0));
 987         AliAODTrack *trackNeg=(AliAODTrack *)(aodV0->GetDaughter(1));
 988
 989                 if ( !(IsAcseptedDaughterTrack(trackPos)) || !(IsAcseptedDaughterTrack(trackNeg)) ) continue;
 990                 //----------------------------------
 991                 Int_t negID = trackNeg->GetID();
 992                 Int_t posID = trackPos->GetID();
 993
 994                 if ((TMath::Abs(negID)+1)==(TMath::Abs(atrID))){ return kTRUE;}
 995                 if ((TMath::Abs(posID)+1)==(TMath::Abs(atrID))){ return kTRUE;}
 996                 //----------------------------------
 997         }
 998         return kFALSE;
 999 }
1000 //---------------------------------------------------------------------------------------
1001 void AliLeadingV0Correlation::FillCorrelationSibling(Double_t MultipOrCent,
1002                                                                           TObjArray*triggerArray,
1003                                                                           TObjArray*selectedV0Array,
1004                                                                           THnSparse*triggerHist,
1005                                                                           THnSparse*associateHist)
1006 {
1007         Double_t  binsv0CORR[7];
1008         Double_t  binsTrigSib[2];
1009         Int_t counterSibMCA=0;
1010
1011     for(Int_t i=0;i<triggerArray->GetEntriesFast();i++)
1012         {
1013                 AliAODTrack* trigger = (AliAODTrack*)triggerArray->At(0);
1014                 if(!trigger)continue;
1015
1016                 if(fRemoveAutoCorr)
1017                 if(IsTrackFromV0(trigger))continue;
1018
1019                 Double_t triggerPt  = trigger->Pt();
1020                 Double_t triggerPhi = trigger->Phi();
1021                 Double_t triggerEta = trigger->Eta();
1022
1023                 if(triggerPt<fTriglow||triggerPt>fTrighigh)continue;
1024                 counterSibMCA++;
1025
1026                 if(counterSibMCA==triggerArray->GetEntriesFast()){
1027
1028                         binsTrigSib[0]=triggerPt;
1029                         binsTrigSib[1]=MultipOrCent;
1030
1031                         if(triggerHist)triggerHist->Fill(binsTrigSib);
1032
1033                         for (Int_t j=0; j<selectedV0Array->GetEntriesFast(); j++){
1034
1035                                 V0Correlationparticle* associate = (V0Correlationparticle*) selectedV0Array->At(j);
1036                                 if(!associate)continue;
1037
1038                                 binsv0CORR[0]= associate->Pt();
1039                                 binsv0CORR[1]= associate->Phi();
1040                                 binsv0CORR[2]= associate->Eta();
1041
1042                                 if(binsv0CORR[0]>triggerPt) continue;
1043
1044                                 binsv0CORR[3]=RangePhi(triggerPhi-binsv0CORR[1]);
1045                                 binsv0CORR[4]=triggerEta-binsv0CORR[2];
1046                                 binsv0CORR[5]= associate->WhichCandidate();
1047                                 binsv0CORR[6]= MultipOrCent;
1048
1049                                 associateHist->Fill(binsv0CORR);
1050                         }
1051                   }
1052                 }
1053 }
1054 //---------------------------------------------------------------------------------------
1055 void AliLeadingV0Correlation::FillCorrelationMixing(Double_t MultipOrCentMix,
1056                                                                    Double_t pvxMix,
1057                                                                    Double_t poolmax,
1058                                                                    Double_t poolmin,
1059                                                                    TObjArray*triggerArray,
1060                                                                    TObjArray*selectedV0Array,
1061                                                                    THnSparse*triggerHist,
1062                                                                    THnSparse*associateHist)
1063 {
1064         if(TMath::Abs(pvxMix)>=fpvzcut || MultipOrCentMix>poolmax || MultipOrCentMix < poolmin)
1065         {
1066                 if(fcollidingSys=="PP")AliInfo(Form("pp Event with Zvertex = %.2f cm and multiplicity = %.0f out of pool bounds, SKIPPING",pvxMix,MultipOrCentMix));
1067                 if(fcollidingSys=="PbPb") AliInfo(Form("PbPb Event with Zvertex = %.2f cm and centrality = %.1f  out of pool bounds, SKIPPING",pvxMix,MultipOrCentMix));
1068                 return;
1069         }
1070
1071         Double_t  binsv0CORRMix[7];
1072         Double_t  binsTrigMix[2];
1073         Double_t  counterMix=0;
1074
1075         AliEventPool* pool = fPoolMgr->GetEventPool(MultipOrCentMix, pvxMix);
1076         if (!pool) AliFatal(Form("No pool found for centrality = %f, zVtx = %f", MultipOrCentMix, pvxMix));
1077
1078     if (pool->IsReady() || pool->NTracksInPool() > fPoolMinNTracks  || pool->GetCurrentNEvents() > fMinEventsToMix)
1079         {
1080                 Int_t nMix = pool->GetCurrentNEvents();
1081                 for (Int_t jMix=0; jMix<nMix; jMix++){
1082
1083                         TObjArray* mixEvents = pool->GetEvent(jMix);
1084                         for (Int_t i=0; i<triggerArray->GetEntriesFast(); i++){
1085
1086                                 AliAODTrack* trig = (AliAODTrack*)triggerArray->At(0);
1087                                 if(!trig)continue;
1088
1089                                 if(fRemoveAutoCorr)
1090                                 if(IsTrackFromV0(trig))continue;
1091
1092                                 Double_t trigPhi  = trig->Phi();
1093                                 Double_t trigEta  = trig->Eta();
1094                                 Double_t trigPt   = trig->Pt();
1095
1096                                 if(trigPt<fTriglow||trigPt>fTrighigh)continue;
1097                                 counterMix++;
1098
1099                                 if(counterMix==triggerArray->GetEntriesFast()){
1100
1101                                         binsTrigMix[0]=trigPt;
1102                                         binsTrigMix[1]=MultipOrCentMix;
1103
1104                                         if(triggerHist)triggerHist->Fill(binsTrigMix);
1105
1106                                         for (Int_t j=0; j<mixEvents->GetEntriesFast(); j++){
1107
1108                                                 V0Correlationparticle* associate = (V0Correlationparticle*) mixEvents->At(j);
1109                                                 if(!associate)continue;
1110
1111                                                 binsv0CORRMix[0]= associate->Pt();
1112                                                 binsv0CORRMix[1]= associate->Phi();
1113                                                 binsv0CORRMix[2]= associate->Eta();
1114
1115                                                 if(binsv0CORRMix[0]>trigPt) continue;
1116
1117                                                 binsv0CORRMix[3]=RangePhi(trigPhi-binsv0CORRMix[1]);
1118                                                 binsv0CORRMix[4]=trigEta-binsv0CORRMix[2];
1119                                                 binsv0CORRMix[5]=associate->WhichCandidate();
1120                                                 binsv0CORRMix[6]=MultipOrCentMix;
1121
1122                                                 associateHist->Fill(binsv0CORRMix);
1123                                                 }
1124                                         }
1125                                 }
1126                         }
1127                 }
1128
1129         TObjArray* tracksClone = new TObjArray;
1130         tracksClone->SetOwner(kTRUE);
1131
1132         for (Int_t i=0; i<selectedV0Array->GetEntriesFast(); i++)
1133         {
1134                 V0Correlationparticle* particle = (V0Correlationparticle*) selectedV0Array->At(i);
1135                 tracksClone->Add(new V0Correlationparticle(particle->Eta(),
1136                                                                                           particle->Phi(),
1137                                                                                           particle->Pt(),
1138                                                                                           particle->WhichCandidate()));
1139         };
1140         pool->UpdatePool(tracksClone);
1141 }
1142 //---------------------------------------------------------------------------------------
1143
1144
1145
1146