]> 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
Updated Ds PID information (Gian Michele)
[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
1413//____________________________________________________________________________
1414void AliAnaParticleJetLeadingConeCorrelation::MakeAODJet(AliAODPWG4ParticleCorrelation *particle, const TLorentzVector pLeading)
9415d854 1415 const {
1c5acb87 1416 //Fill the jet with the particles around the leading particle with
1417 //R=fJetCone and pt_th = fJetPtThres. Calculate the energy of the jet and
1418 //fill aod with found information
1419
1420 TLorentzVector bkg(0,0,0,0);
1421 TLorentzVector jet(0,0,0,0);
1422 TLorentzVector lv (0,0,0,0); //Temporal container for jet particles kinematics
1423
477d6cee 1424 Double_t ptTrig = particle->Pt();
1425 Double_t phiTrig = particle->Phi();
1426 Double_t phil = pLeading.Phi();
1c5acb87 1427 if(phil<0) phil+=TMath::TwoPi();
477d6cee 1428 Double_t etal = pLeading.Eta();
477d6cee 1429
1c5acb87 1430 //Different pt cut for jet particles in different collisions systems
1431 Float_t ptcut = fJetPtThreshold;
1432 if(fPbPb && !fSeveralConeAndPtCuts && ptTrig > fPtTriggerSelectionCut) ptcut = fJetPtThresPbPb ;
1433
1434 //Add charged particles to jet if they are in cone around the leading particle
be518ab0 1435 if(!GetCTSTracks()) {
477d6cee 1436 printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - Cannot construct jets without tracks, STOP analysis");
1c5acb87 1437 return;
1438 }
1439
1440 //Fill jet with tracks
1441 TVector3 p3;
a3aebfff 1442 //Initialize reference arrays that will contain jet and background tracks
591cc579 1443 TObjArray * reftracks = new TObjArray;
1444 TObjArray * reftracksbkg = new TObjArray;
9415d854 1445
be518ab0 1446 for(Int_t ipr = 0;ipr < (GetCTSTracks())->GetEntriesFast() ; ipr ++ ){
88f9563f 1447 AliVTrack* track = (AliVTrack *)((GetCTSTracks())->At(ipr)) ;
1c5acb87 1448 p3.SetXYZ(track->Px(),track->Py(),track->Pz());
1449
1450 //Particles in jet
1451 if(IsParticleInJetCone(p3.Eta(), p3.Phi(), etal, phil)){
477d6cee 1452
a3aebfff 1453 reftracks->Add(track);
9415d854 1454
1c5acb87 1455 if(p3.Pt() > ptcut ){
1456 lv.SetVect(p3);
1457 jet+=lv;
1458 }
1459 }
9415d854 1460
1c5acb87 1461 //Background around (phi_gamma-pi, eta_leading)
1462 else if(IsParticleInJetCone(p3.Eta(),p3.Phi(),etal, phiTrig)) {
9415d854 1463
a3aebfff 1464 reftracksbkg->Add(track);
1465
1c5acb87 1466 if(p3.Pt() > ptcut ){
1467 lv.SetVect(p3);
1468 bkg+=lv;
1469 }
1470 }
1471 }//Track loop
1472
a3aebfff 1473 //Add referenced tracks to AOD
1474 if(reftracks->GetEntriesFast() > 0 ){
591cc579 1475 reftracks->SetName(Form("%sTracks",GetAODObjArrayName().Data()));
1476 particle->AddObjArray(reftracks);
a3aebfff 1477 }
9415d854 1478 else if(GetDebug() > 2 ) printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - No tracks in jet cone\n");
a3aebfff 1479 if(reftracksbkg->GetEntriesFast() > 0 ){
591cc579 1480 reftracksbkg->SetName(Form("%sTracksBkg",GetAODObjArrayName().Data()));
1481 particle->AddObjArray(reftracksbkg);
a3aebfff 1482 }
9415d854 1483 else if(GetDebug() > 2 ) printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - No background tracks in jet cone\n");
1484
1c5acb87 1485 //Add neutral particles to jet
a3aebfff 1486 //Initialize reference arrays that will contain jet and background tracks
591cc579 1487 TObjArray * refclusters = new TObjArray;
1488 TObjArray * refclustersbkg = new TObjArray;
be518ab0 1489 if(!fJetsOnlyInCTS && GetEMCALClusters()){
1c5acb87 1490
233e0df8 1491 //Get vertex for photon momentum calculation
1492 Double_t vertex[] = {0,0,0} ; //vertex
edd59991 1493 if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC)
233e0df8 1494 {
1495 GetReader()->GetVertex(vertex);
1e68a3f4 1496 //if(GetReader()->GetSecondInputAODTree()) GetReader()->GetSecondInputAODVertex(vertex2);
233e0df8 1497 }
1498
be518ab0 1499 for(Int_t iclus = 0;iclus < (GetEMCALClusters())->GetEntriesFast() ; iclus ++ ){
1500 AliVCluster * calo = (AliVCluster *) (GetEMCALClusters()->At(iclus)) ;
1c5acb87 1501
1502 //Cluster selection, not charged
49b5c49b 1503 if(IsTrackMatched(calo,GetReader()->GetInputEvent())) continue ;
1c5acb87 1504
49b5c49b 1505 //Get Momentum vector,
1506 calo->GetMomentum(lv,vertex) ;//Assume that come from vertex in straight line
233e0df8 1507
1c5acb87 1508 //Particles in jet
1509 if(IsParticleInJetCone(lv.Eta(),lv.Phi(), etal, phil)){
591cc579 1510
a3aebfff 1511 refclusters->Add(calo);
1512
1c5acb87 1513 if(lv.Pt() > ptcut ) jet+=lv;
1514 }
1515 //Background around (phi_gamma-pi, eta_leading)
1516 else if(IsParticleInJetCone(lv.Eta(),lv.Phi(),etal, phiTrig)){
a3aebfff 1517
477d6cee 1518
a3aebfff 1519 refclustersbkg->Add(calo);
1520
1c5acb87 1521 if(lv.Pt() > ptcut ) bkg+=lv;
1522 }
1523 }//cluster loop
1524 }//jets with neutral particles
1525
a3aebfff 1526 //Add referenced clusters to AOD
1527 if(refclusters->GetEntriesFast() > 0 ){
591cc579 1528 refclusters->SetName(Form("%sClusters",GetAODObjArrayName().Data()));
1529 particle->AddObjArray(refclusters);
a3aebfff 1530 }
9415d854 1531 else if(GetDebug() > 2 ) printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - No clusters in jet cone\n");
a3aebfff 1532 if(refclustersbkg->GetEntriesFast() > 0 ){
591cc579 1533 refclustersbkg->SetName(Form("%sClustersBkg",GetAODObjArrayName().Data()));
1534 particle->AddObjArray(refclustersbkg);
a3aebfff 1535 }
9415d854 1536 else if(GetDebug() > 2 ) printf("AliAnaParticleJetLeadingConeCorrelation::MakeAODJet() - No background clusters in jet cone\n");
1537
1c5acb87 1538 //If there is any jet found, select after some criteria and
1539 //and fill AOD with corresponding TLorentzVector kinematics
1540 if(IsJetSelected(particle->Pt(), jet.Pt())) {
1541 particle->SetCorrelatedJet(jet);
1542 particle->SetCorrelatedBackground(bkg);
9415d854 1543 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 1544 }
1545
1546}
1547
49b5c49b 1548//______________________________________________________________________________________________________
1549void AliAnaParticleJetLeadingConeCorrelation::MakeJetFromAOD(AliAODPWG4ParticleCorrelation *particle,
1550 const TLorentzVector pLeading,
1551 TLorentzVector & jet, TLorentzVector & bkg) const
1552{
1c5acb87 1553 //Fill the jet with the particles around the leading particle with
1554 //R=fJetCone and pt_th = fJetPtThres. Calculate the energy of the jet and
1555 //fill aod tlorentzvectors with jet and bakcground found
9415d854 1556
1c5acb87 1557 TLorentzVector lv (0,0,0,0); //Temporal container for jet particles kinematics
1558
1559 Double_t ptTrig = particle->Pt();
1560 Double_t phiTrig = particle->Phi();
1561 Double_t phil = pLeading.Phi();
9415d854 1562 if(phil < 0) phil+=TMath::TwoPi();
1c5acb87 1563 Double_t etal = pLeading.Eta();
1564
2fa19d54 1565 TObjArray * refclusters = particle->GetObjArray(Form("Clusters%s" ,GetAODObjArrayName().Data()));
1566 TObjArray * reftracks = particle->GetObjArray(Form("Tracks%s" ,GetAODObjArrayName().Data()));
1567 TObjArray * refclustersbkg = particle->GetObjArray(Form("ClustersBkg%s",GetAODObjArrayName().Data()));
1568 TObjArray * reftracksbkg = particle->GetObjArray(Form("TracksBkg%s" ,GetAODObjArrayName().Data()));
9415d854 1569
1c5acb87 1570 //Different pt cut for jet particles in different collisions systems
1571 Float_t ptcut = fJetPtThreshold;
1572 if(fPbPb && !fSeveralConeAndPtCuts && ptTrig > fPtTriggerSelectionCut) ptcut = fJetPtThresPbPb ;
a3aebfff 1573
1c5acb87 1574 //Fill jet with tracks
1575 //Particles in jet
1576 TVector3 p3;
a3aebfff 1577 if(reftracks){
1578 for(Int_t ipr = 0;ipr < reftracks->GetEntriesFast() ; ipr ++ ){
88f9563f 1579 AliVTrack* track = (AliVTrack *) reftracks->At(ipr) ;
a3aebfff 1580 p3.SetXYZ(track->Px(),track->Py(),track->Pz());
9415d854 1581 Float_t phi = p3.Phi();
1582 if(phi < 0) phi+=TMath::TwoPi();
1583 if(p3.Pt() > ptcut && IsParticleInJetCone(p3.Eta(), phi, etal, phil) ){
49b5c49b 1584 lv.SetVect(p3);
1585 jet+=lv;
a3aebfff 1586 }
1587 }//jet Track loop
1588 }
1c5acb87 1589 //Particles in background
a3aebfff 1590 if(reftracksbkg){
9415d854 1591 for(Int_t ipr = 0;ipr < reftracksbkg->GetEntriesFast() ; ipr ++ ){
88f9563f 1592 AliVTrack* track = (AliVTrack *) reftracksbkg->At(ipr) ;
9415d854 1593 p3.SetXYZ(track->Px(),track->Py(),track->Pz());
1594 if(p3.Pt() > ptcut && IsParticleInJetCone(p3.Eta(),p3.Phi(),etal, phiTrig) ) {
49b5c49b 1595 lv.SetVect(p3);
1596 bkg+=lv;
9415d854 1597 }
1598 }//background Track loop
a3aebfff 1599 }
9415d854 1600
1c5acb87 1601 //Add neutral particles to jet
a3aebfff 1602 if(!fJetsOnlyInCTS && refclusters){
1c5acb87 1603
49b5c49b 1604 //Get vertex for photon momentum calculation
1605 Double_t vertex[] = {0,0,0} ; //vertex
1606 if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC)
1607 {
1608 GetReader()->GetVertex(vertex);
1609 }
233e0df8 1610
1c5acb87 1611 //Loop on jet particles
9415d854 1612 if(refclusters){
1613 for(Int_t iclus = 0;iclus < refclusters->GetEntriesFast() ; iclus ++ ){
49b5c49b 1614 AliVCluster * calo = (AliVCluster *) refclusters->At(iclus) ;
1615
1616 calo->GetMomentum(lv,vertex) ;//Assume that come from vertex in straight line
1617
1618 if(lv.Pt() > ptcut && IsParticleInJetCone(lv.Eta(),lv.Phi(), etal, phil)) jet+=lv;
9415d854 1619 }//jet cluster loop
1620 }
1621
1622 //Loop on background particles
1623 if(refclustersbkg){
1624 for(Int_t iclus = 0;iclus < refclustersbkg->GetEntriesFast() ; iclus ++ ){
49b5c49b 1625 AliVCluster * calo = (AliVCluster *) refclustersbkg->At(iclus) ;
1626
1627 calo->GetMomentum(lv,vertex) ;//Assume that come from vertex in straight line
1628
1629 if( lv.Pt() > ptcut && IsParticleInJetCone(lv.Eta(),lv.Phi(),etal, phiTrig)) bkg+=lv;
9415d854 1630 }//background cluster loop
a3aebfff 1631 }
1c5acb87 1632 }//clusters in jet
9415d854 1633
1c5acb87 1634 //If there is any jet found, leave jet and bkg as they are,
1635 //if not set them to 0.
1636 if(!IsJetSelected(particle->Pt(), jet.Pt())) {
1637 jet.SetPxPyPzE(0.,0.,0.,0.);
1638 bkg.SetPxPyPzE(0.,0.,0.,0.);
1639 }
1640 else
9415d854 1641 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 1642
1643}
1644
1c5acb87 1645//__________________________________________________________________
1646void AliAnaParticleJetLeadingConeCorrelation::Print(const Option_t * opt) const
1647{
9415d854 1648
1c5acb87 1649 //Print some relevant parameters set for the analysis
1650 if(! opt)
1651 return;
1652
a3aebfff 1653 printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
745913ae 1654 AliAnaCaloTrackCorrBaseClass::Print(" ");
9415d854 1655
1c5acb87 1656 if(fJetsOnlyInCTS)printf("Jets reconstructed in CTS \n");
1657 else printf("Jets reconstructed in CTS+EMCAL \n");
9415d854 1658
1c5acb87 1659 if(fPbPb) printf("PbPb events, pT cut in jet cone energy reconstruction %2.1f \n", fJetPtThreshold);
1660 else printf("pp events, pT cut in jet cone energy reconstruction %2.1f \n", fJetPtThresPbPb);
9415d854 1661
1662 printf("If pT of trigger < %2.3f, select jets as in pp? \n", fPtTriggerSelectionCut);
1663
1c5acb87 1664 printf("Phi gamma-Leading < %3.2f\n", fDeltaPhiMaxCut) ;
1665 printf("Phi gamma-Leading > %3.2f\n", fDeltaPhiMinCut) ;
1666 printf("pT Leading / pT Trigger < %3.2f\n", fLeadingRatioMaxCut) ;
1667 printf("pT Leading / pT Trigger > %3.2f\n", fLeadingRatioMinCut) ;
1668
1669 if(fSelect == 2){
1670 printf("pT Jet / pT Gamma < %3.2f\n", fJetRatioMaxCut) ;
1671 printf("pT Jet / pT Gamma > %3.2f\n", fJetRatioMinCut) ;
1672 printf("pT Jet (Only CTS)/ pT Trigger < %3.2f\n", fJetCTSRatioMaxCut) ;
1673 printf("pT Jet (Only CTS)/ pT Trigger > %3.2f\n", fJetCTSRatioMinCut) ;
1674 }
1675 else if(fSelect == 0)
1676 printf("Accept all reconstructed jets \n") ;
1677 else if(fSelect == 1)
1678 printf("Accept jets depending on trigger energy \n") ;
1679 else
1680 printf("Wrong jet selection option: %d \n", fSelect) ;
9415d854 1681
477d6cee 1682 printf("Isolated Trigger? %d\n", fSelectIsolated) ;
1c5acb87 1683
1684}