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