]>
Commit | Line | Data |
---|---|---|
1c5acb87 | 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 | **************************************************************************/ | |
1c5acb87 | 15 | |
16 | //_________________________________________________________________________ | |
17 | // Class that contains the algorithm for the reconstruction of jet, cone around leading particle | |
18 | // The seed is a backward particle (direct photon) | |
78219bac | 19 | // 1) Take the trigger particle stored in AliAODPWG4ParticleCorrelation, |
1c5acb87 | 20 | // 2) Search for the highest pt leading particle opposite to the photon within a phi, pt window |
21 | // 3) Take all particles around leading in a cone R with pt larger than threshold and construct the jet | |
22 | // | |
23 | // Class created from old AliPHOSGammaJet | |
24 | // (see AliRoot versions previous Release 4-09) | |
25 | // | |
26 | //*-- Author: Gustavo Conesa (LNF-INFN) | |
27 | ////////////////////////////////////////////////////////////////////////////// | |
28 | ||
29 | ||
30 | // --- ROOT system --- | |
31 | #include "TH2F.h" | |
477d6cee | 32 | #include "TClonesArray.h" |
9415d854 | 33 | #include "TClass.h" |
34 | //#include "Riostream.h" | |
1c5acb87 | 35 | |
36 | //---- Analysis system ---- | |
88f9563f | 37 | #include "AliVTrack.h" |
0ae57829 | 38 | #include "AliVCluster.h" |
1c5acb87 | 39 | #include "AliCaloTrackReader.h" |
40 | #include "AliNeutralMesonSelection.h" | |
1c5acb87 | 41 | #include "AliAnaParticleJetLeadingConeCorrelation.h" |
42 | #include "AliCaloPID.h" | |
43 | #include "AliAODPWG4ParticleCorrelation.h" | |
ff45398a | 44 | #include "AliFiducialCut.h" |
1c5acb87 | 45 | |
46 | ClassImp(AliAnaParticleJetLeadingConeCorrelation) | |
47 | ||
48 | ||
49 | //____________________________________________________________________________ | |
50 | AliAnaParticleJetLeadingConeCorrelation::AliAnaParticleJetLeadingConeCorrelation() : | |
745913ae | 51 | AliAnaCaloTrackCorrBaseClass(), fJetsOnlyInCTS(kFALSE), fPbPb(kFALSE), |
1c5acb87 | 52 | fSeveralConeAndPtCuts(0), fReMakeJet(0), |
53 | fDeltaPhiMaxCut(0.), fDeltaPhiMinCut(0.), | |
54 | fLeadingRatioMaxCut(0.), fLeadingRatioMinCut(0.), | |
55 | fJetCTSRatioMaxCut(0.), fJetCTSRatioMinCut(0.), | |
56 | fJetRatioMaxCut(0.), fJetRatioMinCut(0.), | |
57 | fJetNCone(0),fJetNPt(0), fJetCone(0), | |
58 | fJetPtThreshold(0),fJetPtThresPbPb(0), | |
59 | fPtTriggerSelectionCut(0.0), fSelect(0), | |
477d6cee | 60 | fSelectIsolated(0), |
1c5acb87 | 61 | //Histograms |
62 | fOutCont(0x0), | |
dde5a268 | 63 | //Leading |
1c5acb87 | 64 | fhChargedLeadingPt(0),fhChargedLeadingPhi(0),fhChargedLeadingEta(0), |
65 | fhChargedLeadingDeltaPt(0),fhChargedLeadingDeltaPhi(0),fhChargedLeadingDeltaEta(0), | |
66 | fhChargedLeadingRatioPt(0), | |
67 | fhNeutralLeadingPt(0),fhNeutralLeadingPhi(0),fhNeutralLeadingEta(0), | |
68 | fhNeutralLeadingDeltaPt(0),fhNeutralLeadingDeltaPhi(0),fhNeutralLeadingDeltaEta(0), | |
9415d854 | 69 | fhNeutralLeadingRatioPt(0),fhChargedLeadingXi(0), fhNeutralLeadingXi(0), |
78219bac | 70 | fhChargedLeadingDeltaPhiRatioPt30(0), fhNeutralLeadingDeltaPhiRatioPt30(0), |
71 | fhChargedLeadingDeltaPhiRatioPt50(0), fhNeutralLeadingDeltaPhiRatioPt50(0), | |
dde5a268 | 72 | //Jet |
1c5acb87 | 73 | fhJetPt(0),fhJetRatioPt(0),fhJetDeltaPhi(0), fhJetDeltaEta(0), |
74 | fhJetLeadingRatioPt(0),fhJetLeadingDeltaPhi(0),fhJetLeadingDeltaEta(0), | |
75 | fhJetFFz(0),fhJetFFxi(0),fhJetFFpt(0),fhJetNTracksInCone(0), | |
76 | fhBkgPt(0),fhBkgRatioPt(0),fhBkgDeltaPhi(0), fhBkgDeltaEta(0), | |
77 | fhBkgLeadingRatioPt(0),fhBkgLeadingDeltaPhi(0),fhBkgLeadingDeltaEta(0), | |
78 | fhBkgFFz(0),fhBkgFFxi(0),fhBkgFFpt(0),fhBkgNTracksInCone(0), | |
79 | //Several cones and thres histograms | |
80 | fhJetPts(),fhJetRatioPts(),fhJetDeltaPhis(), fhJetDeltaEtas(), | |
81 | fhJetLeadingRatioPts(),fhJetLeadingDeltaPhis(),fhJetLeadingDeltaEtas(), | |
82 | fhJetFFzs(),fhJetFFxis(),fhJetFFpts(),fhJetNTracksInCones(), | |
83 | fhBkgPts(),fhBkgRatioPts(),fhBkgDeltaPhis(), fhBkgDeltaEtas(), | |
84 | fhBkgLeadingRatioPts(),fhBkgLeadingDeltaPhis(),fhBkgLeadingDeltaEtas(), | |
85 | fhBkgFFzs(),fhBkgFFxis(),fhBkgFFpts(),fhBkgNTracksInCones() | |
86 | { | |
87 | //Default Ctor | |
477d6cee | 88 | |
1c5acb87 | 89 | //Initialize parameters |
90 | ||
91 | for(Int_t i = 0; i<6; i++){ | |
92 | fJetXMin1[i] = 0.0 ; | |
93 | fJetXMin2[i] = 0.0 ; | |
94 | fJetXMax1[i] = 0.0 ; | |
95 | fJetXMax2[i] = 0.0 ; | |
96 | fBkgMean[i] = 0.0 ; | |
97 | fBkgRMS[i] = 0.0 ; | |
98 | if( i < 2 ){ | |
99 | fJetE1[i] = 0.0 ; | |
100 | fJetE2[i] = 0.0 ; | |
101 | fJetSigma1[i] = 0.0 ; | |
102 | fJetSigma2[i] = 0.0 ; | |
103 | } | |
104 | } | |
477d6cee | 105 | |
1c5acb87 | 106 | //Several cones and thres histograms |
107 | for(Int_t i = 0; i<5; i++){ | |
108 | fJetCones[i] = 0.0 ; | |
109 | fJetNameCones[i] = "" ; | |
110 | fJetPtThres[i] = 0.0 ; | |
111 | fJetNamePtThres[i] = "" ; | |
112 | for(Int_t j = 0; j<5; j++){ | |
113 | fhJetPts[i][j]=0 ; | |
114 | fhJetRatioPts[i][j]=0 ; | |
115 | fhJetDeltaPhis[i][j]=0 ; | |
116 | fhJetDeltaEtas[i][j]=0 ; | |
117 | fhJetLeadingRatioPts[i][j]=0 ; | |
118 | fhJetLeadingDeltaPhis[i][j]=0 ; | |
119 | fhJetLeadingDeltaEtas[i][j]=0 ; | |
120 | fhJetFFzs[i][j]=0 ; | |
121 | fhJetFFxis[i][j]=0 ; | |
122 | fhJetFFpts[i][j]=0 ; | |
123 | fhJetNTracksInCones[i][j]=0 ; | |
124 | fhBkgPts[i][j]=0 ; | |
125 | fhBkgRatioPts[i][j]=0 ; | |
126 | fhBkgDeltaPhis[i][j]=0 ; | |
127 | fhBkgDeltaEtas[i][j]=0 ; | |
128 | fhBkgLeadingRatioPts[i][j]=0 ; | |
129 | fhBkgLeadingDeltaPhis[i][j]=0 ; | |
130 | fhBkgLeadingDeltaEtas[i][j]=0 ; | |
131 | fhBkgFFzs[i][j]=0 ; | |
132 | fhBkgFFxis[i][j]=0 ; | |
133 | fhBkgFFpts[i][j]=0 ; | |
134 | fhBkgNTracksInCones[i][j]=0 ; | |
135 | } | |
136 | } | |
137 | ||
138 | InitParameters(); | |
139 | ||
140 | } | |
78219bac | 141 | /* |
1c5acb87 | 142 | //____________________________________________________________________________ |
143 | AliAnaParticleJetLeadingConeCorrelation::AliAnaParticleJetLeadingConeCorrelation(const AliAnaParticleJetLeadingConeCorrelation & jetlc) : | |
745913ae | 144 | AliAnaCaloTrackCorrBaseClass(jetlc), fJetsOnlyInCTS(jetlc.fJetsOnlyInCTS), fPbPb(jetlc.fPbPb), |
1c5acb87 | 145 | fSeveralConeAndPtCuts(jetlc.fSeveralConeAndPtCuts), fReMakeJet(jetlc. fReMakeJet), |
146 | fDeltaPhiMaxCut(jetlc. fDeltaPhiMaxCut), fDeltaPhiMinCut(jetlc.fDeltaPhiMinCut), | |
147 | fLeadingRatioMaxCut(jetlc.fLeadingRatioMaxCut), fLeadingRatioMinCut(jetlc.fLeadingRatioMinCut), | |
148 | fJetCTSRatioMaxCut(jetlc.fJetCTSRatioMaxCut), | |
149 | fJetCTSRatioMinCut(jetlc.fJetCTSRatioMinCut), fJetRatioMaxCut(jetlc.fJetRatioMaxCut), | |
150 | fJetRatioMinCut(jetlc.fJetRatioMinCut), fJetNCone(jetlc.fJetNCone), | |
151 | fJetNPt(jetlc.fJetNPt), fJetCone(jetlc.fJetCone), | |
152 | fJetPtThreshold(jetlc.fJetPtThreshold),fJetPtThresPbPb(jetlc.fJetPtThresPbPb), | |
477d6cee | 153 | fPtTriggerSelectionCut(jetlc.fPtTriggerSelectionCut), fSelect(jetlc.fSelect), |
154 | fSelectIsolated(jetlc.fSelectIsolated), | |
1c5acb87 | 155 | //Histograms |
156 | fOutCont(jetlc. fOutCont), | |
dde5a268 | 157 | //Leading |
1c5acb87 | 158 | fhChargedLeadingPt(jetlc.fhChargedLeadingPt), fhChargedLeadingPhi(jetlc.fhChargedLeadingPhi), |
159 | fhChargedLeadingEta(jetlc.fhChargedLeadingEta), fhChargedLeadingDeltaPt(jetlc.fhChargedLeadingDeltaPt), | |
160 | fhChargedLeadingDeltaPhi(jetlc.fhChargedLeadingDeltaPhi),fhChargedLeadingDeltaEta(jetlc.fhChargedLeadingDeltaEta), | |
161 | fhChargedLeadingRatioPt(jetlc.fhChargedLeadingRatioPt), | |
162 | fhNeutralLeadingPt(jetlc.fhNeutralLeadingPt),fhNeutralLeadingPhi(jetlc.fhNeutralLeadingPhi), | |
163 | fhNeutralLeadingEta(jetlc.fhNeutralLeadingEta), fhNeutralLeadingDeltaPt(jetlc.fhNeutralLeadingDeltaPt), | |
164 | fhNeutralLeadingDeltaPhi(jetlc.fhNeutralLeadingDeltaPhi),fhNeutralLeadingDeltaEta(jetlc.fhNeutralLeadingDeltaEta), | |
165 | fhNeutralLeadingRatioPt(jetlc.fhNeutralLeadingRatioPt), | |
9415d854 | 166 | fhChargedLeadingXi(jetlc.fhChargedLeadingXi), fhNeutralLeadingXi(jetlc.fhNeutralLeadingXi), |
dde5a268 | 167 | fhChargedLeadingDeltaPhiRatioPt30(jetlc.fhChargedLeadingDeltaPhiRatioPt30), fhNeutralLeadingDeltaPhiRatioPt30(jetlc.fhNeutralLeadingDeltaPhiRatioPt30), |
168 | fhChargedLeadingDeltaPhiRatioPt50(jetlc.fhChargedLeadingDeltaPhiRatioPt50), fhNeutralLeadingDeltaPhiRatioPt50(jetlc.fhNeutralLeadingDeltaPhiRatioPt50), | |
169 | //Jet | |
1c5acb87 | 170 | fhJetPt(jetlc.fhJetPt),fhJetRatioPt(jetlc.fhJetRatioPt),fhJetDeltaPhi(jetlc.fhJetDeltaPhi), |
171 | fhJetDeltaEta(jetlc.fhJetDeltaEta), fhJetLeadingRatioPt(jetlc.fhJetLeadingRatioPt), | |
172 | fhJetLeadingDeltaPhi(jetlc.fhJetLeadingDeltaPhi),fhJetLeadingDeltaEta(jetlc.fhJetLeadingDeltaEta), | |
173 | fhJetFFz(jetlc.fhJetFFz),fhJetFFxi(jetlc.fhJetFFxi),fhJetFFpt(jetlc.fhJetFFpt), | |
174 | fhJetNTracksInCone(jetlc.fhJetNTracksInCone), | |
175 | fhBkgPt(jetlc.fhBkgPt),fhBkgRatioPt(jetlc.fhBkgRatioPt),fhBkgDeltaPhi(jetlc.fhBkgDeltaPhi), | |
176 | fhBkgDeltaEta(jetlc.fhBkgDeltaEta), fhBkgLeadingRatioPt(jetlc.fhBkgLeadingRatioPt), | |
177 | fhBkgLeadingDeltaPhi(jetlc.fhBkgLeadingDeltaPhi),fhBkgLeadingDeltaEta(jetlc.fhBkgLeadingDeltaEta), | |
178 | fhBkgFFz(jetlc.fhBkgFFz),fhBkgFFxi(jetlc.fhBkgFFxi),fhBkgFFpt(jetlc.fhBkgFFpt), | |
179 | fhBkgNTracksInCone(jetlc.fhBkgNTracksInCone), | |
180 | //Several cones and thres histograms | |
181 | fhJetPts(),fhJetRatioPts(),fhJetDeltaPhis(), fhJetDeltaEtas(), | |
182 | fhJetLeadingRatioPts(),fhJetLeadingDeltaPhis(),fhJetLeadingDeltaEtas(), | |
183 | fhJetFFzs(),fhJetFFxis(),fhJetFFpts(),fhJetNTracksInCones(), | |
184 | fhBkgPts(),fhBkgRatioPts(),fhBkgDeltaPhis(), fhBkgDeltaEtas(), | |
185 | fhBkgLeadingRatioPts(),fhBkgLeadingDeltaPhis(),fhBkgLeadingDeltaEtas(), | |
186 | fhBkgFFzs(),fhBkgFFxis(),fhBkgFFpts(),fhBkgNTracksInCones() | |
187 | { | |
188 | // cpy ctor | |
189 | ||
190 | for(Int_t i = 0; i<6; i++){ | |
191 | fJetXMin1[i] = jetlc.fJetXMin1[i] ; | |
192 | fJetXMin2[i] = jetlc.fJetXMin2[i] ; | |
193 | fJetXMax1[i] = jetlc.fJetXMax1[i] ; | |
194 | fJetXMax2[i] = jetlc.fJetXMax2[i] ; | |
195 | fBkgMean[i] = jetlc.fBkgMean[i] ; | |
196 | fBkgRMS[i] = jetlc.fBkgRMS[i] ; | |
197 | if( i < 2 ){ | |
198 | fJetE1[i] = jetlc.fJetE1[i] ; | |
199 | fJetE2[i] = jetlc.fJetE2[i] ; | |
200 | fJetSigma1[i] = jetlc.fJetSigma1[i] ; | |
201 | fJetSigma2[i] = jetlc.fJetSigma2[i] ; | |
202 | } | |
203 | } | |
477d6cee | 204 | |
1c5acb87 | 205 | //Several cones and thres histograms |
206 | for(Int_t i = 0; i<5; i++){ | |
207 | fJetCones[i] = jetlc.fJetCones[i] ; | |
208 | fJetNameCones[i] = jetlc.fJetNameCones[i] ; | |
209 | fJetPtThres[i] = jetlc.fJetPtThres[i] ; | |
210 | fJetNamePtThres[i] = jetlc.fJetNamePtThres[i] ; | |
211 | for(Int_t j = 0; j<5; j++){ | |
212 | fhJetPts[i][j] = jetlc.fhJetPts[i][j] ; | |
213 | fhJetRatioPts[i][j] = jetlc.fhJetRatioPts[i][j] ; | |
214 | fhJetDeltaPhis[i][j] = jetlc.fhJetDeltaPhis[i][j] ; | |
215 | fhJetDeltaEtas[i][j] = jetlc.fhJetDeltaEtas[i][j] ; | |
216 | fhJetLeadingRatioPts[i][j] = jetlc.fhJetLeadingRatioPts[i][j] ; | |
217 | fhJetLeadingDeltaPhis[i][j] = jetlc.fhJetLeadingDeltaPhis[i][j] ; | |
218 | fhJetLeadingDeltaEtas[i][j] = jetlc.fhJetLeadingDeltaEtas[i][j] ; | |
219 | fhJetFFzs[i][j] = jetlc.fhJetFFzs[i][j] ; | |
220 | fhJetFFxis[i][j] = jetlc.fhJetFFxis[i][j] ; | |
221 | fhJetFFpts[i][j] = jetlc.fhJetFFpts[i][j] ; | |
222 | fhJetNTracksInCones[i][j] = fhJetNTracksInCones[i][j] ; | |
223 | fhBkgPts[i][j] = jetlc.fhBkgPts[i][j] ; | |
224 | fhBkgRatioPts[i][j] = jetlc.fhBkgRatioPts[i][j] ; | |
225 | fhBkgDeltaPhis[i][j] = jetlc.fhBkgDeltaPhis[i][j] ; | |
226 | fhBkgDeltaEtas[i][j] = jetlc.fhBkgDeltaEtas[i][j] ; | |
227 | fhBkgLeadingRatioPts[i][j] = jetlc.fhBkgLeadingRatioPts[i][j] ; | |
228 | fhBkgLeadingDeltaPhis[i][j] = jetlc.fhBkgLeadingDeltaPhis[i][j] ; | |
229 | fhBkgLeadingDeltaEtas[i][j] = jetlc.fhBkgLeadingDeltaEtas[i][j] ; | |
230 | fhBkgFFzs[i][j] = jetlc.fhBkgFFzs[i][j] ; | |
231 | fhBkgFFxis[i][j] = jetlc.fhBkgFFxis[i][j] ; | |
232 | fhBkgFFpts[i][j] = jetlc.fhBkgFFpts[i][j] ; | |
233 | fhBkgNTracksInCones[i][j] = jetlc.fhBkgNTracksInCones[i][j] ; | |
234 | } | |
235 | } | |
236 | } | |
237 | ||
238 | //_________________________________________________________________________ | |
239 | AliAnaParticleJetLeadingConeCorrelation & AliAnaParticleJetLeadingConeCorrelation::operator = (const AliAnaParticleJetLeadingConeCorrelation & jetlc) | |
240 | { | |
241 | // assignment operator | |
477d6cee | 242 | |
1c5acb87 | 243 | if(this == &jetlc)return *this; |
745913ae | 244 | ((AliAnaCaloTrackCorrBaseClass *)this)->operator=(jetlc); |
1c5acb87 | 245 | |
477d6cee | 246 | fSeveralConeAndPtCuts = jetlc.fSeveralConeAndPtCuts ; |
247 | fPbPb = jetlc.fPbPb ; | |
248 | fReMakeJet = jetlc.fReMakeJet ; | |
249 | fJetsOnlyInCTS = jetlc.fJetsOnlyInCTS; | |
250 | ||
251 | fDeltaPhiMaxCut = jetlc.fDeltaPhiMaxCut ; | |
252 | fDeltaPhiMinCut = jetlc.fDeltaPhiMinCut ; | |
253 | fLeadingRatioMaxCut = jetlc.fLeadingRatioMaxCut ; | |
254 | fLeadingRatioMinCut = jetlc.fLeadingRatioMinCut ; | |
255 | ||
256 | fJetCTSRatioMaxCut = jetlc.fJetCTSRatioMaxCut ; | |
257 | fJetCTSRatioMinCut = jetlc.fJetCTSRatioMinCut ; | |
258 | fJetRatioMaxCut = jetlc.fJetRatioMaxCut ; | |
259 | fJetRatioMinCut = jetlc.fJetRatioMinCut ; | |
1c5acb87 | 260 | |
477d6cee | 261 | fJetNCone = jetlc.fJetNCone ; |
262 | fJetNPt = jetlc.fJetNPt ; fJetCone = jetlc.fJetCone ; | |
263 | fJetPtThreshold = jetlc.fJetPtThreshold ; | |
264 | fJetPtThresPbPb = jetlc.fJetPtThresPbPb ; | |
1c5acb87 | 265 | fPtTriggerSelectionCut = jetlc.fPtTriggerSelectionCut ; |
477d6cee | 266 | fSelect = jetlc.fSelect ; |
267 | fSelectIsolated = jetlc.fSelectIsolated ; | |
1c5acb87 | 268 | |
269 | for(Int_t i = 0; i<6; i++){ | |
270 | fJetXMin1[i] = jetlc.fJetXMin1[i] ; | |
271 | fJetXMin2[i] = jetlc.fJetXMin2[i] ; | |
272 | fJetXMax1[i] = jetlc.fJetXMax1[i] ; | |
273 | fJetXMax2[i] = jetlc.fJetXMax2[i] ; | |
274 | fBkgMean[i] = jetlc.fBkgMean[i] ; | |
275 | fBkgRMS[i] = jetlc.fBkgRMS[i] ; | |
276 | if( i < 2 ){ | |
277 | fJetE1[i] = jetlc.fJetE1[i] ; | |
278 | fJetE2[i] = jetlc.fJetE2[i] ; | |
279 | fJetSigma1[i] = jetlc.fJetSigma1[i] ; | |
280 | fJetSigma2[i] = jetlc.fJetSigma2[i] ; | |
281 | } | |
282 | } | |
283 | ||
284 | //Histograms | |
285 | fOutCont = jetlc. fOutCont ; | |
286 | fhChargedLeadingPt = jetlc.fhChargedLeadingPt; fhChargedLeadingPhi = jetlc.fhChargedLeadingPhi; | |
287 | fhChargedLeadingEta = jetlc.fhChargedLeadingEta; fhChargedLeadingDeltaPt = jetlc.fhChargedLeadingDeltaPt; | |
288 | fhChargedLeadingDeltaPhi = jetlc.fhChargedLeadingDeltaPhi;fhChargedLeadingDeltaEta = jetlc.fhChargedLeadingDeltaEta; | |
289 | fhChargedLeadingRatioPt = jetlc.fhChargedLeadingRatioPt; | |
290 | fhNeutralLeadingPt = jetlc.fhNeutralLeadingPt;fhNeutralLeadingPhi = jetlc.fhNeutralLeadingPhi; | |
291 | fhNeutralLeadingEta = jetlc.fhNeutralLeadingEta; fhNeutralLeadingDeltaPt = jetlc.fhNeutralLeadingDeltaPt; | |
292 | fhNeutralLeadingDeltaPhi = jetlc.fhNeutralLeadingDeltaPhi;fhNeutralLeadingDeltaEta = jetlc.fhNeutralLeadingDeltaEta; | |
293 | fhNeutralLeadingRatioPt = jetlc.fhNeutralLeadingRatioPt; | |
9415d854 | 294 | fhChargedLeadingXi = jetlc.fhChargedLeadingXi; |
295 | fhNeutralLeadingXi = jetlc.fhNeutralLeadingXi; | |
296 | ||
dde5a268 | 297 | fhChargedLeadingDeltaPhiRatioPt30 = jetlc.fhChargedLeadingDeltaPhiRatioPt30; |
298 | fhNeutralLeadingDeltaPhiRatioPt30 = jetlc.fhNeutralLeadingDeltaPhiRatioPt30; | |
299 | fhChargedLeadingDeltaPhiRatioPt50 = jetlc.fhChargedLeadingDeltaPhiRatioPt50; | |
300 | fhNeutralLeadingDeltaPhiRatioPt50 = jetlc.fhNeutralLeadingDeltaPhiRatioPt50; | |
9415d854 | 301 | |
1c5acb87 | 302 | fhJetPt = jetlc.fhJetPt;fhJetRatioPt = jetlc.fhJetRatioPt;fhJetDeltaPhi = jetlc.fhJetDeltaPhi; |
303 | fhJetDeltaEta = jetlc.fhJetDeltaEta; fhJetLeadingRatioPt = jetlc.fhJetLeadingRatioPt; | |
304 | fhJetLeadingDeltaPhi = jetlc.fhJetLeadingDeltaPhi;fhJetLeadingDeltaEta = jetlc.fhJetLeadingDeltaEta; | |
305 | fhJetFFz = jetlc.fhJetFFz;fhJetFFxi = jetlc.fhJetFFxi;fhJetFFpt = jetlc.fhJetFFpt; | |
306 | fhJetNTracksInCone = jetlc.fhJetNTracksInCone; | |
307 | fhBkgPt = jetlc.fhBkgPt;fhBkgRatioPt = jetlc.fhBkgRatioPt;fhBkgDeltaPhi = jetlc.fhBkgDeltaPhi; | |
308 | fhBkgDeltaEta = jetlc.fhBkgDeltaEta; fhBkgLeadingRatioPt = jetlc.fhBkgLeadingRatioPt; | |
309 | fhBkgLeadingDeltaPhi = jetlc.fhBkgLeadingDeltaPhi;fhBkgLeadingDeltaEta = jetlc.fhBkgLeadingDeltaEta; | |
310 | fhBkgFFz = jetlc.fhBkgFFz;fhBkgFFxi = jetlc.fhBkgFFxi;fhBkgFFpt = jetlc.fhBkgFFpt; | |
311 | fhBkgNTracksInCone = jetlc.fhBkgNTracksInCone; | |
312 | ||
313 | ||
314 | //Several cones and thres histograms | |
315 | for(Int_t i = 0; i<5; i++){ | |
316 | fJetCones[i] = jetlc.fJetCones[i] ; | |
317 | fJetNameCones[i] = jetlc.fJetNameCones[i] ; | |
318 | fJetPtThres[i] = jetlc.fJetPtThres[i] ; | |
319 | fJetNamePtThres[i] = jetlc.fJetNamePtThres[i] ; | |
320 | ||
321 | for(Int_t j = 0; j<5; j++){ | |
322 | fhJetPts[i][j] = jetlc.fhJetPts[i][j] ; | |
323 | fhJetRatioPts[i][j] = jetlc.fhJetRatioPts[i][j] ; | |
324 | fhJetDeltaPhis[i][j] = jetlc.fhJetDeltaPhis[i][j] ; | |
325 | fhJetDeltaEtas[i][j] = jetlc.fhJetDeltaEtas[i][j] ; | |
326 | fhJetLeadingRatioPts[i][j] = jetlc.fhJetLeadingRatioPts[i][j] ; | |
327 | fhJetLeadingDeltaPhis[i][j] = jetlc.fhJetLeadingDeltaPhis[i][j] ; | |
328 | fhJetLeadingDeltaEtas[i][j] = jetlc.fhJetLeadingDeltaEtas[i][j] ; | |
329 | fhJetFFzs[i][j] = jetlc.fhJetFFzs[i][j] ; | |
330 | fhJetFFxis[i][j] = jetlc.fhJetFFxis[i][j] ; | |
331 | fhJetFFpts[i][j] = jetlc.fhJetFFpts[i][j] ; | |
332 | fhJetNTracksInCones[i][j] = fhJetNTracksInCones[i][j] ; | |
333 | fhBkgPts[i][j] = jetlc.fhBkgPts[i][j] ; | |
334 | fhBkgRatioPts[i][j] = jetlc.fhBkgRatioPts[i][j] ; | |
335 | fhBkgDeltaPhis[i][j] = jetlc.fhBkgDeltaPhis[i][j] ; | |
336 | fhBkgDeltaEtas[i][j] = jetlc.fhBkgDeltaEtas[i][j] ; | |
337 | fhBkgLeadingRatioPts[i][j] = jetlc.fhBkgLeadingRatioPts[i][j] ; | |
338 | fhBkgLeadingDeltaPhis[i][j] = jetlc.fhBkgLeadingDeltaPhis[i][j] ; | |
339 | fhBkgLeadingDeltaEtas[i][j] = jetlc.fhBkgLeadingDeltaEtas[i][j] ; | |
340 | fhBkgFFzs[i][j] = jetlc.fhBkgFFzs[i][j] ; | |
341 | fhBkgFFxis[i][j] = jetlc.fhBkgFFxis[i][j] ; | |
342 | fhBkgFFpts[i][j] = jetlc.fhBkgFFpts[i][j] ; | |
343 | fhBkgNTracksInCones[i][j] = jetlc.fhBkgNTracksInCones[i][j] ; | |
344 | } | |
345 | } | |
346 | ||
347 | return *this; | |
348 | ||
349 | } | |
78219bac | 350 | */ |
1c5acb87 | 351 | //____________________________________________________________________________ |
352 | AliAnaParticleJetLeadingConeCorrelation::~AliAnaParticleJetLeadingConeCorrelation() | |
353 | { | |
354 | // Remove all pointers except analysis output pointers. | |
1c5acb87 | 355 | } |
356 | ||
357 | //____________________________________________________________________________ | |
358 | Double_t AliAnaParticleJetLeadingConeCorrelation::CalculateJetRatioLimit(const Double_t ptg, const Double_t *par, const Double_t *x) const { | |
359 | //Calculate the ratio of the jet and trigger particle limit for the selection | |
360 | //WARNING: need to check what it does | |
9415d854 | 361 | //printf("CalculateLimit: x1 %2.3f, x2%2.3f\n",x[0],x[1]); |
1c5acb87 | 362 | Double_t ePP = par[0] + par[1] * ptg ; |
363 | Double_t sPP = par[2] + par[3] * ptg ; | |
364 | Double_t f = x[0] + x[1] * ptg ; | |
365 | Double_t ePbPb = ePP + par[4] ; | |
366 | Double_t sPbPb = TMath::Sqrt(sPP*sPP+ par[5]*par[5]) ; | |
367 | Double_t rat = (ePbPb - sPbPb * f) / ptg ; | |
9415d854 | 368 | //printf("CalculateLimit: ePP %2.3f, sPP %2.3f, f %2.3f\n", ePP, sPP, f); |
369 | //printf("CalculateLimit: ePbPb %2.3f, sPbPb %2.3f, rat %2.3f\n", ePbPb, sPbPb, rat); | |
1c5acb87 | 370 | return rat ; |
371 | } | |
372 | ||
373 | //____________________________________________________________________________ | |
374 | void AliAnaParticleJetLeadingConeCorrelation::FillJetHistos(AliAODPWG4ParticleCorrelation * particle, const TLorentzVector leading, const TLorentzVector jet, const TString type, const TString lastname) | |
375 | { | |
376 | //Fill jet and background histograms | |
377 | Double_t ptTrig = particle->Pt(); | |
378 | Double_t ptJet = jet.Pt(); | |
379 | Double_t ptLead = leading.Pt(); | |
380 | Double_t phiTrig = particle->Phi(); | |
381 | Double_t phiJet = jet.Phi(); | |
9415d854 | 382 | if(phiJet < 0) phiJet+=TMath::TwoPi(); |
1c5acb87 | 383 | Double_t phiLead = leading.Phi(); |
9415d854 | 384 | if(phiLead < 0) phiLead+=TMath::TwoPi(); |
1c5acb87 | 385 | Double_t etaTrig = particle->Eta(); |
386 | Double_t etaJet = jet.Eta(); | |
387 | Double_t etaLead = leading.Eta(); | |
9415d854 | 388 | |
f8006433 | 389 | TH2F *h1 = 0x0; |
390 | h1 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sPt%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); | |
391 | if(h1)h1->Fill(ptTrig,ptJet); | |
392 | ||
393 | TH2F *h2 = 0x0; | |
394 | h2 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sRatioPt%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); | |
395 | if(h2) h2->Fill(ptTrig,ptJet/ptTrig); | |
396 | ||
397 | TH2F *h3 = 0x0; | |
398 | h3 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sLeadingRatioPt%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); | |
399 | if(h3)h3->Fill(ptTrig,ptLead/ptJet); | |
9415d854 | 400 | |
62ccac92 | 401 | // dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sPhi%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())))-> |
9415d854 | 402 | // Fill(ptTrig,phiJet); |
f8006433 | 403 | TH2F *h4 = 0x0; |
404 | h4 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sDeltaPhi%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); | |
405 | if(h4) h4->Fill(ptTrig,phiJet-phiTrig); | |
406 | TH2F *h5 = 0x0; | |
407 | h5 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sLeadingDeltaPhi%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); | |
408 | if(h5) h5->Fill(ptTrig,phiJet-phiLead); | |
9415d854 | 409 | |
62ccac92 | 410 | // dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sEta%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())))-> |
9415d854 | 411 | // Fill(ptTrig,etaJet); |
f8006433 | 412 | TH2F *h6 = 0x0; |
413 | h6 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sDeltaEta%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); | |
414 | if(h6) h6->Fill(ptTrig,etaJet-etaTrig); | |
415 | TH2F *h7 = 0x0; | |
416 | h7 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sLeadingDeltaEta%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); | |
417 | if(h7) h7->Fill(ptTrig,etaJet-etaLead); | |
1c5acb87 | 418 | |
419 | //Construct fragmentation function | |
591cc579 | 420 | TObjArray * pl = new TObjArray; |
9415d854 | 421 | |
591cc579 | 422 | if(type == "Jet") pl = particle->GetObjArray(Form("%sTracks",GetAODObjArrayName().Data())); |
423 | else if(type == "Bkg") particle->GetObjArray(Form("%sTracksBkg",GetAODObjArrayName().Data())); | |
9415d854 | 424 | |
425 | if(!pl) return ; | |
426 | ||
1c5acb87 | 427 | //Different pt cut for jet particles in different collisions systems |
428 | //Only needed when jet is recalculated from AODs | |
c2ae67d0 | 429 | //Float_t ptcut = fJetPtThreshold; |
430 | //if(fPbPb && !fSeveralConeAndPtCuts && ptTrig > fPtTriggerSelectionCut) ptcut = fJetPtThresPbPb ; | |
1c5acb87 | 431 | |
432 | TVector3 p3; | |
433 | Int_t nTracksInCone = 0; | |
9415d854 | 434 | |
c2ae67d0 | 435 | for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ ) |
436 | { | |
88f9563f | 437 | AliVTrack* track = dynamic_cast<AliVTrack *>(pl->At(ipr)) ; |
164a1d84 | 438 | if(track)p3.SetXYZ(track->Px(),track->Py(),track->Pz()); |
439 | else printf("AliAnaParticleJetLeadingConeCorrelation::FillJetHistos() - Track not available\n"); | |
1c5acb87 | 440 | |
441 | //Recheck if particle is in jet cone | |
442 | if(fReMakeJet || fSeveralConeAndPtCuts) | |
443 | if(!IsParticleInJetCone(p3.Eta(), p3.Phi(), leading.Eta(), leading.Phi()) ) continue ; | |
444 | ||
445 | nTracksInCone++; | |
9415d854 | 446 | |
164a1d84 | 447 | TH2F *ha =dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sFFz%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); |
f8006433 | 448 | if(ha) ha->Fill(ptTrig,p3.Pt()/ptTrig); |
164a1d84 | 449 | TH2F *hb =dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sFFxi%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); |
f8006433 | 450 | if(hb) hb->Fill(ptTrig,TMath::Log(ptTrig/p3.Pt())); |
164a1d84 | 451 | TH2F *hc =dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sFFpt%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); |
f8006433 | 452 | if(hc) hc->Fill(ptTrig,p3.Pt()); |
1c5acb87 | 453 | |
454 | }//track loop | |
9415d854 | 455 | |
c2ae67d0 | 456 | if(nTracksInCone > 0) |
457 | { | |
164a1d84 | 458 | TH2F *hd = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sNTracksInCone%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data()))); |
05782323 | 459 | if(hd)hd->Fill(ptTrig, nTracksInCone); |
164a1d84 | 460 | } |
1c5acb87 | 461 | |
462 | } | |
463 | ||
464 | //________________________________________________________________________ | |
465 | TList * AliAnaParticleJetLeadingConeCorrelation::GetCreateOutputObjects() | |
466 | { | |
467 | // Create histograms to be saved in output file and | |
468 | // store them in fOutCont | |
9415d854 | 469 | |
477d6cee | 470 | if(GetDebug()>1) printf("AliAnaParticleJetLeadingConeCorrelation::GetCreateOutputObjects() - Init histograms \n"); |
471 | ||
472 | fOutCont = new TList() ; | |
473 | fOutCont->SetName("ParticleJetLeadingInConeCorrelationHistograms") ; | |
474 | ||
745913ae | 475 | Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); |
476 | Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins(); | |
477 | Int_t netabins = GetHistogramRanges()->GetHistoEtaBins(); | |
478 | Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); | |
479 | Float_t phimax = GetHistogramRanges()->GetHistoPhiMax(); | |
480 | Float_t etamax = GetHistogramRanges()->GetHistoEtaMax(); | |
481 | Float_t ptmin = GetHistogramRanges()->GetHistoPtMin(); | |
482 | Float_t phimin = GetHistogramRanges()->GetHistoPhiMin(); | |
483 | Float_t etamin = GetHistogramRanges()->GetHistoEtaMin(); | |
477d6cee | 484 | |
485 | fhChargedLeadingPt = new TH2F("ChargedLeadingPt","p_{T leading charge} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); | |
9415d854 | 486 | fhChargedLeadingPt->SetYTitle("p_{T leading charge}"); |
477d6cee | 487 | fhChargedLeadingPt->SetXTitle("p_{T trigger} (GeV/c)"); |
488 | ||
489 | fhChargedLeadingPhi = new TH2F("ChargedLeadingPhi","#phi_{h^{#pm}} vs p_{T trigger}", nptbins,ptmin,ptmax,nphibins,phimin,phimax); | |
490 | fhChargedLeadingPhi->SetYTitle("#phi_{h^{#pm}} (rad)"); | |
491 | fhChargedLeadingPhi->SetXTitle("p_{T trigger} (GeV/c)"); | |
492 | ||
493 | fhChargedLeadingEta = new TH2F("ChargedLeadingEta","#eta_{h^{#pm}} vs p_{T trigger}",nptbins,ptmin,ptmax,netabins,etamin,etamax); | |
494 | fhChargedLeadingEta->SetYTitle("#eta_{h^{#pm}} "); | |
495 | fhChargedLeadingEta->SetXTitle("p_{T trigger} (GeV/c)"); | |
496 | ||
9415d854 | 497 | fhChargedLeadingDeltaPt = new TH2F("ChargedLeadingDeltaPt","p_{T trigger} - p_{T h^{#pm}} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); |
477d6cee | 498 | fhChargedLeadingDeltaPt->SetYTitle("#Delta p_{T} (GeV/c)"); |
499 | fhChargedLeadingDeltaPt->SetXTitle("p_{T trigger} (GeV/c)"); | |
500 | ||
501 | fhChargedLeadingDeltaPhi = new TH2F("ChargedLeadingDeltaPhi","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,TMath::TwoPi()); | |
502 | fhChargedLeadingDeltaPhi->SetYTitle("#Delta #phi (rad)"); | |
503 | fhChargedLeadingDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)"); | |
504 | ||
505 | fhChargedLeadingDeltaEta = new TH2F("ChargedLeadingDeltaEta","#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2); | |
506 | fhChargedLeadingDeltaEta->SetYTitle("#Delta #eta"); | |
507 | fhChargedLeadingDeltaEta->SetXTitle("p_{T trigger} (GeV/c)"); | |
508 | ||
509 | fhChargedLeadingRatioPt = new TH2F("ChargedLeadingRatioPt","p_{T leading charge} /p_{T trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2); | |
510 | fhChargedLeadingRatioPt->SetYTitle("p_{T lead charge} /p_{T trigger}"); | |
511 | fhChargedLeadingRatioPt->SetXTitle("p_{T trigger} (GeV/c)"); | |
512 | ||
9415d854 | 513 | fhChargedLeadingXi = new TH2F("ChargedLeadingXi","ln(p_{T trigger} / p_{T leading charge} ) vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,10); |
514 | fhChargedLeadingXi->SetYTitle("#xi"); | |
515 | fhChargedLeadingXi->SetXTitle("p_{T trigger} (GeV/c)"); | |
516 | ||
477d6cee | 517 | fOutCont->Add(fhChargedLeadingPt) ; |
518 | fOutCont->Add(fhChargedLeadingPhi) ; | |
519 | fOutCont->Add(fhChargedLeadingEta) ; | |
520 | fOutCont->Add(fhChargedLeadingDeltaPt) ; | |
521 | fOutCont->Add(fhChargedLeadingDeltaPhi) ; | |
522 | fOutCont->Add(fhChargedLeadingDeltaEta) ; | |
523 | fOutCont->Add(fhChargedLeadingRatioPt) ; | |
9415d854 | 524 | fOutCont->Add(fhChargedLeadingXi) ; |
525 | ||
dde5a268 | 526 | fhChargedLeadingDeltaPhiRatioPt30 = new TH2F("ChargedLeadingDeltaPhiRatioPt30","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, charged leading, p_{T trigger} > 30 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1); |
527 | fhChargedLeadingDeltaPhiRatioPt30->SetXTitle("#Delta #phi (rad)"); | |
528 | fhChargedLeadingDeltaPhiRatioPt30->SetYTitle("p_{T leading} / p_{T trigger}"); | |
529 | ||
530 | fhChargedLeadingDeltaPhiRatioPt50 = new TH2F("ChargedLeadingDeltaPhiRatioPt50","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, charged leading, p_{T trigger} > 50 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1); | |
531 | fhChargedLeadingDeltaPhiRatioPt50->SetXTitle("#Delta #phi (rad)"); | |
532 | fhChargedLeadingDeltaPhiRatioPt50->SetYTitle("p_{T leading} / p_{T trigger}"); | |
533 | ||
534 | fOutCont->Add(fhChargedLeadingDeltaPhiRatioPt30) ; | |
535 | fOutCont->Add(fhChargedLeadingDeltaPhiRatioPt50) ; | |
536 | ||
477d6cee | 537 | if(!fJetsOnlyInCTS){ |
538 | ||
539 | fhNeutralLeadingPt = new TH2F("NeutralLeadingPt","p_{T leading #pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); | |
9415d854 | 540 | fhNeutralLeadingPt->SetYTitle("p_{T leading #pi^{0}}"); |
477d6cee | 541 | fhNeutralLeadingPt->SetXTitle("p_{T trigger} (GeV/c)"); |
542 | ||
543 | fhNeutralLeadingPhi = new TH2F("NeutralLeadingPhi","#phi_{#pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,nphibins,phimin,phimax); | |
544 | fhNeutralLeadingPhi->SetYTitle("#phi_{#pi^{0}} (rad)"); | |
545 | fhNeutralLeadingPhi->SetXTitle("p_{T trigger} (GeV/c)"); | |
546 | ||
547 | fhNeutralLeadingEta = new TH2F("NeutralLeadingEta","#eta_{#pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,netabins,etamin,etamax); | |
548 | fhNeutralLeadingEta->SetYTitle("#eta_{#pi^{0}} "); | |
549 | fhNeutralLeadingEta->SetXTitle("p_{T trigger} (GeV/c)"); | |
550 | ||
9415d854 | 551 | fhNeutralLeadingDeltaPt = new TH2F("NeutralLeadingDeltaPt","p_{T trigger} - p_{T #pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); |
477d6cee | 552 | fhNeutralLeadingDeltaPt->SetYTitle("#Delta p_{T} (GeV/c)"); |
553 | fhNeutralLeadingDeltaPt->SetXTitle("p_{T trigger} (GeV/c)"); | |
554 | ||
555 | fhNeutralLeadingDeltaPhi = new TH2F("NeutralLeadingDeltaPhi","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,TMath::TwoPi()); | |
556 | fhNeutralLeadingDeltaPhi->SetYTitle("#Delta #phi (rad)"); | |
557 | fhNeutralLeadingDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)"); | |
558 | ||
559 | fhNeutralLeadingDeltaEta = new TH2F("NeutralLeadingDeltaEta","#eta_{trigger} - #eta_{#pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2); | |
560 | fhNeutralLeadingDeltaEta->SetYTitle("#Delta #eta"); | |
561 | fhNeutralLeadingDeltaEta->SetXTitle("p_{T trigger} (GeV/c)"); | |
562 | ||
563 | fhNeutralLeadingRatioPt = new TH2F("NeutralLeadingRatioPt","p_{T leading #pi^{0}} /p_{T trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2); | |
564 | fhNeutralLeadingRatioPt->SetYTitle("p_{T lead #pi^{0}} /p_{T trigger}"); | |
565 | fhNeutralLeadingRatioPt->SetXTitle("p_{T trigger} (GeV/c)"); | |
566 | ||
9415d854 | 567 | fhNeutralLeadingXi = new TH2F("NeutralLeadingXi","ln(p_{T trigger} / p_{T leading #pi^{0}} ) vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,10); |
568 | fhNeutralLeadingXi->SetYTitle("#xi"); | |
569 | fhNeutralLeadingXi->SetXTitle("p_{T trigger} (GeV/c)"); | |
570 | ||
477d6cee | 571 | fOutCont->Add(fhNeutralLeadingPt) ; |
572 | fOutCont->Add(fhNeutralLeadingPhi) ; | |
573 | fOutCont->Add(fhNeutralLeadingEta) ; | |
574 | fOutCont->Add(fhNeutralLeadingDeltaPt) ; | |
575 | fOutCont->Add(fhNeutralLeadingDeltaPhi) ; | |
576 | fOutCont->Add(fhNeutralLeadingDeltaEta) ; | |
577 | fOutCont->Add(fhNeutralLeadingRatioPt) ; | |
9415d854 | 578 | fOutCont->Add(fhNeutralLeadingXi) ; |
dde5a268 | 579 | |
580 | fhNeutralLeadingDeltaPhiRatioPt30 = new TH2F("NeutralLeadingDeltaPhiRatioPt30","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, neutral leading, p_{T trigger} > 30 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1); | |
581 | fhNeutralLeadingDeltaPhiRatioPt30->SetXTitle("#Delta #phi (rad)"); | |
582 | fhNeutralLeadingDeltaPhiRatioPt30->SetYTitle("p_{T leading} / p_{T trigger}"); | |
583 | ||
584 | fhNeutralLeadingDeltaPhiRatioPt50 = new TH2F("NeutralLeadingDeltaPhiRatioPt50","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, neutral leading, p_{T trigger} > 50 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1); | |
585 | fhNeutralLeadingDeltaPhiRatioPt50->SetXTitle("#Delta #phi (rad)"); | |
586 | fhNeutralLeadingDeltaPhiRatioPt50->SetYTitle("p_{T leading} / p_{T trigger}"); | |
587 | fOutCont->Add(fhNeutralLeadingDeltaPhiRatioPt30) ; | |
588 | fOutCont->Add(fhNeutralLeadingDeltaPhiRatioPt50) ; | |
589 | ||
477d6cee | 590 | } |
591 | ||
592 | if(!fSeveralConeAndPtCuts){// not several cones | |
593 | ||
594 | //Jet Distributions | |
595 | fhJetPt = new TH2F("JetPt","p_{T jet} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); | |
596 | fhJetPt->SetYTitle("p_{T jet}"); | |
597 | fhJetPt->SetXTitle("p_{T trigger} (GeV/c)"); | |
598 | ||
599 | fhJetRatioPt = new TH2F("JetRatioPt","p_{T jet}/p_{T trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2); | |
600 | fhJetRatioPt->SetYTitle("p_{T jet}/p_{T trigger}"); | |
601 | fhJetRatioPt->SetXTitle("p_{T trigger} (GeV/c)"); | |
602 | ||
603 | fhJetDeltaPhi = new TH2F("JetDeltaPhi","#phi_{jet} - #phi_{trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,TMath::TwoPi()); | |
604 | fhJetDeltaPhi->SetYTitle("#Delta #phi (rad)"); | |
605 | fhJetDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)"); | |
606 | ||
607 | fhJetDeltaEta = new TH2F("JetDeltaEta","#eta_{jet} - #eta_{trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2); | |
608 | fhJetDeltaEta->SetYTitle("#Delta #eta"); | |
609 | fhJetDeltaEta->SetXTitle("p_{T trigger} (GeV/c)"); | |
610 | ||
611 | fhJetLeadingRatioPt = new TH2F("JetLeadingRatioPt","p_{T jet} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2); | |
612 | fhJetLeadingRatioPt->SetYTitle("p_{T leading}/p_{T jet}"); | |
613 | fhJetLeadingRatioPt->SetXTitle("p_{T trigger} (GeV/c)"); | |
614 | ||
9415d854 | 615 | fhJetLeadingDeltaPhi = new TH2F("JetLeadingDeltaPhi","#phi_{jet} - #phi_{leading} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-TMath::Pi(),TMath::Pi()); |
477d6cee | 616 | fhJetLeadingDeltaPhi->SetYTitle("#Delta #phi (rad)"); |
617 | fhJetLeadingDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)"); | |
618 | ||
619 | fhJetLeadingDeltaEta = new TH2F("JetLeadingDeltaEta","#eta_{jet} - #eta_{leading} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2); | |
620 | fhJetLeadingDeltaEta->SetYTitle("#Delta #eta"); | |
621 | fhJetLeadingDeltaEta->SetXTitle("p_{T trigger} (GeV/c)"); | |
622 | ||
623 | fhJetFFz = new TH2F("JetFFz","z = p_{T i charged}/p_{T trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,200,0.,2); | |
624 | fhJetFFz->SetYTitle("z"); | |
625 | fhJetFFz->SetXTitle("p_{T trigger}"); | |
626 | ||
627 | fhJetFFxi = new TH2F("JetFFxi","#xi = ln(p_{T trigger}/p_{T i charged}) vs p_{T trigger}",nptbins,ptmin,ptmax,100,0.,10.); | |
628 | fhJetFFxi->SetYTitle("#xi"); | |
629 | fhJetFFxi->SetXTitle("p_{T trigger}"); | |
630 | ||
631 | fhJetFFpt = new TH2F("JetFFpt","#xi = p_{T i charged}) vs p_{T trigger}",nptbins,ptmin,ptmax,200,0.,50.); | |
632 | fhJetFFpt->SetYTitle("p_{T charged hadron}"); | |
633 | fhJetFFpt->SetXTitle("p_{T trigger}"); | |
634 | ||
635 | fhJetNTracksInCone = new TH2F("JetNTracksInCone","N particles in cone vs p_{T trigger}",nptbins,ptmin,ptmax,5000,0, 5000); | |
636 | fhJetNTracksInCone->SetYTitle("N tracks in jet cone"); | |
637 | fhJetNTracksInCone->SetXTitle("p_{T trigger} (GeV/c)"); | |
638 | ||
639 | fOutCont->Add(fhJetPt) ; | |
640 | fOutCont->Add(fhJetRatioPt) ; | |
641 | fOutCont->Add(fhJetDeltaPhi) ; | |
642 | fOutCont->Add(fhJetDeltaEta) ; | |
643 | fOutCont->Add(fhJetLeadingRatioPt) ; | |
644 | fOutCont->Add(fhJetLeadingDeltaPhi) ; | |
645 | fOutCont->Add(fhJetLeadingDeltaEta) ; | |
646 | fOutCont->Add(fhJetFFz) ; | |
647 | fOutCont->Add(fhJetFFxi) ; | |
648 | fOutCont->Add(fhJetFFpt) ; | |
649 | fOutCont->Add(fhJetNTracksInCone) ; | |
650 | ||
651 | //Bkg Distributions | |
652 | fhBkgPt = new TH2F("BkgPt","p_{T bkg} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); | |
653 | fhBkgPt->SetYTitle("p_{T bkg}"); | |
654 | fhBkgPt->SetXTitle("p_{T trigger} (GeV/c)"); | |
655 | ||
656 | fhBkgRatioPt = new TH2F("BkgRatioPt","p_{T bkg}/p_{T trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2); | |
657 | fhBkgRatioPt->SetYTitle("p_{T bkg}/p_{T trigger}"); | |
658 | fhBkgRatioPt->SetXTitle("p_{T trigger} (GeV/c)"); | |
659 | ||
660 | fhBkgDeltaPhi = new TH2F("BkgDeltaPhi","#phi_{bkg} - #phi_{trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,TMath::TwoPi()); | |
661 | fhBkgDeltaPhi->SetYTitle("#Delta #phi (rad)"); | |
662 | fhBkgDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)"); | |
663 | ||
664 | fhBkgDeltaEta = new TH2F("BkgDeltaEta","#eta_{bkg} - #eta_{trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2); | |
665 | fhBkgDeltaEta->SetYTitle("#Delta #eta"); | |
666 | fhBkgDeltaEta->SetXTitle("p_{T trigger} (GeV/c)"); | |
667 | ||
668 | fhBkgLeadingRatioPt = new TH2F("BkgLeadingRatioPt","p_{T bkg} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2); | |
669 | fhBkgLeadingRatioPt->SetYTitle("p_{T leading}/p_{T bkg}"); | |
670 | fhBkgLeadingRatioPt->SetXTitle("p_{T trigger} (GeV/c)"); | |
671 | ||
672 | fhBkgLeadingDeltaPhi = new TH2F("BkgLeadingDeltaPhi","#phi_{bkg} - #phi_{leading} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,TMath::TwoPi()); | |
673 | fhBkgLeadingDeltaPhi->SetYTitle("#Delta #phi (rad)"); | |
674 | fhBkgLeadingDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)"); | |
675 | ||
676 | fhBkgLeadingDeltaEta = new TH2F("BkgLeadingDeltaEta","#eta_{bkg} - #eta_{leading} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2); | |
677 | fhBkgLeadingDeltaEta->SetYTitle("#Delta #eta"); | |
678 | fhBkgLeadingDeltaEta->SetXTitle("p_{T trigger} (GeV/c)"); | |
679 | ||
680 | fhBkgFFz = new TH2F("BkgFFz","z = p_{T i charged}/p_{T trigger} vs p_{T trigger}", nptbins,ptmin,ptmax,200,0.,2); | |
681 | fhBkgFFz->SetYTitle("z"); | |
682 | fhBkgFFz->SetXTitle("p_{T trigger}"); | |
683 | ||
684 | fhBkgFFxi = new TH2F("BkgFFxi","#xi = ln(p_{T trigger}/p_{T i charged}) vs p_{T trigger}", nptbins,ptmin,ptmax,100,0.,10.); | |
685 | fhBkgFFxi->SetYTitle("#xi"); | |
686 | fhBkgFFxi->SetXTitle("p_{T trigger}"); | |
687 | ||
688 | fhBkgFFpt = new TH2F("BkgFFpt","p_{T charged hadron } vs p_{T trigger}", nptbins,ptmin,ptmax,200,0.,50.); | |
689 | fhBkgFFpt->SetYTitle("p_{T charged} hadron"); | |
690 | fhBkgFFpt->SetXTitle("p_{T trigger}"); | |
691 | ||
692 | fhBkgNTracksInCone = new TH2F("BkgNTracksInCone","N particles in cone vs p_{T trigger}",nptbins,ptmin,ptmax,5000,0, 5000); | |
693 | fhBkgNTracksInCone->SetYTitle("N tracks in bkg cone"); | |
694 | fhBkgNTracksInCone->SetXTitle("p_{T trigger} (GeV/c)"); | |
695 | ||
696 | fOutCont->Add(fhBkgPt) ; | |
697 | fOutCont->Add(fhBkgRatioPt) ; | |
698 | fOutCont->Add(fhBkgDeltaPhi) ; | |
699 | fOutCont->Add(fhBkgDeltaEta) ; | |
700 | fOutCont->Add(fhBkgLeadingRatioPt) ; | |
701 | fOutCont->Add(fhBkgLeadingDeltaPhi) ; | |
702 | fOutCont->Add(fhBkgLeadingDeltaEta) ; | |
703 | fOutCont->Add(fhBkgFFz) ; | |
704 | fOutCont->Add(fhBkgFFxi) ; | |
705 | fOutCont->Add(fhBkgFFpt) ; | |
706 | fOutCont->Add(fhBkgNTracksInCone) ; | |
707 | ||
708 | }//not several cones | |
709 | else{ //If we want to study the jet for different cones and pt | |
710 | for(Int_t icone = 0; icone<fJetNCone; icone++){//icone | |
711 | for(Int_t ipt = 0; ipt<fJetNPt;ipt++){ //ipt | |
1c5acb87 | 712 | |
477d6cee | 713 | TString lastnamehist ="Cone"+ fJetNameCones[icone]+"Pt"+ fJetNamePtThres[ipt]; |
714 | TString lastnametitle =", cone ="+fJetNameCones[icone]+", pt > " +fJetNamePtThres[ipt]+" GeV/c"; | |
1c5acb87 | 715 | |
477d6cee | 716 | //Jet Distributions |
62ccac92 | 717 | fhJetPts[icone][ipt] = new TH2F(Form("JetPt%s",lastnamehist.Data()),Form("p_{T jet} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); |
477d6cee | 718 | fhJetPts[icone][ipt]->SetYTitle("p_{T jet}"); |
719 | fhJetPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
1c5acb87 | 720 | |
62ccac92 | 721 | fhJetRatioPts[icone][ipt] = new TH2F(Form("JetRatioPt%s",lastnamehist.Data()),Form("p_{T jet}/p_{T trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,2); |
477d6cee | 722 | fhJetRatioPts[icone][ipt]->SetYTitle("p_{T jet}/p_{T trigger}"); |
723 | fhJetRatioPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
1c5acb87 | 724 | |
62ccac92 | 725 | fhJetDeltaPhis[icone][ipt] = new TH2F(Form("JetDeltaPhi%s",lastnamehist.Data()),Form("#phi_{jet} - #phi_{trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,TMath::TwoPi()); |
477d6cee | 726 | fhJetDeltaPhis[icone][ipt]->SetYTitle("#Delta #phi (rad)"); |
727 | fhJetDeltaPhis[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
1c5acb87 | 728 | |
62ccac92 | 729 | fhJetDeltaEtas[icone][ipt] = new TH2F(Form("JetDeltaEta%s",lastnamehist.Data()),Form("#eta_{jet} - #eta_{trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,-2,2); |
477d6cee | 730 | fhJetDeltaEtas[icone][ipt]->SetYTitle("#Delta #eta"); |
731 | fhJetDeltaEtas[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
1c5acb87 | 732 | |
62ccac92 | 733 | fhJetLeadingRatioPts[icone][ipt] = new TH2F(Form("JetLeadingRatioPt%s",lastnamehist.Data()),Form("p_{T jet} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,2); |
477d6cee | 734 | fhJetLeadingRatioPts[icone][ipt]->SetYTitle("p_{T leading}/p_{T jet}"); |
735 | fhJetLeadingRatioPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
1c5acb87 | 736 | |
62ccac92 | 737 | fhJetLeadingDeltaPhis[icone][ipt] = new TH2F(Form("JetLeadingDeltaPhi%s",lastnamehist.Data()),Form("#phi_{jet} - #phi_{leading} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,TMath::TwoPi()); |
477d6cee | 738 | fhJetLeadingDeltaPhis[icone][ipt]->SetYTitle("#Delta #phi (rad)"); |
739 | fhJetLeadingDeltaPhis[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
1c5acb87 | 740 | |
62ccac92 | 741 | fhJetLeadingDeltaEtas[icone][ipt] = new TH2F(Form("JetLeadingDeltaEta%s",lastnamehist.Data()),Form("#eta_{jet} - #eta_{leading} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,-2,2); |
477d6cee | 742 | fhJetLeadingDeltaEtas[icone][ipt]->SetYTitle("#Delta #eta"); |
743 | fhJetLeadingDeltaEtas[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
1c5acb87 | 744 | |
62ccac92 | 745 | fhJetFFzs[icone][ipt] = new TH2F(Form("JetFFz%s",lastnamehist.Data()),"z = p_{T i charged}/p_{T trigger} vs p_{T trigger}", 120,0.,120.,200,0.,2); |
477d6cee | 746 | fhJetFFzs[icone][ipt]->SetYTitle("z"); |
747 | fhJetFFzs[icone][ipt]->SetXTitle("p_{T trigger}"); | |
1c5acb87 | 748 | |
62ccac92 | 749 | fhJetFFxis[icone][ipt] = new TH2F(Form("JetFFxi%s",lastnamehist.Data()),"#xi = ln(p_{T trigger}/p_{T i charged}) vs p_{T trigger}", 120,0.,120.,100,0.,10.); |
477d6cee | 750 | fhJetFFxis[icone][ipt]->SetYTitle("#xi"); |
751 | fhJetFFxis[icone][ipt]->SetXTitle("p_{T trigger}"); | |
1c5acb87 | 752 | |
62ccac92 | 753 | fhJetFFpts[icone][ipt] = new TH2F(Form("JetFFpt%s",lastnamehist.Data()),"p_{T charged hadron } in jet vs p_{T trigger}", 120,0.,120.,200,0.,50.); |
477d6cee | 754 | fhJetFFpts[icone][ipt]->SetYTitle("p_{T charged hadron}"); |
755 | fhJetFFpts[icone][ipt]->SetXTitle("p_{T trigger}"); | |
1c5acb87 | 756 | |
62ccac92 | 757 | fhJetNTracksInCones[icone][ipt] = new TH2F(Form("JetNTracksInCone%s",lastnamehist.Data()),Form("N particles in cone vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,5000,0, 5000); |
477d6cee | 758 | fhJetNTracksInCones[icone][ipt]->SetYTitle("N tracks in jet cone"); |
759 | fhJetNTracksInCones[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
1c5acb87 | 760 | |
477d6cee | 761 | fOutCont->Add(fhJetPts[icone][ipt]) ; |
762 | fOutCont->Add(fhJetRatioPts[icone][ipt]) ; | |
763 | fOutCont->Add(fhJetDeltaPhis[icone][ipt]) ; | |
764 | fOutCont->Add(fhJetDeltaEtas[icone][ipt]) ; | |
765 | fOutCont->Add(fhJetLeadingRatioPts[icone][ipt]) ; | |
766 | fOutCont->Add(fhJetLeadingDeltaPhis[icone][ipt]) ; | |
767 | fOutCont->Add(fhJetLeadingDeltaEtas[icone][ipt]) ; | |
768 | fOutCont->Add(fhJetFFzs[icone][ipt]) ; | |
769 | fOutCont->Add(fhJetFFxis[icone][ipt]) ; | |
770 | fOutCont->Add(fhJetFFpts[icone][ipt]) ; | |
771 | fOutCont->Add(fhJetNTracksInCones[icone][ipt]) ; | |
772 | ||
773 | //Bkg Distributions | |
62ccac92 | 774 | fhBkgPts[icone][ipt] = new TH2F(Form("BkgPt%s",lastnamehist.Data()),Form("p_{T bkg} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); |
477d6cee | 775 | fhBkgPts[icone][ipt]->SetYTitle("p_{T bkg}"); |
776 | fhBkgPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
777 | ||
62ccac92 | 778 | fhBkgRatioPts[icone][ipt] = new TH2F(Form("BkgRatioPt%s",lastnamehist.Data()),Form("p_{T bkg}/p_{T trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,2); |
477d6cee | 779 | fhBkgRatioPts[icone][ipt]->SetYTitle("p_{T bkg}/p_{T trigger}"); |
780 | fhBkgRatioPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
781 | ||
62ccac92 | 782 | fhBkgDeltaPhis[icone][ipt] = new TH2F(Form("BkgDeltaPhi%s",lastnamehist.Data()),Form("#phi_{bkg} - #phi_{trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,TMath::TwoPi()); |
477d6cee | 783 | fhBkgDeltaPhis[icone][ipt]->SetYTitle("#Delta #phi (rad)"); |
784 | fhBkgDeltaPhis[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
785 | ||
62ccac92 | 786 | fhBkgDeltaEtas[icone][ipt] = new TH2F(Form("BkgDeltaEta%s",lastnamehist.Data()),Form("#eta_{bkg} - #eta_{trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,-2,2); |
477d6cee | 787 | fhBkgDeltaEtas[icone][ipt]->SetYTitle("#Delta #eta"); |
788 | fhBkgDeltaEtas[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
789 | ||
62ccac92 | 790 | fhBkgLeadingRatioPts[icone][ipt] = new TH2F(Form("BkgLeadingRatioPt%s",lastnamehist.Data()),Form("p_{T bkg} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,2); |
477d6cee | 791 | fhBkgLeadingRatioPts[icone][ipt]->SetYTitle("p_{T leading}/p_{T bkg}"); |
792 | fhBkgLeadingRatioPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
793 | ||
62ccac92 | 794 | fhBkgLeadingDeltaPhis[icone][ipt] = new TH2F(Form("BkgLeadingDeltaPhi%s",lastnamehist.Data()),Form("#phi_{bkg} - #phi_{leading} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,TMath::TwoPi()); |
477d6cee | 795 | fhBkgLeadingDeltaPhis[icone][ipt]->SetYTitle("#Delta #phi (rad)"); |
796 | fhBkgLeadingDeltaPhis[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
797 | ||
62ccac92 | 798 | fhBkgLeadingDeltaEtas[icone][ipt] = new TH2F(Form("BkgLeadingDeltaEta%s",lastnamehist.Data()),Form("#eta_{bkg} - #eta_{leading} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,-2,2); |
477d6cee | 799 | fhBkgLeadingDeltaEtas[icone][ipt]->SetYTitle("#Delta #eta"); |
800 | fhBkgLeadingDeltaEtas[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
801 | ||
62ccac92 | 802 | fhBkgFFzs[icone][ipt] = new TH2F(Form("BkgFFz%s",lastnamehist.Data()),"z = p_{T i charged}/p_{T trigger} vs p_{T trigger}", 120,0.,120.,200,0.,2); |
477d6cee | 803 | fhBkgFFzs[icone][ipt]->SetYTitle("z"); |
804 | fhBkgFFzs[icone][ipt]->SetXTitle("p_{T trigger}"); | |
805 | ||
62ccac92 | 806 | fhBkgFFxis[icone][ipt] = new TH2F(Form("BkgFFxi%s",lastnamehist.Data()),"#xi = ln(p_{T trigger}/p_{T i charged}) vs p_{T trigger}", 120,0.,120.,100,0.,10.); |
477d6cee | 807 | fhBkgFFxis[icone][ipt]->SetYTitle("#xi"); |
808 | fhBkgFFxis[icone][ipt]->SetXTitle("p_{T trigger}"); | |
809 | ||
62ccac92 | 810 | fhBkgFFpts[icone][ipt] = new TH2F(Form("BkgFFpt%s",lastnamehist.Data()),"p_{T charged hadron} in jet vs p_{T trigger}", 120,0.,120.,200,0.,50.); |
477d6cee | 811 | fhBkgFFpts[icone][ipt]->SetYTitle("p_{T charged hadron}"); |
812 | fhBkgFFpts[icone][ipt]->SetXTitle("p_{T trigger}"); | |
813 | ||
62ccac92 | 814 | fhBkgNTracksInCones[icone][ipt] = new TH2F(Form("BkgNTracksInCone%s",lastnamehist.Data()),Form("N particles in cone vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,5000,0, 5000); |
477d6cee | 815 | fhBkgNTracksInCones[icone][ipt]->SetYTitle("N tracks in bkg cone"); |
816 | fhBkgNTracksInCones[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)"); | |
817 | ||
818 | fOutCont->Add(fhBkgPts[icone][ipt]) ; | |
819 | fOutCont->Add(fhBkgRatioPts[icone][ipt]) ; | |
820 | fOutCont->Add(fhBkgDeltaPhis[icone][ipt]) ; | |
821 | fOutCont->Add(fhBkgDeltaEtas[icone][ipt]) ; | |
822 | fOutCont->Add(fhBkgLeadingRatioPts[icone][ipt]) ; | |
823 | fOutCont->Add(fhBkgLeadingDeltaPhis[icone][ipt]) ; | |
824 | fOutCont->Add(fhBkgLeadingDeltaEtas[icone][ipt]) ; | |
825 | fOutCont->Add(fhBkgFFzs[icone][ipt]) ; | |
826 | fOutCont->Add(fhBkgFFxis[icone][ipt]) ; | |
827 | fOutCont->Add(fhBkgFFpts[icone][ipt]) ; | |
828 | fOutCont->Add(fhBkgNTracksInCones[icone][ipt]) ; | |
1c5acb87 | 829 | |
477d6cee | 830 | }//ipt |
831 | } //icone | |
832 | }//If we want to study any cone or pt threshold | |
833 | ||
9415d854 | 834 | //Keep neutral meson selection histograms if requiered |
835 | //Setting done in AliNeutralMesonSelection | |
836 | if(GetNeutralMesonSelection()){ | |
837 | TList * nmsHistos = GetNeutralMesonSelection()->GetCreateOutputObjects() ; | |
838 | if(GetNeutralMesonSelection()->AreNeutralMesonSelectionHistosKept()) | |
839 | for(Int_t i = 0; i < nmsHistos->GetEntries(); i++) fOutCont->Add(nmsHistos->At(i)) ; | |
a14fd526 | 840 | delete nmsHistos; |
9415d854 | 841 | } |
842 | ||
843 | ||
1e1befe8 | 844 | if(GetDebug() > 2){ |
477d6cee | 845 | printf("AliAnaParticleJetLeadingConeCorrelation::GetCreateOutputObjects() - All histograms names : \n"); |
477d6cee | 846 | for(Int_t i = 0 ; i< fOutCont->GetEntries(); i++) |
1e1befe8 | 847 | printf("Histo i %d name %s\n",i,((fOutCont->At(i))->GetName())); |
477d6cee | 848 | //cout<< (fOutCont->At(i))->GetName()<<endl; |
849 | } | |
850 | ||
851 | return fOutCont; | |
a3aebfff | 852 | |
1c5acb87 | 853 | } |
854 | ||
855 | //____________________________________________________________________________ | |
856 | Bool_t AliAnaParticleJetLeadingConeCorrelation::GetLeadingParticle(AliAODPWG4ParticleCorrelation *particle, TLorentzVector & pLeading) | |
decca433 | 857 | { |
1c5acb87 | 858 | //Search Charged or Neutral leading particle, select the highest one and fill AOD |
859 | ||
860 | TLorentzVector pLeadingCh(0,0,0,0) ; | |
861 | TLorentzVector pLeadingPi0(0,0,0,0) ; | |
862 | ||
863 | GetLeadingCharge(particle, pLeadingCh) ; | |
864 | if(!fJetsOnlyInCTS) GetLeadingPi0(particle, pLeadingPi0) ; | |
865 | ||
866 | Double_t ptch = pLeadingCh.Pt(); | |
867 | Double_t ptpi = pLeadingPi0.Pt(); | |
1c5acb87 | 868 | if (ptch > 0 || ptpi > 0){ |
869 | if((ptch >= ptpi)){ | |
477d6cee | 870 | if(GetDebug() > 1)printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingParticle() - Leading found in CTS \n"); |
1c5acb87 | 871 | pLeading = pLeadingCh; |
9415d854 | 872 | if(GetDebug() > 1) printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingParticle() - Found Leading: pt %2.3f, phi %2.3f deg, eta %2.3f\n", |
477d6cee | 873 | pLeading.Pt(),pLeading.Phi()*TMath::RadToDeg(),pLeading.Eta()) ; |
1c5acb87 | 874 | //Put leading in AOD |
477d6cee | 875 | particle->SetLeading(pLeadingCh); |
876 | particle->SetLeadingDetector("CTS"); | |
877 | return kTRUE; | |
1c5acb87 | 878 | } |
879 | else{ | |
9415d854 | 880 | if(GetDebug() > 1) |
881 | printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingParticle() - Leading found in EMCAL \n"); | |
1c5acb87 | 882 | pLeading = pLeadingPi0; |
9415d854 | 883 | if(GetDebug() > 1) printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingParticle() - Found Leading: pt %2.3f, phi %2.3f, eta %2.3f\n", |
477d6cee | 884 | pLeading.Pt(),pLeading.Phi()*TMath::RadToDeg(),pLeading.Eta()) ; |
1c5acb87 | 885 | //Put leading in AOD |
886 | particle->SetLeading(pLeadingPi0); | |
887 | particle->SetLeadingDetector("EMCAL"); | |
888 | return kTRUE; | |
889 | } | |
890 | } | |
891 | ||
477d6cee | 892 | if(GetDebug() > 1)printf ("AliAnaParticleJetLeadingConeCorrelation::GetLeadingParticle() - NO LEADING PARTICLE FOUND \n"); |
1c5acb87 | 893 | |
894 | return kFALSE; | |
895 | ||
896 | } | |
897 | ||
898 | //____________________________________________________________________________ | |
233e0df8 | 899 | void AliAnaParticleJetLeadingConeCorrelation::GetLeadingCharge(AliAODPWG4ParticleCorrelation* const particle, TLorentzVector & pLeading) const |
1c5acb87 | 900 | { |
901 | //Search for the charged particle with highest pt and with | |
902 | //Phi=Phi_trigger-Pi and pT=0.1E_gamma | |
903 | ||
be518ab0 | 904 | if(GetCTSTracks()){ |
9415d854 | 905 | Double_t ptTrig = particle->Pt(); |
1c5acb87 | 906 | Double_t phiTrig = particle->Phi(); |
9415d854 | 907 | Double_t rat = -100 ; |
908 | Double_t ptl = -100 ; | |
909 | Double_t phil = -100 ; | |
910 | Double_t pt = -100.; | |
911 | Double_t phi = -100.; | |
1c5acb87 | 912 | TVector3 p3; |
913 | ||
be518ab0 | 914 | for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ ){ |
88f9563f | 915 | AliVTrack* track = (AliVTrack *)(GetCTSTracks()->At(ipr)) ; |
1c5acb87 | 916 | p3.SetXYZ(track->Px(),track->Py(),track->Pz()); |
9415d854 | 917 | pt = p3.Pt(); |
1c5acb87 | 918 | phi = p3.Phi() ; |
9415d854 | 919 | if(phi < 0) phi+=TMath::TwoPi(); |
1c5acb87 | 920 | rat = pt/ptTrig ; |
9415d854 | 921 | //printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingCharge() - Tracks: pt %2.3f eta %2.3f phi %2.3f pt/ptTrig %2.3f \n", |
922 | // pt, p3.Eta(), phi,pt/ptTrig) ; | |
923 | Float_t deltaphi = TMath::Abs(phiTrig-phi); | |
924 | if((deltaphi > fDeltaPhiMinCut) && (deltaphi < fDeltaPhiMaxCut) && | |
925 | (rat > fLeadingRatioMinCut) && (rat < fLeadingRatioMaxCut) && (pt > ptl)) { | |
1c5acb87 | 926 | phil = phi ; |
927 | ptl = pt ; | |
928 | pLeading.SetVect(p3); | |
929 | } | |
930 | }// track loop | |
931 | ||
9415d854 | 932 | if(GetDebug() > 1 && ptl > 0 ) printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingCharge() - Leading in CTS: pt %2.3f eta %2.3f phi %2.3f pt/ptTrig %2.3f, |phiTrig-phi| %2.3f \n", |
933 | ptl, pLeading.Eta(), phil,ptl/ptTrig, TMath::Abs(phiTrig-phil)) ; | |
1c5acb87 | 934 | |
935 | }//CTS list exist | |
936 | } | |
937 | ||
938 | //____________________________________________________________________________ | |
decca433 | 939 | void AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0(AliAODPWG4ParticleCorrelation* const particle, TLorentzVector & pLeading) |
1c5acb87 | 940 | { |
941 | //Search for the neutral pion with highest pt and with | |
942 | //Phi=Phi_trigger-Pi and pT=0.1E_gamma | |
477d6cee | 943 | |
be518ab0 | 944 | if(GetEMCALClusters()){ |
9415d854 | 945 | Double_t ptTrig = particle->Pt(); |
1c5acb87 | 946 | Double_t phiTrig = particle->Phi(); |
9415d854 | 947 | Double_t rat = -100 ; |
948 | Double_t ptl = -100 ; | |
949 | Double_t phil = -100 ; | |
950 | Double_t pt = -100.; | |
951 | Double_t phi = -100.; | |
1c5acb87 | 952 | |
953 | TLorentzVector gammai; | |
954 | TLorentzVector gammaj; | |
233e0df8 | 955 | |
f8006433 | 956 | //Get vertex for photon momentum calculation |
957 | Double_t vertex [] = {0,0,0} ; //vertex | |
f8006433 | 958 | if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) |
959 | { | |
960 | GetVertex(vertex); | |
f8006433 | 961 | } |
233e0df8 | 962 | |
1c5acb87 | 963 | //Cluster loop, select pairs with good pt, phi and fill AODs or histograms |
be518ab0 | 964 | for(Int_t iclus = 0;iclus < GetEMCALClusters()->GetEntriesFast() ; iclus ++ ){ |
965 | AliVCluster * calo = (AliVCluster *)(GetEMCALClusters()->At(iclus)) ; | |
1c5acb87 | 966 | |
f8006433 | 967 | //Cluster selection, not charged, with photon or pi0 id and in fiducial cut |
968 | Int_t pdgi=0; | |
f8006433 | 969 | if(!SelectCluster(calo, vertex, gammai, pdgi)) continue ; |
1c5acb87 | 970 | |
9415d854 | 971 | if(GetDebug() > 2) printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0() - Neutral cluster: pt %2.3f, phi %2.3f \n", |
f8006433 | 972 | gammai.Pt(),gammai.Phi()); |
1c5acb87 | 973 | |
974 | //2 gamma overlapped, found with PID | |
975 | if(pdgi == AliCaloPID::kPi0){ | |
f8006433 | 976 | |
977 | if(GetDebug() > 2) printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0() - Neutral cluster ID as Pi0 \n"); | |
978 | ||
979 | pt = gammai.Pt(); | |
980 | rat = pt/ptTrig; | |
981 | phi = gammai.Phi(); | |
982 | if(phi < 0) phi+=TMath::TwoPi(); | |
983 | ||
984 | //Selection within angular and energy limits | |
985 | Float_t deltaphi = TMath::Abs(phiTrig-phi); | |
986 | if(pt > ptl && rat > fLeadingRatioMinCut && rat < fLeadingRatioMaxCut && | |
987 | deltaphi > fDeltaPhiMinCut && deltaphi < fDeltaPhiMaxCut ) | |
988 | { | |
989 | phil = phi ; | |
990 | ptl = pt ; | |
991 | pLeading.SetPxPyPzE(gammai.Px(),gammai.Py(),gammai.Pz(),gammai.E()); | |
992 | }// cuts | |
1c5acb87 | 993 | }// pdg = AliCaloPID::kPi0 |
477d6cee | 994 | //Make invariant mass analysis |
1c5acb87 | 995 | else if(pdgi == AliCaloPID::kPhoton){ |
f8006433 | 996 | //Search the photon companion in case it comes from a Pi0 decay |
997 | //Apply several cuts to select the good pair | |
be518ab0 | 998 | for(Int_t jclus = iclus+1; jclus < GetEMCALClusters()->GetEntriesFast() ; jclus ++ ){ |
999 | AliVCluster * calo2 = (AliVCluster *) (GetEMCALClusters()->At(jclus)) ; | |
f8006433 | 1000 | |
f8006433 | 1001 | //Cluster selection, not charged with photon or pi0 id and in fiducial cut |
1002 | Int_t pdgj=0; | |
49b5c49b | 1003 | |
f8006433 | 1004 | if (!SelectCluster(calo2, vertex, gammaj, pdgj)) continue ; |
1005 | ||
1006 | if(pdgj == AliCaloPID::kPhoton ){ | |
1007 | ||
1008 | pt = (gammai+gammaj).Pt(); | |
1009 | phi = (gammai+gammaj).Phi(); | |
1010 | if(phi < 0) phi+=TMath::TwoPi(); | |
1011 | rat = pt/ptTrig; | |
1012 | ||
1013 | //Selection within angular and energy limits | |
1014 | Float_t deltaphi = TMath::Abs(phiTrig-phi); | |
1015 | if(GetDebug() > 3 ) printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0() - Neutral Hadron Correlation: gamma pair: pt %2.2f, phi %2.2f, eta %2.2f, |phiTrig-phi| %2.3f, pt/ptTrig %2.3f, M %2.3f\n", | |
1016 | pt,phi,(gammai+gammaj).Eta(), deltaphi, rat, (gammai+gammaj).M()); | |
1017 | ||
1018 | if(pt > ptl && rat > fLeadingRatioMinCut && rat < fLeadingRatioMaxCut && | |
1019 | deltaphi > fDeltaPhiMinCut && deltaphi < fDeltaPhiMaxCut ){ | |
1020 | //Select good pair (aperture and invariant mass) | |
3bfcb597 | 1021 | if(GetNeutralMesonSelection()->SelectPair(gammai, gammaj,"EMCAL")){ |
f8006433 | 1022 | phil = phi ; |
1023 | ptl = pt ; | |
1024 | pLeading=(gammai+gammaj); | |
1025 | ||
1026 | if(GetDebug() > 3 ) printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0() - Neutral Hadron Correlation: Selected gamma pair: pt %2.2f, phi %2.2f, eta %2.2f, M %2.3f\n", | |
1027 | ptl,phil,(gammai+gammaj).Eta(), (gammai+gammaj).M()); | |
1028 | }//pi0 selection | |
1029 | ||
1030 | ||
1031 | }//Pair selected as leading | |
1032 | }//if pair of gammas | |
1033 | }//2nd loop | |
1c5acb87 | 1034 | }// if pdg = 22 |
1035 | }// 1st Loop | |
1036 | ||
9415d854 | 1037 | if(GetDebug() > 2 && pLeading.Pt() > 0 ) printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingPi0() - Leading EMCAL: pt %2.3f eta %2.3f phi %2.3f pt/Eg %2.3f \n", |
f8006433 | 1038 | pLeading.Pt(), pLeading.Eta(), phil, pLeading.Pt()/ptTrig) ; |
1c5acb87 | 1039 | |
1040 | }//EMCAL list exists | |
1c5acb87 | 1041 | } |
1042 | ||
1043 | //____________________________________________________________________________ | |
1044 | void AliAnaParticleJetLeadingConeCorrelation::InitParameters() | |
1045 | { | |
477d6cee | 1046 | //Initialize the parameters of the analysis. |
a3aebfff | 1047 | SetInputAODName("PWG4Particle"); |
591cc579 | 1048 | SetAODObjArrayName("JetLeadingCone"); |
a3aebfff | 1049 | AddToHistogramsName("AnaJetLCCorr_"); |
9415d854 | 1050 | |
1c5acb87 | 1051 | fJetsOnlyInCTS = kFALSE ; |
1052 | fPbPb = kFALSE ; | |
1053 | fReMakeJet = kFALSE ; | |
477d6cee | 1054 | |
1c5acb87 | 1055 | //Leading selection parameters |
1056 | fDeltaPhiMinCut = 2.9 ; | |
1057 | fDeltaPhiMaxCut = 3.4 ; | |
1058 | fLeadingRatioMinCut = 0.1; | |
1059 | fLeadingRatioMaxCut = 1.5; | |
9415d854 | 1060 | |
1c5acb87 | 1061 | //Jet selection parameters |
1062 | //Fixed cut | |
1063 | fJetRatioMaxCut = 1.2 ; | |
1064 | fJetRatioMinCut = 0.3 ; | |
1065 | fJetCTSRatioMaxCut = 1.2 ; | |
1066 | fJetCTSRatioMinCut = 0.3 ; | |
1067 | fSelect = 0 ; //0, Accept all jets, 1, selection depends on energy, 2 fixed selection | |
9415d854 | 1068 | |
477d6cee | 1069 | fSelectIsolated = kFALSE; |
9415d854 | 1070 | |
1c5acb87 | 1071 | //Cut depending on gamma energy |
1072 | fPtTriggerSelectionCut = 10.; //For Low pt jets+BKG, another limits applied | |
1073 | //Reconstructed jet energy dependence parameters | |
1074 | //e_jet = a1+e_gamma b2. | |
1075 | //Index 0-> Pt>2 GeV r = 0.3; Index 1-> Pt>0.5 GeV r = 0.3 | |
1076 | fJetE1[0] = -5.75; fJetE1[1] = -4.1; | |
1077 | fJetE2[0] = 1.005; fJetE2[1] = 1.05; | |
1078 | ||
1079 | //Reconstructed sigma of jet energy dependence parameters | |
1080 | //s_jet = a1+e_gamma b2. | |
1081 | //Index 0-> Pt>2 GeV r = 0.3; Index 1-> Pt>0.5 GeV r = 0.3 | |
1082 | fJetSigma1[0] = 2.65; fJetSigma1[1] = 2.75; | |
1083 | fJetSigma2[0] = 0.0018; fJetSigma2[1] = 0.033; | |
1084 | ||
1085 | //Background mean energy and RMS | |
1086 | //Index 0-> No BKG; Index 1-> BKG > 2 GeV; | |
1087 | //Index 2-> (low pt jets)BKG > 0.5 GeV; | |
1088 | //Index > 2, same for CTS conf | |
1089 | fBkgMean[0] = 0.; fBkgMean[1] = 8.8 ; fBkgMean[2] = 69.5; | |
1090 | fBkgMean[3] = 0.; fBkgMean[4] = 6.4; fBkgMean[5] = 48.6; | |
1091 | fBkgRMS[0] = 0.; fBkgRMS[1] = 7.5; fBkgRMS[2] = 22.0; | |
1092 | fBkgRMS[3] = 0.; fBkgRMS[4] = 5.4; fBkgRMS[5] = 13.2; | |
1093 | ||
1094 | //Factor x of min/max = E -+ x * sigma. Obtained after selecting the | |
1095 | //limits for monoenergetic jets. | |
1096 | //Index 0-> No BKG; Index 1-> BKG > 2 GeV; | |
1097 | //Index 2-> (low pt jets) BKG > 0.5 GeV; | |
1098 | //Index > 2, same for CTS conf | |
1099 | ||
1100 | fJetXMin1[0] =-0.69 ; fJetXMin1[1] = 0.39 ; fJetXMin1[2] =-0.88 ; | |
1101 | fJetXMin1[3] =-2.0 ; fJetXMin1[4] =-0.442 ; fJetXMin1[5] =-1.1 ; | |
1102 | fJetXMin2[0] = 0.066; fJetXMin2[1] = 0.038; fJetXMin2[2] = 0.034; | |
1103 | fJetXMin2[3] = 0.25 ; fJetXMin2[4] = 0.113; fJetXMin2[5] = 0.077 ; | |
1104 | fJetXMax1[0] =-3.8 ; fJetXMax1[1] =-0.76 ; fJetXMax1[2] =-3.6 ; | |
1105 | fJetXMax1[3] =-2.7 ; fJetXMax1[4] =-1.21 ; fJetXMax1[5] =-3.7 ; | |
1106 | fJetXMax2[0] =-0.012; fJetXMax2[1] =-0.022; fJetXMax2[2] = 0.016; | |
1107 | fJetXMax2[3] =-0.024; fJetXMax2[4] =-0.008; fJetXMax2[5] = 0.027; | |
1108 | ||
1109 | ||
1110 | //Different cones and pt thresholds to construct the jet | |
1111 | ||
1112 | fJetCone = 0.3 ; | |
1113 | fJetPtThreshold = 0.5 ; | |
1114 | fJetPtThresPbPb = 2. ; | |
1115 | fJetNCone = 4 ; | |
1116 | fJetNPt = 4 ; | |
1117 | fJetCones[0] = 0.2 ; fJetNameCones[0] = "02" ; | |
1118 | fJetCones[1] = 0.3 ; fJetNameCones[1] = "03" ; | |
1119 | fJetCones[2] = 0.4 ; fJetNameCones[2] = "04" ; | |
1120 | fJetCones[2] = 0.5 ; fJetNameCones[2] = "05" ; | |
1121 | ||
1122 | fJetPtThres[0] = 0.0 ; fJetNamePtThres[0] = "00" ; | |
1123 | fJetPtThres[1] = 0.5 ; fJetNamePtThres[1] = "05" ; | |
1124 | fJetPtThres[2] = 1.0 ; fJetNamePtThres[2] = "10" ; | |
1125 | fJetPtThres[3] = 2.0 ; fJetNamePtThres[3] = "20" ; | |
1126 | } | |
1127 | ||
1128 | //__________________________________________________________________________- | |
1129 | Bool_t AliAnaParticleJetLeadingConeCorrelation::IsJetSelected(const Double_t ptTrig, const Double_t ptjet) const { | |
1130 | //Given the pt of the jet and the trigger particle, select the jet or not | |
1131 | //3 options, fSelect=0 accepts all, fSelect=1 selects jets depending on a | |
1132 | //function energy dependent and fSelect=2 selects on simple fixed cuts | |
9415d854 | 1133 | |
1c5acb87 | 1134 | if(ptjet == 0) return kFALSE; |
477d6cee | 1135 | |
1c5acb87 | 1136 | Double_t rat = ptTrig / ptjet ; |
1137 | ||
1138 | //############################################################### | |
1139 | if(fSelect == 0) | |
1140 | return kTRUE; //Accept all jets, no restriction | |
1141 | //############################################################### | |
1142 | else if(fSelect == 1){ | |
1143 | //Check if the energy of the reconstructed jet is within an energy window | |
1144 | //WARNING: to be rechecked, don't remember what all the steps mean | |
1145 | Double_t par[6]; | |
1146 | Double_t xmax[2]; | |
1147 | Double_t xmin[2]; | |
1148 | ||
1149 | Int_t iCTS = 0; | |
1150 | if(fJetsOnlyInCTS) | |
1151 | iCTS = 3 ; | |
1152 | ||
1153 | if(!fPbPb){ | |
1154 | //Phythia alone, jets with pt_th > 0.2, r = 0.3 | |
1155 | par[0] = fJetE1[0]; par[1] = fJetE2[0]; | |
1156 | //Energy of the jet peak | |
1157 | //e_jet = fJetE1[0]+fJetE2[0]*e_gamma, simulation fit | |
1158 | par[2] = fJetSigma1[0]; par[3] = fJetSigma2[0]; | |
1159 | //Sigma of the jet peak | |
1160 | //sigma_jet = fJetSigma1[0]+fJetSigma2[0]*e_gamma, simulation fit | |
1161 | par[4] = fBkgMean[0 + iCTS]; par[5] = fBkgRMS[0 + iCTS]; | |
1162 | //Parameters reserved for PbPb bkg. | |
1163 | xmax[0] = fJetXMax1[0 + iCTS]; xmax[1] = fJetXMax2[0 + iCTS]; | |
1164 | xmin[0] = fJetXMin1[0 + iCTS]; xmin[1] = fJetXMin2[0 + iCTS]; | |
1165 | //Factor that multiplies sigma to obtain the best limits, | |
1166 | //by observation, of mono jet ratios (ptjet/ptTrig) | |
1167 | //X_jet = fJetX1[0]+fJetX2[0]*e_gamma | |
1168 | ||
1169 | } | |
1170 | else{ | |
1171 | if(ptTrig > fPtTriggerSelectionCut){ | |
1172 | //Phythia +PbPb with pt_th > 2 GeV/c, r = 0.3 | |
1173 | par[0] = fJetE1[0]; par[1] = fJetE2[0]; | |
1174 | //Energy of the jet peak, same as in pp | |
1175 | //e_jet = fJetE1[0]+fJetE2[0]*e_gamma, simulation fit | |
1176 | par[2] = fJetSigma1[0]; par[3] = fJetSigma2[0]; | |
1177 | //Sigma of the jet peak, same as in pp | |
1178 | //sigma_jet = fJetSigma1[0]+fJetSigma2[0]*e_gamma, simulation fit | |
1179 | par[4] = fBkgMean[1 + iCTS]; par[5] = fBkgRMS[1 + iCTS]; | |
1180 | //Mean value and RMS of PbPb Bkg | |
1181 | xmax[0] = fJetXMax1[1 + iCTS]; xmax[1] = fJetXMax2[1 + iCTS]; | |
1182 | xmin[0] = fJetXMin1[1 + iCTS]; xmin[1] = fJetXMin2[1 + iCTS]; | |
1183 | //Factor that multiplies sigma to obtain the best limits, | |
1184 | //by observation, of mono jet ratios (ptjet/ptTrig) mixed with PbPb Bkg, | |
1185 | //pt_th > 2 GeV, r = 0.3 | |
1186 | //X_jet = fJetX1[0]+fJetX2[0]*e_gamma | |
1187 | ||
1188 | } | |
1189 | else{ | |
1190 | //Phythia + PbPb with pt_th > 0.5 GeV/c, r = 0.3 | |
1191 | par[0] = fJetE1[1]; par[1] = fJetE2[1]; | |
1192 | //Energy of the jet peak, pt_th > 2 GeV/c, r = 0.3 | |
1193 | //e_jet = fJetE1[0]+fJetE2[0]*e_gamma, simulation fit | |
1194 | par[2] = fJetSigma1[1]; par[3] = fJetSigma2[1]; | |
1195 | //Sigma of the jet peak, pt_th > 2 GeV/c, r = 0.3 | |
1196 | //sigma_jet = fJetSigma1[0]+fJetSigma2[0]*e_gamma, simulation fit | |
1197 | par[4] = fBkgMean[2 + iCTS]; par[5] = fBkgRMS[2 + iCTS]; | |
1198 | //Mean value and RMS of PbPb Bkg in a 0.3 cone, pt > 2 GeV. | |
1199 | xmax[0] = fJetXMax1[2 + iCTS]; xmax[1] = fJetXMax2[2 + iCTS]; | |
1200 | xmin[0] = fJetXMin1[2 + iCTS]; xmin[1] = fJetXMin2[2 + iCTS]; | |
1201 | //Factor that multiplies sigma to obtain the best limits, | |
1202 | //by observation, of mono jet ratios (ptjet/ptTrig) mixed with PbPb Bkg, | |
1203 | //pt_th > 2 GeV, r = 0.3 | |
1204 | //X_jet = fJetX1[0]+fJetX2[0]*e_gamma | |
1205 | ||
1206 | }//If low pt jet in bkg | |
1207 | }//if Bkg | |
1208 | ||
1209 | //Calculate minimum and maximum limits of the jet ratio. | |
1210 | Double_t min = CalculateJetRatioLimit(ptTrig, par, xmin); | |
1211 | Double_t max = CalculateJetRatioLimit(ptTrig, par, xmax); | |
1212 | ||
9415d854 | 1213 | if(GetDebug() > 3)printf("AliAnaParticleJetLeadingConeCorrelation::IsJetSelected() - Jet selection? : Limits min %2.3f, max %2.3f, pt_jet %2.3f, pt_gamma %2.3f, pt_jet / pt_gamma %2.3f\n",min,max,ptjet,ptTrig,rat); |
1c5acb87 | 1214 | |
1215 | if(( min < rat ) && ( max > ptjet/rat)) | |
1216 | return kTRUE; | |
1217 | else | |
1218 | return kFALSE; | |
1219 | }//fSelect = 1 | |
1220 | //############################################################### | |
1221 | else if(fSelect == 2){ | |
1222 | //Simple selection | |
1223 | if(!fJetsOnlyInCTS){ | |
1224 | if((rat < fJetRatioMaxCut) && (rat > fJetRatioMinCut )) return kTRUE; | |
1225 | } | |
1226 | else{ | |
1227 | if((rat < fJetCTSRatioMaxCut) && (rat > fJetCTSRatioMinCut )) return kTRUE; | |
1228 | } | |
1229 | }// fSelect = 2 | |
1230 | //############################################################### | |
1231 | else{ | |
a3aebfff | 1232 | printf("AliAnaParticleJetLeadingConeCorrelation::IsJetSelected() - Jet selection option larger than 2, DON'T SELECT JETS\n"); |
1c5acb87 | 1233 | return kFALSE ; |
1234 | } | |
1235 | ||
1236 | return kFALSE; | |
1237 | ||
1238 | } | |
1239 | ||
1240 | //___________________________________________________________________ | |
1241 | Bool_t AliAnaParticleJetLeadingConeCorrelation::IsParticleInJetCone(const Double_t eta, Double_t phi, const Double_t etal, Double_t phil) | |
9415d854 | 1242 | const { |
1c5acb87 | 1243 | //Check if the particle is inside the cone defined by the leading particle |
1244 | //WARNING: To be rechecked | |
9415d854 | 1245 | |
1c5acb87 | 1246 | if(phi < 0) phi+=TMath::TwoPi(); |
1247 | if(phil < 0) phil+=TMath::TwoPi(); | |
1248 | Double_t rad = 10000 + fJetCone; | |
1249 | ||
1250 | if(TMath::Abs(phi-phil) <= (TMath::TwoPi() - fJetCone)) | |
1251 | rad = TMath::Sqrt(TMath::Power(eta-etal,2)+TMath::Power(phi-phil,2)); | |
1252 | else{ | |
1253 | if(phi-phil > TMath::TwoPi() - fJetCone) | |
1254 | rad = TMath::Sqrt(TMath::Power(eta-etal,2)+TMath::Power((phi-TMath::TwoPi())-phil,2)); | |
1255 | if(phi-phil < -(TMath::TwoPi() - fJetCone)) | |
1256 | rad = TMath::Sqrt(TMath::Power(eta-etal,2)+TMath::Power((phi+TMath::TwoPi())-phil,2)); | |
1257 | } | |
1258 | ||
1259 | if(rad < fJetCone) return kTRUE ; | |
1260 | else return kFALSE ; | |
1261 | ||
1262 | } | |
1263 | ||
1264 | //__________________________________________________________________ | |
1265 | void AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() | |
1266 | { | |
1267 | //Particle-Hadron Correlation Analysis, fill AODs | |
1268 | ||
477d6cee | 1269 | if(!GetInputAODBranch()){ |
1270 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - No input particles in AOD with name branch < %s > \n", | |
1271 | GetInputAODName().Data()); | |
1272 | abort(); | |
1273 | } | |
9415d854 | 1274 | |
1275 | if(strcmp(GetInputAODBranch()->GetClass()->GetName(), "AliAODPWG4ParticleCorrelation")){ | |
1276 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - Wrong type of AOD object, change AOD class name in input AOD: It should be <AliAODPWG4ParticleCorrelation> and not <%s> \n",GetInputAODBranch()->GetClass()->GetName()); | |
1277 | abort(); | |
1278 | } | |
1279 | ||
1c5acb87 | 1280 | if(GetDebug() > 1){ |
477d6cee | 1281 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - Begin jet leading cone correlation analysis, fill AODs \n"); |
a3aebfff | 1282 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast()); |
be518ab0 | 1283 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - In CTS aod entries %d\n", GetCTSTracks()->GetEntriesFast()); |
1284 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetEMCALClusters()->GetEntriesFast()); | |
1c5acb87 | 1285 | } |
1286 | ||
1287 | TLorentzVector pLeading(0,0,0,0); //It will contain the kinematics of the found leading particle | |
1288 | ||
1289 | //Loop on stored AOD particles, trigger | |
1290 | Int_t naod = GetInputAODBranch()->GetEntriesFast(); | |
1291 | for(Int_t iaod = 0; iaod < naod ; iaod++){ | |
a3aebfff | 1292 | AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod)); |
9415d854 | 1293 | |
1294 | // printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - Trigger : pt %3.2f, phi %2.2f, eta %2.2f\n",particle->Pt(), particle->Phi(), particle->Eta()); | |
1295 | ||
1c5acb87 | 1296 | //Search leading particles in CTS and EMCAL |
1297 | if(GetLeadingParticle(particle, pLeading)){ | |
1298 | ||
1299 | //Construct the jet around the leading, Fill AOD jet particle list, select jet | |
1300 | //and fill AOD with jet and background | |
1301 | MakeAODJet(particle, pLeading); | |
9415d854 | 1302 | |
1c5acb87 | 1303 | }//Leading found |
1304 | }//AOD trigger particle loop | |
1305 | ||
477d6cee | 1306 | if(GetDebug() >1)printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - End of jet leading cone analysis, fill AODs \n"); |
1c5acb87 | 1307 | |
1308 | } | |
1309 | ||
1310 | //__________________________________________________________________ | |
1311 | void AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() | |
1312 | { | |
1313 | ||
1314 | //Particle-Hadron Correlation Analysis, fill histograms | |
1315 | ||
477d6cee | 1316 | if(!GetInputAODBranch()){ |
1317 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - No input particles in AOD with name branch < %s > \n", | |
1318 | GetInputAODName().Data()); | |
1319 | abort(); | |
1320 | } | |
1c5acb87 | 1321 | if(GetDebug() > 1){ |
477d6cee | 1322 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - Begin jet leading cone correlation analysis, fill histograms \n"); |
a3aebfff | 1323 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast()); |
be518ab0 | 1324 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - In CTS aod entries %d\n", GetCTSTracks()->GetEntriesFast()); |
1325 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - In EMCAL aod entries %d\n", GetEMCALClusters()->GetEntriesFast()); | |
1c5acb87 | 1326 | } |
477d6cee | 1327 | |
1c5acb87 | 1328 | TLorentzVector pLeading(0,0,0,0) ; |
1329 | ||
1330 | //Loop on stored AOD particles, trigger | |
1331 | Int_t naod = GetInputAODBranch()->GetEntriesFast(); | |
1332 | for(Int_t iaod = 0; iaod < naod ; iaod++){ | |
1333 | AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod)); | |
1334 | ||
477d6cee | 1335 | if(OnlyIsolated() && !particle->IsIsolated()) continue; |
1336 | ||
1c5acb87 | 1337 | Double_t pt = particle->Pt(); |
1338 | Double_t phi = particle->Phi(); | |
1339 | Double_t eta = particle->Eta(); | |
1340 | ||
1341 | //Get leading particle, fill histograms | |
1342 | pLeading = particle->GetLeading(); | |
1343 | TString det = particle->GetLeadingDetector(); | |
477d6cee | 1344 | |
1c5acb87 | 1345 | if(det!="" && pLeading.Pt() > 0){ |
1346 | Double_t ptL = pLeading.Pt(); | |
1347 | Double_t phiL = pLeading.Phi(); | |
1348 | if(phiL < 0 ) phiL+=TMath::TwoPi(); | |
1349 | Double_t etaL = pLeading.Eta(); | |
1350 | ||
9415d854 | 1351 | if(GetDebug() > 1) printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - Trigger with pt %3.2f, phi %2.2f, eta %2.2f\n", pt, phi, eta); |
1352 | ||
1c5acb87 | 1353 | if(det == "CTS"){ |
1354 | fhChargedLeadingPt->Fill(pt,ptL); | |
1355 | fhChargedLeadingPhi->Fill(pt,phiL); | |
1356 | fhChargedLeadingEta->Fill(pt,etaL); | |
1357 | fhChargedLeadingDeltaPt->Fill(pt,pt-ptL); | |
9415d854 | 1358 | fhChargedLeadingDeltaPhi->Fill(pt,TMath::Abs(phi-phiL)); |
1c5acb87 | 1359 | fhChargedLeadingDeltaEta->Fill(pt,eta-etaL); |
1360 | fhChargedLeadingRatioPt->Fill(pt,ptL/pt); | |
9415d854 | 1361 | fhChargedLeadingXi->Fill(pt,TMath::Log(pt/ptL)); |
dde5a268 | 1362 | if(pt > 30) fhChargedLeadingDeltaPhiRatioPt30->Fill(TMath::Abs(phi-phiL),ptL/pt); |
1363 | if(pt > 50) fhChargedLeadingDeltaPhiRatioPt50->Fill(TMath::Abs(phi-phiL),ptL/pt); | |
1c5acb87 | 1364 | } |
1365 | else if(det== "EMCAL"){ | |
1366 | fhNeutralLeadingPt->Fill(pt,ptL); | |
1367 | fhNeutralLeadingPhi->Fill(pt,phiL); | |
1368 | fhNeutralLeadingEta->Fill(pt,etaL); | |
1369 | fhNeutralLeadingDeltaPt->Fill(pt,pt-ptL); | |
9415d854 | 1370 | fhNeutralLeadingDeltaPhi->Fill(pt,TMath::Abs(phi-phiL)); |
1c5acb87 | 1371 | fhNeutralLeadingDeltaEta->Fill(pt,eta-etaL); |
1372 | fhNeutralLeadingRatioPt->Fill(pt,ptL/pt); | |
9415d854 | 1373 | fhNeutralLeadingXi->Fill(pt,TMath::Log(pt/ptL)); |
dde5a268 | 1374 | if(pt > 30) fhNeutralLeadingDeltaPhiRatioPt30->Fill(TMath::Abs(phi-phiL),ptL/pt); |
1375 | if(pt > 50) fhNeutralLeadingDeltaPhiRatioPt50->Fill(TMath::Abs(phi-phiL),ptL/pt); | |
1376 | ||
1c5acb87 | 1377 | } |
1378 | ||
1379 | //Fill Jet histograms | |
1380 | TLorentzVector bkg(0,0,0,0); | |
1381 | TLorentzVector jet(0,0,0,0); | |
1382 | if(!fSeveralConeAndPtCuts){//just fill histograms | |
1383 | if(!fReMakeJet){ | |
1384 | jet=particle->GetCorrelatedJet(); | |
1385 | bkg=particle->GetCorrelatedBackground(); | |
1386 | } | |
1387 | else MakeJetFromAOD(particle, pLeading, jet,bkg); | |
1388 | ||
1389 | if(jet.Pt() > 0){//Jet was found | |
1390 | FillJetHistos(particle, pLeading, jet,"Jet",""); | |
1391 | FillJetHistos(particle, pLeading, bkg,"Bkg",""); | |
1392 | } | |
1393 | } | |
1394 | else if(fSeveralConeAndPtCuts){ | |
1395 | for(Int_t icone = 0; icone<fJetNCone; icone++) { | |
1396 | fJetCone=fJetCones[icone]; | |
1397 | for(Int_t ipt = 0; ipt<fJetNPt;ipt++) { | |
1398 | TString lastname ="Cone"+ fJetNameCones[icone]+"Pt"+ fJetNamePtThres[ipt]; | |
1399 | fJetPtThreshold=fJetPtThres[ipt]; | |
1400 | MakeJetFromAOD(particle, pLeading, jet,bkg); | |
1401 | if(jet.Pt() > 0) {//Jet was found | |
1402 | FillJetHistos(particle, pLeading, jet,"Jet",lastname); | |
1403 | FillJetHistos(particle, pLeading, bkg,"Bkg",lastname); | |
1404 | } | |
1405 | }//icone | |
1406 | }//ipt | |
1407 | }//fSeveralConeAndPtCuts | |
1408 | }//Leading | |
1409 | }//AOD trigger particle loop | |
1410 | ||
477d6cee | 1411 | if(GetDebug() >1)printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - End of jet leading cone analysis, fill histograms \n"); |
1c5acb87 | 1412 | |
1413 | } | |
1414 | ||
ad5fec38 | 1415 | //_______________________________________________________________________________________________ |
1416 | void AliAnaParticleJetLeadingConeCorrelation::MakeAODJet(AliAODPWG4ParticleCorrelation *particle, | |
1417 | const TLorentzVector pLeading) | |
1418 | { | |
1c5acb87 | 1419 | //Fill the jet with the particles around the leading particle with |
1420 | //R=fJetCone and pt_th = fJetPtThres. Calculate the energy of the jet and | |
1421 | //fill aod with found information | |
1422 | ||
1423 | TLorentzVector bkg(0,0,0,0); | |
1424 | TLorentzVector jet(0,0,0,0); | |
1425 | TLorentzVector lv (0,0,0,0); //Temporal container for jet particles kinematics | |
1426 | ||
477d6cee | 1427 | Double_t ptTrig = particle->Pt(); |
1428 | Double_t phiTrig = particle->Phi(); | |
1429 | Double_t phil = pLeading.Phi(); | |
1c5acb87 | 1430 | if(phil<0) phil+=TMath::TwoPi(); |
477d6cee | 1431 | Double_t etal = pLeading.Eta(); |
477d6cee | 1432 | |
1c5acb87 | 1433 | //Different pt cut for jet particles in different collisions systems |
1434 | Float_t ptcut = fJetPtThreshold; | |
1435 | if(fPbPb && !fSeveralConeAndPtCuts && ptTrig > fPtTriggerSelectionCut) ptcut = fJetPtThresPbPb ; | |
1436 | ||
1437 | //Add charged particles to jet if they are in cone around the leading particle | |
be518ab0 | 1438 | if(!GetCTSTracks()) { |
477d6cee | 1439 | printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - Cannot construct jets without tracks, STOP analysis"); |
1c5acb87 | 1440 | return; |
1441 | } | |
1442 | ||
1443 | //Fill jet with tracks | |
1444 | TVector3 p3; | |
a3aebfff | 1445 | //Initialize reference arrays that will contain jet and background tracks |
591cc579 | 1446 | TObjArray * reftracks = new TObjArray; |
1447 | TObjArray * reftracksbkg = new TObjArray; | |
9415d854 | 1448 | |
be518ab0 | 1449 | for(Int_t ipr = 0;ipr < (GetCTSTracks())->GetEntriesFast() ; ipr ++ ){ |
88f9563f | 1450 | AliVTrack* track = (AliVTrack *)((GetCTSTracks())->At(ipr)) ; |
1c5acb87 | 1451 | p3.SetXYZ(track->Px(),track->Py(),track->Pz()); |
1452 | ||
1453 | //Particles in jet | |
1454 | if(IsParticleInJetCone(p3.Eta(), p3.Phi(), etal, phil)){ | |
477d6cee | 1455 | |
a3aebfff | 1456 | reftracks->Add(track); |
9415d854 | 1457 | |
1c5acb87 | 1458 | if(p3.Pt() > ptcut ){ |
1459 | lv.SetVect(p3); | |
1460 | jet+=lv; | |
1461 | } | |
1462 | } | |
9415d854 | 1463 | |
1c5acb87 | 1464 | //Background around (phi_gamma-pi, eta_leading) |
1465 | else if(IsParticleInJetCone(p3.Eta(),p3.Phi(),etal, phiTrig)) { | |
9415d854 | 1466 | |
a3aebfff | 1467 | reftracksbkg->Add(track); |
1468 | ||
1c5acb87 | 1469 | if(p3.Pt() > ptcut ){ |
1470 | lv.SetVect(p3); | |
1471 | bkg+=lv; | |
1472 | } | |
1473 | } | |
1474 | }//Track loop | |
1475 | ||
a3aebfff | 1476 | //Add referenced tracks to AOD |
1477 | if(reftracks->GetEntriesFast() > 0 ){ | |
591cc579 | 1478 | reftracks->SetName(Form("%sTracks",GetAODObjArrayName().Data())); |
1479 | particle->AddObjArray(reftracks); | |
a3aebfff | 1480 | } |
9415d854 | 1481 | else if(GetDebug() > 2 ) printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - No tracks in jet cone\n"); |
a3aebfff | 1482 | if(reftracksbkg->GetEntriesFast() > 0 ){ |
591cc579 | 1483 | reftracksbkg->SetName(Form("%sTracksBkg",GetAODObjArrayName().Data())); |
1484 | particle->AddObjArray(reftracksbkg); | |
a3aebfff | 1485 | } |
9415d854 | 1486 | else if(GetDebug() > 2 ) printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - No background tracks in jet cone\n"); |
1487 | ||
1c5acb87 | 1488 | //Add neutral particles to jet |
a3aebfff | 1489 | //Initialize reference arrays that will contain jet and background tracks |
591cc579 | 1490 | TObjArray * refclusters = new TObjArray; |
1491 | TObjArray * refclustersbkg = new TObjArray; | |
be518ab0 | 1492 | if(!fJetsOnlyInCTS && GetEMCALClusters()){ |
1c5acb87 | 1493 | |
233e0df8 | 1494 | //Get vertex for photon momentum calculation |
1495 | Double_t vertex[] = {0,0,0} ; //vertex | |
edd59991 | 1496 | if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) |
233e0df8 | 1497 | { |
1498 | GetReader()->GetVertex(vertex); | |
1e68a3f4 | 1499 | //if(GetReader()->GetSecondInputAODTree()) GetReader()->GetSecondInputAODVertex(vertex2); |
233e0df8 | 1500 | } |
1501 | ||
be518ab0 | 1502 | for(Int_t iclus = 0;iclus < (GetEMCALClusters())->GetEntriesFast() ; iclus ++ ){ |
1503 | AliVCluster * calo = (AliVCluster *) (GetEMCALClusters()->At(iclus)) ; | |
1c5acb87 | 1504 | |
1505 | //Cluster selection, not charged | |
49b5c49b | 1506 | if(IsTrackMatched(calo,GetReader()->GetInputEvent())) continue ; |
1c5acb87 | 1507 | |
49b5c49b | 1508 | //Get Momentum vector, |
1509 | calo->GetMomentum(lv,vertex) ;//Assume that come from vertex in straight line | |
233e0df8 | 1510 | |
1c5acb87 | 1511 | //Particles in jet |
1512 | if(IsParticleInJetCone(lv.Eta(),lv.Phi(), etal, phil)){ | |
591cc579 | 1513 | |
a3aebfff | 1514 | refclusters->Add(calo); |
1515 | ||
1c5acb87 | 1516 | if(lv.Pt() > ptcut ) jet+=lv; |
1517 | } | |
1518 | //Background around (phi_gamma-pi, eta_leading) | |
1519 | else if(IsParticleInJetCone(lv.Eta(),lv.Phi(),etal, phiTrig)){ | |
a3aebfff | 1520 | |
477d6cee | 1521 | |
a3aebfff | 1522 | refclustersbkg->Add(calo); |
1523 | ||
1c5acb87 | 1524 | if(lv.Pt() > ptcut ) bkg+=lv; |
1525 | } | |
1526 | }//cluster loop | |
1527 | }//jets with neutral particles | |
1528 | ||
a3aebfff | 1529 | //Add referenced clusters to AOD |
1530 | if(refclusters->GetEntriesFast() > 0 ){ | |
591cc579 | 1531 | refclusters->SetName(Form("%sClusters",GetAODObjArrayName().Data())); |
1532 | particle->AddObjArray(refclusters); | |
a3aebfff | 1533 | } |
9415d854 | 1534 | else if(GetDebug() > 2 ) printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - No clusters in jet cone\n"); |
a3aebfff | 1535 | if(refclustersbkg->GetEntriesFast() > 0 ){ |
591cc579 | 1536 | refclustersbkg->SetName(Form("%sClustersBkg",GetAODObjArrayName().Data())); |
1537 | particle->AddObjArray(refclustersbkg); | |
a3aebfff | 1538 | } |
9415d854 | 1539 | else if(GetDebug() > 2 ) printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - No background clusters in jet cone\n"); |
1540 | ||
1c5acb87 | 1541 | //If there is any jet found, select after some criteria and |
1542 | //and fill AOD with corresponding TLorentzVector kinematics | |
1543 | if(IsJetSelected(particle->Pt(), jet.Pt())) { | |
1544 | particle->SetCorrelatedJet(jet); | |
1545 | particle->SetCorrelatedBackground(bkg); | |
9415d854 | 1546 | if(GetDebug()>1) printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - Found jet: Trigger pt %2.3f, Jet pt %2.3f, Bkg pt %2.3f\n",ptTrig,jet.Pt(),bkg.Pt()); |
1c5acb87 | 1547 | } |
1548 | ||
1549 | } | |
1550 | ||
49b5c49b | 1551 | //______________________________________________________________________________________________________ |
1552 | void AliAnaParticleJetLeadingConeCorrelation::MakeJetFromAOD(AliAODPWG4ParticleCorrelation *particle, | |
1553 | const TLorentzVector pLeading, | |
1554 | TLorentzVector & jet, TLorentzVector & bkg) const | |
1555 | { | |
1c5acb87 | 1556 | //Fill the jet with the particles around the leading particle with |
1557 | //R=fJetCone and pt_th = fJetPtThres. Calculate the energy of the jet and | |
1558 | //fill aod tlorentzvectors with jet and bakcground found | |
9415d854 | 1559 | |
1c5acb87 | 1560 | TLorentzVector lv (0,0,0,0); //Temporal container for jet particles kinematics |
1561 | ||
1562 | Double_t ptTrig = particle->Pt(); | |
1563 | Double_t phiTrig = particle->Phi(); | |
1564 | Double_t phil = pLeading.Phi(); | |
9415d854 | 1565 | if(phil < 0) phil+=TMath::TwoPi(); |
1c5acb87 | 1566 | Double_t etal = pLeading.Eta(); |
1567 | ||
2fa19d54 | 1568 | TObjArray * refclusters = particle->GetObjArray(Form("Clusters%s" ,GetAODObjArrayName().Data())); |
1569 | TObjArray * reftracks = particle->GetObjArray(Form("Tracks%s" ,GetAODObjArrayName().Data())); | |
1570 | TObjArray * refclustersbkg = particle->GetObjArray(Form("ClustersBkg%s",GetAODObjArrayName().Data())); | |
1571 | TObjArray * reftracksbkg = particle->GetObjArray(Form("TracksBkg%s" ,GetAODObjArrayName().Data())); | |
9415d854 | 1572 | |
1c5acb87 | 1573 | //Different pt cut for jet particles in different collisions systems |
1574 | Float_t ptcut = fJetPtThreshold; | |
1575 | if(fPbPb && !fSeveralConeAndPtCuts && ptTrig > fPtTriggerSelectionCut) ptcut = fJetPtThresPbPb ; | |
a3aebfff | 1576 | |
1c5acb87 | 1577 | //Fill jet with tracks |
1578 | //Particles in jet | |
1579 | TVector3 p3; | |
a3aebfff | 1580 | if(reftracks){ |
1581 | for(Int_t ipr = 0;ipr < reftracks->GetEntriesFast() ; ipr ++ ){ | |
88f9563f | 1582 | AliVTrack* track = (AliVTrack *) reftracks->At(ipr) ; |
a3aebfff | 1583 | p3.SetXYZ(track->Px(),track->Py(),track->Pz()); |
9415d854 | 1584 | Float_t phi = p3.Phi(); |
1585 | if(phi < 0) phi+=TMath::TwoPi(); | |
1586 | if(p3.Pt() > ptcut && IsParticleInJetCone(p3.Eta(), phi, etal, phil) ){ | |
49b5c49b | 1587 | lv.SetVect(p3); |
1588 | jet+=lv; | |
a3aebfff | 1589 | } |
1590 | }//jet Track loop | |
1591 | } | |
1c5acb87 | 1592 | //Particles in background |
a3aebfff | 1593 | if(reftracksbkg){ |
9415d854 | 1594 | for(Int_t ipr = 0;ipr < reftracksbkg->GetEntriesFast() ; ipr ++ ){ |
88f9563f | 1595 | AliVTrack* track = (AliVTrack *) reftracksbkg->At(ipr) ; |
9415d854 | 1596 | p3.SetXYZ(track->Px(),track->Py(),track->Pz()); |
1597 | if(p3.Pt() > ptcut && IsParticleInJetCone(p3.Eta(),p3.Phi(),etal, phiTrig) ) { | |
49b5c49b | 1598 | lv.SetVect(p3); |
1599 | bkg+=lv; | |
9415d854 | 1600 | } |
1601 | }//background Track loop | |
a3aebfff | 1602 | } |
9415d854 | 1603 | |
1c5acb87 | 1604 | //Add neutral particles to jet |
a3aebfff | 1605 | if(!fJetsOnlyInCTS && refclusters){ |
1c5acb87 | 1606 | |
49b5c49b | 1607 | //Get vertex for photon momentum calculation |
1608 | Double_t vertex[] = {0,0,0} ; //vertex | |
1609 | if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC) | |
1610 | { | |
1611 | GetReader()->GetVertex(vertex); | |
1612 | } | |
233e0df8 | 1613 | |
1c5acb87 | 1614 | //Loop on jet particles |
9415d854 | 1615 | if(refclusters){ |
1616 | for(Int_t iclus = 0;iclus < refclusters->GetEntriesFast() ; iclus ++ ){ | |
49b5c49b | 1617 | AliVCluster * calo = (AliVCluster *) refclusters->At(iclus) ; |
1618 | ||
1619 | calo->GetMomentum(lv,vertex) ;//Assume that come from vertex in straight line | |
1620 | ||
1621 | if(lv.Pt() > ptcut && IsParticleInJetCone(lv.Eta(),lv.Phi(), etal, phil)) jet+=lv; | |
9415d854 | 1622 | }//jet cluster loop |
1623 | } | |
1624 | ||
1625 | //Loop on background particles | |
1626 | if(refclustersbkg){ | |
1627 | for(Int_t iclus = 0;iclus < refclustersbkg->GetEntriesFast() ; iclus ++ ){ | |
49b5c49b | 1628 | AliVCluster * calo = (AliVCluster *) refclustersbkg->At(iclus) ; |
1629 | ||
1630 | calo->GetMomentum(lv,vertex) ;//Assume that come from vertex in straight line | |
1631 | ||
1632 | if( lv.Pt() > ptcut && IsParticleInJetCone(lv.Eta(),lv.Phi(),etal, phiTrig)) bkg+=lv; | |
9415d854 | 1633 | }//background cluster loop |
a3aebfff | 1634 | } |
1c5acb87 | 1635 | }//clusters in jet |
9415d854 | 1636 | |
1c5acb87 | 1637 | //If there is any jet found, leave jet and bkg as they are, |
1638 | //if not set them to 0. | |
1639 | if(!IsJetSelected(particle->Pt(), jet.Pt())) { | |
1640 | jet.SetPxPyPzE(0.,0.,0.,0.); | |
1641 | bkg.SetPxPyPzE(0.,0.,0.,0.); | |
1642 | } | |
1643 | else | |
9415d854 | 1644 | if(GetDebug()>1) printf("AliAnaParticleJetLeadingConeCorrelation::MakeJetFromAOD() - Found jet: Trigger pt %2.3f, Jet pt %2.3f, Bkg pt %2.3f\n",ptTrig,jet.Pt(),bkg.Pt()); |
1c5acb87 | 1645 | |
1646 | } | |
1647 | ||
1c5acb87 | 1648 | //__________________________________________________________________ |
1649 | void AliAnaParticleJetLeadingConeCorrelation::Print(const Option_t * opt) const | |
1650 | { | |
9415d854 | 1651 | |
1c5acb87 | 1652 | //Print some relevant parameters set for the analysis |
1653 | if(! opt) | |
1654 | return; | |
1655 | ||
a3aebfff | 1656 | printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ; |
745913ae | 1657 | AliAnaCaloTrackCorrBaseClass::Print(" "); |
9415d854 | 1658 | |
1c5acb87 | 1659 | if(fJetsOnlyInCTS)printf("Jets reconstructed in CTS \n"); |
1660 | else printf("Jets reconstructed in CTS+EMCAL \n"); | |
9415d854 | 1661 | |
1c5acb87 | 1662 | if(fPbPb) printf("PbPb events, pT cut in jet cone energy reconstruction %2.1f \n", fJetPtThreshold); |
1663 | else printf("pp events, pT cut in jet cone energy reconstruction %2.1f \n", fJetPtThresPbPb); | |
9415d854 | 1664 | |
1665 | printf("If pT of trigger < %2.3f, select jets as in pp? \n", fPtTriggerSelectionCut); | |
1666 | ||
1c5acb87 | 1667 | printf("Phi gamma-Leading < %3.2f\n", fDeltaPhiMaxCut) ; |
1668 | printf("Phi gamma-Leading > %3.2f\n", fDeltaPhiMinCut) ; | |
1669 | printf("pT Leading / pT Trigger < %3.2f\n", fLeadingRatioMaxCut) ; | |
1670 | printf("pT Leading / pT Trigger > %3.2f\n", fLeadingRatioMinCut) ; | |
1671 | ||
1672 | if(fSelect == 2){ | |
1673 | printf("pT Jet / pT Gamma < %3.2f\n", fJetRatioMaxCut) ; | |
1674 | printf("pT Jet / pT Gamma > %3.2f\n", fJetRatioMinCut) ; | |
1675 | printf("pT Jet (Only CTS)/ pT Trigger < %3.2f\n", fJetCTSRatioMaxCut) ; | |
1676 | printf("pT Jet (Only CTS)/ pT Trigger > %3.2f\n", fJetCTSRatioMinCut) ; | |
1677 | } | |
1678 | else if(fSelect == 0) | |
1679 | printf("Accept all reconstructed jets \n") ; | |
1680 | else if(fSelect == 1) | |
1681 | printf("Accept jets depending on trigger energy \n") ; | |
1682 | else | |
1683 | printf("Wrong jet selection option: %d \n", fSelect) ; | |
9415d854 | 1684 | |
477d6cee | 1685 | printf("Isolated Trigger? %d\n", fSelectIsolated) ; |
1c5acb87 | 1686 | |
1687 | } |