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