]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/CaloTrackCorrelations/AliAnaParticleHadronCorrelation.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
move the AOD particle creation part to the end of the method, in case of storing...
[u/mrichter/AliRoot.git] / PWGGA / CaloTrackCorrelations / AliAnaParticleHadronCorrelation.cxx
CommitLineData
e09cf5ef 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 **************************************************************************/
e09cf5ef 15
16//_________________________________________________________________________
17// Class for the analysis of particle - hadron correlations
18// Particle (for example direct gamma) must be found in a previous analysis
19//-- Author: Gustavo Conesa (LNF-INFN)
20
21// Modified by Yaxian Mao:
22// 1. add the UE subtraction for corrlation study
23// 2. change the correlation variable
24// 3. Only use leading particle(cluster/track) as trigger for correlation (2010/07/02)
25// 4. Make decay photon-hadron correlations where decay contribute pi0 mass (2010/09/09)
26// 5. fill the pout to extract kt at the end, also to study charge asymmetry(2010/10/06)
045396c8 27// 6. Add the possibility for event selection analysis based on vertex and multiplicity bins (10/10/2010)
28// 7. change the way of delta phi cut for UE study due to memory issue (reduce histograms)
29// 8. Add the possibility to request the absolute leading particle at the near side or not, set trigger bins, general clean-up (08/2011)
e09cf5ef 30//////////////////////////////////////////////////////////////////////////////
31
32
33// --- ROOT system ---
34//#include "TClonesArray.h"
907b38cd 35#include <TClass.h>
36#include <TMath.h>
37#include <TH2F.h>
38#include <TDatabasePDG.h>
e09cf5ef 39
40//---- ANALYSIS system ----
41#include "AliNeutralMesonSelection.h"
42#include "AliAnaParticleHadronCorrelation.h"
43#include "AliCaloTrackReader.h"
e09cf5ef 44#include "AliAODPWG4ParticleCorrelation.h"
45#include "AliFiducialCut.h"
46#include "AliVTrack.h"
47#include "AliVCluster.h"
48#include "AliMCAnalysisUtils.h"
49#include "TParticle.h"
50#include "AliStack.h"
51#include "AliAODMCParticle.h"
52#include "AliMixedEvent.h"
029dea5a 53#include "AliAnalysisManager.h"
54#include "AliInputEventHandler.h"
2e876d85 55#include "AliEventplane.h"
e09cf5ef 56
57ClassImp(AliAnaParticleHadronCorrelation)
58
59
05d0d05d 60//___________________________________________________________________
e09cf5ef 61 AliAnaParticleHadronCorrelation::AliAnaParticleHadronCorrelation():
745913ae 62 AliAnaCaloTrackCorrBaseClass(),
66e64043 63 fMinTriggerPt(0.),
64 fMaxAssocPt(1000.), fMinAssocPt(0.),
05d0d05d 65 fDeltaPhiMaxCut(0.), fDeltaPhiMinCut(0.),
66 fSelectIsolated(0), fMakeSeveralUE(0),
67 fUeDeltaPhiMaxCut(0.), fUeDeltaPhiMinCut(0.),
68 fPi0AODBranchName(""), fNeutralCorr(0),
907b38cd 69 fPi0Trigger(0), fDecayTrigger(0),
3f150b4b 70 fMakeAbsoluteLeading(0), fMakeNearSideLeading(0),
907b38cd 71 fLeadingTriggerIndex(-1), fHMPIDCorrelation(0), fFillBradHisto(0),
05d0d05d 72 fNAssocPtBins(0), fAssocPtBinLimit(),
7d306daf 73 fCorrelVzBin(0),
2bb7ac98 74 fListMixTrackEvents(), fListMixCaloEvents(),
75 fUseMixStoredInReader(0), fFillNeutralEventMixPool(0),
b1f720a7 76 fM02MaxCut(0), fM02MinCut(0),
f7408d50 77 fFillPileUpHistograms(0),
78 fSelectLeadingHadronAngle(0),
79 fMinLeadHadPhi(0), fMaxLeadHadPhi(0),
80 fMinLeadHadPt(0), fMaxLeadHadPt(0),
81
05d0d05d 82 //Histograms
7d306daf 83 fhPtInput(0), fhPtFidCut(0),
cc944149 84 fhPtLeading(0), fhPtLeadingVtxBC0(0),
b1f720a7 85 fhPtLeadingVzBin(0), fhPtLeadingBin(0),
764ab1f4 86 fhPhiLeading(0), fhEtaLeading(0),
87 fhPtLeadingMC(),
68cd2624 88 fhPtLeadingCentrality(0), fhPtLeadingEventPlane(0),
d0b625bc 89 fhLeadingEventPlaneCentrality(0),
7d306daf 90 fhPtLeadingMixed(0), fhPtLeadingMixedVzBin(0), fhPtLeadingMixedBin(0),
d0b625bc 91 fhPhiLeadingMixed(0), fhEtaLeadingMixed(0),
92 fhDeltaPhiDeltaEtaCharged(0),
05d0d05d 93 fhPhiCharged(0), fhEtaCharged(0),
94 fhDeltaPhiCharged(0), fhDeltaEtaCharged(0),
95 fhDeltaPhiChargedPt(0), fhDeltaPhiUeChargedPt(0),
9623bf34 96 fhUePart(0),
f7408d50 97 fhXECharged(0), fhXECharged_Cone2(0), fhXEUeCharged(0),
3f150b4b 98 fhXEPosCharged(0), fhXENegCharged(0),
f7408d50 99 fhPtHbpXECharged(0), fhPtHbpXECharged_Cone2(0), fhPtHbpXEUeCharged(0),
3f150b4b 100 fhZTCharged(0), fhZTUeCharged(0),
101 fhZTPosCharged(0), fhZTNegCharged(0),
102 fhPtHbpZTCharged(0), fhPtHbpZTUeCharged(0),
b1f720a7 103 fhXEChargedMC(), fhDeltaPhiChargedMC(),
104 fhDeltaPhiDeltaEtaChargedPtA3GeV(0),
105 fhDeltaPhiChargedPtA3GeV(0), fhDeltaEtaChargedPtA3GeV(0),
106 //Pile-Up
17af6e24 107 fhDeltaPhiChargedPileUp(), fhDeltaEtaChargedPileUp(),
fedea415 108 fhDeltaPhiChargedPtA3GeVPileUp(), fhDeltaEtaChargedPtA3GeVPileUp(),
109 fhXEChargedPileUp(), fhXEUeChargedPileUp(),
17af6e24 110 fhZTChargedPileUp(), fhZTUeChargedPileUp(),
111 fhPtTrigChargedPileUp(),
fedea415 112 fhDeltaPhiChargedOtherBC(), fhDeltaPhiChargedPtA3GeVOtherBC(),
113 fhXEChargedOtherBC(), fhXEUeChargedOtherBC(),
114 fhZTChargedOtherBC(), fhZTUeChargedOtherBC(),
115 fhPtTrigChargedOtherBC(),
2a9171b5 116 fhDeltaPhiChargedBC0(), fhDeltaPhiChargedPtA3GeVBC0(),
117 fhXEChargedBC0(), fhXEUeChargedBC0(),
118 fhZTChargedBC0(), fhZTUeChargedBC0(),
119 fhPtTrigChargedBC0(),
cc944149 120 fhDeltaPhiChargedVtxBC0(), fhDeltaPhiChargedPtA3GeVVtxBC0(),
121 fhXEChargedVtxBC0(), fhXEUeChargedVtxBC0(),
122 fhZTChargedVtxBC0(), fhZTUeChargedVtxBC0(),
123 fhPtTrigChargedVtxBC0(),
05d0d05d 124 fhDeltaPhiUeLeftCharged(0), fhDeltaPhiUeRightCharged(0),
8cc41381 125 fhDeltaPhiUeLeftUpCharged(0), fhDeltaPhiUeRightUpCharged(0),
126 fhDeltaPhiUeLeftDownCharged(0), fhDeltaPhiUeRightDownCharged(0),
3f150b4b 127 fhXEUeLeftCharged(0), fhXEUeRightCharged(0),
8cc41381 128 fhXEUeLeftUpCharged(0), fhXEUeRightUpCharged(0),
129 fhXEUeLeftDownCharged(0), fhXEUeRightDownCharged(0),
3f150b4b 130 fhPtHbpXEUeLeftCharged(0), fhPtHbpXEUeRightCharged(0),
131 fhZTUeLeftCharged(0), fhZTUeRightCharged(0),
132 fhPtHbpZTUeLeftCharged(0), fhPtHbpZTUeRightCharged(0),
05d0d05d 133 fhPtTrigPout(0), fhPtTrigCharged(0),
134 fhTrigDeltaPhiCharged(0x0), fhTrigDeltaEtaCharged(0x0),
3f150b4b 135 fhTrigXECorr(0x0), fhTrigXEUeCorr(0x0),
136 fhTrigZTCorr(0x0), fhTrigZTUeCorr(0x0),
8cc41381 137 fhAssocPtBkg(0), fhDeltaPhiDeltaEtaAssocPtBin(0),
138 fhDeltaPhiAssocPtBin(0),
139 fhDeltaPhiAssocPtBinDEta08(0), fhDeltaPhiAssocPtBinDEta0(0),
2013f378 140 fhDeltaPhiAssocPtBinHMPID(0), fhDeltaPhiAssocPtBinHMPIDAcc(0),
66e64043 141 fhDeltaPhiBradAssocPtBin(0), fhDeltaPhiBrad(0),
907b38cd 142 fhXEAssocPtBin(0), fhZTAssocPtBin(0),
e09cf5ef 143 fhDeltaPhiDeltaEtaNeutral(0),
05d0d05d 144 fhPhiNeutral(0), fhEtaNeutral(0),
145 fhDeltaPhiNeutral(0), fhDeltaEtaNeutral(0),
146 fhDeltaPhiNeutralPt(0), fhDeltaPhiUeNeutralPt(0),
3f150b4b 147 fhXENeutral(0), fhXEUeNeutral(0),
148 fhPtHbpXENeutral(0), fhPtHbpXEUeNeutral(0),
149 fhZTNeutral(0), fhZTUeNeutral(0),
150 fhPtHbpZTNeutral(0), fhPtHbpZTUeNeutral(0),
05d0d05d 151 fhDeltaPhiUeLeftNeutral(0), fhDeltaPhiUeRightNeutral(0),
3f150b4b 152 fhXEUeLeftNeutral(0), fhXEUeRightNeutral(0),
153 fhPtHbpXEUeLeftNeutral(0), fhPtHbpXEUeRightNeutral(0),
154 fhZTUeLeftNeutral(0), fhZTUeRightNeutral(0),
155 fhPtHbpZTUeLeftNeutral(0), fhPtHbpZTUeRightNeutral(0),
e09cf5ef 156 fhPtPi0DecayRatio(0),
3f150b4b 157 fhDeltaPhiDecayCharged(0), fhXEDecayCharged(0), fhZTDecayCharged(0),
158 fhDeltaPhiDecayNeutral(0), fhXEDecayNeutral(0), fhZTDecayNeutral(0),
907b38cd 159 fhDeltaPhiDecayChargedAssocPtBin(0),
160 fhXEDecayChargedAssocPtBin(0), fhZTDecayChargedAssocPtBin(0),
9623bf34 161 fh2phiLeadingParticle(0x0), fhMCPtLeading(0),
08f220c8 162 fhMCPhiLeading(0), fhMCEtaLeading(0),
05d0d05d 163 fhMCEtaCharged(0), fhMCPhiCharged(0),
164 fhMCDeltaEtaCharged(0), fhMCDeltaPhiCharged(0x0),
165 fhMCDeltaPhiDeltaEtaCharged(0), fhMCDeltaPhiChargedPt(0),
9623bf34 166 fhMCPtXECharged(0), fhMCPtXEUeCharged(0),
c78eef61 167 fhMCPtXEUeLeftCharged(0), fhMCPtXEUeRightCharged(0),
9623bf34 168 fhMCPtHbpXECharged(0), fhMCPtHbpXEUeCharged(0),
c78eef61 169 fhMCPtHbpXEUeLeftCharged(0), fhMCPtHbpXEUeRightCharged(0),
9623bf34 170 fhMCUePart(0),
c78eef61 171 fhMCPtZTCharged(0), fhMCPtZTUeCharged(0),
172 fhMCPtZTUeLeftCharged(0), fhMCPtZTUeRightCharged(0),
173 fhMCPtHbpZTCharged(0), fhMCPtHbpZTUeCharged(0),
174 fhMCPtHbpZTUeLeftCharged(0), fhMCPtHbpZTUeRightCharged(0),
029dea5a 175 fhMCPtTrigPout(0), fhMCPtAssocDeltaPhi(0),
176 //Mixing
31864468 177 fhNEventsTrigger(0), fhNtracksMB(0), fhNclustersMB(0),
029dea5a 178 fhMixDeltaPhiCharged(0), fhMixDeltaPhiDeltaEtaCharged(0),
18838011 179 fhMixXECharged(0), fhMixXEUeCharged(0), fhMixHbpXECharged(0),
2013f378 180 fhMixDeltaPhiChargedAssocPtBin(),
181 fhMixDeltaPhiChargedAssocPtBinDEta08(),
8cc41381 182 fhMixDeltaPhiChargedAssocPtBinDEta0(),
2013f378 183 fhMixDeltaPhiDeltaEtaChargedAssocPtBin(),
68cd2624 184 fhEventBin(0), fhEventMixBin(0)
029dea5a 185{
8cc41381 186 //Default Ctor
029dea5a 187
e09cf5ef 188 //Initialize parameters
189 InitParameters();
764ab1f4 190
b1f720a7 191 for(Int_t i = 0; i < 7; i++)
764ab1f4 192 {
193 fhPtLeadingMC[i] = 0;
194 fhXEChargedMC[i] = 0;
b1f720a7 195 fhDeltaPhiChargedMC[i] = 0;
764ab1f4 196 }
197
17af6e24 198 for(Int_t i = 0; i < 7; i++)
199 {
200 fhPtLeadingPileUp [i] = 0 ;
201 fhDeltaPhiChargedPileUp [i] = 0 ; fhDeltaEtaChargedPileUp [i] = 0 ;
202 fhXEChargedPileUp [i] = 0 ; fhXEUeChargedPileUp [i] = 0 ;
203 fhZTChargedPileUp [i] = 0 ; fhZTUeChargedPileUp [i] = 0 ;
204 fhPtTrigChargedPileUp [i] = 0 ;
205 fhDeltaPhiChargedPtA3GeVPileUp[i] = 0 ; fhDeltaEtaChargedPtA3GeVPileUp[i] = 0 ;
17af6e24 206 }
207
e09cf5ef 208}
209
029dea5a 210//_________________________________________________________________
2bb7ac98 211AliAnaParticleHadronCorrelation::~AliAnaParticleHadronCorrelation()
029dea5a 212{
213 // Remove event containers
214
d07ffd54 215 if(DoOwnMix())
216 {
217 if(fListMixTrackEvents)
218 {
219 for(Int_t iz=0; iz < GetNZvertBin(); iz++)
029dea5a 220 {
d07ffd54 221 for(Int_t ic=0; ic < GetNCentrBin(); ic++)
222 {
223 for(Int_t irp=0; irp<GetNRPBin(); irp++)
224 {
225 Int_t bin = GetEventMixBin(ic, iz, irp);
226 fListMixTrackEvents[bin]->Delete() ;
227 delete fListMixTrackEvents[bin] ;
228 }
229 }
029dea5a 230 }
231 }
d07ffd54 232
233 delete[] fListMixTrackEvents;
234
235 if(fListMixCaloEvents)
236 {
237 for(Int_t iz=0; iz < GetNZvertBin(); iz++)
238 {
239 for(Int_t ic=0; ic < GetNCentrBin(); ic++)
240 {
241 for(Int_t irp=0; irp<GetNRPBin(); irp++)
242 {
243 Int_t bin = GetEventMixBin(ic, iz, irp);
244 fListMixCaloEvents[bin]->Delete() ;
245 delete fListMixCaloEvents[bin] ;
246 }
247 }
248 }
249 }
250
251 delete[] fListMixCaloEvents;
029dea5a 252
253 }
254}
255
907b38cd 256//______________________________________________________________________________________________________________________________________________________
22ad7981 257void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(Float_t ptAssoc, Float_t ptTrig, Int_t bin,
258 Float_t phiAssoc, Float_t phiTrig, Float_t & deltaPhi,
259 Float_t etaAssoc, Float_t etaTrig,
260 Bool_t decay, Float_t hmpidSignal, Int_t outTOF,
261 Int_t nTracks, Int_t mcTag)
907b38cd 262{
263 // Fill angular correlation related histograms
264
265 Float_t deltaEta = etaTrig-etaAssoc;
266 deltaPhi = phiTrig-phiAssoc;
267 Float_t deltaPhiOrg = deltaPhi;
268
269 if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
270 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
271
b1f720a7 272 fhEtaCharged ->Fill(ptAssoc,etaAssoc);
273 fhPhiCharged ->Fill(ptAssoc,phiAssoc);
274 fhDeltaEtaCharged ->Fill(ptTrig ,deltaEta);
275 fhDeltaPhiCharged ->Fill(ptTrig ,deltaPhi);
276 fhDeltaPhiChargedPt->Fill(ptAssoc, deltaPhi);
277 fhDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta);
278
279 if(ptAssoc > 3 )
280 {
281 fhDeltaEtaChargedPtA3GeV ->Fill(ptTrig ,deltaEta);
282 fhDeltaPhiChargedPtA3GeV ->Fill(ptTrig ,deltaPhi);
283 fhDeltaPhiDeltaEtaChargedPtA3GeV->Fill(deltaPhi, deltaEta);
284 }
907b38cd 285
b1f720a7 286 // Pile up studies
17af6e24 287
288 if(fFillPileUpHistograms)
b1f720a7 289 {
2a9171b5 290 if (outTOF==1)
fedea415 291 {
560498d1 292 fhDeltaPhiChargedOtherBC->Fill(ptTrig ,deltaPhi) ;
fedea415 293 if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVOtherBC->Fill(ptTrig ,deltaPhi) ;
294 }
2a9171b5 295 else if(outTOF==0)
296 {
297 fhDeltaPhiChargedBC0->Fill(ptTrig ,deltaPhi) ;
298 if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVBC0->Fill(ptTrig ,deltaPhi) ;
299 }
fedea415 300
cc944149 301 Int_t vtxBC = GetReader()->GetVertexBC();
302 if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
303 {
304 fhDeltaPhiChargedVtxBC0->Fill(ptTrig ,deltaPhi) ;
305 if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVVtxBC0->Fill(ptTrig ,deltaPhi) ;
306 }
307
17af6e24 308 if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[0]->Fill(ptTrig ,deltaPhi) ; }
309 if(GetReader()->IsPileUpFromEMCal()) { fhDeltaEtaChargedPileUp[1]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[1]->Fill(ptTrig ,deltaPhi) ; }
310 if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhDeltaEtaChargedPileUp[2]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[2]->Fill(ptTrig ,deltaPhi) ; }
311 if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhDeltaEtaChargedPileUp[3]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[3]->Fill(ptTrig ,deltaPhi) ; }
312 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhDeltaEtaChargedPileUp[4]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[4]->Fill(ptTrig ,deltaPhi) ; }
313 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhDeltaEtaChargedPileUp[5]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[5]->Fill(ptTrig ,deltaPhi) ; }
314 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhDeltaEtaChargedPileUp[6]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[6]->Fill(ptTrig ,deltaPhi) ; }
315
b1f720a7 316 if(ptAssoc > 3 )
317 {
17af6e24 318 if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaPhi) ; }
319 if(GetReader()->IsPileUpFromEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[1]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[1]->Fill(ptTrig ,deltaPhi) ; }
320 if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[2]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[2]->Fill(ptTrig ,deltaPhi) ; }
321 if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[3]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[3]->Fill(ptTrig ,deltaPhi) ; }
322 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[4]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[4]->Fill(ptTrig ,deltaPhi) ; }
323 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhDeltaEtaChargedPtA3GeVPileUp[5]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[5]->Fill(ptTrig ,deltaPhi) ; }
324 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[6]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[6]->Fill(ptTrig ,deltaPhi) ; }
b1f720a7 325 }
326 }
327
328 if(IsDataMC())
329 {
330 Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
331 fhDeltaPhiChargedMC[mcIndex]->Fill(ptTrig , deltaPhi);
332 }
907b38cd 333
334 if(fDecayTrigger && decay) fhDeltaPhiDecayCharged ->Fill(ptTrig , deltaPhi);
335
336 Double_t dphiBrad = -100;
337 if(fFillBradHisto)
338 {
339 dphiBrad = atan2(sin(deltaPhiOrg), cos(deltaPhiOrg))/TMath::Pi();//-1 to 1
340 if(TMath::Abs(dphiBrad)>0.325 && TMath::Abs(dphiBrad)<0.475) //Hardcoded values, BAD, FIXME
341 {
342 fhAssocPtBkg->Fill(ptTrig, ptAssoc);
343 }
344
345 if(dphiBrad<-1./3) dphiBrad += 2;
346 fhDeltaPhiBrad->Fill(ptTrig, dphiBrad);
347 }
348
349 // Fill histograms in bins of associated particle pT
8cc41381 350 if(bin>=0)
907b38cd 351 {
8cc41381 352 fhDeltaPhiDeltaEtaAssocPtBin [bin]->Fill(deltaPhi,deltaEta);
353
354 fhDeltaPhiAssocPtBin [bin]->Fill(ptTrig, deltaPhi);
2013f378 355
356 if(TMath::Abs(deltaEta)> 0.8)
8cc41381 357 fhDeltaPhiAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi);
358
03a96401 359 if(TMath::Abs(deltaEta)< 0.01)
8cc41381 360 fhDeltaPhiAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi);
2013f378 361
362 if (fFillBradHisto)
8cc41381 363 fhDeltaPhiBradAssocPtBin [bin]->Fill(ptTrig, dphiBrad);
2013f378 364
365 if(fDecayTrigger && decay)
8cc41381 366 fhDeltaPhiDecayChargedAssocPtBin[bin]->Fill(ptTrig, deltaPhi);
907b38cd 367
368 if(fHMPIDCorrelation)
369 {
370 if( hmpidSignal > 0 )
371 {
372 //printf("Track pt %f with HMPID signal %f \n",pt,hmpidSignal);
8cc41381 373 fhDeltaPhiAssocPtBinHMPID[bin]->Fill(ptTrig, deltaPhi);
907b38cd 374 }
375
376 if(phiAssoc > 5*TMath::DegToRad() && phiAssoc < 20*TMath::DegToRad())
377 {
378 //printf("Track pt %f in HMPID acceptance phi %f \n ",pt,phi*TMath::RadToDeg() );
8cc41381 379 fhDeltaPhiAssocPtBinHMPIDAcc[bin]->Fill(ptTrig, deltaPhi);
907b38cd 380 }
381 }
382 }
383
384 //fill different multiplicity histogram
385 if(DoEventSelect())
386 {
387 for(Int_t im = 0; im<GetMultiBin(); im++)
388 {
389 if(nTracks < ( GetMaxMulti() - GetMinMulti() )/GetMultiBin()*(im+1))
390 {
391 fhTrigDeltaPhiCharged[im]->Fill(ptTrig,deltaPhi);
392 fhTrigDeltaEtaCharged[im]->Fill(ptTrig,deltaEta);
393 }
394 }
395 }
396}
397
398//____________________________________________________________________________________________________________________________________________________
22ad7981 399Bool_t AliAnaParticleHadronCorrelation::FillChargedMCCorrelationHistograms(Float_t mcAssocPt, Float_t mcAssocPhi, Float_t mcAssocEta,
400 Float_t mcTrigPt, Float_t mcTrigPhi, Float_t mcTrigEta)
907b38cd 401{
402 // Fill MC histograms independently of AOD or ESD
403
404 //Select only hadrons in pt range
d07cdf32 405 if( mcAssocPt < fMinAssocPt || mcAssocPt > fMaxAssocPt ) return kTRUE ; // exclude but continue
907b38cd 406
d07cdf32 407 if( mcAssocPhi < 0 ) mcAssocPhi+=TMath::TwoPi();
907b38cd 408
409 //remove trigger itself for correlation when use charged triggers
410 if(TMath::Abs(mcAssocPt -mcTrigPt ) < 1e-6 &&
411 TMath::Abs(mcAssocPhi-mcTrigPhi) < 1e-6 &&
412 TMath::Abs(mcAssocEta-mcTrigEta) < 1e-6) return kTRUE ; // exclude but continue
413
414 // Absolute leading?
d07cdf32 415 if( fMakeAbsoluteLeading && mcAssocPt > mcTrigPt ) return kFALSE; // skip event
907b38cd 416
d07cdf32 417 // Skip this event if near side associated particle pt larger than trigger
907b38cd 418 if( fMakeNearSideLeading && mcAssocPt > mcTrigPt &&
d07cdf32 419 TMath::Abs(mcAssocPhi-mcTrigPhi)<TMath::PiOver2() ) return kFALSE; // skip event
907b38cd 420
421 Float_t mcdeltaPhi= mcTrigPhi-mcAssocPhi;
422 if(mcdeltaPhi <= -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi();
423 if(mcdeltaPhi > 3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi();
424
425 Float_t mcxE =-mcAssocPt/mcTrigPt*TMath::Cos(mcdeltaPhi);// -(mcAssocPx*pxprim+mcAssocPy*pyprim)/(mcTrigPt*mcTrigPt);
426 Float_t mchbpXE =-100 ;
f16872ec 427 if(mcxE > 0 ) mchbpXE = TMath::Log(1./mcxE);
907b38cd 428
429 Float_t mczT = mcAssocPt/mcTrigPt ;
430 Float_t mchbpZT =-100 ;
f16872ec 431 if(mczT > 0 ) mchbpZT = TMath::Log(1./mczT);
907b38cd 432
433 //Selection within angular range
434 if( mcdeltaPhi< -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi();
435 if( mcdeltaPhi>3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi();
436
437 Double_t mcpout = mcAssocPt*TMath::Sin(mcdeltaPhi) ;
438
d07cdf32 439 if(GetDebug() > 0 )
440 {
441 AliInfo(Form("Charged hadron: track Pt %f, track Phi %f, phi trigger %f. Cuts: delta phi %2.2f < %2.2f < %2.2f, pT min %2.2f \n",
442 mcAssocPt,mcAssocPhi, mcTrigPhi,fDeltaPhiMinCut, mcdeltaPhi, fDeltaPhiMaxCut, GetMinPt()));
443 }
907b38cd 444
445 // Fill Histograms
446 fhMCEtaCharged ->Fill(mcAssocPt, mcAssocEta);
447 fhMCPhiCharged ->Fill(mcAssocPt, mcAssocPhi);
c78eef61 448 fhMCDeltaEtaCharged->Fill(mcTrigPt , mcTrigEta-mcAssocEta);
449 fhMCDeltaPhiCharged->Fill(mcTrigPt , mcdeltaPhi);
907b38cd 450 fhMCPtAssocDeltaPhi->Fill(mcAssocPt, mcdeltaPhi);
451
452 fhMCDeltaPhiDeltaEtaCharged->Fill(mcdeltaPhi,mcTrigEta-mcAssocEta);
453
454 //delta phi cut for correlation
455 if( (mcdeltaPhi > fDeltaPhiMinCut) && (mcdeltaPhi < fDeltaPhiMaxCut) )
456 {
457 fhMCDeltaPhiChargedPt->Fill(mcAssocPt,mcdeltaPhi);
c78eef61 458 fhMCPtXECharged ->Fill(mcTrigPt, mcxE);
459 fhMCPtHbpXECharged ->Fill(mcTrigPt, mchbpXE);
460 fhMCPtZTCharged ->Fill(mcTrigPt, mczT);
461 fhMCPtHbpZTCharged ->Fill(mcTrigPt, mchbpZT);
907b38cd 462 fhMCPtTrigPout ->Fill(mcTrigPt, mcpout) ;
463 }
9623bf34 464
465 //underlying event
9623bf34 466
c78eef61 467 if ( (mcdeltaPhi > fUeDeltaPhiMinCut) && (mcdeltaPhi < fUeDeltaPhiMaxCut) )
468 {
469 //Double_t randomphi = gRandom->Uniform(TMath::Pi()/2,3*TMath::Pi()/2);
470 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
471 Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi);
472 Double_t mcUezT = mcAssocPt/mcTrigPt;
473
474 if(mcUexE < 0.) mcUexE = -mcUexE;
9623bf34 475
c78eef61 476 fhMCPtXEUeCharged->Fill(mcTrigPt,mcUexE);
477 if(mcUexE > 0) fhMCPtHbpXEUeCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE));
9623bf34 478
c78eef61 479 fhMCPtZTUeCharged->Fill(mcTrigPt,mcUezT);
480 if(mcUezT > 0) fhMCPtHbpZTUeCharged->Fill(mcTrigPt,TMath::Log(1/mcUezT));
481
482 fhMCUePart->Fill(mcTrigPt);
483 }
484
485 //left
486 if((mcdeltaPhi<-fUeDeltaPhiMinCut) || (mcdeltaPhi >2*fUeDeltaPhiMaxCut))
487 {
488 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
489 Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi);
490 Double_t mcUezT = mcAssocPt/mcTrigPt;
491
492 if(mcUexE < 0.) mcUexE = -mcUexE;
493
494 fhMCPtXEUeLeftCharged->Fill(mcTrigPt,mcUexE);
495 if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE));
496
497 fhMCPtZTUeLeftCharged->Fill(mcTrigPt,mcUezT);
498 if(mcUexE > 0) fhMCPtHbpZTUeLeftCharged->Fill(mcTrigPt,TMath::Log(1/mcUezT));
499
500 }
501
502 //right
503 if((mcdeltaPhi > fUeDeltaPhiMinCut) && (mcdeltaPhi < fUeDeltaPhiMaxCut))
504 {
505 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
506 Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi);
507 Double_t mcUezT = mcAssocPt/mcTrigPt;
508
509 if(mcUexE < 0.) mcUexE = -mcUexE;
510
511 fhMCPtXEUeRightCharged->Fill(mcTrigPt,mcUexE);
512 if(mcUexE > 0) fhMCPtHbpXEUeRightCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE));
513
514 fhMCPtZTUeRightCharged->Fill(mcTrigPt,mcUezT);
515 if(mcUexE > 0) fhMCPtHbpZTUeRightCharged->Fill(mcTrigPt,TMath::Log(1/mcUezT));
516 }
907b38cd 517
518 return kTRUE;
519}
520
521//___________________________________________________________________________________________________________________
22ad7981 522void AliAnaParticleHadronCorrelation::FillChargedMomentumImbalanceHistograms(Float_t ptTrig, Float_t ptAssoc,
523 Float_t xE, Float_t hbpXE,
524 Float_t zT, Float_t hbpZT,
727a309a 525 Float_t pout, Float_t deltaPhi,
22ad7981 526 Int_t nTracks, Int_t charge,
527 Int_t bin, Bool_t decay,
528 Int_t outTOF, Int_t mcTag)
907b38cd 529
530{
531 // Fill mostly momentum imbalance related histograms
532
727a309a 533 fhXECharged ->Fill(ptTrig , xE);
907b38cd 534 fhPtHbpXECharged ->Fill(ptTrig , hbpXE);
535 fhZTCharged ->Fill(ptTrig , zT);
536 fhPtHbpZTCharged ->Fill(ptTrig , hbpZT);
537 fhPtTrigPout ->Fill(ptTrig , pout) ;
538 fhPtTrigCharged ->Fill(ptTrig , ptAssoc) ;
727a309a 539 if((deltaPhi > 5*TMath::Pi()/6.) && (deltaPhi < 7*TMath::Pi()/6.)) {
540 fhXECharged_Cone2 ->Fill(ptTrig , xE);
541 fhPtHbpXECharged_Cone2 ->Fill(ptTrig , hbpXE);
542 }
907b38cd 543
b1f720a7 544 // Pile up studies
17af6e24 545 if(fFillPileUpHistograms)
b1f720a7 546 {
2a9171b5 547 if (outTOF==1)
fedea415 548 {
549 fhXEChargedOtherBC ->Fill(ptTrig,xE);
550 fhZTChargedOtherBC ->Fill(ptTrig,zT);
551 fhPtTrigChargedOtherBC->Fill(ptTrig,ptAssoc);
552 }
2a9171b5 553 else if(outTOF==0)
554 {
555 fhXEChargedBC0 ->Fill(ptTrig,xE);
556 fhZTChargedBC0 ->Fill(ptTrig,zT);
557 fhPtTrigChargedBC0->Fill(ptTrig,ptAssoc);
558 }
559
cc944149 560 Int_t vtxBC = GetReader()->GetVertexBC();
561 if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
562 {
563 fhXEChargedVtxBC0 ->Fill(ptTrig,xE);
564 fhZTChargedVtxBC0 ->Fill(ptTrig,zT);
565 fhPtTrigChargedVtxBC0->Fill(ptTrig,ptAssoc);
566 }
567
fedea415 568 if(GetReader()->IsPileUpFromSPD()) { fhXEChargedPileUp[0]->Fill(ptTrig,xE); fhZTChargedPileUp[0]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[0]->Fill(ptTrig,ptAssoc); }
569 if(GetReader()->IsPileUpFromEMCal()) { fhXEChargedPileUp[1]->Fill(ptTrig,xE); fhZTChargedPileUp[1]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[1]->Fill(ptTrig,ptAssoc); }
570 if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEChargedPileUp[2]->Fill(ptTrig,xE); fhZTChargedPileUp[2]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[2]->Fill(ptTrig,ptAssoc); }
571 if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhXEChargedPileUp[3]->Fill(ptTrig,xE); fhZTChargedPileUp[3]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[3]->Fill(ptTrig,ptAssoc); }
572 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhXEChargedPileUp[4]->Fill(ptTrig,xE); fhZTChargedPileUp[4]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[4]->Fill(ptTrig,ptAssoc); }
573 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhXEChargedPileUp[5]->Fill(ptTrig,xE); fhZTChargedPileUp[5]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[5]->Fill(ptTrig,ptAssoc); }
574 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhXEChargedPileUp[6]->Fill(ptTrig,xE); fhZTChargedPileUp[6]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[6]->Fill(ptTrig,ptAssoc); }
b1f720a7 575 }
576
764ab1f4 577 if(IsDataMC())
578 {
b1f720a7 579 Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
580 fhXEChargedMC [mcIndex]->Fill(ptTrig , xE );
764ab1f4 581 }
582
907b38cd 583 if(fDecayTrigger && decay)
584 {
585 fhXEDecayCharged->Fill(ptTrig,xE);
586 fhZTDecayCharged->Fill(ptTrig,zT);
587 } // photon decay pi0/eta trigger
588
8cc41381 589 if(bin >= 0 )//away side
907b38cd 590 {
8cc41381 591 fhXEAssocPtBin[bin]->Fill(ptTrig, xE) ;
592 fhZTAssocPtBin[bin]->Fill(ptTrig, zT) ;
907b38cd 593
594 if(fDecayTrigger && decay)
595 {
8cc41381 596 fhXEDecayChargedAssocPtBin[bin]->Fill(ptTrig, xE);
597 fhZTDecayChargedAssocPtBin[bin]->Fill(ptTrig, zT);
907b38cd 598 }
599 }
600
601 if(charge > 0)
602 {
603 fhXEPosCharged->Fill(ptTrig,xE) ;
604 fhZTPosCharged->Fill(ptTrig,zT) ;
605 }
606 else
607 {
608 fhXENegCharged->Fill(ptTrig,xE) ;
609 fhZTNegCharged->Fill(ptTrig,zT) ;
610 }
611
612 //fill different multiplicity histogram
613 if(DoEventSelect())
614 {
615 for(Int_t im=0; im<GetMultiBin(); im++)
616 {
617 if(nTracks < ( GetMaxMulti() - GetMinMulti() )/GetMultiBin()*(im+1))
618 {
619 fhTrigXECorr[im]->Fill(ptTrig,xE);
620 fhTrigZTCorr[im]->Fill(ptTrig,zT);
621 }
622 }
623 } //multiplicity events selection
624}
625
626//_______________________________________________________________________________________________________________________
22ad7981 627void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventHistograms(Float_t ptTrig, Float_t ptAssoc,
628 Float_t deltaPhi, Int_t nTracks, Int_t outTOF)
907b38cd 629{
630 // Fill underlying event histograms
631
632 fhDeltaPhiUeChargedPt->Fill(ptAssoc,deltaPhi);
633
08f220c8 634 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
907b38cd 635 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
636 Double_t uezT = ptAssoc/ptTrig;
637
638 if(uexE < 0.) uexE = -uexE;
639
640 fhXEUeCharged->Fill(ptTrig,uexE);
f16872ec 641 if(uexE > 0) fhPtHbpXEUeCharged->Fill(ptTrig,TMath::Log(1/uexE));
907b38cd 642
643 fhZTUeCharged->Fill(ptTrig,uezT);
76fc98bb 644 if(uezT > 0) fhPtHbpZTUeCharged->Fill(ptTrig,TMath::Log(1/uezT));
907b38cd 645
b1f720a7 646 // Pile up studies
17af6e24 647
648 if(fFillPileUpHistograms)
b1f720a7 649 {
2a9171b5 650 if (outTOF==1)
fedea415 651 {
652 fhXEUeChargedOtherBC->Fill(ptTrig,uexE);
653 fhZTUeChargedOtherBC->Fill(ptTrig,uezT);
654 }
2a9171b5 655 else if(outTOF==0)
656 {
657 fhXEUeChargedBC0->Fill(ptTrig,uexE);
658 fhZTUeChargedBC0->Fill(ptTrig,uezT);
659 }
fedea415 660
cc944149 661 Int_t vtxBC = GetReader()->GetVertexBC();
662 if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
663 {
664 fhXEUeChargedVtxBC0->Fill(ptTrig,uexE);
665 fhZTUeChargedVtxBC0->Fill(ptTrig,uezT);
666 }
667
17af6e24 668 if(GetReader()->IsPileUpFromSPD()) { fhXEUeChargedPileUp[0]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[0]->Fill(ptTrig,uezT);}
669 if(GetReader()->IsPileUpFromEMCal()) { fhXEUeChargedPileUp[1]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[1]->Fill(ptTrig,uezT);}
670 if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEUeChargedPileUp[2]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[2]->Fill(ptTrig,uezT);}
671 if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhXEUeChargedPileUp[3]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[3]->Fill(ptTrig,uezT);}
672 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhXEUeChargedPileUp[4]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[4]->Fill(ptTrig,uezT);}
673 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhXEUeChargedPileUp[5]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[5]->Fill(ptTrig,uezT);}
674 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhXEUeChargedPileUp[6]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[6]->Fill(ptTrig,uezT);}
675 }
b1f720a7 676
907b38cd 677 if(DoEventSelect())
678 {
679 for(Int_t im=0; im<GetMultiBin(); im++)
680 {
681 if(nTracks < ( GetMaxMulti() - GetMinMulti() )/GetMultiBin()*(im+1))
682 {
683 fhTrigXEUeCorr[im]->Fill(ptTrig,uexE); // xE? CHECK
684 fhTrigZTUeCorr[im]->Fill(ptTrig,uezT); // zT? CHECK
685 }
686 }
687 } //multiplicity events selection
688}
689
8cc41381 690//_____________________________________________________________________________________________________
22ad7981 691void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventSidesHistograms(Float_t ptTrig,
692 Float_t ptAssoc,
693 Float_t deltaPhi)
907b38cd 694{
08f220c8 695 // Fill underlying event histograms to the left and right of trigger
696 if((deltaPhi<-fUeDeltaPhiMinCut) || (deltaPhi >2*fUeDeltaPhiMaxCut))
907b38cd 697 {
08f220c8 698 fhDeltaPhiUeLeftCharged->Fill(ptAssoc,deltaPhi);
699 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
700 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
701 Double_t uezT = ptAssoc/ptTrig;
702
703 if(uexE < 0.) uexE = -uexE;
704
705 fhXEUeLeftCharged->Fill(ptTrig,uexE);
706 if(uexE > 0) fhPtHbpXEUeLeftCharged->Fill(ptTrig,TMath::Log(1/uexE));
707
708 fhZTUeLeftCharged->Fill(ptTrig,uezT);
709 if(uexE > 0) fhPtHbpZTUeLeftCharged->Fill(ptTrig,TMath::Log(1/uezT));
907b38cd 710 fhDeltaPhiUeLeftCharged->Fill(ptAssoc, deltaPhi);
907b38cd 711 }
712
713 if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut))
714 {
08f220c8 715 fhDeltaPhiUeRightCharged->Fill(ptAssoc,deltaPhi);
716 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
717 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
718 Double_t uezT = ptAssoc/ptTrig;
719
720 if(uexE < 0.) uexE = -uexE;
721
722 fhXEUeRightCharged->Fill(ptTrig,uexE);
723 if(uexE > 0) fhPtHbpXEUeRightCharged->Fill(ptTrig,TMath::Log(1/uexE));
724
725 fhZTUeRightCharged->Fill(ptTrig,uezT);
726 if(uexE > 0) fhPtHbpZTUeRightCharged->Fill(ptTrig,TMath::Log(1/uezT));
907b38cd 727 fhDeltaPhiUeRightCharged->Fill(ptAssoc, deltaPhi);
907b38cd 728 }
8cc41381 729
730 if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-TMath::Pi()/2))
731 {
732 fhDeltaPhiUeLeftDownCharged->Fill(ptAssoc,deltaPhi);
733 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
734 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
735
736 if(uexE < 0.) uexE = -uexE;
737
738 fhXEUeLeftDownCharged->Fill(ptTrig,uexE);
739 }
740
741 if((deltaPhi>2*fUeDeltaPhiMaxCut) && (deltaPhi <3*TMath::Pi()/2))
742 {
743 fhDeltaPhiUeLeftUpCharged->Fill(ptAssoc,deltaPhi);
744 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
745 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
746
747 if(uexE < 0.) uexE = -uexE;
748
749 fhXEUeLeftUpCharged->Fill(ptTrig,uexE);
750 }
751
752 if((deltaPhi > TMath::Pi()/2) && (deltaPhi < fUeDeltaPhiMaxCut))
753 {
754 fhDeltaPhiUeRightUpCharged->Fill(ptAssoc,deltaPhi);
755 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
756 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
757
758 if(uexE < 0.) uexE = -uexE;
759
760 fhXEUeRightUpCharged->Fill(ptTrig,uexE);
761 }
762
763 if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < TMath::Pi()/2))
764 {
765 fhDeltaPhiUeRightDownCharged->Fill(ptAssoc,deltaPhi);
766 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
767 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
768
769 if(uexE < 0.) uexE = -uexE;
770
771 fhXEUeRightDownCharged->Fill(ptTrig,uexE);
772 }
907b38cd 773}
774
775//______________________________________________________________________________________________________________________________
22ad7981 776void AliAnaParticleHadronCorrelation::FillDecayPhotonCorrelationHistograms(Float_t ptAssoc, Float_t phiAssoc,
777 TLorentzVector mom1, TLorentzVector mom2,
778 Bool_t bChargedOrNeutral)
907b38cd 779{
780 // Do correlation with decay photons of triggered pi0 or eta
781
782 // Calculate the correlation parameters
783 Float_t ptDecay1 = mom1.Pt();
784 Float_t ptDecay2 = mom2.Pt();
785
786 Float_t zTDecay1 = -100, zTDecay2 = -100;
787 if(ptDecay1) zTDecay1 = ptAssoc/ptDecay1 ;
788 if(ptDecay2) zTDecay2 = ptAssoc/ptDecay2 ;
789
790 Float_t deltaPhiDecay1 = mom1.Phi()-phiAssoc;
791 if(deltaPhiDecay1< -TMath::PiOver2()) deltaPhiDecay1+=TMath::TwoPi();
792 if(deltaPhiDecay1>3*TMath::PiOver2()) deltaPhiDecay1-=TMath::TwoPi();
793
794 Float_t deltaPhiDecay2 = mom2.Phi()-phiAssoc;
795 if(deltaPhiDecay2< -TMath::PiOver2()) deltaPhiDecay2+=TMath::TwoPi();
796 if(deltaPhiDecay2>3*TMath::PiOver2()) deltaPhiDecay2-=TMath::TwoPi();
797
798 Float_t xEDecay1 =-zTDecay1*TMath::Cos(deltaPhiDecay1); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
799 Float_t xEDecay2 =-zTDecay2*TMath::Cos(deltaPhiDecay2); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
800
801 if(bChargedOrNeutral) // correlate with charges
802 {
803 fhDeltaPhiDecayCharged->Fill(ptDecay1, deltaPhiDecay1);
804 fhDeltaPhiDecayCharged->Fill(ptDecay2, deltaPhiDecay2);
805
2e876d85 806 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::FillDecayPhotonHistograms( Charged corr) - deltaPhoton1 = %f, deltaPhoton2 = %f \n", deltaPhiDecay1, deltaPhiDecay2);
907b38cd 807
808 if( (deltaPhiDecay1 > fDeltaPhiMinCut) && ( deltaPhiDecay1 < fDeltaPhiMaxCut) )
809 {
810 fhZTDecayCharged->Fill(ptDecay1,zTDecay1);
811 fhXEDecayCharged->Fill(ptDecay1,xEDecay1);
812 }
813 if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) )
814 {
815 fhZTDecayCharged->Fill(ptDecay2,zTDecay2);
816 fhXEDecayCharged->Fill(ptDecay2,xEDecay2);
817 }
818 }
819 else // correlate with neutrals
820 {
821 fhDeltaPhiDecayCharged->Fill(ptDecay1, deltaPhiDecay1);
822 fhDeltaPhiDecayCharged->Fill(ptDecay2, deltaPhiDecay2);
823
2e876d85 824 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::FillDecayPhotonHistograms(Neutral corr) - deltaPhoton1 = %f, deltaPhoton2 = %f \n", deltaPhiDecay1, deltaPhiDecay2);
907b38cd 825
826 if( (deltaPhiDecay1 > fDeltaPhiMinCut) && ( deltaPhiDecay1 < fDeltaPhiMaxCut) )
827 {
828 fhZTDecayCharged->Fill(ptDecay1,zTDecay1);
829 fhXEDecayCharged->Fill(ptDecay1,xEDecay1);
830 }
831 if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) )
832 {
833 fhZTDecayCharged->Fill(ptDecay2,zTDecay2);
834 fhXEDecayCharged->Fill(ptDecay2,xEDecay2);
835 }
836 }
837}
838
839//______________________________________________________________________________________________________________________________________________________
22ad7981 840void AliAnaParticleHadronCorrelation::FillNeutralAngularCorrelationHistograms(Float_t ptAssoc, Float_t ptTrig,
841 Float_t phiAssoc, Float_t phiTrig, Float_t & deltaPhi,
842 Float_t etaAssoc, Float_t etaTrig)
907b38cd 843{
844 // Fill angular correlation related histograms
845
846 Float_t deltaEta = etaTrig-etaAssoc;
847 deltaPhi = phiTrig-phiAssoc;
848
849 if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
850 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
851
852 fhEtaNeutral ->Fill(ptAssoc,etaAssoc);
853 fhPhiNeutral ->Fill(ptAssoc,phiAssoc);
854 fhDeltaEtaNeutral->Fill(ptTrig ,deltaEta);
855 fhDeltaPhiNeutral->Fill(ptTrig ,deltaPhi);
856
857 if(ptAssoc > 2 ) fhDeltaPhiDeltaEtaNeutral->Fill(deltaPhi, deltaEta);
858
859}
860
861//_____________________________________________________________________________________________________________________________
22ad7981 862void AliAnaParticleHadronCorrelation::FillNeutralUnderlyingEventSidesHistograms(Float_t ptTrig, Float_t ptAssoc,
863 Float_t xE, Float_t hbpXE,
864 Float_t zT, Float_t hbpZT,
865 Float_t deltaPhi)
907b38cd 866{
867 // Fill underlying event histograms to the left and right of trigger
868
869 if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-fUeDeltaPhiMaxCut))
870 {
871 fhDeltaPhiUeLeftNeutral->Fill(ptAssoc, deltaPhi);
872 fhXEUeLeftNeutral ->Fill(ptTrig , xE);
873 fhPtHbpXEUeLeftNeutral ->Fill(ptTrig , hbpXE);
874 fhZTUeLeftNeutral ->Fill(ptTrig , zT);
875 fhPtHbpZTUeLeftNeutral ->Fill(ptTrig , hbpZT);
876 }
877
878 if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut))
879 {
880 fhDeltaPhiUeRightNeutral->Fill(ptAssoc, deltaPhi);
881 fhXEUeRightNeutral ->Fill(ptTrig , xE);
882 fhPtHbpXEUeRightNeutral ->Fill(ptTrig , hbpXE);
883 fhZTUeRightNeutral ->Fill(ptTrig , zT);
884 fhPtHbpZTUeRightNeutral ->Fill(ptTrig , hbpZT);
885 }
886}
887
31864468 888//______________________________________________________
889void AliAnaParticleHadronCorrelation::FillEventMixPool()
890{
891 // Fill the pool with tracks if requested
892
893 if(DoOwnMix())
894 {
895 FillChargedEventMixPool();
896
897 if(OnlyIsolated() || fFillNeutralEventMixPool)
898 FillNeutralEventMixPool();
899 }
900
901}
902
029dea5a 903//_____________________________________________________________
904void AliAnaParticleHadronCorrelation::FillChargedEventMixPool()
905{
d07ffd54 906 // Mixed event pool filling for tracks
31864468 907
7ed3a248 908 if(fUseMixStoredInReader && GetReader()->GetLastTracksMixedEvent() == GetEventNumber())
909 {
910 //printf("%s : Pool already filled for this event !!!\n",GetInputAODName().Data());
911 return ; // pool filled previously for another trigger
912 }
913
029dea5a 914 Int_t nTracks = GetCTSTracks()->GetEntriesFast();
31864468 915
029dea5a 916 AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
917 AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
918
c6b4facc 919 if(!inputHandler) return ;
31864468 920
d07ffd54 921 // Do mixing only with MB event (or the chosen mask), if not skip
922 if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ;
923
924 fhNtracksMB->Fill(nTracks);
925
926 Int_t eventBin = GetEventMixBin();
927
928 //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
929 if(eventBin < 0) return;
930
931 TObjArray * mixEventTracks = new TObjArray;
932
933 if(fUseMixStoredInReader)
029dea5a 934 {
d07ffd54 935 fListMixTrackEvents[eventBin] = GetReader()->GetListWithMixedEventsForTracks(eventBin);
936 }
937
938 if(!fListMixTrackEvents[eventBin]) fListMixTrackEvents[eventBin] = new TList();
939
940 //printf("%s ***** Pool Event bin : %d - nTracks %d\n",GetInputAODName().Data(),eventBin, GetCTSTracks()->GetEntriesFast());
941
942 TList * pool = fListMixTrackEvents[eventBin];
943
944 TVector3 p3;
945 for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
946 {
947 AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
029dea5a 948
d07ffd54 949 Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
950 p3.SetXYZ(mom[0],mom[1],mom[2]);
951 Float_t pt = p3.Pt();
2e876d85 952
d07ffd54 953 //Select only hadrons in pt range
954 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
029dea5a 955
d07ffd54 956 AliAODPWG4Particle * mixedTrack = new AliAODPWG4Particle(mom[0],mom[1],mom[2],0);
957 mixedTrack->SetDetector("CTS");
958 mixedTrack->SetChargedBit(track->Charge()>0);
959 mixEventTracks->Add(mixedTrack);
960 }
961
962 //Set the event number where the last event was added, to avoid double pool filling
963 GetReader()->SetLastTracksMixedEvent(GetEventNumber());
964
965 //printf("Add event to pool with %d tracks \n ",mixEventTracks->GetEntries());
966 pool->AddFirst(mixEventTracks);
967 mixEventTracks = 0;
968
969 //printf("Pool size %d, max %d\n",pool->GetSize(), GetNMaxEvMix());
970
971 if(pool->GetSize() > GetNMaxEvMix())
972 {//Remove last event
973 TClonesArray * tmp = static_cast<TClonesArray*>(pool->Last()) ;
974 pool->RemoveLast() ;
975 delete tmp ;
976 }
977}
978
979//_____________________________________________________________
980void AliAnaParticleHadronCorrelation::FillNeutralEventMixPool()
981{
982 // Mixed event pool filling for neutral clusters
983 // Right now only for EMCAL and in isolation case
984
985 //printf("FillNeutralEventMixPool for %s\n",GetInputAODName().Data());
986
2bb7ac98 987 TObjArray * pl = GetEMCALClusters();
988 //if (GetAODObjArrayName.Contains("PHOS") )pl = GetPHOSClusters();
989 //else pl = GetEMCALClusters();
990
991 Int_t nClusters = pl->GetEntriesFast();
2bb7ac98 992
d07ffd54 993 if(fUseMixStoredInReader && GetReader()->GetLastCaloMixedEvent() == GetEventNumber())
994 {
995 //printf("%s : Pool already filled for this event !!!\n",GetInputAODName().Data());
996 return ; // pool filled previously for another trigger
997 }
998
d07ffd54 999 AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
1000 AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
1001
1002 if(!inputHandler) return ;
31864468 1003
d07ffd54 1004 // Do mixing only with MB event (or the chosen mask), if not skip
1005 if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ;
1006
2bb7ac98 1007 fhNclustersMB->Fill(nClusters);
d07ffd54 1008
1009 Int_t eventBin = GetEventMixBin();
1010
1011 //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
1012 if(eventBin < 0) return;
1013
1014 TObjArray * mixEventCalo = new TObjArray;
1015
1016 if(fUseMixStoredInReader)
1017 {
1018 fListMixCaloEvents[eventBin] = GetReader()->GetListWithMixedEventsForCalo(eventBin);
1019 }
1020
1021 if(!fListMixCaloEvents[eventBin]) fListMixCaloEvents[eventBin] = new TList();
1022
1023 TList * poolCalo = fListMixCaloEvents[eventBin];
1024
d07ffd54 1025 TLorentzVector mom;
2bb7ac98 1026
1027 for(Int_t ipr = 0;ipr < nClusters ; ipr ++ )
d07ffd54 1028 {
1029 AliVCluster * calo = (AliVCluster *) (pl->At(ipr)) ;
1030
1031 // remove matched clusters
1032 if( IsTrackMatched( calo, GetReader()->GetInputEvent() ) ) continue ;
283f989c 1033
2bb7ac98 1034 //Cluster momentum calculation
d07ffd54 1035 if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
283f989c 1036 {
d07ffd54 1037 calo->GetMomentum(mom,GetVertex(0)) ;
1038 }//Assume that come from vertex in straight line
1039 else
029dea5a 1040 {
d07ffd54 1041 Double_t vertex[]={0,0,0};
1042 calo->GetMomentum(mom,vertex) ;
029dea5a 1043 }
1044
d07ffd54 1045 Float_t pt = mom.Pt();
1046 //Select only clusters in pt range
1047 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
2e876d85 1048
d07ffd54 1049 AliAODPWG4Particle * mixedCalo = new AliAODPWG4Particle(mom);
1050 mixedCalo->SetDetector("EMCAL");
1051 mixEventCalo->Add(mixedCalo);
1052 }
1053
1054 //Set the event number where the last event was added, to avoid double pool filling
1055 GetReader()->SetLastCaloMixedEvent(GetEventNumber());
1056
1057 //printf("Add event to pool with %d clusters \n ",mixEventCalo->GetEntries());
1058 poolCalo->AddFirst(mixEventCalo);
1059 mixEventCalo = 0;
1060
1061 //printf("Pool size %d, max %d\n",poolCalo->GetSize(), GetNMaxEvMix());
029dea5a 1062
d07ffd54 1063 if(poolCalo->GetSize() > GetNMaxEvMix())
1064 {//Remove last event
1065 TClonesArray * tmp = static_cast<TClonesArray*>(poolCalo->Last()) ;
1066 poolCalo->RemoveLast() ;
1067 delete tmp ;
1068 }
029dea5a 1069}
1070
05d0d05d 1071//____________________________________________________________
1072TObjString* AliAnaParticleHadronCorrelation::GetAnalysisCuts()
1073{
1074 //Save parameters used for analysis
1075 TString parList ; //this will be list of parameters used for this analysis.
1076 const Int_t buffersize = 560;
1077 char onePar[buffersize] ;
1078
1079 snprintf(onePar,buffersize,"--- AliAnaPaticleHadronCorrelation ---\n") ;
1080 parList+=onePar ;
66e64043 1081 snprintf(onePar,buffersize," Pt Trigger > %3.2f ", fMinTriggerPt) ;
05d0d05d 1082 parList+=onePar ;
66e64043 1083 snprintf(onePar,buffersize," %3.2f < Pt associated < %3.2f ", fMinAssocPt, fMaxAssocPt) ;
05d0d05d 1084 parList+=onePar ;
66e64043 1085 snprintf(onePar,buffersize," %3.2f < Phi trigger particle-Hadron < %3.2f ", fDeltaPhiMinCut, fDeltaPhiMaxCut) ;
05d0d05d 1086 parList+=onePar ;
66e64043 1087 snprintf(onePar,buffersize," %3.2f < Phi trigger particle-UeHadron < %3.2f ", fUeDeltaPhiMinCut, fUeDeltaPhiMaxCut) ;
05d0d05d 1088 parList+=onePar ;
66e64043 1089 snprintf(onePar,buffersize,"Isolated Trigger? %d\n", fSelectIsolated) ;
05d0d05d 1090 parList+=onePar ;
66e64043 1091 snprintf(onePar,buffersize,"Several UE? %d\n", fMakeSeveralUE) ;
05d0d05d 1092 parList+=onePar ;
66e64043 1093 snprintf(onePar,buffersize,"Name of AOD Pi0 Branch %s ", fPi0AODBranchName.Data());
05d0d05d 1094 parList+=onePar ;
907b38cd 1095 snprintf(onePar,buffersize,"Do Decay-hadron correlation ? pi0 %d, decay %d", fPi0Trigger, fDecayTrigger) ;
05d0d05d 1096 parList+=onePar ;
3f150b4b 1097 snprintf(onePar,buffersize,"Select absolute leading for cluster triggers ? %d or Near Side Leading %d \n",
1098 fMakeAbsoluteLeading, fMakeNearSideLeading) ;
05d0d05d 1099 parList+=onePar ;
1100 snprintf(onePar,buffersize,"Associated particle pt bins %d: ", fNAssocPtBins) ;
1101 parList+=onePar ;
1102 for (Int_t ibin = 0; ibin<fNAssocPtBins; ibin++) {
1103 snprintf(onePar,buffersize,"bin %d = [%2.1f,%2.1f];", ibin, fAssocPtBinLimit[ibin], fAssocPtBinLimit[ibin+1]) ;
1104 }
1105 parList+=onePar ;
1106
1107 //Get parameters set in base class.
1108 parList += GetBaseParametersList() ;
1109
05d0d05d 1110 //Get parameters set in FiducialCut class (not available yet)
1111 //parlist += GetFidCut()->GetFidCutParametersList()
1112
1113 return new TObjString(parList) ;
1114
1115}
1116
1117//________________________________________________________________
e09cf5ef 1118TList * AliAnaParticleHadronCorrelation::GetCreateOutputObjects()
1119{
1120
1121 // Create histograms to be saved in output file and
1122 // store them in fOutputContainer
029dea5a 1123
e09cf5ef 1124 TList * outputContainer = new TList() ;
1125 outputContainer->SetName("CorrelationHistos") ;
1126
62f2fe4d 1127 Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins(); Int_t netabins = GetHistogramRanges()->GetHistoEtaBins(); Int_t ndeltaphibins = GetHistogramRanges()->GetHistoDeltaPhiBins(); Int_t ndeltaetabins = GetHistogramRanges()->GetHistoDeltaEtaBins();
1128 Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t phimax = GetHistogramRanges()->GetHistoPhiMax(); Float_t etamax = GetHistogramRanges()->GetHistoEtaMax(); Float_t deltaphimax = GetHistogramRanges()->GetHistoDeltaPhiMax(); Float_t deltaetamax = GetHistogramRanges()->GetHistoDeltaEtaMax();
1129 Float_t ptmin = GetHistogramRanges()->GetHistoPtMin(); Float_t phimin = GetHistogramRanges()->GetHistoPhiMin(); Float_t etamin = GetHistogramRanges()->GetHistoEtaMin(); Float_t deltaphimin = GetHistogramRanges()->GetHistoDeltaPhiMin(); Float_t deltaetamin = GetHistogramRanges()->GetHistoDeltaEtaMin();
e09cf5ef 1130
d0b625bc 1131 Int_t nMixBins = GetNCentrBin()*GetNZvertBin()*GetNRPBin();
1132
17af6e24 1133 TString nameMC[] = {"Photon","Pi0","Pi0Decay","EtaDecay","OtherDecay","Electron","Hadron"};
1134 TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ;
1135
7d306daf 1136 // For vz dependent histograms, if option ON
1137 Int_t nz = 1 ;
1138 if(fCorrelVzBin) nz = GetNZvertBin();
1139 TString sz = "" ;
1140 TString tz = "" ;
1141
858212dd 1142 fhPtInput = new TH1F("hPtInput","#it{p}_{T} distribution of input trigger particles", nptbins,ptmin,ptmax);
1143 fhPtInput->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
7d306daf 1144 outputContainer->Add(fhPtInput);
1145
858212dd 1146 fhPtFidCut = new TH1F("hPtFidCut","#it{p}_{T} distribution of input trigger particles after fiducial cut", nptbins,ptmin,ptmax);
1147 fhPtFidCut->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
7d306daf 1148 outputContainer->Add(fhPtFidCut);
1149
858212dd 1150 fhPtLeading = new TH1F("hPtLeading","#it{p}_{T} distribution of leading particles", nptbins,ptmin,ptmax);
1151 fhPtLeading->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
7d306daf 1152 outputContainer->Add(fhPtLeading);
ca17b39f 1153
764ab1f4 1154 if(IsDataMC())
1155 {
b1f720a7 1156 for(Int_t i=0; i < 7; i++)
764ab1f4 1157 {
1158 fhPtLeadingMC[i] = new TH1F(Form("hPtLeading_MC%s",nameMC[i].Data()),
858212dd 1159 Form("#it{p}_{T} distribution of leading particles, trigger origin is %s",nameMC[i].Data()),
764ab1f4 1160 nptbins,ptmin,ptmax);
858212dd 1161 fhPtLeadingMC[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
764ab1f4 1162 outputContainer->Add(fhPtLeadingMC[i]);
1163 }
1164 }
1165
7d306daf 1166 if(fCorrelVzBin)
1167 {
858212dd 1168 fhPtLeadingVzBin = new TH2F("hPtLeadingVzBin","#it{p}_{T} distribution of leading particles vs vz bin", nptbins,ptmin,ptmax,GetNZvertBin(),0,GetNZvertBin());
1169 fhPtLeadingVzBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
1170 fhPtLeadingVzBin->SetYTitle("#it{v}_{#it{z}} bin");
7d306daf 1171 outputContainer->Add(fhPtLeadingVzBin);
1172 }
1173
858212dd 1174 fhPtLeadingBin = new TH2F ("hPtLeadingBin","#it{p}_{T} distribution of leading particles", nptbins,ptmin,ptmax,nMixBins,0,nMixBins);
1175 fhPtLeadingBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
d0b625bc 1176 fhPtLeadingBin->SetYTitle("Bin");
7d306daf 1177 outputContainer->Add(fhPtLeadingBin);
d0b625bc 1178
e09cf5ef 1179 fhPhiLeading = new TH2F ("hPhiLeading","#phi distribution of leading Particles",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
1180 fhPhiLeading->SetYTitle("#phi (rad)");
7d306daf 1181 outputContainer->Add(fhPhiLeading);
1182
e09cf5ef 1183 fhEtaLeading = new TH2F ("hEtaLeading","#eta distribution of leading",nptbins,ptmin,ptmax, netabins,etamin,etamax);
1184 fhEtaLeading->SetYTitle("#eta ");
e09cf5ef 1185 outputContainer->Add(fhEtaLeading);
1186
858212dd 1187 fhPtLeadingCentrality = new TH2F("hPtLeadingCentrality","Leading particle #it{p}_{T} vs centrality",nptbins,ptmin,ptmax,100,0.,100) ;
1188 fhPtLeadingCentrality->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
68cd2624 1189 fhPtLeadingCentrality->SetYTitle("Centrality (%)");
1190 outputContainer->Add(fhPtLeadingCentrality) ;
1191
858212dd 1192 fhPtLeadingEventPlane = new TH2F("hPtLeadingEventPlane","Leading particle #it{p}_{T} vs event plane angle",nptbins,ptmin,ptmax, 100,0.,TMath::Pi()) ;
1193 fhPtLeadingEventPlane->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
68cd2624 1194 fhPtLeadingEventPlane->SetXTitle("EP angle (rad)");
1195 outputContainer->Add(fhPtLeadingEventPlane) ;
1196
1197 fhLeadingEventPlaneCentrality = new TH2F("hLeadingEventPlane","Leading particle centrality vs event plane angle",100,0.,100,100,0.,TMath::Pi()) ;
1198 fhLeadingEventPlaneCentrality->SetXTitle("Centrality (%)");
1199 fhLeadingEventPlaneCentrality->SetYTitle("EP angle (rad)");
1200 outputContainer->Add(fhLeadingEventPlaneCentrality) ;
1201
e09cf5ef 1202 //Correlation with charged hadrons
547c2f01 1203 if(GetReader()->IsCTSSwitchedOn())
1204 {
e09cf5ef 1205 fhDeltaPhiDeltaEtaCharged = new TH2F
62f2fe4d 1206 ("hDeltaPhiDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}}",
1207 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
2bb7ac98 1208 fhDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
e09cf5ef 1209 fhDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
1210
b1f720a7 1211 fhDeltaPhiDeltaEtaChargedPtA3GeV = new TH2F
858212dd 1212 ("hDeltaPhiDeltaEtaChargedPtA3GeV","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}, #it{p}_{TA}>3 GeV/#it{c}}",
b1f720a7 1213 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
2bb7ac98 1214 fhDeltaPhiDeltaEtaChargedPtA3GeV->SetXTitle("#Delta #phi (rad)");
b1f720a7 1215 fhDeltaPhiDeltaEtaChargedPtA3GeV->SetYTitle("#Delta #eta");
1216
e09cf5ef 1217 fhPhiCharged = new TH2F
858212dd 1218 ("hPhiCharged","#phi_{h^{#pm}} vs #it{p}_{T #pm}",
e09cf5ef 1219 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
1220 fhPhiCharged->SetYTitle("#phi_{h^{#pm}} (rad)");
858212dd 1221 fhPhiCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
e09cf5ef 1222
1223 fhEtaCharged = new TH2F
858212dd 1224 ("hEtaCharged","#eta_{h^{#pm}} vs #it{p}_{T #pm}",
e09cf5ef 1225 nptbins,ptmin,ptmax,netabins,etamin,etamax);
1226 fhEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)");
858212dd 1227 fhEtaCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
e09cf5ef 1228
1229 fhDeltaPhiCharged = new TH2F
858212dd 1230 ("hDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}",
62f2fe4d 1231 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1232 fhDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
858212dd 1233 fhDeltaPhiCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1234
b1f720a7 1235 fhDeltaPhiChargedPtA3GeV = new TH2F
858212dd 1236 ("hDeltaPhiChargedPtA3GeV","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}",
b1f720a7 1237 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1238 fhDeltaPhiChargedPtA3GeV->SetYTitle("#Delta #phi (rad)");
858212dd 1239 fhDeltaPhiChargedPtA3GeV->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
b1f720a7 1240
1241
e09cf5ef 1242 fhDeltaPhiChargedPt = new TH2F
858212dd 1243 ("hDeltaPhiChargedPt","#phi_{trigger} - #phi_{#h^{#pm}} vs #it{p}_{T h^{#pm}}",
62f2fe4d 1244 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1245 fhDeltaPhiChargedPt->SetYTitle("#Delta #phi (rad)");
858212dd 1246 fhDeltaPhiChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
e09cf5ef 1247
1248 fhDeltaPhiUeChargedPt = new TH2F
858212dd 1249 ("hDeltaPhiUeChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}}",
62f2fe4d 1250 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1251 fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi (rad)");
858212dd 1252 fhDeltaPhiUeChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
e09cf5ef 1253
9623bf34 1254 fhUePart = new TH1F("hUePart","UE particles distribution vs pt trig",
1255 nptbins,ptmin,ptmax);
1256 fhUePart->SetYTitle("dNch");
858212dd 1257 fhUePart->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
9623bf34 1258
1259
e09cf5ef 1260 fhDeltaEtaCharged = new TH2F
858212dd 1261 ("hDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}",
62f2fe4d 1262 nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
e09cf5ef 1263 fhDeltaEtaCharged->SetYTitle("#Delta #eta");
858212dd 1264 fhDeltaEtaCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1265
b1f720a7 1266 fhDeltaEtaChargedPtA3GeV = new TH2F
858212dd 1267 ("hDeltaEtaChargedPtA3GeV","#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}",
b1f720a7 1268 nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
1269 fhDeltaEtaChargedPtA3GeV->SetYTitle("#Delta #eta");
858212dd 1270 fhDeltaEtaChargedPtA3GeV->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
b1f720a7 1271
3f150b4b 1272 fhXECharged =
858212dd 1273 new TH2F("hXECharged","#it{x}_{#it{E}} for charged tracks",
e09cf5ef 1274 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1275 fhXECharged->SetYTitle("#it{x}_{#it{E}}");
1276 fhXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
727a309a 1277
1278 fhXECharged_Cone2 =
858212dd 1279 new TH2F("hXECharged_Cone2","#it{x}_{#it{E}} for charged tracks in cone 2 (5#pi/6-7#pi/6)",
727a309a 1280 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1281 fhXECharged_Cone2->SetYTitle("#it{x}_{#it{E}}");
1282 fhXECharged_Cone2->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1283
3f150b4b 1284 fhXEUeCharged =
858212dd 1285 new TH2F("hXEUeCharged","#it{x}_{#it{E}} for Underlying Event",
e09cf5ef 1286 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1287 fhXEUeCharged->SetYTitle("#it{x}_{#it{E}}");
1288 fhXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1289
3f150b4b 1290 fhXEPosCharged =
858212dd 1291 new TH2F("hXEPositiveCharged","#it{x}_{#it{E}} for positive charged tracks",
e09cf5ef 1292 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1293 fhXEPosCharged->SetYTitle("#it{x}_{#it{E}}");
1294 fhXEPosCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1295
3f150b4b 1296 fhXENegCharged =
858212dd 1297 new TH2F("hXENegativeCharged","#it{x}_{#it{E}} for negative charged tracks",
e09cf5ef 1298 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1299 fhXENegCharged->SetYTitle("#it{x}_{#it{E}}");
1300 fhXENegCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1301
3f150b4b 1302 fhPtHbpXECharged =
858212dd 1303 new TH2F("hHbpXECharged","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons",
e09cf5ef 1304 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 1305 fhPtHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
1306 fhPtHbpXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
727a309a 1307
1308 fhPtHbpXECharged_Cone2 =
858212dd 1309 new TH2F("hHbpXECharged_Cone2","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons in cone 2 (5#pi/6-7#pi/6)",
727a309a 1310 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 1311 fhPtHbpXECharged_Cone2->SetYTitle("ln(1/#it{x}_{#it{E}})");
1312 fhPtHbpXECharged_Cone2->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1313
3f150b4b 1314 fhPtHbpXEUeCharged =
858212dd 1315 new TH2F("hHbpXEUeCharged","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons,Underlying Event",
e09cf5ef 1316 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 1317 fhPtHbpXEUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
1318 fhPtHbpXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1319
1320 fhZTCharged =
858212dd 1321 new TH2F("hZTCharged","#it{z}_{T} for charged tracks",
3f150b4b 1322 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1323 fhZTCharged->SetYTitle("#it{z}_{T}");
1324 fhZTCharged->SetXTitle("#it{p}_{T trigger}");
3f150b4b 1325
1326 fhZTUeCharged =
858212dd 1327 new TH2F("hZTUeCharged","#it{z}_{T} for Underlying Event",
3f150b4b 1328 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1329 fhZTUeCharged->SetYTitle("#it{z}_{T}");
1330 fhZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1331
1332 fhZTPosCharged =
858212dd 1333 new TH2F("hZTPositiveCharged","#it{z}_{T} for positive charged tracks",
3f150b4b 1334 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1335 fhZTPosCharged->SetYTitle("#it{z}_{T}");
1336 fhZTPosCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1337
1338 fhZTNegCharged =
858212dd 1339 new TH2F("hZTNegativeCharged","#it{z}_{T} for negative charged tracks",
3f150b4b 1340 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1341 fhZTNegCharged->SetYTitle("#it{z}_{T}");
1342 fhZTNegCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1343
1344 fhPtHbpZTCharged =
858212dd 1345 new TH2F("hHbpZTCharged","#xi = ln(1/#it{z}_{T}) with charged hadrons",
3f150b4b 1346 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 1347 fhPtHbpZTCharged->SetYTitle("ln(1/#it{z}_{T})");
1348 fhPtHbpZTCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1349
1350 fhPtHbpZTUeCharged =
858212dd 1351 new TH2F("hHbpZTUeCharged","#xi = ln(1/#it{z}_{T}) with charged hadrons,Underlying Event",
3f150b4b 1352 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 1353 fhPtHbpZTUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
1354 fhPtHbpZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1355
1356 fhPtTrigPout =
babcbc9d 1357 new TH2F("hPtTrigPout","Pout with triggers",
e09cf5ef 1358 nptbins,ptmin,ptmax,2*nptbins,-ptmax,ptmax);
858212dd 1359 fhPtTrigPout->SetYTitle("#it{p}_{out} (GeV/#it{c})");
1360 fhPtTrigPout->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1361
e09cf5ef 1362 fhPtTrigCharged =
b1f720a7 1363 new TH2F("hPtTrigCharged","trigger and charged tracks pt distribution",
e09cf5ef 1364 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
858212dd 1365 fhPtTrigCharged->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1366 fhPtTrigCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1367
1368 outputContainer->Add(fhDeltaPhiDeltaEtaCharged);
b1f720a7 1369 outputContainer->Add(fhDeltaPhiDeltaEtaChargedPtA3GeV);
e09cf5ef 1370 outputContainer->Add(fhPhiCharged) ;
1371 outputContainer->Add(fhEtaCharged) ;
1372 outputContainer->Add(fhDeltaPhiCharged) ;
b1f720a7 1373 outputContainer->Add(fhDeltaPhiChargedPtA3GeV) ;
e09cf5ef 1374 outputContainer->Add(fhDeltaEtaCharged) ;
b1f720a7 1375 outputContainer->Add(fhDeltaEtaChargedPtA3GeV) ;
e09cf5ef 1376 outputContainer->Add(fhDeltaPhiChargedPt) ;
1377 outputContainer->Add(fhDeltaPhiUeChargedPt) ;
9623bf34 1378 outputContainer->Add(fhUePart);
050ad675 1379
3f150b4b 1380 outputContainer->Add(fhXECharged) ;
727a309a 1381 outputContainer->Add(fhXECharged_Cone2) ;
764ab1f4 1382 if(IsDataMC())
1383 {
b1f720a7 1384 for(Int_t i=0; i < 7; i++)
764ab1f4 1385 {
b1f720a7 1386
1387 fhDeltaPhiChargedMC[i] = new TH2F(Form("hDeltaPhiCharged_MC%s",nameMC[i].Data()),
1388 Form("#Delta #phi for charged tracks, trigger origin is %s",nameMC[i].Data()),
1389 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 1390 fhDeltaPhiChargedMC[i]->SetYTitle("#it{x}_{#it{E}}");
1391 fhDeltaPhiChargedMC[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
b1f720a7 1392 outputContainer->Add(fhDeltaPhiChargedMC[i]) ;
1393
764ab1f4 1394 fhXEChargedMC[i] = new TH2F(Form("hXECharged_MC%s",nameMC[i].Data()),
858212dd 1395 Form("#it{x}_{#it{E}} for charged tracks, trigger origin is %s",nameMC[i].Data()),
764ab1f4 1396 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1397 fhXEChargedMC[i]->SetYTitle("#it{x}_{#it{E}}");
1398 fhXEChargedMC[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
764ab1f4 1399 outputContainer->Add(fhXEChargedMC[i]) ;
1400 }
1401 }
1402
3f150b4b 1403 outputContainer->Add(fhXEPosCharged) ;
1404 outputContainer->Add(fhXENegCharged) ;
1405 outputContainer->Add(fhXEUeCharged) ;
1406 outputContainer->Add(fhPtHbpXECharged) ;
727a309a 1407 outputContainer->Add(fhPtHbpXECharged_Cone2) ;
3f150b4b 1408 outputContainer->Add(fhPtHbpXEUeCharged) ;
050ad675 1409
3f150b4b 1410 outputContainer->Add(fhZTCharged) ;
1411 outputContainer->Add(fhZTPosCharged) ;
1412 outputContainer->Add(fhZTNegCharged) ;
1413 outputContainer->Add(fhZTUeCharged) ;
1414 outputContainer->Add(fhPtHbpZTCharged) ;
1415 outputContainer->Add(fhPtHbpZTUeCharged) ;
1416
e09cf5ef 1417 outputContainer->Add(fhPtTrigPout) ;
e09cf5ef 1418 outputContainer->Add(fhPtTrigCharged) ;
1419
b1f720a7 1420 if(fFillPileUpHistograms)
1421 {
560498d1 1422 fhDeltaPhiChargedOtherBC = new TH2F
858212dd 1423 ("hDeltaPhiChargedOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC!=0",
560498d1 1424 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1425 fhDeltaPhiChargedOtherBC->SetYTitle("#Delta #phi (rad)");
858212dd 1426 fhDeltaPhiChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
560498d1 1427
1428 fhDeltaPhiChargedPtA3GeVOtherBC = new TH2F
858212dd 1429 ("hDeltaPhiChargedPtA3GeVOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC!=0",
560498d1 1430 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1431 fhDeltaPhiChargedPtA3GeVOtherBC->SetYTitle("#Delta #phi (rad)");
858212dd 1432 fhDeltaPhiChargedPtA3GeVOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
560498d1 1433
1434 fhPtTrigChargedOtherBC =
1435 new TH2F("hPtTrigChargedOtherBC","trigger and charged tracks pt distribution, track BC!=0",
1436 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
858212dd 1437 fhPtTrigChargedOtherBC->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1438 fhPtTrigChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
560498d1 1439
1440 fhXEChargedOtherBC =
858212dd 1441 new TH2F("hXEChargedOtherBC","#it{x}_{#it{E}} for charged tracks, track BC!=0",
560498d1 1442 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1443 fhXEChargedOtherBC->SetYTitle("#it{x}_{#it{E}}");
1444 fhXEChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
560498d1 1445
1446 fhXEUeChargedOtherBC =
858212dd 1447 new TH2F("hXEUeChargedOtherBC","#it{x}_{#it{E}} for Underlying Event, track BC!=0",
560498d1 1448 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1449 fhXEUeChargedOtherBC->SetYTitle("#it{x}_{#it{E}}");
1450 fhXEUeChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
560498d1 1451
1452 fhZTChargedOtherBC =
858212dd 1453 new TH2F("hZTChargedOtherBC","#it{z}_{T} for charged tracks, track BC!=0",
560498d1 1454 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1455 fhZTChargedOtherBC->SetYTitle("#it{z}_{T}");
1456 fhZTChargedOtherBC->SetXTitle("#it{p}_{T trigger}");
560498d1 1457
1458 fhZTUeChargedOtherBC =
858212dd 1459 new TH2F("hZTUeChargedOtherBC","#it{z}_{T} for Underlying Event, track BC!=0",
560498d1 1460 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1461 fhZTUeChargedOtherBC->SetYTitle("#it{z}_{T}");
1462 fhZTUeChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
560498d1 1463
1464 outputContainer->Add(fhDeltaPhiChargedOtherBC) ;
1465 outputContainer->Add(fhDeltaPhiChargedPtA3GeVOtherBC) ;
1466 outputContainer->Add(fhXEChargedOtherBC) ;
1467 outputContainer->Add(fhXEUeChargedOtherBC) ;
1468 outputContainer->Add(fhZTChargedOtherBC) ;
1469 outputContainer->Add(fhZTUeChargedOtherBC) ;
1470 outputContainer->Add(fhPtTrigChargedOtherBC) ;
1471
2a9171b5 1472 fhDeltaPhiChargedBC0 = new TH2F
858212dd 1473 ("hDeltaPhiChargedBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC==0",
2a9171b5 1474 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1475 fhDeltaPhiChargedBC0->SetYTitle("#Delta #phi (rad)");
858212dd 1476 fhDeltaPhiChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2a9171b5 1477
1478 fhDeltaPhiChargedPtA3GeVBC0 = new TH2F
858212dd 1479 ("hDeltaPhiChargedPtA3GeVBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC==0",
2a9171b5 1480 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1481 fhDeltaPhiChargedPtA3GeVBC0->SetYTitle("#Delta #phi (rad)");
858212dd 1482 fhDeltaPhiChargedPtA3GeVBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2a9171b5 1483
1484 fhPtTrigChargedBC0 =
1485 new TH2F("hPtTrigChargedBC0","trigger and charged tracks pt distribution, track BC==0",
1486 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
858212dd 1487 fhPtTrigChargedBC0->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1488 fhPtTrigChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2a9171b5 1489
1490 fhXEChargedBC0 =
858212dd 1491 new TH2F("hXEChargedBC0","#it{x}_{#it{E}} for charged tracks, track BC==0",
2a9171b5 1492 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1493 fhXEChargedBC0->SetYTitle("#it{x}_{#it{E}}");
1494 fhXEChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2a9171b5 1495
1496 fhXEUeChargedBC0 =
858212dd 1497 new TH2F("hXEUeChargedBC0","#it{x}_{#it{E}} for Underlying Event, track BC==0",
2a9171b5 1498 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1499 fhXEUeChargedBC0->SetYTitle("#it{x}_{#it{E}}");
1500 fhXEUeChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2a9171b5 1501
1502 fhZTChargedBC0 =
858212dd 1503 new TH2F("hZTChargedBC0","#it{z}_{T} for charged tracks, track BC==0",
2a9171b5 1504 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1505 fhZTChargedBC0->SetYTitle("#it{z}_{T}");
1506 fhZTChargedBC0->SetXTitle("#it{p}_{T trigger}");
2a9171b5 1507
1508 fhZTUeChargedBC0 =
858212dd 1509 new TH2F("hZTUeChargedBC0","#it{z}_{T} for Underlying Event, track BC==0",
2a9171b5 1510 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1511 fhZTUeChargedBC0->SetYTitle("#it{z}_{T}");
1512 fhZTUeChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2a9171b5 1513
1514 outputContainer->Add(fhDeltaPhiChargedBC0) ;
1515 outputContainer->Add(fhDeltaPhiChargedPtA3GeVBC0) ;
1516 outputContainer->Add(fhXEChargedBC0) ;
1517 outputContainer->Add(fhXEUeChargedBC0) ;
1518 outputContainer->Add(fhZTChargedBC0) ;
1519 outputContainer->Add(fhZTUeChargedBC0) ;
1520 outputContainer->Add(fhPtTrigChargedBC0) ;
1521
858212dd 1522 fhPtLeadingVtxBC0 = new TH1F("hPtLeadingVtxBC0","#it{p}_{T} distribution of leading particles", nptbins,ptmin,ptmax);
1523 fhPtLeadingVtxBC0->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
cc944149 1524
1525 fhDeltaPhiChargedVtxBC0 = new TH2F
858212dd 1526 ("hDeltaPhiChargedVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC==0",
cc944149 1527 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1528 fhDeltaPhiChargedVtxBC0->SetYTitle("#Delta #phi (rad)");
858212dd 1529 fhDeltaPhiChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
cc944149 1530
1531 fhDeltaPhiChargedPtA3GeVVtxBC0 = new TH2F
858212dd 1532 ("hDeltaPhiChargedPtA3GeVVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC==0",
cc944149 1533 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1534 fhDeltaPhiChargedPtA3GeVVtxBC0->SetYTitle("#Delta #phi (rad)");
858212dd 1535 fhDeltaPhiChargedPtA3GeVVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
cc944149 1536
1537 fhPtTrigChargedVtxBC0 =
1538 new TH2F("hPtTrigChargedVtxBC0","trigger and charged tracks pt distribution, track BC==0",
1539 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
858212dd 1540 fhPtTrigChargedVtxBC0->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1541 fhPtTrigChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
cc944149 1542
1543 fhXEChargedVtxBC0 =
858212dd 1544 new TH2F("hXEChargedVtxBC0","#it{x}_{#it{E}} for charged tracks, track BC==0",
cc944149 1545 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1546 fhXEChargedVtxBC0->SetYTitle("#it{x}_{#it{E}}");
1547 fhXEChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
cc944149 1548
1549 fhXEUeChargedVtxBC0 =
858212dd 1550 new TH2F("hXEUeChargedVtxBC0","#it{x}_{#it{E}} for Underlying Event, track BC==0",
cc944149 1551 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1552 fhXEUeChargedVtxBC0->SetYTitle("#it{x}_{#it{E}}");
1553 fhXEUeChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
cc944149 1554
1555 fhZTChargedVtxBC0 =
858212dd 1556 new TH2F("hZTChargedVtxBC0","#it{z}_{T} for charged tracks, track BC==0",
cc944149 1557 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1558 fhZTChargedVtxBC0->SetYTitle("#it{z}_{T}");
1559 fhZTChargedVtxBC0->SetXTitle("#it{p}_{T trigger}");
cc944149 1560
1561 fhZTUeChargedVtxBC0 =
858212dd 1562 new TH2F("hZTUeChargedVtxBC0","#it{z}_{T} for Underlying Event, track BC==0",
cc944149 1563 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1564 fhZTUeChargedVtxBC0->SetYTitle("#it{z}_{T}");
1565 fhZTUeChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
cc944149 1566
1567 outputContainer->Add(fhPtLeadingVtxBC0);
1568 outputContainer->Add(fhDeltaPhiChargedVtxBC0) ;
1569 outputContainer->Add(fhDeltaPhiChargedPtA3GeVVtxBC0) ;
1570 outputContainer->Add(fhXEChargedVtxBC0) ;
1571 outputContainer->Add(fhXEUeChargedVtxBC0) ;
1572 outputContainer->Add(fhZTChargedVtxBC0) ;
1573 outputContainer->Add(fhZTUeChargedVtxBC0) ;
1574 outputContainer->Add(fhPtTrigChargedVtxBC0) ;
2a9171b5 1575
17af6e24 1576 for(Int_t i = 0 ; i < 7 ; i++)
1577 {
1578 fhPtLeadingPileUp[i] = new TH1F(Form("hPtLeadingPileUp%s",pileUpName[i].Data()),
858212dd 1579 Form("#it{p}_{T} distribution of leading particles, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
1580 fhPtLeadingPileUp[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
17af6e24 1581 outputContainer->Add(fhPtLeadingPileUp[i]);
1582
1583 fhDeltaPhiChargedPileUp[i] = new TH2F(Form("hDeltaPhiChargedPileUp%s",pileUpName[i].Data()),
858212dd 1584 Form("#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, %s Pile-Up event",pileUpName[i].Data()),
17af6e24 1585 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1586 fhDeltaPhiChargedPileUp[i]->SetYTitle("#Delta #phi (rad)");
858212dd 1587 fhDeltaPhiChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
17af6e24 1588 outputContainer->Add(fhDeltaPhiChargedPileUp[i]) ;
1589
1590 fhDeltaPhiChargedPtA3GeVPileUp[i] = new TH2F(Form("hDeltaPhiChargedPtA3GeVPileUp%s",pileUpName[i].Data()),
858212dd 1591 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()),
17af6e24 1592 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1593 fhDeltaPhiChargedPtA3GeVPileUp[i]->SetYTitle("#Delta #phi (rad)");
858212dd 1594 fhDeltaPhiChargedPtA3GeVPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
17af6e24 1595 outputContainer->Add(fhDeltaPhiChargedPtA3GeVPileUp[i]) ;
1596
1597 fhDeltaEtaChargedPileUp[i] = new TH2F(Form("hDeltaEtaChargedPileUp%s",pileUpName[i].Data()),
858212dd 1598 Form("#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}, %s Pile-Up event",pileUpName[i].Data()),
17af6e24 1599 nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
1600 fhDeltaEtaChargedPileUp[i]->SetYTitle("#Delta #eta");
858212dd 1601 fhDeltaEtaChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
17af6e24 1602 outputContainer->Add(fhDeltaEtaChargedPileUp[i]) ;
1603
1604 fhDeltaEtaChargedPtA3GeVPileUp[i] = new TH2F(Form("hDeltaEtaChargedPtA3GeVPileUp%s",pileUpName[i].Data()),
858212dd 1605 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()),
17af6e24 1606 nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
1607 fhDeltaEtaChargedPtA3GeVPileUp[i]->SetYTitle("#Delta #eta");
858212dd 1608 fhDeltaEtaChargedPtA3GeVPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
17af6e24 1609 outputContainer->Add(fhDeltaEtaChargedPtA3GeVPileUp[i]) ;
1610
1611 fhXEChargedPileUp[i] = new TH2F(Form("hXEChargedPileUp%s",pileUpName[i].Data()),
858212dd 1612 Form("#it{x}_{#it{E}} for charged tracks, %s Pile-Up event",pileUpName[i].Data()),
17af6e24 1613 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1614 fhXEChargedPileUp[i]->SetYTitle("#it{x}_{#it{E}}");
1615 fhXEChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
17af6e24 1616 outputContainer->Add(fhXEChargedPileUp[i]) ;
1617
1618 fhXEUeChargedPileUp[i] = new TH2F(Form("hXEUeChargedPileUp%s",pileUpName[i].Data()),
858212dd 1619 Form("#it{x}_{#it{E}} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()),
17af6e24 1620 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1621 fhXEUeChargedPileUp[i]->SetYTitle("#it{x}_{#it{E}}");
1622 fhXEUeChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
17af6e24 1623 outputContainer->Add(fhXEUeChargedPileUp[i]) ;
1624
1625 fhZTChargedPileUp[i] = new TH2F(Form("hZTChargedPileUp%s",pileUpName[i].Data()),
858212dd 1626 Form("#it{z}_{T} for charged tracks, %s Pile-Up event",pileUpName[i].Data()),
17af6e24 1627 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1628 fhZTChargedPileUp[i]->SetYTitle("#it{z}_{T}");
1629 fhZTChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
17af6e24 1630 outputContainer->Add(fhZTChargedPileUp[i]) ;
1631
1632 fhZTUeChargedPileUp[i] = new TH2F(Form("hZTUeChargedPileUp%s",pileUpName[i].Data()),
858212dd 1633 Form("#it{z}_{T} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()),
17af6e24 1634 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1635 fhZTUeChargedPileUp[i]->SetYTitle("#it{z}_{T}");
1636 fhZTUeChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
17af6e24 1637 outputContainer->Add(fhZTUeChargedPileUp[i]) ;
1638
1639 fhPtTrigChargedPileUp[i] = new TH2F(Form("hPtTrigChargedPileUp%s",pileUpName[i].Data()),
1640 Form("trigger and charged tracks pt distribution, %s Pile-Up event",pileUpName[i].Data()),
1641 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
858212dd 1642 fhPtTrigChargedPileUp[i]->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
1643 fhPtTrigChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
17af6e24 1644 outputContainer->Add(fhPtTrigChargedPileUp[i]) ;
2bb7ac98 1645
17af6e24 1646 }
b1f720a7 1647 }
1648
547c2f01 1649 if(DoEventSelect())
1650 {
e09cf5ef 1651 Int_t nMultiBins = GetMultiBin();
1652 fhTrigDeltaPhiCharged = new TH2F*[nMultiBins] ;
1653 fhTrigDeltaEtaCharged = new TH2F*[nMultiBins] ;
3f150b4b 1654 fhTrigXECorr = new TH2F*[nMultiBins] ;
1655 fhTrigXEUeCorr = new TH2F*[nMultiBins] ;
1656 fhTrigZTCorr = new TH2F*[nMultiBins] ;
1657 fhTrigZTUeCorr = new TH2F*[nMultiBins] ;
1658
1659 for(Int_t im=0; im<nMultiBins; im++)
1660 {
e09cf5ef 1661 fhTrigDeltaPhiCharged[im] = new TH2F
62f2fe4d 1662 (Form("hTrigDeltaPhiCharged_%d",im),Form("hTrigDeltaPhiCharged_%d",im), nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 1663 fhTrigDeltaPhiCharged[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2bb7ac98 1664 fhTrigDeltaPhiCharged[im]->SetYTitle("#Delta #phi (rad)");
3f150b4b 1665
e09cf5ef 1666 fhTrigDeltaEtaCharged[im] = new TH2F
62f2fe4d 1667 (Form("hTrigDeltaEtaCharged_%d",im),Form("hTrigDeltaEtaCharged_%d",im), nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax);
858212dd 1668 fhTrigDeltaEtaCharged[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 1669 fhTrigDeltaEtaCharged[im]->SetYTitle("#Delta #eta");
3f150b4b 1670
1671 fhTrigXECorr[im] = new TH2F
1672 (Form("hTrigXEPtCorr_%d",im),Form("hTrigXEPtCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1673 fhTrigXECorr[im]->SetYTitle("#it{x}_{#it{E} trigger h^{#pm}}");
1674 fhTrigXECorr[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1675
1676 fhTrigXEUeCorr[im] = new TH2F
1677 (Form("hTrigXEPtUeCorr_%d",im),Form("hTrigXEPtUeCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1678 fhTrigXEUeCorr[im]->SetYTitle("#it{x}_{#it{E} trigger h^{#pm}}");
1679 fhTrigXEUeCorr[im]->SetXTitle("#it{p}_{T trigger}(GeV/#it{c})");
3f150b4b 1680
1681 fhTrigZTCorr[im] = new TH2F
1682 (Form("hTrigZTPtCorr_%d",im),Form("hTrigZTPtCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1683 fhTrigZTCorr[im]->SetYTitle("#it{z}_{trigger h^{#pm}}");
1684 fhTrigZTCorr[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1685
1686 fhTrigZTUeCorr[im] = new TH2F
1687 (Form("hTrigZTPtUeCorr_%d",im),Form("hTrigZTPtUeCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1688 fhTrigZTUeCorr[im]->SetYTitle("#it{z}_{trigger h^{#pm}}");
1689 fhTrigZTUeCorr[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
045396c8 1690
e09cf5ef 1691 outputContainer->Add(fhTrigDeltaPhiCharged[im]) ;
1692 outputContainer->Add(fhTrigDeltaEtaCharged[im]) ;
3f150b4b 1693 outputContainer->Add(fhTrigXECorr[im]);
1694 outputContainer->Add(fhTrigXEUeCorr[im]);
1695 outputContainer->Add(fhTrigZTCorr[im]);
1696 outputContainer->Add(fhTrigZTUeCorr[im]);
045396c8 1697 }
1698 }
1699
907b38cd 1700 if(fFillBradHisto)
1701 {
858212dd 1702 fhAssocPtBkg = new TH2F("hAssocPtBkg", " Trigger #it{p}_{T} vs associated hadron #it{p}_{T} from background",
907b38cd 1703 nptbins, ptmin, ptmax,nptbins,ptmin,ptmax);
858212dd 1704 fhAssocPtBkg->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1705 fhAssocPtBkg->SetYTitle("#it{p}_{T associated} (GeV/#it{c})");
907b38cd 1706 outputContainer->Add(fhAssocPtBkg) ;
1707
858212dd 1708 fhDeltaPhiBrad = new TH2F("hDeltaPhiBrad","atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs #it{p}_{T trigger} ",
907b38cd 1709 nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0);
858212dd 1710 fhDeltaPhiBrad->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
907b38cd 1711 fhDeltaPhiBrad->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi");
1712 outputContainer->Add(fhDeltaPhiBrad) ;
1713 }
7d306daf 1714
1715 fhDeltaPhiDeltaEtaAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1716 fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1717 fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz];
1718 fhDeltaPhiAssocPtBinDEta0 = new TH2F*[fNAssocPtBins*nz];
1719 fhXEAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1720 fhZTAssocPtBin = new TH2F*[fNAssocPtBins*nz];
3f150b4b 1721
907b38cd 1722 if(fFillBradHisto)
7d306daf 1723 fhDeltaPhiBradAssocPtBin = new TH2F*[fNAssocPtBins*nz];
907b38cd 1724
1725 if(fPi0Trigger || fDecayTrigger)
1726 {
7d306daf 1727 fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1728 fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz];
1729 fhXEAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1730 fhZTAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1731 fhXEDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1732 fhZTDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1733 fhDeltaPhiDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
907b38cd 1734 }
050ad675 1735
907b38cd 1736 if(fHMPIDCorrelation)
1737 {
7d306daf 1738 fhDeltaPhiAssocPtBinHMPID = new TH2F*[fNAssocPtBins*nz];
1739 fhDeltaPhiAssocPtBinHMPIDAcc= new TH2F*[fNAssocPtBins*nz];
907b38cd 1740 }
1741
babcbc9d 1742 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
1743 {
7d306daf 1744 for(Int_t z = 0 ; z < nz ; z++)
907b38cd 1745 {
7d306daf 1746 Int_t bin = i*nz+z;
1747
1748 if(fCorrelVzBin)
1749 {
d71a7d1f 1750 sz = Form("_vz%d",z);
858212dd 1751 tz = Form(", #it{v}_{#it{z}} bin %d",z);
7d306daf 1752 }
1753
1754 //printf("iAssoc %d, Vz %d, bin %d - sz %s, tz %s \n",i,z,bin,sz.Data(),tz.Data());
8cc41381 1755
7d306daf 1756 fhDeltaPhiDeltaEtaAssocPtBin[bin] = new TH2F(Form("hDeltaPhiDeltaEtaPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1757 Form("#Delta #phi vs #Delta #eta for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1758 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
2bb7ac98 1759 fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)");
8cc41381 1760 fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetYTitle("#Delta #eta");
1761
7d306daf 1762 fhDeltaPhiAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1763 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()),
62f2fe4d 1764 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 1765 fhDeltaPhiAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2bb7ac98 1766 fhDeltaPhiAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
907b38cd 1767
7d306daf 1768 fhDeltaPhiAssocPtBinDEta08[bin] = new TH2F(Form("hDeltaPhiDeltaEta0.8PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1769 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()),
8cc41381 1770 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 1771 fhDeltaPhiAssocPtBinDEta08[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2bb7ac98 1772 fhDeltaPhiAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 1773
7d306daf 1774 fhDeltaPhiAssocPtBinDEta0[bin] = new TH2F(Form("hDeltaPhiDeltaEta0PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
858212dd 1775 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()),
8cc41381 1776 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 1777 fhDeltaPhiAssocPtBinDEta0[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2bb7ac98 1778 fhDeltaPhiAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)");
907b38cd 1779
7d306daf 1780 fhXEAssocPtBin[bin] = new TH2F(Form("hXEAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1781 Form("#it{x}_{#it{E}} vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
907b38cd 1782 nptbins, ptmin, ptmax,200, 0.0, 2.0);
858212dd 1783 fhXEAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1784 fhXEAssocPtBin[bin]->SetYTitle("#it{x}_{#it{E}}");
907b38cd 1785
7d306daf 1786 fhZTAssocPtBin[bin] = new TH2F(Form("hZTAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1787 Form("#it{z}_{T} vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1788 nptbins, ptmin, ptmax,200, 0.0, 2.0);
858212dd 1789 fhZTAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1790 fhZTAssocPtBin[bin]->SetYTitle("#it{z}_{T}");
907b38cd 1791
8cc41381 1792 outputContainer->Add(fhDeltaPhiDeltaEtaAssocPtBin[bin]) ;
1793 outputContainer->Add(fhDeltaPhiAssocPtBin[bin]) ;
1794 outputContainer->Add(fhDeltaPhiAssocPtBinDEta08[bin]) ;
1795 outputContainer->Add(fhDeltaPhiAssocPtBinDEta0[bin]) ;
1796 outputContainer->Add(fhXEAssocPtBin[bin]);
1797 outputContainer->Add(fhZTAssocPtBin[bin]);
1798
1799 if(fPi0Trigger || fDecayTrigger)
1800 {
7d306daf 1801 fhDeltaPhiDecayChargedAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtDecayChargedAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1802 Form("#Delta #phi vs #it{p}_{T trigger} tagged as decay for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1803 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 1804 fhDeltaPhiDecayChargedAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2bb7ac98 1805 fhDeltaPhiDecayChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 1806
7d306daf 1807 fhXEDecayChargedAssocPtBin[bin] = new TH2F(Form("hXEDecayChargedAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1808 Form("#it{x}_{#it{E}} vs #it{p}_{T trigger} tagged as decay for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1809 nptbins, ptmin, ptmax,200, 0.0, 2.0);
858212dd 1810 fhXEDecayChargedAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1811 fhXEDecayChargedAssocPtBin[bin]->SetYTitle("#it{x}_{#it{E}}");
8cc41381 1812
7d306daf 1813 fhZTDecayChargedAssocPtBin[bin] = new TH2F(Form("hZTDecayChargedAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1814 Form("#it{z}_{T} vs #it{p}_{T trigger} tagged as decay for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1815 nptbins, ptmin, ptmax,200, 0.0, 2.0);
858212dd 1816 fhZTDecayChargedAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
1817 fhZTDecayChargedAssocPtBin[bin]->SetYTitle("#it{z}_{T}");
8cc41381 1818
1819 outputContainer->Add(fhDeltaPhiDecayChargedAssocPtBin[bin]) ;
1820 outputContainer->Add(fhXEDecayChargedAssocPtBin[bin]);
1821 outputContainer->Add(fhZTDecayChargedAssocPtBin[bin]);
1822
1823 }
907b38cd 1824
8cc41381 1825 if(fFillBradHisto)
1826 {
7d306daf 1827 fhDeltaPhiBradAssocPtBin[bin] = new TH2F(Form("hDeltaPhiBradPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1828 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()),
8cc41381 1829 nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0);
858212dd 1830 fhDeltaPhiBradAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
8cc41381 1831 fhDeltaPhiBradAssocPtBin[bin]->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi");
1832 outputContainer->Add(fhDeltaPhiBradAssocPtBin[bin]) ;
1833 }
907b38cd 1834
8cc41381 1835 if(fHMPIDCorrelation)
1836 {
7d306daf 1837 fhDeltaPhiAssocPtBinHMPID[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPID", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1838 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()),
8cc41381 1839 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 1840 fhDeltaPhiAssocPtBinHMPID[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})" );
2bb7ac98 1841 fhDeltaPhiAssocPtBinHMPID[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 1842
7d306daf 1843 fhDeltaPhiAssocPtBinHMPIDAcc[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPIDAcc", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 1844 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()),
8cc41381 1845 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 1846 fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2bb7ac98 1847 fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 1848
7d306daf 1849 outputContainer->Add(fhDeltaPhiAssocPtBinHMPID[bin]) ;
1850 outputContainer->Add(fhDeltaPhiAssocPtBinHMPIDAcc[bin]) ;
8cc41381 1851
1852 }
1853 }
e09cf5ef 1854 }
045396c8 1855
907b38cd 1856 if(fPi0Trigger || fDecayTrigger)
547c2f01 1857 {
907b38cd 1858 if(fPi0Trigger)
1859 {
1860 fhPtPi0DecayRatio = new TH2F
858212dd 1861 ("hPtPi0DecayRatio","#it{p}_{T} of #pi^{0} and the ratio of pt for two decay",
907b38cd 1862 nptbins,ptmin,ptmax, 100,0.,2.);
858212dd 1863 fhPtPi0DecayRatio->SetXTitle("#it{p}_{T}^{#pi^{0}} (GeV/#it{c})");
1864 fhPtPi0DecayRatio->SetYTitle("#it{p}_{T}^{Decay}/#it{p}_{T}^{#pi^{0}}");
050ad675 1865 outputContainer->Add(fhPtPi0DecayRatio) ;
907b38cd 1866 }
e09cf5ef 1867
1868 fhDeltaPhiDecayCharged = new TH2F
858212dd 1869 ("hDeltaPhiDecayCharged","#phi_{Decay} - #phi_{h^{#pm}} vs #it{p}_{T Decay}",
62f2fe4d 1870 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1871 fhDeltaPhiDecayCharged->SetYTitle("#Delta #phi (rad)");
858212dd 1872 fhDeltaPhiDecayCharged->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})");
e09cf5ef 1873
3f150b4b 1874 fhXEDecayCharged =
858212dd 1875 new TH2F("hXEDecayCharged","#it{x}_{#it{E}} Decay",
3f150b4b 1876 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1877 fhXEDecayCharged->SetYTitle("#it{x}_{#it{E}}");
1878 fhXEDecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
3f150b4b 1879
1880 fhZTDecayCharged =
858212dd 1881 new TH2F("hZTDecayCharged","#it{z}_{trigger h^{#pm}} = #it{p}_{T h^{#pm}} / #it{p}_{T Decay}",
e09cf5ef 1882 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1883 fhZTDecayCharged->SetYTitle("#it{z}_{decay h^{#pm}}");
1884 fhZTDecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
e09cf5ef 1885
e09cf5ef 1886 outputContainer->Add(fhDeltaPhiDecayCharged) ;
3f150b4b 1887 outputContainer->Add(fhXEDecayCharged) ;
1888 outputContainer->Add(fhZTDecayCharged) ;
e09cf5ef 1889 }
1890
547c2f01 1891 if(fMakeSeveralUE)
1892 {
e09cf5ef 1893 fhDeltaPhiUeLeftCharged = new TH2F
858212dd 1894 ("hDeltaPhiUeLeftChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left side range of trigger particles",
62f2fe4d 1895 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1896 fhDeltaPhiUeLeftCharged->SetYTitle("#Delta #phi (rad)");
858212dd 1897 fhDeltaPhiUeLeftCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
e09cf5ef 1898 outputContainer->Add(fhDeltaPhiUeLeftCharged) ;
1899
1900 fhDeltaPhiUeRightCharged = new TH2F
858212dd 1901 ("hDeltaPhiUeRightChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right side range of trigger particles",
62f2fe4d 1902 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1903 fhDeltaPhiUeRightCharged->SetYTitle("#Delta #phi (rad)");
858212dd 1904 fhDeltaPhiUeRightCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
e09cf5ef 1905 outputContainer->Add(fhDeltaPhiUeRightCharged) ;
1906
8cc41381 1907 fhDeltaPhiUeLeftUpCharged = new TH2F
858212dd 1908 ("hDeltaPhiUeLeftUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left Up side range of trigger particles",
8cc41381 1909 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1910 fhDeltaPhiUeLeftUpCharged->SetYTitle("#Delta #phi (rad)");
858212dd 1911 fhDeltaPhiUeLeftUpCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
8cc41381 1912 outputContainer->Add(fhDeltaPhiUeLeftUpCharged) ;
1913
1914 fhDeltaPhiUeRightUpCharged = new TH2F
858212dd 1915 ("hDeltaPhiUeRightUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right Up side range of trigger particles",
8cc41381 1916 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1917 fhDeltaPhiUeRightUpCharged->SetYTitle("#Delta #phi (rad)");
858212dd 1918 fhDeltaPhiUeRightUpCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
8cc41381 1919 outputContainer->Add(fhDeltaPhiUeRightUpCharged) ;
1920
1921 fhDeltaPhiUeLeftDownCharged = new TH2F
858212dd 1922 ("hDeltaPhiUeLeftDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left Down side range of trigger particles",
8cc41381 1923 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1924 fhDeltaPhiUeLeftDownCharged->SetYTitle("#Delta #phi (rad)");
858212dd 1925 fhDeltaPhiUeLeftDownCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
8cc41381 1926 outputContainer->Add(fhDeltaPhiUeLeftDownCharged) ;
1927
1928 fhDeltaPhiUeRightDownCharged = new TH2F
858212dd 1929 ("hDeltaPhiUeRightDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right Down side range of trigger particles",
8cc41381 1930 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1931 fhDeltaPhiUeRightDownCharged->SetYTitle("#Delta #phi (rad)");
858212dd 1932 fhDeltaPhiUeRightDownCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
8cc41381 1933 outputContainer->Add(fhDeltaPhiUeRightDownCharged) ;
1934
3f150b4b 1935 fhXEUeLeftCharged =
858212dd 1936 new TH2F("hXEUeChargedLeft","#it{x}_{#it{E}} with UE left side of trigger",
e09cf5ef 1937 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1938 fhXEUeLeftCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
1939 fhXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1940 outputContainer->Add(fhXEUeLeftCharged) ;
e09cf5ef 1941
3f150b4b 1942 fhXEUeRightCharged =
858212dd 1943 new TH2F("hXEUeChargedRight","#it{x}_{#it{E} h^{#pm}} with UE right side of trigger",
e09cf5ef 1944 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1945 fhXEUeRightCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
1946 fhXEUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1947 outputContainer->Add(fhXEUeRightCharged) ;
1948
8cc41381 1949 fhXEUeLeftUpCharged =
858212dd 1950 new TH2F("hXEUeChargedLeftUp","#it{x}_{#it{E}} with UE left Up side of trigger",
8cc41381 1951 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1952 fhXEUeLeftUpCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
1953 fhXEUeLeftUpCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
8cc41381 1954 outputContainer->Add(fhXEUeLeftUpCharged) ;
1955
1956 fhXEUeRightUpCharged =
858212dd 1957 new TH2F("hXEUeChargedRightUp","#it{x}_{#it{E} h^{#pm}} with UE right Up side of trigger",
8cc41381 1958 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1959 fhXEUeRightUpCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
1960 fhXEUeRightUpCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
8cc41381 1961 outputContainer->Add(fhXEUeRightUpCharged) ;
1962
1963 fhXEUeLeftDownCharged =
858212dd 1964 new TH2F("hXEUeChargedLeftDown","#it{x}_{#it{E}} with UE left Down side of trigger",
8cc41381 1965 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1966 fhXEUeLeftDownCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
1967 fhXEUeLeftDownCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
8cc41381 1968 outputContainer->Add(fhXEUeLeftDownCharged) ;
1969
1970 fhXEUeRightDownCharged =
858212dd 1971 new TH2F("hXEUeChargedRightDown","#it{x}_{#it{E} h^{#pm}} with UE right Down side of trigger",
8cc41381 1972 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1973 fhXEUeRightDownCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
1974 fhXEUeRightDownCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
8cc41381 1975 outputContainer->Add(fhXEUeRightDownCharged) ;
1976
3f150b4b 1977 fhPtHbpXEUeLeftCharged =
858212dd 1978 new TH2F("hHbpXEUeChargedLeft","#xi = ln(1/#it{x}_{#it{E}}) with charged UE left side of trigger",
3f150b4b 1979 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 1980 fhPtHbpXEUeLeftCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
1981 fhPtHbpXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1982 outputContainer->Add(fhPtHbpXEUeLeftCharged) ;
e09cf5ef 1983
3f150b4b 1984 fhPtHbpXEUeRightCharged =
858212dd 1985 new TH2F("hHbpXEUeChargedRight","#xi = ln(1/#it{x}_{#it{E}}) with charged UE right side of trigger",
e09cf5ef 1986 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 1987 fhPtHbpXEUeRightCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
1988 fhPtHbpXEUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1989 outputContainer->Add(fhPtHbpXEUeRightCharged) ;
1990
1991 fhZTUeLeftCharged =
858212dd 1992 new TH2F("hZTUeChargedLeft","#it{z}_{trigger h^{#pm}} = #it{p}_{T Ueh^{#pm}} / #it{p}_{T trigger} with UE left side of trigger",
3f150b4b 1993 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 1994 fhZTUeLeftCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
1995 fhZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 1996 outputContainer->Add(fhZTUeLeftCharged) ;
1997
1998 fhZTUeRightCharged =
858212dd 1999 new TH2F("hZTUeChargedRight","#it{z}_{trigger h^{#pm}} = #it{p}_{T Ueh^{#pm}} / #it{p}_{T trigger} with UE right side of trigger",
3f150b4b 2000 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2001 fhZTUeRightCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
2002 fhZTUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2003 outputContainer->Add(fhZTUeRightCharged) ;
e09cf5ef 2004
3f150b4b 2005 fhPtHbpZTUeLeftCharged =
858212dd 2006 new TH2F("hHbpZTUeChargedLeft","#xi = ln(1/#it{z}_{T}) with charged UE left side of trigger",
e09cf5ef 2007 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2008 fhPtHbpZTUeLeftCharged->SetYTitle("ln(1/#it{z}_{T})");
2009 fhPtHbpZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2010 outputContainer->Add(fhPtHbpZTUeLeftCharged) ;
2011
2012 fhPtHbpZTUeRightCharged =
858212dd 2013 new TH2F("hHbpZTUeChargedRight","#xi = ln(1/#it{z}_{T}) with charged UE right side of trigger",
3f150b4b 2014 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2015 fhPtHbpZTUeRightCharged->SetYTitle("ln(1/#it{z}_{T})");
2016 fhPtHbpZTUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2017 outputContainer->Add(fhPtHbpZTUeRightCharged) ;
e09cf5ef 2018
8cc41381 2019 }
e09cf5ef 2020 } //Correlation with charged hadrons
050ad675 2021
e09cf5ef 2022 //Correlation with neutral hadrons
547c2f01 2023 if(fNeutralCorr)
2024 {
e09cf5ef 2025 fhDeltaPhiDeltaEtaNeutral = new TH2F
babcbc9d 2026 ("hDeltaPhiDeltaEtaNeutral","#phi_{trigger} - #phi_{h^{0}} vs #eta_{trigger} - #eta_{h^{0}}",
62f2fe4d 2027 ndeltaphibins ,deltaphimin,deltaphimax, ndeltaetabins ,deltaetamin,deltaetamax);
2bb7ac98 2028 fhDeltaPhiDeltaEtaNeutral->SetXTitle("#Delta #phi (rad)");
e09cf5ef 2029 fhDeltaPhiDeltaEtaNeutral->SetYTitle("#Delta #eta");
2030
2031 fhPhiNeutral = new TH2F
858212dd 2032 ("hPhiNeutral","#phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}",
e09cf5ef 2033 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
2034 fhPhiNeutral->SetYTitle("#phi_{#pi^{0}} (rad)");
858212dd 2035 fhPhiNeutral->SetXTitle("#it{p}_{T #pi^{0}} (GeV/#it{c})");
e09cf5ef 2036
2037 fhEtaNeutral = new TH2F
858212dd 2038 ("hEtaNeutral","#eta_{#pi^{0}} vs #it{p}_{T #pi^{0}}",
e09cf5ef 2039 nptbins,ptmin,ptmax,netabins,etamin,etamax);
2040 fhEtaNeutral->SetYTitle("#eta_{#pi^{0}} (rad)");
858212dd 2041 fhEtaNeutral->SetXTitle("#it{p}_{T #pi^{0}} (GeV/#it{c})");
e09cf5ef 2042
2043 fhDeltaPhiNeutral = new TH2F
858212dd 2044 ("hDeltaPhiNeutral","#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T trigger}",
e09cf5ef 2045 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
2bb7ac98 2046 fhDeltaPhiNeutral->SetYTitle("#Delta #phi (rad)");
858212dd 2047 fhDeltaPhiNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 2048
2049 fhDeltaPhiNeutralPt = new TH2F
858212dd 2050 ("hDeltaPhiNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}}",
62f2fe4d 2051 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2052 fhDeltaPhiNeutralPt->SetYTitle("#Delta #phi (rad)");
858212dd 2053 fhDeltaPhiNeutralPt->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
e09cf5ef 2054
2055 fhDeltaPhiUeNeutralPt = new TH2F
858212dd 2056 ("hDeltaPhiUeNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}}",
62f2fe4d 2057 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2058 fhDeltaPhiUeNeutralPt->SetYTitle("#Delta #phi (rad)");
858212dd 2059 fhDeltaPhiUeNeutralPt->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
e09cf5ef 2060
2061 fhDeltaEtaNeutral = new TH2F
858212dd 2062 ("hDeltaEtaNeutral","#eta_{trigger} - #eta_{#pi^{0}} vs #it{p}_{T trigger}",
62f2fe4d 2063 nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax);
e09cf5ef 2064 fhDeltaEtaNeutral->SetYTitle("#Delta #eta");
858212dd 2065 fhDeltaEtaNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 2066
3f150b4b 2067 fhXENeutral =
858212dd 2068 new TH2F("hXENeutral","#it{x}_{#it{E}} for #pi^{0} associated",
e09cf5ef 2069 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2070 fhXENeutral->SetYTitle("#it{x}_{#it{E}}");
2071 fhXENeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 2072
3f150b4b 2073 fhXEUeNeutral =
858212dd 2074 new TH2F("hXEUeNeutral","#it{x}_{#it{E}} for #pi^{0} associated",
e09cf5ef 2075 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2076 fhXEUeNeutral->SetYTitle("#it{x}_{#it{E}}");
2077 fhXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 2078
3f150b4b 2079 fhPtHbpXENeutral =
858212dd 2080 new TH2F("hHbpXENeutral","#xi = ln(1/#it{x}_{#it{E}})for #pi^{0} associated",
e09cf5ef 2081 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2082 fhPtHbpXENeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
2083 fhPtHbpXENeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 2084
3f150b4b 2085 fhPtHbpXEUeNeutral =
858212dd 2086 new TH2F("hHbpXEUeNeutral","#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
e09cf5ef 2087 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2088 fhPtHbpXEUeNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
2089 fhPtHbpXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2090
2091 fhZTNeutral =
858212dd 2092 new TH2F("hZTNeutral","#it{z}_{trigger #pi} = #it{p}_{T #pi^{0}} / #it{p}_{T trigger} for #pi^{0} associated",
3f150b4b 2093 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2094 fhZTNeutral->SetYTitle("#it{z}_{trigger #pi^{0}}");
2095 fhZTNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 2096
3f150b4b 2097 fhZTUeNeutral =
858212dd 2098 new TH2F("hZTUeNeutral","#it{z}_{trigger #pi} = #it{p}_{T #pi^{0}} / #it{p}_{T trigger} for #pi^{0} associated",
3f150b4b 2099 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2100 fhZTUeNeutral->SetYTitle("#it{z}_{trigger #pi^{0}}");
2101 fhZTUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2102
2103 fhPtHbpZTNeutral =
858212dd 2104 new TH2F("hHbpZTNeutral","#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
3f150b4b 2105 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2106 fhPtHbpZTNeutral->SetYTitle("ln(1/#it{z}_{T})");
2107 fhPtHbpZTNeutral->SetXTitle("#it{p}_{T trigger}");
3f150b4b 2108
2109 fhPtHbpZTUeNeutral =
858212dd 2110 new TH2F("hHbpZTUeNeutral","#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
3f150b4b 2111 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2112 fhPtHbpXEUeNeutral->SetYTitle("ln(1/#it{z}_{T})");
2113 fhPtHbpXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
e09cf5ef 2114
2115 outputContainer->Add(fhDeltaPhiDeltaEtaNeutral);
2116 outputContainer->Add(fhPhiNeutral) ;
2117 outputContainer->Add(fhEtaNeutral) ;
2118 outputContainer->Add(fhDeltaPhiNeutral) ;
2119 outputContainer->Add(fhDeltaPhiNeutralPt) ;
2120 outputContainer->Add(fhDeltaPhiUeNeutralPt) ;
2121 outputContainer->Add(fhDeltaEtaNeutral) ;
3f150b4b 2122 outputContainer->Add(fhXENeutral) ;
2123 outputContainer->Add(fhXEUeNeutral) ;
2124 outputContainer->Add(fhPtHbpXENeutral) ;
2125 outputContainer->Add(fhPtHbpXEUeNeutral) ;
2126 outputContainer->Add(fhZTNeutral) ;
2127 outputContainer->Add(fhZTUeNeutral) ;
2128 outputContainer->Add(fhPtHbpZTNeutral) ;
2129 outputContainer->Add(fhPtHbpZTUeNeutral) ;
e09cf5ef 2130
907b38cd 2131 if(fPi0Trigger || fDecayTrigger)
babcbc9d 2132 {
e09cf5ef 2133 fhDeltaPhiDecayNeutral = new TH2F
858212dd 2134 ("hDeltaPhiDecayNeutral","#phi_{Decay} - #phi_{h^{0}} vs #it{p}_{T Decay}",
62f2fe4d 2135 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2136 fhDeltaPhiDecayNeutral->SetYTitle("#Delta #phi (rad)");
858212dd 2137 fhDeltaPhiDecayNeutral->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})");
e09cf5ef 2138
3f150b4b 2139 fhXEDecayNeutral =
858212dd 2140 new TH2F("hXEDecayNeutral","#it{x}_{#it{E}} for decay trigger",
3f150b4b 2141 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2142 fhXEDecayNeutral->SetYTitle("#it{x}_{#it{E}}");
2143 fhXEDecayNeutral->SetXTitle("#it{p}_{T decay}");
3f150b4b 2144
2145 fhZTDecayNeutral =
858212dd 2146 new TH2F("hZTDecayNeutral","#it{z}_{trigger h^{0}} = #it{p}_{T h^{0}} / #it{p}_{T Decay}",
e09cf5ef 2147 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2148 fhZTDecayNeutral->SetYTitle("#it{z}_{h^{0}}");
2149 fhZTDecayNeutral->SetXTitle("#it{p}_{T decay}");
e09cf5ef 2150
2151 outputContainer->Add(fhDeltaPhiDecayNeutral) ;
3f150b4b 2152 outputContainer->Add(fhXEDecayNeutral) ;
2153 outputContainer->Add(fhZTDecayNeutral) ;
2154
e09cf5ef 2155 }
2156
547c2f01 2157 if(fMakeSeveralUE)
2158 {
e09cf5ef 2159 fhDeltaPhiUeLeftNeutral = new TH2F
858212dd 2160 ("hDeltaPhiUeLeftNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs #it{p}_{T h^{0}} with neutral UE left side range of trigger particles",
62f2fe4d 2161 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2162 fhDeltaPhiUeLeftNeutral->SetYTitle("#Delta #phi (rad)");
858212dd 2163 fhDeltaPhiUeLeftNeutral->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
e09cf5ef 2164 outputContainer->Add(fhDeltaPhiUeLeftNeutral) ;
2165
2166 fhDeltaPhiUeRightNeutral = new TH2F
858212dd 2167 ("hDeltaPhiUeRightNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs #it{p}_{T Ueh^{0}} with neutral UE right side range of trigger particles",
62f2fe4d 2168 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2169 fhDeltaPhiUeRightNeutral->SetYTitle("#Delta #phi (rad)");
858212dd 2170 fhDeltaPhiUeRightNeutral->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
e09cf5ef 2171 outputContainer->Add(fhDeltaPhiUeRightNeutral) ;
2172
3f150b4b 2173 fhXEUeLeftNeutral =
858212dd 2174 new TH2F("hXEUeNeutralLeft","#it{x}_{#it{E}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE left side of trigger",
3f150b4b 2175 nptbins,ptmin,ptmax,140,0.,2.);
858212dd 2176 fhXEUeLeftNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}");
2177 fhXEUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2178 outputContainer->Add(fhXEUeLeftNeutral) ;
2179
2180 fhXEUeRightNeutral =
858212dd 2181 new TH2F("hXEUeNeutralRight","#it{x}_{#it{E}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE right side of trigger",
3f150b4b 2182 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2183 fhXEUeRightNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}");
2184 fhXEUeRightNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2185 outputContainer->Add(fhXEUeRightNeutral) ;
2186
2187 fhPtHbpXEUeLeftNeutral =
858212dd 2188 new TH2F("hHbpXEUeNeutralLeft","#xi = ln(1/#it{x}_{#it{E}}) with neutral UE left side of trigger",
3f150b4b 2189 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2190 fhPtHbpXEUeLeftNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
2191 fhPtHbpXEUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2192 outputContainer->Add(fhPtHbpXEUeLeftNeutral) ;
2193
2194 fhPtHbpXEUeRightNeutral =
858212dd 2195 new TH2F("hHbpXEUeNeutralRight","#xi = ln(1/#it{x}_{#it{E}}) with neutral UE right side of trigger",
3f150b4b 2196 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2197 fhPtHbpXEUeRightNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
2198 fhPtHbpXEUeRightNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2199 outputContainer->Add(fhPtHbpXEUeRightNeutral) ;
2200
2201 fhZTUeLeftNeutral =
858212dd 2202 new TH2F("hZTUeNeutralLeft","#it{z}_{trigger h^{0}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE left side of trigger",
e09cf5ef 2203 nptbins,ptmin,ptmax,140,0.,2.);
858212dd 2204 fhZTUeLeftNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}");
2205 fhZTUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2206 outputContainer->Add(fhZTUeLeftNeutral) ;
e09cf5ef 2207
3f150b4b 2208 fhZTUeRightNeutral =
858212dd 2209 new TH2F("hZTUeNeutralRight","#it{z}_{trigger h^{0}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE right side of trigger",
e09cf5ef 2210 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2211 fhZTUeRightNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}");
2212 fhZTUeRightNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2213 outputContainer->Add(fhZTUeRightNeutral) ;
e09cf5ef 2214
3f150b4b 2215 fhPtHbpZTUeLeftNeutral =
858212dd 2216 new TH2F("hHbpZTUeNeutralLeft","#xi = ln(1/#it{z}_{T}) with neutral UE left side of trigger",
e09cf5ef 2217 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2218 fhPtHbpZTUeLeftNeutral->SetYTitle("ln(1/#it{z}_{T})");
2219 fhPtHbpZTUeLeftNeutral->SetXTitle("#it{p}_{T trigger}");
3f150b4b 2220 outputContainer->Add(fhPtHbpZTUeLeftNeutral) ;
e09cf5ef 2221
3f150b4b 2222 fhPtHbpZTUeRightNeutral =
858212dd 2223 new TH2F("hHbpZTUeNeutralRight","#xi = ln(1/#it{z}_{T}) with neutral UE right side of trigger",
e09cf5ef 2224 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2225 fhPtHbpZTUeRightNeutral->SetYTitle("ln(1/#it{z}_{T})");
2226 fhPtHbpZTUeRightNeutral->SetXTitle("#it{p}_{T trigger}");
3f150b4b 2227 outputContainer->Add(fhPtHbpZTUeRightNeutral) ;
e09cf5ef 2228
2229 }
fe871b21 2230
2231 }//Correlation with neutral hadrons
2232
2233 //if data is MC, fill more histograms
babcbc9d 2234 if(IsDataMC())
2235 {
2236 fh2phiLeadingParticle=new TH2F("h2phiLeadingParticle","#phi resolustion for trigger particles",nptbins,ptmin,ptmax,100,-1,1);
858212dd 2237 fh2phiLeadingParticle->GetXaxis()->SetTitle("#it{p}_{T gen Leading} (GeV/#it{c})");
fe871b21 2238 fh2phiLeadingParticle->GetYaxis()->SetTitle("(#phi_{rec}-#phi_{gen})/#phi_{gen}");
9623bf34 2239
858212dd 2240 fhMCPtLeading = new TH1F ("hMCPtLeading","MC : #it{p}_{T} distribution of leading particles", nptbins,ptmin,ptmax);
2241 fhMCPtLeading->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
08f220c8 2242
2243 fhMCPhiLeading = new TH2F ("hMCPhiLeading","MC : #phi distribution of leading Particles",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
2244 fhMCPhiLeading->SetYTitle("#phi (rad)");
2245
2246 fhMCEtaLeading = new TH2F ("hMCEtaLeading","MC : #eta distribution of leading",nptbins,ptmin,ptmax, netabins,etamin,etamax);
2247 fhMCEtaLeading->SetYTitle("#eta ");
2248
e09cf5ef 2249
fe871b21 2250 fhMCEtaCharged = new TH2F
858212dd 2251 ("hMCEtaCharged","MC #eta_{h^{#pm}} vs #it{p}_{T #pm}",
fe871b21 2252 nptbins,ptmin,ptmax,netabins,etamin,etamax);
2253 fhMCEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)");
858212dd 2254 fhMCEtaCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
fe871b21 2255
2256 fhMCPhiCharged = new TH2F
858212dd 2257 ("hMCPhiCharged","#MC phi_{h^{#pm}} vs #it{p}_{T #pm}",
fe871b21 2258 200,ptmin,ptmax,nphibins,phimin,phimax);
2259 fhMCPhiCharged->SetYTitle("MC #phi_{h^{#pm}} (rad)");
858212dd 2260 fhMCPhiCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
fe871b21 2261
2262 fhMCDeltaPhiDeltaEtaCharged = new TH2F
babcbc9d 2263 ("hMCDeltaPhiDeltaEtaCharged","#MC phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",
fe871b21 2264 140,-2.,5.,200,-2,2);
2bb7ac98 2265 fhMCDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
fe871b21 2266 fhMCDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
2267
2268 fhMCDeltaEtaCharged = new TH2F
858212dd 2269 ("hMCDeltaEtaCharged","MC #eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger} and #it{p}_{T assoc}",
fe871b21 2270 nptbins,ptmin,ptmax,200,-2,2);
2271 fhMCDeltaEtaCharged->SetYTitle("#Delta #eta");
858212dd 2272 fhMCDeltaEtaCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fe871b21 2273
2274 fhMCDeltaPhiCharged = new TH2F
858212dd 2275 ("hMCDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}",
62f2fe4d 2276 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2277 fhMCDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
858212dd 2278 fhMCDeltaPhiCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fe871b21 2279
2280 fhMCDeltaPhiChargedPt = new TH2F
858212dd 2281 ("hMCDeltaPhiChargedPt","MC #phi_{trigger} - #phi_{#h^{#pm}} vs #it{p}_{T h^{#pm}}",
62f2fe4d 2282 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2283 fhMCDeltaPhiChargedPt->SetYTitle("#Delta #phi (rad)");
858212dd 2284 fhMCDeltaPhiChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
fe871b21 2285
3f150b4b 2286 fhMCPtXECharged =
c78eef61 2287 new TH2F("hMCPtXECharged","#it{x}_{#it{E}} with charged hadrons",
fe871b21 2288 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2289 fhMCPtXECharged->SetYTitle("#it{x}_{#it{E}}");
2290 fhMCPtXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
9623bf34 2291
2292 fhMCPtXEUeCharged =
c78eef61 2293 new TH2F("hMCPtXEUeCharged","#it{x}_{#it{E}} with charged hadrons, Underlying Event",
9623bf34 2294 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2295 fhMCPtXEUeCharged->SetYTitle("#it{x}_{#it{E}}");
2296 fhMCPtXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
c78eef61 2297
2298 fhMCPtXEUeLeftCharged =
2299 new TH2F("hMCPtXEUeChargedLeft","#it{x}_{#it{E}} with charged hadrons, with UE left side range of trigger particles",
2300 nptbins,ptmin,ptmax,200,0.,2.);
2301 fhMCPtXEUeLeftCharged->SetYTitle("#it{x}_{#it{E}}");
2302 fhMCPtXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2303
2304 fhMCPtXEUeRightCharged =
2305 new TH2F("hMCPtXEUeChargedRight","#it{x}_{#it{E}} with charged hadrons, with UE left side range of trigger particles",
2306 nptbins,ptmin,ptmax,200,0.,2.);
2307 fhMCPtXEUeRightCharged->SetYTitle("#it{x}_{#it{E}}");
2308 fhMCPtXEUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2309
fe871b21 2310
3f150b4b 2311 fhMCPtHbpXECharged =
858212dd 2312 new TH2F("hMCHbpXECharged","MC #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons",
fe871b21 2313 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2314 fhMCPtHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
2315 fhMCPtHbpXECharged->SetXTitle("#it{p}_{T trigger}");
9623bf34 2316
2317 fhMCPtHbpXEUeCharged =
c78eef61 2318 new TH2F("hMCPtHbpXEUeCharged","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, Underlying Event",
2319 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2320 fhMCPtHbpXEUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
2321 fhMCPtHbpXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
c78eef61 2322
2323 fhMCPtHbpXEUeLeftCharged =
2324 new TH2F("hMCPtHbpXEUeChargedLeft","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, with UE left side range of trigger particles",
2325 nptbins,ptmin,ptmax,200,0.,10.);
2326 fhMCPtHbpXEUeLeftCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
2327 fhMCPtHbpXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2328
2329 fhMCPtHbpXEUeRightCharged =
2330 new TH2F("hMCPtHbpXEUeChargedRight","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, with UE right side range of trigger particles",
2331 nptbins,ptmin,ptmax,200,0.,10.);
2332 fhMCPtHbpXEUeRightCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
2333 fhMCPtHbpXEUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
9623bf34 2334
c78eef61 2335
9623bf34 2336 fhMCUePart =
2337 new TH1F("hMCUePart","MC UE particles distribution vs pt trig",
2338 nptbins,ptmin,ptmax);
858212dd 2339 fhMCUePart->SetYTitle("#it{dN}^{ch}");
2340 fhMCUePart->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
3f150b4b 2341
2342 fhMCPtZTCharged =
c78eef61 2343 new TH2F("hMCPtZTCharged","#it{z}_{T} with charged hadrons",
3f150b4b 2344 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2345 fhMCPtZTCharged->SetYTitle("#it{z}_{T}");
2346 fhMCPtZTCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
c78eef61 2347
2348 fhMCPtZTUeCharged =
2349 new TH2F("hMCPtZTUeCharged","#it{z}_{T} with charged hadrons, Underlying Event",
2350 nptbins,ptmin,ptmax,200,0.,2.);
2351 fhMCPtZTUeCharged->SetYTitle("#it{z}_{T}");
2352 fhMCPtZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2353
2354 fhMCPtZTUeLeftCharged =
2355 new TH2F("hMCPtZTUeChargedLeft","#it{z}_{T} with charged hadrons, with UE left side range of trigger particles",
2356 nptbins,ptmin,ptmax,200,0.,2.);
2357 fhMCPtZTUeLeftCharged->SetYTitle("#it{z}_{T}");
2358 fhMCPtZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2359
2360 fhMCPtZTUeRightCharged =
2361 new TH2F("hMCPtZTUeChargedRight","#it{z}_{T} with charged hadrons, with UE right side range of trigger particles",
2362 nptbins,ptmin,ptmax,200,0.,2.);
2363 fhMCPtZTUeRightCharged->SetYTitle("#it{z}_{T}");
2364 fhMCPtZTUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2365
3f150b4b 2366 fhMCPtHbpZTCharged =
858212dd 2367 new TH2F("hMCHbpZTCharged","MC #xi = ln(1/#it{z}_{T}) with charged hadrons",
3f150b4b 2368 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2369 fhMCPtHbpZTCharged->SetYTitle("ln(1/#it{z}_{T})");
2370 fhMCPtHbpZTCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fe871b21 2371
c78eef61 2372 fhMCPtHbpZTUeCharged =
2373 new TH2F("hMCPtHbpZTUeCharged","#xi = ln(1/#it{z}_{T}) with charged hadrons, Underlying Event",
2374 nptbins,ptmin,ptmax,200,0.,10.);
2375 fhMCPtHbpZTUeCharged->SetYTitle("ln(1/#it{z}_{T})");
2376 fhMCPtHbpZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2377
2378 fhMCPtHbpZTUeLeftCharged =
2379 new TH2F("hMCPtHbpZTUeChargedLeft","#xi = ln(1/#it{z}_{T}) with charged hadrons, with UE left side range of trigger particles",
2380 nptbins,ptmin,ptmax,200,0.,10.);
2381 fhMCPtHbpZTUeLeftCharged->SetYTitle("ln(1/#it{z}_{T})");
2382 fhMCPtHbpZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2383
2384 fhMCPtHbpZTUeRightCharged =
2385 new TH2F("hMCPtHbpZTUeChargedRight","#xi = ln(1/#it{z}_{T}) with charged hadrons, with UE right side range of trigger particles",
2386 nptbins,ptmin,ptmax,200,0.,10.);
2387 fhMCPtHbpZTUeRightCharged->SetYTitle("ln(1/#it{z}_{T})");
2388 fhMCPtHbpZTUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2389
fe871b21 2390 fhMCPtTrigPout =
babcbc9d 2391 new TH2F("hMCPtTrigPout","AOD MC Pout with triggers",
fe871b21 2392 nptbins,ptmin,ptmax,2*nptbins,-ptmax,ptmax);
858212dd 2393 fhMCPtTrigPout->SetYTitle("#it{p}_{out} (GeV/#it{c})");
2394 fhMCPtTrigPout->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fe871b21 2395
2396 fhMCPtAssocDeltaPhi =
babcbc9d 2397 new TH2F("hMCPtAssocDeltaPhi","AOD MC delta phi with associated charged hadrons",
62f2fe4d 2398 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2399 fhMCPtAssocDeltaPhi->SetYTitle("#Delta #phi (rad)");
858212dd 2400 fhMCPtAssocDeltaPhi->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fe871b21 2401
2402 outputContainer->Add(fh2phiLeadingParticle);
9623bf34 2403 outputContainer->Add(fhMCPtLeading);
08f220c8 2404 outputContainer->Add(fhMCPhiLeading);
2405 outputContainer->Add(fhMCEtaLeading);
fe871b21 2406 outputContainer->Add(fhMCDeltaPhiDeltaEtaCharged);
2407 outputContainer->Add(fhMCPhiCharged) ;
2408 outputContainer->Add(fhMCEtaCharged) ;
2409 outputContainer->Add(fhMCDeltaEtaCharged) ;
2410 outputContainer->Add(fhMCDeltaPhiCharged) ;
2411
2412 outputContainer->Add(fhMCDeltaPhiChargedPt) ;
3f150b4b 2413 outputContainer->Add(fhMCPtXECharged) ;
9623bf34 2414 outputContainer->Add(fhMCPtXEUeCharged) ;
c78eef61 2415 outputContainer->Add(fhMCPtXEUeLeftCharged) ;
2416 outputContainer->Add(fhMCPtXEUeRightCharged) ;
3f150b4b 2417 outputContainer->Add(fhMCPtZTCharged) ;
c78eef61 2418 outputContainer->Add(fhMCPtZTUeCharged) ;
2419 outputContainer->Add(fhMCPtZTUeLeftCharged) ;
2420 outputContainer->Add(fhMCPtZTUeRightCharged) ;
3f150b4b 2421 outputContainer->Add(fhMCPtHbpXECharged) ;
9623bf34 2422 outputContainer->Add(fhMCPtHbpXEUeCharged);
c78eef61 2423 outputContainer->Add(fhMCPtHbpXEUeLeftCharged);
2424 outputContainer->Add(fhMCPtHbpXEUeRightCharged);
9623bf34 2425 outputContainer->Add(fhMCUePart);
3f150b4b 2426 outputContainer->Add(fhMCPtHbpZTCharged) ;
c78eef61 2427 outputContainer->Add(fhMCPtHbpZTUeCharged) ;
2428 outputContainer->Add(fhMCPtHbpZTUeLeftCharged) ;
2429 outputContainer->Add(fhMCPtHbpZTUeRightCharged) ;
fe871b21 2430 outputContainer->Add(fhMCPtTrigPout) ;
2431 outputContainer->Add(fhMCPtAssocDeltaPhi) ;
2432 } //for MC histogram
2433
2e876d85 2434 if(DoOwnMix())
029dea5a 2435 {
2436 //create event containers
029dea5a 2437
283f989c 2438 if(!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForTracksExists()))
2e876d85 2439 {
d07ffd54 2440 Int_t nvz = GetNZvertBin();
2441 Int_t nrp = GetNRPBin();
2442 Int_t nce = GetNCentrBin();
283f989c 2443
d07ffd54 2444 fListMixTrackEvents= new TList*[nvz*nrp*nce] ;
2445
2446 for( Int_t ice = 0 ; ice < nce ; ice++ )
2447 {
2448 for( Int_t ivz = 0 ; ivz < nvz ; ivz++ )
2449 {
2450 for( Int_t irp = 0 ; irp < nrp ; irp++ )
2451 {
2452 Int_t bin = GetEventMixBin(ice,ivz,irp); //ic*nvz*nrp+iz*nrp+irp;
2453
2454 //printf("GetCreateOutputObjects - Bins : cent %d, vz %d, RP %d, event %d/%d\n",
2455 // ic,iz, irp, bin);
2456
2457 fListMixTrackEvents[bin] = new TList() ;
2458 fListMixTrackEvents[bin]->SetOwner(kFALSE);
2459 }
2460 }
2461 }
2462 }
d0b625bc 2463
858212dd 2464 fhPtLeadingMixed = new TH1F ("hPtLeadingMixed","#it{p}_{T} distribution of leading particles, used for mixing", nptbins,ptmin,ptmax);
2465 fhPtLeadingMixed->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
ca17b39f 2466
7d306daf 2467 if(fCorrelVzBin)
2468 {
858212dd 2469 fhPtLeadingMixedVzBin = new TH2F ("hPtLeadingMixedVzBin","#it{p}_{T} distribution of leading particles, used for mixing", nptbins,ptmin,ptmax,GetNZvertBin(),0,GetNZvertBin());
2470 fhPtLeadingMixedVzBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
2471 fhPtLeadingMixedVzBin->SetYTitle("#it{v}_{#it{z}} bin");
7d306daf 2472 outputContainer->Add(fhPtLeadingMixedVzBin);
2473 }
2474
858212dd 2475 fhPtLeadingMixedBin = new TH2F ("hPtLeadingMixedBin","#it{p}_{T} distribution of leading particles vs mixing bin", nptbins,ptmin,ptmax,nMixBins,0,nMixBins);
2476 fhPtLeadingMixedBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
d0b625bc 2477 fhPtLeadingMixedBin->SetYTitle("Bin");
d07ffd54 2478
d0b625bc 2479 fhPhiLeadingMixed = new TH2F ("hPhiLeadingMixed","#phi distribution of leading Particles, used for mixing",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
2480 fhPhiLeadingMixed->SetYTitle("#phi (rad)");
2481
2482 fhEtaLeadingMixed = new TH2F ("hEtaLeadingMixed","#eta distribution of leading, used for mixing",nptbins,ptmin,ptmax, netabins,etamin,etamax);
2483 fhEtaLeadingMixed->SetYTitle("#eta ");
2484
2485 outputContainer->Add(fhPtLeadingMixed);
2486 outputContainer->Add(fhPtLeadingMixedBin);
2487 outputContainer->Add(fhPhiLeadingMixed);
2488 outputContainer->Add(fhEtaLeadingMixed);
2489
2bb7ac98 2490 // Fill the cluster pool only in isolation analysis or if requested
2491 if( ( OnlyIsolated() || fFillNeutralEventMixPool) &&
2492 (!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForCaloExists())))
d07ffd54 2493 {
7ed3a248 2494 Int_t nvz = GetNZvertBin();
2495 Int_t nrp = GetNRPBin();
2496 Int_t nce = GetNCentrBin();
2497
d07ffd54 2498 fListMixCaloEvents= new TList*[nvz*nrp*nce] ;
7ed3a248 2499
2500 for( Int_t ice = 0 ; ice < nce ; ice++ )
2e876d85 2501 {
7ed3a248 2502 for( Int_t ivz = 0 ; ivz < nvz ; ivz++ )
2e876d85 2503 {
7ed3a248 2504 for( Int_t irp = 0 ; irp < nrp ; irp++ )
283f989c 2505 {
7ed3a248 2506 Int_t bin = GetEventMixBin(ice,ivz,irp); //ic*nvz*nrp+iz*nrp+irp;
2507
da3c40f7 2508 //printf("GetCreateOutputObjects - Bins : cent %d, vz %d, RP %d, event %d/%d\n",
7ed3a248 2509 // ic,iz, irp, bin);
2510
d07ffd54 2511 fListMixCaloEvents[bin] = new TList() ;
2512 fListMixCaloEvents[bin]->SetOwner(kFALSE);
283f989c 2513 }
2e876d85 2514 }
283f989c 2515 }
2516 }
2517
2518 //Init the list in the reader if not done previously
d07ffd54 2519 if(fUseMixStoredInReader)
283f989c 2520 {
d07ffd54 2521 if( !GetReader()->ListWithMixedEventsForTracksExists() )
2522 GetReader()->SetListWithMixedEventsForTracks(fListMixTrackEvents);
2523
2524 if( !GetReader()->ListWithMixedEventsForCaloExists() )
2525 GetReader()->SetListWithMixedEventsForCalo (fListMixCaloEvents );
283f989c 2526 }
029dea5a 2527
2e876d85 2528 fhEventBin=new TH1I("hEventBin","Number of real events per bin(cen,vz,rp)",
2529 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
2530 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
2531 fhEventBin->SetXTitle("bin");
2532 outputContainer->Add(fhEventBin) ;
283f989c 2533
2e876d85 2534 fhEventMixBin=new TH1I("hEventMixBin","Number of events per bin(cen,vz,rp)",
2535 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
2536 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
2537 fhEventMixBin->SetXTitle("bin");
2538 outputContainer->Add(fhEventMixBin) ;
283f989c 2539
2e876d85 2540 fhNtracksMB=new TH1F("hNtracksMBEvent","Number of tracks w/ event trigger kMB",2000,0,2000);
2541 outputContainer->Add(fhNtracksMB);
029dea5a 2542
2bb7ac98 2543 if(fFillNeutralEventMixPool || OnlyIsolated())
2544 {
2bb7ac98 2545 fhNclustersMB=new TH1F("hNclustersMBEvent","Number of clusters w/ event trigger kMB",2000,0,2000);
2546 outputContainer->Add(fhNclustersMB);
2547 }
2548
029dea5a 2549 fhMixDeltaPhiCharged = new TH2F
858212dd 2550 ("hMixDeltaPhiCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}",
62f2fe4d 2551 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2552 fhMixDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
858212dd 2553 fhMixDeltaPhiCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
029dea5a 2554 outputContainer->Add(fhMixDeltaPhiCharged);
283f989c 2555
029dea5a 2556 fhMixDeltaPhiDeltaEtaCharged = new TH2F
2557 ("hMixDeltaPhiDeltaEtaCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",
62f2fe4d 2558 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
2bb7ac98 2559 fhMixDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
029dea5a 2560 fhMixDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
2561 outputContainer->Add(fhMixDeltaPhiDeltaEtaCharged);
283f989c 2562
08f220c8 2563 fhMixXECharged =
858212dd 2564 new TH2F("hMixXECharged","Mixed event : #it{x}_{#it{E}} for charged tracks",
08f220c8 2565 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2566 fhMixXECharged->SetYTitle("#it{x}_{#it{E}}");
2567 fhMixXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
08f220c8 2568 outputContainer->Add(fhMixXECharged);
18838011 2569
2570 fhMixXEUeCharged =
858212dd 2571 new TH2F("hMixXEUeCharged","Mixed event : #it{x}_{#it{E}} for charged tracks in Ue region",
18838011 2572 nptbins,ptmin,ptmax,200,0.,2.);
858212dd 2573 fhMixXEUeCharged->SetYTitle("#it{x}_{#it{E}}");
2574 fhMixXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
18838011 2575 outputContainer->Add(fhMixXEUeCharged);
08f220c8 2576
18838011 2577 fhMixHbpXECharged =
858212dd 2578 new TH2F("hMixHbpXECharged","mixed event : #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons",
08f220c8 2579 nptbins,ptmin,ptmax,200,0.,10.);
858212dd 2580 fhMixHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
2581 fhMixHbpXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
08f220c8 2582 outputContainer->Add(fhMixHbpXECharged);
2583
7d306daf 2584 fhMixDeltaPhiChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
2585 fhMixDeltaPhiChargedAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz];
2586 fhMixDeltaPhiChargedAssocPtBinDEta0 = new TH2F*[fNAssocPtBins*nz];
2587 fhMixDeltaPhiDeltaEtaChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
283f989c 2588
029dea5a 2589 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
8cc41381 2590 {
7d306daf 2591 for(Int_t z = 0 ; z < nz ; z++)
8cc41381 2592 {
7d306daf 2593 Int_t bin = i*nz+z;
8cc41381 2594
7d306daf 2595 if(fCorrelVzBin)
2596 {
d71a7d1f 2597 sz = Form("_vz%d",z);
858212dd 2598 tz = Form(", #it{v}_{#it{z}} bin %d",z);
7d306daf 2599 }
2600
2601 //printf("MIX : iAssoc %d, Vz %d, bin %d - sz %s, tz %s \n",i,z,bin,sz.Data(),tz.Data());
2602
2603 fhMixDeltaPhiChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 2604 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()),
8cc41381 2605 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 2606 fhMixDeltaPhiChargedAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2bb7ac98 2607 fhMixDeltaPhiChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 2608
7d306daf 2609 fhMixDeltaPhiChargedAssocPtBinDEta08[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0.8ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 2610 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()),
8cc41381 2611 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 2612 fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2bb7ac98 2613 fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 2614
7d306daf 2615 fhMixDeltaPhiChargedAssocPtBinDEta0[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 2616 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()),
8cc41381 2617 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
858212dd 2618 fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
2bb7ac98 2619 fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 2620
7d306daf 2621 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiDeltaEtaChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
858212dd 2622 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()),
8cc41381 2623 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
2bb7ac98 2624 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)");
8cc41381 2625 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetYTitle("#Delta #eta");
2626
2627 outputContainer->Add(fhMixDeltaPhiChargedAssocPtBin[bin]);
2628 outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta08[bin]);
2629 outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta0[bin]);
2630 outputContainer->Add(fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]);
2631 }
050ad675 2632 }
029dea5a 2633 }
7d306daf 2634
e09cf5ef 2635 return outputContainer;
2636
2637}
2638
907b38cd 2639//_________________________________________________________________________________________________
2640Bool_t AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum(const AliAODPWG4Particle* trigger,
2641 TLorentzVector & mom1,
2642 TLorentzVector & mom2)
2643{
2644 // Get the momentum of the pi0/eta assigned decay photons
2645 // In case of pi0/eta trigger, we may want to check their decay correlation,
2646 // get their decay children
2647
2648 Int_t indexPhoton1 = trigger->GetCaloLabel(0);
2649 Int_t indexPhoton2 = trigger->GetCaloLabel(1);
2650 Float_t ptTrig = trigger->Pt();
2651
2652 if(indexPhoton1!=-1 || indexPhoton2!=-1) return kFALSE;
2653
2654 if(GetDebug() > 1)
2655 printf("AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum() - indexPhoton1 = %d, indexPhoton2 = %d \n", indexPhoton1, indexPhoton2);
2656
2657 TObjArray * clusters = 0x0 ;
2658 if(trigger->GetDetector()=="EMCAL") clusters = GetEMCALClusters() ;
2659 else clusters = GetPHOSClusters() ;
2660
2661 for(Int_t iclus = 0; iclus < clusters->GetEntriesFast(); iclus++)
2662 {
2663 AliVCluster * photon = (AliVCluster*) (clusters->At(iclus));
2664 if(photon->GetID()==indexPhoton1)
2665 {
2666 photon->GetMomentum(mom1,GetVertex(0)) ;
2667 if(ptTrig) fhPtPi0DecayRatio->Fill(ptTrig, mom1.Pt()/ptTrig);
2668 }
2669 if(photon->GetID()==indexPhoton2)
2670 {
2671 photon->GetMomentum(mom1,GetVertex(0)) ;
2672 if(ptTrig > 0) fhPtPi0DecayRatio->Fill(ptTrig, mom2.Pt()/ptTrig);
2673 }
2674
2675 if(GetDebug() > 1)printf("AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum() - Photon1 = %f, Photon2 = %f \n", mom1.Pt(), mom2.Pt());
2676
2677 } //cluster loop
2678
2679 return kTRUE;
2680
2681}
2682
b1f720a7 2683//_____________________________________________________________
22ad7981 2684Int_t AliAnaParticleHadronCorrelation::GetMCTagHistogramIndex(Int_t mcTag)
b1f720a7 2685{
2686 // Index of MC histograms depending on MC origin
2687
2688 if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPrompt) ||
2689 GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCFragmentation)) return 0;
2690 else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0)) return 1;
2691 else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0Decay)) return 2;
2692 else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay)) return 3;
2693 else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCOtherDecay)) return 4;
2694 else if(!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron)) return 5;
2695 else return 6;
2696
2697}
2698
05d0d05d 2699//____________________________________________________
e09cf5ef 2700void AliAnaParticleHadronCorrelation::InitParameters()
2701{
2702
2703 //Initialize the parameters of the analysis.
e4c0a0eb 2704 SetInputAODName("Particle");
e09cf5ef 2705 SetAODObjArrayName("Hadrons");
2706 AddToHistogramsName("AnaHadronCorr_");
045396c8 2707
e09cf5ef 2708 SetPtCutRange(0.,300);
045396c8 2709 fDeltaPhiMinCut = 1.5 ;
2710 fDeltaPhiMaxCut = 4.5 ;
2711 fSelectIsolated = kFALSE;
2712 fMakeSeveralUE = kFALSE;
2713 fUeDeltaPhiMinCut = 1. ;
2714 fUeDeltaPhiMaxCut = 1.5 ;
907b38cd 2715
045396c8 2716 fNeutralCorr = kFALSE ;
2717 fPi0Trigger = kFALSE ;
907b38cd 2718 fDecayTrigger = kFALSE ;
2719 fHMPIDCorrelation = kFALSE ;
045396c8 2720
3f150b4b 2721 fMakeAbsoluteLeading = kTRUE;
2722 fMakeNearSideLeading = kFALSE;
2723
050ad675 2724 fNAssocPtBins = 9 ;
2725 fAssocPtBinLimit[0] = 0.2 ;
f85f4afb 2726 fAssocPtBinLimit[1] = 0.5 ;
2727 fAssocPtBinLimit[2] = 1.0 ;
2728 fAssocPtBinLimit[3] = 2.0 ;
2729 fAssocPtBinLimit[4] = 3.0 ;
2730 fAssocPtBinLimit[5] = 4.0 ;
2731 fAssocPtBinLimit[6] = 5.0 ;
2732 fAssocPtBinLimit[7] = 6.0 ;
2733 fAssocPtBinLimit[8] = 7.0 ;
2734 fAssocPtBinLimit[9] = 8.0 ;
2735 fAssocPtBinLimit[10] = 9.0 ;
2736 fAssocPtBinLimit[11] = 10.0 ;
2737 fAssocPtBinLimit[12] = 12.0 ;
2738 fAssocPtBinLimit[13] = 14.0 ;
2739 fAssocPtBinLimit[14] = 16.0 ;
2740 fAssocPtBinLimit[15] = 20.0 ;
2741 fAssocPtBinLimit[16] = 30.0 ;
2742 fAssocPtBinLimit[17] = 40.0 ;
2743 fAssocPtBinLimit[18] = 50.0 ;
2744 fAssocPtBinLimit[19] = 200.0 ;
2745
283f989c 2746 fUseMixStoredInReader = kTRUE;
2747
e4c0a0eb 2748 fM02MinCut = -1 ;
2749 fM02MaxCut = -1 ;
2750
f7408d50 2751 fSelectLeadingHadronAngle = kFALSE;
2752 fMinLeadHadPhi = 150*TMath::DegToRad();
2753 fMaxLeadHadPhi = 210*TMath::DegToRad();
2754
2755 fMinLeadHadPt = 1;
2756 fMaxLeadHadPt = 100;
2757
e09cf5ef 2758}
2759
05d0d05d 2760//__________________________________________________________
e09cf5ef 2761void AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD()
2762{
2763 //Particle-Hadron Correlation Analysis, fill AODs
2764
547c2f01 2765 if(!GetInputAODBranch())
2766 {
e09cf5ef 2767 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - No input particles in AOD with name branch < %s >, STOP \n",GetInputAODName().Data());
2768 abort();
2769 }
2770
547c2f01 2771 if(strcmp(GetInputAODBranch()->GetClass()->GetName(), "AliAODPWG4ParticleCorrelation"))
2772 {
e09cf5ef 2773 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - Wrong type of AOD object, change AOD class name in input AOD: It should be <AliAODPWG4ParticleCorrelation> and not <%s> \n",GetInputAODBranch()->GetClass()->GetName());
2774 abort();
2775 }
2776
283f989c 2777 if(GetDebug() > 1)
2778 {
e09cf5ef 2779 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - Begin hadron correlation analysis, fill AODs \n");
2780 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast());
66e64043 2781 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In CTS aod entries %d\n", GetCTSTracks() ->GetEntriesFast());
e09cf5ef 2782 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetEMCALClusters()->GetEntriesFast());
66e64043 2783 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In PHOS aod entries %d\n", GetPHOSClusters() ->GetEntriesFast());
e09cf5ef 2784 }
2785
045396c8 2786 //Get the vertex and check it is not too large in z
2787 Double_t v[3] = {0,0,0}; //vertex ;
2788 GetReader()->GetVertex(v);
2789 if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ;
31864468 2790
045396c8 2791 //Loop on stored AOD particles, find leading trigger
66e64043 2792 Double_t ptTrig = fMinTriggerPt ;
045396c8 2793 fLeadingTriggerIndex = -1 ;
2794 Int_t naod = GetInputAODBranch()->GetEntriesFast() ;
04f7a616 2795 for(Int_t iaod = 0; iaod < naod ; iaod++)
2796 {
e09cf5ef 2797 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
045396c8 2798
04f7a616 2799 // Vertex cut in case of mixing
2800 Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0));
2801 if(check == 0) continue;
2802 if(check == -1) return;
2803
045396c8 2804 // find the leading particles with highest momentum
547c2f01 2805 if (particle->Pt() > ptTrig)
2806 {
045396c8 2807 ptTrig = particle->Pt() ;
2808 fLeadingTriggerIndex = iaod ;
2809 }
2810 }// finish search of leading trigger particle
e09cf5ef 2811
66e64043 2812
e09cf5ef 2813 //Do correlation with leading particle
547c2f01 2814 if(fLeadingTriggerIndex >= 0)
2815 {
e09cf5ef 2816
045396c8 2817 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(fLeadingTriggerIndex));
2818
2819 //check if the particle is isolated or if we want to take the isolation into account
2820 if(OnlyIsolated() && !particle->IsIsolated()) return;
2821
e09cf5ef 2822 //Make correlation with charged hadrons
045396c8 2823 Bool_t okcharged = kTRUE;
2824 Bool_t okneutral = kTRUE;
e09cf5ef 2825 if(GetReader()->IsCTSSwitchedOn() )
045396c8 2826 okcharged = MakeChargedCorrelation(particle, GetCTSTracks(),kFALSE);
e09cf5ef 2827
2828 TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); //For the future, foresee more possible pi0 lists
2829 if(fNeutralCorr && pi0list && pi0list->GetEntriesFast() > 0)
045396c8 2830 okneutral = MakeNeutralCorrelation(particle, pi0list,kFALSE);
e09cf5ef 2831
37bd27d6 2832 if( GetDebug() > 1 ) AliInfo(Form("Charged correlation OK %d; Neutral correlation OK %d",okcharged,okneutral));
2833
e09cf5ef 2834 }//Correlate leading
2835
2836 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - End fill AODs \n");
2837
2838}
2839
05d0d05d 2840//_________________________________________________________________
e09cf5ef 2841void AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms()
2842{
2843 //Particle-Hadron Correlation Analysis, fill histograms
2844
3f150b4b 2845 if(!GetInputAODBranch())
2846 {
e09cf5ef 2847 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - No input particles in AOD with name branch < %s >, STOP \n",GetInputAODName().Data());
2848 abort();
2849 }
2850
3f150b4b 2851 if(GetDebug() > 1)
2852 {
e09cf5ef 2853 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Begin hadron correlation analysis, fill histograms \n");
2854 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast());
2855 }
babcbc9d 2856
e09cf5ef 2857 //Get the vertex and check it is not too large in z
2858 Double_t v[3] = {0,0,0}; //vertex ;
2859 GetReader()->GetVertex(v);
2860 if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ;
2861
c8710850 2862 Float_t cen = GetEventCentrality();
2863 Float_t ep = GetEventPlaneAngle();
2864
e09cf5ef 2865 //Loop on stored AOD particles, find leading
66e64043 2866 Double_t ptTrig = fMinTriggerPt;
04f7a616 2867 if(fLeadingTriggerIndex < 0)
2868 {
2869 //Search leading if not done before
045396c8 2870 Int_t naod = GetInputAODBranch()->GetEntriesFast() ;
547c2f01 2871 for(Int_t iaod = 0; iaod < naod ; iaod++)
2872 { //loop on input trigger AOD file
045396c8 2873 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
04f7a616 2874
2875 // Vertex cut in case of mixing
2876 Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0));
2877 if(check == 0) continue;
2878 if(check == -1) return;
9623bf34 2879
045396c8 2880 //check if the particle is isolated or if we want to take the isolation into account
2881 if(OnlyIsolated() && !particle->IsIsolated()) continue;
e09cf5ef 2882
045396c8 2883 //find the leading particles with highest momentum
547c2f01 2884 if (particle->Pt() > ptTrig)
2885 {
045396c8 2886 ptTrig = particle->Pt() ;
2887 fLeadingTriggerIndex = iaod ;
e09cf5ef 2888 }
547c2f01 2889
2890 }// Finish search of leading trigger particle
2891 }// Search leading if not done before
045396c8 2892
547c2f01 2893 if(fLeadingTriggerIndex >= 0 )
2894 { //using trigger particle to do correlations
2895
045396c8 2896 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(fLeadingTriggerIndex));
06d3bad7 2897
e4c0a0eb 2898 // check if it was a calorimeter cluster and if the SS cut was requested, if so, apply it
2899 Int_t clID1 = particle->GetCaloLabel(0) ;
2900 Int_t clID2 = particle->GetCaloLabel(1) ; // for photon clusters should not be set.
2901 //printf("Leading for for %s: id1 %d, id2 %d, min %f, max %f, det %s\n",
2902 // GetInputAODName().Data(),clID1,clID2,fM02MinCut,fM02MaxCut,(particle->GetDetector()).Data());
2903
2904 if(clID1 > 0 && clID2 < 0 && fM02MaxCut > 0 && fM02MinCut > 0)
2905 {
2906 Int_t iclus = -1;
2907 TObjArray* clusters = 0x0;
2908 if (particle->GetDetector() == "EMCAL") clusters = GetEMCALClusters();
2909 else if(particle->GetDetector() == "PHOS" ) clusters = GetPHOSClusters();
2910
2911 if(clusters)
2912 {
2913 AliVCluster *cluster = FindCluster(clusters,clID1,iclus);
2914 Float_t m02 = cluster->GetM02();
2915 //printf("\t Check m02 = %2.2f\n",m02);
2916 if(m02 > fM02MaxCut || m02 < fM02MinCut)
2917 {
2918 //printf("\t \t Not accepted\n");
2919 return;
2920 }
2921 }
2922 }
2923
7d306daf 2924 // Check if the particle is isolated or if we want to take the isolation into account
2925 if(OnlyIsolated() && !particle->IsIsolated()) return;
2926
2927 Float_t pt = particle->Pt();
2928 fhPtInput->Fill(pt);
2929
547c2f01 2930 // Check if trigger is in fiducial region
2931 if(IsFiducialCutOn())
2932 {
2933 Bool_t in = GetFiducialCut()->IsInFiducialCut(*particle->Momentum(),particle->GetDetector()) ;
2934 if(! in ) return ;
9623bf34 2935 }
547c2f01 2936
7d306daf 2937 fhPtFidCut->Fill(pt);
2938
547c2f01 2939 // Make correlation with charged hadrons
045396c8 2940 Bool_t okcharged = kTRUE;
2941 Bool_t okneutral = kTRUE;
547c2f01 2942 if(GetReader()->IsCTSSwitchedOn() )
2943 {
045396c8 2944 okcharged = MakeChargedCorrelation(particle, GetCTSTracks(),kTRUE);
547c2f01 2945 if(IsDataMC())
2946 {
045396c8 2947 MakeMCChargedCorrelation(particle);
2948 }
a5f1e836 2949 }
2950
e09cf5ef 2951 TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); //For the future, foresee more possible pi0 lists
547c2f01 2952 if(fNeutralCorr && pi0list)
2953 {
a5f1e836 2954 if(pi0list->GetEntriesFast() > 0)
2955 okneutral = MakeNeutralCorrelation(particle, pi0list,kTRUE);
2956 }
e09cf5ef 2957
045396c8 2958 // Fill leading particle histogram if correlation went well and
2959 // no problem was found, like not absolute leading, or bad vertex in mixing.
547c2f01 2960 if(okcharged && okneutral)
2961 {
7d306daf 2962 fhPtLeading->Fill(pt);
d0b625bc 2963 fhPtLeadingBin->Fill(pt,GetEventMixBin());
7d306daf 2964 if(fCorrelVzBin) fhPtLeadingVzBin->Fill(pt,GetEventVzBin());
17af6e24 2965
2966 if(fFillPileUpHistograms)
2967 {
cc944149 2968 Int_t vtxBC = GetReader()->GetVertexBC();
2969 if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtLeadingVtxBC0->Fill(pt);
2970
17af6e24 2971 if(GetReader()->IsPileUpFromSPD()) fhPtLeadingPileUp[0]->Fill(pt);
2972 if(GetReader()->IsPileUpFromEMCal()) fhPtLeadingPileUp[1]->Fill(pt);
2973 if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtLeadingPileUp[2]->Fill(pt);
2974 if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtLeadingPileUp[3]->Fill(pt);
2975 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtLeadingPileUp[4]->Fill(pt);
2976 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtLeadingPileUp[5]->Fill(pt);
2977 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtLeadingPileUp[6]->Fill(pt);
2978 }
2979
045396c8 2980 Float_t phi = particle->Phi();
2981 if(phi<0)phi+=TMath::TwoPi();
68cd2624 2982 fhPhiLeading->Fill(pt, phi);
2983
2984 fhEtaLeading->Fill(pt, particle->Eta());
283f989c 2985 //printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Leading particle : pt %f, eta %f, phi %f\n",particle->Pt(),particle->Eta(),phi);
68cd2624 2986
764ab1f4 2987 if(IsDataMC())
2988 {
b1f720a7 2989 Int_t mcIndex = GetMCTagHistogramIndex(particle->GetTag());
2990 fhPtLeadingMC[mcIndex]->Fill(pt);
764ab1f4 2991 }
c8710850 2992
68cd2624 2993 fhPtLeadingCentrality ->Fill(pt,cen);
2994 fhPtLeadingEventPlane ->Fill(pt,ep);
2995 fhLeadingEventPlaneCentrality->Fill(cen,ep);
2996
045396c8 2997 }//ok charged && neutral
e09cf5ef 2998 }//Aod branch loop
2999
045396c8 3000 //Reinit for next event
3001 fLeadingTriggerIndex = -1;
e09cf5ef 3002
045396c8 3003 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - End fill histograms \n");
e09cf5ef 3004}
3005
c5693f62 3006//___________________________________________________________________________________________________________
045396c8 3007Bool_t AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle,
22ad7981 3008 const TObjArray* pl, Bool_t bFillHisto)
e09cf5ef 3009{
3010 // Charged Hadron Correlation Analysis
283f989c 3011 if(GetDebug() > 1)
3012 printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Make trigger particle - charged hadron correlation \n");
907b38cd 3013
3014 Float_t phiTrig = aodParticle->Phi();
3015 Float_t etaTrig = aodParticle->Eta();
3016 Float_t ptTrig = aodParticle->Pt();
3017 Bool_t decay = aodParticle->IsTagged();
b1f720a7 3018 Int_t mcTag = aodParticle->GetTag();
fedea415 3019 Double_t bz = GetReader()->GetInputEvent()->GetMagneticField();
3020
907b38cd 3021 Float_t pt = -100. ;
3022 Float_t zT = -100. ;
3023 Float_t xE = -100. ;
3024 Float_t hbpXE = -100. ;
3025 Float_t hbpZT = -100. ;
3026 Float_t phi = -100. ;
3027 Float_t eta = -100. ;
3028 Float_t pout = -100. ;
3029 Float_t deltaPhi = -100. ;
f7408d50 3030 Float_t ptLeadHad = -100 ;
3031 Float_t phiLeadHad = -100 ;
e09cf5ef 3032
907b38cd 3033 TVector3 p3;
3034 TLorentzVector photonMom ;
3035 TObjArray * reftracks = 0x0;
3036 Int_t nrefs = 0;
3037 Int_t nTracks = GetCTSTracks()->GetEntriesFast() ;
3038
3039 // Mixed event settings
3040 Int_t evtIndex11 = -1 ; // cluster trigger or pi0 trigger
045396c8 3041 Int_t evtIndex12 = -1 ; // pi0 trigger
3042 Int_t evtIndex13 = -1 ; // charged trigger
045396c8 3043
3044 Double_t v[3] = {0,0,0}; //vertex ;
e09cf5ef 3045 GetReader()->GetVertex(v);
e09cf5ef 3046
04f7a616 3047 if (GetMixedEvent())
3048 {
e09cf5ef 3049 evtIndex11 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(0)) ;
3050 evtIndex12 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(1)) ;
3051 evtIndex13 = GetMixedEvent()->EventIndex(aodParticle->GetTrackLabel(0)) ;
3052 }
3053
907b38cd 3054 // In case of pi0/eta trigger, we may want to check their decay correlation,
3055 // get their decay children
3056 TLorentzVector decayMom1;
3057 TLorentzVector decayMom2;
3058 Bool_t decayFound = kFALSE;
3059 if(fPi0Trigger && bFillHisto) decayFound = GetDecayPhotonMomentum(aodParticle,decayMom1, decayMom2);
3060
3061 //-----------------------------------------------------------------------
f7408d50 3062 // Track loop, select tracks with good pt, phi and fill AODs or histograms
907b38cd 3063 //-----------------------------------------------------------------------
3064
f7408d50 3065 // select events where the leading particle in the opposite hemisphere to the trigger particle is
3066 // is in a window centered at 180 from the trigger
3067 // Find the leading hadron
3068 if(fSelectLeadingHadronAngle)
3069 {
3070 for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ )
3071 {
3072 AliVTrack * track = (AliVTrack *) (pl->At(ipr)) ;
3073 Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
3074 p3.SetXYZ(mom[0],mom[1],mom[2]);
3075 pt = p3.Pt();
3076 phi = p3.Phi() ;
3077
3078 if(pt > ptLeadHad && TMath::Abs(phi-phiTrig) > TMath::PiOver2())
3079 {
3080 ptLeadHad = pt ;
3081 phiLeadHad = phi;
3082 }
3083
3084 }// track loop
3085
3086 if( ptLeadHad < fMinLeadHadPt ||
3087 ptLeadHad > fMaxLeadHadPt ) return kFALSE;
3088
3089 if( TMath::Abs(phiLeadHad-phiTrig) < fMinLeadHadPhi ||
3090 TMath::Abs(phiLeadHad-phiTrig) > fMaxLeadHadPhi ) return kFALSE;
3091
3092 }// select leading hadron
3093
547c2f01 3094 for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ )
3095 {
e09cf5ef 3096 AliVTrack * track = (AliVTrack *) (pl->At(ipr)) ;
045396c8 3097
e09cf5ef 3098 Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
3099 p3.SetXYZ(mom[0],mom[1],mom[2]);
3100 pt = p3.Pt();
e09cf5ef 3101 eta = p3.Eta();
3102 phi = p3.Phi() ;
3103 if(phi < 0) phi+=TMath::TwoPi();
045396c8 3104
e09cf5ef 3105 //Select only hadrons in pt range
66e64043 3106 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
3107
e09cf5ef 3108 //remove trigger itself for correlation when use charged triggers
3109 if( track->GetID() == aodParticle->GetTrackLabel(0) || track->GetID() == aodParticle->GetTrackLabel(1) ||
66e64043 3110 track->GetID() == aodParticle->GetTrackLabel(2) || track->GetID() == aodParticle->GetTrackLabel(3) )
045396c8 3111 continue ;
3112
045396c8 3113 //jump out this event if near side associated particle pt larger than trigger
3f150b4b 3114 if (fMakeNearSideLeading)
547c2f01 3115 {
3f150b4b 3116 if(pt > ptTrig && TMath::Abs(phi-phiTrig) < TMath::PiOver2()) return kFALSE;
3117 }
3118 //jump out this event if there is any other particle with pt larger than trigger
3119 else if(fMakeAbsoluteLeading)
3120 {
3121 if(pt > ptTrig) return kFALSE;
045396c8 3122 }
f7408d50 3123
045396c8 3124 //Only for mixed event
3125 Int_t evtIndex2 = 0 ;
04f7a616 3126 if (GetMixedEvent())
3127 {
045396c8 3128 evtIndex2 = GetMixedEvent()->EventIndex(track->GetID()) ;
3129 if (evtIndex11 == evtIndex2 || evtIndex12 == evtIndex2 || evtIndex13 == evtIndex2 ) // photon and track from different events
3130 continue ;
3131 //vertex cut
3132 if (TMath::Abs(GetVertex(evtIndex2)[2]) > GetZvertexCut())
3133 return kFALSE;
3134 }
3135
045396c8 3136 // Fill Histograms
3f150b4b 3137 if(bFillHisto)
907b38cd 3138 {
66e64043 3139
283f989c 3140 if(GetDebug() > 2 )
3141 printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Selected charge for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta);
907b38cd 3142
3143 // Set the pt associated bin for the defined bins
3144 Int_t assocBin = -1;
3145 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
547c2f01 3146 {
907b38cd 3147 if(pt > fAssocPtBinLimit[i] && pt < fAssocPtBinLimit[i+1]) assocBin= i;
3148 }
66e64043 3149
8cc41381 3150 // Assign to the histogram array a bin corresponding to a combination of pTa and vz bins
7d306daf 3151 Int_t nz = 1;
3152 Int_t vz = 0;
3153
3154 if(fCorrelVzBin)
3155 {
3156 nz = GetNZvertBin();
3157 vz = GetEventVzBin();
3158 }
3159
3160 Int_t bin = assocBin*nz+vz;
3161
8cc41381 3162 //printf("assoc Bin = %d, vZ bin = %d, bin = %d \n", assocBin,GetEventVzBin(),bin);
3163
fedea415 3164 ULong_t status = track->GetStatus();
3165 Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
3166 //Double32_t tof = track->GetTOFsignal()*1e-3;
3167 Int_t trackBC = track->GetTOFBunchCrossing(bz);
3168
2a9171b5 3169 Int_t outTOF = -1;
3170 if (okTOF && trackBC!=0) outTOF = 1;
3171 else if(okTOF && trackBC==0) outTOF = 0;
fedea415 3172
907b38cd 3173 // Azimuthal Angle
3174 // calculate deltaPhi for later, shift when needed
8cc41381 3175 FillChargedAngularCorrelationHistograms(pt, ptTrig, bin, phi, phiTrig, deltaPhi,
fedea415 3176 eta, etaTrig, decay, track->GetHMPIDsignal(),outTOF,nTracks,mcTag);
05d0d05d 3177
907b38cd 3178 // Imbalance zT/xE/pOut
3179 zT = pt/ptTrig ;
f16872ec 3180 if(zT > 0 ) hbpZT = TMath::Log(1./zT);
907b38cd 3181 else hbpZT =-100;
e09cf5ef 3182
907b38cd 3183 xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
3184 //if(xE <0.)xE =-xE;
f16872ec 3185 if(xE > 0 ) hbpXE = TMath::Log(1./xE);
907b38cd 3186 else hbpXE =-100;
3187
3188 pout = pt*TMath::Sin(deltaPhi) ;
66e64043 3189
907b38cd 3190 //delta phi cut for momentum imbalance correlation
18838011 3191 if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
547c2f01 3192 {
3f150b4b 3193
727a309a 3194 FillChargedMomentumImbalanceHistograms(ptTrig, pt, xE, hbpXE, zT, hbpZT, pout, deltaPhi,
fedea415 3195 nTracks, track->Charge(), bin, decay,outTOF,mcTag);
3f150b4b 3196
18838011 3197 }
3198
fedea415 3199 if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
547c2f01 3200 { //UE study
3f150b4b 3201
fedea415 3202 FillChargedUnderlyingEventHistograms(ptTrig, pt, deltaPhi, nTracks,outTOF);
9623bf34 3203
d0b625bc 3204 fhUePart->Fill(ptTrig);
3f150b4b 3205
907b38cd 3206 }
e09cf5ef 3207
907b38cd 3208 if(fPi0Trigger && decayFound)
3209 FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2, kTRUE) ;
e09cf5ef 3210
3211 //several UE calculation
8cc41381 3212 if(fMakeSeveralUE) FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,deltaPhi);
907b38cd 3213
e09cf5ef 3214 } //Fill histogram
547c2f01 3215 else
3216 {
e09cf5ef 3217 nrefs++;
547c2f01 3218 if(nrefs==1)
3219 {
e09cf5ef 3220 reftracks = new TObjArray(0);
045396c8 3221 TString trackname = Form("%s+Tracks", GetAODObjArrayName().Data());
3222 reftracks->SetName(trackname.Data());
029dea5a 3223 reftracks->SetOwner(kFALSE);
e09cf5ef 3224 }
029dea5a 3225
e09cf5ef 3226 reftracks->Add(track);
029dea5a 3227
e09cf5ef 3228 }//aod particle loop
3229 }// track loop
3230
3231 //Fill AOD with reference tracks, if not filling histograms
547c2f01 3232 if(!bFillHisto && reftracks)
3233 {
e09cf5ef 3234 aodParticle->AddObjArray(reftracks);
3235 }
283f989c 3236
029dea5a 3237 //Own mixed event, add event and remove previous or fill the mixed histograms
2e876d85 3238 if(DoOwnMix() && bFillHisto)
029dea5a 3239 {
3240 MakeChargedMixCorrelation(aodParticle);
3241 }
3242
045396c8 3243 return kTRUE;
e09cf5ef 3244
3245}
3246
029dea5a 3247
7ed3a248 3248//_________________________________________________________________________________________________________
3249void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4ParticleCorrelation *aodParticle)
029dea5a 3250{
2e876d85 3251 // Mix current trigger with tracks in another MB event
029dea5a 3252
2e876d85 3253 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Make trigger particle - charged hadron mixed event correlation \n");
029dea5a 3254
3255 if(GetMixedEvent()) return; // This is not the mixed event from general mixing frame
3256
029dea5a 3257 // Get the event with similar caracteristics
2e876d85 3258 //printf("MakeChargedMixCorrelation for %s\n",GetInputAODName().Data());
3259
3260 AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
c52aeef5 3261
2e876d85 3262 AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
c52aeef5 3263
3264 if(!inputHandler) return;
3265
2e876d85 3266 if(!(inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask())) return;
7ed3a248 3267
029dea5a 3268 // Get the pool, check if it exits
2e876d85 3269 Int_t eventBin = GetEventMixBin();
3270
3271 fhEventBin->Fill(eventBin);
029dea5a 3272
2e876d85 3273 //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
3274 if(eventBin < 0) return;
029dea5a 3275
d07ffd54 3276 TList * pool = 0;
3277 TList * poolCalo = 0;
3278 if(fUseMixStoredInReader)
3279 {
3280 pool = GetReader()->GetListWithMixedEventsForTracks(eventBin);
2bb7ac98 3281 if(OnlyIsolated() || fFillNeutralEventMixPool) poolCalo = GetReader()->GetListWithMixedEventsForCalo (eventBin);
d07ffd54 3282 }
3283 else
3284 {
3285 pool = fListMixTrackEvents[eventBin];
2bb7ac98 3286 if(OnlyIsolated() || fFillNeutralEventMixPool) poolCalo = fListMixCaloEvents [eventBin];
d07ffd54 3287 }
3288
2e876d85 3289 if(!pool) return ;
029dea5a 3290
2bb7ac98 3291 if((OnlyIsolated() || fFillNeutralEventMixPool ) && !poolCalo &&
d07ffd54 3292 (GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::AliIsolationCut::kOnlyCharged))
3293 printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Careful, cluster pool not available\n");
3294
029dea5a 3295 Double_t ptTrig = aodParticle->Pt();
3296 Double_t etaTrig = aodParticle->Eta();
3297 Double_t phiTrig = aodParticle->Phi();
3298 if(phiTrig < 0.) phiTrig+=TMath::TwoPi();
3299
2e876d85 3300 if(GetDebug() > 1)
283f989c 3301 printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Pool bin %d size %d, leading trigger pt=%f, phi=%f, eta=%f\n",
3302 eventBin,pool->GetSize(), ptTrig,phiTrig,etaTrig);
029dea5a 3303
3304 Double_t ptAssoc = -999.;
2e876d85 3305 Double_t phiAssoc = -999.;
029dea5a 3306 Double_t etaAssoc = -999.;
3307 Double_t deltaPhi = -999.;
3308 Double_t deltaEta = -999.;
08f220c8 3309 Double_t xE = -999.;
3310 Double_t hbpXE = -999.;
3311
2e876d85 3312 //Start from first event in pool except if in this same event the pool was filled
283f989c 3313 Int_t ev0 = 0;
3314 if(GetReader()->GetLastTracksMixedEvent() == GetEventNumber()) ev0 = 1;
7ed3a248 3315
283f989c 3316 for(Int_t ev=ev0; ev < pool->GetSize(); ev++)
029dea5a 3317 {
3318 TObjArray* bgTracks = static_cast<TObjArray*>(pool->At(ev));
2bb7ac98 3319 TObjArray* bgCalo = 0;
3320
7ed3a248 3321 // Check if the particle is isolated in the mixed event, it not, do not fill the histograms
5a951426 3322 if((OnlyIsolated() || fFillNeutralEventMixPool) && poolCalo)
7ed3a248 3323 {
d07ffd54 3324 if(pool->GetSize()!=poolCalo->GetSize())
3325 printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Different size of calo and track pools\n");
3326
2bb7ac98 3327 bgCalo = static_cast<TObjArray*>(poolCalo->At(ev));
d07ffd54 3328
3329 if(!bgCalo)
3330 printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Event %d in calo pool not available?\n",ev);
3331
152c5ca9 3332 if(OnlyIsolated())
2bb7ac98 3333 {
3334 Int_t n=0; Int_t nfrac = 0; Bool_t isolated = kFALSE; Float_t coneptsum = 0;
3335 GetIsolationCut()->MakeIsolationCut(bgTracks,bgCalo,
3336 GetReader(), GetCaloPID(),
3337 kFALSE, aodParticle, "",
3338 n,nfrac,coneptsum, isolated);
3339
3340 //printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Isolated? %d - cone %f, ptthres %f",
3341 // isolated,GetIsolationCut()->GetConeSize(),GetIsolationCut()->GetPtThreshold());
3342 //if(bgTracks)printf(" - n track %d", bgTracks->GetEntriesFast());
3343 //printf("\n");
3344
3345 if(!isolated) continue ;
3346 }
7ed3a248 3347 }
3348
2e876d85 3349 fhEventMixBin->Fill(eventBin);
029dea5a 3350
2e876d85 3351 Int_t nTracks=bgTracks->GetEntriesFast();
3352 //printf("\t Read Pool event %d, nTracks %d\n",ev,nTracks);
3353
d0b625bc 3354 //Check if it is leading if mixed event
3355 if(fMakeNearSideLeading || fMakeAbsoluteLeading)
3356 {
3357 Bool_t leading = kTRUE;
3358 for(Int_t jlead = 0;jlead <nTracks; jlead++ )
3359 {
3360 AliAODPWG4Particle *track = (AliAODPWG4Particle*) bgTracks->At(jlead) ;
3361
3362 ptAssoc = track->Pt();
3363 phiAssoc = track->Phi() ;
3364
3365 if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
d0b625bc 3366 if (fMakeNearSideLeading)
3367 {
3368 if(ptAssoc > ptTrig && TMath::Abs(phiAssoc-phiTrig) < TMath::PiOver2())
3369 {
3370 leading = kFALSE;
3371 break;
3372 }
3373 }
3374 //jump out this event if there is any other particle with pt larger than trigger
3375 else if(fMakeAbsoluteLeading)
3376 {
3377 if(ptAssoc > ptTrig)
3378 {
3379 leading = kFALSE;
d0b625bc 3380 break;
3381 }
3382 }
3383 }
2bb7ac98 3384
3385 if(fFillNeutralEventMixPool && bgCalo)
3386 {
3387 Int_t nClusters=bgCalo->GetEntriesFast();
3388 TLorentzVector mom ;
3389 for(Int_t jlead = 0;jlead <nClusters; jlead++ )
3390 {
152c5ca9 3391 AliAODPWG4Particle *cluster= (AliAODPWG4Particle*) bgCalo->At(jlead) ;
2bb7ac98 3392
152c5ca9 3393 ptAssoc = cluster->Pt();
3394 phiAssoc = cluster->Phi() ;
2bb7ac98 3395
3396 if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
3397 if (fMakeNearSideLeading)
3398 {
3399 if(ptAssoc > ptTrig && TMath::Abs(phiAssoc-phiTrig) < TMath::PiOver2())
3400 {
3401 leading = kFALSE;
3402 break;
3403 }
3404 }
3405 //jump out this event if there is any other particle with pt larger than trigger
3406 else if(fMakeAbsoluteLeading)
3407 {
3408 if(ptAssoc > ptTrig)
3409 {
3410 leading = kFALSE;
3411 break;
3412 }
3413 }
3414 }
3415 }
3416
d0b625bc 3417 if(!leading) continue; // not leading, check the next event in pool
2bb7ac98 3418
d0b625bc 3419 }
3420
7d306daf 3421 fhPtLeadingMixed ->Fill(ptTrig);
ca17b39f 3422 fhPhiLeadingMixed ->Fill(ptTrig, phiTrig);
3423 fhEtaLeadingMixed ->Fill(ptTrig, etaTrig);
d0b625bc 3424 fhPtLeadingMixedBin->Fill(ptTrig,eventBin);
7d306daf 3425 if(fCorrelVzBin)fhPtLeadingMixedVzBin->Fill(ptTrig, GetEventVzBin());
d0b625bc 3426
029dea5a 3427 for(Int_t j1 = 0;j1 <nTracks; j1++ )
3428 {
3429 AliAODPWG4Particle *track = (AliAODPWG4Particle*) bgTracks->At(j1) ;
3430
3431 if(!track) continue;
3432
3433 ptAssoc = track->Pt();
3434 etaAssoc = track->Eta();
3435 phiAssoc = track->Phi() ;
3436 if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
2e876d85 3437
029dea5a 3438 if(IsFiducialCutOn())
3439 {
3440 Bool_t in = GetFiducialCut()->IsInFiducialCut(*aodParticle->Momentum(),"CTS") ;
3441 if(!in) continue ;
3442 }
3443
3444 deltaPhi = phiTrig-phiAssoc;
3445 if(deltaPhi < -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
3446 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
3447 deltaEta = etaTrig-etaAssoc;
3448
3449 if(GetDebug()>0)
3450 printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation(): deltaPhi= %f, deltaEta=%f\n",deltaPhi, deltaEta);
3451
3452 // Set the pt associated bin for the defined bins
3453 Int_t assocBin = -1;
3454 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
3455 {
3456 if(ptAssoc > fAssocPtBinLimit[i] && ptAssoc < fAssocPtBinLimit[i+1]) assocBin= i;
3457 }
3458
8cc41381 3459 // Assign to the histogram array a bin corresponding to a combination of pTa and vz bins
7d306daf 3460 Int_t nz = 1;
3461 Int_t vz = 0;
3462
3463 if(fCorrelVzBin)
3464 {
3465 nz = GetNZvertBin();
3466 vz = GetEventVzBin();
3467 }
3468
3469 Int_t bin = assocBin*nz+vz;
8cc41381 3470
029dea5a 3471 fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi);
3472 fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta);
3473
08f220c8 3474 fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi);
3475 fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta);
3476
3477 xE =-ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
3478 //if(xE <0.)xE =-xE;
3479 if(xE > 0 ) hbpXE = TMath::Log(1./xE);
3480 else hbpXE =-100;
3481
18838011 3482 if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
08f220c8 3483 {
7d306daf 3484 fhMixXECharged->Fill(ptTrig,xE);
3485 fhMixHbpXECharged->Fill(ptTrig,hbpXE);
08f220c8 3486 }
18838011 3487
3488 if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
3489 {
3490 //Underlying event region
3491 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
3492 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
3493
3494 if(uexE < 0.) uexE = -uexE;
3495
3496 fhMixXEUeCharged->Fill(ptTrig,uexE);
3497 }
3498
8cc41381 3499 if(bin < 0) continue ; // this pt bin was not considered
029dea5a 3500
2013f378 3501 if(TMath::Abs(deltaEta) > 0.8)
8cc41381 3502 fhMixDeltaPhiChargedAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi);
03a96401 3503 if(TMath::Abs(deltaEta) < 0.01)
8cc41381 3504 fhMixDeltaPhiChargedAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi);
2013f378 3505
8cc41381 3506 fhMixDeltaPhiChargedAssocPtBin [bin]->Fill(ptTrig, deltaPhi);
3507 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->Fill(deltaPhi, deltaEta);
029dea5a 3508
3509 } // track loop
3510 } // mixed event loop
3511}
3512
3513
05d0d05d 3514//________________________________________________________________________________________________________________
045396c8 3515Bool_t AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4ParticleCorrelation * const aodParticle,
22ad7981 3516 const TObjArray* pi0list, Bool_t bFillHisto)
e09cf5ef 3517{
3518 // Neutral Pion Correlation Analysis
907b38cd 3519 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Make trigger particle - pi0 correlation, %d pi0's \n",
3520 pi0list->GetEntriesFast());
e09cf5ef 3521
3522 Int_t evtIndex11 = 0 ;
3523 Int_t evtIndex12 = 0 ;
04f7a616 3524 if (GetMixedEvent())
3525 {
e09cf5ef 3526 evtIndex11 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(0)) ;
3527 evtIndex12 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(1)) ;
3528 }
3529
907b38cd 3530 Float_t pt = -100. ;
4b58c519 3531// Float_t zT = -100. ;
907b38cd 3532 Float_t phi = -100. ;
3533 Float_t eta = -100. ;
3534 Float_t xE = -100. ;
3535 Float_t hbpXE= -100. ;
37bd27d6 3536 //Float_t hbpZT= -100. ;
907b38cd 3537
3538 Float_t ptTrig = aodParticle->Pt();
3539 Float_t phiTrig = aodParticle->Phi();
3540 Float_t etaTrig = aodParticle->Eta();
3541 Float_t deltaPhi= -100. ;
3f150b4b 3542
045396c8 3543 TLorentzVector photonMom ;
3544
907b38cd 3545 // In case of pi0/eta trigger, we may want to check their decay correlation,
3546 // get their decay children
3547 TLorentzVector decayMom1;
3548 TLorentzVector decayMom2;
3549 Bool_t decayFound = kFALSE;
3550 if(fPi0Trigger && bFillHisto) decayFound = GetDecayPhotonMomentum(aodParticle,decayMom1, decayMom2);
e09cf5ef 3551
907b38cd 3552 TObjArray * refpi0 = 0x0;
3553 Int_t nrefs = 0;
e09cf5ef 3554
3555 //Loop on stored AOD pi0
547c2f01 3556
e09cf5ef 3557 Int_t naod = pi0list->GetEntriesFast();
045396c8 3558 if(GetDebug() > 0)
3559 printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillHistograms() - aod branch entries %d\n", naod);
547c2f01 3560
3561 for(Int_t iaod = 0; iaod < naod ; iaod++)
3562 {
e09cf5ef 3563 AliAODPWG4Particle* pi0 = (AliAODPWG4Particle*) (pi0list->At(iaod));
3564
3565 Int_t evtIndex2 = 0 ;
3566 Int_t evtIndex3 = 0 ;
04f7a616 3567 if (GetMixedEvent())
3568 {
e09cf5ef 3569 evtIndex2 = GetMixedEvent()->EventIndexForCaloCluster(pi0->GetCaloLabel(0)) ;
3570 evtIndex3 = GetMixedEvent()->EventIndexForCaloCluster(pi0->GetCaloLabel(1)) ;
3571
045396c8 3572 if (evtIndex11 == evtIndex2 || evtIndex12 == evtIndex2 ||
3573 evtIndex11 == evtIndex3 || evtIndex12 == evtIndex3) // trigger and pi0 are not from different events
e09cf5ef 3574 continue ;
3575 }
907b38cd 3576
e09cf5ef 3577 pt = pi0->Pt();
907b38cd 3578
66e64043 3579 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
3580
907b38cd 3581 //jump out this event if near side associated particle pt larger than trigger
3582 if (fMakeNearSideLeading)
3583 {
3584 if(pt > ptTrig && TMath::Abs(phi-phiTrig) < TMath::PiOver2()) return kFALSE;
3585 }
3586 //jump out this event if there is any other particle with pt larger than trigger
3587 else if(fMakeAbsoluteLeading)
3588 {
3589 if(pt > ptTrig) return kFALSE;
3590 }
e09cf5ef 3591
547c2f01 3592 if(bFillHisto)
3593 {
e09cf5ef 3594 phi = pi0->Phi() ;
3595 eta = pi0->Eta() ;
907b38cd 3596
3597 FillNeutralAngularCorrelationHistograms(pt, ptTrig, phi, phiTrig, deltaPhi, eta, etaTrig);
3598
4b58c519 3599 //zT = pt/ptTrig ;
3f150b4b 3600 xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
3601
66e64043 3602 //if(xE <0.)xE =-xE;
e09cf5ef 3603
3f150b4b 3604 hbpXE = -100;
37bd27d6 3605 //hbpZT = -100;
907b38cd 3606
f16872ec 3607 if(xE > 0 ) hbpXE = TMath::Log(1./xE);
37bd27d6 3608 //if(zT > 0 ) hbpZT = TMath::Log(1./zT);
e09cf5ef 3609
907b38cd 3610 if(fPi0Trigger && decayFound)
3611 FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2,kFALSE) ;
e09cf5ef 3612
3613 //delta phi cut for correlation
547c2f01 3614 if( (deltaPhi > fDeltaPhiMinCut) && ( deltaPhi < fDeltaPhiMaxCut) )
3615 {
045396c8 3616 fhDeltaPhiNeutralPt->Fill(pt,deltaPhi);
3f150b4b 3617 fhXENeutral ->Fill(ptTrig,xE);
3618 fhPtHbpXENeutral ->Fill(ptTrig,hbpXE);
e09cf5ef 3619 }
907b38cd 3620 else if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
547c2f01 3621 {
045396c8 3622 fhDeltaPhiUeNeutralPt->Fill(pt,deltaPhi);
3f150b4b 3623 fhXEUeNeutral ->Fill(ptTrig,xE);
3624 fhPtHbpXEUeNeutral ->Fill(ptTrig,hbpXE);
e09cf5ef 3625 }
907b38cd 3626
e09cf5ef 3627 //several UE calculation
8cc41381 3628 if(fMakeSeveralUE) FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,deltaPhi);
907b38cd 3629
e09cf5ef 3630 }
547c2f01 3631 else
3632 {
e09cf5ef 3633 nrefs++;
547c2f01 3634 if(nrefs==1)
3635 {
e09cf5ef 3636 refpi0 = new TObjArray(0);
3637 refpi0->SetName(GetAODObjArrayName()+"Pi0s");
3638 refpi0->SetOwner(kFALSE);
3639 }
3640 refpi0->Add(pi0);
3641 }//put references in trigger AOD
045396c8 3642
3643 if(GetDebug() > 2 )
3644 printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Selected neutral for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta);
3645
3646 }//loop
3647
3648 return kTRUE;
3649}
3650
05d0d05d 3651//_________________________________________________________________________________________________________
045396c8 3652void AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle)
d07cdf32 3653{
045396c8 3654 // Charged Hadron Correlation Analysis with MC information
a426f453 3655
d07cdf32 3656 if ( GetDebug() > 1 )
3657 AliInfo("Make trigger particle - charged hadron correlation in AOD MC level");
045396c8 3658
3659 AliStack * stack = 0x0 ;
d07cdf32 3660 TParticle * primary = 0x0 ;
045396c8 3661 TClonesArray * mcparticles = 0x0 ;
d07cdf32 3662 AliAODMCParticle * aodprimary = 0x0 ;
045396c8 3663
3664 Double_t eprim = 0 ;
3665 Double_t ptprim = 0 ;
3666 Double_t phiprim = 0 ;
3667 Double_t etaprim = 0 ;
d07cdf32 3668 Int_t nTracks = 0 ;
045396c8 3669 Int_t iParticle = 0 ;
a9023d3b 3670
d07cdf32 3671 Bool_t lead = kFALSE;
045396c8 3672
3673 Int_t label= aodParticle->GetLabel();
d07cdf32 3674 if( label < 0 )
a426f453 3675 {
d07cdf32 3676 if( GetDebug() > 0 ) AliInfo(Form(" *** bad label ***: label %d", label));
045396c8 3677 return;
d07cdf32 3678 }
045396c8 3679
d07cdf32 3680 if( GetReader()->ReadStack() )
547c2f01 3681 {
045396c8 3682 stack = GetMCStack() ;
d07cdf32 3683 if(!stack)
2e876d85 3684 {
d07cdf32 3685 AliFatal("Stack not available, is the MC handler called? STOP");
3686 return;
045396c8 3687 }
3688
d07cdf32 3689 //nTracks = stack->GetNtrack() ;
3690 nTracks = stack->GetNprimary();
3691 if( label >= stack->GetNtrack() )
547c2f01 3692 {
d07cdf32 3693 if(GetDebug() > 2)
3694 AliInfo(Form("*** large label ***: label %d, n tracks %d", label, stack->GetNtrack()));
045396c8 3695 return ;
3696 }
547c2f01 3697
045396c8 3698 primary = stack->Particle(label);
d07cdf32 3699 if ( !primary )
547c2f01 3700 {
d07cdf32 3701 AliInfo(Form(" *** no primary ***: label %d", label));
045396c8 3702 return;
3703 }
3704
d07cdf32 3705 eprim = primary->Energy();
3706 ptprim = primary->Pt();
3707 phiprim = primary->Phi();
3708 etaprim = primary->Eta();
3709
3710 if(ptprim < 0.01 || eprim < 0.01) return ;
3711
3712 for (iParticle = 0 ; iParticle < nTracks ; iParticle++)
547c2f01 3713 {
d07cdf32 3714 TParticle * particle = stack->Particle(iParticle);
3715 TLorentzVector momentum;
2747966a 3716
d07cdf32 3717 //keep only final state particles
3718 if( particle->GetStatusCode() != 1 ) continue ;
a9023d3b 3719
d07cdf32 3720 if ( particle->Pt() < GetReader()->GetCTSPtMin()) continue;
3721
3722 //---------- Charged particles ----------------------
3723 Int_t pdg = particle->GetPdgCode();
3724 Int_t charge = (Int_t) TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
3725 if(charge == 0) continue;
3726
3727 particle->Momentum(momentum);
3728
3729 //Particles in CTS acceptance, make sure to use the same selection as in the reader
3730 Bool_t inCTS = GetReader()->GetFiducialCut()->IsInFiducialCut(momentum,"CTS");
3731 //printf("Accepted? %d; pt %2.2f, eta %2.2f, phi %2.2f\n",inCTS,momentum.Pt(),momentum.Eta(),momentum.Phi()*TMath::RadToDeg());
3732 if( !inCTS ) continue;
3733
3734 // Remove conversions
3735 if ( TMath::Abs(pdg) == 11 && stack->Particle(particle->GetFirstMother())->GetPdgCode() == 22 ) continue ;
3736
3737 if ( label == iParticle ) continue; // avoid trigger particle
3738
3739 lead = FillChargedMCCorrelationHistograms(particle->Pt(),particle->Phi(),particle->Eta(),ptprim,phiprim,etaprim);
3740 if ( !lead ) return;
3741
3742 } //track loop
3743
045396c8 3744 } //ESD MC
a9023d3b 3745
d07cdf32 3746 else if( GetReader()->ReadAODMCParticles() )
547c2f01 3747 {
045396c8 3748 //Get the list of MC particles
d07cdf32 3749 mcparticles = GetReader()->GetAODMCParticles();
3750 if( !mcparticles ) return;
a9023d3b 3751
d07cdf32 3752 nTracks = mcparticles->GetEntriesFast() ;
3753
3754 if( label >= nTracks )
547c2f01 3755 {
d07cdf32 3756 if(GetDebug() > 2)
3757 AliInfo(Form(" *** large label ***: label %d, n tracks %d", label,nTracks));
045396c8 3758 return;
3759 }
a9023d3b 3760
045396c8 3761 //Get the particle
d07cdf32 3762 aodprimary = (AliAODMCParticle*) mcparticles->At(label);
3763 if( !aodprimary )
547c2f01 3764 {
d07cdf32 3765 AliInfo(Form(" *** no AOD primary ***: label %d", label));
045396c8 3766 return;
3767 }
a9023d3b 3768
d07cdf32 3769 ptprim = aodprimary->Pt();
3770 phiprim = aodprimary->Phi();
3771 etaprim = aodprimary->Eta();
3772 eprim = aodprimary->E();
3773
3774 if(ptprim < 0.01 || eprim < 0.01) return ;
3775
3776 for (iParticle = 0; iParticle < nTracks; iParticle++)
547c2f01 3777 {
d07cdf32 3778 AliAODMCParticle *part = (AliAODMCParticle*) mcparticles->At(iParticle);
a9023d3b 3779
d07cdf32 3780 if (!part->IsPhysicalPrimary() ) continue; // same as part->GetStatus() !=1
2747966a 3781
d07cdf32 3782 if ( part->Charge() == 0 ) continue;
a9023d3b 3783
d07cdf32 3784 if ( part->Pt() < GetReader()->GetCTSPtMin()) continue;
3785
3786 TLorentzVector momentum(part->Px(),part->Py(),part->Pz(),part->E());
3787
3788 //Particles in CTS acceptance, make sure to use the same selection as in the reader
3789 Bool_t inCTS = GetReader()->GetFiducialCut()->IsInFiducialCut(momentum,"CTS");
3790 //printf("Accepted? %d; pt %2.2f, eta %2.2f, phi %2.2f\n",inCTS,momentum.Pt(),momentum.Eta(),momentum.Phi()*TMath::RadToDeg());
3791 if( !inCTS ) continue;
3792
3793 // Remove conversions
3794 Int_t indexmother = part->GetMother();
3795 if ( indexmother > -1 )
a9023d3b 3796 {
d07cdf32 3797 Int_t pdg = part->GetPdgCode();
3798 Int_t mPdg = ((AliAODMCParticle*) mcparticles->At(indexmother)) ->GetPdgCode();
3799 if (TMath::Abs(pdg) == 11 && mPdg == 22) continue;
a9023d3b 3800 }
d07cdf32 3801
3802 if ( label == iParticle ) continue; // avoid trigger particle
3803
3804 lead = FillChargedMCCorrelationHistograms(part->Pt(),part->Phi(),part->Eta(),ptprim,phiprim,etaprim);
3805 if ( !lead ) return;
3806
3807 } //MC particle loop
045396c8 3808 }// AOD MC
d07cdf32 3809
3810 // Leading MC particle histograms
3811 if (lead)
3812 {
3813 fhMCPtLeading ->Fill(ptprim);
3814 fhMCPhiLeading->Fill(ptprim,phiprim);
3815 fhMCEtaLeading->Fill(ptprim,etaprim);
3816 }
e09cf5ef 3817}
045396c8 3818
05d0d05d 3819//_____________________________________________________________________
3820void AliAnaParticleHadronCorrelation::Print(const Option_t * opt) const
3821{
3822
3823 //Print some relevant parameters set for the analysis
3824 if(! opt)
3825 return;
3826
3827 printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
745913ae 3828 AliAnaCaloTrackCorrBaseClass::Print(" ");
66e64043 3829 printf("Pt trigger > %3.2f\n", fMinTriggerPt) ;
3830 printf("Pt associated hadron < %3.2f\n", fMaxAssocPt) ;
3831 printf("Pt associated hadron > %3.2f\n", fMinAssocPt) ;
3832 printf("Phi trigger particle-Hadron < %3.2f\n", fDeltaPhiMaxCut) ;
3833 printf("Phi trigger particle-Hadron > %3.2f\n", fDeltaPhiMinCut) ;
3834 printf("Phi trigger particle-UeHadron < %3.2f\n", fUeDeltaPhiMaxCut) ;
3835 printf("Phi trigger particle-UeHadron > %3.2f\n", fUeDeltaPhiMinCut) ;
3836 printf("Isolated Trigger? %d\n" , fSelectIsolated) ;
3837 printf("Several UE? %d\n" , fMakeSeveralUE) ;
3838 printf("Name of AOD Pi0 Branch %s \n", fPi0AODBranchName.Data());
05d0d05d 3839 printf("Do Decay-hadron correlation ? %d\n", fPi0Trigger) ;
3f150b4b 3840 printf("Select absolute leading for cluster triggers ? %d or Near Side %d\n",
3841 fMakeAbsoluteLeading, fMakeNearSideLeading) ;
05d0d05d 3842 printf("Trigger pt bins %d\n", fNAssocPtBins) ;
3843 for (Int_t ibin = 0; ibin<fNAssocPtBins; ibin++) {
3844 printf("\t bin %d = [%2.1f,%2.1f]\n", ibin, fAssocPtBinLimit[ibin], fAssocPtBinLimit[ibin+1]) ;
3845 }
3846
3847}
3848
3849//____________________________________________________________
3850void AliAnaParticleHadronCorrelation::SetNAssocPtBins(Int_t n)
045396c8 3851{
3852 // Set number of bins
e09cf5ef 3853
05d0d05d 3854 fNAssocPtBins = n ;
3855
3856
f85f4afb 3857 if(n < 20 && n > 0)
045396c8 3858 {
05d0d05d 3859 fNAssocPtBins = n ;
045396c8 3860 }
3861 else
3862 {
f85f4afb 3863 printf("n = larger than 19 or too small, set to 19 \n");
3864 fNAssocPtBins = 19;
045396c8 3865 }
3866}
e09cf5ef 3867
05d0d05d 3868//______________________________________________________________________________
3869void AliAnaParticleHadronCorrelation::SetAssocPtBinLimit(Int_t ibin, Float_t pt)
045396c8 3870{
3871 // Set the list of limits for the trigger pt bins
3872
05d0d05d 3873 if(ibin <= fNAssocPtBins || ibin >= 0)
045396c8 3874 {
05d0d05d 3875 fAssocPtBinLimit[ibin] = pt ;
045396c8 3876 }
2e876d85 3877 else
3878 {
05d0d05d 3879 printf("AliAnaParticleHadronCorrelation::SetAssocPtBinLimit() - bin number too large %d > %d or small, nothing done\n", ibin, fNAssocPtBins) ;
045396c8 3880 }
3881}
3882