]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/CaloTrackCorrelations/AliAnaParticleJetLeadingConeCorrelation.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fix wrong initialization of int with a float
[u/mrichter/AliRoot.git] / PWGGA / CaloTrackCorrelations / AliAnaParticleJetLeadingConeCorrelation.cxx
CommitLineData
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
46ClassImp(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//____________________________________________________________________________
143AliAnaParticleJetLeadingConeCorrelation::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//_________________________________________________________________________
239AliAnaParticleJetLeadingConeCorrelation & 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//____________________________________________________________________________
352AliAnaParticleJetLeadingConeCorrelation::~AliAnaParticleJetLeadingConeCorrelation()
353{
354 // Remove all pointers except analysis output pointers.
1c5acb87 355}
356
357//____________________________________________________________________________
358Double_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//____________________________________________________________________________
374void 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//________________________________________________________________________
465TList * 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//____________________________________________________________________________
856Bool_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 899void 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 939void 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//____________________________________________________________________________
1044void 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//__________________________________________________________________________-
1129Bool_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//___________________________________________________________________
1241Bool_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//__________________________________________________________________
1265void 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//__________________________________________________________________
1311void 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//_______________________________________________________________________________________________
1416void 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//______________________________________________________________________________________________________
1552void 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//__________________________________________________________________
1649void 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}