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