| 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 | |
git://git.uio.no / u / mrichter / AliRoot.git / blame