AliPhysics  vAN-20150807 (6e57b21)
 All Classes Namespaces Files Functions Variables Enumerations Enumerator Macros
AliAnaParticleHadronCorrelation.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: The ALICE Off-line Project. *
5  * Contributors are mentioned in the code where appropriate. *
6  * *
7  * Permission to use, copy, modify and distribute this software and its *
8  * documentation strictly for non-commercial purposes is hereby granted *
9  * without fee, provided that the above copyright notice appears in all *
10  * copies and that both the copyright notice and this permission notice *
11  * appear in the supporting documentation. The authors make no claims *
12  * about the suitability of this software for any purpose. It is *
13  * provided "as is" without express or implied warranty. *
14  **************************************************************************/
15 
16 // --- ROOT system ---
17 #include <TClass.h>
18 #include <TMath.h>
19 #include <TH2F.h>
20 #include <TDatabasePDG.h>
21 #include "TParticle.h"
22 #include <TClonesArray.h>
23 #include <TList.h>
24 #include <TObjString.h>
25 
26 //---- ANALYSIS system ----
29 #include "AliCaloTrackReader.h"
30 #include "AliAODPWG4ParticleCorrelation.h"
31 #include "AliFiducialCut.h"
32 #include "AliVTrack.h"
33 #include "AliVCluster.h"
34 #include "AliMCAnalysisUtils.h"
35 #include "TParticle.h"
36 #include "AliStack.h"
37 #include "AliAODMCParticle.h"
38 #include "AliMixedEvent.h"
39 #include "AliAnalysisManager.h"
40 #include "AliInputEventHandler.h"
41 #include "AliEventplane.h"
42 #include "AliIsolationCut.h"
43 #include "AliESDEvent.h"
44 #include "AliAODEvent.h"
45 
46 // --- Detectors ---
47 #include "AliEMCALGeometry.h"
48 #include "AliPHOSGeoUtils.h"
49 
53 
54 
55 //___________________________________________________________________
57 //___________________________________________________________________
60 fFillAODWithReferences(0), fCheckLeadingWithNeutralClusters(0),
61 fMaxAssocPt(1000.), fMinAssocPt(0.),
62 fDeltaPhiMaxCut(0.), fDeltaPhiMinCut(0.),
63 fSelectIsolated(0), fMakeSeveralUE(0),
64 fUeDeltaPhiMaxCut(0.), fUeDeltaPhiMinCut(0.),
65 fPi0AODBranchName(""), fAODNamepTInConeHisto(""), fNeutralCorr(0),
66 fPi0Trigger(0), fDecayTrigger(0),
67 fNDecayBits(0), fDecayBits(),
68 fNBkgBin(0),
69 fMakeAbsoluteLeading(0), fMakeNearSideLeading(0),
70 fLeadingTriggerIndex(-1), fHMPIDCorrelation(0), fFillBradHisto(0),
71 fNAssocPtBins(0), fAssocPtBinLimit(),
72 fCorrelVzBin(0),
73 fListMixTrackEvents(), fListMixCaloEvents(),
74 fUseMixStoredInReader(0), fFillNeutralEventMixPool(0),
75 fM02MaxCut(0), fM02MinCut(0),
76 fSelectLeadingHadronAngle(0), fFillLeadHadOppositeHisto(0),
77 fMinLeadHadPhi(0), fMaxLeadHadPhi(0),
78 fMinLeadHadPt(0), fMaxLeadHadPt(0),
79 fFillEtaGapsHisto(1), fFillMomImbalancePtAssocBinsHisto(0),
80 fFillInvMassHisto(0), fFillBkgBinsHisto(0),
81 fFillTaggedDecayHistograms(0), fDecayTagsM02Cut(0),
82 fMCGenTypeMin(0), fMCGenTypeMax(0),
83 fTrackVector(), fMomentum(), fMomentumIM(),
84 fDecayMom1(), fDecayMom2(),
85 //Histograms
86 fhPtTriggerInput(0), fhPtTriggerSSCut(0),
87 fhPtTriggerIsoCut(0), fhPtTriggerFidCut(0),
88 fhPtTrigger(0), fhPtTriggerVtxBC0(0),
89 fhPtTriggerVzBin(0), fhPtTriggerBin(0),
90 fhPhiTrigger(0), fhEtaTrigger(0),
91 fhPtTriggerMC(),
92 fhPtDecayTrigger(), fhPtDecayTriggerMC(),
93 fhPtTriggerCentrality(0), fhPtTriggerEventPlane(0),
94 fhTriggerEventPlaneCentrality(0),
95 fhPtTriggerMixed(0), fhPtTriggerMixedVzBin(0), fhPtTriggerMixedBin(0),
96 fhPhiTriggerMixed(0), fhEtaTriggerMixed(0),
97 fhPtLeadingOppositeHadron(0), fhPtDiffPhiLeadingOppositeHadron(0), fhPtDiffEtaLeadingOppositeHadron(0),
98 fhPtNoLeadingOppositeHadron(0), fhEtaPhiNoLeadingOppositeHadron(0),
99 fhDeltaPhiDeltaEtaCharged(0),
100 fhPhiCharged(0), fhEtaCharged(0),
101 fhDeltaPhiCharged(0), fhDeltaEtaCharged(0),
102 fhDeltaPhiChargedPt(0), fhDeltaPhiUeChargedPt(0),
103 fhUePart(0),
104 fhXECharged(0), fhXECharged_Cone2(0), fhXEUeCharged(0),
105 fhXEPosCharged(0), fhXENegCharged(0),
106 fhPtHbpXECharged(0), fhPtHbpXECharged_Cone2(0), fhPtHbpXEUeCharged(0),
107 fhZTCharged(0), fhZTUeCharged(0),
108 fhZTPosCharged(0), fhZTNegCharged(0),
109 fhPtHbpZTCharged(0), fhPtHbpZTUeCharged(0),
110 fhXEChargedMC(), fhDeltaPhiChargedMC(),
111 fhXEUeChargedRightMC(), fhXEUeChargedLeftMC(),
112 fhDeltaPhiDeltaEtaChargedPtA3GeV(0),
113 fhDeltaPhiChargedPtA3GeV(0), fhDeltaEtaChargedPtA3GeV(0),
114 // Pile-Up
115 fhDeltaPhiChargedPileUp(), fhDeltaEtaChargedPileUp(),
116 fhDeltaPhiChargedPtA3GeVPileUp(), fhDeltaEtaChargedPtA3GeVPileUp(),
117 fhXEChargedPileUp(), fhXEUeChargedPileUp(),
118 fhZTChargedPileUp(), fhZTUeChargedPileUp(),
119 fhPtTrigChargedPileUp(),
120 fhDeltaPhiChargedOtherBC(), fhDeltaPhiChargedPtA3GeVOtherBC(),
121 fhXEChargedOtherBC(), fhXEUeChargedOtherBC(),
122 fhZTChargedOtherBC(), fhZTUeChargedOtherBC(),
123 fhPtTrigChargedOtherBC(),
124 fhDeltaPhiChargedBC0(), fhDeltaPhiChargedPtA3GeVBC0(),
125 fhXEChargedBC0(), fhXEUeChargedBC0(),
126 fhZTChargedBC0(), fhZTUeChargedBC0(),
127 fhPtTrigChargedBC0(),
128 fhDeltaPhiChargedVtxBC0(), fhDeltaPhiChargedPtA3GeVVtxBC0(),
129 fhXEChargedVtxBC0(), fhXEUeChargedVtxBC0(),
130 fhZTChargedVtxBC0(), fhZTUeChargedVtxBC0(),
131 fhPtTrigChargedVtxBC0(),
132 fhDeltaPhiUeLeftCharged(0),
133 fhDeltaPhiUeLeftUpCharged(0), fhDeltaPhiUeRightUpCharged(0),
134 fhDeltaPhiUeLeftDownCharged(0), fhDeltaPhiUeRightDownCharged(0),
135 fhXEUeLeftCharged(0),
136 fhXEUeLeftUpCharged(0), fhXEUeRightUpCharged(0),
137 fhXEUeLeftDownCharged(0), fhXEUeRightDownCharged(0),
138 fhPtHbpXEUeLeftCharged(0), fhZTUeLeftCharged(0),
139 fhPtHbpZTUeLeftCharged(0),
140 fhPtTrigPout(0), fhPtTrigCharged(0),
141 fhDeltaPhiChargedMult(0x0), fhDeltaEtaChargedMult(0x0),
142 fhXEMult(0x0), fhXEUeMult(0x0),
143 fhZTMult(0x0), fhZTUeMult(0x0),
144 fhAssocPtBkg(0), fhDeltaPhiDeltaEtaAssocPtBin(0),
145 fhDeltaPhiAssocPtBin(0),
146 fhDeltaPhiAssocPtBinDEta08(0), fhDeltaPhiAssocPtBinDEta0(0),
147 fhDeltaPhiAssocPtBinHMPID(0), fhDeltaPhiAssocPtBinHMPIDAcc(0),
148 fhDeltaPhiBradAssocPtBin(0), fhDeltaPhiBrad(0),
149 fhXEAssocPtBin(0), fhZTAssocPtBin(0),
150 fhXEVZ(0), fhZTVZ(0),
151 fhDeltaPhiDeltaEtaNeutral(0),
152 fhPhiNeutral(0), fhEtaNeutral(0),
153 fhDeltaPhiNeutral(0), fhDeltaEtaNeutral(0),
154 fhDeltaPhiNeutralPt(0), fhDeltaPhiUeNeutralPt(0),
155 fhXENeutral(0), fhXEUeNeutral(0),
156 fhPtHbpXENeutral(0), fhPtHbpXEUeNeutral(0),
157 fhZTNeutral(0), fhZTUeNeutral(0),
158 fhPtHbpZTNeutral(0), fhPtHbpZTUeNeutral(0),
159 fhDeltaPhiUeLeftNeutral(0), fhXEUeLeftNeutral(0),
160 fhPtHbpXEUeLeftNeutral(0), fhZTUeLeftNeutral(0),
161 fhPtHbpZTUeLeftNeutral(0), fhPtPi0DecayRatio(0),
162 fhDeltaPhiPi0DecayCharged(0), fhXEPi0DecayCharged(0), fhZTPi0DecayCharged(0),
163 fhDeltaPhiPi0DecayNeutral(0), fhXEPi0DecayNeutral(0), fhZTPi0DecayNeutral(0),
164 fhDeltaPhiDecayCharged(), fhXEDecayCharged(), fhZTDecayCharged(),
165 fhDeltaPhiDecayChargedAssocPtBin(),
166 fhMCPtTrigger(), fhMCPhiTrigger(), fhMCEtaTrigger(),
167 fhMCPtTriggerNotLeading(), fhMCPhiTriggerNotLeading(), fhMCEtaTriggerNotLeading(),
168 fhMCEtaCharged(), fhMCPhiCharged(),
169 fhMCDeltaEtaCharged(), fhMCDeltaPhiCharged(),
170 fhMCDeltaPhiDeltaEtaCharged(), fhMCDeltaPhiChargedPt(),
171 fhMCPtXECharged(), fhMCPtXEUeCharged(),
172 fhMCPtXEUeLeftCharged(),
173 fhMCPtHbpXECharged(), fhMCPtHbpXEUeCharged(),
174 fhMCPtHbpXEUeLeftCharged(),
175 fhMCUePart(),
176 fhMCPtZTCharged(), fhMCPtZTUeCharged(),
177 fhMCPtZTUeLeftCharged(),
178 fhMCPtHbpZTCharged(), fhMCPtHbpZTUeCharged(),
179 fhMCPtHbpZTUeLeftCharged(),
180 fhMCPtTrigPout(), fhMCPtAssocDeltaPhi(),
181 // Mixing
182 fhNEventsTrigger(0), fhNtracksMB(0), fhNclustersMB(0),
183 fhMixDeltaPhiCharged(0), fhMixDeltaPhiDeltaEtaCharged(0),
184 fhMixXECharged(0), fhMixXEUeCharged(0), fhMixHbpXECharged(0),
185 fhMixDeltaPhiChargedAssocPtBin(),
186 fhMixDeltaPhiChargedAssocPtBinDEta08(),
187 fhMixDeltaPhiChargedAssocPtBinDEta0(),
188 fhMixDeltaPhiDeltaEtaChargedAssocPtBin(),
189 fhEventBin(0), fhEventMixBin(0), fhEventMBBin(0),
190 fhMassPtTrigger(0), fhMCMassPtTrigger(),
191 fhPtLeadInConeBin(), fhPtSumInConeBin(),
192 fhPtLeadConeBinDecay(), fhSumPtConeBinDecay(),
193 fhPtLeadConeBinMC(), fhSumPtConeBinMC()
194 {
195  InitParameters();
196 
197  for(Int_t i = 0; i < fgkNmcTypes; i++)
198  {
199  fhPtTriggerMC[i] = 0;
200  fhXEChargedMC[i] = 0;
201  fhDeltaPhiChargedMC[i] = 0;
202  fhMCMassPtTrigger [i] = 0 ;
203  fhXEUeChargedRightMC[i] = 0;
204  fhXEUeChargedLeftMC[i] = 0;
205 
206  for(Int_t ib = 0; ib < AliNeutralMesonSelection::fgkMaxNDecayBits; ib++) fhPtDecayTriggerMC[ib][i] = 0;
207  }
208 
209  for(Int_t ib = 0; ib < AliNeutralMesonSelection::fgkMaxNDecayBits; ib++) fhPtDecayTrigger[ib] = 0;
210 
211  for(Int_t i = 0; i < 7; i++)
212  {
213  fhPtTriggerPileUp [i] = 0 ;
215  fhXEChargedPileUp [i] = 0 ; fhXEUeChargedPileUp [i] = 0 ;
216  fhZTChargedPileUp [i] = 0 ; fhZTUeChargedPileUp [i] = 0 ;
217  fhPtTrigChargedPileUp [i] = 0 ;
219  }
220 }
221 
222 //_________________________________________________________________
224 //_________________________________________________________________
226 {
227  if(DoOwnMix())
228  {
230  {
231  for(Int_t iz=0; iz < GetNZvertBin(); iz++)
232  {
233  for(Int_t ic=0; ic < GetNCentrBin(); ic++)
234  {
235  for(Int_t irp=0; irp<GetNRPBin(); irp++)
236  {
237  Int_t bin = GetEventMixBin(ic, iz, irp);
238  fListMixTrackEvents[bin]->Delete() ;
239  delete fListMixTrackEvents[bin] ;
240  }
241  }
242  }
243  }
244 
245  delete[] fListMixTrackEvents;
246 
248  {
249  for(Int_t iz=0; iz < GetNZvertBin(); iz++)
250  {
251  for(Int_t ic=0; ic < GetNCentrBin(); ic++)
252  {
253  for(Int_t irp=0; irp<GetNRPBin(); irp++)
254  {
255  Int_t bin = GetEventMixBin(ic, iz, irp);
256  fListMixCaloEvents[bin]->Delete() ;
257  delete fListMixCaloEvents[bin] ;
258  }
259  }
260  }
261  }
262 
263  delete[] fListMixCaloEvents;
264  }
265 }
266 
267 //____________________________________________________________________________________________________________________________________
269 //____________________________________________________________________________________________________________________________________
270 void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(Float_t ptAssoc, Float_t ptTrig, Int_t bin,
271  Float_t phiAssoc, Float_t phiTrig, Float_t deltaPhi,
272  Float_t etaAssoc, Float_t etaTrig,
273  Int_t decayTag, Float_t hmpidSignal, Int_t outTOF,
274  Int_t cen, Int_t mcTag)
275 {
276  Float_t deltaEta = etaTrig-etaAssoc;
277  Float_t deltaPhiOrg = phiTrig-phiAssoc;
278 
279  fhEtaCharged ->Fill(ptAssoc, etaAssoc, GetEventWeight());
280  fhPhiCharged ->Fill(ptAssoc, phiAssoc, GetEventWeight());
281  fhDeltaEtaCharged ->Fill(ptTrig , deltaEta, GetEventWeight());
282  fhDeltaPhiCharged ->Fill(ptTrig , deltaPhi, GetEventWeight());
283  fhDeltaPhiChargedPt->Fill(ptAssoc, deltaPhi, GetEventWeight());
284  fhDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta, GetEventWeight());
285 
286  if(ptAssoc > 3 )
287  {
288  fhDeltaEtaChargedPtA3GeV ->Fill(ptTrig , deltaEta, GetEventWeight());
289  fhDeltaPhiChargedPtA3GeV ->Fill(ptTrig , deltaPhi, GetEventWeight());
290  fhDeltaPhiDeltaEtaChargedPtA3GeV->Fill(deltaPhi, deltaEta, GetEventWeight());
291  }
292 
293  // Pile up studies
294 
295  if(IsPileUpAnalysisOn())
296  {
297  if (outTOF==1)
298  {
299  fhDeltaPhiChargedOtherBC->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
300  if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVOtherBC->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
301  }
302  else if(outTOF==0)
303  {
304  fhDeltaPhiChargedBC0->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
305  if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVBC0->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
306  }
307 
308  Int_t vtxBC = GetReader()->GetVertexBC();
309  if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
310  {
311  fhDeltaPhiChargedVtxBC0->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
312  if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVVtxBC0->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
313  }
314 
315  if(GetReader()->IsPileUpFromSPD())
316  {
317  fhDeltaEtaChargedPileUp[0]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
318  fhDeltaPhiChargedPileUp[0]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
319  }
320  if(GetReader()->IsPileUpFromEMCal())
321  {
322  fhDeltaEtaChargedPileUp[1]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
323  fhDeltaPhiChargedPileUp[1]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
324  }
325  if(GetReader()->IsPileUpFromSPDOrEMCal())
326  {
327  fhDeltaEtaChargedPileUp[2]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
328  fhDeltaPhiChargedPileUp[2]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
329  }
330  if(GetReader()->IsPileUpFromSPDAndEMCal())
331  {
332  fhDeltaEtaChargedPileUp[3]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
333  fhDeltaPhiChargedPileUp[3]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
334  }
335  if(GetReader()->IsPileUpFromSPDAndNotEMCal())
336  {
337  fhDeltaEtaChargedPileUp[4]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
338  fhDeltaPhiChargedPileUp[4]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
339  }
340  if(GetReader()->IsPileUpFromEMCalAndNotSPD())
341  {
342  fhDeltaEtaChargedPileUp[5]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
343  fhDeltaPhiChargedPileUp[5]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
344  }
345  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal())
346  {
347  fhDeltaEtaChargedPileUp[6]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
348  fhDeltaPhiChargedPileUp[6]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
349  }
350 
351  if(ptAssoc > 3 )
352  {
353  if(GetReader()->IsPileUpFromSPD())
354  {
355  fhDeltaEtaChargedPtA3GeVPileUp[0]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
356  fhDeltaPhiChargedPtA3GeVPileUp[0]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
357  }
358  if(GetReader()->IsPileUpFromEMCal())
359  {
360  fhDeltaEtaChargedPtA3GeVPileUp[1]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
361  fhDeltaPhiChargedPtA3GeVPileUp[1]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
362  }
363  if(GetReader()->IsPileUpFromSPDOrEMCal())
364  {
365  fhDeltaEtaChargedPtA3GeVPileUp[2]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
366  fhDeltaPhiChargedPtA3GeVPileUp[2]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
367  }
368  if(GetReader()->IsPileUpFromSPDAndEMCal())
369  {
370  fhDeltaEtaChargedPtA3GeVPileUp[3]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
371  fhDeltaPhiChargedPtA3GeVPileUp[3]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
372  }
373  if(GetReader()->IsPileUpFromSPDAndNotEMCal())
374  {
375  fhDeltaEtaChargedPtA3GeVPileUp[4]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
376  fhDeltaPhiChargedPtA3GeVPileUp[4]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
377  }
378  if(GetReader()->IsPileUpFromEMCalAndNotSPD())
379  {
380  fhDeltaEtaChargedPtA3GeVPileUp[5]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
381  fhDeltaPhiChargedPtA3GeVPileUp[5]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
382  }
383  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal())
384  {
385  fhDeltaEtaChargedPtA3GeVPileUp[6]->Fill(ptTrig, deltaEta, GetEventWeight()) ;
386  fhDeltaPhiChargedPtA3GeVPileUp[6]->Fill(ptTrig, deltaPhi, GetEventWeight()) ;
387  }
388  }
389  }
390 
391  if(IsDataMC())
392  {
393  Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
394  fhDeltaPhiChargedMC[mcIndex]->Fill(ptTrig , deltaPhi, GetEventWeight());
395 
397  {
398  // check index in GetMCTagIndexHistogram
399  if ( mcIndex == 2 ) fhDeltaPhiChargedMC[8]->Fill(ptTrig, deltaPhi, GetEventWeight()); // pi0 decay
400  else if( mcIndex == 4 ) fhDeltaPhiChargedMC[9]->Fill(ptTrig, deltaPhi, GetEventWeight()); // eta decay
401  }
402  }
403 
404  if(fDecayTrigger && decayTag > 0)
405  {
406  for(Int_t ibit = 0; ibit<fNDecayBits; ibit++)
407  {
408  if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
409  fhDeltaPhiDecayCharged[ibit]->Fill(ptTrig, deltaPhi, GetEventWeight());
410  }
411  }
412 
413  Double_t dphiBrad = -100;
414  if(fFillBradHisto)
415  {
416  dphiBrad = atan2(sin(deltaPhiOrg), cos(deltaPhiOrg))/TMath::Pi();//-1 to 1
417  if( TMath::Abs(dphiBrad) > 0.325 && TMath::Abs(dphiBrad) < 0.475 ) // Hardcoded values, BAD, FIXME
418  {
419  fhAssocPtBkg->Fill(ptTrig, ptAssoc, GetEventWeight());
420  }
421 
422  if( dphiBrad < -1./3 ) dphiBrad += 2;
423  fhDeltaPhiBrad->Fill(ptTrig, dphiBrad, GetEventWeight());
424  }
425 
426  // Fill histograms in bins of associated particle pT
427  if ( bin >= 0 )
428  {
429  fhDeltaPhiDeltaEtaAssocPtBin[bin]->Fill(deltaPhi,deltaEta, GetEventWeight());
430 
431  fhDeltaPhiAssocPtBin [bin]->Fill(ptTrig, deltaPhi, GetEventWeight());
432 
434  {
435  if(TMath::Abs(deltaEta)> 0.8)
436  fhDeltaPhiAssocPtBinDEta08[bin]->Fill(ptTrig, deltaPhi, GetEventWeight());
437 
438  if(TMath::Abs(deltaEta)< 0.01)
439  fhDeltaPhiAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi, GetEventWeight());
440  }
441 
442  if (fFillBradHisto)
443  fhDeltaPhiBradAssocPtBin [bin]->Fill(ptTrig, dphiBrad, GetEventWeight());
444 
445  if(fDecayTrigger && decayTag > 0 && fNDecayBits > 0 &&
446  GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
447  {
448  fhDeltaPhiDecayChargedAssocPtBin[bin]->Fill(ptTrig, deltaPhi, GetEventWeight());
449  }
450 
452  {
453  if( hmpidSignal > 0 )
454  {
455  //printf("Track pt %f with HMPID signal %f \n",pt,hmpidSignal);
456  fhDeltaPhiAssocPtBinHMPID[bin]->Fill(ptTrig, deltaPhi, GetEventWeight());
457  }
458 
459  if(phiAssoc > 5*TMath::DegToRad() && phiAssoc < 20*TMath::DegToRad())
460  {
461  //printf("Track pt %f in HMPID acceptance phi %f \n ",pt,phi*TMath::RadToDeg() );
462  fhDeltaPhiAssocPtBinHMPIDAcc[bin]->Fill(ptTrig, deltaPhi, GetEventWeight());
463  }
464  }
465  }
466 
467  // Fill different multiplicity/centrality histogram
468  if(IsHighMultiplicityAnalysisOn() && cen >= 0 && cen < GetNCentrBin())
469  {
470  fhDeltaPhiChargedMult[cen]->Fill(ptTrig, deltaPhi, GetEventWeight());
471  fhDeltaEtaChargedMult[cen]->Fill(ptTrig, deltaEta, GetEventWeight());
472  }
473 }
474 
475 //___________________________________________________________________________________________________________________________________
477 //___________________________________________________________________________________________________________________________________
478 Bool_t AliAnaParticleHadronCorrelation::FillChargedMCCorrelationHistograms(Float_t mcAssocPt, Float_t mcAssocPhi, Float_t mcAssocEta,
479  Float_t mcTrigPt, Float_t mcTrigPhi, Float_t mcTrigEta,
480  Int_t histoIndex, Bool_t lostDecayPair)
481 {
482  Bool_t lead = kTRUE;
483 
484  // In case we requested the trigger to be a leading particle,
485  // check if this is true at the MC level.
486  // Not sure if it is correct to skip or not skip this.
487  // Absolute leading?
488  if( fMakeAbsoluteLeading && mcAssocPt > mcTrigPt ) lead = kFALSE; // skip event
489 
490  // Skip this event if near side associated particle pt larger than trigger
491  if( mcAssocPhi < 0 ) mcAssocPhi+=TMath::TwoPi();
492 
493  Float_t mcdeltaPhi= mcTrigPhi-mcAssocPhi;
494  if(mcdeltaPhi <= -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi();
495  if(mcdeltaPhi > 3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi();
496 
498  {
499  if( mcAssocPt > mcTrigPt && mcdeltaPhi < TMath::PiOver2() ) lead = kFALSE; // skip event
500  }
501 
502  //
503  // Select only hadrons in pt range
504  if ( mcAssocPt < fMinAssocPt || mcAssocPt > fMaxAssocPt ) return lead ; // exclude but continue
505  if ( mcAssocPt < GetReader()->GetCTSPtMin()) return lead ;
506 
507 
508  //
509  // Remove trigger itself for correlation when use charged triggers
510  if(TMath::Abs(mcAssocPt -mcTrigPt ) < 1e-6 &&
511  mcdeltaPhi < 1e-6 &&
512  TMath::Abs(mcAssocEta-mcTrigEta) < 1e-6) return lead ; // exclude but continue
513 
514  Float_t mcxE =-mcAssocPt/mcTrigPt*TMath::Cos(mcdeltaPhi);// -(mcAssocPx*pxprim+mcAssocPy*pyprim)/(mcTrigPt*mcTrigPt);
515  Float_t mchbpXE =-100 ;
516  if(mcxE > 0 ) mchbpXE = TMath::Log(1./mcxE);
517 
518  Float_t mczT = mcAssocPt/mcTrigPt ;
519  Float_t mchbpZT =-100 ;
520  if(mczT > 0 ) mchbpZT = TMath::Log(1./mczT);
521 
522  Double_t mcpout = mcAssocPt*TMath::Sin(mcdeltaPhi) ;
523 
524  AliDebug(1,Form("Charged hadron: track Pt %f, track Phi %f, phi trigger %f. Cuts: delta phi %2.2f < %2.2f < %2.2f",
525  mcAssocPt,mcAssocPhi, mcTrigPhi,fDeltaPhiMinCut, mcdeltaPhi, fDeltaPhiMaxCut));
526 
527  // Fill Histograms
528  fhMCEtaCharged [histoIndex]->Fill(mcAssocPt, mcAssocEta, GetEventWeight());
529  fhMCPhiCharged [histoIndex]->Fill(mcAssocPt, mcAssocPhi, GetEventWeight());
530  fhMCDeltaPhiCharged[histoIndex]->Fill(mcTrigPt , mcdeltaPhi, GetEventWeight());
531  fhMCPtAssocDeltaPhi[histoIndex]->Fill(mcAssocPt, mcdeltaPhi, GetEventWeight());
532 
533  fhMCDeltaEtaCharged [histoIndex]->Fill(mcTrigPt , mcTrigEta-mcAssocEta, GetEventWeight());
534  fhMCDeltaPhiDeltaEtaCharged[histoIndex]->Fill(mcdeltaPhi, mcTrigEta-mcAssocEta, GetEventWeight());
535 
536  // Delta phi cut for correlation
537  if( (mcdeltaPhi > fDeltaPhiMinCut) && (mcdeltaPhi < fDeltaPhiMaxCut) )
538  {
539  fhMCDeltaPhiChargedPt[histoIndex]->Fill(mcAssocPt, mcdeltaPhi, GetEventWeight());
540  fhMCPtXECharged [histoIndex]->Fill(mcTrigPt , mcxE , GetEventWeight());
541  fhMCPtHbpXECharged [histoIndex]->Fill(mcTrigPt , mchbpXE , GetEventWeight());
542  fhMCPtZTCharged [histoIndex]->Fill(mcTrigPt , mczT , GetEventWeight());
543  fhMCPtHbpZTCharged [histoIndex]->Fill(mcTrigPt , mchbpZT , GetEventWeight());
544  fhMCPtTrigPout [histoIndex]->Fill(mcTrigPt , mcpout , GetEventWeight());
545  }
546 
547  if(lostDecayPair)
548  {
549  // check index in GetMCTagIndexHistogram
550  if(histoIndex == 2 && 8 >= fMCGenTypeMin && 8 <= fMCGenTypeMax )
551  {
552  // pi0 decay
553  fhMCEtaCharged [8]->Fill(mcAssocPt, mcAssocEta, GetEventWeight());
554  fhMCPhiCharged [8]->Fill(mcAssocPt, mcAssocPhi, GetEventWeight());
555  fhMCDeltaPhiCharged[8]->Fill(mcTrigPt , mcdeltaPhi, GetEventWeight());
556  fhMCPtAssocDeltaPhi[8]->Fill(mcAssocPt, mcdeltaPhi, GetEventWeight());
557 
558  fhMCDeltaEtaCharged [8]->Fill(mcTrigPt , mcTrigEta-mcAssocEta, GetEventWeight());
559  fhMCDeltaPhiDeltaEtaCharged[8]->Fill(mcdeltaPhi, mcTrigEta-mcAssocEta, GetEventWeight());
560 
561  //delta phi cut for correlation
562  if( (mcdeltaPhi > fDeltaPhiMinCut) && (mcdeltaPhi < fDeltaPhiMaxCut) )
563  {
564  fhMCDeltaPhiChargedPt[8]->Fill(mcAssocPt, mcdeltaPhi, GetEventWeight());
565  fhMCPtXECharged [8]->Fill(mcTrigPt , mcxE , GetEventWeight());
566  fhMCPtHbpXECharged [8]->Fill(mcTrigPt , mchbpXE , GetEventWeight());
567  fhMCPtZTCharged [8]->Fill(mcTrigPt , mczT , GetEventWeight());
568  fhMCPtHbpZTCharged [8]->Fill(mcTrigPt , mchbpZT , GetEventWeight());
569  fhMCPtTrigPout [8]->Fill(mcTrigPt , mcpout , GetEventWeight());
570  }
571  } // pi0 decay lost pair
572 
573  if(histoIndex == 4 && 9 >= fMCGenTypeMin && 9 <= fMCGenTypeMax )
574  {
575  // eta decay
576  fhMCEtaCharged [9]->Fill(mcAssocPt, mcAssocEta, GetEventWeight());
577  fhMCPhiCharged [9]->Fill(mcAssocPt, mcAssocPhi, GetEventWeight());
578  fhMCDeltaPhiCharged[9]->Fill(mcTrigPt , mcdeltaPhi, GetEventWeight());
579  fhMCPtAssocDeltaPhi[9]->Fill(mcAssocPt, mcdeltaPhi, GetEventWeight());
580 
581  fhMCDeltaEtaCharged [9]->Fill(mcTrigPt , mcTrigEta-mcAssocEta, GetEventWeight());
582  fhMCDeltaPhiDeltaEtaCharged[9]->Fill(mcdeltaPhi, mcTrigEta-mcAssocEta, GetEventWeight());
583 
584  // Delta phi cut for correlation
585  if( (mcdeltaPhi > fDeltaPhiMinCut) && (mcdeltaPhi < fDeltaPhiMaxCut) )
586  {
587  fhMCDeltaPhiChargedPt[9]->Fill(mcAssocPt, mcdeltaPhi, GetEventWeight());
588  fhMCPtXECharged [9]->Fill(mcTrigPt , mcxE , GetEventWeight());
589  fhMCPtHbpXECharged [9]->Fill(mcTrigPt , mchbpXE , GetEventWeight());
590  fhMCPtZTCharged [9]->Fill(mcTrigPt , mczT , GetEventWeight());
591  fhMCPtHbpZTCharged [9]->Fill(mcTrigPt , mchbpZT , GetEventWeight());
592  fhMCPtTrigPout [9]->Fill(mcTrigPt , mcpout , GetEventWeight()) ;
593  }
594  } // eta decay lost pair
595  }
596  // Underlying event
597 
598  // Right
599  if ( (mcdeltaPhi > fUeDeltaPhiMinCut) && (mcdeltaPhi < fUeDeltaPhiMaxCut) )
600  {
601  //Double_t randomphi = gRandom->Uniform(TMath::Pi()/2,3*TMath::Pi()/2);
602  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
603  Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi);
604  Double_t mcUezT = mcAssocPt/mcTrigPt;
605 
606  if(mcUexE < 0.)
607  AliWarning(Form("Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
608  mcUexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
609 
610  fhMCPtXEUeCharged[histoIndex]->Fill(mcTrigPt, mcUexE, GetEventWeight());
611  if(mcUexE > 0) fhMCPtHbpXEUeCharged[histoIndex]->Fill(mcTrigPt, TMath::Log(1/mcUexE), GetEventWeight());
612 
613  fhMCPtZTUeCharged[histoIndex]->Fill(mcTrigPt, mcUezT, GetEventWeight());
614  if(mcUezT > 0) fhMCPtHbpZTUeCharged[histoIndex]->Fill(mcTrigPt, TMath::Log(1/mcUezT), GetEventWeight());
615 
616  fhMCUePart[histoIndex]->Fill(mcTrigPt, GetEventWeight());
617 
618  if(lostDecayPair)
619  {
620  // check index in GetMCTagIndexHistogram
621  if(histoIndex == 2 && 8 >= fMCGenTypeMin && 8 <= fMCGenTypeMax )
622  {
623  // pi0 decay
624  fhMCPtXEUeCharged[8]->Fill(mcTrigPt, mcUexE, GetEventWeight());
625  if(mcUexE > 0) fhMCPtHbpXEUeCharged[8]->Fill(mcTrigPt, TMath::Log(1/mcUexE), GetEventWeight());
626 
627  fhMCPtZTUeCharged[8]->Fill(mcTrigPt, mcUezT, GetEventWeight());
628  if(mcUezT > 0) fhMCPtHbpZTUeCharged[8]->Fill(mcTrigPt, TMath::Log(1/mcUezT), GetEventWeight());
629 
630  fhMCUePart[8]->Fill(mcTrigPt, GetEventWeight());
631  }
632  else if(histoIndex == 4 && 9 >= fMCGenTypeMin && 9 <= fMCGenTypeMax )
633  {
634  // eta decay
635  fhMCPtXEUeCharged[9]->Fill(mcTrigPt, mcUexE, GetEventWeight());
636  if(mcUexE > 0) fhMCPtHbpXEUeCharged[9]->Fill(mcTrigPt, TMath::Log(1/mcUexE), GetEventWeight());
637 
638  fhMCPtZTUeCharged[9]->Fill(mcTrigPt, mcUezT, GetEventWeight());
639  if(mcUezT > 0) fhMCPtHbpZTUeCharged[9]->Fill(mcTrigPt, TMath::Log(1/mcUezT), GetEventWeight());
640 
641  fhMCUePart[9]->Fill(mcTrigPt, GetEventWeight());
642  }
643  }
644  }
645 
646  if(fMakeSeveralUE)
647  {
648  // Left
649  if((mcdeltaPhi<-fUeDeltaPhiMinCut) || (mcdeltaPhi >2*fUeDeltaPhiMaxCut))
650  {
651  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
652  Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi);
653  Double_t mcUezT = mcAssocPt/mcTrigPt;
654 
655  if(mcUexE < 0.)
656  AliWarning(Form("Careful!!, negative xE %2.2f for left UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
657  mcUexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
658 
659  fhMCPtXEUeLeftCharged[histoIndex]->Fill(mcTrigPt, mcUexE, GetEventWeight());
660  if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged[histoIndex]->Fill(mcTrigPt, TMath::Log(1/mcUexE), GetEventWeight());
661 
662  fhMCPtZTUeLeftCharged[histoIndex]->Fill(mcTrigPt, mcUezT, GetEventWeight());
663  if(mcUezT > 0) fhMCPtHbpZTUeLeftCharged[histoIndex]->Fill(mcTrigPt, TMath::Log(1/mcUezT), GetEventWeight());
664 
665  if(lostDecayPair)
666  {
667  // Check index in GetMCTagIndexHistogram
668  if(histoIndex == 2 && 8 >= fMCGenTypeMin && 8 <= fMCGenTypeMax )
669  {
670  // pi0 decay
671  fhMCPtXEUeLeftCharged[8]->Fill(mcTrigPt,mcUexE, GetEventWeight());
672  if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged[8]->Fill(mcTrigPt, TMath::Log(1/mcUexE), GetEventWeight());
673 
674  fhMCPtZTUeLeftCharged[8]->Fill(mcTrigPt,mcUezT, GetEventWeight());
675  if(mcUezT > 0) fhMCPtHbpZTUeLeftCharged[8]->Fill(mcTrigPt, TMath::Log(1/mcUezT), GetEventWeight());
676  }
677  else if(histoIndex == 4 && 9 >= fMCGenTypeMin && 9 <= fMCGenTypeMax )
678  {
679  // eta decay
680  fhMCPtXEUeLeftCharged[9]->Fill(mcTrigPt, mcUexE, GetEventWeight());
681  if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged[9]->Fill(mcTrigPt, TMath::Log(1/mcUexE), GetEventWeight());
682 
683  fhMCPtZTUeLeftCharged[9]->Fill(mcTrigPt, mcUezT, GetEventWeight());
684  if(mcUezT > 0) fhMCPtHbpZTUeLeftCharged[9]->Fill(mcTrigPt, TMath::Log(1/mcUezT), GetEventWeight());
685  }
686  }
687  }
688  }
689 
690  return lead;
691 }
692 
693 //______________________________________________________________________________________________________________
695 //______________________________________________________________________________________________________________
697  Float_t deltaPhi,
698  Int_t cen, Int_t charge,
699  Int_t bin, Int_t decayTag,
700  Int_t outTOF, Int_t mcTag)
701 
702 {
703  Float_t zT = ptAssoc/ptTrig ;
704  Float_t xE =-ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
705  Float_t pout = ptAssoc*TMath::Sin(deltaPhi) ;
706 
707  if(xE < 0.)
708  AliWarning(Form("Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
709  xE,deltaPhi*TMath::RadToDeg(),TMath::Cos(deltaPhi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
710 
711  Float_t hbpXE = -100;
712  Float_t hbpZT = -100;
713 
714  if(xE > 0 ) hbpXE = TMath::Log(1./xE);
715  if(zT > 0 ) hbpZT = TMath::Log(1./zT);
716 
717  fhXECharged ->Fill(ptTrig, xE , GetEventWeight());
718  fhPtHbpXECharged ->Fill(ptTrig, hbpXE , GetEventWeight());
719  fhZTCharged ->Fill(ptTrig, zT , GetEventWeight());
720  fhPtHbpZTCharged ->Fill(ptTrig, hbpZT , GetEventWeight());
721  fhPtTrigPout ->Fill(ptTrig, pout , GetEventWeight());
722  fhPtTrigCharged ->Fill(ptTrig, ptAssoc, GetEventWeight());
723 
724  if((deltaPhi > 5*TMath::Pi()/6.) && (deltaPhi < 7*TMath::Pi()/6.))
725  {
726  fhXECharged_Cone2 ->Fill(ptTrig, xE , GetEventWeight());
727  fhPtHbpXECharged_Cone2 ->Fill(ptTrig, hbpXE, GetEventWeight());
728  }
729 
730  // MC
731  if(IsDataMC())
732  {
733  Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
734  fhXEChargedMC[mcIndex]->Fill(ptTrig, xE, GetEventWeight());
735 
736  if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) )
737  {
738  // check index in GetMCTagIndexHistogram
739  if ( mcIndex == 2 ) fhXEChargedMC[8]->Fill(ptTrig, xE, GetEventWeight()); // pi0 decay
740  else if ( mcIndex == 4 ) fhXEChargedMC[9]->Fill(ptTrig, xE, GetEventWeight()); // eta decay
741  }
742  }
743 
744  // Pile-up studies
745  if(IsPileUpAnalysisOn())
746  {
747  if (outTOF==1)
748  {
749  fhXEChargedOtherBC ->Fill(ptTrig, xE , GetEventWeight());
750  fhZTChargedOtherBC ->Fill(ptTrig, zT , GetEventWeight());
751  fhPtTrigChargedOtherBC->Fill(ptTrig, ptAssoc, GetEventWeight());
752  }
753  else if(outTOF==0)
754  {
755  fhXEChargedBC0 ->Fill(ptTrig, xE , GetEventWeight());
756  fhZTChargedBC0 ->Fill(ptTrig, zT , GetEventWeight());
757  fhPtTrigChargedBC0->Fill(ptTrig, ptAssoc, GetEventWeight());
758  }
759 
760  Int_t vtxBC = GetReader()->GetVertexBC();
761  if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
762  {
763  fhXEChargedVtxBC0 ->Fill(ptTrig, xE , GetEventWeight());
764  fhZTChargedVtxBC0 ->Fill(ptTrig, zT , GetEventWeight());
765  fhPtTrigChargedVtxBC0->Fill(ptTrig, ptAssoc, GetEventWeight());
766  }
767 
768  if(GetReader()->IsPileUpFromSPD())
769  {
770  fhXEChargedPileUp [0]->Fill(ptTrig, xE , GetEventWeight());
771  fhZTChargedPileUp [0]->Fill(ptTrig, zT , GetEventWeight());
772  fhPtTrigChargedPileUp[0]->Fill(ptTrig, ptAssoc, GetEventWeight());
773  }
774  if(GetReader()->IsPileUpFromEMCal())
775  {
776  fhXEChargedPileUp [1]->Fill(ptTrig, xE , GetEventWeight());
777  fhZTChargedPileUp [1]->Fill(ptTrig, zT , GetEventWeight());
778  fhPtTrigChargedPileUp[1]->Fill(ptTrig, ptAssoc, GetEventWeight());
779  }
780  if(GetReader()->IsPileUpFromSPDOrEMCal())
781  {
782  fhXEChargedPileUp [2]->Fill(ptTrig, xE , GetEventWeight());
783  fhZTChargedPileUp [2]->Fill(ptTrig, zT , GetEventWeight());
784  fhPtTrigChargedPileUp[2]->Fill(ptTrig, ptAssoc, GetEventWeight());
785  }
786  if(GetReader()->IsPileUpFromSPDAndEMCal())
787  {
788  fhXEChargedPileUp [3]->Fill(ptTrig, xE , GetEventWeight());
789  fhZTChargedPileUp [3]->Fill(ptTrig, zT , GetEventWeight());
790  fhPtTrigChargedPileUp[3]->Fill(ptTrig, ptAssoc, GetEventWeight());
791  }
792  if(GetReader()->IsPileUpFromSPDAndNotEMCal())
793  {
794  fhXEChargedPileUp [4]->Fill(ptTrig, xE , GetEventWeight());
795  fhZTChargedPileUp [4]->Fill(ptTrig, zT , GetEventWeight());
796  fhPtTrigChargedPileUp[4]->Fill(ptTrig, ptAssoc, GetEventWeight());
797  }
798  if(GetReader()->IsPileUpFromEMCalAndNotSPD())
799  {
800  fhXEChargedPileUp [5]->Fill(ptTrig, xE , GetEventWeight());
801  fhZTChargedPileUp [5]->Fill(ptTrig, zT , GetEventWeight());
802  fhPtTrigChargedPileUp[5]->Fill(ptTrig, ptAssoc, GetEventWeight());
803  }
804  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal())
805  {
806  fhXEChargedPileUp [6]->Fill(ptTrig, xE , GetEventWeight());
807  fhZTChargedPileUp [6]->Fill(ptTrig, zT , GetEventWeight());
808  fhPtTrigChargedPileUp[6]->Fill(ptTrig, ptAssoc, GetEventWeight());
809  }
810  }
811 
812  if(fDecayTrigger && decayTag > 0)
813  {
814  for(Int_t ibit = 0; ibit<fNDecayBits; ibit++)
815  {
816  if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
817  {
818  fhXEDecayCharged[ibit]->Fill(ptTrig, xE, GetEventWeight());
819  fhZTDecayCharged[ibit]->Fill(ptTrig, zT, GetEventWeight());
820  }
821  }
822  } // photon decay pi0/eta trigger
823 
824  if(bin >= 0 && fFillMomImbalancePtAssocBinsHisto)//away side
825  {
826  fhXEAssocPtBin[bin]->Fill(ptTrig, xE, GetEventWeight()) ;
827  fhZTAssocPtBin[bin]->Fill(ptTrig, zT, GetEventWeight()) ;
828  }
829 
830  if(fCorrelVzBin)
831  {
832  Int_t vz = GetEventVzBin();
833  fhXEVZ[vz]->Fill(ptTrig, xE, GetEventWeight()) ;
834  fhZTVZ[vz]->Fill(ptTrig, zT, GetEventWeight()) ;
835  }
836 
837  if(charge > 0)
838  {
839  fhXEPosCharged->Fill(ptTrig, xE, GetEventWeight()) ;
840  fhZTPosCharged->Fill(ptTrig, zT, GetEventWeight()) ;
841  }
842  else
843  {
844  fhXENegCharged->Fill(ptTrig, xE, GetEventWeight()) ;
845  fhZTNegCharged->Fill(ptTrig, zT, GetEventWeight()) ;
846  }
847 
848  // Fill different multiplicity/centrality histogram
849  if(IsHighMultiplicityAnalysisOn() && cen >= 0 && cen < GetNCentrBin())
850  {
851  fhXEMult[cen]->Fill(ptTrig, xE, GetEventWeight());
852  fhZTMult[cen]->Fill(ptTrig, zT, GetEventWeight());
853  } // multiplicity/centrality events selection
854 }
855 
856 //___________________________________________________________________________________________________________________
858 //___________________________________________________________________________________________________________________
860  Float_t deltaPhi, Int_t cen, Int_t outTOF, Int_t mcTag)
861 {
862  fhUePart->Fill(ptTrig, GetEventWeight());
863 
864  fhDeltaPhiUeChargedPt->Fill(ptAssoc, deltaPhi, GetEventWeight());
865 
866  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
867  Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
868  Double_t uezT = ptAssoc/ptTrig;
869 
870  if(uexE < 0.)
871  AliWarning(Form("Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
872  uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
873 
874  fhXEUeCharged->Fill(ptTrig, uexE, GetEventWeight());
875  if(uexE > 0) fhPtHbpXEUeCharged->Fill(ptTrig, TMath::Log(1/uexE), GetEventWeight());
876 
877  fhZTUeCharged->Fill(ptTrig, uezT, GetEventWeight());
878  if(uezT > 0) fhPtHbpZTUeCharged->Fill(ptTrig, TMath::Log(1/uezT), GetEventWeight());
879 
880  if(IsDataMC())
881  {
882  Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
883  fhXEUeChargedRightMC[mcIndex]->Fill(ptTrig, uexE, GetEventWeight());
884 
885  if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) )
886  {
887  // check index in GetMCTagIndexHistogram
888  if ( mcIndex == 2 ) fhXEUeChargedRightMC[8]->Fill(ptTrig, uexE, GetEventWeight()); // pi0 decay
889  else if ( mcIndex == 4 ) fhXEUeChargedRightMC[9]->Fill(ptTrig, uexE, GetEventWeight()); // eta decay
890  }
891  }
892 
893  // Pile-up studies
894 
895  if(IsPileUpAnalysisOn())
896  {
897  if (outTOF==1)
898  {
899  fhXEUeChargedOtherBC->Fill(ptTrig, uexE, GetEventWeight());
900  fhZTUeChargedOtherBC->Fill(ptTrig, uezT, GetEventWeight());
901  }
902  else if(outTOF==0)
903  {
904  fhXEUeChargedBC0->Fill(ptTrig, uexE, GetEventWeight());
905  fhZTUeChargedBC0->Fill(ptTrig, uezT, GetEventWeight());
906  }
907 
908  Int_t vtxBC = GetReader()->GetVertexBC();
909  if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
910  {
911  fhXEUeChargedVtxBC0->Fill(ptTrig, uexE, GetEventWeight());
912  fhZTUeChargedVtxBC0->Fill(ptTrig, uezT, GetEventWeight());
913  }
914 
915  if(GetReader()->IsPileUpFromSPD())
916  {
917  fhXEUeChargedPileUp[0]->Fill(ptTrig, uexE, GetEventWeight());
918  fhZTUeChargedPileUp[0]->Fill(ptTrig, uezT, GetEventWeight());
919  }
920  if(GetReader()->IsPileUpFromEMCal())
921  {
922  fhXEUeChargedPileUp[1]->Fill(ptTrig, uexE, GetEventWeight());
923  fhZTUeChargedPileUp[1]->Fill(ptTrig, uezT, GetEventWeight());
924  }
925  if(GetReader()->IsPileUpFromSPDOrEMCal())
926  {
927  fhXEUeChargedPileUp[2]->Fill(ptTrig, uexE, GetEventWeight());
928  fhZTUeChargedPileUp[2]->Fill(ptTrig, uezT, GetEventWeight());
929  }
930  if(GetReader()->IsPileUpFromSPDAndEMCal())
931  {
932  fhXEUeChargedPileUp[3]->Fill(ptTrig, uexE, GetEventWeight());
933  fhZTUeChargedPileUp[3]->Fill(ptTrig, uezT, GetEventWeight());
934  }
935  if(GetReader()->IsPileUpFromSPDAndNotEMCal())
936  {
937  fhXEUeChargedPileUp[4]->Fill(ptTrig, uexE, GetEventWeight());
938  fhZTUeChargedPileUp[4]->Fill(ptTrig, uezT, GetEventWeight());
939  }
940  if(GetReader()->IsPileUpFromEMCalAndNotSPD())
941  {
942  fhXEUeChargedPileUp[5]->Fill(ptTrig, uexE, GetEventWeight());
943  fhZTUeChargedPileUp[5]->Fill(ptTrig, uezT, GetEventWeight());
944  }
945  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal())
946  {
947  fhXEUeChargedPileUp[6]->Fill(ptTrig, uexE, GetEventWeight());
948  fhZTUeChargedPileUp[6]->Fill(ptTrig, uezT, GetEventWeight());
949  }
950  }
951 
952  // Fill different multiplicity/centrality histogram
953  if(IsHighMultiplicityAnalysisOn() && cen >= 0 && cen < GetNCentrBin())
954  {
955  fhXEUeMult[cen]->Fill(ptTrig, uexE, GetEventWeight());
956  fhZTUeMult[cen]->Fill(ptTrig, uezT, GetEventWeight());
957  }
958 }
959 
960 //_______________________________________________________________________________________________
963 //_______________________________________________________________________________________________
965  Float_t ptAssoc,
966  Float_t deltaPhi,
967  Int_t mcTag)
968 {
969  if((deltaPhi<-fUeDeltaPhiMinCut) || (deltaPhi >2*fUeDeltaPhiMaxCut))
970  {
971  fhDeltaPhiUeLeftCharged->Fill(ptAssoc, deltaPhi, GetEventWeight());
972 
973  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
974  Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
975  Double_t uezT = ptAssoc/ptTrig;
976 
977  if(uexE < 0.)
978  AliWarning(Form("Careful!!, negative xE %2.2f for left UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
979  uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
980 
981  fhXEUeLeftCharged->Fill(ptTrig, uexE, GetEventWeight());
982  if(uexE > 0) fhPtHbpXEUeLeftCharged->Fill(ptTrig, TMath::Log(1/uexE), GetEventWeight());
983 
984  fhZTUeLeftCharged->Fill(ptTrig, uezT, GetEventWeight());
985  if(uezT > 0) fhPtHbpZTUeLeftCharged->Fill(ptTrig, TMath::Log(1/uezT), GetEventWeight());
986 
987  fhDeltaPhiUeLeftCharged->Fill(ptAssoc, deltaPhi, GetEventWeight());
988 
989  if(IsDataMC())
990  {
991  Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
992  fhXEUeChargedLeftMC[mcIndex]->Fill(ptTrig, uexE, GetEventWeight());
993 
994  if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) )
995  {
996  // check index in GetMCTagIndexHistogram
997  if ( mcIndex == 2 ) fhXEUeChargedLeftMC[8]->Fill(ptTrig, uexE, GetEventWeight()); // pi0 decay
998  else if ( mcIndex == 4 ) fhXEUeChargedLeftMC[9]->Fill(ptTrig, uexE, GetEventWeight()); // eta decay
999  }
1000  }
1001  }
1002 
1003  if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-TMath::Pi()/2))
1004  {
1005  fhDeltaPhiUeLeftDownCharged->Fill(ptAssoc, deltaPhi, GetEventWeight());
1006 
1007  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
1008  Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
1009 
1010  if(uexE < 0.)
1011  AliWarning(Form("Careful!!, negative xE %2.2f for left-down UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
1012  uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
1013 
1014  fhXEUeLeftDownCharged->Fill(ptTrig, uexE, GetEventWeight());
1015  }
1016 
1017  if((deltaPhi>2*fUeDeltaPhiMaxCut) && (deltaPhi <3*TMath::Pi()/2))
1018  {
1019  fhDeltaPhiUeLeftUpCharged->Fill(ptAssoc, deltaPhi, GetEventWeight());
1020 
1021  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
1022  Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
1023 
1024  if(uexE < 0.)
1025  AliWarning(Form("Careful!!, negative xE %2.2f for left-up UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
1026  uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
1027 
1028  fhXEUeLeftUpCharged->Fill(ptTrig, uexE, GetEventWeight());
1029  }
1030 
1031  if((deltaPhi > TMath::Pi()/2) && (deltaPhi < fUeDeltaPhiMaxCut))
1032  {
1033  fhDeltaPhiUeRightUpCharged->Fill(ptAssoc, deltaPhi, GetEventWeight());
1034 
1035  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
1036  Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
1037 
1038  if(uexE < 0.)
1039  AliWarning(Form("Careful!!, negative xE %2.2f for right-up UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
1040  uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
1041 
1042  fhXEUeRightUpCharged->Fill(ptTrig, uexE, GetEventWeight());
1043  }
1044 
1045  if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < TMath::Pi()/2))
1046  {
1047  fhDeltaPhiUeRightDownCharged->Fill(ptAssoc, deltaPhi, GetEventWeight());
1048 
1049  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
1050  Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
1051 
1052  if(uexE < 0.)
1053  AliWarning(Form("Careful!!, negative xE %2.2f for right-down UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
1054  uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
1055 
1056  fhXEUeRightDownCharged->Fill(ptTrig, uexE, GetEventWeight());
1057  }
1058 }
1059 
1060 //_____________________________________________________________________________________________________________________________________
1062 //_____________________________________________________________________________________________________________________________________
1063 void AliAnaParticleHadronCorrelation::FillDecayPhotonCorrelationHistograms(Float_t ptAssoc, Float_t phiAssoc, Bool_t bChargedOrNeutral)
1064 {
1065  // Calculate the correlation parameters
1066  Float_t ptDecay1 = fDecayMom1.Pt();
1067  Float_t ptDecay2 = fDecayMom2.Pt();
1068 
1069  Float_t zTDecay1 = -100, zTDecay2 = -100;
1070  if(ptDecay1 > 0) zTDecay1 = ptAssoc/ptDecay1 ;
1071  if(ptDecay2 > 0) zTDecay2 = ptAssoc/ptDecay2 ;
1072 
1073  Float_t deltaPhiDecay1 = fDecayMom1.Phi()-phiAssoc;
1074  if(deltaPhiDecay1< -TMath::PiOver2()) deltaPhiDecay1+=TMath::TwoPi();
1075  if(deltaPhiDecay1>3*TMath::PiOver2()) deltaPhiDecay1-=TMath::TwoPi();
1076 
1077  Float_t deltaPhiDecay2 = fDecayMom2.Phi()-phiAssoc;
1078  if(deltaPhiDecay2< -TMath::PiOver2()) deltaPhiDecay2+=TMath::TwoPi();
1079  if(deltaPhiDecay2>3*TMath::PiOver2()) deltaPhiDecay2-=TMath::TwoPi();
1080 
1081  Float_t xEDecay1 =-zTDecay1*TMath::Cos(deltaPhiDecay1); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
1082  Float_t xEDecay2 =-zTDecay2*TMath::Cos(deltaPhiDecay2); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
1083 
1084  if(bChargedOrNeutral) // correlate with charges
1085  {
1086  fhDeltaPhiPi0DecayCharged->Fill(ptDecay1, deltaPhiDecay1, GetEventWeight());
1087  fhDeltaPhiPi0DecayCharged->Fill(ptDecay2, deltaPhiDecay2, GetEventWeight());
1088 
1089  AliDebug(2,Form("deltaPhoton1 = %f, deltaPhoton2 = %f", deltaPhiDecay1, deltaPhiDecay2));
1090 
1091  if( (deltaPhiDecay1 > fDeltaPhiMinCut) && ( deltaPhiDecay1 < fDeltaPhiMaxCut) )
1092  {
1093  fhZTPi0DecayCharged->Fill(ptDecay1, zTDecay1, GetEventWeight());
1094  fhXEPi0DecayCharged->Fill(ptDecay1, xEDecay1, GetEventWeight());
1095  }
1096  if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) )
1097  {
1098  fhZTPi0DecayCharged->Fill(ptDecay2, zTDecay2, GetEventWeight());
1099  fhXEPi0DecayCharged->Fill(ptDecay2, xEDecay2, GetEventWeight());
1100  }
1101  }
1102  else // correlate with neutrals
1103  {
1104  fhDeltaPhiPi0DecayNeutral->Fill(ptDecay1, deltaPhiDecay1, GetEventWeight());
1105  fhDeltaPhiPi0DecayNeutral->Fill(ptDecay2, deltaPhiDecay2, GetEventWeight());
1106 
1107  AliDebug(2,Form("deltaPhoton1 = %f, deltaPhoton2 = %f", deltaPhiDecay1, deltaPhiDecay2));
1108 
1109  if( (deltaPhiDecay1 > fDeltaPhiMinCut) && ( deltaPhiDecay1 < fDeltaPhiMaxCut) )
1110  {
1111  fhZTPi0DecayNeutral->Fill(ptDecay1, zTDecay1, GetEventWeight());
1112  fhXEPi0DecayNeutral->Fill(ptDecay1, xEDecay1, GetEventWeight());
1113  }
1114  if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) )
1115  {
1116  fhZTPi0DecayNeutral->Fill(ptDecay2, zTDecay2, GetEventWeight());
1117  fhXEPi0DecayNeutral->Fill(ptDecay2, xEDecay2, GetEventWeight());
1118  }
1119  }
1120 }
1121 
1122 //_____________________________________________________________________________________________________________________________
1125 //_____________________________________________________________________________________________________________________________
1127  Float_t zT, Float_t hbpZT,
1128  Float_t deltaPhi)
1129 {
1130  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
1131 
1132  Float_t xE =-ptAssoc/ptTrig*TMath::Cos(randomphi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
1133  Float_t hbpXE = -100;
1134  if(xE > 0 ) hbpXE = TMath::Log(1./xE);
1135 
1136  if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-fUeDeltaPhiMaxCut))
1137  {
1138  fhDeltaPhiUeLeftNeutral->Fill(ptAssoc, deltaPhi, GetEventWeight());
1139  fhXEUeLeftNeutral ->Fill(ptTrig , xE , GetEventWeight());
1140  fhPtHbpXEUeLeftNeutral ->Fill(ptTrig , hbpXE , GetEventWeight());
1141  fhZTUeLeftNeutral ->Fill(ptTrig , zT , GetEventWeight());
1142  fhPtHbpZTUeLeftNeutral ->Fill(ptTrig , hbpZT , GetEventWeight());
1143  }
1144 }
1145 
1146 //______________________________________________________
1148 //______________________________________________________
1150 {
1151  if ( !DoOwnMix() ) return;
1152 
1154 
1155  // Do the cluster pool filling only if requested
1156  // or in case of isolation cut using clusters in the cone.
1158 
1159  if( !fFillNeutralEventMixPool && !isoCase) return;
1160 
1162 }
1163 
1164 //_____________________________________________________________
1166 //_____________________________________________________________
1168 {
1169  if(fUseMixStoredInReader && GetReader()->GetLastTracksMixedEvent() == GetEventNumber())
1170  {
1171  //printf("%s : Pool already filled for this event !!!\n",GetInputAODName().Data());
1172  return ; // pool filled previously for another trigger
1173  }
1174 
1175  AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
1176  AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
1177 
1178  if(!inputHandler) return ;
1179 
1180  // Do mixing only with MB event (or the chosen mask), if not skip
1181  if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ;
1182 
1183  Int_t eventBin = GetEventMixBin();
1184 
1185  //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
1186  if(eventBin < 0) return;
1187 
1188  fhEventMBBin->Fill(eventBin, GetEventWeight());
1189 
1190  TObjArray * mixEventTracks = new TObjArray;
1191 
1193  {
1195  }
1196 
1197  if(!fListMixTrackEvents[eventBin]) fListMixTrackEvents[eventBin] = new TList();
1198 
1199  //printf("%s ***** Pool Event bin : %d - nTracks %d\n",GetInputAODName().Data(),eventBin, GetCTSTracks()->GetEntriesFast());
1200 
1201  TList * pool = fListMixTrackEvents[eventBin];
1202 
1203  for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
1204  {
1205  AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
1206 
1207  fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
1208  Float_t pt = fTrackVector.Pt();
1209 
1210  // Select only hadrons in pt range
1211  if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
1212 
1213  AliAODPWG4Particle * mixedTrack = new AliAODPWG4Particle(track->Px(),track->Py(),track->Pz(),0);
1214  mixedTrack->SetDetectorTag(kCTS);
1215  mixedTrack->SetChargedBit(track->Charge()>0);
1216  mixEventTracks->Add(mixedTrack);
1217  }
1218 
1219  fhNtracksMB->Fill(mixEventTracks->GetEntriesFast(), eventBin, GetEventWeight());
1220 
1221  // Set the event number where the last event was added, to avoid double pool filling
1223 
1224  //printf("Add event to pool with %d tracks \n ",mixEventTracks->GetEntries());
1225  pool->AddFirst(mixEventTracks);
1226  mixEventTracks = 0;
1227 
1228  //printf("Pool size %d, max %d\n",pool->GetSize(), GetNMaxEvMix());
1229 
1230  if(pool->GetSize() > GetNMaxEvMix())
1231  {
1232  // Remove last event
1233  TClonesArray * tmp = static_cast<TClonesArray*>(pool->Last()) ;
1234  pool->RemoveLast() ;
1235  delete tmp ;
1236  }
1237 }
1238 
1239 //_____________________________________________________________
1242 //_____________________________________________________________
1244 {
1245  //printf("FillNeutralEventMixPool for %s\n",GetInputAODName().Data());
1246 
1247  if(fUseMixStoredInReader && GetReader()->GetLastCaloMixedEvent() == GetEventNumber())
1248  {
1249  //printf("%s : Pool already filled for this event !!!\n",GetInputAODName().Data());
1250  return ; // pool filled previously for another trigger
1251  }
1252 
1253  TObjArray * pl = GetEMCALClusters();
1254  //if (GetAODObjArrayName.Contains("PHOS") )pl = GetPHOSClusters();
1255  //else pl = GetEMCALClusters();
1256 
1257  AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
1258  AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
1259 
1260  if(!inputHandler) return ;
1261 
1262  // Do mixing only with MB event (or the chosen mask), if not skip
1263  if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ;
1264 
1265  Int_t eventBin = GetEventMixBin();
1266 
1267  // Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
1268  if(eventBin < 0) return;
1269 
1270  TObjArray * mixEventCalo = new TObjArray;
1271 
1273  {
1275  }
1276 
1277  if(!fListMixCaloEvents[eventBin]) fListMixCaloEvents[eventBin] = new TList();
1278 
1279  TList * poolCalo = fListMixCaloEvents[eventBin];
1280 
1281  for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ )
1282  {
1283  AliVCluster * calo = (AliVCluster *) (pl->At(ipr)) ;
1284 
1285  // Remove matched clusters
1286  if( IsTrackMatched( calo, GetReader()->GetInputEvent() ) ) continue ;
1287 
1288  // Cluster momentum calculation
1290  {
1291  calo->GetMomentum(fMomentum,GetVertex(0)) ;
1292  }// Assume that come from vertex in straight line
1293  else
1294  {
1295  Double_t vertex[]={0,0,0};
1296  calo->GetMomentum(fMomentum,vertex) ;
1297  }
1298 
1299  Float_t pt = fMomentum.Pt();
1300 
1301  // Select only clusters in pt range
1302  if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
1303 
1304  AliAODPWG4Particle * mixedCalo = new AliAODPWG4Particle(fMomentum);
1305  mixedCalo->SetDetectorTag(kEMCAL);
1306  mixEventCalo->Add(mixedCalo);
1307  }
1308 
1309  fhNclustersMB->Fill(mixEventCalo->GetEntriesFast(), eventBin, GetEventWeight());
1310 
1311  // Set the event number where the last event was added, to avoid double pool filling
1313 
1314  //printf("Add event to pool with %d clusters \n ",mixEventCalo->GetEntries());
1315  poolCalo->AddFirst(mixEventCalo);
1316  mixEventCalo = 0;
1317 
1318  //printf("Pool size %d, max %d\n",poolCalo->GetSize(), GetNMaxEvMix());
1319 
1320  if(poolCalo->GetSize() > GetNMaxEvMix())
1321  {
1322  // Remove last event
1323  TClonesArray * tmp = static_cast<TClonesArray*>(poolCalo->Last()) ;
1324  poolCalo->RemoveLast() ;
1325  delete tmp ;
1326  }
1327 }
1328 
1329 //_________________________________________________________________________________________________________________
1332 //_________________________________________________________________________________________________________________
1333 Bool_t AliAnaParticleHadronCorrelation::FindLeadingOppositeHadronInWindow(AliAODPWG4ParticleCorrelation * particle)
1334 {
1335  Float_t etaTrig = particle->Eta();
1336  Float_t ptTrig = particle->Pt();
1337  Float_t phiTrig = particle->Phi();
1338  if(phiTrig < 0 ) phiTrig+= TMath::TwoPi();
1339 
1340  Float_t ptLeadHad = 0 ;
1341  Float_t dphiLeadHad= -100 ;
1342  Float_t phiLeadHad = -100 ;
1343  Float_t etaLeadHad = -100 ;
1344  Int_t nTrack = 0;
1345 
1346  for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
1347  {
1348  AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
1349 
1350  fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
1351 
1352  Float_t pt = fTrackVector.Pt();
1353  Float_t phi = fTrackVector.Phi() ;
1354  if(phi < 0 ) phi+= TMath::TwoPi();
1355 
1356  Float_t deltaPhi = phiTrig-phi;
1357  //
1358  // Calculate deltaPhi shift so that for the particles on the opposite side
1359  // it is defined between 90 and 270 degrees
1360  // Shift [-360,-90] to [0, 270]
1361  // and [270,360] to [-90,0]
1362  if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
1363  if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
1364 
1365  if(pt > ptLeadHad && deltaPhi > TMath::PiOver2()) // in opposite hemisphere
1366  {
1367  ptLeadHad = pt ;
1368  phiLeadHad = phi;
1369  dphiLeadHad= deltaPhi;
1370  etaLeadHad = fTrackVector.Eta();
1371  nTrack++;
1372  }
1373  }// track loop
1374 
1376  {
1377  if(nTrack == 0)
1378  {
1379  fhPtNoLeadingOppositeHadron ->Fill(ptTrig , GetEventWeight());
1380  fhEtaPhiNoLeadingOppositeHadron->Fill(etaTrig, phiTrig, GetEventWeight());
1381  }
1382  else
1383  {
1384  fhPtLeadingOppositeHadron ->Fill(ptTrig, ptLeadHad, GetEventWeight());
1385  fhPtDiffPhiLeadingOppositeHadron->Fill(ptTrig, dphiLeadHad, GetEventWeight());
1386  fhPtDiffEtaLeadingOppositeHadron->Fill(ptTrig, etaLeadHad-etaTrig, GetEventWeight());
1387  }
1388  }
1389 
1390 
1391  AliDebug(1,Form("pT %2.2f, phi %2.2f, eta %2.2f, nTracks away %d, total tracks %d",
1392  ptLeadHad,phiLeadHad*TMath::RadToDeg(),etaLeadHad,nTrack, GetTrackMultiplicity()));
1393  AliDebug(1,Form("\t pT trig %2.2f, Dphi (trigger-hadron) %2.2f, Deta (trigger-hadron) %2.2f",
1394  ptTrig, dphiLeadHad*TMath::RadToDeg(), etaLeadHad-etaTrig));
1395  AliDebug(1,Form("\t cuts pT: min %2.2f, max %2.2f; DPhi: min %2.2f, max %2.2f",
1396  fMinLeadHadPt,fMaxLeadHadPt,fMinLeadHadPhi*TMath::RadToDeg(),fMaxLeadHadPhi*TMath::RadToDeg()));
1397 
1398 
1399  // reject the trigger if the leading hadron is not in the requested pt or phi window and
1400 
1401  if( nTrack == 0 ) return kFALSE; // No track found in opposite hemisphere
1402 
1403  if( ptLeadHad < fMinLeadHadPt || ptLeadHad > fMaxLeadHadPt ) return kFALSE;
1404 
1405  //printf("Accept leading hadron pT \n");
1406 
1407  if( dphiLeadHad < fMinLeadHadPhi || dphiLeadHad > fMaxLeadHadPhi ) return kFALSE;
1408 
1409  //printf("Accept leading hadron phi \n");
1410 
1411  return kTRUE ;
1412 }
1413 
1414 //____________________________________________________________
1416 //____________________________________________________________
1418 {
1419  TString parList ; //this will be list of parameters used for this analysis.
1420  const Int_t buffersize = 560;
1421  char onePar[buffersize] ;
1422 
1423  snprintf(onePar,buffersize,"--- AliAnaPaticleHadronCorrelation ---:") ;
1424  parList+=onePar ;
1425  snprintf(onePar,buffersize," %3.2f < Pt associated < %3.2f; ", fMinAssocPt, fMaxAssocPt) ;
1426  parList+=onePar ;
1427  snprintf(onePar,buffersize," %3.2f < Phi trigger particle-Hadron < %3.2f; ", fDeltaPhiMinCut, fDeltaPhiMaxCut) ;
1428  parList+=onePar ;
1429  snprintf(onePar,buffersize," %3.2f < Phi trigger particle-UeHadron < %3.2f; ", fUeDeltaPhiMinCut, fUeDeltaPhiMaxCut) ;
1430  parList+=onePar ;
1431  snprintf(onePar,buffersize,"Isolated Trigger? %d;", fSelectIsolated) ;
1432  parList+=onePar ;
1433  snprintf(onePar,buffersize,"Several UE? %d;", fMakeSeveralUE) ;
1434  parList+=onePar ;
1435  snprintf(onePar,buffersize,"Name of AOD Pi0 Branch %s;", fPi0AODBranchName.Data());
1436  parList+=onePar ;
1437  snprintf(onePar,buffersize,"Do Decay-hadron correlation ? pi0 %d, decay %d;", fPi0Trigger, fDecayTrigger) ;
1438  parList+=onePar ;
1439  snprintf(onePar,buffersize,"Select absolute leading for cluster triggers ? %d or Near Side Leading %d;",
1441  parList+=onePar ;
1442  snprintf(onePar,buffersize,"Associated particle pt bins %d: ", fNAssocPtBins) ;
1443  parList+=onePar ;
1444  for (Int_t ibin = 0; ibin<fNAssocPtBins; ibin++) {
1445  snprintf(onePar,buffersize,"bin %d = [%2.1f,%2.1f];", ibin, fAssocPtBinLimit[ibin], fAssocPtBinLimit[ibin+1]) ;
1446  }
1447  parList+=onePar ;
1448 
1449  //Get parameters set in base class.
1450  parList += GetBaseParametersList() ;
1451 
1452  //Get parameters set in FiducialCut class (not available yet)
1453  //parlist += GetFidCut()->GetFidCutParametersList()
1454 
1455  return new TObjString(parList) ;
1456 }
1457 
1458 //________________________________________________________________
1461 //________________________________________________________________
1463 {
1464  TList * outputContainer = new TList() ;
1465  outputContainer->SetName("CorrelationHistos") ;
1466 
1467  Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins(); Int_t netabins = GetHistogramRanges()->GetHistoEtaBins();
1468  Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t phimax = GetHistogramRanges()->GetHistoPhiMax(); Float_t etamax = GetHistogramRanges()->GetHistoEtaMax();
1469  Float_t ptmin = GetHistogramRanges()->GetHistoPtMin(); Float_t phimin = GetHistogramRanges()->GetHistoPhiMin(); Float_t etamin = GetHistogramRanges()->GetHistoEtaMin();
1470 
1471  Int_t ndeltaphibins = GetHistogramRanges()->GetHistoDeltaPhiBins(); Int_t ndeltaetabins = GetHistogramRanges()->GetHistoDeltaEtaBins();
1472  Float_t deltaphimax = GetHistogramRanges()->GetHistoDeltaPhiMax(); Float_t deltaetamax = GetHistogramRanges()->GetHistoDeltaEtaMax();
1473  Float_t deltaphimin = GetHistogramRanges()->GetHistoDeltaPhiMin(); Float_t deltaetamin = GetHistogramRanges()->GetHistoDeltaEtaMin();
1474 
1478 
1479  Int_t nxeztbins = GetHistogramRanges()->GetHistoRatioBins(); Int_t nhbpbins = GetHistogramRanges()->GetHistoHBPBins();
1480  Float_t xeztmax = GetHistogramRanges()->GetHistoRatioMax(); Float_t hbpmax = GetHistogramRanges()->GetHistoHBPMax();
1481  Float_t xeztmin = GetHistogramRanges()->GetHistoRatioMin(); Float_t hbpmin = GetHistogramRanges()->GetHistoHBPMin();
1482 
1483  Int_t nMixBins = GetNCentrBin()*GetNZvertBin()*GetNRPBin();
1484 
1485  Int_t nmassbins = GetHistogramRanges()->GetHistoMassBins();
1486  Float_t massmin = GetHistogramRanges()->GetHistoMassMin();
1487  Float_t massmax = GetHistogramRanges()->GetHistoMassMax();
1488 
1489  TString nameMC[] = {"Photon","Pi0","Pi0Decay","Eta","EtaDecay","OtherDecay","Electron","Hadron","Pi0DecayLostPair","EtaDecayLostPair"};
1490  TString mcPartType[] = { "#gamma", "#pi^{0} (merged #gamma)", "#gamma_{#pi decay}","#eta (merged #gamma)" , "#gamma_{#eta decay}", "#gamma_{other decay}" , "e^{#pm}" , "hadrons?" , "#gamma_{#pi decay} lost companion", "#gamma_{#eta decay} lost companion"} ;
1491  TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ;
1492 
1493  TString parTitle = Form("#it{R} = %2.2f",GetIsolationCut()->GetConeSize());
1494 
1495  // For vz dependent histograms, if option ON
1496  Int_t nz = 1 ;
1497  if(fCorrelVzBin) nz = GetNZvertBin();
1498  TString sz = "" ;
1499  TString tz = "" ;
1500 
1501  // Fill histograms for neutral clusters in mixing?
1503  Bool_t neutralMix = fFillNeutralEventMixPool || isoCase ;
1504 
1505  fhPtTriggerInput = new TH1F("hPtTriggerInput","Input trigger #it{p}_{T}", nptbins,ptmin,ptmax);
1506  fhPtTriggerInput->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1507  outputContainer->Add(fhPtTriggerInput);
1508 
1509  if( fM02MaxCut > 0 && fM02MinCut > 0 )
1510  {
1511  fhPtTriggerSSCut = new TH1F("hPtTriggerSSCut","Trigger #it{p}_{T} after #lambda^{2}_{0} cut", nptbins,ptmin,ptmax);
1512  fhPtTriggerSSCut->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1513  outputContainer->Add(fhPtTriggerSSCut);
1514  }
1515 
1516  if( OnlyIsolated() )
1517  {
1518  fhPtTriggerIsoCut = new TH1F("hPtTriggerIsoCut","Trigger #it{p}_{T} after isolation (and #lambda^{2}_{0} cut)", nptbins,ptmin,ptmax);
1519  fhPtTriggerIsoCut->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1520  outputContainer->Add(fhPtTriggerIsoCut);
1521  }
1522 
1523  fhPtTriggerFidCut = new TH1F("hPtTriggerFidCut","Trigger #it{p}_{T} after fiducial (isolation and #lambda^{2}_{0}) cut", nptbins,ptmin,ptmax);
1524  fhPtTriggerFidCut->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1525  outputContainer->Add(fhPtTriggerFidCut);
1526 
1527  fhPtTrigger = new TH1F("hPtTrigger","#it{p}_{T} distribution of trigger particles (after opposite hadron leading cut and rest)", nptbins,ptmin,ptmax);
1528  fhPtTrigger->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1529  outputContainer->Add(fhPtTrigger);
1530 
1531  if(fFillInvMassHisto)
1532  {
1533  fhMassPtTrigger = new TH2F("hMassPtTrigger","2 photons invariant mass vs p_{T}^{trig}",
1534  nptbins,ptmin,ptmax,nmassbins,massmin,massmax);
1535  fhMassPtTrigger->SetYTitle("M_{#gamma#gamma} (GeV/#it{c}^{2})");
1536  fhMassPtTrigger->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1537  outputContainer->Add(fhMassPtTrigger);
1538  }
1539 
1540  if(fFillBkgBinsHisto)
1541  {
1542 
1543  fhPtLeadInConeBin = new TH1F*[fNBkgBin] ;
1544 
1545  fhPtSumInConeBin = new TH1F*[fNBkgBin] ;
1546 
1548 
1550 
1551  fhPtLeadConeBinMC = new TH1F*[fNBkgBin*fgkNmcTypes] ;
1552 
1553  fhSumPtConeBinMC = new TH1F*[fNBkgBin*fgkNmcTypes] ;
1554 
1555  for(Int_t ibin = 0; ibin < fNBkgBin; ibin++)
1556  {
1557  fhPtLeadInConeBin[ibin] = new TH1F
1558  (Form("hPtLeadCone_Bin%d",ibin),
1559  Form("cone %2.2f<#it{p}_{T}^{leading}<%2.2f GeV/#it{c}, %s",
1560  fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax);
1561  fhPtLeadInConeBin[ibin]->SetYTitle("d #it{N} / d #it{p}_{T}");
1562  fhPtLeadInConeBin[ibin]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1563  outputContainer->Add(fhPtLeadInConeBin[ibin]) ;
1564 
1565  fhPtSumInConeBin[ibin] = new TH1F
1566  (Form("hSumPtCone_Bin%d",ibin),
1567  Form("in cone %2.2f <#Sigma #it{p}_{T}< %2.2f GeV/#it{c}, %s",
1568  fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax);
1569  fhPtSumInConeBin[ibin]->SetYTitle("d #it{N} / d #it{p}_{T}");
1570  fhPtSumInConeBin[ibin]->SetXTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
1571  outputContainer->Add(fhPtSumInConeBin[ibin]) ;
1572 
1574  {
1575  for(Int_t idecay = 0; idecay < fNDecayBits; idecay++)
1576  {
1577  Int_t bindecay = ibin+idecay*fNBkgBin;
1578 
1579  fhPtLeadConeBinDecay[bindecay] = new TH1F
1580  (Form("hPtLeadCone_Bin%d_DecayBit%d",ibin,fDecayBits[idecay]),
1581  Form("Decay bit %d, cone %2.2f<#it{p}_{T}^{leading}<%2.2f GeV/#it{c}, %s",
1582  fDecayBits[idecay],fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax);
1583  fhPtLeadConeBinDecay[bindecay]->SetYTitle("d #it{N} / d #it{p}_{T}");
1584  fhPtLeadConeBinDecay[bindecay]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1585  outputContainer->Add(fhPtLeadConeBinDecay[bindecay]) ;
1586 
1587  fhSumPtConeBinDecay[bindecay] = new TH1F
1588  (Form("hSumPtCone_Bin%d_DecayBit%d",ibin,fDecayBits[idecay]),
1589  Form("Decay bit %d, in cone %2.2f <#Sigma #it{p}_{T}< %2.2f GeV/#it{c}, %s",
1590  fDecayBits[idecay],fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax);
1591  fhSumPtConeBinDecay[bindecay]->SetYTitle("d #it{N} / d #it{p}_{T}");
1592  fhSumPtConeBinDecay[bindecay]->SetXTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
1593  outputContainer->Add(fhSumPtConeBinDecay[bindecay]) ;
1594  }
1595  }
1596 
1597  if(IsDataMC())
1598  {
1599  for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
1600  {
1601  Int_t binmc = ibin+imc*fNBkgBin;
1602  fhPtLeadConeBinMC[binmc] = new TH1F
1603  (Form("hPtLeadCone_Bin%d_MC%s",ibin, nameMC[imc].Data()),
1604  Form("in cone %2.2f<#it{p}_{T}^{leading}<%2.2f GeV/#it{c}, MC %s, %s",
1605  fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax);
1606  fhPtLeadConeBinMC[binmc]->SetYTitle("d #it{N} / d #it{p}_{T}");
1607  fhPtLeadConeBinMC[binmc]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1608  outputContainer->Add(fhPtLeadConeBinMC[binmc]) ;
1609 
1610  fhSumPtConeBinMC[binmc] = new TH1F
1611  (Form("hSumPtCone_Bin%d_MC%s",ibin,nameMC[imc].Data()),
1612  Form("in cone %2.2f <#Sigma #it{p}_{T}< %2.2f GeV/#it{c}, MC %s, %s",
1613  fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax);
1614  fhSumPtConeBinMC[binmc]->SetYTitle("d #it{N} / d #it{p}_{T}");
1615  fhSumPtConeBinMC[binmc]->SetXTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
1616  outputContainer->Add(fhSumPtConeBinMC[binmc]) ;
1617  } // MC particle loop
1618  }
1619  }
1620  }
1621 
1622  if(IsDataMC())
1623  {
1624  for(Int_t i=0; i < fgkNmcTypes; i++)
1625  {
1626  fhPtTriggerMC[i] = new TH1F(Form("hPtTrigger_MC%s",nameMC[i].Data()),
1627  Form("#it{p}_{T} distribution of trigger particles, trigger origin is %s",nameMC[i].Data()),
1628  nptbins,ptmin,ptmax);
1629  fhPtTriggerMC[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1630  outputContainer->Add(fhPtTriggerMC[i]);
1631 
1632  if(fFillInvMassHisto)
1633  {
1634  fhMCMassPtTrigger[i] = new TH2F(Form("hMassPtTrigger_MC%s",nameMC[i].Data()),
1635  Form("2 photons invariant mass, trigger origin is %s",nameMC[i].Data()),
1636  nptbins,ptmin,ptmax,nmassbins,massmin,massmax);
1637  fhMCMassPtTrigger[i]->SetYTitle("m_{#gamma#gamma}");
1638  fhMCMassPtTrigger[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1639  outputContainer->Add(fhMCMassPtTrigger[i]) ;
1640  }
1641  }
1642  }
1643 
1644  if(fDecayTrigger)
1645  {
1646  for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
1647  {
1648  fhPtDecayTrigger[ibit] = new TH1F(Form("hPtDecayTrigger_bit%d",fDecayBits[ibit]),
1649  Form("#it{p}_{T} distribution of trigger particles, decay Bit %d",fDecayBits[ibit]),
1650  nptbins,ptmin,ptmax);
1651  fhPtDecayTrigger[ibit]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1652  outputContainer->Add(fhPtDecayTrigger[ibit]);
1653 
1654  if(IsDataMC())
1655  {
1656  for(Int_t i=0; i < fgkNmcTypes; i++)
1657  {
1658  fhPtDecayTriggerMC[ibit][i] = new TH1F(Form("hPtDecayTrigger_bit%d_MC%s",fDecayBits[ibit], nameMC[i].Data()),
1659  Form("#it{p}_{T} distribution of trigger particles, decay Bit %d, trigger origin is %s",fDecayBits[ibit], nameMC[i].Data()),
1660  nptbins,ptmin,ptmax);
1661  fhPtDecayTriggerMC[ibit][i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1662  outputContainer->Add(fhPtDecayTriggerMC[ibit][i]);
1663  }
1664  }
1665  }
1666  }
1667 
1668  if(fCorrelVzBin)
1669  {
1670  fhPtTriggerVzBin = new TH2F("hPtTriggerVzBin","#it{p}_{T} distribution of trigger particles vs vz bin", nptbins,ptmin,ptmax,GetNZvertBin(),0,GetNZvertBin());
1671  fhPtTriggerVzBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1672  fhPtTriggerVzBin->SetYTitle("#it{v}_{#it{z}} bin");
1673  outputContainer->Add(fhPtTriggerVzBin);
1674  }
1675 
1676  fhPtTriggerBin = new TH2F ("hPtTriggerBin","#it{p}_{T} distribution of trigger particles", nptbins,ptmin,ptmax,nMixBins,0,nMixBins);
1677  fhPtTriggerBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1678  fhPtTriggerBin->SetYTitle("Bin");
1679  outputContainer->Add(fhPtTriggerBin);
1680 
1681  fhPhiTrigger = new TH2F ("hPhiTrigger","#phi distribution of trigger Particles",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
1682  fhPhiTrigger->SetYTitle("#phi (rad)");
1683  outputContainer->Add(fhPhiTrigger);
1684 
1685  fhEtaTrigger = new TH2F ("hEtaTrigger","#eta distribution of trigger",nptbins,ptmin,ptmax, netabins,etamin,etamax);
1686  fhEtaTrigger->SetYTitle("#eta ");
1687  outputContainer->Add(fhEtaTrigger);
1688 
1690  {
1691  fhPtTriggerCentrality = new TH2F("hPtTriggerCentrality","Trigger particle #it{p}_{T} vs centrality",nptbins,ptmin,ptmax,100,0.,100) ;
1692  fhPtTriggerCentrality->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1693  fhPtTriggerCentrality->SetYTitle("Centrality (%)");
1694  outputContainer->Add(fhPtTriggerCentrality) ;
1695 
1696  fhPtTriggerEventPlane = new TH2F("hPtTriggerEventPlane","Trigger particle #it{p}_{T} vs event plane angle",nptbins,ptmin,ptmax, 100,0.,TMath::Pi()) ;
1697  fhPtTriggerEventPlane->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1698  fhPtTriggerEventPlane->SetXTitle("EP angle (rad)");
1699  outputContainer->Add(fhPtTriggerEventPlane) ;
1700 
1701  fhTriggerEventPlaneCentrality = new TH2F("hTriggerEventPlaneCentrality","Trigger particle centrality vs event plane angle",100,0.,100,100,0.,TMath::Pi()) ;
1702  fhTriggerEventPlaneCentrality->SetXTitle("Centrality (%)");
1703  fhTriggerEventPlaneCentrality->SetYTitle("EP angle (rad)");
1704  outputContainer->Add(fhTriggerEventPlaneCentrality) ;
1705  }
1706 
1707  // Leading hadron in oposite side
1709  {
1710  fhPtLeadingOppositeHadron = new TH2F("hPtTriggerPtLeadingOppositeHadron","Leading hadron opposite to trigger vs trigger #it{p}_{T}",
1711  nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
1712  fhPtLeadingOppositeHadron->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1713  fhPtLeadingOppositeHadron->SetYTitle("#it{p}_{T}^{lead hadron} (GeV/#it{c})");
1714  outputContainer->Add(fhPtLeadingOppositeHadron);
1715 
1716  fhPtNoLeadingOppositeHadron = new TH1F("hPtTriggerNoLeadingOppositeHadron","No Leading hadron opposite to trigger #it{p}_{T}",
1717  nptbins,ptmin,ptmax);
1718  fhPtNoLeadingOppositeHadron->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1719  outputContainer->Add(fhPtNoLeadingOppositeHadron);
1720 
1721  fhEtaPhiNoLeadingOppositeHadron = new TH2F("hEtaPhiTriggerNoLeadingOppositeHadron","No Leading hadron opposite to trigger #eta:#phi",
1722  netabins,etamin,etamax,nphibins,phimin,phimax);
1723  fhEtaPhiNoLeadingOppositeHadron->SetXTitle("#eta");
1724  fhEtaPhiNoLeadingOppositeHadron->SetYTitle("#phi");
1725  outputContainer->Add(fhEtaPhiNoLeadingOppositeHadron);
1726 
1727 
1728  fhPtDiffPhiLeadingOppositeHadron = new TH2F("hPtTriggerDiffPhiTriggerLeadingOppositeHadron","#phi_{trigger}-#phi_{leading opposite hadron} vs #it{p}_{T}^{trig}",
1729  nptbins,ptmin,ptmax,ndeltaphibins,deltaphimin,deltaphimax);
1730  fhPtDiffPhiLeadingOppositeHadron->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1731  fhPtDiffPhiLeadingOppositeHadron->SetYTitle("#phi_{trigger}-#phi_{leading opposite hadron} (rad)");
1732  outputContainer->Add(fhPtDiffPhiLeadingOppositeHadron);
1733 
1734  fhPtDiffEtaLeadingOppositeHadron = new TH2F("hPtTriggerDiffEtaTriggerPhiLeadingOppositeHadron","#eta_{trigger}-#eta_{leading opposite hadron} vs #it{p}_{T}^{trig}",
1735  nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
1736  fhPtDiffEtaLeadingOppositeHadron->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1737  fhPtDiffEtaLeadingOppositeHadron->SetYTitle("#eta_{trigger}-#eta_{leading opposite hadron}");
1738  outputContainer->Add(fhPtDiffEtaLeadingOppositeHadron);
1739  }
1740 
1741  // Correlation with charged hadrons
1742 
1743  fhDeltaPhiDeltaEtaCharged = new TH2F
1744  ("hDeltaPhiDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}}",
1745  ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
1746  fhDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
1747  fhDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
1748 
1750  ("hDeltaPhiDeltaEtaChargedPtA3GeV","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}, #it{p}_{TA}>3 GeV/#it{c}}",
1751  ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
1752  fhDeltaPhiDeltaEtaChargedPtA3GeV->SetXTitle("#Delta #phi (rad)");
1753  fhDeltaPhiDeltaEtaChargedPtA3GeV->SetYTitle("#Delta #eta");
1754 
1755  fhPhiCharged = new TH2F
1756  ("hPhiCharged","#phi_{h^{#pm}} vs #it{p}_{T #pm}",
1757  nptbins,ptmin,ptmax,180,0,TMath::TwoPi());
1758  fhPhiCharged->SetYTitle("#phi_{h^{#pm}} (rad)");
1759  fhPhiCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
1760 
1761  fhEtaCharged = new TH2F
1762  ("hEtaCharged","#eta_{h^{#pm}} vs #it{p}_{T #pm}",
1763  nptbins,ptmin,ptmax,100,-1.,1.);
1764  fhEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)");
1765  fhEtaCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
1766 
1767  fhDeltaPhiCharged = new TH2F
1768  ("hDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}",
1769  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1770  fhDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
1771  fhDeltaPhiCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1772 
1773  fhDeltaPhiChargedPtA3GeV = new TH2F
1774  ("hDeltaPhiChargedPtA3GeV","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}",
1775  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1776  fhDeltaPhiChargedPtA3GeV->SetYTitle("#Delta #phi (rad)");
1777  fhDeltaPhiChargedPtA3GeV->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1778 
1779 
1780  fhDeltaPhiChargedPt = new TH2F
1781  ("hDeltaPhiChargedPt","#phi_{trigger} - #phi_{#h^{#pm}} vs #it{p}_{T h^{#pm}}",
1782  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1783  fhDeltaPhiChargedPt->SetYTitle("#Delta #phi (rad)");
1784  fhDeltaPhiChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1785 
1786  fhDeltaEtaCharged = new TH2F
1787  ("hDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}",
1788  nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
1789  fhDeltaEtaCharged->SetYTitle("#Delta #eta");
1790  fhDeltaEtaCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1791 
1792  fhDeltaEtaChargedPtA3GeV = new TH2F
1793  ("hDeltaEtaChargedPtA3GeV","#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}",
1794  nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
1795  fhDeltaEtaChargedPtA3GeV->SetYTitle("#Delta #eta");
1796  fhDeltaEtaChargedPtA3GeV->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1797 
1798  fhXECharged =
1799  new TH2F("hXECharged","#it{x}_{#it{E}} for charged tracks",
1800  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1801  fhXECharged->SetYTitle("#it{x}_{#it{E}}");
1802  fhXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1803 
1805  new TH2F("hXECharged_Cone2","#it{x}_{#it{E}} for charged tracks in cone 2 (5#pi/6-7#pi/6)",
1806  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1807  fhXECharged_Cone2->SetYTitle("#it{x}_{#it{E}}");
1808  fhXECharged_Cone2->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1809 
1810  fhXEPosCharged =
1811  new TH2F("hXEPositiveCharged","#it{x}_{#it{E}} for positive charged tracks",
1812  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1813  fhXEPosCharged->SetYTitle("#it{x}_{#it{E}}");
1814  fhXEPosCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1815 
1816  fhXENegCharged =
1817  new TH2F("hXENegativeCharged","#it{x}_{#it{E}} for negative charged tracks",
1818  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1819  fhXENegCharged->SetYTitle("#it{x}_{#it{E}}");
1820  fhXENegCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1821 
1823  new TH2F("hHbpXECharged","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons",
1824  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
1825  fhPtHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
1826  fhPtHbpXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1827 
1829  new TH2F("hHbpXECharged_Cone2","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons in cone 2 (5#pi/6-7#pi/6)",
1830  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
1831  fhPtHbpXECharged_Cone2->SetYTitle("ln(1/#it{x}_{#it{E}})");
1832  fhPtHbpXECharged_Cone2->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1833 
1834  fhZTCharged =
1835  new TH2F("hZTCharged","#it{z}_{T} for charged tracks",
1836  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1837  fhZTCharged->SetYTitle("#it{z}_{T}");
1838  fhZTCharged->SetXTitle("#it{p}_{T trigger}");
1839 
1840  fhZTPosCharged =
1841  new TH2F("hZTPositiveCharged","#it{z}_{T} for positive charged tracks",
1842  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1843  fhZTPosCharged->SetYTitle("#it{z}_{T}");
1844  fhZTPosCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1845 
1846  fhZTNegCharged =
1847  new TH2F("hZTNegativeCharged","#it{z}_{T} for negative charged tracks",
1848  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1849  fhZTNegCharged->SetYTitle("#it{z}_{T}");
1850  fhZTNegCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1851 
1853  new TH2F("hHbpZTCharged","#xi = ln(1/#it{z}_{T}) with charged hadrons",
1854  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
1855  fhPtHbpZTCharged->SetYTitle("ln(1/#it{z}_{T})");
1856  fhPtHbpZTCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1857 
1858  fhPtTrigPout =
1859  new TH2F("hPtTrigPout","Pout with triggers",
1860  nptbins,ptmin,ptmax,nptbins,-1.*ptmax/2.,ptmax/2.);
1861  fhPtTrigPout->SetYTitle("#it{p}_{out} (GeV/#it{c})");
1862  fhPtTrigPout->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1863 
1864  fhPtTrigCharged =
1865  new TH2F("hPtTrigCharged","trigger and charged tracks pt distribution",
1866  nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
1867  fhPtTrigCharged->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1868  fhPtTrigCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1869 
1870  outputContainer->Add(fhDeltaPhiDeltaEtaCharged);
1871  outputContainer->Add(fhDeltaPhiDeltaEtaChargedPtA3GeV);
1872  outputContainer->Add(fhPhiCharged) ;
1873  outputContainer->Add(fhEtaCharged) ;
1874  outputContainer->Add(fhDeltaPhiCharged) ;
1875  outputContainer->Add(fhDeltaPhiChargedPtA3GeV) ;
1876  outputContainer->Add(fhDeltaEtaCharged) ;
1877  outputContainer->Add(fhDeltaEtaChargedPtA3GeV) ;
1878  outputContainer->Add(fhDeltaPhiChargedPt) ;
1879 
1880  outputContainer->Add(fhXECharged) ;
1881  outputContainer->Add(fhXECharged_Cone2) ;
1882 
1883  if(IsDataMC())
1884  {
1885  for(Int_t i=0; i < fgkNmcTypes; i++)
1886  {
1887 
1888  fhDeltaPhiChargedMC[i] = new TH2F(Form("hDeltaPhiCharged_MC%s",nameMC[i].Data()),
1889  Form("#Delta #phi for charged tracks, trigger origin is %s",nameMC[i].Data()),
1890  nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
1891  fhDeltaPhiChargedMC[i]->SetYTitle("#it{x}_{#it{E}}");
1892  fhDeltaPhiChargedMC[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1893  outputContainer->Add(fhDeltaPhiChargedMC[i]) ;
1894 
1895  fhXEChargedMC[i] = new TH2F(Form("hXECharged_MC%s",nameMC[i].Data()),
1896  Form("#it{x}_{#it{E}} for charged tracks, trigger origin is %s",nameMC[i].Data()),
1897  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1898  fhXEChargedMC[i]->SetYTitle("#it{x}_{#it{E}}");
1899  fhXEChargedMC[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1900  outputContainer->Add(fhXEChargedMC[i]) ;
1901 
1902  fhXEUeChargedRightMC[i] = new TH2F(Form("hXEUeChargedRight_MC%s",nameMC[i].Data()),
1903  Form("#it{x}_{#it{E}} for charged tracks in right UE cone, trigger origin is %s",nameMC[i].Data()),
1904  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1905  fhXEUeChargedRightMC[i]->SetYTitle("#it{x}_{#it{E}}");
1906  fhXEUeChargedRightMC[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1907  outputContainer->Add(fhXEUeChargedRightMC[i]) ;
1908 
1909  fhXEUeChargedLeftMC[i] = new TH2F(Form("hXEUeChargedLeft_MC%s",nameMC[i].Data()),
1910  Form("#it{x}_{#it{E}} for charged tracks in left UE cone, trigger origin is %s",nameMC[i].Data()),
1911  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1912  fhXEUeChargedLeftMC[i]->SetYTitle("#it{x}_{#it{E}}");
1913  fhXEUeChargedLeftMC[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1914  outputContainer->Add(fhXEUeChargedLeftMC[i]) ;
1915  }
1916  }
1917 
1918  outputContainer->Add(fhXEPosCharged) ;
1919  outputContainer->Add(fhXENegCharged) ;
1920  outputContainer->Add(fhPtHbpXECharged) ;
1921  outputContainer->Add(fhPtHbpXECharged_Cone2) ;
1922 
1923  outputContainer->Add(fhZTCharged) ;
1924  outputContainer->Add(fhZTPosCharged) ;
1925  outputContainer->Add(fhZTNegCharged) ;
1926  outputContainer->Add(fhPtHbpZTCharged) ;
1927 
1928  outputContainer->Add(fhPtTrigPout) ;
1929  outputContainer->Add(fhPtTrigCharged) ;
1930 
1931  TString right = "";
1932  if(fMakeSeveralUE) right = "Right";
1933 
1934  fhUePart = new TH1F("hUePart","UE particles distribution vs pt trig",
1935  nptbins,ptmin,ptmax);
1936  fhUePart->SetYTitle("dNch");
1937  fhUePart->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1938 
1939  fhDeltaPhiUeChargedPt = new TH2F
1940  (Form("hDeltaPhiUe%sChargedPt",right.Data()),"#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}}",
1941  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1942  fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi (rad)");
1943  fhDeltaPhiUeChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1944 
1945  fhXEUeCharged =
1946  new TH2F(Form("hXEUeCharged%s",right.Data()),"#it{x}_{#it{E}} for Underlying Event",
1947  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1948  fhXEUeCharged->SetYTitle("#it{x}_{#it{E}}");
1949  fhXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1950 
1952  new TH2F(Form("hHbpXEUeCharged%s",right.Data()),"#xi = ln(1/#it{x}_{#it{E}}) for Underlying Event",
1953  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
1954  fhPtHbpXEUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
1955  fhPtHbpXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1956 
1957  fhZTUeCharged =
1958  new TH2F(Form("hZTUeCharged%s",right.Data()),"#it{z}_{T} for Underlying Event",
1959  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
1960  fhZTUeCharged->SetYTitle("#it{z}_{T}");
1961  fhZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1962 
1964  new TH2F(Form("hHbpZTUeCharged%s",right.Data()),"#xi = ln(1/#it{z}_{T}) for Underlying Event",
1965  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
1966  fhPtHbpZTUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
1967  fhPtHbpZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1968 
1969  outputContainer->Add(fhUePart);
1970  outputContainer->Add(fhDeltaPhiUeChargedPt) ;
1971  outputContainer->Add(fhXEUeCharged) ;
1972  outputContainer->Add(fhPtHbpXEUeCharged) ;
1973  outputContainer->Add(fhZTUeCharged) ;
1974  outputContainer->Add(fhPtHbpZTUeCharged) ;
1975 
1976  if(fMakeSeveralUE)
1977  {
1978  fhDeltaPhiUeLeftCharged = new TH2F
1979  ("hDeltaPhiUeLeftChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left side range of trigger particles",
1980  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1981  fhDeltaPhiUeLeftCharged->SetYTitle("#Delta #phi (rad)");
1982  fhDeltaPhiUeLeftCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1983  outputContainer->Add(fhDeltaPhiUeLeftCharged) ;
1984 
1985  fhDeltaPhiUeLeftUpCharged = new TH2F
1986  ("hDeltaPhiUeLeftUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left Up side range of trigger particles",
1987  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1988  fhDeltaPhiUeLeftUpCharged->SetYTitle("#Delta #phi (rad)");
1989  fhDeltaPhiUeLeftUpCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1990  outputContainer->Add(fhDeltaPhiUeLeftUpCharged) ;
1991 
1992  fhDeltaPhiUeRightUpCharged = new TH2F
1993  ("hDeltaPhiUeRightUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right Up side range of trigger particles",
1994  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1995  fhDeltaPhiUeRightUpCharged->SetYTitle("#Delta #phi (rad)");
1996  fhDeltaPhiUeRightUpCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1997  outputContainer->Add(fhDeltaPhiUeRightUpCharged) ;
1998 
1999  fhDeltaPhiUeLeftDownCharged = new TH2F
2000  ("hDeltaPhiUeLeftDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left Down side range of trigger particles",
2001  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2002  fhDeltaPhiUeLeftDownCharged->SetYTitle("#Delta #phi (rad)");
2003  fhDeltaPhiUeLeftDownCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
2004  outputContainer->Add(fhDeltaPhiUeLeftDownCharged) ;
2005 
2006  fhDeltaPhiUeRightDownCharged = new TH2F
2007  ("hDeltaPhiUeRightDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right Down side range of trigger particles",
2008  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2009  fhDeltaPhiUeRightDownCharged->SetYTitle("#Delta #phi (rad)");
2010  fhDeltaPhiUeRightDownCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
2011  outputContainer->Add(fhDeltaPhiUeRightDownCharged) ;
2012 
2014  new TH2F("hXEUeChargedLeft","#it{x}_{#it{E}} with UE left side of trigger",
2015  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2016  fhXEUeLeftCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
2017  fhXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2018  outputContainer->Add(fhXEUeLeftCharged) ;
2019 
2021  new TH2F("hXEUeChargedLeftUp","#it{x}_{#it{E}} with UE left Up side of trigger",
2022  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2023  fhXEUeLeftUpCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
2024  fhXEUeLeftUpCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2025  outputContainer->Add(fhXEUeLeftUpCharged) ;
2026 
2028  new TH2F("hXEUeChargedRightUp","#it{x}_{#it{E} h^{#pm}} with UE right Up side of trigger",
2029  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2030  fhXEUeRightUpCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
2031  fhXEUeRightUpCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2032  outputContainer->Add(fhXEUeRightUpCharged) ;
2033 
2035  new TH2F("hXEUeChargedLeftDown","#it{x}_{#it{E}} with UE left Down side of trigger",
2036  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2037  fhXEUeLeftDownCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
2038  fhXEUeLeftDownCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2039  outputContainer->Add(fhXEUeLeftDownCharged) ;
2040 
2042  new TH2F("hXEUeChargedRightDown","#it{x}_{#it{E} h^{#pm}} with UE right Down side of trigger",
2043  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2044  fhXEUeRightDownCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
2045  fhXEUeRightDownCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2046  outputContainer->Add(fhXEUeRightDownCharged) ;
2047 
2049  new TH2F("hHbpXEUeChargedLeft","#xi = ln(1/#it{x}_{#it{E}}) with charged UE left side of trigger",
2050  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2051  fhPtHbpXEUeLeftCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
2052  fhPtHbpXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2053  outputContainer->Add(fhPtHbpXEUeLeftCharged) ;
2054 
2056  new TH2F("hZTUeChargedLeft","#it{z}_{trigger h^{#pm}} = #it{p}_{T Ueh^{#pm}} / #it{p}_{T trigger} with UE left side of trigger",
2057  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2058  fhZTUeLeftCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
2059  fhZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2060  outputContainer->Add(fhZTUeLeftCharged) ;
2061 
2063  new TH2F("hHbpZTUeChargedLeft","#xi = ln(1/#it{z}_{T}) with charged UE left side of trigger",
2064  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2065  fhPtHbpZTUeLeftCharged->SetYTitle("ln(1/#it{z}_{T})");
2066  fhPtHbpZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2067  outputContainer->Add(fhPtHbpZTUeLeftCharged) ;
2068  }
2069 
2070  if(IsPileUpAnalysisOn())
2071  {
2072  fhDeltaPhiChargedOtherBC = new TH2F
2073  ("hDeltaPhiChargedOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC!=0",
2074  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2075  fhDeltaPhiChargedOtherBC->SetYTitle("#Delta #phi (rad)");
2076  fhDeltaPhiChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2077 
2079  ("hDeltaPhiChargedPtA3GeVOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC!=0",
2080  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2081  fhDeltaPhiChargedPtA3GeVOtherBC->SetYTitle("#Delta #phi (rad)");
2082  fhDeltaPhiChargedPtA3GeVOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2083 
2085  new TH2F("hPtTrigChargedOtherBC","trigger and charged tracks pt distribution, track BC!=0",
2086  nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2087  fhPtTrigChargedOtherBC->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
2088  fhPtTrigChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2089 
2091  new TH2F("hXEChargedOtherBC","#it{x}_{#it{E}} for charged tracks, track BC!=0",
2092  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2093  fhXEChargedOtherBC->SetYTitle("#it{x}_{#it{E}}");
2094  fhXEChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2095 
2097  new TH2F("hXEUeChargedOtherBC","#it{x}_{#it{E}} for Underlying Event, track BC!=0",
2098  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2099  fhXEUeChargedOtherBC->SetYTitle("#it{x}_{#it{E}}");
2100  fhXEUeChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2101 
2103  new TH2F("hZTChargedOtherBC","#it{z}_{T} for charged tracks, track BC!=0",
2104  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2105  fhZTChargedOtherBC->SetYTitle("#it{z}_{T}");
2106  fhZTChargedOtherBC->SetXTitle("#it{p}_{T trigger}");
2107 
2109  new TH2F("hZTUeChargedOtherBC","#it{z}_{T} for Underlying Event, track BC!=0",
2110  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2111  fhZTUeChargedOtherBC->SetYTitle("#it{z}_{T}");
2112  fhZTUeChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2113 
2114  outputContainer->Add(fhDeltaPhiChargedOtherBC) ;
2115  outputContainer->Add(fhDeltaPhiChargedPtA3GeVOtherBC) ;
2116  outputContainer->Add(fhXEChargedOtherBC) ;
2117  outputContainer->Add(fhXEUeChargedOtherBC) ;
2118  outputContainer->Add(fhZTChargedOtherBC) ;
2119  outputContainer->Add(fhZTUeChargedOtherBC) ;
2120  outputContainer->Add(fhPtTrigChargedOtherBC) ;
2121 
2122  fhDeltaPhiChargedBC0 = new TH2F
2123  ("hDeltaPhiChargedBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC==0",
2124  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2125  fhDeltaPhiChargedBC0->SetYTitle("#Delta #phi (rad)");
2126  fhDeltaPhiChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2127 
2128  fhDeltaPhiChargedPtA3GeVBC0 = new TH2F
2129  ("hDeltaPhiChargedPtA3GeVBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC==0",
2130  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2131  fhDeltaPhiChargedPtA3GeVBC0->SetYTitle("#Delta #phi (rad)");
2132  fhDeltaPhiChargedPtA3GeVBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2133 
2135  new TH2F("hPtTrigChargedBC0","trigger and charged tracks pt distribution, track BC==0",
2136  nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2137  fhPtTrigChargedBC0->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
2138  fhPtTrigChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2139 
2140  fhXEChargedBC0 =
2141  new TH2F("hXEChargedBC0","#it{x}_{#it{E}} for charged tracks, track BC==0",
2142  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2143  fhXEChargedBC0->SetYTitle("#it{x}_{#it{E}}");
2144  fhXEChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2145 
2147  new TH2F("hXEUeChargedBC0","#it{x}_{#it{E}} for Underlying Event, track BC==0",
2148  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2149  fhXEUeChargedBC0->SetYTitle("#it{x}_{#it{E}}");
2150  fhXEUeChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2151 
2152  fhZTChargedBC0 =
2153  new TH2F("hZTChargedBC0","#it{z}_{T} for charged tracks, track BC==0",
2154  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2155  fhZTChargedBC0->SetYTitle("#it{z}_{T}");
2156  fhZTChargedBC0->SetXTitle("#it{p}_{T trigger}");
2157 
2159  new TH2F("hZTUeChargedBC0","#it{z}_{T} for Underlying Event, track BC==0",
2160  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2161  fhZTUeChargedBC0->SetYTitle("#it{z}_{T}");
2162  fhZTUeChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2163 
2164  outputContainer->Add(fhDeltaPhiChargedBC0) ;
2165  outputContainer->Add(fhDeltaPhiChargedPtA3GeVBC0) ;
2166  outputContainer->Add(fhXEChargedBC0) ;
2167  outputContainer->Add(fhXEUeChargedBC0) ;
2168  outputContainer->Add(fhZTChargedBC0) ;
2169  outputContainer->Add(fhZTUeChargedBC0) ;
2170  outputContainer->Add(fhPtTrigChargedBC0) ;
2171 
2172  fhPtTriggerVtxBC0 = new TH1F("hPtTriggerVtxBC0","#it{p}_{T} distribution of trigger particles", nptbins,ptmin,ptmax);
2173  fhPtTriggerVtxBC0->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
2174 
2175  fhDeltaPhiChargedVtxBC0 = new TH2F
2176  ("hDeltaPhiChargedVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC==0",
2177  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2178  fhDeltaPhiChargedVtxBC0->SetYTitle("#Delta #phi (rad)");
2179  fhDeltaPhiChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2180 
2182  ("hDeltaPhiChargedPtA3GeVVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC==0",
2183  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2184  fhDeltaPhiChargedPtA3GeVVtxBC0->SetYTitle("#Delta #phi (rad)");
2185  fhDeltaPhiChargedPtA3GeVVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2186 
2188  new TH2F("hPtTrigChargedVtxBC0","trigger and charged tracks pt distribution, track BC==0",
2189  nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2190  fhPtTrigChargedVtxBC0->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
2191  fhPtTrigChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2192 
2194  new TH2F("hXEChargedVtxBC0","#it{x}_{#it{E}} for charged tracks, track BC==0",
2195  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2196  fhXEChargedVtxBC0->SetYTitle("#it{x}_{#it{E}}");
2197  fhXEChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2198 
2200  new TH2F("hXEUeChargedVtxBC0","#it{x}_{#it{E}} for Underlying Event, track BC==0",
2201  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2202  fhXEUeChargedVtxBC0->SetYTitle("#it{x}_{#it{E}}");
2203  fhXEUeChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2204 
2206  new TH2F("hZTChargedVtxBC0","#it{z}_{T} for charged tracks, track BC==0",
2207  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2208  fhZTChargedVtxBC0->SetYTitle("#it{z}_{T}");
2209  fhZTChargedVtxBC0->SetXTitle("#it{p}_{T trigger}");
2210 
2212  new TH2F("hZTUeChargedVtxBC0","#it{z}_{T} for Underlying Event, track BC==0",
2213  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2214  fhZTUeChargedVtxBC0->SetYTitle("#it{z}_{T}");
2215  fhZTUeChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2216 
2217  outputContainer->Add(fhPtTriggerVtxBC0);
2218  outputContainer->Add(fhDeltaPhiChargedVtxBC0) ;
2219  outputContainer->Add(fhDeltaPhiChargedPtA3GeVVtxBC0) ;
2220  outputContainer->Add(fhXEChargedVtxBC0) ;
2221  outputContainer->Add(fhXEUeChargedVtxBC0) ;
2222  outputContainer->Add(fhZTChargedVtxBC0) ;
2223  outputContainer->Add(fhZTUeChargedVtxBC0) ;
2224  outputContainer->Add(fhPtTrigChargedVtxBC0) ;
2225 
2226  for(Int_t i = 0 ; i < 7 ; i++)
2227  {
2228  fhPtTriggerPileUp[i] = new TH1F(Form("hPtTriggerPileUp%s",pileUpName[i].Data()),
2229  Form("#it{p}_{T} distribution of trigger particles, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
2230  fhPtTriggerPileUp[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
2231  outputContainer->Add(fhPtTriggerPileUp[i]);
2232 
2233  fhDeltaPhiChargedPileUp[i] = new TH2F(Form("hDeltaPhiChargedPileUp%s",pileUpName[i].Data()),
2234  Form("#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, %s Pile-Up event",pileUpName[i].Data()),
2235  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2236  fhDeltaPhiChargedPileUp[i]->SetYTitle("#Delta #phi (rad)");
2237  fhDeltaPhiChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2238  outputContainer->Add(fhDeltaPhiChargedPileUp[i]) ;
2239 
2240  fhDeltaPhiChargedPtA3GeVPileUp[i] = new TH2F(Form("hDeltaPhiChargedPtA3GeVPileUp%s",pileUpName[i].Data()),
2241  Form("#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, %s Pile-Up event",pileUpName[i].Data()),
2242  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2243  fhDeltaPhiChargedPtA3GeVPileUp[i]->SetYTitle("#Delta #phi (rad)");
2244  fhDeltaPhiChargedPtA3GeVPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2245  outputContainer->Add(fhDeltaPhiChargedPtA3GeVPileUp[i]) ;
2246 
2247  fhDeltaEtaChargedPileUp[i] = new TH2F(Form("hDeltaEtaChargedPileUp%s",pileUpName[i].Data()),
2248  Form("#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}, %s Pile-Up event",pileUpName[i].Data()),
2249  nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
2250  fhDeltaEtaChargedPileUp[i]->SetYTitle("#Delta #eta");
2251  fhDeltaEtaChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2252  outputContainer->Add(fhDeltaEtaChargedPileUp[i]) ;
2253 
2254  fhDeltaEtaChargedPtA3GeVPileUp[i] = new TH2F(Form("hDeltaEtaChargedPtA3GeVPileUp%s",pileUpName[i].Data()),
2255  Form("#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, %s Pile-Up event",pileUpName[i].Data()),
2256  nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
2257  fhDeltaEtaChargedPtA3GeVPileUp[i]->SetYTitle("#Delta #eta");
2258  fhDeltaEtaChargedPtA3GeVPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2259  outputContainer->Add(fhDeltaEtaChargedPtA3GeVPileUp[i]) ;
2260 
2261  fhXEChargedPileUp[i] = new TH2F(Form("hXEChargedPileUp%s",pileUpName[i].Data()),
2262  Form("#it{x}_{#it{E}} for charged tracks, %s Pile-Up event",pileUpName[i].Data()),
2263  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2264  fhXEChargedPileUp[i]->SetYTitle("#it{x}_{#it{E}}");
2265  fhXEChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2266  outputContainer->Add(fhXEChargedPileUp[i]) ;
2267 
2268  fhXEUeChargedPileUp[i] = new TH2F(Form("hXEUeChargedPileUp%s",pileUpName[i].Data()),
2269  Form("#it{x}_{#it{E}} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()),
2270  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2271  fhXEUeChargedPileUp[i]->SetYTitle("#it{x}_{#it{E}}");
2272  fhXEUeChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2273  outputContainer->Add(fhXEUeChargedPileUp[i]) ;
2274 
2275  fhZTChargedPileUp[i] = new TH2F(Form("hZTChargedPileUp%s",pileUpName[i].Data()),
2276  Form("#it{z}_{T} for charged tracks, %s Pile-Up event",pileUpName[i].Data()),
2277  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2278  fhZTChargedPileUp[i]->SetYTitle("#it{z}_{T}");
2279  fhZTChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2280  outputContainer->Add(fhZTChargedPileUp[i]) ;
2281 
2282  fhZTUeChargedPileUp[i] = new TH2F(Form("hZTUeChargedPileUp%s",pileUpName[i].Data()),
2283  Form("#it{z}_{T} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()),
2284  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2285  fhZTUeChargedPileUp[i]->SetYTitle("#it{z}_{T}");
2286  fhZTUeChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2287  outputContainer->Add(fhZTUeChargedPileUp[i]) ;
2288 
2289  fhPtTrigChargedPileUp[i] = new TH2F(Form("hPtTrigChargedPileUp%s",pileUpName[i].Data()),
2290  Form("trigger and charged tracks pt distribution, %s Pile-Up event",pileUpName[i].Data()),
2291  nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2292  fhPtTrigChargedPileUp[i]->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
2293  fhPtTrigChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2294  outputContainer->Add(fhPtTrigChargedPileUp[i]) ;
2295  }
2296  }
2297 
2299  {
2300  Int_t nMultiBins = GetNCentrBin();
2301  fhDeltaPhiChargedMult = new TH2F*[nMultiBins] ;
2302  fhDeltaEtaChargedMult = new TH2F*[nMultiBins] ;
2303  fhXEMult = new TH2F*[nMultiBins] ;
2304  fhXEUeMult = new TH2F*[nMultiBins] ;
2305  fhZTMult = new TH2F*[nMultiBins] ;
2306  fhZTUeMult = new TH2F*[nMultiBins] ;
2307 
2308  for(Int_t im=0; im<nMultiBins; im++)
2309  {
2310  fhDeltaPhiChargedMult[im] = new TH2F
2311  (Form("hDeltaPhiCharged_Mult%d",im),Form("#Delta #phi charged Mult bin %d",im), nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2312  fhDeltaPhiChargedMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2313  fhDeltaPhiChargedMult[im]->SetYTitle("#Delta #phi (rad)");
2314 
2315  fhDeltaEtaChargedMult[im] = new TH2F
2316  (Form("hDeltaEtaCharged_Mult%d",im),Form("#Delta #eta charged Mult bin %d",im), nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax);
2317  fhDeltaEtaChargedMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2318  fhDeltaEtaChargedMult[im]->SetYTitle("#Delta #eta");
2319 
2320  fhXEMult[im] = new TH2F
2321  (Form("hXECharged_Mult%d",im),Form("#it{x}_{E} charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2322  fhXEMult[im]->SetYTitle("#it{x}_{E}");
2323  fhXEMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2324 
2325  fhXEUeMult[im] = new TH2F
2326  (Form("hXEUeCharged_Mult%d",im),Form("#it{x}_{E} UE charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2327  fhXEUeMult[im]->SetYTitle("#it{x}_{E}");
2328  fhXEUeMult[im]->SetXTitle("#it{p}_{T trigger}(GeV/#it{c})");
2329 
2330  fhZTMult[im] = new TH2F
2331  (Form("hZTCharged_Mult%d",im),Form("#it{z}_{T} charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2332  fhZTMult[im]->SetYTitle("#it{z}_{T}");
2333  fhZTMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2334 
2335  fhZTUeMult[im] = new TH2F
2336  (Form("hZTUeCharged_Mult%d",im),Form("#it{z}_{T} UE charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2337  fhZTUeMult[im]->SetYTitle("#it{z}_{T}");
2338  fhZTUeMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2339 
2340  outputContainer->Add(fhDeltaPhiChargedMult[im]) ;
2341  outputContainer->Add(fhDeltaEtaChargedMult[im]) ;
2342  outputContainer->Add(fhXEMult [im]);
2343  outputContainer->Add(fhXEUeMult[im]);
2344  outputContainer->Add(fhZTMult [im]);
2345  outputContainer->Add(fhZTUeMult[im]);
2346  }
2347  }
2348 
2349  if(fFillBradHisto)
2350  {
2351  fhAssocPtBkg = new TH2F("hAssocPtBkg", " Trigger #it{p}_{T} vs associated hadron #it{p}_{T} from background",
2352  nptbins, ptmin, ptmax,nptbins,ptmin,ptmax);
2353  fhAssocPtBkg->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2354  fhAssocPtBkg->SetYTitle("#it{p}_{T associated} (GeV/#it{c})");
2355  outputContainer->Add(fhAssocPtBkg) ;
2356 
2357  fhDeltaPhiBrad = new TH2F("hDeltaPhiBrad","atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs #it{p}_{T trigger} ",
2358  nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0);
2359  fhDeltaPhiBrad->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2360  fhDeltaPhiBrad->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi");
2361  outputContainer->Add(fhDeltaPhiBrad) ;
2362  }
2363 
2365  fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz];
2366  fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz];
2367  fhDeltaPhiAssocPtBinDEta0 = new TH2F*[fNAssocPtBins*nz];
2369  {
2370  fhXEAssocPtBin = new TH2F*[fNAssocPtBins*nz];
2371  fhZTAssocPtBin = new TH2F*[fNAssocPtBins*nz];
2372  }
2373 
2374  if(fCorrelVzBin)
2375  {
2376  fhXEVZ = new TH2F*[nz];
2377  fhZTVZ = new TH2F*[nz];
2378  }
2379 
2380  if(fFillBradHisto)
2381  fhDeltaPhiBradAssocPtBin = new TH2F*[fNAssocPtBins*nz];
2382 
2383 
2384  fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz];
2387 
2388 
2389  if(fHMPIDCorrelation)
2390  {
2391  fhDeltaPhiAssocPtBinHMPID = new TH2F*[fNAssocPtBins*nz];
2393  }
2394 
2395  for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
2396  {
2397  for(Int_t z = 0 ; z < nz ; z++)
2398  {
2399  Int_t bin = i*nz+z;
2400 
2401  if(fCorrelVzBin)
2402  {
2403  sz = Form("_vz%d",z);
2404  tz = Form(", #it{v}_{#it{z}} bin %d",z);
2405  }
2406 
2407  //printf("iAssoc %d, Vz %d, bin %d - sz %s, tz %s \n",i,z,bin,sz.Data(),tz.Data());
2408 
2409  fhDeltaPhiDeltaEtaAssocPtBin[bin] = new TH2F(Form("hDeltaPhiDeltaEtaPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
2410  Form("#Delta #phi vs #Delta #eta for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
2411  ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
2412  fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)");
2413  fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetYTitle("#Delta #eta");
2414 
2415  fhDeltaPhiAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
2416  Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
2417  nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2418  fhDeltaPhiAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2419  fhDeltaPhiAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
2420 
2421  outputContainer->Add(fhDeltaPhiDeltaEtaAssocPtBin[bin]) ;
2422  outputContainer->Add(fhDeltaPhiAssocPtBin[bin]) ;
2423 
2424  if(fFillEtaGapsHisto)
2425  {
2426  fhDeltaPhiAssocPtBinDEta08[bin] = new TH2F(Form("hDeltaPhiDeltaEta0.8PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
2427  Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
2428  nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2429  fhDeltaPhiAssocPtBinDEta08[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2430  fhDeltaPhiAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)");
2431 
2432  fhDeltaPhiAssocPtBinDEta0[bin] = new TH2F(Form("hDeltaPhiDeltaEta0PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
2433  Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0.", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
2434  nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2435  fhDeltaPhiAssocPtBinDEta0[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2436  fhDeltaPhiAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)");
2437 
2438  outputContainer->Add(fhDeltaPhiAssocPtBinDEta08[bin]) ;
2439  outputContainer->Add(fhDeltaPhiAssocPtBinDEta0[bin]) ;
2440  }
2441 
2442  if(fDecayTrigger)
2443  {
2444  fhDeltaPhiDecayChargedAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtDecayChargedAssocPt%2.1f_%2.1f%s_bit%d", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data(),fDecayBits[0]),
2445  Form("#Delta #phi vs #it{p}_{T trigger} tagged as decay for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, Bit %d", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data(),fDecayBits[0]),
2446  nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2447  fhDeltaPhiDecayChargedAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2448  fhDeltaPhiDecayChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
2449 
2450  outputContainer->Add(fhDeltaPhiDecayChargedAssocPtBin[bin]) ;
2451  }
2452 
2453  if(fFillBradHisto)
2454  {
2455  fhDeltaPhiBradAssocPtBin[bin] = new TH2F(Form("hDeltaPhiBradPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
2456  Form("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
2457  nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0);
2458  fhDeltaPhiBradAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2459  fhDeltaPhiBradAssocPtBin[bin]->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi");
2460  outputContainer->Add(fhDeltaPhiBradAssocPtBin[bin]) ;
2461  }
2462 
2463  if(fHMPIDCorrelation)
2464  {
2465  fhDeltaPhiAssocPtBinHMPID[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPID", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
2466  Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, with track having HMPID signal", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
2467  nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2468  fhDeltaPhiAssocPtBinHMPID[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})" );
2469  fhDeltaPhiAssocPtBinHMPID[bin]->SetYTitle("#Delta #phi (rad)");
2470 
2471  fhDeltaPhiAssocPtBinHMPIDAcc[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPIDAcc", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
2472  Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, with track within 5<phi<20 deg", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
2473  nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2474  fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2475  fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetYTitle("#Delta #phi (rad)");
2476 
2477  outputContainer->Add(fhDeltaPhiAssocPtBinHMPID [bin]) ;
2478  outputContainer->Add(fhDeltaPhiAssocPtBinHMPIDAcc[bin]) ;
2479  }
2480  }
2481  }
2482 
2484  {
2485  for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
2486  {
2487  fhXEAssocPtBin[i] = new TH2F(Form("hXEAssocPtBin%1.f_%1.f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
2488  Form("#it{x}_{#it{E}} vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
2489  nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax);
2490  fhXEAssocPtBin[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2491  fhXEAssocPtBin[i]->SetYTitle("#it{x}_{#it{E}}");
2492 
2493  fhZTAssocPtBin[i] = new TH2F(Form("hZTAssocPtBin%1.f_%1.f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
2494  Form("#it{z}_{T} vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
2495  nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax);
2496  fhZTAssocPtBin[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2497  fhZTAssocPtBin[i]->SetYTitle("#it{z}_{T}");
2498 
2499 
2500  outputContainer->Add(fhXEAssocPtBin[i]);
2501  outputContainer->Add(fhZTAssocPtBin[i]);
2502  }
2503  }
2504 
2505  if(fCorrelVzBin)
2506  {
2507  for(Int_t z = 0 ; z < nz ; z++)
2508  {
2509  sz = Form("_vz%d",z);
2510  tz = Form(", #it{v}_{#it{z}} bin %d",z);
2511 
2512  fhXEVZ[z] = new TH2F(Form("hXE%s", sz.Data()),
2513  Form("#it{x}_{#it{E}} vs #it{p}_{T trigger}%s", tz.Data()),
2514  nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax);
2515  fhXEVZ[z]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2516  fhXEVZ[z]->SetYTitle("#it{x}_{#it{E}}");
2517 
2518  fhZTVZ[z] = new TH2F(Form("hZT%s",sz.Data()),
2519  Form("#it{z}_{T} vs #it{p}_{T trigger}%s", tz.Data()),
2520  nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax);
2521  fhZTVZ[z]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2522  fhZTVZ[z]->SetYTitle("#it{z}_{T}");
2523 
2524  outputContainer->Add(fhXEVZ[z]);
2525  outputContainer->Add(fhZTVZ[z]);
2526  }
2527  }
2528 
2529 
2530  if(fPi0Trigger)
2531  {
2532  fhPtPi0DecayRatio = new TH2F
2533  ("hPtPi0DecayRatio","#it{p}_{T} of #pi^{0} and the ratio of pt for two decay",
2534  nptbins,ptmin,ptmax, 100,0.,2.);
2535  fhPtPi0DecayRatio->SetXTitle("#it{p}_{T}^{#pi^{0}} (GeV/#it{c})");
2536  fhPtPi0DecayRatio->SetYTitle("#it{p}_{T}^{Decay}/#it{p}_{T}^{#pi^{0}}");
2537  outputContainer->Add(fhPtPi0DecayRatio) ;
2538 
2539  fhDeltaPhiPi0DecayCharged = new TH2F
2540  ("hDeltaPhiPi0DecayCharged","#phi_{Decay} - #phi_{h^{#pm}} vs #it{p}_{T Decay}",
2541  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2542  fhDeltaPhiPi0DecayCharged->SetYTitle("#Delta #phi (rad)");
2543  fhDeltaPhiPi0DecayCharged->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})");
2544 
2546  new TH2F("hXEPi0DecayCharged","#it{x}_{#it{E}} Decay",
2547  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2548  fhXEPi0DecayCharged->SetYTitle("#it{x}_{#it{E}}");
2549  fhXEPi0DecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
2550 
2552  new TH2F("hZTPi0DecayCharged","#it{z}_{trigger h^{#pm}} = #it{p}_{T h^{#pm}} / #it{p}_{T Decay}",
2553  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2554  fhZTPi0DecayCharged->SetYTitle("#it{z}_{decay h^{#pm}}");
2555  fhZTPi0DecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
2556 
2557  outputContainer->Add(fhDeltaPhiPi0DecayCharged) ;
2558  outputContainer->Add(fhXEPi0DecayCharged) ;
2559  outputContainer->Add(fhZTPi0DecayCharged) ;
2560  }
2561 
2562  if(fDecayTrigger)
2563  {
2564  for(Int_t ibit = 0; ibit< fNDecayBits; ibit++)
2565  {
2566  fhDeltaPhiDecayCharged[ibit] = new TH2F
2567  (Form("hDeltaPhiDecayCharged_bit%d",fDecayBits[ibit]),
2568  Form("#phi_{Decay} - #phi_{h^{#pm}} vs #it{p}_{T Decay}, Bit %d",fDecayBits[ibit]),
2569  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2570  fhDeltaPhiDecayCharged[ibit]->SetYTitle("#Delta #phi (rad)");
2571  fhDeltaPhiDecayCharged[ibit]->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})");
2572 
2573  fhXEDecayCharged[ibit] =
2574  new TH2F(Form("hXEDecayCharged_bit%d",fDecayBits[ibit]),
2575  Form("#it{x}_{#it{E}} Decay, Bit %d",fDecayBits[ibit]),
2576  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2577  fhXEDecayCharged[ibit]->SetYTitle("#it{x}_{#it{E}}");
2578  fhXEDecayCharged[ibit]->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
2579 
2580  fhZTDecayCharged[ibit] =
2581  new TH2F(Form("hZTDecayCharged_bit%d",fDecayBits[ibit]),
2582  Form("#it{z}_{trigger h^{#pm}} = #it{p}_{T h^{#pm}} / #it{p}_{T Decay}, Bit %d",fDecayBits[ibit]),
2583  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2584  fhZTDecayCharged[ibit]->SetYTitle("#it{z}_{decay h^{#pm}}");
2585  fhZTDecayCharged[ibit]->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
2586 
2587  outputContainer->Add(fhDeltaPhiDecayCharged[ibit]) ;
2588  outputContainer->Add(fhXEDecayCharged[ibit]) ;
2589  outputContainer->Add(fhZTDecayCharged[ibit]) ;
2590  }
2591  }
2592 
2593  //Correlation with neutral hadrons
2594  if(fNeutralCorr)
2595  {
2596  fhDeltaPhiDeltaEtaNeutral = new TH2F
2597  ("hDeltaPhiDeltaEtaNeutral","#phi_{trigger} - #phi_{h^{0}} vs #eta_{trigger} - #eta_{h^{0}}",
2598  ndeltaphibins ,deltaphimin,deltaphimax, ndeltaetabins ,deltaetamin,deltaetamax);
2599  fhDeltaPhiDeltaEtaNeutral->SetXTitle("#Delta #phi (rad)");
2600  fhDeltaPhiDeltaEtaNeutral->SetYTitle("#Delta #eta");
2601 
2602  fhPhiNeutral = new TH2F
2603  ("hPhiNeutral","#phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}",
2604  nptbins,ptmin,ptmax,180,0,TMath::TwoPi());
2605  fhPhiNeutral->SetYTitle("#phi_{#pi^{0}} (rad)");
2606  fhPhiNeutral->SetXTitle("#it{p}_{T #pi^{0}} (GeV/#it{c})");
2607 
2608  fhEtaNeutral = new TH2F
2609  ("hEtaNeutral","#eta_{#pi^{0}} vs #it{p}_{T #pi^{0}}",
2610  nptbins,ptmin,ptmax,200,-1.,1.);
2611  fhEtaNeutral->SetYTitle("#eta_{#pi^{0}} (rad)");
2612  fhEtaNeutral->SetXTitle("#it{p}_{T #pi^{0}} (GeV/#it{c})");
2613 
2614  fhDeltaPhiNeutral = new TH2F
2615  ("hDeltaPhiNeutral","#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T trigger}",
2616  nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2617  fhDeltaPhiNeutral->SetYTitle("#Delta #phi (rad)");
2618  fhDeltaPhiNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2619 
2620  fhDeltaPhiNeutralPt = new TH2F
2621  ("hDeltaPhiNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}}",
2622  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2623  fhDeltaPhiNeutralPt->SetYTitle("#Delta #phi (rad)");
2624  fhDeltaPhiNeutralPt->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
2625 
2626  fhDeltaEtaNeutral = new TH2F
2627  ("hDeltaEtaNeutral","#eta_{trigger} - #eta_{#pi^{0}} vs #it{p}_{T trigger}",
2628  nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax);
2629  fhDeltaEtaNeutral->SetYTitle("#Delta #eta");
2630  fhDeltaEtaNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2631 
2632  fhXENeutral =
2633  new TH2F("hXENeutral","#it{x}_{#it{E}} for #pi^{0} associated",
2634  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2635  fhXENeutral->SetYTitle("#it{x}_{#it{E}}");
2636  fhXENeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2637 
2639  new TH2F("hHbpXENeutral","#xi = ln(1/#it{x}_{#it{E}})for #pi^{0} associated",
2640  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2641  fhPtHbpXENeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
2642  fhPtHbpXENeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2643 
2644  fhZTNeutral =
2645  new TH2F("hZTNeutral","#it{z}_{trigger #pi} = #it{p}_{T #pi^{0}} / #it{p}_{T trigger} for #pi^{0} associated",
2646  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2647  fhZTNeutral->SetYTitle("#it{z}_{trigger #pi^{0}}");
2648  fhZTNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2649 
2651  new TH2F("hHbpZTNeutral","#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
2652  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2653  fhPtHbpZTNeutral->SetYTitle("ln(1/#it{z}_{T})");
2654  fhPtHbpZTNeutral->SetXTitle("#it{p}_{T trigger}");
2655 
2656  outputContainer->Add(fhDeltaPhiDeltaEtaNeutral);
2657  outputContainer->Add(fhPhiNeutral) ;
2658  outputContainer->Add(fhEtaNeutral) ;
2659  outputContainer->Add(fhDeltaPhiNeutral) ;
2660  outputContainer->Add(fhDeltaPhiNeutralPt) ;
2661  outputContainer->Add(fhDeltaEtaNeutral) ;
2662  outputContainer->Add(fhXENeutral) ;
2663  outputContainer->Add(fhPtHbpXENeutral) ;
2664  outputContainer->Add(fhZTNeutral) ;
2665  outputContainer->Add(fhPtHbpZTNeutral) ;
2666 
2667  fhDeltaPhiUeNeutralPt = new TH2F
2668  (Form("hDeltaPhiUe%sNeutralPt",right.Data()),"#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}}",
2669  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2670  fhDeltaPhiUeNeutralPt->SetYTitle("#Delta #phi (rad)");
2671  fhDeltaPhiUeNeutralPt->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
2672 
2673  fhXEUeNeutral =
2674  new TH2F(Form("hXEUeNeutral%s",right.Data()),"#it{x}_{#it{E}} for #pi^{0} associated",
2675  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2676  fhXEUeNeutral->SetYTitle("#it{x}_{#it{E}}");
2677  fhXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2678 
2680  new TH2F(Form("hHbpXEUeNeutral%s",right.Data()),"#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
2681  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2682  fhPtHbpXEUeNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
2683  fhPtHbpXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2684 
2685  fhZTUeNeutral =
2686  new TH2F(Form("hZTUeNeutral%s",right.Data()),"#it{z}_{trigger #pi} = #it{p}_{T #pi^{0}} / #it{p}_{T trigger} for #pi^{0} associated",
2687  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2688  fhZTUeNeutral->SetYTitle("#it{z}_{trigger #pi^{0}}");
2689  fhZTUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2690 
2692  new TH2F(Form("hHbpZTUeNeutral%s",right.Data()),"#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
2693  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2694  fhPtHbpXEUeNeutral->SetYTitle("ln(1/#it{z}_{T})");
2695  fhPtHbpXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2696 
2697  outputContainer->Add(fhDeltaPhiUeNeutralPt) ;
2698  outputContainer->Add(fhXEUeNeutral) ;
2699  outputContainer->Add(fhPtHbpXEUeNeutral) ;
2700  outputContainer->Add(fhZTUeNeutral) ;
2701  outputContainer->Add(fhPtHbpZTUeNeutral) ;
2702 
2703  if(fMakeSeveralUE)
2704  {
2705  fhDeltaPhiUeLeftNeutral = new TH2F
2706  ("hDeltaPhiUeLeftNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs #it{p}_{T h^{0}} with neutral UE left side range of trigger particles",
2707  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2708  fhDeltaPhiUeLeftNeutral->SetYTitle("#Delta #phi (rad)");
2709  fhDeltaPhiUeLeftNeutral->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
2710  outputContainer->Add(fhDeltaPhiUeLeftNeutral) ;
2711 
2713  new TH2F("hXEUeNeutralLeft","#it{x}_{#it{E}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE left side of trigger",
2714  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2715  fhXEUeLeftNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}");
2716  fhXEUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2717  outputContainer->Add(fhXEUeLeftNeutral) ;
2718 
2720  new TH2F("hHbpXEUeNeutralLeft","#xi = ln(1/#it{x}_{#it{E}}) with neutral UE left side of trigger",
2721  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2722  fhPtHbpXEUeLeftNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
2723  fhPtHbpXEUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2724  outputContainer->Add(fhPtHbpXEUeLeftNeutral) ;
2725 
2727  new TH2F("hZTUeNeutralLeft","#it{z}_{trigger h^{0}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE left side of trigger",
2728  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2729  fhZTUeLeftNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}");
2730  fhZTUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2731  outputContainer->Add(fhZTUeLeftNeutral) ;
2732 
2734  new TH2F("hHbpZTUeNeutralLeft","#xi = ln(1/#it{z}_{T}) with neutral UE left side of trigger",
2735  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2736  fhPtHbpZTUeLeftNeutral->SetYTitle("ln(1/#it{z}_{T})");
2737  fhPtHbpZTUeLeftNeutral->SetXTitle("#it{p}_{T trigger}");
2738  outputContainer->Add(fhPtHbpZTUeLeftNeutral) ;
2739  }
2740 
2741  if(fPi0Trigger)
2742  {
2743  fhDeltaPhiPi0DecayNeutral = new TH2F
2744  ("hDeltaPhiPi0DecayNeutral","#phi_{Decay} - #phi_{h^{0}} vs #it{p}_{T Decay}",
2745  nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2746  fhDeltaPhiPi0DecayNeutral->SetYTitle("#Delta #phi (rad)");
2747  fhDeltaPhiPi0DecayNeutral->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})");
2748 
2750  new TH2F("hXEPi0DecayNeutral","#it{x}_{#it{E}} for decay trigger",
2751  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2752  fhXEPi0DecayNeutral->SetYTitle("#it{x}_{#it{E}}");
2753  fhXEPi0DecayNeutral->SetXTitle("#it{p}_{T decay}");
2754 
2756  new TH2F("hZTPi0DecayNeutral","#it{z}_{trigger h^{0}} = #it{p}_{T h^{0}} / #it{p}_{T Decay}",
2757  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2758  fhZTPi0DecayNeutral->SetYTitle("#it{z}_{h^{0}}");
2759  fhZTPi0DecayNeutral->SetXTitle("#it{p}_{T decay}");
2760 
2761  outputContainer->Add(fhDeltaPhiPi0DecayNeutral) ;
2762  outputContainer->Add(fhXEPi0DecayNeutral) ;
2763  outputContainer->Add(fhZTPi0DecayNeutral) ;
2764  }
2765  }//Correlation with neutral hadrons
2766 
2767  // If data is MC, fill more histograms, depending on origin
2768  if(IsDataMC())
2769  {
2770  for(Int_t i= fMCGenTypeMin; i <= fMCGenTypeMax; i++)
2771  {
2772  fhMCPtTrigger[i] = new TH1F (Form("hMCPtTrigger_%s",nameMC[i].Data()),
2773  Form("MC %s: generated trigger #it{p}_{T}",nameMC[i].Data()),
2774  nptbins,ptmin,ptmax);
2775  fhMCPtTrigger[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
2776 
2777  fhMCPhiTrigger[i] = new TH2F (Form("hMCPhiTrigger_%s",nameMC[i].Data()),
2778  Form("MC %s: generated trigger #phi",nameMC[i].Data()),
2779  nptbins,ptmin,ptmax, nphibins,phimin,phimax);
2780  fhMCPhiTrigger[i]->SetYTitle("#phi (rad)");
2781  fhMCPhiTrigger[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
2782 
2783  fhMCEtaTrigger[i] = new TH2F (Form("hMCEtaTrigger_%s",nameMC[i].Data()),
2784  Form("MC %s: generated trigger #eta",nameMC[i].Data()),
2785  nptbins,ptmin,ptmax, netabins,etamin,etamax);
2786  fhMCEtaTrigger[i]->SetYTitle("#eta");
2787  fhMCEtaTrigger[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
2788 
2790  {
2791  fhMCPtTriggerNotLeading[i] = new TH1F (Form("hMCPtTriggerNotLeading_%s",nameMC[i].Data()),
2792  Form("MC %s: generated trigger #it{p}_{T}, when not leading of primaries",nameMC[i].Data()),
2793  nptbins,ptmin,ptmax);
2794  fhMCPtTriggerNotLeading[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
2795 
2796  fhMCPhiTriggerNotLeading[i] = new TH2F (Form("hMCPhiTriggerNotLeading_%s",nameMC[i].Data()),
2797  Form("MC %s: generated trigger #phi, when not leading of primaries",nameMC[i].Data()),
2798  nptbins,ptmin,ptmax, nphibins,phimin,phimax);
2799  fhMCPhiTriggerNotLeading[i]->SetYTitle("#phi (rad)");
2800  fhMCPhiTriggerNotLeading[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
2801 
2802 
2803  fhMCEtaTriggerNotLeading[i] = new TH2F (Form("hMCEtaTriggerNotLeading_%s",nameMC[i].Data()),
2804  Form("MC %s: generated triogger #eta, when not leading of primaries",nameMC[i].Data()),
2805  nptbins,ptmin,ptmax, netabins,etamin,etamax);
2806  fhMCEtaTriggerNotLeading[i]->SetYTitle("#eta ");
2807  fhMCEtaTriggerNotLeading[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
2808  }
2809 
2810  fhMCEtaCharged[i] = new TH2F (Form("hMCEtaCharged_%s",nameMC[i].Data()),
2811  Form("MC %s: #eta_{h^{#pm}} vs #it{p}_{T #pm}",nameMC[i].Data()),
2812  nptbins,ptmin,ptmax,100,-1.,1.);
2813  fhMCEtaCharged[i]->SetYTitle("#eta_{h^{#pm}} (rad)");
2814  fhMCEtaCharged[i]->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
2815 
2816  fhMCPhiCharged[i] = new TH2F(Form("hMCPhiCharged_%s",nameMC[i].Data()),
2817  Form("MC %s: phi_{h^{#pm}} vs #it{p}_{T #pm}",nameMC[i].Data()),
2818  nptbins,ptmin,ptmax,180,0,TMath::TwoPi());
2819  fhMCPhiCharged[i]->SetYTitle("MC #phi_{h^{#pm}} (rad)");
2820  fhMCPhiCharged[i]->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
2821 
2822  fhMCDeltaPhiDeltaEtaCharged[i] = new TH2F (Form("hMCDeltaPhiDeltaEtaCharged_%s",nameMC[i].Data()),
2823  Form("MC %s: phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",nameMC[i].Data()),
2824  ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
2825  fhMCDeltaPhiDeltaEtaCharged[i]->SetXTitle("#Delta #phi (rad)");
2826  fhMCDeltaPhiDeltaEtaCharged[i]->SetYTitle("#Delta #eta");
2827 
2828  fhMCDeltaEtaCharged[i] = new TH2F (Form("hMCDeltaEtaCharged_%s",nameMC[i].Data()),
2829  Form("MC %s: #eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger} and #it{p}_{T assoc}",nameMC[i].Data()),
2830  nptbins,ptmin,ptmax,ndeltaetabins ,deltaetamin,deltaetamax);
2831  fhMCDeltaEtaCharged[i]->SetYTitle("#Delta #eta");
2832  fhMCDeltaEtaCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2833 
2834  fhMCDeltaPhiCharged[i] = new TH2F (Form("hMCDeltaPhiCharged_%s",nameMC[i].Data()),
2835  Form("MC %s: #phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}",nameMC[i].Data()),
2836  nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2837  fhMCDeltaPhiCharged[i]->SetYTitle("#Delta #phi (rad)");
2838  fhMCDeltaPhiCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2839 
2840  fhMCDeltaPhiChargedPt[i] = new TH2F (Form("hMCDeltaPhiChargedPt_%s",nameMC[i].Data()),
2841  Form("MC %s: #phi_{trigger} - #phi_{#h^{#pm}} vs #it{p}_{T h^{#pm}}",nameMC[i].Data()),
2842  nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2843  fhMCDeltaPhiChargedPt[i]->SetYTitle("#Delta #phi (rad)");
2844  fhMCDeltaPhiChargedPt[i]->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
2845 
2846  fhMCPtXECharged[i] = new TH2F (Form("hMCPtXECharged_%s",nameMC[i].Data()),
2847  Form("MC %s: #it{x}_{#it{E}} with charged hadrons",nameMC[i].Data()),
2848  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2849  fhMCPtXECharged[i]->SetYTitle("#it{x}_{#it{E}}");
2850  fhMCPtXECharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2851 
2852  fhMCPtHbpXECharged[i] = new TH2F(Form("hMCHbpXECharged_%s",nameMC[i].Data()),
2853  Form("MC %s: #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons",nameMC[i].Data()),
2854  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2855  fhMCPtHbpXECharged[i]->SetYTitle("ln(1/#it{x}_{#it{E}})");
2856  fhMCPtHbpXECharged[i]->SetXTitle("#it{p}_{T trigger}");
2857 
2858  fhMCPtZTCharged[i] = new TH2F(Form("hMCPtZTCharged_%s",nameMC[i].Data()),
2859  Form("MC %s: #it{z}_{T} with charged hadrons",nameMC[i].Data()),
2860  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2861  fhMCPtZTCharged[i]->SetYTitle("#it{z}_{T}");
2862  fhMCPtZTCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2863 
2864  fhMCPtHbpZTCharged[i] = new TH2F(Form("hMCHbpZTCharged_%s",nameMC[i].Data()),
2865  Form("MC %s: #xi = ln(1/#it{z}_{T}) with charged hadrons",nameMC[i].Data()),
2866  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2867  fhMCPtHbpZTCharged[i]->SetYTitle("ln(1/#it{z}_{T})");
2868  fhMCPtHbpZTCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2869 
2870  fhMCPtTrigPout[i] = new TH2F(Form("hMCPtTrigPout_%s",nameMC[i].Data()),
2871  Form("MC %s: #it{p}_{out} with triggers",nameMC[i].Data()),
2872  nptbins,ptmin,ptmax,nptbins,-1.*ptmax/2.,ptmax/2.);
2873  fhMCPtTrigPout[i]->SetYTitle("#it{p}_{out} (GeV/#it{c})");
2874  fhMCPtTrigPout[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2875 
2876  fhMCPtAssocDeltaPhi[i] = new TH2F(Form("hMCPtAssocDeltaPhi_%s",nameMC[i].Data()),
2877  Form("MC %s: #Delta #phi with associated charged hadrons",nameMC[i].Data()),
2878  nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2879  fhMCPtAssocDeltaPhi[i]->SetYTitle("#Delta #phi (rad)");
2880  fhMCPtAssocDeltaPhi[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2881 
2882  outputContainer->Add(fhMCPtTrigger[i]);
2883  outputContainer->Add(fhMCPhiTrigger[i]);
2884  outputContainer->Add(fhMCEtaTrigger[i]);
2885 
2887  {
2888  outputContainer->Add(fhMCPtTriggerNotLeading[i]);
2889  outputContainer->Add(fhMCPhiTriggerNotLeading[i]);
2890  outputContainer->Add(fhMCEtaTriggerNotLeading[i]);
2891  }
2892 
2893  outputContainer->Add(fhMCDeltaPhiDeltaEtaCharged[i]);
2894  outputContainer->Add(fhMCPhiCharged[i]) ;
2895  outputContainer->Add(fhMCEtaCharged[i]) ;
2896  outputContainer->Add(fhMCDeltaEtaCharged[i]) ;
2897  outputContainer->Add(fhMCDeltaPhiCharged[i]) ;
2898 
2899  outputContainer->Add(fhMCDeltaPhiChargedPt[i]) ;
2900  outputContainer->Add(fhMCPtXECharged[i]) ;
2901  outputContainer->Add(fhMCPtZTCharged[i]) ;
2902  outputContainer->Add(fhMCPtHbpXECharged[i]) ;
2903  outputContainer->Add(fhMCPtHbpZTCharged[i]) ;
2904  outputContainer->Add(fhMCPtTrigPout[i]) ;
2905  outputContainer->Add(fhMCPtAssocDeltaPhi[i]) ;
2906 
2907  // Underlying event
2908 
2909  fhMCUePart[i] =
2910  new TH1F(Form("hMCUePart_%s",nameMC[i].Data()),
2911  Form("MC %s: UE particles distribution vs #it{p}_{T trigger}",nameMC[i].Data()),
2912  nptbins,ptmin,ptmax);
2913  fhMCUePart[i]->SetYTitle("#it{dN}^{ch}");
2914  fhMCUePart[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2915 
2916  fhMCPtXEUeCharged[i] =
2917  new TH2F(Form("hMCPtXEUeCharged%s_%s",right.Data(),nameMC[i].Data()),
2918  Form("MC %s: #it{x}_{#it{E}} with charged hadrons, Underlying Event %s",nameMC[i].Data(),right.Data()),
2919  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2920  fhMCPtXEUeCharged[i]->SetYTitle("#it{x}_{#it{E}}");
2921  fhMCPtXEUeCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2922 
2924  new TH2F(Form("hMCPtHbpXEUeCharged%s_%s",right.Data(),nameMC[i].Data()),
2925  Form("MC %s: #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, Underlying Event %s",nameMC[i].Data(),right.Data()),
2926  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2927  fhMCPtHbpXEUeCharged[i]->SetYTitle("ln(1/#it{x}_{#it{E}})");
2928  fhMCPtHbpXEUeCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2929 
2930  fhMCPtZTUeCharged[i] =
2931  new TH2F(Form("hMCPtZTUeCharged%s_%s",right.Data(),nameMC[i].Data()),
2932  Form("MC %s: #it{z}_{T} with charged hadrons, Underlying Event %s",nameMC[i].Data(),right.Data()),
2933  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2934  fhMCPtZTUeCharged[i]->SetYTitle("#it{z}_{T}");
2935  fhMCPtZTUeCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2936 
2938  new TH2F(Form("hMCPtHbpZTUeCharged%s_%s",right.Data(),nameMC[i].Data()),
2939  Form("MC %s: #xi = ln(1/#it{z}_{T}) with charged hadrons, Underlying Event %s",nameMC[i].Data(),right.Data()),
2940  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2941  fhMCPtHbpZTUeCharged[i]->SetYTitle("ln(1/#it{z}_{T})");
2942  fhMCPtHbpZTUeCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2943 
2944  outputContainer->Add(fhMCUePart[i]);
2945  outputContainer->Add(fhMCPtXEUeCharged[i]) ;
2946  outputContainer->Add(fhMCPtZTUeCharged[i]) ;
2947  outputContainer->Add(fhMCPtHbpZTUeCharged[i]);
2948  outputContainer->Add(fhMCPtHbpXEUeCharged[i]);
2949 
2950  if(fMakeSeveralUE)
2951  {
2952  fhMCPtXEUeLeftCharged[i] = new TH2F(Form("hMCPtXEUeChargedLeft_%s",nameMC[i].Data()),
2953  Form("MC %s: #it{x}_{#it{E}} with charged hadrons, with UE left side range of trigger particles",nameMC[i].Data()),
2954  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2955  fhMCPtXEUeLeftCharged[i]->SetYTitle("#it{x}_{#it{E}}");
2956  fhMCPtXEUeLeftCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2957 
2958  fhMCPtHbpXEUeLeftCharged[i] = new TH2F(Form("hMCPtHbpXEUeChargedLeft_%s",nameMC[i].Data()),
2959  Form("MC %s: #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, with UE left side range of trigger particles",nameMC[i].Data()),
2960  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2961  fhMCPtHbpXEUeLeftCharged[i]->SetYTitle("ln(1/#it{x}_{#it{E}})");
2962  fhMCPtHbpXEUeLeftCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2963 
2964  fhMCPtZTUeLeftCharged[i] = new TH2F(Form("hMCPtZTUeChargedLeft_%s",nameMC[i].Data()),
2965  Form("MC %s: #it{z}_{T} with charged hadrons, with UE left side range of trigger particles",nameMC[i].Data()),
2966  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
2967  fhMCPtZTUeLeftCharged[i]->SetYTitle("#it{z}_{T}");
2968  fhMCPtZTUeLeftCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2969 
2970  fhMCPtHbpZTUeLeftCharged[i] = new TH2F(Form("hMCPtHbpZTUeChargedLeft_%s",nameMC[i].Data()),
2971  Form("MC %s: #xi = ln(1/#it{z}_{T}) with charged hadrons, with UE left side range of trigger particles",nameMC[i].Data()),
2972  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
2973  fhMCPtHbpZTUeLeftCharged[i]->SetYTitle("ln(1/#it{z}_{T})");
2974  fhMCPtHbpZTUeLeftCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2975 
2976  outputContainer->Add(fhMCPtXEUeLeftCharged[i]) ;
2977  outputContainer->Add(fhMCPtZTUeLeftCharged[i]) ;
2978  outputContainer->Add(fhMCPtHbpXEUeLeftCharged[i]);
2979  outputContainer->Add(fhMCPtHbpZTUeLeftCharged[i]) ;
2980 
2981  }
2982  }
2983  } // For MC histogram
2984 
2985  if(DoOwnMix())
2986  {
2987  // Create event containers
2988 
2989  if(!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForTracksExists()))
2990  {
2991  Int_t nvz = GetNZvertBin();
2992  Int_t nrp = GetNRPBin();
2993  Int_t nce = GetNCentrBin();
2994 
2995  fListMixTrackEvents= new TList*[nvz*nrp*nce] ;
2996 
2997  for( Int_t ice = 0 ; ice < nce ; ice++ )
2998  {
2999  for( Int_t ivz = 0 ; ivz < nvz ; ivz++ )
3000  {
3001  for( Int_t irp = 0 ; irp < nrp ; irp++ )
3002  {
3003  Int_t bin = GetEventMixBin(ice,ivz,irp); //ic*nvz*nrp+iz*nrp+irp;
3004 
3005  //printf("GetCreateOutputObjects - Bins : cent %d, vz %d, RP %d, event %d/%d\n",
3006  // ic,iz, irp, bin);
3007 
3008  fListMixTrackEvents[bin] = new TList() ;
3009  fListMixTrackEvents[bin]->SetOwner(kFALSE);
3010  }
3011  }
3012  }
3013  }
3014 
3015  fhPtTriggerMixed = new TH1F ("hPtTriggerMixed","#it{p}_{T} distribution of trigger particles, used for mixing", nptbins,ptmin,ptmax);
3016  fhPtTriggerMixed->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
3017 
3018  if(fCorrelVzBin)
3019  {
3020  fhPtTriggerMixedVzBin = new TH2F ("hPtTriggerMixedVzBin","#it{p}_{T} distribution of trigger particles, used for mixing", nptbins,ptmin,ptmax,GetNZvertBin(),0,GetNZvertBin());
3021  fhPtTriggerMixedVzBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
3022  fhPtTriggerMixedVzBin->SetYTitle("#it{v}_{#it{z}} bin");
3023  outputContainer->Add(fhPtTriggerMixedVzBin);
3024  }
3025 
3026  fhPtTriggerMixedBin = new TH2F ("hPtTriggerMixedBin","#it{p}_{T} distribution of trigger particles vs mixing bin", nptbins,ptmin,ptmax,nMixBins,0,nMixBins);
3027  fhPtTriggerMixedBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
3028  fhPtTriggerMixedBin->SetYTitle("Bin");
3029 
3030  fhPhiTriggerMixed = new TH2F ("hPhiTriggerMixed","#phi distribution of trigger Particles, used for mixing",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
3031  fhPhiTriggerMixed->SetYTitle("#phi (rad)");
3032 
3033  fhEtaTriggerMixed = new TH2F ("hEtaTriggerMixed","#eta distribution of trigger, used for mixing",nptbins,ptmin,ptmax, netabins,etamin,etamax);
3034  fhEtaTriggerMixed->SetYTitle("#eta ");
3035 
3036  outputContainer->Add(fhPtTriggerMixed);
3037  outputContainer->Add(fhPtTriggerMixedBin);
3038  outputContainer->Add(fhPhiTriggerMixed);
3039  outputContainer->Add(fhEtaTriggerMixed);
3040 
3041  // Fill the cluster pool only in isolation analysis or if requested
3042  if( neutralMix && (!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForCaloExists())))
3043  {
3044  Int_t nvz = GetNZvertBin();
3045  Int_t nrp = GetNRPBin();
3046  Int_t nce = GetNCentrBin();
3047 
3048  fListMixCaloEvents= new TList*[nvz*nrp*nce] ;
3049 
3050  for( Int_t ice = 0 ; ice < nce ; ice++ )
3051  {
3052  for( Int_t ivz = 0 ; ivz < nvz ; ivz++ )
3053  {
3054  for( Int_t irp = 0 ; irp < nrp ; irp++ )
3055  {
3056  Int_t bin = GetEventMixBin(ice,ivz,irp); //ic*nvz*nrp+iz*nrp+irp;
3057 
3058  //printf("GetCreateOutputObjects - Bins : cent %d, vz %d, RP %d, event %d/%d\n",
3059  // ic,iz, irp, bin);
3060 
3061  fListMixCaloEvents[bin] = new TList() ;
3062  fListMixCaloEvents[bin]->SetOwner(kFALSE);
3063  }
3064  }
3065  }
3066  }
3067 
3068  // Init the list in the reader if not done previously
3070  {
3071  if( !GetReader()->ListWithMixedEventsForTracksExists() )
3073 
3074  if( !GetReader()->ListWithMixedEventsForCaloExists() )
3076  }
3077 
3078  fhEventBin=new TH1I("hEventBin","Number of triggers per bin(cen,vz,rp)",
3081  fhEventBin->SetXTitle("event bin");
3082  outputContainer->Add(fhEventBin) ;
3083 
3084  fhEventMixBin=new TH1I("hEventMixBin","Number of triggers mixed per event bin(cen,vz,rp)",
3087  fhEventMixBin->SetXTitle("event bin");
3088  outputContainer->Add(fhEventMixBin) ;
3089 
3090  fhEventMBBin=new TH1I("hEventMBBin","Number of min bias events per bin(cen,vz,rp)",
3093  fhEventMBBin->SetXTitle("event bin");
3094  outputContainer->Add(fhEventMBBin) ;
3095 
3096  fhNtracksMB=new TH2F("hNtracksMBEvent","Number of filtered tracks in MB event per event bin",ntrbins,trmin,trmax,
3099  fhNtracksMB->SetYTitle("event bin");
3100  fhNtracksMB->SetXTitle("#it{N}_{track}");
3101  outputContainer->Add(fhNtracksMB);
3102 
3103  if( neutralMix )
3104  {
3105  fhNclustersMB=new TH2F("hNclustersMBEvent","Number of filtered clusters in MB events per event bin",nclbins,clmin,clmax,
3108  fhNclustersMB->SetYTitle("event bin");
3109  fhNclustersMB->SetXTitle("#it{N}_{cluster}");
3110  outputContainer->Add(fhNclustersMB);
3111  }
3112 
3113  fhMixDeltaPhiCharged = new TH2F
3114  ("hMixDeltaPhiCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}",
3115  nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
3116  fhMixDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
3117  fhMixDeltaPhiCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3118  outputContainer->Add(fhMixDeltaPhiCharged);
3119 
3120  fhMixDeltaPhiDeltaEtaCharged = new TH2F
3121  ("hMixDeltaPhiDeltaEtaCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",
3122  ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
3123  fhMixDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
3124  fhMixDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
3125  outputContainer->Add(fhMixDeltaPhiDeltaEtaCharged);
3126 
3127  fhMixXECharged =
3128  new TH2F("hMixXECharged","Mixed event : #it{x}_{#it{E}} for charged tracks",
3129  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
3130  fhMixXECharged->SetYTitle("#it{x}_{#it{E}}");
3131  fhMixXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3132  outputContainer->Add(fhMixXECharged);
3133 
3135  new TH2F("hMixXEUeCharged","Mixed event : #it{x}_{#it{E}} for charged tracks in Ue region",
3136  nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
3137  fhMixXEUeCharged->SetYTitle("#it{x}_{#it{E}}");
3138  fhMixXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3139  outputContainer->Add(fhMixXEUeCharged);
3140 
3142  new TH2F("hMixHbpXECharged","mixed event : #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons",
3143  nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
3144  fhMixHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
3145  fhMixHbpXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3146  outputContainer->Add(fhMixHbpXECharged);
3147 
3148  fhMixDeltaPhiChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
3149  fhMixDeltaPhiChargedAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz];
3150  fhMixDeltaPhiChargedAssocPtBinDEta0 = new TH2F*[fNAssocPtBins*nz];
3151  fhMixDeltaPhiDeltaEtaChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
3152 
3153  for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
3154  {
3155  for(Int_t z = 0 ; z < nz ; z++)
3156  {
3157  Int_t bin = i*nz+z;
3158 
3159  if(fCorrelVzBin)
3160  {
3161  sz = Form("_vz%d",z);
3162  tz = Form(", #it{v}_{#it{z}} bin %d",z);
3163  }
3164 
3165  //printf("MIX : iAssoc %d, Vz %d, bin %d - sz %s, tz %s \n",i,z,bin,sz.Data(),tz.Data());
3166 
3167  fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiDeltaEtaChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
3168  Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
3169  ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
3170  fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)");
3171  fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetYTitle("#Delta #eta");
3172 
3173  outputContainer->Add(fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]);
3174 
3175  fhMixDeltaPhiChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
3176  Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
3177  nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
3178  fhMixDeltaPhiChargedAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3179  fhMixDeltaPhiChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
3180 
3181  outputContainer->Add(fhMixDeltaPhiChargedAssocPtBin[bin]);
3182 
3183  if(fFillEtaGapsHisto)
3184  {
3185  fhMixDeltaPhiChargedAssocPtBinDEta08[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0.8ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
3186  Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
3187  nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
3188  fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3189  fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)");
3190 
3191  fhMixDeltaPhiChargedAssocPtBinDEta0[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
3192  Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
3193  nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
3194  fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3195  fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)");
3196 
3197  outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta08[bin]);
3198  outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta0[bin]);
3199  }
3200  }
3201  }
3202  }
3203 
3204  return outputContainer;
3205 }
3206 
3207 //_____________________________________________________________________________________________________________________
3215 //_____________________________________________________________________________________________________________________
3216 Bool_t AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum(Int_t indexPhoton1, Int_t indexPhoton2, Int_t idetector)
3217 {
3218  if(indexPhoton1!=-1 || indexPhoton2!=-1) return kFALSE;
3219 
3220  AliDebug(1,Form("indexPhoton1 = %d, indexPhoton2 = %d", indexPhoton1, indexPhoton2));
3221 
3222  TObjArray * clusters = 0x0 ;
3223  if(idetector==kEMCAL) clusters = GetEMCALClusters() ;
3224  else clusters = GetPHOSClusters() ;
3225 
3226  for(Int_t iclus = 0; iclus < clusters->GetEntriesFast(); iclus++)
3227  {
3228  AliVCluster * photon = (AliVCluster*) (clusters->At(iclus));
3229 
3230  if(photon->GetID()==indexPhoton1) photon->GetMomentum(fDecayMom1,GetVertex(0)) ;
3231  if(photon->GetID()==indexPhoton2) photon->GetMomentum(fDecayMom2,GetVertex(0)) ;
3232 
3233  AliDebug(1,Form("Photon1 = %f, Photon2 = %f", fDecayMom1.Pt(), fDecayMom2.Pt()));
3234  } //cluster loop
3235 
3236  return kTRUE;
3237 }
3238 
3239 //________________________________________________________________________
3242 //________________________________________________________________________
3244 {
3245  if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPrompt) ||
3247  GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCISR) ) return 0;
3248  else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) ) return 1;
3249  else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0Decay) ) return 2;
3250  else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) ) return 3;
3251  else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay) ) return 4;
3252  else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) ) return 5; // other decays
3253  else if(!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron) ) return 6;
3254  else return 7;
3255 }
3256 
3257 //_________________________________________
3259 //_________________________________________
3261 {
3262  if(!GetReader()->IsCTSSwitchedOn())
3263  AliFatal("STOP!: You want to use CTS tracks in analysis but not read!! \n!!Check the configuration file!!");
3264 }
3265 
3266 //____________________________________________________
3268 //____________________________________________________
3270 {
3271  SetInputAODName("Particle");
3272  SetAODObjArrayName("Hadrons");
3273  AddToHistogramsName("AnaHadronCorr_");
3274 
3275  SetPtCutRange(0.,300);
3276  fDeltaPhiMinCut = TMath::DegToRad()*120.;
3277  fDeltaPhiMaxCut = TMath::DegToRad()*240. ;
3278  fSelectIsolated = kFALSE;
3279  fMakeSeveralUE = kFALSE;
3280  fUeDeltaPhiMinCut = TMath::DegToRad()*60.;
3281  fUeDeltaPhiMaxCut = TMath::DegToRad()*120 ;
3282 
3283  fNeutralCorr = kFALSE ;
3284  fPi0Trigger = kFALSE ;
3285  fDecayTrigger = kFALSE ;
3286  fHMPIDCorrelation = kFALSE ;
3287 
3288  fMakeAbsoluteLeading = kTRUE;
3289  fMakeNearSideLeading = kFALSE;
3290 
3291  fNAssocPtBins = 9 ;
3292  fAssocPtBinLimit[0] = 0.2 ;
3293  fAssocPtBinLimit[1] = 0.5 ;
3294  fAssocPtBinLimit[2] = 1.0 ;
3295  fAssocPtBinLimit[3] = 2.0 ;
3296  fAssocPtBinLimit[4] = 3.0 ;
3297  fAssocPtBinLimit[5] = 4.0 ;
3298  fAssocPtBinLimit[6] = 5.0 ;
3299  fAssocPtBinLimit[7] = 6.0 ;
3300  fAssocPtBinLimit[8] = 7.0 ;
3301  fAssocPtBinLimit[9] = 8.0 ;
3302  fAssocPtBinLimit[10] = 9.0 ;
3303  fAssocPtBinLimit[11] = 10.0 ;
3304  fAssocPtBinLimit[12] = 12.0 ;
3305  fAssocPtBinLimit[13] = 14.0 ;
3306  fAssocPtBinLimit[14] = 16.0 ;
3307  fAssocPtBinLimit[15] = 20.0 ;
3308  fAssocPtBinLimit[16] = 30.0 ;
3309  fAssocPtBinLimit[17] = 40.0 ;
3310  fAssocPtBinLimit[18] = 50.0 ;
3311  fAssocPtBinLimit[19] = 200.0 ;
3312 
3313  fUseMixStoredInReader = kTRUE;
3314 
3315  fM02MinCut = -1 ;
3316  fM02MaxCut = -1 ;
3317 
3318  fDecayTagsM02Cut = 0.27;
3319 
3320  fSelectLeadingHadronAngle = kFALSE;
3321  fFillLeadHadOppositeHisto = kFALSE;
3322  fMinLeadHadPhi = 150*TMath::DegToRad();
3323  fMaxLeadHadPhi = 210*TMath::DegToRad();
3324 
3325  fMinLeadHadPt = 1;
3326  fMaxLeadHadPt = 100;
3327 
3328  fMCGenTypeMin = 0;
3329  fMCGenTypeMax = 10;
3330 
3331  fNDecayBits = 1;
3338  fDecayBits[6] = AliNeutralMesonSelection::kPi0LeftSide ; // Leave it last since likely not used
3339  fDecayBits[7] = AliNeutralMesonSelection::kPi0BothSides; // Leave it last since likely not used
3340 
3341  fNBkgBin = 11;
3342  fBkgBinLimit[ 0] = 00.0; fBkgBinLimit[ 1] = 00.2; fBkgBinLimit[ 2] = 00.3; fBkgBinLimit[ 3] = 00.4; fBkgBinLimit[ 4] = 00.5;
3343  fBkgBinLimit[ 5] = 01.0; fBkgBinLimit[ 6] = 01.5; fBkgBinLimit[ 7] = 02.0; fBkgBinLimit[ 8] = 03.0; fBkgBinLimit[ 9] = 05.0;
3344  fBkgBinLimit[10] = 10.0; fBkgBinLimit[11] = 100.;
3345  for(Int_t ibin = fNBkgBin+1; ibin < 20; ibin++)
3346  {
3347  fBkgBinLimit[ibin] = 00.0;
3348  }
3349 
3350 }
3351 
3352 //________________________________________________________________________________________________________
3357 //________________________________________________________________________________________________________
3358 void AliAnaParticleHadronCorrelation::InvMassHisto(AliAODPWG4ParticleCorrelation * trigger, Int_t mcIndex)
3359 {
3360  Int_t idTrig = trigger->GetCaloLabel(0);
3361  Float_t ptTrig = trigger->Pt();
3362  Float_t tofTrig = trigger->GetTime();
3363 
3364  fMomentum = *(trigger->Momentum());
3365 
3366  // Loop on second cluster to be associated to trigger particle to have the invariant mass
3367  Int_t nphoton = GetInputAODBranch()->GetEntriesFast();
3368 
3369  for(Int_t iphoton = 0; iphoton < nphoton; iphoton++)
3370  {
3371  AliAODPWG4ParticleCorrelation * photon1 = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iphoton));
3372 
3373  if(idTrig == photon1->GetCaloLabel(0)) continue; //Do not the invariant mass for the same particle
3374 
3375  fMomentumIM = *(photon1->Momentum());
3376 
3377  // Select secondary photon with proper invariant mass
3378  if(fM02MaxCut > 0 && fM02MinCut > 0) //clID1 > 0 && clID2 < 0 &&
3379  {
3380  Float_t m02 = photon1->GetM02();
3381 
3382  if(m02 > fM02MaxCut || m02 < fM02MinCut) continue ;
3383  }
3384 
3385  // Select clusters with good time window difference
3386  Double_t tdiff = tofTrig - photon1->GetTime();
3387  if(TMath::Abs(tdiff) > GetPairTimeCut()) continue;
3388 
3389  // Add momenta of trigger and possible secondary decay
3391 
3392  Double_t mass = fMomentumIM.M();
3393  // Double_t epair = fMomentumIM.E();
3394  // Float_t ptpair = fMomentumIM.Pt();
3395 
3396  // Mass of all pairs
3397  fhMassPtTrigger->Fill(ptTrig, mass, GetEventWeight());
3398  if ( IsDataMC() ) fhMCMassPtTrigger[mcIndex]->Fill(ptTrig, mass, GetEventWeight());
3399  }
3400 }
3401 
3402 //_________________________________________________________________________
3405 //_________________________________________________________________________
3407 {
3408  Double_t ptTrig = GetMinPt();
3409  Double_t phiTrig = 0 ;
3410  fLeadingTriggerIndex =-1 ;
3411  Int_t index =-1 ;
3412  AliAODPWG4ParticleCorrelation* pLeading = 0;
3413 
3414  // Loop on stored AOD particles, find leading trigger on the selected list, with at least min pT.
3415 
3416  for(Int_t iaod = 0; iaod < GetInputAODBranch()->GetEntriesFast() ; iaod++)
3417  {
3418  AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
3419  particle->SetLeadingParticle(kFALSE); // set it later
3420 
3421  // Vertex cut in case of mixing
3422  Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0));
3423  if(check == 0) continue;
3424  if(check == -1) return kFALSE; // not sure if it is correct.
3425 
3426  // Find the leading particles with highest momentum
3427  if (particle->Pt() > ptTrig)
3428  {
3429  ptTrig = particle->Pt() ;
3430  phiTrig = particle->Phi();
3431  index = iaod ;
3432  pLeading = particle ;
3433  }
3434  }// Finish search of leading trigger particle on the AOD branch.
3435 
3436  if(index < 0) return kFALSE;
3437 
3438  //printf("AOD leading pT %2.2f, ID %d\n", pLeading->Pt(),pLeading->GetCaloLabel(0));
3439 
3440  if(phiTrig < 0 ) phiTrig += TMath::TwoPi();
3441 
3442  // Compare if it is the leading of all tracks
3443 
3444  for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
3445  {
3446  AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
3447 
3448  if(track->GetID() == pLeading->GetTrackLabel(0) || track->GetID() == pLeading->GetTrackLabel(1) ||
3449  track->GetID() == pLeading->GetTrackLabel(2) || track->GetID() == pLeading->GetTrackLabel(3) ) continue ;
3450 
3451  fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
3452  Float_t pt = fTrackVector.Pt();
3453  Float_t phi = fTrackVector.Phi() ;
3454  if(phi < 0) phi+=TMath::TwoPi();
3455 
3456  //jump out this event if near side associated particle pt larger than trigger
3458  {
3459  Float_t deltaPhi = phiTrig-phi;
3460  if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
3461  if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
3462 
3463  if(pt > ptTrig && deltaPhi < TMath::PiOver2()) return kFALSE;
3464  }
3465  //jump out this event if there is any other particle with pt larger than trigger
3466  else
3467  {
3468  if(pt > ptTrig) return kFALSE ;
3469  }
3470  }// track loop
3471 
3472  // Compare if it is leading of all calorimeter clusters
3473 
3475  {
3476  // Select the calorimeter cluster list
3477  TObjArray * nePl = 0x0;
3478  if (pLeading->GetDetectorTag() == kPHOS )
3479  nePl = GetPHOSClusters();
3480  else
3481  nePl = GetEMCALClusters();
3482 
3483  if(!nePl) return kTRUE; // Do the selection just with the tracks if no calorimeter is available.
3484 
3485  for(Int_t ipr = 0;ipr < nePl->GetEntriesFast() ; ipr ++ )
3486  {
3487  AliVCluster * cluster = (AliVCluster *) (nePl->At(ipr)) ;
3488 
3489  if(cluster->GetID() == pLeading->GetCaloLabel(0) || cluster->GetID() == pLeading->GetCaloLabel(1) ) continue ;
3490 
3491  cluster->GetMomentum(fMomentum,GetVertex(0));
3492 
3493  Float_t pt = fMomentum.Pt();
3494  Float_t phi = fMomentum.Phi() ;
3495  if(phi < 0) phi+=TMath::TwoPi();
3496 
3497  if(IsTrackMatched(cluster,GetReader()->GetInputEvent())) continue ; // avoid charged clusters, already covered by tracks, or cluster merging with track.
3498 
3499  //jump out this event if near side associated particle pt larger than trigger
3500  // not really needed for calorimeter, unless DCal is included
3502  {
3503  Float_t deltaPhi = phiTrig-phi;
3504  if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
3505  if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
3506 
3507  if(pt > ptTrig && deltaPhi < TMath::PiOver2()) return kFALSE ;
3508  }
3509  //jump out this event if there is any other particle with pt larger than trigger
3510  else
3511  {
3512  if(pt > ptTrig) return kFALSE ;
3513  }
3514  }// cluster loop
3515  } // check neutral clusters
3516 
3517  fLeadingTriggerIndex = index ;
3518  pLeading->SetLeadingParticle(kTRUE);
3519 
3520  AliDebug(1,Form("\t particle AOD with index %d is leading with pT %2.2f", fLeadingTriggerIndex, pLeading->Pt()));
3521 
3522  return kTRUE;
3523 }
3524 
3525 //_________________________________________________________________
3539 //_________________________________________________________________
3541 {
3542  if(!GetInputAODBranch())
3543  {
3544  AliFatal(Form("No input particles in AOD with name branch < %s >, STOP",GetInputAODName().Data()));
3545  return ; // coverity
3546  }
3547 
3548  Int_t naod = GetInputAODBranch()->GetEntriesFast();
3549  if( naod == 0 )
3550  {
3551  AliDebug(1,"No particle AOD found!");
3552  return ; // no trigger particles found.
3553  }
3554 
3555  AliDebug(1,Form("Begin hadron correlation analysis, fill histograms"));
3556  AliDebug(1,Form("n particle branch aod entries %d", naod));
3557  AliDebug(1,Form("In CTS aod entries %d",GetCTSTracks()->GetEntriesFast()));
3558 
3559  //------------------------------------------------------
3560  // Find leading trigger if analysis request only leading,
3561  // if there is no leading trigger, then skip the event
3562 
3563  Int_t iaod = 0 ;
3565  {
3566  Bool_t leading = IsTriggerTheEventLeadingParticle();
3567 
3568  AliDebug(1,Form("AOD Leading trigger? %d, with index %d",leading,fLeadingTriggerIndex));
3569 
3570  if(!leading)
3571  {
3572  AliDebug(1,"Leading was requested and not found");
3573  return ;
3574  }
3575  else
3576  {
3577  // Select only the leading in the trigger AOD loop
3578  naod = fLeadingTriggerIndex+1 ;
3579  iaod = fLeadingTriggerIndex ;
3580  }
3581  }
3582 
3583  //------------------------------------------------------
3584  // Get event multiplicity and bins
3585 
3586  Float_t cen = GetEventCentrality();
3587  Float_t ep = GetEventPlaneAngle();
3589 
3590  Int_t mixEventBin = GetEventMixBin();
3591  Int_t vzbin = GetEventVzBin();
3592 
3593  //------------------------------------------------------
3594  // Loop on trigger AOD
3595 
3596  for( iaod = 0; iaod < naod; iaod++ )
3597  {
3598  AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
3599 
3600  //
3601  // Trigger particle selection criteria:
3602  //
3603  Float_t pt = particle->Pt();
3604 
3605  if(pt < GetMinPt() || pt > GetMaxPt() ) continue ;
3606 
3607  fhPtTriggerInput->Fill(pt, GetEventWeight());
3608 
3609  //
3610  // check if it was a calorimeter cluster
3611  // and if the shower shape cut was requested apply it.
3612  // Not needed if already done at the particle identification level,
3613  // but for isolation studies, it is preferred not to remove so we do it here
3614  //
3615 
3616  AliDebug(1,Form("%s Trigger : min %f, max %f, det %d",
3617  GetInputAODName().Data(),fM02MinCut,fM02MaxCut,particle->GetDetectorTag()));
3618 
3619  if(fM02MaxCut > 0 && fM02MinCut > 0) //clID1 > 0 && clID2 < 0 &&
3620  {
3621  // Int_t iclus = -1;
3622  // TObjArray* clusters = 0x0;
3623  // if (particle->GetDetectorTag() == kEMCAL) clusters = GetEMCALClusters();
3624  // else if(particle->GetDetectorTag() == kPHOS ) clusters = GetPHOSClusters();
3625  //
3626  // if(clusters)
3627  // {
3628  // AliVCluster *cluster = FindCluster(clusters,clID1,iclus);
3629  // Float_t m02 = cluster->GetM02();
3630  // if(m02 > fM02MaxCut || m02 < fM02MinCut) continue ;
3631  // }
3632 
3633  Float_t m02 = particle->GetM02();
3634 
3635  if(m02 > fM02MaxCut || m02 < fM02MinCut) continue ;
3636 
3637  fhPtTriggerSSCut->Fill(pt, GetEventWeight());
3638 
3639  AliDebug(1,"Pass the shower shape cut");
3640  }
3641 
3642  //
3643  // Check if the particle is isolated or if we want to take the isolation into account
3644  // This bool is set in AliAnaParticleIsolation
3645  //
3646  if(OnlyIsolated())
3647  {
3648  if( !particle->IsIsolated() ) continue;
3649 
3650  fhPtTriggerIsoCut->Fill(pt, GetEventWeight());
3651 
3652  AliDebug(1,"Pass the isolation cut");
3653  }
3654 
3655  //
3656  // Check if trigger is in fiducial region
3657  //
3658  if(IsFiducialCutOn())
3659  {
3660  Bool_t in = GetFiducialCut()->IsInFiducialCut(particle->Eta(),particle->Phi(),particle->GetDetectorTag()) ;
3661 
3662  if(! in ) continue ;
3663 
3664  AliDebug(1,"Pass the fiducial cut");
3665  }
3666 
3667  fhPtTriggerFidCut->Fill(pt, GetEventWeight());
3668 
3669  //---------------------------------------
3670  // Make correlation
3671 
3672  // Find the leading hadron in the opposite hemisphere to the trigger
3673  // and accept the trigger if leading is in defined window.
3674  Bool_t okLeadHad = kTRUE;
3676  {
3677  okLeadHad = FindLeadingOppositeHadronInWindow(particle);
3678  if(!okLeadHad && fSelectLeadingHadronAngle) continue;
3679  }
3680 
3681  //
3682  // Charged particles correlation
3683  //
3684  MakeChargedCorrelation(particle);
3685 
3686  // MC
3687  Int_t mcIndex = -1;
3688  Int_t mcTag = particle->GetTag();
3689  Bool_t lostDecayPair = kFALSE;
3690  if(IsDataMC())
3691  {
3692  mcIndex = GetMCTagHistogramIndex(mcTag);
3694  MakeMCChargedCorrelation(particle->GetLabel(), mcIndex,lostDecayPair);
3695  }
3696 
3697  // Do own mixed event with charged,
3698  // add event and remove previous or fill the mixed histograms
3699  if(DoOwnMix())
3700  MakeChargedMixCorrelation(particle);
3701 
3702  //
3703  // Neutral particles correlation
3704  //
3705  if(fNeutralCorr)
3706  MakeNeutralCorrelation(particle);
3707 
3708  //----------------------------------------------------------------
3709  // Fill trigger pT related histograms if not absolute leading
3710 
3711  //
3712  // pT of the trigger, vs trigger origin if MC
3713  //
3714  fhPtTrigger->Fill(pt, GetEventWeight());
3715 
3716 
3717  if(IsDataMC() && mcIndex >=0 && mcIndex < fgkNmcTypes)
3718  {
3719  fhPtTriggerMC[mcIndex]->Fill(pt, GetEventWeight());
3720  if( lostDecayPair )
3721  {
3722  // check index in GetMCTagIndexHistogram
3723  if ( mcIndex == 2 ) fhPtTriggerMC[8]->Fill(pt, GetEventWeight()); // pi0 decay
3724  else if( mcIndex == 4 ) fhPtTriggerMC[9]->Fill(pt, GetEventWeight()); // eta decay
3725  }
3726  }
3727 
3728  //
3729  // pT lead cone, pT sum cone background bins distribution
3730  //
3731  if(fFillBkgBinsHisto)
3732  {
3733  Float_t m02 = particle->GetM02();
3734  Float_t pTLeadTrackInCone = 0;
3735  Float_t pTSumTrackInCone = 0;
3736  Float_t pTLeadClusterInCone = 0;
3737  Float_t pTSumClusterInCone = 0;
3738 
3739  // Remove when AliRoot v5-06-38 is available
3740  CalculateChargedActivityInCone(particle, pTLeadTrackInCone , pTSumTrackInCone );
3741  CalculateNeutralActivityInCone(particle, pTLeadClusterInCone, pTSumClusterInCone);
3742 
3743  // Uncomment when AliRoot v5-06-38 is available
3744 // pTLeadTrackInCone = particle->GetChargedLeadPtInCone();
3745 // pTLeadClusterInCone = particle->GetNeutralLeadPtInCone();
3746 //
3747 // pTSumTrackInCone = particle->GetChargedPtSumInCone();
3748 // pTSumClusterInCone = particle->GetNeutralPtSumInCone();
3749 
3750  Float_t pTLeadInCone = pTLeadTrackInCone;
3751  if(pTLeadClusterInCone > pTLeadInCone) pTLeadInCone = pTLeadClusterInCone;
3752  Float_t pTSumInCone = pTSumTrackInCone + pTSumClusterInCone;
3753 
3754  // Get the background bin for this cone and trigger
3755  Int_t pTSumBin = -1;
3756  Int_t pTLeadBin = -1;
3757 
3758  for(Int_t ibin = 0; ibin < fNBkgBin; ibin++)
3759  {
3760  if( pTSumInCone >= fBkgBinLimit[ibin] && pTSumInCone < fBkgBinLimit[ibin+1]) pTSumBin = ibin;
3761  if( pTLeadInCone >= fBkgBinLimit[ibin] && pTLeadInCone < fBkgBinLimit[ibin+1]) pTLeadBin = ibin;
3762  }
3763  if(pTSumBin > 0)
3764  {
3765  fhPtSumInConeBin[pTSumBin]->Fill(pt, GetEventWeight());
3766  }
3767 
3768  if(pTLeadBin > 0)
3769  {
3770  fhPtLeadInConeBin[pTLeadBin]->Fill(pt, GetEventWeight());
3771  }
3772 
3773  // Check if it was a decay
3775  {
3776  Int_t decayTag = particle->DecayTag();
3777  if(decayTag < 0) decayTag = 0;
3778 
3779  for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
3780  {
3781  if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
3782  {
3783  Int_t pTLeadBinDecay = pTLeadBin+ibit*fNBkgBin;
3784  Int_t pTSumBinDecay = pTSumBin+ibit*fNBkgBin;
3785  if( pTLeadBin >=0 ) fhPtLeadConeBinDecay[pTLeadBinDecay]->Fill(pt, GetEventWeight());
3786  if( pTSumBin >=0 ) fhSumPtConeBinDecay [pTSumBinDecay] ->Fill(pt, GetEventWeight());
3787  }
3788  }
3789  }
3790 
3791  if(IsDataMC())
3792  {
3793  Int_t pTLeadBinMC = pTLeadBin+mcIndex*fNBkgBin;
3794  Int_t pTSumBinMC = pTSumBin+mcIndex*fNBkgBin;
3795 
3796  if( pTLeadBin >=0 )
3797  {
3798  fhPtLeadConeBinMC[pTLeadBinMC]->Fill(pt, GetEventWeight());
3799  }
3800 
3801  if( pTSumBin >=0 )
3802  {
3803  fhSumPtConeBinMC [pTSumBinMC]->Fill(pt, GetEventWeight());
3804  }
3805 
3806  if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
3807  {
3808  pTLeadBinMC = pTLeadBin+kmcPhoton*fNBkgBin;
3809  pTSumBinMC = pTSumBin+kmcPhoton*fNBkgBin;
3810  if( pTLeadBin >=0 )
3811  {
3812  fhPtLeadConeBinMC[pTLeadBinMC]->Fill(pt, GetEventWeight());
3813  }
3814 
3815  if( pTSumBin >=0 )
3816  {
3817  fhSumPtConeBinMC [ pTSumBinMC]->Fill(pt, GetEventWeight());
3818  }
3819  }
3820 
3821  // Check if decay and if pair is lost
3822  if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) )
3823  {
3824  if ( mcIndex == kmcPi0Decay )
3825  {
3826  pTLeadBinMC = pTLeadBin+kmcPi0DecayLostPair*fNBkgBin;
3827  pTSumBinMC = pTSumBin+kmcPi0DecayLostPair*fNBkgBin;
3828  }
3829  else if(mcIndex == kmcEtaDecay)
3830  {
3831  pTLeadBinMC = pTLeadBin+kmcEtaDecayLostPair*fNBkgBin;
3832  pTSumBinMC = pTSumBin+kmcEtaDecayLostPair*fNBkgBin;
3833  }
3834  else
3835  AliFatal(Form("Lost decay Bit assigned to bad case, mcIndex %d",mcIndex));
3836 
3837  if( pTLeadBin >=0 )
3838  {
3839  fhPtLeadConeBinMC[pTLeadBinMC]->Fill(pt, GetEventWeight());
3840  }
3841 
3842  if( pTSumBin >=0 )
3843  {
3844  fhSumPtConeBinMC [ pTSumBinMC]->Fill(pt, GetEventWeight());
3845  }
3846 
3847  }
3848 
3849  }
3850  }
3851 
3852  // Invariant mass of trigger particle
3853  if(fFillInvMassHisto) InvMassHisto(particle,mcIndex);
3854 
3855  if(fDecayTrigger)
3856  {
3857  Int_t decayTag = particle->DecayTag();
3858  if(decayTag < 0) decayTag = 0;
3859 
3860  for(Int_t ibit = 0; ibit<fNDecayBits; ibit++)
3861  {
3862  if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
3863  {
3864  fhPtDecayTrigger[ibit]->Fill(pt, GetEventWeight());
3865 
3866  if(IsDataMC() && mcIndex >=0 && mcIndex < fgkNmcTypes)
3867  {
3868  fhPtDecayTriggerMC[ibit][mcIndex]->Fill(pt, GetEventWeight());
3869  if( lostDecayPair )
3870  {
3871  // check index in GetMCTagIndexHistogram
3872  if( mcIndex == 2 ) fhPtDecayTriggerMC[ibit][8]->Fill(pt, GetEventWeight()); // pi0 decay
3873  if( mcIndex == 4 ) fhPtDecayTriggerMC[ibit][9]->Fill(pt, GetEventWeight()); // eta decay
3874  }
3875  }
3876  }// check bit
3877  }// bit loop
3878  }
3879 
3880  //
3881  // Acceptance of the trigger
3882  //
3883  Float_t phi = particle->Phi();
3884  if( phi < 0 ) phi+=TMath::TwoPi();
3885  fhPhiTrigger->Fill(pt, phi, GetEventWeight());
3886 
3887  fhEtaTrigger->Fill(pt, particle->Eta(), GetEventWeight());
3888  //printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Trigger particle : pt %f, eta %f, phi %f\n",particle->Pt(),particle->Eta(),phi);
3889 
3890  //----------------------------------
3891  // Trigger particle pT vs event bins
3892 
3893  fhPtTriggerBin->Fill(pt, mixEventBin, GetEventWeight());
3894  if(fCorrelVzBin)
3895  fhPtTriggerVzBin->Fill(pt, vzbin, GetEventWeight());
3896 
3898  {
3899  fhPtTriggerCentrality->Fill(pt, cen, GetEventWeight());
3900  fhPtTriggerEventPlane->Fill(pt, ep , GetEventWeight());
3901  }
3902 
3903  //----------------------------------
3904  // Trigger particle pT vs pile-up
3905 
3906  if(IsPileUpAnalysisOn())
3907  {
3908  Int_t vtxBC = GetReader()->GetVertexBC();
3909  if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtTriggerVtxBC0->Fill(pt, GetEventWeight());
3910 
3911  if(GetReader()->IsPileUpFromSPD()) fhPtTriggerPileUp[0]->Fill(pt, GetEventWeight());
3912  if(GetReader()->IsPileUpFromEMCal()) fhPtTriggerPileUp[1]->Fill(pt, GetEventWeight());
3913  if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtTriggerPileUp[2]->Fill(pt, GetEventWeight());
3914  if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtTriggerPileUp[3]->Fill(pt, GetEventWeight());
3915  if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtTriggerPileUp[4]->Fill(pt, GetEventWeight());
3916  if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtTriggerPileUp[5]->Fill(pt, GetEventWeight());
3917  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtTriggerPileUp[6]->Fill(pt, GetEventWeight());
3918  }
3919  } // AOD trigger loop
3920 
3921  // Re-init for next event
3922  fLeadingTriggerIndex = -1;
3923 
3924  AliDebug(1,"End fill histograms");
3925 }
3926 
3927 //_______________________________________________________________________________________________________
3933 //_______________________________________________________________________________________________________
3934 void AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle)
3935 {
3936  AliDebug(1,"Make trigger particle - charged hadron correlation");
3937 
3938  Float_t phiTrig = aodParticle->Phi();
3939  Float_t etaTrig = aodParticle->Eta();
3940  Float_t ptTrig = aodParticle->Pt();
3941  Int_t mcTag = aodParticle->GetTag();
3942  Double_t bz = GetReader()->GetInputEvent()->GetMagneticField();
3943 
3944 
3945  Int_t decayTag = 0;
3946  if(fDecayTrigger)
3947  {
3948  //decay = aodParticle->IsTagged();
3949  decayTag = aodParticle->DecayTag();
3950  if(decayTag < 0) decayTag = 0;
3951  // printf("Correlation: pT %2.2f, BTag %d, Tagged %d\n",ptTrig, decayTag, aodParticle->IsTagged());
3952  // printf("\t check bit Pi0 %d, Eta %d, Pi0Side %d, EtaSide %d\n",
3953  // GetNeutralMesonSelection()->CheckDecayBit(decayTag,AliNeutralMesonSelection::kPi0),
3954  // GetNeutralMesonSelection()->CheckDecayBit(decayTag,AliNeutralMesonSelection::kEta),
3955  // GetNeutralMesonSelection()->CheckDecayBit(decayTag,AliNeutralMesonSelection::kPi0Side),
3956  // GetNeutralMesonSelection()->CheckDecayBit(decayTag,AliNeutralMesonSelection::kEtaSide));
3957  }
3958 
3959  Float_t pt = -100. ;
3960  Float_t phi = -100. ;
3961  Float_t eta = -100. ;
3962  Float_t deltaPhi = -100. ;
3963 
3964  TObjArray * reftracks = 0x0;
3965  Int_t nrefs = 0;
3966 
3967  // Mixed event settings
3968  Int_t evtIndex11 = -1 ; // cluster trigger or pi0 trigger
3969  Int_t evtIndex12 = -1 ; // pi0 trigger
3970  Int_t evtIndex13 = -1 ; // charged trigger
3971 
3972  if (GetMixedEvent())
3973  {
3974  evtIndex11 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(0)) ;
3975  evtIndex12 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(1)) ;
3976  evtIndex13 = GetMixedEvent()->EventIndex(aodParticle->GetTrackLabel(0)) ;
3977  }
3978 
3979  // Track multiplicity or cent bin
3980  Int_t cenbin = 0;
3982 
3983  //
3984  // In case of pi0/eta trigger, we may want to check their decay correlation,
3985  // get their decay children
3986  //
3987 
3988  Bool_t decayFound = kFALSE;
3989  if( fPi0Trigger )
3990  {
3991  decayFound = GetDecayPhotonMomentum(aodParticle->GetCaloLabel(0),aodParticle->GetCaloLabel(1),aodParticle->GetDetectorTag());
3992  if(decayFound)
3993  {
3994  fhPtPi0DecayRatio->Fill(ptTrig, fDecayMom1.Pt()/ptTrig, GetEventWeight());
3995  fhPtPi0DecayRatio->Fill(ptTrig, fDecayMom2.Pt()/ptTrig, GetEventWeight());
3996  }
3997  }
3998 
3999  //-----------------------------------------------------------------------
4000  // Track loop, select tracks with good pt, phi and fill AODs or histograms
4001  //-----------------------------------------------------------------------
4002 
4003  for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
4004  {
4005  AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
4006 
4007  fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
4008  pt = fTrackVector.Pt();
4009  eta = fTrackVector.Eta();
4010  phi = fTrackVector.Phi() ;
4011  if(phi < 0) phi+=TMath::TwoPi();
4012 
4013  //Select only hadrons in pt range
4014  if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
4015 
4016  //remove trigger itself for correlation when use charged triggers
4017  if( track->GetID() == aodParticle->GetTrackLabel(0) || track->GetID() == aodParticle->GetTrackLabel(1) ||
4018  track->GetID() == aodParticle->GetTrackLabel(2) || track->GetID() == aodParticle->GetTrackLabel(3) )
4019  continue ;
4020 
4021  //Only for mixed event frame
4022  Int_t evtIndex2 = 0 ;
4023  if (GetMixedEvent())
4024  {
4025  evtIndex2 = GetMixedEvent()->EventIndex(track->GetID()) ;
4026  if (evtIndex11 == evtIndex2 || evtIndex12 == evtIndex2 || evtIndex13 == evtIndex2 ) // photon and track from different events
4027  continue ;
4028  //vertex cut
4029  if (TMath::Abs(GetVertex(evtIndex2)[2]) > GetZvertexCut())
4030  continue;
4031  }
4032 
4033  AliDebug(2,Form("Selected charge for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f",pt,phi,eta));
4034 
4035  // ------------------------------
4036  // Track type bin or bits setting
4037  //
4038 
4039  //
4040  // * Set the pt associated bin for the defined bins *
4041  //
4042  Int_t assocBin = -1;
4043  for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
4044  {
4045  if(pt > fAssocPtBinLimit[i] && pt < fAssocPtBinLimit[i+1]) assocBin= i;
4046  }
4047 
4048  //
4049  // * Assign to the histogram array a bin corresponding
4050  // to a combination of pTa and vz bins *
4051  //
4052  Int_t nz = 1;
4053  Int_t vz = 0;
4054 
4055  if(fCorrelVzBin)
4056  {
4057  nz = GetNZvertBin();
4058  vz = GetEventVzBin();
4059  }
4060 
4061  Int_t bin = assocBin*nz+vz;
4062 
4063  //printf("assoc Bin = %d, vZ bin = %d, bin = %d \n", assocBin,GetEventVzBin(),bin);
4064 
4065  //
4066  // * Get the status of the TOF bit *
4067  //
4068  ULong_t status = track->GetStatus();
4069  Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
4070  //Double32_t tof = track->GetTOFsignal()*1e-3;
4071  Int_t trackBC = track->GetTOFBunchCrossing(bz);
4072 
4073  Int_t outTOF = -1;
4074  if (okTOF && trackBC!=0) outTOF = 1;
4075  else if(okTOF && trackBC==0) outTOF = 0;
4076 
4077  //----------------
4078  // Fill Histograms
4079 
4080  //
4081  // Azimuthal Angle histograms
4082  //
4083 
4084  deltaPhi = phiTrig-phi;
4085 
4086  //
4087  // Calculate deltaPhi shift so that for the particles on the opposite side
4088  // it is defined between 90 and 270 degrees
4089  // Shift [-360,-90] to [0, 270]
4090  // and [270,360] to [-90,0]
4091  if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
4092  if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
4093 
4094  FillChargedAngularCorrelationHistograms(pt, ptTrig, bin, phi, phiTrig, deltaPhi,
4095  eta, etaTrig, decayTag, track->GetHMPIDsignal(),
4096  outTOF, cenbin, mcTag);
4097 
4098  //
4099  // Imbalance zT/xE/pOut histograms
4100  //
4101 
4102  //
4103  // Delta phi cut for momentum imbalance correlation
4104  //
4105  if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
4106  FillChargedMomentumImbalanceHistograms(ptTrig, pt, deltaPhi, cenbin, track->Charge(),
4107  assocBin, decayTag, outTOF, mcTag);
4108 
4109  //
4110  // Underlying event, right side, default case
4111  //
4112  if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
4113  FillChargedUnderlyingEventHistograms(ptTrig, pt, deltaPhi, cenbin, outTOF,mcTag);
4114 
4115  //
4116  // Several UE calculation, in different perpendicular regions, up to 6:
4117  // left, right, upper-left, lower left, upper-right, lower-right
4118  //
4119  if(fMakeSeveralUE)
4120  FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,deltaPhi,mcTag);
4121 
4122  //
4123  if(fPi0Trigger && decayFound)
4124  FillDecayPhotonCorrelationHistograms(pt, phi, kTRUE) ;
4125 
4126  //
4127  // Add track reference to array
4128  //
4130  {
4131  nrefs++;
4132  if(nrefs==1)
4133  {
4134  reftracks = new TObjArray(0);
4135  TString trackname = Form("%sTracks", GetAODObjArrayName().Data());
4136  reftracks->SetName(trackname.Data());
4137  reftracks->SetOwner(kFALSE);
4138  }
4139 
4140  reftracks->Add(track);
4141  }// reference track to AOD
4142  }// track loop
4143 
4144  //Fill AOD with reference tracks, if not filling histograms
4145  if(fFillAODWithReferences && reftracks)
4146  {
4147  aodParticle->AddObjArray(reftracks);
4148  }
4149 }
4150 
4151 //_________________________________________________________________________________________________________
4153 //_________________________________________________________________________________________________________
4154 void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4ParticleCorrelation *aodParticle)
4155 {
4156  AliDebug(1,Form("Make trigger particle - charged hadron mixed event correlation"));
4157 
4158  if(GetMixedEvent()) return; // This is not the mixed event from general mixing frame
4159 
4160  // Get the event with similar caracteristics
4161  //printf("MakeChargedMixCorrelation for %s\n",GetInputAODName().Data());
4162 
4163  AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
4164 
4165  AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
4166 
4167  if(!inputHandler) return;
4168 
4169  if(!(inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask())) return;
4170 
4171  // Get the pool, check if it exits
4172  Int_t eventBin = GetEventMixBin();
4173 
4174  //Check that the bin exists, if not (bad determination of RP, ntrality or vz bin) do nothing
4175  if(eventBin < 0) return;
4176 
4177  fhEventBin->Fill(eventBin, GetEventWeight());
4178 
4179  // Get neutral clusters pool?
4181  Bool_t neutralMix = fFillNeutralEventMixPool || isoCase ;
4182 
4183  TList * pool = 0;
4184  TList * poolCalo = 0;
4186  {
4187  pool = GetReader()->GetListWithMixedEventsForTracks(eventBin);
4188  if(neutralMix) poolCalo = GetReader()->GetListWithMixedEventsForCalo (eventBin);
4189  }
4190  else
4191  {
4192  pool = fListMixTrackEvents[eventBin];
4193  if(neutralMix) poolCalo = fListMixCaloEvents [eventBin];
4194  }
4195 
4196  if(!pool) return ;
4197 
4198  if( neutralMix && !poolCalo )
4199  AliWarning("Careful, cluster pool not available");
4200 
4201  Double_t ptTrig = aodParticle->Pt();
4202  Double_t etaTrig = aodParticle->Eta();
4203  Double_t phiTrig = aodParticle->Phi();
4204  if(phiTrig < 0.) phiTrig+=TMath::TwoPi();
4205 
4206  AliDebug(1,Form("Pool bin %d size %d, trigger trigger pt=%f, phi=%f, eta=%f",
4207  eventBin,pool->GetSize(), ptTrig,phiTrig,etaTrig));
4208 
4209  Double_t ptAssoc = -999.;
4210  Double_t phiAssoc = -999.;
4211  Double_t etaAssoc = -999.;
4212  Double_t deltaPhi = -999.;
4213  Double_t deltaEta = -999.;
4214  Double_t xE = -999.;
4215 
4216  // Start from first event in pool except if in this same event the pool was filled
4217  Int_t ev0 = 0;
4218  if(GetReader()->GetLastTracksMixedEvent() == GetEventNumber()) ev0 = 1;
4219 
4220  for(Int_t ev=ev0; ev < pool->GetSize(); ev++)
4221  {
4222  //
4223  // Recover the lists of tracks or clusters
4224  //
4225  TObjArray* bgTracks = static_cast<TObjArray*>(pool->At(ev));
4226  TObjArray* bgCalo = 0;
4227 
4228  // Recover the clusters list if requested
4229  if( neutralMix && poolCalo )
4230  {
4231  if(pool->GetSize()!=poolCalo->GetSize())
4232  AliWarning("Different size of calo and track pools");
4233 
4234  bgCalo = static_cast<TObjArray*>(poolCalo->At(ev));
4235 
4236  if(!bgCalo) AliDebug(1,Form("Event %d in calo pool not available?",ev));
4237  }
4238 
4239  //
4240  // Isolate the trigger in the mixed event with mixed tracks and clusters
4241  //
4242  if( OnlyIsolated() )
4243  {
4244  Int_t n=0, nfrac = 0;
4245  Bool_t isolated = kFALSE;
4246  Float_t coneptsum = 0, coneptlead = 0;
4247  GetIsolationCut()->MakeIsolationCut(bgTracks,bgCalo,
4248  GetReader(), GetCaloPID(),
4249  kFALSE, aodParticle, "",
4250  n,nfrac,coneptsum,coneptlead,isolated);
4251 
4252  //printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Isolated? %d - cone %f, ptthres %f",
4253  // isolated,GetIsolationCut()->GetConeSize(),GetIsolationCut()->GetPtThreshold());
4254  //if(bgTracks)printf(" - n track %d", bgTracks->GetEntriesFast());
4255  //printf("\n");
4256 
4257  if(!isolated) continue ;
4258  }
4259 
4260  //
4261  // Check if the trigger is leading of mixed event
4262  //
4263  Int_t nTracks=bgTracks->GetEntriesFast();
4264 
4266  {
4267  Bool_t leading = kTRUE;
4268  for(Int_t jlead = 0;jlead < nTracks; jlead++ )
4269  {
4270  AliAODPWG4Particle *track = (AliAODPWG4Particle*) bgTracks->At(jlead) ;
4271 
4272  ptAssoc = track->Pt();
4273  phiAssoc = track->Phi() ;
4274  if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
4275 
4277  {
4278  deltaPhi = phiTrig-phiAssoc;
4279  if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
4280  if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
4281 
4282  if(ptAssoc > ptTrig && deltaPhi < TMath::PiOver2())
4283  {
4284  leading = kFALSE;
4285  break;
4286  }
4287  }
4288  //jump out this event if there is any other particle with pt larger than trigger
4289  else if(fMakeAbsoluteLeading)
4290  {
4291  if(ptAssoc > ptTrig)
4292  {
4293  leading = kFALSE;
4294  break;
4295  }
4296  }
4297  }
4298 
4299  if( !neutralMix && fCheckLeadingWithNeutralClusters )
4300  AliWarning("Leading of clusters requested but no clusters in mixed event");
4301 
4302  if(neutralMix && fCheckLeadingWithNeutralClusters && bgCalo)
4303  {
4304  Int_t nClusters=bgCalo->GetEntriesFast();
4305  for(Int_t jlead = 0;jlead <nClusters; jlead++ )
4306  {
4307  AliAODPWG4Particle *cluster= (AliAODPWG4Particle*) bgCalo->At(jlead) ;
4308 
4309  ptAssoc = cluster->Pt();
4310  phiAssoc = cluster->Phi() ;
4311  if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
4312 
4314  {
4315  deltaPhi = phiTrig-phiAssoc;
4316  if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
4317  if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
4318 
4319  if(ptAssoc > ptTrig && deltaPhi < TMath::PiOver2())
4320  {
4321  leading = kFALSE;
4322  break;
4323  }
4324  }
4325  //jump out this event if there is any other particle with pt larger than trigger
4326  else if(fMakeAbsoluteLeading)
4327  {
4328  if(ptAssoc > ptTrig)
4329  {
4330  leading = kFALSE;
4331  break;
4332  }
4333  }
4334  }
4335  }
4336 
4337  if(!leading) continue; // not leading, check the next event in pool
4338  }
4339 
4340  //
4341  // Fill histograms for selected triggers
4342  //
4343 
4344  fhEventMixBin->Fill(eventBin, GetEventWeight());
4345 
4346  //printf("\t Read Pool event %d, nTracks %d\n",ev,nTracks);
4347 
4348  fhPtTriggerMixed ->Fill(ptTrig, GetEventWeight());
4349  fhPhiTriggerMixed ->Fill(ptTrig, phiTrig, GetEventWeight());
4350  fhEtaTriggerMixed ->Fill(ptTrig, etaTrig, GetEventWeight());
4351  fhPtTriggerMixedBin->Fill(ptTrig, eventBin, GetEventWeight());
4352 
4354 
4355  //
4356  // Correlation histograms
4357  //
4358  for(Int_t j1 = 0;j1 <nTracks; j1++ )
4359  {
4360  AliAODPWG4Particle *track = (AliAODPWG4Particle*) bgTracks->At(j1) ;
4361 
4362  if(!track) continue;
4363 
4364  ptAssoc = track->Pt();
4365  etaAssoc = track->Eta();
4366  phiAssoc = track->Phi() ;
4367  if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
4368 
4369  deltaPhi = phiTrig-phiAssoc;
4370  if(deltaPhi < -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
4371  if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
4372  deltaEta = etaTrig-etaAssoc;
4373 
4374  AliDebug(1,Form("deltaPhi= %f, deltaEta=%f",deltaPhi, deltaEta));
4375 
4376  // Angular correlation
4377  fhMixDeltaPhiCharged ->Fill(ptTrig , deltaPhi, GetEventWeight());
4378  fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta, GetEventWeight());
4379 
4380  //
4381  // Momentum imbalance
4382  //
4383  if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
4384  {
4385  xE = -ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
4386 
4387  if( xE < 0.)
4388  AliWarning(Form("Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
4389  xE,deltaPhi*TMath::RadToDeg(),TMath::Cos(deltaPhi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
4390 
4391  fhMixXECharged->Fill(ptTrig, xE, GetEventWeight());
4392  if ( xE > 0 ) fhMixHbpXECharged->Fill(ptTrig, TMath::Log(1./xE), GetEventWeight());
4393  }
4394 
4395  //
4396  // Underlying event momentum imbalance
4397  //
4398  if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
4399  {
4400  //Underlying event region
4401  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
4402  Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
4403 
4404  if(uexE < 0.)
4405  AliWarning(Form("Careful!!, negative xE %2.2f for left UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
4406  uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
4407 
4408  fhMixXEUeCharged->Fill(ptTrig, uexE, GetEventWeight());
4409  }
4410 
4411  // Set the pt associated bin for the defined bins
4412  Int_t assocBin = -1;
4413  for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
4414  {
4415  if(ptAssoc > fAssocPtBinLimit[i] && ptAssoc < fAssocPtBinLimit[i+1]) assocBin= i;
4416  }
4417 
4418  //
4419  // Assign to the histogram array a bin corresponding to a combination of pTa and vz bins
4420  //
4421  Int_t nz = 1;
4422  Int_t vz = 0;
4423 
4424  if(fCorrelVzBin)
4425  {
4426  nz = GetNZvertBin();
4427  vz = GetEventVzBin();
4428  }
4429 
4430  Int_t bin = assocBin*nz+vz;
4431 
4432  if(bin < 0) continue ; // this pt bin was not considered
4433 
4434  fhMixDeltaPhiChargedAssocPtBin [bin]->Fill(ptTrig, deltaPhi, GetEventWeight());
4435  fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->Fill(deltaPhi, deltaEta, GetEventWeight());
4436 
4437  if(fFillEtaGapsHisto)
4438  {
4439  if(TMath::Abs(deltaEta) > 0.8)
4440  fhMixDeltaPhiChargedAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi, GetEventWeight());
4441  if(TMath::Abs(deltaEta) < 0.01)
4442  fhMixDeltaPhiChargedAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi, GetEventWeight());
4443  }
4444 
4445  } // track loop
4446  } // mixed event loop
4447 }
4448 
4449 //_______________________________________________________________________________________________________
4452 //_______________________________________________________________________________________________________
4453 void AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4ParticleCorrelation * aodParticle)
4454 {
4455  TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); // For the future, foresee more possible pi0 lists
4456  if(!pi0list) return ;
4457 
4458  Int_t npi0 = pi0list->GetEntriesFast();
4459  if(npi0 == 0) return ;
4460 
4461  AliDebug(1,Form("Particle - pi0 correlation, %d pi0's",npi0));
4462 
4463  Int_t evtIndex11 = 0 ;
4464  Int_t evtIndex12 = 0 ;
4465  if (GetMixedEvent())
4466  {
4467  evtIndex11 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(0)) ;
4468  evtIndex12 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(1)) ;
4469  }
4470 
4471  Float_t pt = -100. ;
4472  Float_t zT = -100. ;
4473  Float_t phi = -100. ;
4474  Float_t eta = -100. ;
4475  Float_t xE = -100. ;
4476  Float_t hbpXE= -100. ;
4477  Float_t hbpZT= -100. ;
4478 
4479  Float_t ptTrig = aodParticle->Pt();
4480  Float_t phiTrig = aodParticle->Phi();
4481  Float_t etaTrig = aodParticle->Eta();
4482  Float_t deltaPhi= -100. ;
4483  Float_t deltaEta= -100. ;
4484 
4485  // In case of pi0/eta trigger, we may want to check their decay correlation,
4486  // get their decay children
4487 
4488  Bool_t decayFound = kFALSE;
4489  if(fPi0Trigger) decayFound = GetDecayPhotonMomentum(aodParticle->GetCaloLabel(0),aodParticle->GetCaloLabel(1),aodParticle->GetDetectorTag());
4490 
4491  TObjArray * refpi0 = 0x0;
4492  Int_t nrefs = 0;
4493 
4494  // Loop on stored AOD pi0
4495 
4496  for(Int_t iaod = 0; iaod < npi0 ; iaod++)
4497  {
4498  AliAODPWG4Particle* pi0 = (AliAODPWG4Particle*) (pi0list->At(iaod));
4499 
4500  Int_t evtIndex2 = 0 ;
4501  Int_t evtIndex3 = 0 ;
4502  if (GetMixedEvent())
4503  {
4504  evtIndex2 = GetMixedEvent()->EventIndexForCaloCluster(pi0->GetCaloLabel(0)) ;
4505  evtIndex3 = GetMixedEvent()->EventIndexForCaloCluster(pi0->GetCaloLabel(1)) ;
4506 
4507  if (evtIndex11 == evtIndex2 || evtIndex12 == evtIndex2 ||
4508  evtIndex11 == evtIndex3 || evtIndex12 == evtIndex3) // trigger and pi0 are not from different events
4509  continue ;
4510  }
4511 
4512  pt = pi0->Pt();
4513 
4514  if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
4515 
4516  // Remove trigger itself for correlation when use charged triggers
4517  if(aodParticle->GetCaloLabel(0) >= 0 &&
4518  (pi0->GetCaloLabel(0) == aodParticle->GetCaloLabel(0) || pi0->GetCaloLabel(1) == aodParticle->GetCaloLabel(0))) continue ;
4519 
4520  if( aodParticle->GetCaloLabel(1) >= 0 &&
4521  (pi0->GetCaloLabel(0) == aodParticle->GetCaloLabel(1) || pi0->GetCaloLabel(1) == aodParticle->GetCaloLabel(1))) continue ;
4522 
4523  //
4524  // Angular correlations
4525  //
4526  phi = pi0->Phi() ;
4527  eta = pi0->Eta() ;
4528  deltaEta = etaTrig-eta;
4529  deltaPhi = phiTrig-phi;
4530  if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
4531  if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
4532 
4533  fhEtaNeutral ->Fill(pt , eta , GetEventWeight());
4534  fhPhiNeutral ->Fill(pt , phi , GetEventWeight());
4535  fhDeltaEtaNeutral->Fill(ptTrig, deltaEta, GetEventWeight());
4536  fhDeltaPhiNeutral->Fill(ptTrig, deltaPhi, GetEventWeight());
4537 
4538  if ( pt > 2 ) fhDeltaPhiDeltaEtaNeutral->Fill(deltaPhi, deltaEta, GetEventWeight());
4539 
4540  //
4541  // Momentum imbalance
4542  //
4543  zT = pt/ptTrig ;
4544 
4545  hbpZT = -100;
4546  hbpXE = -100;
4547 
4548  if(zT > 0 ) hbpZT = TMath::Log(1./zT);
4549 
4550  // Delta phi cut for correlation
4551  if( (deltaPhi > fDeltaPhiMinCut) && ( deltaPhi < fDeltaPhiMaxCut) )
4552  {
4553  xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
4554 
4555  if( xE < 0. )
4556  AliWarning(Form("Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f",
4557  xE,deltaPhi*TMath::RadToDeg(),TMath::Cos(deltaPhi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg()));
4558 
4559  if( xE > 0 ) hbpXE = TMath::Log(1./xE);
4560 
4561  fhDeltaPhiNeutralPt->Fill(pt , deltaPhi, GetEventWeight());
4562  fhXENeutral ->Fill(ptTrig, xE , GetEventWeight());
4563  fhPtHbpXENeutral ->Fill(ptTrig, hbpXE , GetEventWeight());
4564  fhZTNeutral ->Fill(ptTrig, zT , GetEventWeight());
4565  fhPtHbpZTNeutral ->Fill(ptTrig, hbpZT , GetEventWeight());
4566  }
4567  else if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
4568  {
4569  // Randomize angle for xE calculation
4570  Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
4571 
4572  xE = -(pt/ptTrig)*TMath::Cos(randomphi);
4573  if(xE > 0 ) hbpXE = TMath::Log(1./xE);
4574 
4575  fhDeltaPhiUeNeutralPt->Fill(pt , deltaPhi, GetEventWeight());
4576  fhZTUeNeutral ->Fill(ptTrig, zT , GetEventWeight());
4577  fhPtHbpZTUeNeutral ->Fill(ptTrig, hbpZT , GetEventWeight());
4578  fhXEUeNeutral ->Fill(ptTrig, xE , GetEventWeight());
4579  fhPtHbpXEUeNeutral ->Fill(ptTrig, hbpXE , GetEventWeight());
4580  }
4581 
4582  // Several UE calculation, not sure it is useful
4583  // with partical calorimter acceptance
4584  if(fMakeSeveralUE) FillNeutralUnderlyingEventSidesHistograms(ptTrig,pt,zT,hbpZT,deltaPhi);
4585 
4586  //
4587  // Decay photon correlations
4588  //
4589  if(fPi0Trigger && decayFound)
4590  FillDecayPhotonCorrelationHistograms(pt, phi, kFALSE) ;
4591 
4593  {
4594  nrefs++;
4595  if(nrefs==1)
4596  {
4597  refpi0 = new TObjArray(0);
4598  refpi0->SetName(GetAODObjArrayName()+"Pi0s");
4599  refpi0->SetOwner(kFALSE);
4600  }
4601  refpi0->Add(pi0);
4602  } // put references in trigger AOD
4603 
4604  AliDebug(1,Form("Selected pi0: pt %2.2f, phi %2.2f, eta %2.2f",pt,phi,eta));
4605 
4606  } // loop
4607 
4608  // Fill AOD with reference tracks, if not filling histograms
4609  if(fFillAODWithReferences && refpi0)
4610  {
4611  aodParticle->AddObjArray(refpi0);
4612  }
4613 }
4614 
4615 //__________________________________________________________________________________________________________________
4617 //__________________________________________________________________________________________________________________
4618 void AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation(Int_t label, Int_t histoIndex, Bool_t lostDecayPair)
4619 {
4620  AliDebug(1,"Make trigger particle - charged hadron correlation in AOD MC level");
4621 
4622  if( label < 0 )
4623  {
4624  AliDebug(1,Form(" *** bad label ***: label %d", label));
4625  return;
4626  }
4627 
4628  // Do MC correlation for a given particle type range.
4629  // Types defined in GetMCTagHistogramIndex:
4630  // 0 direct gamma; 1 pi0; 2 pi0 decay; 3 eta decay; 4 other decay; 5 electron; 6 other (hadron)
4631  if(histoIndex < fMCGenTypeMin || histoIndex > fMCGenTypeMax) return ;
4632 
4633  AliStack * stack = 0x0 ;
4634  TParticle * primary = 0x0 ;
4635  TClonesArray * mcparticles = 0x0 ;
4636  AliAODMCParticle * aodprimary = 0x0 ;
4637 
4638  Double_t eprim = 0 ;
4639  Double_t ptprim = 0 ;
4640  Double_t phiprim = 0 ;
4641  Double_t etaprim = 0 ;
4642  Int_t nTracks = 0 ;
4643  Int_t iParticle = 0 ;
4644 
4645  Bool_t leadTrig = kTRUE;
4646 
4647  if( GetReader()->ReadStack() )
4648  {
4649  stack = GetMCStack() ;
4650  if(!stack)
4651  {
4652  AliFatal("Stack not available, is the MC handler called? STOP");
4653  return;
4654  }
4655 
4656  //nTracks = stack->GetNtrack() ;
4657  nTracks = stack->GetNprimary();
4658  if( label >= stack->GetNtrack() )
4659  {
4660  if(GetDebug() > 2)
4661  AliInfo(Form("*** large label ***: label %d, n tracks %d", label, stack->GetNtrack()));
4662  return ;
4663  }
4664 
4665  primary = stack->Particle(label);
4666  if ( !primary )
4667  {
4668  AliInfo(Form(" *** no primary ***: label %d", label));
4669  return;
4670  }
4671 
4672  eprim = primary->Energy();
4673  ptprim = primary->Pt();
4674  etaprim = primary->Eta();
4675  phiprim = primary->Phi();
4676  if(phiprim < 0) phiprim+=TMath::TwoPi();
4677 
4678  if(ptprim < 0.01 || eprim < 0.01) return ;
4679 
4680  for (iParticle = 0 ; iParticle < nTracks ; iParticle++)
4681  {
4682  TParticle * particle = stack->Particle(iParticle);
4683 
4684  //keep only final state particles
4685  if( particle->GetStatusCode() != 1 ) continue ;
4686 
4687  //---------- Charged particles ----------------------
4688  Int_t pdg = particle->GetPdgCode();
4689  Int_t charge = (Int_t) TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
4690  if(charge == 0) continue;
4691 
4692  particle->Momentum(fMomentum);
4693 
4694  //Particles in CTS acceptance, make sure to use the same selection as in the reader
4695  Bool_t inCTS = GetReader()->GetFiducialCut()->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kCTS);
4696  //printf("Accepted? %d; pt %2.2f, eta %2.2f, phi %2.2f\n",inCTS,fMomentum.Pt(),fMomentum.Eta(),fMomentum.Phi()*TMath::RadToDeg());
4697  if( !inCTS ) continue;
4698 
4699  // Remove conversions
4700  if ( TMath::Abs(pdg) == 11 && stack->Particle(particle->GetFirstMother())->GetPdgCode() == 22 ) continue ;
4701 
4702  if ( label == iParticle ) continue; // avoid trigger particle
4703 
4704  Float_t phi = particle->Phi();
4705  if(phi < 0) phi+=TMath::TwoPi();
4706 
4707  Bool_t lead = FillChargedMCCorrelationHistograms(particle->Pt(),phi,particle->Eta(),ptprim,phiprim,etaprim,histoIndex,lostDecayPair);
4708 
4709  if ( !lead ) leadTrig = kFALSE;
4710 
4711  // if ( !lead && (fMakeAbsoluteLeading || fMakeNearSideLeading) ) return;
4712  } // track loop
4713  } // ESD MC
4714  else if( GetReader()->ReadAODMCParticles() )
4715  {
4716  // Get the list of MC particles
4717  mcparticles = GetReader()->GetAODMCParticles();
4718  if( !mcparticles ) return;
4719 
4720  nTracks = mcparticles->GetEntriesFast() ;
4721 
4722  if( label >= nTracks )
4723  {
4724  if(GetDebug() > 2)
4725  AliInfo(Form(" *** large label ***: label %d, n tracks %d", label,nTracks));
4726  return;
4727  }
4728 
4729  // Get the particle
4730  aodprimary = (AliAODMCParticle*) mcparticles->At(label);
4731  if( !aodprimary )
4732  {
4733  AliInfo(Form(" *** no AOD primary ***: label %d", label));
4734  return;
4735  }
4736 
4737  eprim = aodprimary->E();
4738  ptprim = aodprimary->Pt();
4739  etaprim = aodprimary->Eta();
4740  phiprim = aodprimary->Phi();
4741  if(phiprim < 0) phiprim+=TMath::TwoPi();
4742 
4743  if(ptprim < 0.01 || eprim < 0.01) return ;
4744 
4745  for (iParticle = 0; iParticle < nTracks; iParticle++)
4746  {
4747  AliAODMCParticle *part = (AliAODMCParticle*) mcparticles->At(iParticle);
4748 
4749  if (!part->IsPhysicalPrimary() ) continue; // same as part->GetStatus() !=1
4750 
4751  if ( part->Charge() == 0 ) continue;
4752 
4753  fMomentum.SetPxPyPzE(part->Px(),part->Py(),part->Pz(),part->E());
4754 
4755  //Particles in CTS acceptance, make sure to use the same selection as in the reader
4756  Bool_t inCTS = GetReader()->GetFiducialCut()->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kCTS);
4757  //printf("Accepted? %d; pt %2.2f, eta %2.2f, phi %2.2f\n",inCTS,fMomentum.Pt(),fMomentum.Eta(),fMomentum.Phi()*TMath::RadToDeg());
4758  if( !inCTS ) continue;
4759 
4760  // Remove conversions
4761  Int_t indexmother = part->GetMother();
4762  if ( indexmother > -1 )
4763  {
4764  Int_t pdg = part->GetPdgCode();
4765  Int_t mPdg = ((AliAODMCParticle*) mcparticles->At(indexmother)) ->GetPdgCode();
4766  if (TMath::Abs(pdg) == 11 && mPdg == 22) continue;
4767  }
4768 
4769  if ( label == iParticle ) continue; // avoid trigger particle
4770 
4771  Float_t phi = part->Phi();
4772  if(phi < 0) phi+=TMath::TwoPi();
4773 
4774  Bool_t lead = FillChargedMCCorrelationHistograms(part->Pt(),phi,part->Eta(),ptprim,phiprim,etaprim, histoIndex,lostDecayPair);
4775 
4776  if ( !lead ) leadTrig = kFALSE;
4777  // if ( !lead && (fMakeAbsoluteLeading || fMakeNearSideLeading)) return;
4778  } //MC particle loop
4779  }// AOD MC
4780 
4781  // Trigger MC particle histograms
4782  //if (!lead && (fMakeAbsoluteLeading || fMakeNearSideLeading)) return;
4783 
4784  fhMCPtTrigger [histoIndex]->Fill(ptprim, GetEventWeight());
4785  fhMCPhiTrigger[histoIndex]->Fill(ptprim, phiprim, GetEventWeight());
4786  fhMCEtaTrigger[histoIndex]->Fill(ptprim, etaprim, GetEventWeight());
4787 
4788  if(lostDecayPair)
4789  {
4790  // check index in GetMCTagIndexHistogram
4791  if (histoIndex == 2 && 8 >= fMCGenTypeMin && 8 <= fMCGenTypeMax )
4792  {
4793  // pi0 decay
4794  fhMCPtTrigger [8]->Fill(ptprim, GetEventWeight());
4795  fhMCPhiTrigger[8]->Fill(ptprim, phiprim, GetEventWeight());
4796  fhMCEtaTrigger[8]->Fill(ptprim, etaprim, GetEventWeight());
4797  }
4798  else if(histoIndex == 4 && 9 >= fMCGenTypeMin && 9 <= fMCGenTypeMax )
4799  {
4800  // eta decay
4801  fhMCPtTrigger [9]->Fill(ptprim, GetEventWeight());
4802  fhMCPhiTrigger[9]->Fill(ptprim, phiprim, GetEventWeight());
4803  fhMCEtaTrigger[9]->Fill(ptprim, etaprim, GetEventWeight());
4804  }
4805  }
4806 
4807  if(!leadTrig && (fMakeAbsoluteLeading || fMakeNearSideLeading) )
4808  {
4809  AliDebug(1,Form("Not leading primary trigger: pT %2.2f, phi %2.2f, eta %2.2f",
4810  ptprim,phiprim*TMath::RadToDeg(),etaprim));
4811 
4812  fhMCPtTriggerNotLeading [histoIndex]->Fill(ptprim, GetEventWeight());
4813  fhMCPhiTriggerNotLeading[histoIndex]->Fill(ptprim, phiprim, GetEventWeight());
4814  fhMCEtaTriggerNotLeading[histoIndex]->Fill(ptprim, etaprim, GetEventWeight());
4815 
4816  if(lostDecayPair)
4817  {
4818  // check index in GetMCTagIndexHistogram
4819  if (histoIndex == 2 && 8 >= fMCGenTypeMin && 8 <= fMCGenTypeMax )
4820  {
4821  // pi0 decay
4822  fhMCPtTriggerNotLeading [8]->Fill(ptprim, GetEventWeight());
4823  fhMCPhiTriggerNotLeading[8]->Fill(ptprim, phiprim, GetEventWeight());
4824  fhMCEtaTriggerNotLeading[8]->Fill(ptprim, etaprim, GetEventWeight());
4825  }
4826  else if(histoIndex == 4 && 9 >= fMCGenTypeMin && 9 <= fMCGenTypeMax )
4827  {
4828  // eta decay
4829  fhMCPtTriggerNotLeading [9]->Fill(ptprim, GetEventWeight());
4830  fhMCPhiTriggerNotLeading[9]->Fill(ptprim, phiprim, GetEventWeight());
4831  fhMCEtaTriggerNotLeading[9]->Fill(ptprim, etaprim, GetEventWeight());
4832  }
4833  }
4834  }
4835 }
4836 
4837 //_____________________________________________________________________
4839 //_____________________________________________________________________
4840 void AliAnaParticleHadronCorrelation::Print(const Option_t * opt) const
4841 {
4842  if(! opt)
4843  return;
4844 
4845  printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
4847  printf("Pt trigger > %2.2f; < %2.2f\n", GetMinPt() , GetMaxPt()) ;
4848  printf("Pt associa > %2.2f; < %2.2f\n", fMinAssocPt, fMaxAssocPt) ;
4849  printf("Phi trigger particle-Hadron < %3.2f\n", fDeltaPhiMaxCut) ;
4850  printf("Phi trigger particle-Hadron > %3.2f\n", fDeltaPhiMinCut) ;
4851  printf("Phi trigger particle-UeHadron < %3.2f\n", fUeDeltaPhiMaxCut) ;
4852  printf("Phi trigger particle-UeHadron > %3.2f\n", fUeDeltaPhiMinCut) ;
4853  printf("Isolated Trigger? %d\n" , fSelectIsolated) ;
4854  printf("Several UE? %d\n" , fMakeSeveralUE) ;
4855  printf("Name of AOD Pi0 Branch %s \n", fPi0AODBranchName.Data());
4856  printf("Do Decay-hadron correlation ? %d\n", fPi0Trigger) ;
4857  printf("Select absolute leading for cluster triggers ? %d or Near Side %d\n",
4859  printf("Trigger pt bins %d\n", fNAssocPtBins) ;
4860  for (Int_t ibin = 0; ibin<fNAssocPtBins; ibin++) {
4861  printf("\t bin %d = [%2.1f,%2.1f]\n", ibin, fAssocPtBinLimit[ibin], fAssocPtBinLimit[ibin+1]) ;
4862  }
4863 
4864 }
4865 
4866 //____________________________________________________________
4868 //____________________________________________________________
4870 {
4871  fNAssocPtBins = n ;
4872 
4873  if(n < 20 && n > 0)
4874  {
4875  fNAssocPtBins = n ;
4876  }
4877  else
4878  {
4879  AliWarning("n = larger than 19 or too small, set to 19");
4880  fNAssocPtBins = 19;
4881  }
4882 }
4883 
4884 //______________________________________________________________________________
4886 //______________________________________________________________________________
4888 {
4889  if(ibin <= fNAssocPtBins || ibin >= 0)
4890  {
4891  fAssocPtBinLimit[ibin] = pt ;
4892  }
4893  else
4894  {
4895  AliWarning(Form("Bin number too large %d > %d or small, nothing done", ibin, fNAssocPtBins)) ;
4896  }
4897 }
4898 
4899 
4900 
4901 //___________________________________________________________________________________________________________
4903 // Remove when AliRoot v5-06-38 is available
4904 //___________________________________________________________________________________________________________
4905 void AliAnaParticleHadronCorrelation::CalculateChargedActivityInCone(AliAODPWG4ParticleCorrelation * particle,
4906  Float_t & pTLeadTrackInCone, Float_t & pTSumTrackInCone)
4907 {
4908  TObjArray * reftracks = particle->GetObjArray(fAODNamepTInConeHisto+"Tracks");
4909  if(!reftracks) return ;
4910 
4911  for(Int_t itrack=0; itrack < reftracks->GetEntriesFast(); itrack++)
4912  {
4913  AliVTrack* track = (AliVTrack *) reftracks->At(itrack);
4914 
4915  Float_t pTtrack = track->Pt();
4916  // Float_t etaAssoc = track->Eta();
4917  // Float_t phiAssoc = track->Phi();
4918  // Float_t etaTrig = particle->Eta();
4919  // Float_t phiTrig = particle->Phi();
4920  // Float_t dEta = etaTrig - etaAssoc;
4921  // Float_t dPhi = phiTrig - phiAssoc;
4922  // Float_t coneSize = GetIsolationCut()->GetConeSize();
4923 
4924  pTSumTrackInCone+=pTtrack;
4925  if(pTtrack > pTLeadTrackInCone) pTLeadTrackInCone = pTtrack;
4926 
4927  }
4928 
4929 }
4930 
4931 
4932 
4933 //___________________________________________________________________________________________________________
4935 // Remove when AliRoot v5-06-38 is available
4936 //___________________________________________________________________________________________________________
4937 void AliAnaParticleHadronCorrelation::CalculateNeutralActivityInCone(AliAODPWG4ParticleCorrelation * particle,
4938  Float_t & pTLeadClusterInCone, Float_t & pTSumClusterInCone)
4939 {
4940  TObjArray * refclusters = particle->GetObjArray(fAODNamepTInConeHisto+"Clusters");
4941  if(!refclusters) return ;
4942 
4943  if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyCharged ) return ;
4944 
4945  // Get vertex for cluster momentum calculation
4946  Double_t vertex[] = {0,0,0} ; //vertex ;
4947  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
4948  GetReader()->GetVertex(vertex);
4949 
4950  for(Int_t icalo=0; icalo < refclusters->GetEntriesFast(); icalo++)
4951  {
4952  AliVCluster* calo = (AliVCluster *) refclusters->At(icalo);
4953  calo->GetMomentum(fMomentum,vertex) ;//Assume that come from vertex in straight line
4954 
4955  Float_t pTCluster = fMomentum.Pt();
4956  // Float_t etaAssoc = fMomentum.Eta();
4957  // Float_t phiAssoc = fMomentum.Phi();
4958  // Float_t etaTrig = particle->Eta();
4959  // Float_t phiTrig = particle->Phi();
4960  // Float_t dEta = etaTrig - etaAssoc;
4961  // Float_t dPhi = phiTrig - phiAssoc;
4962  // Float_t coneSize = GetIsolationCut()->GetConeSize();
4963 
4964  pTSumClusterInCone += pTCluster;
4965  if(pTCluster > pTLeadClusterInCone) pTLeadClusterInCone = pTCluster;
4966  }
4967 
4968 }
4969 
Int_t charge
Float_t GetHistoPtMax() const
TH2F * fhDeltaPhiDeltaEtaCharged
! Differences of eta and phi between trigger and charged hadrons.
TH2F * fhMCEtaCharged[fgkNmcTypes]
! MC pure particles charged primary pt vs eta (both associated)
void MakeIsolationCut(TObjArray *plCTS, TObjArray *plNe, AliCaloTrackReader *reader, AliCaloPID *pid, Bool_t bFillAOD, AliAODPWG4ParticleCorrelation *pCandidate, TString aodObjArrayName, Int_t &n, Int_t &nfrac, Float_t &ptSum, Float_t &ptLead, Bool_t &isolated)
TH2F * fhMCMassPtTrigger[fgkNmcTypes]
! Invariant mass of the trigger vs MC origin.
TH2F * fhMCPtXECharged[fgkNmcTypes]
! MC pure particles charged trigger primary pt vs xE
TH2F * fhMCPtAssocDeltaPhi[fgkNmcTypes]
! MC pure particles charged associated primary pt vs delta phi (associated-trigger) ...
void SetLastCaloMixedEvent(Int_t e)
ClassImp(AliAnalysisTaskTriggerRates) AliAnalysisTaskTriggerRates
Int_t GetHistoDeltaEtaBins() const
TH1F * fhPtNoLeadingOppositeHadron
! pT trigger for events without opposite hadrons.
TH1F ** fhSumPtConeBinMC
[fNBkgBin*fgkNmcTypes]
TH2F * fhXEChargedVtxBC0
! Trigger particle -charged hadron momentum imbalance histogram.
TH2F * fhMixXEUeCharged
! xE for mixed event in Ue region.
Float_t GetHistoPtMin() const
virtual TObjArray * GetCTSTracks() const
TH2F * fhDeltaPhiChargedPt
! Difference of charged particle phi and trigger particle phi as function of charged. particle pT
TH2F * fhPtHbpXECharged_Cone2
! Trigger particle -charged hadron momentum HBP histogram in cone2 (5pi/6-7pi/6). ...
TH2F * fhPtTrigPout
! Pout =associated pt*sin(delta phi) distribution vs trigger pt
TH2F * fhZTCharged
! Trigger particle -charged hadron momentum imbalance histogram.
TH2F * fhPhiCharged
! Phi distribution of charged particles.
TH2F * fhZTPi0DecayCharged
! Trigger particle (decay from pi0/eta trigger)-charged hadron momentum imbalance histogram ...
TH2F * fhXEDecayCharged[AliNeutralMesonSelection::fgkMaxNDecayBits]
! Trigger particle (decay from pi0)-charged hadron momentum imbalance histogram.
virtual void AddToHistogramsName(TString add)
TList * GetListWithMixedEventsForTracks(Int_t bi) const
void FillNeutralUnderlyingEventSidesHistograms(Float_t ptTrig, Float_t ptAssoc, Float_t zT, Float_t hbpZT, Float_t deltaPhi)
void FillChargedUnderlyingEventHistograms(Float_t ptTrig, Float_t ptAssoc, Float_t deltaPhi, Int_t cenbin, Int_t outTOF, Int_t mcTag)
Fill underlying event histograms.
TList ** fListMixTrackEvents
Containers for tracks in stored events for mixing.
void InitParameters()
Initialize the default parameters of the analysis.
TH2F * fhMixDeltaPhiCharged
! Difference of charged particle phi and trigger particle phi as function of trigger particle pT...
TH2F * fhMCPtHbpZTCharged[fgkNmcTypes]
! MC pure particles charged trigger primary pt vs ln(1/zT)
void MakeChargedCorrelation(AliAODPWG4ParticleCorrelation *particle)
TH2F * fhDeltaPhiNeutral
! Difference of neutral particle phi and trigger particle phi as function of trigger particle pT ...
TH2F * fhZTNegCharged
! Trigger particle -negative charged hadron momentum imbalance histogram.
TH1F * fhPtTriggerIsoCut
! pT distribution of trigger particles after isolation cut selection.
virtual Float_t GetPairTimeCut() const
Time cut in ns.
TString fPi0AODBranchName
Name of AOD branch with pi0, not trigger.
TH2F * fhXEUeCharged
! Trigger particle -underlying charged hadron momentum imbalance histogram.
TH1F * fhPtTriggerSSCut
! pT distribution of trigger particles after shower shape selection.
Bool_t ReadAODMCParticles() const
virtual void GetVertex(Double_t vertex[3]) const
Int_t GetHistoTrackMultiplicityMax() const
TH2F * fhMCPhiCharged[fgkNmcTypes]
! MC pure particles charged primary pt vs phi (both associated)
Bool_t fMakeAbsoluteLeading
Requesting absolute leading triggers.
TH1F * fhPtDecayTriggerMC[AliNeutralMesonSelection::fgkMaxNDecayBits][fgkNmcTypes]
! pT distribution of trigger particles, tagged as decay, check the origin of the cluster.
TH1F * fhPtDecayTrigger[AliNeutralMesonSelection::fgkMaxNDecayBits]
! pT distribution of trigger particles, tagged as decay.
TLorentzVector fMomentumIM
! Cluster momentum from Invariant mass.
void FillDecayPhotonCorrelationHistograms(Float_t ptAssoc, Float_t phiAssoc, Bool_t bChargedOrNeutral)
Do correlation with decay photons of triggered pi0 or eta.
void FillEventMixPool()
Fill the pool with tracks or clusters if requested.
TH2F * fhDeltaPhiUeRightUpCharged
! Difference of charged particle from underlying events phi and trigger particle phi ...
TH1F * fhPtTriggerVtxBC0
! pT distribution of trigger particles when vertex is BC0.
void MakeMCChargedCorrelation(Int_t triggerMCLable, Int_t histoIndex, Bool_t lostDecayPair)
Make the trigger-charged particles correlation at the generator level.
Definition: AliAnaParticleHadr