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