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