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