]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
First version of a class to correct for 3D Space Charges
[u/mrichter/AliRoot.git] / PWG4 / JetTasks / AliAnalysisTaskFragmentationFunction.cxx
CommitLineData
656dc810 1/*************************************************************************
2 * *
3 * Task for Fragmentation Function Analysis in PWG4 Jet Task Force Train *
4 * *
5 *************************************************************************/
6
7
8/**************************************************************************
9 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
10 * *
11 * Author: The ALICE Off-line Project. *
12 * Contributors are mentioned in the code where appropriate. *
13 * *
14 * Permission to use, copy, modify and distribute this software and its *
15 * documentation strictly for non-commercial purposes is hereby granted *
16 * without fee, provided that the above copyright notice appears in all *
17 * copies and that both the copyright notice and this permission notice *
18 * appear in the supporting documentation. The authors make no claims *
19 * about the suitability of this software for any purpose. It is *
20 * provided "as is" without express or implied warranty. *
21 **************************************************************************/
22
23/* $Id: */
24
25#include "TList.h"
26#include "TH1F.h"
27#include "TH2F.h"
28#include "TString.h"
29#include "THnSparse.h"
ac017ff3 30#include "TProfile.h"
31#include "TFile.h"
32#include "TKey.h"
656dc810 33
34#include "AliAODInputHandler.h"
35#include "AliAODHandler.h"
36#include "AliESDEvent.h"
37#include "AliAODMCParticle.h"
38#include "AliAODJet.h"
39#include "AliGenPythiaEventHeader.h"
40#include "AliInputEventHandler.h"
41
42#include "AliAnalysisHelperJetTasks.h"
43#include "AliAnalysisManager.h"
44#include "AliAnalysisTaskSE.h"
45
46#include "AliAnalysisTaskFragmentationFunction.h"
47
48
49ClassImp(AliAnalysisTaskFragmentationFunction)
50
51//____________________________________________________________________________
52AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction()
53 : AliAnalysisTaskSE()
54 ,fESD(0)
55 ,fAOD(0)
56 ,fMCEvent(0)
57 ,fBranchRecJets("jets")
58 ,fBranchGenJets("")
59 ,fTrackTypeGen(0)
60 ,fJetTypeGen(0)
fe343c6b 61 ,fJetTypeRecEff(0)
656dc810 62 ,fFilterMask(0)
ac017ff3 63 ,fUsePhysicsSelection(kTRUE)
656dc810 64 ,fTrackPtCut(0)
65 ,fTrackEtaMin(0)
66 ,fTrackEtaMax(0)
67 ,fTrackPhiMin(0)
68 ,fTrackPhiMax(0)
69 ,fJetPtCut(0)
70 ,fJetEtaMin(0)
71 ,fJetEtaMax(0)
72 ,fJetPhiMin(0)
73 ,fJetPhiMax(0)
74 ,fDiJetCut(0)
75 ,fDiJetDeltaPhiCut(0)
76 ,fDiJetPtFractionCut(0)
77 ,fDiJetCDFCut(0)
78 ,fDiJetKindBins(0)
79 ,fFFRadius(0)
80 ,fTracksRec(0)
81 ,fTracksRecCuts(0)
82 ,fTracksGen(0)
fe343c6b 83 ,fTracksAODMCCharged(0)
84 ,fTracksRecQualityCuts(0)
656dc810 85 ,fJetsRec(0)
86 ,fJetsRecCuts(0)
87 ,fJetsGen(0)
fe343c6b 88 ,fJetsRecEff(0)
656dc810 89 ,fQATrackHistosRec(0)
90 ,fQATrackHistosRecCuts(0)
91 ,fQATrackHistosGen(0)
92 ,fQAJetHistosRec(0)
93 ,fQAJetHistosRecCuts(0)
94 ,fQAJetHistosRecCutsLeading(0)
95 ,fQAJetHistosGen(0)
96 ,fQAJetHistosGenLeading(0)
fe343c6b 97 ,fQAJetHistosRecEffLeading(0)
656dc810 98 ,fFFHistosRecCuts(0)
99 ,fFFHistosRecLeading(0)
100 ,fFFHistosRecLeadingTrack(0)
101 ,fFFHistosGen(0)
102 ,fFFHistosGenLeading(0)
103 ,fFFHistosGenLeadingTrack(0)
104 ,fIJHistosRecCuts(0)
105 ,fIJHistosRecLeading(0)
106 ,fIJHistosRecLeadingTrack(0)
107 ,fIJHistosGen(0)
108 ,fIJHistosGenLeading(0)
109 ,fIJHistosGenLeadingTrack(0)
110 ,fFFDiJetHistosRecCuts(0)
111 ,fFFDiJetHistosRecLeading(0)
112 ,fFFDiJetHistosRecLeadingTrack(0)
113 ,fFFDiJetHistosGen(0)
114 ,fFFDiJetHistosGenLeading(0)
115 ,fFFDiJetHistosGenLeadingTrack(0)
116 ,fQADiJetHistosRecCuts(0)
117 ,fQADiJetHistosGen(0)
118 ,fQATrackHighPtThreshold(0)
119 ,fFFNBinsJetPt(0)
120 ,fFFJetPtMin(0)
121 ,fFFJetPtMax(0)
122 ,fFFNBinsPt(0)
123 ,fFFPtMin(0)
124 ,fFFPtMax(0)
125 ,fFFNBinsXi(0)
126 ,fFFXiMin(0)
127 ,fFFXiMax(0)
128 ,fFFNBinsZ(0)
129 ,fFFZMin(0)
130 ,fFFZMax(0)
131 ,fQAJetNBinsPt(0)
132 ,fQAJetPtMin(0)
133 ,fQAJetPtMax(0)
134 ,fQAJetNBinsEta(0)
135 ,fQAJetEtaMin(0)
136 ,fQAJetEtaMax(0)
137 ,fQAJetNBinsPhi(0)
138 ,fQAJetPhiMin(0)
139 ,fQAJetPhiMax(0)
140 ,fQATrackNBinsPt(0)
141 ,fQATrackPtMin(0)
142 ,fQATrackPtMax(0)
143 ,fQATrackNBinsEta(0)
144 ,fQATrackEtaMin(0)
145 ,fQATrackEtaMax(0)
146 ,fQATrackNBinsPhi(0)
147 ,fQATrackPhiMin(0)
148 ,fQATrackPhiMax(0)
149 ,fIJNBinsJetPt(0)
150 ,fIJJetPtMin(0)
151 ,fIJJetPtMax(0)
152 ,fIJNBinsPt(0)
153 ,fIJPtMin(0)
154 ,fIJPtMax(0)
155 ,fIJNBinsZ(0)
156 ,fIJZMin(0)
157 ,fIJZMax(0)
158 ,fIJNBinsCosTheta(0)
159 ,fIJCosThetaMin(0)
160 ,fIJCosThetaMax(0)
161 ,fIJNBinsTheta(0)
162 ,fIJThetaMin(0)
163 ,fIJThetaMax(0)
164 ,fIJNBinsJt(0)
165 ,fIJJtMin(0)
166 ,fIJJtMax(0)
167 ,fDiJetNBinsJetInvMass(0)
168 ,fDiJetJetInvMassMin(0)
169 ,fDiJetJetInvMassMax(0)
170 ,fDiJetNBinsJetPt(0)
171 ,fDiJetJetPtMin(0)
172 ,fDiJetJetPtMax(0)
173 ,fDiJetNBinsPt(0)
174 ,fDiJetPtMin(0)
175 ,fDiJetPtMax(0)
176 ,fDiJetNBinsXi(0)
177 ,fDiJetXiMin(0)
178 ,fDiJetXiMax(0)
179 ,fDiJetNBinsZ(0)
180 ,fDiJetZMin(0)
181 ,fDiJetZMax(0)
182 ,fQADiJetNBinsInvMass(0)
183 ,fQADiJetInvMassMin(0)
184 ,fQADiJetInvMassMax(0)
185 ,fQADiJetNBinsJetPt(0)
186 ,fQADiJetJetPtMin(0)
187 ,fQADiJetJetPtMax(0)
188 ,fQADiJetNBinsDeltaPhi(0)
189 ,fQADiJetDeltaPhiMin(0)
190 ,fQADiJetDeltaPhiMax(0)
191 ,fQADiJetNBinsDeltaEta(0)
192 ,fQADiJetDeltaEtaMin(0)
193 ,fQADiJetDeltaEtaMax(0)
194 ,fQADiJetNBinsDeltaPt(0)
195 ,fQADiJetDeltaPtMin(0)
196 ,fQADiJetDeltaPtMax(0)
197 ,fCommonHistList(0)
198 ,fh1EvtSelection(0)
199 ,fh1VertexNContributors(0)
200 ,fh1VertexZ(0)
201 ,fh1EvtMult(0)
ac017ff3 202 ,fh1Xsec(0)
203 ,fh1Trials(0)
204 ,fh1PtHard(0)
205 ,fh1PtHardTrials(0)
656dc810 206 ,fh1nRecJetsCuts(0)
207 ,fh1nGenJets(0)
fe343c6b 208 ,fh1nRecEffJets(0)
209 ,fhnSingleTrackRecEffHisto(0)
210 ,fhnJetTrackRecEffHisto(0)
656dc810 211{
212 // default constructor
213}
214
215//__________________________________________________________________________________________
216AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const char *name)
217 : AliAnalysisTaskSE(name)
218 ,fESD(0)
219 ,fAOD(0)
220 ,fMCEvent(0)
221 ,fBranchRecJets("jets")
222 ,fBranchGenJets("")
223 ,fTrackTypeGen(0)
224 ,fJetTypeGen(0)
fe343c6b 225 ,fJetTypeRecEff(0)
656dc810 226 ,fFilterMask(0)
ac017ff3 227 ,fUsePhysicsSelection(kTRUE)
656dc810 228 ,fTrackPtCut(0)
229 ,fTrackEtaMin(0)
230 ,fTrackEtaMax(0)
231 ,fTrackPhiMin(0)
232 ,fTrackPhiMax(0)
233 ,fJetPtCut(0)
234 ,fJetEtaMin(0)
235 ,fJetEtaMax(0)
236 ,fJetPhiMin(0)
237 ,fJetPhiMax(0)
238 ,fDiJetCut(0)
239 ,fDiJetDeltaPhiCut(0)
240 ,fDiJetPtFractionCut(0)
241 ,fDiJetCDFCut(0)
242 ,fDiJetKindBins(0)
243 ,fFFRadius(0)
244 ,fTracksRec(0)
245 ,fTracksRecCuts(0)
246 ,fTracksGen(0)
fe343c6b 247 ,fTracksAODMCCharged(0)
248 ,fTracksRecQualityCuts(0)
656dc810 249 ,fJetsRec(0)
250 ,fJetsRecCuts(0)
251 ,fJetsGen(0)
fe343c6b 252 ,fJetsRecEff(0)
656dc810 253 ,fQATrackHistosRec(0)
254 ,fQATrackHistosRecCuts(0)
255 ,fQATrackHistosGen(0)
256 ,fQAJetHistosRec(0)
257 ,fQAJetHistosRecCuts(0)
258 ,fQAJetHistosRecCutsLeading(0)
259 ,fQAJetHistosGen(0)
260 ,fQAJetHistosGenLeading(0)
fe343c6b 261 ,fQAJetHistosRecEffLeading(0)
656dc810 262 ,fFFHistosRecCuts(0)
263 ,fFFHistosRecLeading(0)
264 ,fFFHistosRecLeadingTrack(0)
265 ,fFFHistosGen(0)
266 ,fFFHistosGenLeading(0)
267 ,fFFHistosGenLeadingTrack(0)
268 ,fIJHistosRecCuts(0)
269 ,fIJHistosRecLeading(0)
270 ,fIJHistosRecLeadingTrack(0)
271 ,fIJHistosGen(0)
272 ,fIJHistosGenLeading(0)
273 ,fIJHistosGenLeadingTrack(0)
274 ,fFFDiJetHistosRecCuts(0)
275 ,fFFDiJetHistosRecLeading(0)
276 ,fFFDiJetHistosRecLeadingTrack(0)
277 ,fFFDiJetHistosGen(0)
278 ,fFFDiJetHistosGenLeading(0)
279 ,fFFDiJetHistosGenLeadingTrack(0)
280 ,fQADiJetHistosRecCuts(0)
281 ,fQADiJetHistosGen(0)
282 ,fQATrackHighPtThreshold(0)
283 ,fFFNBinsJetPt(0)
284 ,fFFJetPtMin(0)
285 ,fFFJetPtMax(0)
286 ,fFFNBinsPt(0)
287 ,fFFPtMin(0)
288 ,fFFPtMax(0)
289 ,fFFNBinsXi(0)
290 ,fFFXiMin(0)
291 ,fFFXiMax(0)
292 ,fFFNBinsZ(0)
293 ,fFFZMin(0)
294 ,fFFZMax(0)
295 ,fQAJetNBinsPt(0)
296 ,fQAJetPtMin(0)
297 ,fQAJetPtMax(0)
298 ,fQAJetNBinsEta(0)
299 ,fQAJetEtaMin(0)
300 ,fQAJetEtaMax(0)
301 ,fQAJetNBinsPhi(0)
302 ,fQAJetPhiMin(0)
303 ,fQAJetPhiMax(0)
304 ,fQATrackNBinsPt(0)
305 ,fQATrackPtMin(0)
306 ,fQATrackPtMax(0)
307 ,fQATrackNBinsEta(0)
308 ,fQATrackEtaMin(0)
309 ,fQATrackEtaMax(0)
310 ,fQATrackNBinsPhi(0)
311 ,fQATrackPhiMin(0)
312 ,fQATrackPhiMax(0)
313 ,fIJNBinsJetPt(0)
314 ,fIJJetPtMin(0)
315 ,fIJJetPtMax(0)
316 ,fIJNBinsPt(0)
317 ,fIJPtMin(0)
318 ,fIJPtMax(0)
319 ,fIJNBinsZ(0)
320 ,fIJZMin(0)
321 ,fIJZMax(0)
322 ,fIJNBinsCosTheta(0)
323 ,fIJCosThetaMin(0)
324 ,fIJCosThetaMax(0)
325 ,fIJNBinsTheta(0)
326 ,fIJThetaMin(0)
327 ,fIJThetaMax(0)
328 ,fIJNBinsJt(0)
329 ,fIJJtMin(0)
330 ,fIJJtMax(0)
331 ,fDiJetNBinsJetInvMass(0)
332 ,fDiJetJetInvMassMin(0)
333 ,fDiJetJetInvMassMax(0)
334 ,fDiJetNBinsJetPt(0)
335 ,fDiJetJetPtMin(0)
336 ,fDiJetJetPtMax(0)
337 ,fDiJetNBinsPt(0)
338 ,fDiJetPtMin(0)
339 ,fDiJetPtMax(0)
340 ,fDiJetNBinsXi(0)
341 ,fDiJetXiMin(0)
342 ,fDiJetXiMax(0)
343 ,fDiJetNBinsZ(0)
344 ,fDiJetZMin(0)
345 ,fDiJetZMax(0)
346 ,fQADiJetNBinsInvMass(0)
347 ,fQADiJetInvMassMin(0)
348 ,fQADiJetInvMassMax(0)
349 ,fQADiJetNBinsJetPt(0)
350 ,fQADiJetJetPtMin(0)
351 ,fQADiJetJetPtMax(0)
352 ,fQADiJetNBinsDeltaPhi(0)
353 ,fQADiJetDeltaPhiMin(0)
354 ,fQADiJetDeltaPhiMax(0)
355 ,fQADiJetNBinsDeltaEta(0)
356 ,fQADiJetDeltaEtaMin(0)
357 ,fQADiJetDeltaEtaMax(0)
358 ,fQADiJetNBinsDeltaPt(0)
359 ,fQADiJetDeltaPtMin(0)
360 ,fQADiJetDeltaPtMax(0)
361 ,fCommonHistList(0)
362 ,fh1EvtSelection(0)
363 ,fh1VertexNContributors(0)
364 ,fh1VertexZ(0)
365 ,fh1EvtMult(0)
ac017ff3 366 ,fh1Xsec(0)
367 ,fh1Trials(0)
368 ,fh1PtHard(0)
369 ,fh1PtHardTrials(0)
656dc810 370 ,fh1nRecJetsCuts(0)
371 ,fh1nGenJets(0)
fe343c6b 372 ,fh1nRecEffJets(0)
373 ,fhnSingleTrackRecEffHisto(0)
374 ,fhnJetTrackRecEffHisto(0)
656dc810 375{
376 // constructor
377
378 DefineOutput(1,TList::Class());
379
380
381}
382
383//__________________________________________________________________________________________________________________________
384AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const AliAnalysisTaskFragmentationFunction &copy)
385 : AliAnalysisTaskSE()
386 ,fESD(copy.fESD)
387 ,fAOD(copy.fAOD)
388 ,fMCEvent(copy.fMCEvent)
389 ,fBranchRecJets(copy.fBranchRecJets)
390 ,fBranchGenJets(copy.fBranchGenJets)
391 ,fTrackTypeGen(copy.fTrackTypeGen)
392 ,fJetTypeGen(copy.fJetTypeGen)
fe343c6b 393 ,fJetTypeRecEff(copy.fJetTypeRecEff)
656dc810 394 ,fFilterMask(copy.fFilterMask)
ac017ff3 395 ,fUsePhysicsSelection(copy.fUsePhysicsSelection)
656dc810 396 ,fTrackPtCut(copy.fTrackPtCut)
397 ,fTrackEtaMin(copy.fTrackEtaMin)
398 ,fTrackEtaMax(copy.fTrackEtaMax)
399 ,fTrackPhiMin(copy.fTrackPhiMin)
400 ,fTrackPhiMax(copy.fTrackPhiMax)
401 ,fJetPtCut(copy.fJetPtCut)
402 ,fJetEtaMin(copy.fJetEtaMin)
403 ,fJetEtaMax(copy.fJetEtaMax)
404 ,fJetPhiMin(copy.fJetPhiMin)
fe343c6b 405 ,fJetPhiMax(copy.fJetPhiMax)
656dc810 406 ,fDiJetCut(copy.fDiJetCut)
407 ,fDiJetDeltaPhiCut(copy.fDiJetDeltaPhiCut)
408 ,fDiJetPtFractionCut(copy.fDiJetPtFractionCut)
409 ,fDiJetCDFCut(copy.fDiJetCDFCut)
410 ,fDiJetKindBins(copy.fDiJetKindBins)
411 ,fFFRadius(copy.fFFRadius)
412 ,fTracksRec(copy.fTracksRec)
413 ,fTracksRecCuts(copy.fTracksRecCuts)
414 ,fTracksGen(copy.fTracksGen)
fe343c6b 415 ,fTracksAODMCCharged(copy.fTracksAODMCCharged)
416 ,fTracksRecQualityCuts(copy.fTracksRecQualityCuts)
656dc810 417 ,fJetsRec(copy.fJetsRec)
418 ,fJetsRecCuts(copy.fJetsRecCuts)
419 ,fJetsGen(copy.fJetsGen)
fe343c6b 420 ,fJetsRecEff(copy.fJetsRecEff)
656dc810 421 ,fQATrackHistosRec(copy.fQATrackHistosRec)
422 ,fQATrackHistosRecCuts(copy.fQATrackHistosRecCuts)
423 ,fQATrackHistosGen(copy.fQATrackHistosGen)
424 ,fQAJetHistosRec(copy.fQAJetHistosRec)
425 ,fQAJetHistosRecCuts(copy.fQAJetHistosRecCuts)
426 ,fQAJetHistosRecCutsLeading(copy.fQAJetHistosRecCutsLeading)
427 ,fQAJetHistosGen(copy.fQAJetHistosGen)
428 ,fQAJetHistosGenLeading(copy.fQAJetHistosGenLeading)
fe343c6b 429 ,fQAJetHistosRecEffLeading(copy.fQAJetHistosRecEffLeading)
656dc810 430 ,fFFHistosRecCuts(copy.fFFHistosRecCuts)
431 ,fFFHistosRecLeading(copy.fFFHistosRecLeading)
432 ,fFFHistosRecLeadingTrack(copy.fFFHistosRecLeadingTrack)
433 ,fFFHistosGen(copy.fFFHistosGen)
434 ,fFFHistosGenLeading(copy.fFFHistosGenLeading)
435 ,fFFHistosGenLeadingTrack(copy.fFFHistosGenLeadingTrack)
436 ,fIJHistosRecCuts(copy.fIJHistosRecCuts)
437 ,fIJHistosRecLeading(copy.fIJHistosRecLeading)
438 ,fIJHistosRecLeadingTrack(copy.fIJHistosRecLeadingTrack)
439 ,fIJHistosGen(copy.fIJHistosGen)
440 ,fIJHistosGenLeading(copy.fIJHistosGenLeading)
441 ,fIJHistosGenLeadingTrack(copy.fIJHistosGenLeadingTrack)
442 ,fFFDiJetHistosRecCuts(copy.fFFDiJetHistosRecCuts)
443 ,fFFDiJetHistosRecLeading(copy.fFFDiJetHistosRecLeading)
444 ,fFFDiJetHistosRecLeadingTrack(copy.fFFDiJetHistosRecLeadingTrack)
445 ,fFFDiJetHistosGen(copy.fFFDiJetHistosGen)
446 ,fFFDiJetHistosGenLeading(copy.fFFDiJetHistosGenLeading)
447 ,fFFDiJetHistosGenLeadingTrack(copy.fFFDiJetHistosGenLeadingTrack)
448 ,fQADiJetHistosRecCuts(copy.fQADiJetHistosRecCuts)
449 ,fQADiJetHistosGen(copy.fQADiJetHistosGen)
450 ,fQATrackHighPtThreshold(copy.fQATrackHighPtThreshold)
451 ,fFFNBinsJetPt(copy.fFFNBinsJetPt)
452 ,fFFJetPtMin(copy.fFFJetPtMin)
453 ,fFFJetPtMax(copy.fFFJetPtMax)
454 ,fFFNBinsPt(copy.fFFNBinsPt)
455 ,fFFPtMin(copy.fFFPtMin)
456 ,fFFPtMax(copy.fFFPtMax)
457 ,fFFNBinsXi(copy.fFFNBinsXi)
458 ,fFFXiMin(copy.fFFXiMin)
459 ,fFFXiMax(copy.fFFXiMax)
460 ,fFFNBinsZ(copy.fFFNBinsZ)
461 ,fFFZMin(copy.fFFZMin)
462 ,fFFZMax(copy.fFFZMax)
463 ,fQAJetNBinsPt(copy.fQAJetNBinsPt)
464 ,fQAJetPtMin(copy.fQAJetPtMin)
465 ,fQAJetPtMax(copy.fQAJetPtMax)
466 ,fQAJetNBinsEta(copy.fQAJetNBinsEta)
467 ,fQAJetEtaMin(copy.fQAJetEtaMin)
468 ,fQAJetEtaMax(copy.fQAJetEtaMax)
469 ,fQAJetNBinsPhi(copy.fQAJetNBinsPhi)
470 ,fQAJetPhiMin(copy.fQAJetPhiMin)
471 ,fQAJetPhiMax(copy.fQAJetPhiMax)
472 ,fQATrackNBinsPt(copy.fQATrackNBinsPt)
473 ,fQATrackPtMin(copy.fQATrackPtMin)
474 ,fQATrackPtMax(copy.fQATrackPtMax)
475 ,fQATrackNBinsEta(copy.fQATrackNBinsEta)
476 ,fQATrackEtaMin(copy.fQATrackEtaMin)
477 ,fQATrackEtaMax(copy.fQATrackEtaMax)
478 ,fQATrackNBinsPhi(copy.fQATrackNBinsPhi)
479 ,fQATrackPhiMin(copy.fQATrackPhiMin)
480 ,fQATrackPhiMax(copy.fQATrackPhiMax)
481 ,fIJNBinsJetPt(copy.fIJNBinsJetPt)
482 ,fIJJetPtMin(copy.fIJJetPtMin)
483 ,fIJJetPtMax(copy.fIJJetPtMax)
484 ,fIJNBinsPt(copy.fIJNBinsPt)
485 ,fIJPtMin(copy.fIJPtMin)
486 ,fIJPtMax(copy.fIJPtMax)
487 ,fIJNBinsZ(copy.fIJNBinsZ)
488 ,fIJZMin(copy.fIJZMin)
489 ,fIJZMax(copy.fIJZMax)
490 ,fIJNBinsCosTheta(copy.fIJNBinsCosTheta)
491 ,fIJCosThetaMin(copy.fIJCosThetaMin)
492 ,fIJCosThetaMax(copy.fIJCosThetaMax)
493 ,fIJNBinsTheta(copy.fIJNBinsTheta)
494 ,fIJThetaMin(copy.fIJThetaMin)
495 ,fIJThetaMax(copy.fIJThetaMax)
496 ,fIJNBinsJt(copy.fIJNBinsJt)
497 ,fIJJtMin(copy.fIJJtMin)
498 ,fIJJtMax(copy.fIJJtMax)
499 ,fDiJetNBinsJetInvMass(copy.fDiJetNBinsJetInvMass)
500 ,fDiJetJetInvMassMin(copy.fDiJetJetInvMassMin)
501 ,fDiJetJetInvMassMax(copy.fDiJetJetInvMassMax)
502 ,fDiJetNBinsJetPt(copy.fDiJetNBinsJetPt)
503 ,fDiJetJetPtMin(copy.fDiJetJetPtMin)
504 ,fDiJetJetPtMax(copy.fDiJetJetPtMax)
505 ,fDiJetNBinsPt(copy.fDiJetNBinsPt)
506 ,fDiJetPtMin(copy.fDiJetPtMin)
507 ,fDiJetPtMax(copy.fDiJetPtMax)
508 ,fDiJetNBinsXi(copy.fDiJetNBinsXi)
509 ,fDiJetXiMin(copy.fDiJetXiMin)
510 ,fDiJetXiMax(copy.fDiJetXiMax)
511 ,fDiJetNBinsZ(copy.fDiJetNBinsZ)
512 ,fDiJetZMin(copy.fDiJetZMin)
513 ,fDiJetZMax(copy.fDiJetZMax)
514 ,fQADiJetNBinsInvMass(copy.fQADiJetNBinsInvMass)
515 ,fQADiJetInvMassMin(copy.fQADiJetInvMassMin)
516 ,fQADiJetInvMassMax(copy.fQADiJetInvMassMax)
517 ,fQADiJetNBinsJetPt(copy.fQADiJetNBinsJetPt)
518 ,fQADiJetJetPtMin(copy.fQADiJetJetPtMin)
519 ,fQADiJetJetPtMax(copy.fQADiJetJetPtMax)
520 ,fQADiJetNBinsDeltaPhi(copy.fQADiJetNBinsDeltaPhi)
521 ,fQADiJetDeltaPhiMin(copy.fQADiJetDeltaPhiMin)
522 ,fQADiJetDeltaPhiMax(copy.fQADiJetDeltaPhiMax)
523 ,fQADiJetNBinsDeltaEta(copy.fQADiJetNBinsDeltaEta)
524 ,fQADiJetDeltaEtaMin(copy.fQADiJetDeltaEtaMin)
525 ,fQADiJetDeltaEtaMax(copy.fQADiJetDeltaEtaMax)
526 ,fQADiJetNBinsDeltaPt(copy.fQADiJetNBinsDeltaPt)
527 ,fQADiJetDeltaPtMin(copy.fQADiJetDeltaPtMin)
528 ,fQADiJetDeltaPtMax(copy.fQADiJetDeltaPtMax)
529 ,fCommonHistList(copy.fCommonHistList)
530 ,fh1EvtSelection(copy.fh1EvtSelection)
531 ,fh1VertexNContributors(copy.fh1VertexNContributors)
532 ,fh1VertexZ(copy.fh1VertexZ)
533 ,fh1EvtMult(copy.fh1EvtMult)
ac017ff3 534 ,fh1Xsec(copy.fh1Xsec)
535 ,fh1Trials(copy.fh1Trials)
536 ,fh1PtHard(copy.fh1PtHard)
537 ,fh1PtHardTrials(copy.fh1PtHardTrials)
656dc810 538 ,fh1nRecJetsCuts(copy.fh1nRecJetsCuts)
539 ,fh1nGenJets(copy.fh1nGenJets)
fe343c6b 540 ,fh1nRecEffJets(copy.fh1nRecEffJets)
541 ,fhnSingleTrackRecEffHisto(copy.fhnSingleTrackRecEffHisto)
542 ,fhnJetTrackRecEffHisto(copy.fhnJetTrackRecEffHisto)
656dc810 543{
544 // copy constructor
545
546}
547
548// _________________________________________________________________________________________________________________________________
549AliAnalysisTaskFragmentationFunction& AliAnalysisTaskFragmentationFunction::operator=(const AliAnalysisTaskFragmentationFunction& o)
550{
551 // assignment
552
553 if(this!=&o){
554
555 AliAnalysisTaskSE::operator=(o);
556 fESD = o.fESD;
557 fAOD = o.fAOD;
558 fMCEvent = o.fMCEvent;
559 fBranchRecJets = o.fBranchRecJets;
560 fBranchGenJets = o.fBranchGenJets;
561 fTrackTypeGen = o.fTrackTypeGen;
562 fJetTypeGen = o.fJetTypeGen;
fe343c6b 563 fJetTypeRecEff = o.fJetTypeRecEff;
656dc810 564 fFilterMask = o.fFilterMask;
ac017ff3 565 fUsePhysicsSelection = o.fUsePhysicsSelection;
656dc810 566 fTrackPtCut = o.fTrackPtCut;
567 fTrackEtaMin = o.fTrackEtaMin;
568 fTrackEtaMax = o.fTrackEtaMax;
569 fTrackPhiMin = o.fTrackPhiMin;
570 fTrackPhiMax = o.fTrackPhiMax;
571 fJetPtCut = o.fJetPtCut;
572 fJetEtaMin = o.fJetEtaMin;
573 fJetEtaMax = o.fJetEtaMax;
574 fJetPhiMin = o.fJetPhiMin;
575 fJetPhiMax = o.fJetPhiMin;
576 fDiJetCut = o.fDiJetCut;
577 fDiJetDeltaPhiCut = o.fDiJetDeltaPhiCut;
578 fDiJetPtFractionCut = o.fDiJetPtFractionCut;
579 fDiJetCDFCut = o.fDiJetCDFCut;
580 fDiJetKindBins = o.fDiJetKindBins;
581 fFFRadius = o.fFFRadius;
582 fTracksRec = o.fTracksRec;
583 fTracksRecCuts = o.fTracksRecCuts;
584 fTracksGen = o.fTracksGen;
fe343c6b 585 fTracksAODMCCharged = o.fTracksAODMCCharged;
586 fTracksRecQualityCuts = o.fTracksRecQualityCuts;
656dc810 587 fJetsRec = o.fJetsRec;
588 fJetsRecCuts = o.fJetsRecCuts;
589 fJetsGen = o.fJetsGen;
fe343c6b 590 fJetsRecEff = o.fJetsRecEff;
656dc810 591 fQATrackHistosRec = o.fQATrackHistosRec;
592 fQATrackHistosRecCuts = o.fQATrackHistosRecCuts;
593 fQATrackHistosGen = o.fQATrackHistosGen;
594 fQAJetHistosRec = o.fQAJetHistosRec;
595 fQAJetHistosRecCuts = o.fQAJetHistosRecCuts;
596 fQAJetHistosRecCutsLeading = o.fQAJetHistosRecCutsLeading;
597 fQAJetHistosGen = o.fQAJetHistosGen;
598 fQAJetHistosGenLeading = o.fQAJetHistosGenLeading;
fe343c6b 599 fQAJetHistosRecEffLeading = o.fQAJetHistosRecEffLeading;
656dc810 600 fFFHistosRecCuts = o.fFFHistosRecCuts;
601 fFFHistosRecLeading = o.fFFHistosRecLeading;
602 fFFHistosRecLeadingTrack = o.fFFHistosRecLeadingTrack;
603 fFFHistosGen = o.fFFHistosGen;
604 fFFHistosGenLeading = o.fFFHistosGenLeading;
605 fFFHistosGenLeadingTrack = o.fFFHistosGenLeadingTrack;
606 fIJHistosRecCuts = o.fIJHistosRecCuts;
607 fIJHistosRecLeading = o.fIJHistosRecLeading;
608 fIJHistosRecLeadingTrack = o.fIJHistosRecLeadingTrack;
609 fIJHistosGen = o.fIJHistosGen;
610 fIJHistosGenLeading = o.fIJHistosGenLeading;
611 fIJHistosGenLeadingTrack = o.fIJHistosGenLeadingTrack;
612 fFFDiJetHistosRecCuts = o.fFFDiJetHistosRecCuts;
613 fFFDiJetHistosRecLeading = o.fFFDiJetHistosRecLeading;
614 fFFDiJetHistosRecLeadingTrack = o.fFFDiJetHistosRecLeadingTrack;
615 fFFDiJetHistosGen = o.fFFDiJetHistosGen;
616 fFFDiJetHistosGenLeading = o.fFFDiJetHistosGenLeading;
617 fFFDiJetHistosGenLeadingTrack = o.fFFDiJetHistosGenLeadingTrack;
618 fQADiJetHistosRecCuts = o.fQADiJetHistosRecCuts;
619 fQADiJetHistosGen = o.fQADiJetHistosGen;
620 fQATrackHighPtThreshold = o.fQATrackHighPtThreshold;
621 fFFNBinsJetPt = o.fFFNBinsJetPt;
622 fFFJetPtMin = o.fFFJetPtMin;
623 fFFJetPtMax = o.fFFJetPtMax;
624 fFFNBinsPt = o.fFFNBinsPt;
625 fFFPtMin = o.fFFPtMin;
626 fFFPtMax = o.fFFPtMax;
627 fFFNBinsXi = o.fFFNBinsXi;
628 fFFXiMin = o.fFFXiMin;
629 fFFXiMax = o.fFFXiMax;
630 fFFNBinsZ = o.fFFNBinsZ;
631 fFFZMin = o.fFFZMin;
632 fFFZMax = o.fFFZMax;
633 fQAJetNBinsPt = o.fQAJetNBinsPt;
634 fQAJetPtMin = o.fQAJetPtMin;
635 fQAJetPtMax = o.fQAJetPtMax;
636 fQAJetNBinsEta = o.fQAJetNBinsEta;
637 fQAJetEtaMin = o.fQAJetEtaMin;
638 fQAJetEtaMax = o.fQAJetEtaMax;
639 fQAJetNBinsPhi = o.fQAJetNBinsPhi;
640 fQAJetPhiMin = o.fQAJetPhiMin;
641 fQAJetPhiMax = o.fQAJetPhiMax;
642 fQATrackNBinsPt = o.fQATrackNBinsPt;
643 fQATrackPtMin = o.fQATrackPtMin;
644 fQATrackPtMax = o.fQATrackPtMax;
645 fQATrackNBinsEta = o.fQATrackNBinsEta;
646 fQATrackEtaMin = o.fQATrackEtaMin;
647 fQATrackEtaMax = o.fQATrackEtaMax;
648 fQATrackNBinsPhi = o.fQATrackNBinsPhi;
649 fQATrackPhiMin = o.fQATrackPhiMin;
650 fQATrackPhiMax = o.fQATrackPhiMax;
651 fIJNBinsJetPt = o.fIJNBinsJetPt;
652 fIJJetPtMin = o.fIJJetPtMin;
653 fIJJetPtMax = o.fIJJetPtMax;
654 fIJNBinsPt = o.fIJNBinsPt;
655 fIJPtMin = o.fIJPtMin;
656 fIJPtMax = o.fIJPtMax;
657 fIJNBinsZ = o.fIJNBinsZ;
658 fIJZMin = o.fIJZMin;
659 fIJZMax = o.fIJZMax;
660 fIJNBinsCosTheta = o.fIJNBinsCosTheta;
661 fIJCosThetaMin = o.fIJCosThetaMin;
662 fIJCosThetaMax = o.fIJCosThetaMax;
663 fIJNBinsTheta = o.fIJNBinsTheta;
664 fIJThetaMin = o.fIJThetaMin;
665 fIJThetaMax = o.fIJThetaMax;
666 fIJNBinsJt = o.fIJNBinsJt;
667 fIJJtMin = o.fIJJtMin;
668 fIJJtMax = o.fIJJtMax;
669 fDiJetNBinsJetInvMass = o.fDiJetNBinsJetInvMass;
670 fDiJetJetInvMassMin = o.fDiJetJetInvMassMin;
671 fDiJetJetInvMassMax = o.fDiJetJetInvMassMax;
672 fDiJetNBinsJetPt = o.fDiJetNBinsJetPt;
673 fDiJetJetPtMin = o.fDiJetJetPtMin;
674 fDiJetJetPtMax = o.fDiJetJetPtMax;
675 fDiJetNBinsPt = o.fDiJetNBinsPt;
676 fDiJetPtMin = o.fDiJetPtMin;
677 fDiJetPtMax = o.fDiJetPtMax;
678 fDiJetNBinsXi = o.fDiJetNBinsXi;
679 fDiJetXiMin = o.fDiJetXiMin;
680 fDiJetXiMax = o.fDiJetXiMax;
681 fDiJetNBinsZ = o.fDiJetNBinsZ;
682 fDiJetZMin = o.fDiJetZMin;
683 fDiJetZMax = o.fDiJetZMax;
684 fQADiJetNBinsInvMass = o.fQADiJetNBinsInvMass;
685 fQADiJetInvMassMin = o.fQADiJetInvMassMin;
686 fQADiJetInvMassMax = o.fQADiJetInvMassMax;
687 fQADiJetNBinsJetPt = o.fQADiJetNBinsJetPt;
688 fQADiJetJetPtMin = o.fQADiJetJetPtMin;
689 fQADiJetJetPtMax = o.fQADiJetJetPtMax;
690 fQADiJetNBinsDeltaPhi = o.fQADiJetNBinsDeltaPhi;
691 fQADiJetDeltaPhiMin = o.fQADiJetDeltaPhiMin;
692 fQADiJetDeltaPhiMax = o.fQADiJetDeltaPhiMax;
693 fQADiJetNBinsDeltaEta = o.fQADiJetNBinsDeltaEta;
694 fQADiJetDeltaEtaMin = o.fQADiJetDeltaEtaMin;
695 fQADiJetDeltaEtaMax = o.fQADiJetDeltaEtaMax;
696 fQADiJetNBinsDeltaPt = o.fQADiJetNBinsDeltaPt;
697 fQADiJetDeltaPtMin = o.fQADiJetDeltaPtMin;
698 fQADiJetDeltaPtMax = o.fQADiJetDeltaPtMax;
699 fCommonHistList = o.fCommonHistList;
700 fh1EvtSelection = o.fh1EvtSelection;
701 fh1VertexNContributors = o.fh1VertexNContributors;
702 fh1VertexZ = o.fh1VertexZ;
703 fh1EvtMult = o.fh1EvtMult;
ac017ff3 704 fh1Xsec = o.fh1Xsec;
705 fh1Trials = o.fh1Trials;
706 fh1PtHard = o.fh1PtHard;
707 fh1PtHardTrials = o.fh1PtHardTrials;
656dc810 708 fh1nRecJetsCuts = o.fh1nRecJetsCuts;
709 fh1nGenJets = o.fh1nGenJets;
fe343c6b 710 fh1nRecEffJets = o.fh1nRecEffJets;
711 fhnSingleTrackRecEffHisto = o.fhnSingleTrackRecEffHisto;
712 fhnJetTrackRecEffHisto = o.fhnJetTrackRecEffHisto;
656dc810 713 }
714
715 return *this;
716}
717
718//___________________________________________________________________________
719AliAnalysisTaskFragmentationFunction::~AliAnalysisTaskFragmentationFunction()
720{
721 // destructor
722
fe343c6b 723 if(fTracksRec) delete fTracksRec;
724 if(fTracksRecCuts) delete fTracksRecCuts;
725 if(fTracksGen) delete fTracksGen;
726 if(fTracksAODMCCharged) delete fTracksAODMCCharged;
727 if(fTracksRecQualityCuts) delete fTracksRecQualityCuts;
728 if(fJetsRec) delete fJetsRec;
729 if(fJetsRecCuts) delete fJetsRecCuts;
730 if(fJetsGen) delete fJetsGen;
731 if(fJetsRecEff) delete fJetsRecEff;
656dc810 732
733 // if(fDiJetBins) delete fDiJetBins;
734
735}
736
737//______________________________________________________________________________________________________
738AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::AliFragFuncHistos(const char* name,
739 Int_t nJetPt, Float_t jetPtMin, Float_t jetPtMax,
740 Int_t nPt, Float_t ptMin, Float_t ptMax,
741 Int_t nXi, Float_t xiMin, Float_t xiMax,
742 Int_t nZ , Float_t zMin , Float_t zMax )
743 : TObject()
744 ,fNBinsJetPt(nJetPt)
745 ,fJetPtMin(jetPtMin)
746 ,fJetPtMax(jetPtMax)
747 ,fNBinsPt(nPt)
748 ,fPtMin(ptMin)
749 ,fPtMax(ptMax)
750 ,fNBinsXi(nXi)
751 ,fXiMin(xiMin)
752 ,fXiMax(xiMax)
753 ,fNBinsZ(nZ)
754 ,fZMin(zMin)
755 ,fZMax(zMax)
756 ,fh2TrackPt(0)
757 ,fh2Xi(0)
758 ,fh2Z(0)
759 ,fh1JetPt(0)
760 ,fName(name)
761{
762 // default constructor
763
764}
765
766//___________________________________________________________________________
767AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::AliFragFuncHistos(const AliFragFuncHistos& copy)
768 : TObject()
769 ,fNBinsJetPt(copy.fNBinsJetPt)
770 ,fJetPtMin(copy.fJetPtMin)
771 ,fJetPtMax(copy.fJetPtMax)
772 ,fNBinsPt(copy.fNBinsPt)
773 ,fPtMin(copy.fPtMin)
774 ,fPtMax(copy.fPtMax)
775 ,fNBinsXi(copy.fNBinsXi)
776 ,fXiMin(copy.fXiMin)
777 ,fXiMax(copy.fXiMax)
778 ,fNBinsZ(copy.fNBinsZ)
779 ,fZMin(copy.fZMin)
780 ,fZMax(copy.fZMax)
781 ,fh2TrackPt(copy.fh2TrackPt)
782 ,fh2Xi(copy.fh2Xi)
783 ,fh2Z(copy.fh2Z)
784 ,fh1JetPt(copy.fh1JetPt)
785 ,fName(copy.fName)
786{
787 // copy constructor
788}
789
790//_______________________________________________________________________________________________________________________________________________________________
791AliAnalysisTaskFragmentationFunction::AliFragFuncHistos& AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::operator=(const AliAnalysisTaskFragmentationFunction::AliFragFuncHistos& o)
792{
793 // assignment
794
795 if(this!=&o){
796 TObject::operator=(o);
797 fNBinsJetPt = o.fNBinsJetPt;
798 fJetPtMin = o.fJetPtMin;
799 fJetPtMax = o.fJetPtMax;
800 fNBinsPt = o.fNBinsPt;
801 fPtMin = o.fPtMin;
802 fPtMax = o.fPtMax;
803 fNBinsXi = o.fNBinsXi;
804 fXiMin = o.fXiMin;
805 fXiMax = o.fXiMax;
806 fNBinsZ = o.fNBinsZ;
807 fZMin = o.fZMin;
808 fZMax = o.fZMax;
809 fh2TrackPt = o.fh2TrackPt;
810 fh2Xi = o.fh2Xi;
811 fh2Z = o.fh2Z;
812 fh1JetPt = o.fh1JetPt;
813 fName = o.fName;
814 }
815
816 return *this;
817}
818
819//_________________________________________________________
820AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::~AliFragFuncHistos()
821{
822 // destructor
823
824 if(fh1JetPt) delete fh1JetPt;
825 if(fh2TrackPt) delete fh2TrackPt;
826 if(fh2Xi) delete fh2Xi;
827 if(fh2Z) delete fh2Z;
828}
829
830//_________________________________________________________________
831void AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::DefineHistos()
832{
833 // book FF histos
834
835 fh1JetPt = new TH1F(Form("fh1FFJetPt%s", fName.Data()),"",fNBinsJetPt,fJetPtMin,fJetPtMax);
836 fh2TrackPt = new TH2F(Form("fh2FFTrackPt%s",fName.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax,fNBinsPt, fPtMin, fPtMax);
837 fh2Xi = new TH2F(Form("fh2FFXi%s",fName.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax, fNBinsXi, fXiMin, fXiMax);
838 fh2Z = new TH2F(Form("fh2FFZ%s",fName.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax, fNBinsZ, fZMin, fZMax);
839
840 AliAnalysisTaskFragmentationFunction::SetProperties(fh1JetPt, "p_{T} [GeV/c]", "entries");
841 AliAnalysisTaskFragmentationFunction::SetProperties(fh2TrackPt,"jet p_{T} [GeV/c]","p_{T} [GeV/c]","entries");
842 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Xi,"jet p_{T} [GeV/c]","#xi", "entries");
843 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Z,"jet p_{T} [GeV/c]","z","entries");
844}
845
846//_______________________________________________________________________________________________________________
847void AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::FillFF(Float_t trackPt, Float_t jetPt, Bool_t incrementJetPt)
848{
849 // fill FF
850
851 if(incrementJetPt) fh1JetPt->Fill(jetPt);
852 fh2TrackPt->Fill(jetPt,trackPt);
853
656dc810 854 Double_t z = 0.;
855 if(jetPt>0) z = trackPt / jetPt;
856 Double_t xi = 0;
857 if(z>0) xi = TMath::Log(1/z);
858
859 fh2Xi->Fill(jetPt,xi);
860 fh2Z->Fill(jetPt,z);
861}
862
863//_________________________________________________________________________________
864void AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::AddToOutput(TList* list) const
865{
866 // add histos to list
867
868 list->Add(fh1JetPt);
869
870 list->Add(fh2TrackPt);
871 list->Add(fh2Xi);
872 list->Add(fh2Z);
873}
874
875//_________________________________________________________________________________________________________
876AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::AliFragFuncQAJetHistos(const char* name,
877 Int_t nPt, Float_t ptMin, Float_t ptMax,
878 Int_t nEta, Float_t etaMin, Float_t etaMax,
879 Int_t nPhi, Float_t phiMin, Float_t phiMax)
880 : TObject()
881 ,fNBinsPt(nPt)
882 ,fPtMin(ptMin)
883 ,fPtMax(ptMax)
884 ,fNBinsEta(nEta)
885 ,fEtaMin(etaMin)
886 ,fEtaMax(etaMax)
887 ,fNBinsPhi(nPhi)
888 ,fPhiMin(phiMin)
889 ,fPhiMax(phiMax)
890 ,fh2EtaPhi(0)
891 ,fh1Pt(0)
892 ,fName(name)
893{
894 // default constructor
895}
896
897//____________________________________________________________________________________
898AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::AliFragFuncQAJetHistos(const AliFragFuncQAJetHistos& copy)
899 : TObject()
900 ,fNBinsPt(copy.fNBinsPt)
901 ,fPtMin(copy.fPtMin)
902 ,fPtMax(copy.fPtMax)
903 ,fNBinsEta(copy.fNBinsEta)
904 ,fEtaMin(copy.fEtaMin)
905 ,fEtaMax(copy.fEtaMax)
906 ,fNBinsPhi(copy.fNBinsPhi)
907 ,fPhiMin(copy.fPhiMin)
908 ,fPhiMax(copy.fPhiMax)
909 ,fh2EtaPhi(copy.fh2EtaPhi)
910 ,fh1Pt(copy.fh1Pt)
911 ,fName(copy.fName)
912{
913 // copy constructor
914}
915
916//________________________________________________________________________________________________________________________________________________________________________
917AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos& AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::operator=(const AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos& o)
918{
919 // assignment
920
921 if(this!=&o){
922 TObject::operator=(o);
923 fNBinsPt = o.fNBinsPt;
924 fPtMin = o.fPtMin;
925 fPtMax = o.fPtMax;
926 fNBinsEta = o.fNBinsEta;
927 fEtaMin = o.fEtaMin;
928 fEtaMax = o.fEtaMax;
929 fNBinsPhi = o.fNBinsPhi;
930 fPhiMin = o.fPhiMin;
931 fPhiMax = o.fPhiMax;
932 fh2EtaPhi = o.fh2EtaPhi;
933 fh1Pt = o.fh1Pt;
934 fName = o.fName;
935 }
936
937 return *this;
938}
939
940//______________________________________________________________
941AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::~AliFragFuncQAJetHistos()
942{
943 // destructor
944
945 if(fh2EtaPhi) delete fh2EtaPhi;
946 if(fh1Pt) delete fh1Pt;
947}
948
949//____________________________________________________________________
950void AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::DefineHistos()
951{
952 // book jet QA histos
953
954 fh2EtaPhi = new TH2F(Form("fh2JetQAEtaPhi%s", fName.Data()), Form("%s: #eta - #phi distribution", fName.Data()), fNBinsEta, fEtaMin, fEtaMax, fNBinsPhi, fPhiMin, fPhiMax);
955 fh1Pt = new TH1F(Form("fh1JetQAPt%s", fName.Data()), Form("%s: p_{T} distribution", fName.Data()), fNBinsPt, fPtMin, fPtMax);
956
957 AliAnalysisTaskFragmentationFunction::SetProperties(fh2EtaPhi, "#eta", "#phi");
958 AliAnalysisTaskFragmentationFunction::SetProperties(fh1Pt, "p_{T} [GeV/c]", "entries");
959}
960
961//____________________________________________________________________________________________________
962void AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::FillJetQA(Float_t eta, Float_t phi, Float_t pt)
963{
964 // fill jet QA histos
965
966 fh2EtaPhi->Fill( eta, phi);
967 fh1Pt->Fill( pt );
968}
969
970//____________________________________________________________________________________
971void AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::AddToOutput(TList* list) const
972{
973 // add histos to list
974
975 list->Add(fh2EtaPhi);
976 list->Add(fh1Pt);
977}
978
979//___________________________________________________________________________________________________________
980AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::AliFragFuncQATrackHistos(const char* name,
981 Int_t nPt, Float_t ptMin, Float_t ptMax,
982 Int_t nEta, Float_t etaMin, Float_t etaMax,
983 Int_t nPhi, Float_t phiMin, Float_t phiMax,
984 Float_t ptThresh)
985 : TObject()
986 ,fNBinsPt(nPt)
987 ,fPtMin(ptMin)
988 ,fPtMax(ptMax)
989 ,fNBinsEta(nEta)
990 ,fEtaMin(etaMin)
991 ,fEtaMax(etaMax)
992 ,fNBinsPhi(nPhi)
993 ,fPhiMin(phiMin)
994 ,fPhiMax(phiMax)
995 ,fHighPtThreshold(ptThresh)
996 ,fh2EtaPhi(0)
997 ,fh1Pt(0)
998 ,fh2HighPtEtaPhi(0)
999 ,fName(name)
1000{
1001 // default constructor
1002}
1003
1004//__________________________________________________________________________________________
1005AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::AliFragFuncQATrackHistos(const AliFragFuncQATrackHistos& copy)
1006 : TObject()
1007 ,fNBinsPt(copy.fNBinsPt)
1008 ,fPtMin(copy.fPtMin)
1009 ,fPtMax(copy.fPtMax)
1010 ,fNBinsEta(copy.fNBinsEta)
1011 ,fEtaMin(copy.fEtaMin)
1012 ,fEtaMax(copy.fEtaMax)
1013 ,fNBinsPhi(copy.fNBinsPhi)
1014 ,fPhiMin(copy.fPhiMin)
1015 ,fPhiMax(copy.fPhiMax)
1016 ,fHighPtThreshold(copy.fHighPtThreshold)
1017 ,fh2EtaPhi(copy.fh2EtaPhi)
1018 ,fh1Pt(copy.fh1Pt)
1019 ,fh2HighPtEtaPhi(copy.fh2HighPtEtaPhi)
1020 ,fName(copy.fName)
1021{
1022 // copy constructor
1023}
1024
1025// _____________________________________________________________________________________________________________________________________________________________________________
1026AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos& AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::operator=(const AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos& o)
1027{
1028 // assignment
1029
1030 if(this!=&o){
1031 TObject::operator=(o);
1032 fNBinsPt = o.fNBinsPt;
1033 fPtMin = o.fPtMin;
1034 fPtMax = o.fPtMax;
1035 fNBinsEta = o.fNBinsEta;
1036 fEtaMin = o.fEtaMin;
1037 fEtaMax = o.fEtaMax;
1038 fNBinsPhi = o.fNBinsPhi;
1039 fPhiMin = o.fPhiMin;
1040 fPhiMax = o.fPhiMax;
1041 fHighPtThreshold = o.fHighPtThreshold;
1042 fh2EtaPhi = o.fh2EtaPhi;
1043 fh1Pt = o.fh1Pt;
1044 fh2HighPtEtaPhi = o.fh2HighPtEtaPhi;
1045 fName = o.fName;
1046 }
1047
1048 return *this;
1049}
1050
1051//___________________________________________________________________
1052AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::~AliFragFuncQATrackHistos()
1053{
1054 // destructor
1055
1056 if(fh2EtaPhi) delete fh2EtaPhi;
1057 if(fh2HighPtEtaPhi) delete fh2HighPtEtaPhi;
1058 if(fh1Pt) delete fh1Pt;
1059}
1060
1061//______________________________________________________________________
1062void AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::DefineHistos()
1063{
1064 // book track QA histos
1065
1066 fh2EtaPhi = new TH2F(Form("fh2TrackQAEtaPhi%s", fName.Data()), Form("%s: #eta - #phi distribution", fName.Data()), fNBinsEta, fEtaMin, fEtaMax, fNBinsPhi, fPhiMin, fPhiMax);
1067 fh2HighPtEtaPhi = new TH2F(Form("fh2TrackQAHighPtEtaPhi%s", fName.Data()), Form("%s: #eta - #phi distribution for high-p_{T}", fName.Data()), fNBinsEta, fEtaMin, fEtaMax, fNBinsPhi, fPhiMin, fPhiMax);
1068 fh1Pt = new TH1F(Form("fh1TrackQAPt%s", fName.Data()), Form("%s: p_{T} distribution", fName.Data()), fNBinsPt, fPtMin, fPtMax);
1069
1070 AliAnalysisTaskFragmentationFunction::SetProperties(fh2EtaPhi, "#eta", "#phi");
1071 AliAnalysisTaskFragmentationFunction::SetProperties(fh2HighPtEtaPhi, "#eta", "#phi");
1072 AliAnalysisTaskFragmentationFunction::SetProperties(fh1Pt, "p_{T} [GeV/c]", "entries");
1073}
1074
1075//________________________________________________________________________________________________________
1076void AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::FillTrackQA(Float_t eta, Float_t phi, Float_t pt)
1077{
1078 // fill track QA histos
1079
1080 fh2EtaPhi->Fill( eta, phi);
1081 if(pt > fHighPtThreshold) fh2HighPtEtaPhi->Fill( eta, phi);
1082 fh1Pt->Fill( pt );
1083}
1084
1085//______________________________________________________________________________________
1086void AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::AddToOutput(TList* list) const
1087{
1088 // add histos to list
1089
1090 list->Add(fh2EtaPhi);
1091 list->Add(fh2HighPtEtaPhi);
1092 list->Add(fh1Pt);
1093}
1094
1095//______________________________________________________________________________________________________
1096AliAnalysisTaskFragmentationFunction::AliFragFuncIntraJetHistos::AliFragFuncIntraJetHistos(const char* name,
1097 Int_t nJetPt, Float_t jetPtMin, Float_t jetPtMax,
1098 Int_t nPt, Float_t ptMin, Float_t ptMax,
1099 Int_t nZ , Float_t zMin , Float_t zMax,
1100 Int_t nCosTheta , Float_t costhetaMin , Float_t costhetaMax,
1101 Int_t nTheta , Float_t thetaMin , Float_t thetaMax,
1102 Int_t nJt , Float_t jtMin , Float_t jtMax)
1103 : TObject()
1104 ,fNBinsJetPt(nJetPt)
1105 ,fJetPtMin(jetPtMin)
1106 ,fJetPtMax(jetPtMax)
1107 ,fNBinsPt(nPt)
1108 ,fPtMin(ptMin)
1109 ,fPtMax(ptMax)
1110 ,fNBinsZ(nZ)
1111 ,fZMin(zMin)
1112 ,fZMax(zMax)
1113 ,fNBinsJt(nJt)
1114 ,fJtMin(jtMin)
1115 ,fJtMax(jtMax)
1116 ,fNBinsTheta(nTheta)
1117 ,fThetaMin(thetaMin)
1118 ,fThetaMax(thetaMax)
1119 ,fNBinsCosTheta(nCosTheta)
1120 ,fCosThetaMin(costhetaMin)
1121 ,fCosThetaMax(costhetaMax)
1122 ,fh2Theta(0)
1123 ,fh2CosTheta(0)
1124 ,fh2Jt(0)
1125 ,fh2PtvsZ(0)
1126 ,fhnIntraJet(0)
1127 ,fnDim(6)
1128 ,fName(name)
1129{
1130 // default constructor
1131
1132}
1133
1134//___________________________________________________________________________
1135AliAnalysisTaskFragmentationFunction::AliFragFuncIntraJetHistos::AliFragFuncIntraJetHistos(const AliFragFuncIntraJetHistos& copy)
1136 : TObject()
1137 ,fNBinsJetPt(copy.fNBinsJetPt)
1138 ,fJetPtMin(copy.fJetPtMin)
1139 ,fJetPtMax(copy.fJetPtMax)
1140 ,fNBinsPt(copy.fNBinsPt)
1141 ,fPtMin(copy.fPtMin)
1142 ,fPtMax(copy.fPtMax)
1143 ,fNBinsZ(copy.fNBinsZ)
1144 ,fZMin(copy.fZMin)
1145 ,fZMax(copy.fZMax)
1146 ,fNBinsJt(copy.fNBinsJt)
1147 ,fJtMin(copy.fJtMin)
1148 ,fJtMax(copy.fJtMax)
1149 ,fNBinsTheta(copy.fNBinsTheta)
1150 ,fThetaMin(copy.fThetaMin)
1151 ,fThetaMax(copy.fThetaMax)
1152 ,fNBinsCosTheta(copy.fNBinsCosTheta)
1153 ,fCosThetaMin(copy.fCosThetaMin)
1154 ,fCosThetaMax(copy.fCosThetaMax)
1155 ,fh2Theta(copy.fh2Theta)
1156 ,fh2CosTheta(copy.fh2CosTheta)
1157 ,fh2Jt(copy.fh2Jt)
1158 ,fh2PtvsZ(copy.fh2PtvsZ)
1159 ,fhnIntraJet(copy.fhnIntraJet)
1160 ,fnDim(copy.fnDim)
1161 ,fName(copy.fName)
1162{
1163 // copy constructor
1164}
1165
1166//_______________________________________________________________________________________________________________________________________________________________
1167AliAnalysisTaskFragmentationFunction::AliFragFuncIntraJetHistos& AliAnalysisTaskFragmentationFunction::AliFragFuncIntraJetHistos::operator=(const AliAnalysisTaskFragmentationFunction::AliFragFuncIntraJetHistos& o)
1168{
1169 // assignment
1170
1171 if(this!=&o){
1172 TObject::operator=(o);
1173 fNBinsJetPt = o.fNBinsJetPt;
1174 fJetPtMin = o.fJetPtMin;
1175 fJetPtMax = o.fJetPtMax;
1176 fNBinsPt = o.fNBinsPt;
1177 fPtMin = o.fPtMin;
1178 fPtMax = o.fPtMax;
1179 fNBinsZ = o.fNBinsZ;
1180 fZMin = o.fZMin;
1181 fZMax = o.fZMax;
1182 fNBinsJt = o.fNBinsJt;
1183 fJtMin = o.fJtMin;
1184 fJtMax = o.fJtMax;
1185 fNBinsTheta = o.fNBinsTheta;
1186 fThetaMin = o.fThetaMin;
1187 fThetaMax = o.fThetaMax;
1188 fNBinsCosTheta = o.fNBinsCosTheta;
1189 fCosThetaMin = o.fCosThetaMin;
1190 fCosThetaMax = o.fCosThetaMax;
1191 fh2Theta = o.fh2Theta;
1192 fh2CosTheta = o.fh2CosTheta;
1193 fh2Jt = o.fh2Jt;
1194 fh2PtvsZ = o.fh2PtvsZ;
1195 fhnIntraJet = o.fhnIntraJet;
1196 fnDim = o.fnDim;
1197 fName = o.fName;
1198 }
1199
1200 return *this;
1201}
1202
1203//_________________________________________________________
1204AliAnalysisTaskFragmentationFunction::AliFragFuncIntraJetHistos::~AliFragFuncIntraJetHistos()
1205{
1206 // destructor
1207
1208
1209 if(fh2Theta) delete fh2Theta;
1210 if(fh2CosTheta) delete fh2CosTheta;
1211 if(fh2Jt) delete fh2Jt;
1212 if(fh2PtvsZ) delete fh2PtvsZ;
1213 if(fhnIntraJet) delete fhnIntraJet;
1214
1215}
1216
1217//_________________________________________________________________
1218void AliAnalysisTaskFragmentationFunction::AliFragFuncIntraJetHistos::DefineHistos()
1219{
1220 // book FF histos
1221
1222 fh2Theta = new TH2F(Form("fh2IJTheta%s",fName.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax,fNBinsTheta, fThetaMin, fThetaMax);
1223 fh2CosTheta = new TH2F(Form("fh2IJcosTheta%s",fName.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax,fNBinsCosTheta, fCosThetaMin, fCosThetaMax);
1224 fh2Jt = new TH2F(Form("fh2IJJt%s",fName.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax, fNBinsJt, fJtMin, fJtMax);
1225
1226 // Create 3D histograms
1227 Int_t *iBin = new Int_t[fnDim];
1228 Double_t *min = new Double_t[fnDim];
1229 Double_t *max = new Double_t[fnDim];
1230
1231 iBin[0] = fNBinsJetPt; iBin[1] = fNBinsTheta; iBin[2] = fNBinsCosTheta; iBin[3] = fNBinsJt; iBin[4] = fNBinsZ; iBin[5] = fNBinsPt;
1232 min[0] = fJetPtMin; min[1] = fThetaMin; min[2] = fCosThetaMin; min[3] = fJtMin; min[4] = fZMin; min[5] = fPtMin;
1233 max[0] = fJetPtMax; max[1] = fThetaMax; max[2] = fCosThetaMax; max[3] = fJtMax; max[4] = fZMax; max[5] = fPtMax;
1234
1235 const char* title = Form("fhnIntraJetPart%s",fName.Data());
1236 const char* comment = "THnSparseF p_{T} jet [GeV/c] : #Theta : cos(#Theta) : j_{T} : Z : p_{T} part [GeV/c]";
1237 fhnIntraJet = new THnSparseF(title,comment,fnDim,iBin,min,max);
1238
1239 const char** axisTitle = new const char*[fnDim];
1240 axisTitle[0] = "p_{T}^{jet} [GeV/c]";
1241 axisTitle[1] = "#Theta";
1242 axisTitle[2] = "Cos(#Theta)";
1243 axisTitle[3] = "j_{T} [GeV]";
1244 axisTitle[4] = "z = p_{T}^{had}/p_{T}^{jet}";
1245 axisTitle[5] = "p_{T}^{had} [GeV/c]";
1246
1247 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Theta,"jet p_{T} [GeV/c]","#Theta","entries");
1248 AliAnalysisTaskFragmentationFunction::SetProperties(fh2CosTheta,"jet p_{T} [GeV/c]","cos(#Theta)", "entries");
1249 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Jt,"jet p_{T} [GeV/c]","j_{T}","entries");
1250 AliAnalysisTaskFragmentationFunction::SetProperties(fhnIntraJet,fnDim,axisTitle);
1251 delete[] iBin;
1252 delete[] min;
1253 delete[] max;
1254 delete[] axisTitle;
1255}
1256
1257//_______________________________________________________________________________________________________________
1258void AliAnalysisTaskFragmentationFunction::AliFragFuncIntraJetHistos::FillIntraJet(TLorentzVector* trackV, TLorentzVector* jetV)
1259{
1260 // fill IntraJet histos
1261
1262 Float_t cosTheta = 0.; Float_t theta = 0.;
1263 Float_t jt = 0.; Float_t z = 0.;
1264 // For Theta distribution
1265 Float_t pxT = trackV->Px();
1266 Float_t pyT = trackV->Py();
1267 Float_t pzT = trackV->Pz();
1268 Float_t ptT = trackV->Pt();
1269 Float_t pT = trackV->P();
1270 Float_t etaT = trackV->Eta();
1271 Float_t phiT = trackV->Phi(); // Check the value returned
1272 Float_t pxJ = jetV->Px();
1273 Float_t pyJ = jetV->Py();
1274 Float_t pzJ = jetV->Pz();
1275 Float_t ptJ = jetV->Pt();
1276 Float_t pJ = jetV->P();
1277
1278 // Compute z
1279 z = (Float_t)(ptT/ptJ);
1280
1281 // Compute theta
1282 cosTheta = (pxT*pxJ+pyT*pyJ+pzT*pzJ)/(pT*pJ);
1283 theta = TMath::ACos(cosTheta);
1284
1285 // Compute jt
1286 TVector3 trackP; TVector3 jetP;
1287 jetP[0] = pxJ;
1288 jetP[1] = pyJ;
1289 jetP[2] = pzJ;
1290 trackP.SetPtEtaPhi(ptT,etaT,phiT);
1291 jt = TMath::Sin(trackP.Angle(jetP))*trackP.Mag();
1292
1293 // Fill histos and THnSparse
1294 fh2CosTheta->Fill(ptJ,cosTheta);
1295 fh2Theta->Fill(ptJ,theta);
1296 fh2Jt->Fill(ptJ,jt);
1297
1298 // Fill THnSparse
1299 Double_t *content = new Double_t[fnDim];
1300 content[0]= ptJ; content[1] = theta; content[2] = cosTheta; content[3] = jt; content[4] = z; content[5] = ptT;
1301
1302 fhnIntraJet->Fill(content);
1303
1304 delete content;
1305
1306}
1307
1308//______________________________________________________________________________________________________
1309AliAnalysisTaskFragmentationFunction::AliFragFuncDiJetHistos::AliFragFuncDiJetHistos(const char* name, Int_t kindSlices,
1310 Int_t nJetInvMass, Float_t jetInvMassMin, Float_t jetInvMassMax,
1311 Int_t nJetPt, Float_t jetPtMin, Float_t jetPtMax,
1312 Int_t nPt, Float_t ptMin, Float_t ptMax,
1313 Int_t nXi, Float_t xiMin, Float_t xiMax,
1314 Int_t nZ , Float_t zMin , Float_t zMax)
1315 : TObject()
1316 ,fKindSlices(kindSlices)
1317 ,fNBinsJetInvMass(nJetInvMass)
1318 ,fJetInvMassMin(jetInvMassMin)
1319 ,fJetInvMassMax(jetInvMassMax)
1320 ,fNBinsJetPt(nJetPt)
1321 ,fJetPtMin(jetPtMin)
1322 ,fJetPtMax(jetPtMax)
1323 ,fNBinsPt(nPt)
1324 ,fPtMin(ptMin)
1325 ,fPtMax(ptMax)
1326 ,fNBinsXi(nXi)
1327 ,fXiMin(xiMin)
1328 ,fXiMax(xiMax)
1329 ,fNBinsZ(nZ)
1330 ,fZMin(zMin)
1331 ,fZMax(zMax)
1332 ,fh2TrackPtJet1(0)
1333 ,fh2TrackPtJet2(0)
1334 ,fh2TrackPtJet(0)
1335 ,fh1Jet1Pt(0)
1336 ,fh1Jet2Pt(0)
1337 ,fh1JetPt(0)
1338 ,fh2Xi1(0)
1339 ,fh2Xi2(0)
1340 ,fh2Xi(0)
1341 ,fh2Z1(0)
1342 ,fh2Z2(0)
1343 ,fh2Z(0)
1344 ,fh2Pt1(0)
1345 ,fh2Pt2(0)
1346 ,fh2Pt(0)
1347 ,fName(name)
1348{
1349 // default constructor
1350
1351}
1352
1353//______________________________________________________________________________________________________
1354AliAnalysisTaskFragmentationFunction::AliFragFuncDiJetHistos::AliFragFuncDiJetHistos(const AliFragFuncDiJetHistos& copy)
1355 : TObject()
1356 ,fKindSlices(copy.fKindSlices)
1357 ,fNBinsJetInvMass(copy.fNBinsJetInvMass)
1358 ,fJetInvMassMin(copy.fJetInvMassMin)
1359 ,fJetInvMassMax(copy.fJetInvMassMax)
1360 ,fNBinsJetPt(copy.fNBinsJetPt)
1361 ,fJetPtMin(copy.fJetPtMin)
1362 ,fJetPtMax(copy.fJetPtMax)
1363 ,fNBinsPt(copy.fNBinsPt)
1364 ,fPtMin(copy.fPtMin)
1365 ,fPtMax(copy.fPtMax)
1366 ,fNBinsXi(copy.fNBinsXi)
1367 ,fXiMin(copy.fXiMin)
1368 ,fXiMax(copy.fXiMax)
1369 ,fNBinsZ(copy.fNBinsZ)
1370 ,fZMin(copy.fZMin)
1371 ,fZMax(copy.fZMax)
1372 ,fh2TrackPtJet1(copy.fh2TrackPtJet1)
1373 ,fh2TrackPtJet2(copy.fh2TrackPtJet2)
1374 ,fh2TrackPtJet(copy.fh2TrackPtJet)
1375 ,fh1Jet1Pt(copy.fh1Jet1Pt)
1376 ,fh1Jet2Pt(copy.fh1Jet2Pt)
1377 ,fh1JetPt(copy.fh1JetPt)
1378 ,fh2Xi1(copy.fh2Xi1)
1379 ,fh2Xi2(copy.fh2Xi2)
1380 ,fh2Xi(copy.fh2Xi2)
1381 ,fh2Z1(copy.fh2Z1)
1382 ,fh2Z2(copy.fh2Z2)
1383 ,fh2Z(copy.fh2Z)
1384 ,fh2Pt1(copy.fh2Pt1)
1385 ,fh2Pt2(copy.fh2Pt2)
1386 ,fh2Pt(copy.fh2Pt)
1387 ,fName(copy.fName)
1388{
1389 // default constructor
1390
1391}
1392
1393//_______________________________________________________________________________________________________________________________________________________________
1394AliAnalysisTaskFragmentationFunction::AliFragFuncDiJetHistos& AliAnalysisTaskFragmentationFunction::AliFragFuncDiJetHistos::operator=(const AliAnalysisTaskFragmentationFunction::AliFragFuncDiJetHistos& o)
1395{
1396 // assignment
1397
1398 if(this!=&o){
1399 TObject::operator=(o);
1400 fKindSlices = o.fKindSlices;
1401 fNBinsJetInvMass = o.fNBinsJetInvMass;
1402 fJetInvMassMin = o.fJetInvMassMin;
1403 fJetInvMassMax = o.fJetInvMassMax;
1404 fNBinsJetPt = o.fNBinsJetPt;
1405 fJetPtMin = o.fJetPtMin;
1406 fJetPtMax = o.fJetPtMax;
1407 fNBinsPt = o.fNBinsPt;
1408 fPtMin = o.fPtMin;
1409 fPtMax = o.fPtMax;
1410 fNBinsXi = o.fNBinsXi;
1411 fXiMin = o.fXiMin;
1412 fXiMax = o.fXiMax;
1413 fNBinsZ = o.fNBinsZ;
1414 fZMin = o.fZMin;
1415 fZMax = o.fZMax;
1416 fh2TrackPtJet1 = o.fh2TrackPtJet1;
1417 fh2TrackPtJet2 = o.fh2TrackPtJet2;
1418 fh2TrackPtJet = o.fh2TrackPtJet;
1419 fh1Jet1Pt = o.fh1Jet1Pt;
1420 fh1Jet2Pt = o.fh1Jet2Pt;
1421 fh1JetPt = o.fh1JetPt;
1422 fh2Xi1 = o.fh2Xi1;
1423 fh2Xi2 = o.fh2Xi2;
1424 fh2Xi = o.fh2Xi;
1425 fh2Z1 = o.fh2Z1;
1426 fh2Z2 = o.fh2Z2;
1427 fh2Z = o.fh2Z;
1428 fh2Pt1 = o.fh2Pt1;
1429 fh2Pt2 = o.fh2Pt2;
1430 fh2Pt = o.fh2Pt;
1431 fName = o.fName;
1432 }
1433
1434 return *this;
1435}
1436
1437//_________________________________________________________
1438AliAnalysisTaskFragmentationFunction::AliFragFuncDiJetHistos::~AliFragFuncDiJetHistos()
1439{
1440 // destructor
1441
1442 if(fh2TrackPtJet1) delete fh2TrackPtJet1;
1443 if(fh2TrackPtJet2) delete fh2TrackPtJet2;
1444 if(fh2TrackPtJet ) delete fh2TrackPtJet;
1445 if(fh1Jet1Pt) delete fh1Jet1Pt;
1446 if(fh1Jet2Pt) delete fh1Jet2Pt;
1447 if(fh1JetPt) delete fh1JetPt;
1448 if(fh2Xi1) delete fh2Xi1;
1449 if(fh2Xi2) delete fh2Xi2;
1450 if(fh2Xi) delete fh2Xi;
1451 if(fh2Z1) delete fh2Z1;
1452 if(fh2Z2) delete fh2Z2;
1453 if(fh2Z) delete fh2Z;
1454 if(fh2Pt1) delete fh2Pt1;
1455 if(fh2Pt2) delete fh2Pt2;
1456 if(fh2Pt) delete fh2Pt;
1457}
1458
1459//________________________________________________________________________
1460void AliAnalysisTaskFragmentationFunction::AliFragFuncDiJetHistos::DefineDiJetHistos()
1461{
1462
1463 Int_t nBins = 0;
1464 Double_t min = 0.;
1465 Double_t max = 0.;
1466 const char *xaxis = "";
1467 if(fKindSlices == 1)
1468 {
1469 nBins = fNBinsJetInvMass;
1470 min = fJetInvMassMin;
1471 max = fJetInvMassMax;
1472 xaxis = "M_{JJ} [GeV]";
1473 }
1474 if(fKindSlices == 2 || fKindSlices == 3)
1475 {
1476 nBins = fNBinsJetPt;
1477 min = fJetPtMin;
1478 max = fJetPtMax;
1479 if(fKindSlices == 2) xaxis = "E_{Tmean} [GeV]";
1480 if(fKindSlices == 3) xaxis ="leading jet p_{T} [GeV/c]";
1481 }
1482
1483 fh1Jet1Pt = new TH1F(Form("fh1DJJet1Pt%s", fName.Data()), "", fNBinsJetPt, fJetPtMin, fJetPtMax);
1484 fh1Jet2Pt = new TH1F(Form("fh1DJJet2Pt%s", fName.Data()), "", fNBinsJetPt, fJetPtMin, fJetPtMax);
1485 fh1JetPt = new TH1F(Form("fh1DJJetPt%s", fName.Data()), "", fNBinsJetPt, fJetPtMin, fJetPtMax);
1486
1487 fh2TrackPtJet1 = new TH2F(Form("fh2DJTrackPtJet1%s", fName.Data()), "",nBins, min, max, fNBinsPt, fPtMin, fPtMax);
1488 fh2TrackPtJet2 = new TH2F(Form("fh2DJTrackPtJet2%s", fName.Data()), "",nBins, min, max, fNBinsPt, fPtMin, fPtMax);
1489 fh2TrackPtJet = new TH2F(Form("fh2DJTrackPtJet%s", fName.Data()), "",nBins, min, max, fNBinsPt, fPtMin, fPtMax);
1490
1491 fh2Xi1 = new TH2F(Form("fh2DJXi1%s", fName.Data()), "",nBins, min, max, fNBinsXi, fXiMin, fXiMax);
1492 fh2Xi2 = new TH2F(Form("fh2DJXi2%s", fName.Data()), "",nBins, min, max, fNBinsXi, fXiMin, fXiMax);
1493 fh2Xi = new TH2F(Form("fh2DJXi%s", fName.Data()), "",nBins, min, max, fNBinsXi, fXiMin, fXiMax);
1494
1495 fh2Z1 = new TH2F(Form("fh2DJZ1%s", fName.Data()), "",nBins, min, max, fNBinsZ, fZMin, fZMax);
1496 fh2Z2 = new TH2F(Form("fh2DJZ2%s", fName.Data()), "",nBins, min, max, fNBinsZ, fZMin, fZMax);
1497 fh2Z = new TH2F(Form("fh2DJZ%s", fName.Data()), "",nBins, min, max, fNBinsZ, fZMin, fZMax);
1498
1499 fh2Pt1 = new TH2F(Form("fh2DJPt1%s", fName.Data()), "",nBins, min, max, fNBinsPt, fPtMin, fPtMax);
1500 fh2Pt2 = new TH2F(Form("fh2DJPt2%s", fName.Data()), "",nBins, min, max, fNBinsPt, fPtMin, fPtMax);
1501 fh2Pt = new TH2F(Form("fh2DJPtZ%s", fName.Data()), "",nBins, min, max, fNBinsPt, fPtMin, fPtMax);
1502
1503 AliAnalysisTaskFragmentationFunction::SetProperties(fh1Jet1Pt, "p_{T} [GeV/c]", "entries");
1504 AliAnalysisTaskFragmentationFunction::SetProperties(fh1Jet2Pt, "p_{T} [GeV/c]", "entries");
1505 AliAnalysisTaskFragmentationFunction::SetProperties(fh1JetPt, "p_{T} [GeV/c]", "entries");
1506
1507 AliAnalysisTaskFragmentationFunction::SetProperties(fh2TrackPtJet1, xaxis, "p_{T} [GeV/c]", "Entries");
1508 AliAnalysisTaskFragmentationFunction::SetProperties(fh2TrackPtJet2, xaxis, "p_{T} [GeV/c]", "Entries");
1509 AliAnalysisTaskFragmentationFunction::SetProperties(fh2TrackPtJet, xaxis, "p_{T} [GeV/c]", "Entries");
1510 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Xi1, xaxis, "#xi", "Entries");
1511 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Xi2, xaxis, "#xi", "Entries");
1512 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Xi, xaxis, "#xi", "Entries");
1513 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Z1, xaxis, "z", "Entries");
1514 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Z2, xaxis, "z", "Entries");
1515 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Z, xaxis, "z", "Entries");
1516 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Pt1, xaxis, "p_{T} [GeV/c]", "Entries");
1517 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Pt2, xaxis, "p_{T} [GeV/c]", "Entries");
1518 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Pt, xaxis, "p_{T} [GeV/c]", "Entries");
1519
1520}
1521
1522//________________________________________________________________________
1523void AliAnalysisTaskFragmentationFunction::AliFragFuncDiJetHistos::FillDiJetFF(Int_t jetType, Float_t trackPt, Float_t jetPt, Double_t jetBin, Bool_t incrementJetPt)
1524{
1525 if(jetType == 0)
1526 {
1527 if(incrementJetPt) fh1JetPt->Fill(jetPt);
1528
1529 fh2TrackPtJet->Fill(jetBin, trackPt);
1530
1531 Double_t z = trackPt / jetPt;
1532 Double_t xi = 0;
1533 if(z!=0) xi = TMath::Log(1/z);
1534
1535 fh2Xi->Fill(jetBin, xi);
1536 fh2Z->Fill(jetBin, z);
1537 }
1538 if(jetType == 1)
1539 {
1540 if(incrementJetPt) fh1Jet1Pt->Fill(jetPt);
1541
1542 fh2TrackPtJet1->Fill(jetBin, trackPt);
1543
1544 Double_t z = trackPt / jetPt;
1545 Double_t xi = 0;
1546 if(z!=0) xi = TMath::Log(1/z);
1547
1548 fh2Xi1->Fill(jetBin, xi);
1549 fh2Z1->Fill(jetBin, z);
1550 }
1551 if(jetType == 2)
1552 {
1553 if(incrementJetPt) fh1Jet2Pt->Fill(jetPt);
1554
1555 fh2TrackPtJet2->Fill(jetBin, trackPt);
1556
1557 Double_t z = trackPt / jetPt;
1558 Double_t xi = 0;
1559 if(z!=0) xi = TMath::Log(1/z);
1560
1561 fh2Xi2->Fill(jetBin, xi);
1562 fh2Z2->Fill(jetBin, z);
1563 }
1564
1565
1566}
1567
1568//________________________________________________________________________
1569void AliAnalysisTaskFragmentationFunction::AliFragFuncDiJetHistos::AddToOutput(TList* list)const
1570{
1571 list->Add(fh1Jet1Pt);
1572 list->Add(fh1Jet2Pt);
1573 list->Add(fh1JetPt);
1574 list->Add(fh2TrackPtJet1);
1575 list->Add(fh2TrackPtJet2);
1576 list->Add(fh2TrackPtJet);
1577 list->Add(fh2Xi1);
1578 list->Add(fh2Xi2);
1579 list->Add(fh2Xi);
1580 list->Add(fh2Z1);
1581 list->Add(fh2Z2);
1582 list->Add(fh2Z);
1583}
1584
1585//______________________________________________________________________________________________________
1586AliAnalysisTaskFragmentationFunction::AliFragFuncQADiJetHistos::AliFragFuncQADiJetHistos(const char* name, Int_t kindSlices,
1587 Int_t nInvMass, Float_t invMassMin, Float_t invMassMax,
1588 Int_t nJetPt, Float_t jetPtMin, Float_t jetPtMax,
1589 Int_t nDeltaPhi, Float_t deltaPhiMin, Float_t deltaPhiMax,
1590 Int_t nDeltaEta, Float_t deltaEtaMin, Float_t deltaEtaMax,
1591 Int_t nDeltaPt, Float_t deltaPtMin, Float_t deltaPtMax)
1592 : TObject()
1593 ,fKindSlices(kindSlices)
1594 ,fNBinsJetInvMass(nInvMass)
1595 ,fJetInvMassMin(invMassMin)
1596 ,fJetInvMassMax(invMassMax)
1597 ,fNBinsJetPt(nJetPt)
1598 ,fJetPtMin(jetPtMin)
1599 ,fJetPtMax(jetPtMax)
1600 ,fNBinsDeltaPhi(nDeltaPhi)
1601 ,fDeltaPhiMin(deltaPhiMin)
1602 ,fDeltaPhiMax(deltaPhiMax)
1603 ,fNBinsDeltaEta(nDeltaEta)
1604 ,fDeltaEtaMin(deltaEtaMin)
1605 ,fDeltaEtaMax(deltaEtaMax)
1606 ,fNBinsDeltaPt(nDeltaPt)
1607 ,fDeltaPtMin(deltaPtMin)
1608 ,fDeltaPtMax(deltaPtMax)
1609 ,fh2InvMass(0)
1610 ,fh2DeltaPhi(0)
1611 ,fh2DeltaEta(0)
1612 ,fh2DeltaPt(0)
1613 ,fName(name)
1614{
1615 // default constructor
1616
1617}
1618
1619//______________________________________________________________________________________________________
1620AliAnalysisTaskFragmentationFunction::AliFragFuncQADiJetHistos::AliFragFuncQADiJetHistos(const AliFragFuncQADiJetHistos& copy)
1621 : TObject()
1622 ,fKindSlices(copy.fKindSlices)
1623 ,fNBinsJetInvMass(copy.fNBinsJetInvMass)
1624 ,fJetInvMassMin(copy.fJetInvMassMin)
1625 ,fJetInvMassMax(copy.fJetInvMassMax)
1626 ,fNBinsJetPt(copy.fNBinsJetPt)
1627 ,fJetPtMin(copy.fJetPtMin)
1628 ,fJetPtMax(copy.fJetPtMax)
1629 ,fNBinsDeltaPhi(copy.fNBinsDeltaPhi)
1630 ,fDeltaPhiMin(copy.fDeltaPhiMin)
1631 ,fDeltaPhiMax(copy.fDeltaPhiMax)
1632 ,fNBinsDeltaEta(copy.fNBinsDeltaEta)
1633 ,fDeltaEtaMin(copy.fDeltaEtaMin)
1634 ,fDeltaEtaMax(copy.fDeltaEtaMax)
1635 ,fNBinsDeltaPt(copy.fNBinsDeltaPt)
1636 ,fDeltaPtMin(copy.fDeltaPtMin)
1637 ,fDeltaPtMax(copy.fDeltaPtMax)
1638 ,fh2InvMass(copy.fh2InvMass)
1639 ,fh2DeltaPhi(copy.fh2DeltaPhi)
1640 ,fh2DeltaEta(copy.fh2DeltaEta)
1641 ,fh2DeltaPt(copy.fh2DeltaPt)
1642 ,fName(copy.fName)
1643{
1644 // default constructor
1645
1646}
1647
1648//_______________________________________________________________________________________________________________________________________________________________
1649AliAnalysisTaskFragmentationFunction::AliFragFuncQADiJetHistos& AliAnalysisTaskFragmentationFunction::AliFragFuncQADiJetHistos::operator=(const AliAnalysisTaskFragmentationFunction::AliFragFuncQADiJetHistos& o)
1650{
1651 // assignment
1652
1653 if(this!=&o){
1654 TObject::operator=(o);
1655 fKindSlices = o.fKindSlices;
1656 fNBinsJetInvMass = o.fNBinsJetInvMass;
1657 fJetInvMassMin = o.fJetInvMassMin;
1658 fJetInvMassMax = o.fJetInvMassMax;
1659 fNBinsJetPt = o.fNBinsJetPt;
1660 fJetPtMin = o.fJetPtMin;
1661 fJetPtMax = o.fJetPtMax;
1662 fNBinsDeltaPhi = o.fNBinsDeltaPhi;
1663 fDeltaPhiMin = o.fDeltaPhiMin;
1664 fDeltaPhiMax = o.fDeltaPhiMax;
1665 fNBinsDeltaEta = o.fNBinsDeltaEta;
1666 fDeltaEtaMin = o.fDeltaEtaMin;
1667 fDeltaEtaMax = o.fDeltaEtaMax;
1668 fNBinsDeltaPt = o.fNBinsDeltaPt;
1669 fDeltaPtMin = o.fDeltaPtMin;
1670 fDeltaPtMax = o.fDeltaPtMax;
1671 fh2InvMass = o.fh2InvMass;
1672 fh2DeltaPhi = o.fh2DeltaPhi;
1673 fh2DeltaEta = o.fh2DeltaEta;
1674 fh2DeltaPt = o.fh2DeltaPt;
1675 fName = o.fName;
1676 }
1677
1678 return *this;
1679}
1680
1681//_________________________________________________________
1682AliAnalysisTaskFragmentationFunction::AliFragFuncQADiJetHistos::~AliFragFuncQADiJetHistos()
1683{
1684 // destructor
1685
1686 if(fh2InvMass) delete fh2InvMass;
1687 if(fh2DeltaPhi) delete fh2DeltaPhi;
1688 if(fh2DeltaEta) delete fh2DeltaEta;
1689 if(fh2DeltaPt) delete fh2DeltaPt;
1690}
1691
1692//________________________________________________________________________
1693void AliAnalysisTaskFragmentationFunction::AliFragFuncQADiJetHistos::DefineQADiJetHistos()
1694{
1695
1696 Int_t nBins = 0;
1697 Double_t min = 0.;
1698 Double_t max = 0.;
1699 const char *xaxis = "";
1700 if(fKindSlices == 1)
1701 {
1702 nBins = fNBinsJetInvMass;
1703 min = fJetInvMassMin;
1704 max = fJetInvMassMax;
1705 xaxis = "M_{JJ} [GeV]";
1706 }
1707 if(fKindSlices == 2 || fKindSlices == 3)
1708 {
1709 nBins = fNBinsJetPt;
1710 min = fJetPtMin;
1711 max = fJetPtMax;
1712 if(fKindSlices == 2) xaxis = "E_{Tmean} [GeV]";
1713 if(fKindSlices == 3) xaxis ="leading jet p_{T} [GeV/c]";
1714 }
1715
1716
1717 fh2InvMass = new TH2F(Form("fh2DJInvMassPositionCut%s", fName.Data()), "",nBins, min, max, fNBinsJetInvMass, fJetInvMassMin, fJetInvMassMax);
1718 fh2DeltaPhi = new TH2F(Form("fh2DJDeltaPhiPositionCut%s", fName.Data()), "",nBins, min, max, fNBinsDeltaPhi, fDeltaPhiMin, fDeltaPhiMax);
1719 fh2DeltaEta = new TH2F(Form("fh2DJDeltaEtaPositionCut%s", fName.Data()), "",nBins, min, max, fNBinsDeltaEta, fDeltaEtaMin, fDeltaEtaMax);
1720 fh2DeltaPt = new TH2F(Form("fh2DJDeltaPtPositionCut%s", fName.Data()), "",nBins, min, max, fNBinsDeltaPt, fDeltaPtMin, fDeltaPtMax);
1721
1722 AliAnalysisTaskFragmentationFunction::SetProperties(fh2InvMass, xaxis, "Invariant Mass", "Entries");
1723 AliAnalysisTaskFragmentationFunction::SetProperties(fh2DeltaPhi, xaxis, "#Delta #phi", "Entries");
1724 AliAnalysisTaskFragmentationFunction::SetProperties(fh2DeltaEta, xaxis, "#Delta #eta", "Entries");
1725 AliAnalysisTaskFragmentationFunction::SetProperties(fh2DeltaPt, xaxis, "#Delta p_{T}", "Entries");
1726
1727}
1728
1729//________________________________________________________________________
1730void AliAnalysisTaskFragmentationFunction::AliFragFuncQADiJetHistos::FillDiJetQA(Double_t invMass, Double_t deltaPhi, Double_t deltaEta,Double_t deltaPt, Double_t jetBin)
1731{
1732 fh2InvMass->Fill(jetBin, invMass);
1733 fh2DeltaPhi->Fill(jetBin, deltaPhi);
1734 fh2DeltaEta->Fill(jetBin, deltaEta);
1735 fh2DeltaPt->Fill(jetBin, deltaPt);
1736}
1737
1738//________________________________________________________________________
1739void AliAnalysisTaskFragmentationFunction::AliFragFuncQADiJetHistos::AddToOutput(TList* list)const
1740{
1741 list->Add(fh2InvMass);
1742 list->Add(fh2DeltaPhi);
1743 list->Add(fh2DeltaEta);
1744 list->Add(fh2DeltaPt);
1745}
1746
1747//_________________________________________________________________________________
1748void AliAnalysisTaskFragmentationFunction::AliFragFuncIntraJetHistos::AddToOutput(TList* list) const
1749{
1750 // add histos to list
1751
1752 list->Add(fh2CosTheta);
1753 list->Add(fh2Theta);
1754 list->Add(fh2Jt);
1755
1756 list->Add(fhnIntraJet);
1757
1758}
1759
ac017ff3 1760
1761Bool_t AliAnalysisTaskFragmentationFunction::Notify()
1762{
1763 //
1764 // Implemented Notify() to read the cross sections
1765 // and number of trials from pyxsec.root
1766 // (taken from AliAnalysisTaskJetSpectrum)
1767 //
1768 TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
1769 Double_t xsection = 0;
1770 UInt_t ntrials = 0;
1771 Float_t ftrials = 0;
1772 if(tree){
1773 TFile *curfile = tree->GetCurrentFile();
1774 if (!curfile) {
1775 Error("Notify","No current file");
1776 return kFALSE;
1777 }
1778 if(!fh1Xsec||!fh1Trials){
1779 Printf("%s%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__);
1780 return kFALSE;
1781 }
1782
1783 TString fileName(curfile->GetName());
1784 if(fileName.Contains("AliESDs.root")){
1785 fileName.ReplaceAll("AliESDs.root", "");
1786 }
1787 else if(fileName.Contains("AliAOD.root")){
1788 fileName.ReplaceAll("AliAOD.root", "");
1789 }
1790 else if(fileName.Contains("AliAODs.root")){
1791 fileName.ReplaceAll("AliAODs.root", "");
1792 }
1793 else if(fileName.Contains("galice.root")){
1794 // for running with galice and kinematics alone...
1795 fileName.ReplaceAll("galice.root", "");
1796 }
1797 TFile *fxsec = TFile::Open(Form("%s%s",fileName.Data(),"pyxsec.root"));
1798 if(!fxsec){
1799 if(fDebug>0)Printf("%s:%d %s not found in the Input",(char*)__FILE__,__LINE__,Form("%s%s",fileName.Data(),"pyxsec.root"));
1800 // next trial fetch the histgram file
1801 fxsec = TFile::Open(Form("%s%s",fileName.Data(),"pyxsec_hists.root"));
1802 if(!fxsec){
1803 // not a severe condition
1804 if(fDebug>0)Printf("%s:%d %s not found in the Input",(char*)__FILE__,__LINE__,Form("%s%s",fileName.Data(),"pyxsec_hists.root"));
1805 return kTRUE;
1806 }
1807 else{
1808 // find the tlist we want to be independtent of the name so use the Tkey
1809 TKey* key = (TKey*)fxsec->GetListOfKeys()->At(0);
1810 if(!key){
1811 if(fDebug>0)Printf("%s:%d key not found in the file",(char*)__FILE__,__LINE__);
1812 return kTRUE;
1813 }
1814 TList *list = dynamic_cast<TList*>(key->ReadObj());
1815 if(!list){
1816 if(fDebug>0)Printf("%s:%d key is not a tlist",(char*)__FILE__,__LINE__);
1817 return kTRUE;
1818 }
1819 xsection = ((TProfile*)list->FindObject("h1Xsec"))->GetBinContent(1);
1820 ftrials = ((TH1F*)list->FindObject("h1Trials"))->GetBinContent(1);
1821 }
1822 }
1823 else{
1824 TTree *xtree = (TTree*)fxsec->Get("Xsection");
1825 if(!xtree){
1826 Printf("%s:%d tree not found in the pyxsec.root",(char*)__FILE__,__LINE__);
1827 }
1828 xtree->SetBranchAddress("xsection",&xsection);
1829 xtree->SetBranchAddress("ntrials",&ntrials);
1830 ftrials = ntrials;
1831 xtree->GetEntry(0);
1832 }
1833 fh1Xsec->Fill("<#sigma>",xsection);
1834 fh1Trials->Fill("#sum{ntrials}",ftrials);
1835 }
1836
1837 return kTRUE;
1838}
1839
1840
1841
656dc810 1842//__________________________________________________________________
1843void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects()
1844{
1845 // create output objects
1846
1847 if(fDebug > 1) Printf("AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects()");
1848
1849 // create list of tracks and jets
1850
1851 fTracksRec = new TList();
1852 fTracksRec->SetOwner(kFALSE);
1853
1854 fTracksRecCuts = new TList();
1855 fTracksRecCuts->SetOwner(kFALSE);
1856
1857 fTracksGen = new TList();
1858 fTracksGen->SetOwner(kFALSE);
1859
fe343c6b 1860 fTracksAODMCCharged = new TList();
1861 fTracksAODMCCharged->SetOwner(kFALSE);
1862
1863 fTracksRecQualityCuts = new TList();
1864 fTracksRecQualityCuts->SetOwner(kFALSE);
1865
656dc810 1866 fJetsRec = new TList();
1867 fJetsRec->SetOwner(kFALSE);
1868
1869 fJetsRecCuts = new TList();
1870 fJetsRecCuts->SetOwner(kFALSE);
1871
1872 fJetsGen = new TList();
1873 fJetsGen->SetOwner(kFALSE);
1874
fe343c6b 1875 fJetsRecEff = new TList();
1876 fJetsRecEff->SetOwner(kFALSE);
1877
656dc810 1878 // fJetsKine = new TList();
1879 // fJetsKine->SetOwner(kTRUE); // delete AOD jets using mom from Kine Tree via TList::Clear()
1880
1881
1882 //
1883 // Create histograms / output container
1884 //
1885
1886 OpenFile(1);
1887 fCommonHistList = new TList();
1888
1889 Bool_t oldStatus = TH1::AddDirectoryStatus();
1890 TH1::AddDirectory(kFALSE);
1891
1892
1893 // Histograms
1894 fh1EvtSelection = new TH1F("fh1EvtSelection", "Event Selection", 6, -0.5, 5.5);
1895 fh1VertexNContributors = new TH1F("fh1VertexNContributors", "Vertex N contributors", 11,-.5, 10.5);
1896 fh1VertexZ = new TH1F("fh1VertexZ", "Vertex z distribution", 30, -15., 15.);
ac017ff3 1897 fh1EvtMult = new TH1F("fh1EvtMult","Event multiplicity, track pT cut > 150 MeV/c, |#eta| < 0.9",120,0.,120.);
1898
1899 fh1Xsec = new TProfile("fh1Xsec","xsec from pyxsec.root",1,0,1);
1900 fh1Xsec->GetXaxis()->SetBinLabel(1,"<#sigma>");
1901 fh1Trials = new TH1F("fh1Trials","trials from pyxsec.root",1,0,1);
1902 fh1Trials->GetXaxis()->SetBinLabel(1,"#sum{ntrials}");
1903 fh1PtHard = new TH1F("fh1PtHard","PYTHIA Pt hard;p_{T,hard}",350,-.5,349.5);
1904 fh1PtHardTrials = new TH1F("fh1PtHardTrials","PYTHIA Pt hard weight with trials;p_{T,hard}",350,-.5,349.5);
1905
656dc810 1906 fh1nRecJetsCuts = new TH1F("fh1nRecJetsCuts","reconstructed jets per event",10,-0.5,9.5);
1907 fh1nGenJets = new TH1F("fh1nGenJets","generated jets per event",10,-0.5,9.5);
fe343c6b 1908 fh1nRecEffJets = new TH1F("fh1nRecEffJets","reconstruction effiency: jets per event",10,-0.5,9.5);
1909
1910 // 5D single track eff histo: phi:eta:gen pt:rec pt:isReconstructed - use binning as for track QA
1911 Int_t nBinsSingleTrackEffHisto[5] = { fQATrackNBinsPhi, fQATrackNBinsEta, fQATrackNBinsPt, fQATrackNBinsPt, 2 };
1912 Double_t binMinSingleTrackEffHisto[5] = { fQATrackPhiMin, fQATrackEtaMin, fQATrackPtMin, fQATrackPtMin, 0 };
1913 Double_t binMaxSingleTrackEffHisto[5] = { fQATrackPhiMax, fQATrackEtaMax, fQATrackPtMax, fQATrackPtMax, 2 };
1914 const char* labelsSingleTrackEffHisto[5] = {"#phi","#eta","gen p_{T} [GeV/c]", "rec p_{T} [GeV/c]", "isRec"};
1915
1916 fhnSingleTrackRecEffHisto = new THnSparseF("fhnSingleTrackRecEffHisto","generated tracks phi:eta:pt:isReconstructed",5,
1917 nBinsSingleTrackEffHisto,binMinSingleTrackEffHisto,binMaxSingleTrackEffHisto);
1918
1919 AliAnalysisTaskFragmentationFunction::SetProperties(fhnSingleTrackRecEffHisto,5,labelsSingleTrackEffHisto);
1920
1921
1922 // 7D jets track eff histo: jet phi:eta:pt:track pt:z:xi:isReconstructed - use binning as for track/jet QA
1923 Int_t nBinsJetTrackEffHisto[7] = { fQAJetNBinsPhi, fQAJetNBinsEta, fFFNBinsJetPt, fFFNBinsPt, fFFNBinsZ, fFFNBinsXi, 2};
1924 Double_t binMinJetTrackEffHisto[7] = { fQAJetPhiMin, fQAJetEtaMin, fFFJetPtMin , fFFPtMin, fFFZMin , fFFXiMin, 0 };
1925 Double_t binMaxJetTrackEffHisto[7] = { fQAJetPhiMax, fQAJetEtaMax, fFFJetPtMax , fFFPtMax, fFFZMax , fFFXiMax, 2 };
1926 const char* labelsJetTrackEffHisto[7] = {"jet #phi","jet #eta","jet p_{T} [GeV/c]","track p_{T} [GeV/c]","z","#xi","isRec"};
1927
1928 fhnJetTrackRecEffHisto = new THnSparseF("fhnJetTrackRecEffHisto","generated tracks - jet phi:jet eta:jet pt:track pt:z:xi:isReconstructed",7,
1929 nBinsJetTrackEffHisto,binMinJetTrackEffHisto,binMaxJetTrackEffHisto);
1930
1931 AliAnalysisTaskFragmentationFunction::SetProperties(fhnJetTrackRecEffHisto,7,labelsJetTrackEffHisto);
656dc810 1932
1933
1934 fQATrackHistosRec = new AliFragFuncQATrackHistos("Rec", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1935 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1936 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1937 fQATrackHighPtThreshold);
1938 fQATrackHistosRecCuts = new AliFragFuncQATrackHistos("RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1939 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1940 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1941 fQATrackHighPtThreshold);
1942 fQATrackHistosGen = new AliFragFuncQATrackHistos("Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1943 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1944 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1945 fQATrackHighPtThreshold);
1946
1947
1948 fQAJetHistosRec = new AliFragFuncQAJetHistos("Rec", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1949 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1950 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1951 fQAJetHistosRecCuts = new AliFragFuncQAJetHistos("RecCuts", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1952 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1953 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1954 fQAJetHistosRecCutsLeading = new AliFragFuncQAJetHistos("RecCutsLeading", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1955 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1956 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1957 fQAJetHistosGen = new AliFragFuncQAJetHistos("Gen", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1958 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1959 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1960 fQAJetHistosGenLeading = new AliFragFuncQAJetHistos("GenLeading", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1961 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
fe343c6b 1962 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1963 fQAJetHistosRecEffLeading = new AliFragFuncQAJetHistos("RecEffLeading", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1964 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1965
656dc810 1966
1967 fFFHistosRecCuts = new AliFragFuncHistos("RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1968 fFFNBinsPt, fFFPtMin, fFFPtMax,
1969 fFFNBinsXi, fFFXiMin, fFFXiMax,
1970 fFFNBinsZ , fFFZMin , fFFZMax);
1971 fFFHistosRecLeading = new AliFragFuncHistos("RecLeading", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1972 fFFNBinsPt, fFFPtMin, fFFPtMax,
1973 fFFNBinsXi, fFFXiMin, fFFXiMax,
1974 fFFNBinsZ , fFFZMin , fFFZMax);
1975 fFFHistosRecLeadingTrack = new AliFragFuncHistos("RecLeadingTrack", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1976 fFFNBinsPt, fFFPtMin, fFFPtMax,
1977 fFFNBinsXi, fFFXiMin, fFFXiMax,
1978 fFFNBinsZ , fFFZMin , fFFZMax);
1979 fFFHistosGen = new AliFragFuncHistos("Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1980 fFFNBinsPt, fFFPtMin, fFFPtMax,
1981 fFFNBinsXi, fFFXiMin, fFFXiMax,
1982 fFFNBinsZ , fFFZMin , fFFZMax);
1983 fFFHistosGenLeading = new AliFragFuncHistos("GenLeading", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1984 fFFNBinsPt, fFFPtMin, fFFPtMax,
1985 fFFNBinsXi, fFFXiMin, fFFXiMax,
1986 fFFNBinsZ , fFFZMin , fFFZMax);
1987 fFFHistosGenLeadingTrack = new AliFragFuncHistos("GenLeadingTrack", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1988 fFFNBinsPt, fFFPtMin, fFFPtMax,
1989 fFFNBinsXi, fFFXiMin, fFFXiMax,
1990 fFFNBinsZ , fFFZMin , fFFZMax);
1991
1992
1993 fIJHistosRecCuts = new AliFragFuncIntraJetHistos("RecCuts", fIJNBinsJetPt, fIJJetPtMin, fIJJetPtMax,
1994 fIJNBinsPt, fIJPtMin, fIJPtMax,
1995 fIJNBinsZ, fIJZMin, fIJZMax,
1996 fIJNBinsCosTheta , fIJCosThetaMin , fIJCosThetaMax,
1997 fIJNBinsTheta , fIJThetaMin , fIJThetaMax,
1998 fIJNBinsJt , fIJJtMin , fIJJtMax);
1999 fIJHistosRecLeading = new AliFragFuncIntraJetHistos("RecLeading", fIJNBinsJetPt, fIJJetPtMin, fIJJetPtMax,
2000 fIJNBinsPt, fIJPtMin, fIJPtMax,
2001 fIJNBinsZ, fIJZMin, fIJZMax,
2002 fIJNBinsCosTheta , fIJCosThetaMin , fIJCosThetaMax,
2003 fIJNBinsTheta , fIJThetaMin , fIJThetaMax,
2004 fIJNBinsJt , fIJJtMin , fIJJtMax);
2005 fIJHistosRecLeadingTrack = new AliFragFuncIntraJetHistos("RecLeadingTrack", fIJNBinsJetPt, fIJJetPtMin, fIJJetPtMax,
2006 fIJNBinsPt, fIJPtMin, fIJPtMax,
2007 fIJNBinsZ, fIJZMin, fIJZMax,
2008 fIJNBinsCosTheta , fIJCosThetaMin , fIJCosThetaMax,
2009 fIJNBinsTheta , fIJThetaMin , fIJThetaMax,
2010 fIJNBinsJt , fIJJtMin , fIJJtMax);
2011 fIJHistosGen = new AliFragFuncIntraJetHistos("Gen", fIJNBinsJetPt, fIJJetPtMin, fIJJetPtMax,
2012 fIJNBinsPt, fIJPtMin, fIJPtMax,
2013 fIJNBinsZ, fIJZMin, fIJZMax,
2014 fIJNBinsCosTheta , fIJCosThetaMin , fIJCosThetaMax,
2015 fIJNBinsTheta , fIJThetaMin , fIJThetaMax,
2016 fIJNBinsJt , fIJJtMin , fIJJtMax);
2017 fIJHistosGenLeading = new AliFragFuncIntraJetHistos("GenLeading", fIJNBinsJetPt, fIJJetPtMin, fIJJetPtMax,
2018 fIJNBinsPt, fIJPtMin, fIJPtMax,
2019 fIJNBinsZ, fIJZMin, fIJZMax,
2020 fIJNBinsCosTheta , fIJCosThetaMin , fIJCosThetaMax,
2021 fIJNBinsTheta , fIJThetaMin , fIJThetaMax,
2022 fIJNBinsJt , fIJJtMin , fIJJtMax);
2023 fIJHistosGenLeadingTrack = new AliFragFuncIntraJetHistos("GenLeadingTrack", fIJNBinsJetPt, fIJJetPtMin, fIJJetPtMax,
2024 fIJNBinsPt, fIJPtMin, fIJPtMax,
2025 fIJNBinsZ, fIJZMin, fIJZMax,
2026 fIJNBinsCosTheta , fIJCosThetaMin , fIJCosThetaMax,
2027 fIJNBinsTheta , fIJThetaMin , fIJThetaMax,
2028 fIJNBinsJt , fIJJtMin , fIJJtMax);
2029
2030
2031 fFFDiJetHistosRecCuts = new AliFragFuncDiJetHistos("RecCuts", fDiJetKindBins,
2032 fDiJetNBinsJetInvMass, fDiJetJetInvMassMin, fDiJetJetInvMassMax,
2033 fDiJetNBinsJetPt, fDiJetJetPtMin, fDiJetJetPtMax,
2034 fDiJetNBinsPt, fDiJetPtMin, fDiJetPtMax,
2035 fDiJetNBinsXi, fDiJetXiMin, fDiJetXiMax,
2036 fDiJetNBinsZ, fDiJetZMin, fDiJetZMax);
2037 fFFDiJetHistosRecLeading = new AliFragFuncDiJetHistos("RecLeading", fDiJetKindBins,
2038 fDiJetNBinsJetInvMass, fDiJetJetInvMassMin, fDiJetJetInvMassMax,
2039 fDiJetNBinsJetPt, fDiJetJetPtMin, fDiJetJetPtMax,
2040 fDiJetNBinsPt, fDiJetPtMin, fDiJetPtMax,
2041 fDiJetNBinsXi, fDiJetXiMin, fDiJetXiMax,
2042 fDiJetNBinsZ, fDiJetZMin, fDiJetZMax);
2043 fFFDiJetHistosRecLeadingTrack = new AliFragFuncDiJetHistos("RecLeadingTrack", fDiJetKindBins,
2044 fDiJetNBinsJetInvMass, fDiJetJetInvMassMin, fDiJetJetInvMassMax,
2045 fDiJetNBinsJetPt, fDiJetJetPtMin, fDiJetJetPtMax,
2046 fDiJetNBinsPt, fDiJetPtMin, fDiJetPtMax,
2047 fDiJetNBinsXi, fDiJetXiMin, fDiJetXiMax,
2048 fDiJetNBinsZ, fDiJetZMin, fDiJetZMax);
2049
2050 fFFDiJetHistosGen = new AliFragFuncDiJetHistos("Gen", fDiJetKindBins,
2051 fDiJetNBinsJetInvMass, fDiJetJetInvMassMin, fDiJetJetInvMassMax,
2052 fDiJetNBinsJetPt, fDiJetJetPtMin, fDiJetJetPtMax,
2053 fDiJetNBinsPt, fDiJetPtMin, fDiJetPtMax,
2054 fDiJetNBinsXi, fDiJetXiMin, fDiJetXiMax,
2055 fDiJetNBinsZ, fDiJetZMin, fDiJetZMax);
2056 fFFDiJetHistosGenLeading = new AliFragFuncDiJetHistos("GenLeading", fDiJetKindBins,
2057 fDiJetNBinsJetInvMass, fDiJetJetInvMassMin, fDiJetJetInvMassMax,
2058 fDiJetNBinsJetPt, fDiJetJetPtMin, fDiJetJetPtMax,
2059 fDiJetNBinsPt, fDiJetPtMin, fDiJetPtMax,
2060 fDiJetNBinsXi, fDiJetXiMin, fDiJetXiMax,
2061 fDiJetNBinsZ, fDiJetZMin, fDiJetZMax);
2062 fFFDiJetHistosGenLeadingTrack = new AliFragFuncDiJetHistos("GenLeadingTrack", fDiJetKindBins,
2063 fDiJetNBinsJetInvMass, fDiJetJetInvMassMin, fDiJetJetInvMassMax,
2064 fDiJetNBinsJetPt, fDiJetJetPtMin, fDiJetJetPtMax,
2065 fDiJetNBinsPt, fDiJetPtMin, fDiJetPtMax,
2066 fDiJetNBinsXi, fDiJetXiMin, fDiJetXiMax,
2067 fDiJetNBinsZ, fDiJetZMin, fDiJetZMax);
2068
2069 fQADiJetHistosRecCuts = new AliFragFuncQADiJetHistos("RecCuts", fDiJetKindBins,
2070 fQADiJetNBinsInvMass, fQADiJetInvMassMin, fQADiJetInvMassMax,
2071 fQADiJetNBinsJetPt, fQADiJetJetPtMin, fQADiJetJetPtMax,
2072 fQADiJetNBinsDeltaPhi, fQADiJetDeltaPhiMin, fQADiJetDeltaPhiMax ,
2073 fQADiJetNBinsDeltaEta, fQADiJetDeltaEtaMin, fQADiJetDeltaEtaMax ,
2074 fQADiJetNBinsDeltaPt, fQADiJetDeltaPtMin, fQADiJetDeltaPtMax);
2075 fQADiJetHistosGen = new AliFragFuncQADiJetHistos("Gen", fDiJetKindBins,
2076 fQADiJetNBinsInvMass, fQADiJetInvMassMin, fQADiJetInvMassMax,
2077 fDiJetNBinsJetPt, fDiJetJetPtMin, fDiJetJetPtMax,
2078 fQADiJetNBinsDeltaPhi, fQADiJetDeltaPhiMin, fQADiJetDeltaPhiMax,
2079 fQADiJetNBinsDeltaEta, fQADiJetDeltaEtaMin, fQADiJetDeltaEtaMax,
2080 fQADiJetNBinsDeltaPt, fQADiJetDeltaPtMin, fQADiJetDeltaPtMax);
2081
2082
2083 fQATrackHistosRec->DefineHistos();
2084 fQATrackHistosRecCuts->DefineHistos();
2085 fQATrackHistosGen->DefineHistos();
2086
2087 fQAJetHistosRec->DefineHistos();
2088 fQAJetHistosRecCuts->DefineHistos();
2089 fQAJetHistosRecCutsLeading->DefineHistos();
2090 fQAJetHistosGen->DefineHistos();
2091 fQAJetHistosGenLeading->DefineHistos();
fe343c6b 2092 fQAJetHistosRecEffLeading->DefineHistos();
656dc810 2093
2094 fFFHistosRecCuts->DefineHistos();
2095 fFFHistosRecLeading->DefineHistos();
2096 fFFHistosRecLeadingTrack->DefineHistos();
2097 fFFHistosGen->DefineHistos();
2098 fFFHistosGenLeading->DefineHistos();
2099 fFFHistosGenLeadingTrack->DefineHistos();
2100
2101 fIJHistosRecCuts->DefineHistos();
2102 fIJHistosRecLeading->DefineHistos();
2103 fIJHistosRecLeadingTrack->DefineHistos();
2104 fIJHistosGen->DefineHistos();
2105 fIJHistosGenLeading->DefineHistos();
2106 fIJHistosGenLeadingTrack->DefineHistos();
2107
2108 fFFDiJetHistosRecCuts->DefineDiJetHistos();
2109 fFFDiJetHistosRecLeading->DefineDiJetHistos();
2110 fFFDiJetHistosRecLeadingTrack->DefineDiJetHistos();
2111 fFFDiJetHistosGen->DefineDiJetHistos();
2112 fFFDiJetHistosGenLeading->DefineDiJetHistos();
2113 fFFDiJetHistosGenLeadingTrack->DefineDiJetHistos();
2114 fQADiJetHistosRecCuts->DefineQADiJetHistos();
2115 fQADiJetHistosGen->DefineQADiJetHistos();
2116
fb03edbe 2117 Bool_t genJets = (fJetTypeGen != kJetsUndef) ? kTRUE : kFALSE;
2118 Bool_t genTracks = (fTrackTypeGen != kTrackUndef) ? kTRUE : kFALSE;
2119 Bool_t recJetsEff = (fJetTypeRecEff != kJetsUndef) ? kTRUE : kFALSE;
2120
2121
656dc810 2122 const Int_t saveLevel = 5;
2123 if(saveLevel>0){
2124 fCommonHistList->Add(fh1EvtSelection);
2125 fFFHistosRecCuts->AddToOutput(fCommonHistList);
2126 fFFHistosRecLeading->AddToOutput(fCommonHistList);
2127 fFFHistosRecLeadingTrack->AddToOutput(fCommonHistList);
fb03edbe 2128
2129 if(genJets && genTracks){
2130 fFFHistosGen->AddToOutput(fCommonHistList);
2131 fFFHistosGenLeading->AddToOutput(fCommonHistList);
2132 fFFHistosGenLeadingTrack->AddToOutput(fCommonHistList);
ac017ff3 2133
2134 fCommonHistList->Add(fh1Xsec);
2135 fCommonHistList->Add(fh1Trials);
2136 fCommonHistList->Add(fh1PtHard);
2137 fCommonHistList->Add(fh1PtHardTrials);
fb03edbe 2138 }
656dc810 2139 }
2140 if(saveLevel>1){
2141 fQATrackHistosRec->AddToOutput(fCommonHistList);
2142 fQATrackHistosRecCuts->AddToOutput(fCommonHistList);
fb03edbe 2143 if(genTracks) fQATrackHistosGen->AddToOutput(fCommonHistList);
656dc810 2144
2145 fQAJetHistosRec->AddToOutput(fCommonHistList);
2146 fQAJetHistosRecCuts->AddToOutput(fCommonHistList);
2147 fQAJetHistosRecCutsLeading->AddToOutput(fCommonHistList);
fb03edbe 2148 if(recJetsEff) fQAJetHistosRecEffLeading->AddToOutput(fCommonHistList);
2149
2150 if(genJets){
2151 fQAJetHistosGen->AddToOutput(fCommonHistList);
2152 fQAJetHistosGenLeading->AddToOutput(fCommonHistList);
2153 }
fe343c6b 2154
656dc810 2155 fCommonHistList->Add(fh1EvtMult);
2156 fCommonHistList->Add(fh1nRecJetsCuts);
fb03edbe 2157 if(genJets) fCommonHistList->Add(fh1nGenJets);
656dc810 2158 }
2159 if(saveLevel>2){
2160 fCommonHistList->Add(fh1VertexNContributors);
2161 fCommonHistList->Add(fh1VertexZ);
2162 }
2163 if(saveLevel>3){
2164 fIJHistosRecCuts->AddToOutput(fCommonHistList);
2165 fIJHistosRecLeading->AddToOutput(fCommonHistList);
2166 fIJHistosRecLeadingTrack->AddToOutput(fCommonHistList);
fb03edbe 2167
2168 if(genJets && genTracks){
2169 fIJHistosGen->AddToOutput(fCommonHistList);
2170 fIJHistosGenLeading->AddToOutput(fCommonHistList);
2171 fIJHistosGenLeadingTrack->AddToOutput(fCommonHistList);
2172 }
656dc810 2173 }
2174 if(saveLevel>4){
2175 fFFDiJetHistosRecCuts->AddToOutput(fCommonHistList);
2176 fFFDiJetHistosRecLeading->AddToOutput(fCommonHistList);
2177 fFFDiJetHistosRecLeadingTrack->AddToOutput(fCommonHistList);
656dc810 2178 fQADiJetHistosRecCuts->AddToOutput(fCommonHistList);
fb03edbe 2179
2180 if(genJets && genTracks){
2181 fFFDiJetHistosGen->AddToOutput(fCommonHistList);
2182 fFFDiJetHistosGenLeading->AddToOutput(fCommonHistList);
2183 fFFDiJetHistosGenLeadingTrack->AddToOutput(fCommonHistList);
2184 fQADiJetHistosGen->AddToOutput(fCommonHistList);
2185 }
2186
2187 if(recJetsEff && genTracks){
2188 fCommonHistList->Add(fhnSingleTrackRecEffHisto);
2189 fCommonHistList->Add(fhnJetTrackRecEffHisto);
2190 fCommonHistList->Add(fh1nRecEffJets);
2191 }
656dc810 2192 }
2193
2194 // =========== Switch on Sumw2 for all histos ===========
2195 for (Int_t i=0; i<fCommonHistList->GetEntries(); ++i){
2196 TH1 *h1 = dynamic_cast<TH1*>(fCommonHistList->At(i));
2197 if (h1) h1->Sumw2();
2198 else{
2199 THnSparse *hnSparse = dynamic_cast<THnSparse*>(fCommonHistList->At(i));
2200 if(hnSparse) hnSparse->Sumw2();
2201 }
2202 }
2203
2204 TH1::AddDirectory(oldStatus);
2205}
2206
2207//_______________________________________________
2208void AliAnalysisTaskFragmentationFunction::Init()
2209{
2210 // Initialization
2211 if(fDebug > 1) Printf("AliAnalysisTaskFragmentationFunction::Init()");
2212
2213}
2214
2215//_____________________________________________________________
2216void AliAnalysisTaskFragmentationFunction::UserExec(Option_t *)
2217{
2218 // Main loop
2219 // Called for each event
2220 if(fDebug > 1) Printf("AliAnalysisTaskFragmentationFunction::UserExec()");
2221
2222
2223 if(fDebug > 1) Printf("Analysis event #%5d", (Int_t) fEntry);
2224 // Trigger selection
2225
2226 AliInputEventHandler* inputHandler = (AliInputEventHandler*)
2227 ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
fe343c6b 2228 if(inputHandler->IsEventSelected() & AliVEvent::kMB){
656dc810 2229 if(fDebug > 1) Printf(" Trigger Selection: event ACCEPTED ... ");
2230 fh1EvtSelection->Fill(1.);
2231 } else {
2232 fh1EvtSelection->Fill(0.);
ac017ff3 2233 if(inputHandler->InheritsFrom("AliESDInputHandler") && fUsePhysicsSelection){ // PhysicsSelection only with ESD input
656dc810 2234 if (fDebug > 1 ) Printf(" Trigger Selection: event REJECTED ... ");
2235 PostData(1, fCommonHistList);
2236 return;
2237 }
2238 }
2239
2240 fESD = dynamic_cast<AliESDEvent*>(InputEvent());
2241 if(!fESD){
2242 if(fDebug>3) Printf("%s:%d ESDEvent not found in the input", (char*)__FILE__,__LINE__);
2243 }
2244
2245 fMCEvent = MCEvent();
2246 if(!fMCEvent){
2247 if(fDebug>3) Printf("%s:%d MCEvent not found in the input", (char*)__FILE__,__LINE__);
2248 }
2249
2250 // get AOD event from input/ouput
2251 TObject* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
2252 if( handler && handler->InheritsFrom("AliAODInputHandler") ) {
2253 fAOD = ((AliAODInputHandler*)handler)->GetEvent();
2254 if (fDebug > 1) Printf("%s:%d AOD event from input", (char*)__FILE__,__LINE__);
2255 }
2256 else {
2257 handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
2258 if( handler && handler->InheritsFrom("AliAODHandler") ) {
2259 fAOD = ((AliAODHandler*)handler)->GetAOD();
2260 if (fDebug > 1) Printf("%s:%d AOD event from output", (char*)__FILE__,__LINE__);
2261 }
2262 }
2263
2264 if(!fAOD){
2265 Printf("%s:%d AODEvent not found", (char*)__FILE__,__LINE__);
2266 return;
2267 }
2268
2269
2270 // event selection (vertex) *****************************************
2271
2272 AliAODVertex* primVtx = fAOD->GetPrimaryVertex();
2273 Int_t nTracksPrim = primVtx->GetNContributors();
2274 fh1VertexNContributors->Fill(nTracksPrim);
2275
2276 if (fDebug > 1) Printf("%s:%d primary vertex selection: %d", (char*)__FILE__,__LINE__,nTracksPrim);
2277 if(!nTracksPrim){
2278 if (fDebug > 1) Printf("%s:%d primary vertex selection: event REJECTED...",(char*)__FILE__,__LINE__);
2279 fh1EvtSelection->Fill(2.);
2280 PostData(1, fCommonHistList);
2281 return;
2282 }
2283
2284 fh1VertexZ->Fill(primVtx->GetZ());
2285
2286 if(TMath::Abs(primVtx->GetZ())>10){
2287 if (fDebug > 1) Printf("%s:%d primary vertex z = %f: event REJECTED...",(char*)__FILE__,__LINE__,primVtx->GetZ());
2288 fh1EvtSelection->Fill(3.);
2289 PostData(1, fCommonHistList);
2290 return;
2291 }
2292
2293 TString primVtxName(primVtx->GetName());
2294
2295 if(primVtxName.CompareTo("TPCVertex",TString::kIgnoreCase) == 1){
2296 if (fDebug > 1) Printf("%s:%d primary vertex selection: TPC vertex, event REJECTED...",(char*)__FILE__,__LINE__);
2297 fh1EvtSelection->Fill(4.);
2298 PostData(1, fCommonHistList);
2299 return;
2300 }
2301 if (fDebug > 1) Printf("%s:%d primary vertex selection: event ACCEPTED ...",(char*)__FILE__,__LINE__);
2302 fh1EvtSelection->Fill(5.);
ac017ff3 2303
2304
2305 //___ get MC information __________________________________________________________________
2306
2307 Double_t ptHard = 0.;
2308 Double_t nTrials = 1; // trials for MC trigger weight for real data
2309
2310 AliGenPythiaEventHeader* pythiaGenHeader = AliAnalysisHelperJetTasks::GetPythiaEventHeader(fMCEvent);
2311 if(!pythiaGenHeader){
2312 if(fJetTypeGen != kJetsUndef && fTrackTypeGen != kTrackUndef){
2313 Printf("%s:%d no pythiaGenHeader found", (char*)__FILE__,__LINE__);
2314 return;
2315 }
2316 } else {
2317 nTrials = pythiaGenHeader->Trials();
2318 ptHard = pythiaGenHeader->GetPtHard();
2319
2320 fh1PtHard->Fill(ptHard);
2321 fh1PtHardTrials->Fill(ptHard,nTrials);
2322 }
656dc810 2323
2324
2325 //___ fetch jets __________________________________________________________________________
2326
2327 Int_t nJ = GetListOfJets(fJetsRec, kJetsRec);
2328 Int_t nRecJets = 0;
2329 if(nJ>=0) nRecJets = fJetsRec->GetEntries();
2330 if(fDebug>2)Printf("%s:%d Selected Rec jets: %d %d",(char*)__FILE__,__LINE__,nJ,nRecJets);
2331 if(nJ != nRecJets) Printf("%s:%d Mismatch Selected Rec Jets: %d %d",(char*)__FILE__,__LINE__,nJ,nRecJets);
2332
2333 Int_t nJCuts = GetListOfJets(fJetsRecCuts, kJetsRecAcceptance);
2334 Int_t nRecJetsCuts = 0;
2335 if(nJCuts>=0) nRecJetsCuts = fJetsRecCuts->GetEntries();
2336 if(fDebug>2)Printf("%s:%d Selected Rec jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2337 if(nRecJetsCuts != nJCuts) Printf("%s:%d Mismatch selected Rec jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2338 fh1nRecJetsCuts->Fill(nRecJetsCuts);
2339
2340
2341 if(fJetTypeGen==kJetsKine || fJetTypeGen == kJetsKineAcceptance) fJetsGen->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2342 Int_t nJGen = GetListOfJets(fJetsGen, fJetTypeGen);
2343 Int_t nGenJets = 0;
2344 if(nJGen>=0) nGenJets = fJetsGen->GetEntries();
2345 if(fDebug>2)Printf("%s:%d Selected Gen jets: %d %d",(char*)__FILE__,__LINE__,nJGen,nGenJets);
2346 if(nJGen != nGenJets) Printf("%s:%d Mismatch selected Gen jets: %d %d",(char*)__FILE__,__LINE__,nJGen,nGenJets);
2347 fh1nGenJets->Fill(nGenJets);
2348
2349
fe343c6b 2350 if(fJetTypeRecEff==kJetsKine || fJetTypeRecEff == kJetsKineAcceptance) fJetsRecEff->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2351 Int_t nJRecEff = GetListOfJets(fJetsRecEff, fJetTypeRecEff);
2352 Int_t nRecEffJets = 0;
2353 if(nJRecEff>=0) nRecEffJets = fJetsRecEff->GetEntries();
2354 if(fDebug>2)Printf("%s:%d Selected RecEff jets: %d %d",(char*)__FILE__,__LINE__,nJRecEff,nRecEffJets);
2355 if(nJRecEff != nRecEffJets) Printf("%s:%d Mismatch selected RecEff jets: %d %d",(char*)__FILE__,__LINE__,nJRecEff,nRecEffJets);
2356 fh1nRecEffJets->Fill(nRecEffJets);
2357
2358
656dc810 2359 //____ fetch particles __________________________________________________________
2360
2361 Int_t nT = GetListOfTracks(fTracksRec, kTrackAOD);
2362 Int_t nRecPart = 0;
2363 if(nT>=0) nRecPart = fTracksRec->GetEntries();
2364 if(fDebug>2)Printf("%s:%d Selected Rec tracks: %d %d",(char*)__FILE__,__LINE__,nT,nRecPart);
2365 if(nRecPart != nT) Printf("%s:%d Mismatch selected Rec tracks: %d %d",(char*)__FILE__,__LINE__,nT,nRecPart);
2366
2367
2368 Int_t nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODCuts);
2369 Int_t nRecPartCuts = 0;
2370 if(nTCuts>=0) nRecPartCuts = fTracksRecCuts->GetEntries();
2371 if(fDebug>2)Printf("%s:%d Selected Rec tracks after cuts: %d %d",(char*)__FILE__,__LINE__,nTCuts,nRecPartCuts);
2372 if(nRecPartCuts != nTCuts) Printf("%s:%d Mismatch selected Rec tracks after cuts: %d %d",(char*)__FILE__,__LINE__,nTCuts,nRecPartCuts);
2373 fh1EvtMult->Fill(nRecPartCuts);
2374
2375
2376 Int_t nTGen = GetListOfTracks(fTracksGen,fTrackTypeGen);
2377 Int_t nGenPart = 0;
2378 if(nTGen>=0) nGenPart = fTracksGen->GetEntries();
2379 if(fDebug>2)Printf("%s:%d Selected Gen tracks: %d %d",(char*)__FILE__,__LINE__,nTGen,nGenPart);
2380 if(nGenPart != nTGen) Printf("%s:%d Mismatch selected Gen tracks: %d %d",(char*)__FILE__,__LINE__,nTGen,nGenPart);
2381
2382
2383 //____ analysis, fill histos ___________________________________________________
2384
2385 // loop over tracks
2386
2387 for(Int_t it=0; it<nRecPart; ++it){
2388 AliVParticle *part = dynamic_cast<AliVParticle*>(fTracksRec->At(it));
2389 fQATrackHistosRec->FillTrackQA( part->Eta(), TVector2::Phi_0_2pi(part->Phi()), part->Pt());
2390 }
2391 for(Int_t it=0; it<nRecPartCuts; ++it){
2392 AliVParticle *part = dynamic_cast<AliVParticle*>(fTracksRecCuts->At(it));
2393 fQATrackHistosRecCuts->FillTrackQA( part->Eta(), TVector2::Phi_0_2pi(part->Phi()), part->Pt());
2394 }
2395 for(Int_t it=0; it<nGenPart; ++it){
2396 AliVParticle *part = dynamic_cast<AliVParticle*>(fTracksGen->At(it));
2397 fQATrackHistosGen->FillTrackQA( part->Eta(), TVector2::Phi_0_2pi(part->Phi()), part->Pt());
2398 }
2399
2400 // loop over jets
2401
2402 for(Int_t ij=0; ij<nRecJets; ++ij){
2403
2404 AliAODJet* jet = dynamic_cast<AliAODJet*>(fJetsRec->At(ij));
2405 fQAJetHistosRec->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2406 }
2407
2408
2409 for(Int_t ij=0; ij<nRecJetsCuts; ++ij){
2410
2411 AliAODJet* jet = dynamic_cast<AliAODJet*>(fJetsRecCuts->At(ij));
2412 fQAJetHistosRecCuts->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2413
2414 if(ij==0){ // leading jet
2415
2416 fQAJetHistosRecCutsLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
2417
2418 TList* jettracklist = new TList();
2419 Double_t sumPt = 0.;
2420 Float_t leadTrackPx = 0.;
2421 Float_t leadTrackPy = 0.;
2422 Float_t leadTrackPz = 0.;
2423 Float_t leadTrackP = 0.;
2424 Float_t leadTrackPt = 0.;
2425 TLorentzVector* leadTrackV = new TLorentzVector();
2426
2427 if(GetFFRadius()<=0){
2428 GetJetTracksTrackrefs(jettracklist, jet);
2429 } else {
2430 GetJetTracksPointing(fTracksRecCuts, jettracklist, jet, GetFFRadius(), sumPt);
2431 }
2432
2433 for(Int_t it=0; it<jettracklist->GetSize(); ++it){
2434 Float_t trackPx = (dynamic_cast<AliVParticle*> (jettracklist->At(it)))->Px();
2435 Float_t trackPy = (dynamic_cast<AliVParticle*> (jettracklist->At(it)))->Py();
2436 Float_t trackPz = (dynamic_cast<AliVParticle*> (jettracklist->At(it)))->Pz();
2437 Float_t trackP = (dynamic_cast<AliVParticle*> (jettracklist->At(it)))->P();
2438 Float_t trackPt = (dynamic_cast<AliVParticle*> (jettracklist->At(it)))->Pt();
2439 Float_t jetPx = jet->Px();
2440 Float_t jetPy = jet->Py();
2441 Float_t jetPz = jet->Pz();
2442 Float_t jetP = jet->P();
2443 Float_t jetPt = jet->Pt();
2444 TLorentzVector* trackV = new TLorentzVector();
2445 TLorentzVector *jetV = new TLorentzVector();
2446 trackV->SetPxPyPzE(trackPx,trackPy,trackPz,trackP);
2447 jetV->SetPxPyPzE(jetPx,jetPy,jetPz,jetP);
2448
2449 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2450
2451 fFFHistosRecCuts->FillFF( trackPt, jetPt, incrementJetPt);
2452 fIJHistosRecCuts->FillIntraJet( trackV, jetV );
2453
2454 if(it==0){
2455 leadTrackPx = trackPx;
2456 leadTrackPy = trackPy;
2457 leadTrackPz = trackPz;
2458 leadTrackP = trackP;
2459 leadTrackPt = trackPt;
2460 fFFHistosRecLeadingTrack->FillFF( leadTrackPt, jetPt, kTRUE);
2461
2462 leadTrackV->SetPxPyPzE(leadTrackPx,leadTrackPy,leadTrackPz,leadTrackP);
2463 fIJHistosRecLeadingTrack->FillIntraJet( leadTrackV, jetV );
2464 }
2465 fFFHistosRecLeading->FillFF( trackPt, leadTrackPt , incrementJetPt);
2466 fIJHistosRecLeading->FillIntraJet( trackV, leadTrackV );
2467
2468 delete trackV;
2469 delete jetV;
2470 }
2471
2472 delete leadTrackV;
2473 delete jettracklist;
2474 }
2475 }
2476
2477
2478 for(Int_t ij=0; ij<nGenJets; ++ij){
2479
2480 AliAODJet* jet = dynamic_cast<AliAODJet*>(fJetsGen->At(ij));
2481 fQAJetHistosGen->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2482
2483 if(ij==0){ // leading jet
2484
2485 fQAJetHistosGenLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2486
2487 TList* jettracklist = new TList();
2488 Double_t sumPt = 0.;
2489 Float_t leadTrackPx = 0.;
2490 Float_t leadTrackPy = 0.;
2491 Float_t leadTrackPz = 0.;
2492 Float_t leadTrackP = 0.;
2493 Float_t leadTrackPt = 0.;
2494 TLorentzVector* leadTrackV = new TLorentzVector();
2495
2496 if(GetFFRadius()<=0){
2497 GetJetTracksTrackrefs(jettracklist, jet);
2498 } else {
2499 GetJetTracksPointing(fTracksGen, jettracklist, jet, GetFFRadius(), sumPt);
2500 }
2501
2502 for(Int_t it=0; it<jettracklist->GetSize(); ++it){
2503 Float_t trackPx = (dynamic_cast<AliVParticle*>(jettracklist->At(it)))->Px();
2504 Float_t trackPy = (dynamic_cast<AliVParticle*>(jettracklist->At(it)))->Py();
2505 Float_t trackPz = (dynamic_cast<AliVParticle*>(jettracklist->At(it)))->Pz();
2506 Float_t trackP = (dynamic_cast<AliVParticle*>(jettracklist->At(it)))->P();
2507 Float_t trackPt = (dynamic_cast<AliVParticle*>(jettracklist->At(it)))->Pt();
2508 Float_t jetPx = jet->Px();
2509 Float_t jetPy = jet->Py();
2510 Float_t jetPz = jet->Pz();
2511 Float_t jetP = jet->P();
2512 Float_t jetPt = jet->Pt();
2513 TLorentzVector* trackV = new TLorentzVector();
2514 TLorentzVector *jetV = new TLorentzVector();
2515 trackV->SetPxPyPzE(trackPx,trackPy,trackPz,trackP);
2516 jetV->SetPxPyPzE(jetPx,jetPy,jetPz,jetP);
2517
2518 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2519
2520 fFFHistosGen->FillFF( trackPt, jetPt, incrementJetPt);
2521 fIJHistosGen->FillIntraJet( trackV, jetV );
2522
2523 if(it==0){
2524 leadTrackPx = trackPx;
2525 leadTrackPy = trackPy;
2526 leadTrackPz = trackPz;
2527 leadTrackP = trackP;
2528 leadTrackPt = trackPt;
2529 fFFHistosGenLeadingTrack->FillFF( leadTrackPt, jetPt, kTRUE);
2530
2531 leadTrackV->SetPxPyPzE(leadTrackPx,leadTrackPy,leadTrackPz,leadTrackP);
2532 fIJHistosGenLeadingTrack->FillIntraJet( leadTrackV, jetV );
2533 }
2534 fFFHistosGenLeading->FillFF( trackPt, leadTrackPt, incrementJetPt);
2535 fIJHistosGenLeading->FillIntraJet( trackV, leadTrackV );
2536
2537 delete trackV;
2538 delete jetV;
2539 }
2540
2541 delete leadTrackV;
2542 delete jettracklist;
2543 }
2544 }
2545
2546 //_______ DiJet part _____________________________________________________
2547
fe343c6b 2548 if (nRecJetsCuts > 1) // OB: debugged this
656dc810 2549 {
2550
2551 AliAODJet* jet1 = dynamic_cast<AliAODJet*>(fJetsRecCuts->At(0));
2552 AliAODJet* jet2 = dynamic_cast<AliAODJet*>(fJetsRecCuts->At(1));
2553
2554 // DiJet deltaphi calculation
2555 Double_t phi1 = TVector2::Phi_0_2pi(jet1->Phi());
2556 Double_t phi2 = TVector2::Phi_0_2pi(jet2->Phi());
2557 Double_t deltaPhi = TMath::Abs(phi1-phi2);
2558 if (deltaPhi > TMath::Pi() && deltaPhi < 2*TMath::Pi()) deltaPhi = 2*TMath::Pi() - deltaPhi;
2559
2560 // DiJet CDF cut calculation
2561 Double_t Et1 = TMath::Abs(jet1->E()*TMath::Sin(jet1->Theta()));
2562 Double_t Et2 = TMath::Abs(jet2->E()*TMath::Sin(jet2->Theta()));
2563 Double_t sumEt = Et1 + Et2;
2564 Double_t normEt1PlusEt2 = TMath::Sqrt(Et1*Et1+Et2*Et2+2*Et1*Et2*TMath::Cos(deltaPhi));
2565 Double_t ratio = (Double_t)(normEt1PlusEt2/sumEt);
2566
2567 // DiJet events selection
2568 Bool_t positionCut = 0;
2569 Bool_t positionEnergyCut = 0;
2570 Bool_t cdfCut = 0;
2571
2572 // Position cut :
2573 if (deltaPhi > fDiJetDeltaPhiCut) positionCut = 1;
2574 // Position-Energy cut :
2575 if ((deltaPhi > fDiJetDeltaPhiCut) && ((jet2->Pt()) >= fDiJetPtFractionCut*(jet1->Pt()))) positionEnergyCut = 1;
2576 // CDF cut :
2577 if (ratio < fDiJetCDFCut) cdfCut = 1;
2578
2579 Int_t go = 0;
2580
2581 if (fDiJetCut == 1 && positionCut == 1) go = 1;
2582 if (fDiJetCut == 2 && positionEnergyCut == 1) go = 1;
2583 if (fDiJetCut == 3 && cdfCut == 1) go = 1;
2584
2585 if (go)
2586 {
2587 Double_t deltaEta = TMath::Abs(jet1->Eta()-jet2->Eta());
2588 Double_t deltaPt = TMath::Abs(jet1->Pt()-jet2->Pt());
2589 Double_t meanEt = (Double_t)((Et1+Et2)/2.);
2590 Double_t invariantMass = (Double_t)InvMass(jet1,jet2);
2591
2592 Double_t jetBin = GetDiJetBin(invariantMass, jet1->Pt(), meanEt, fDiJetKindBins);
2593
2594 if (jetBin > 0)
2595 {
2596 fQADiJetHistosRecCuts->FillDiJetQA(invariantMass, deltaPhi, deltaEta, deltaPt, jetBin);
2597
2598 TList* jettracklist1 = new TList();
2599 Double_t sumPt1 = 0.;
2600 Float_t leadTrackPt1 = 0;
2601
2602 TList* jettracklist2 = new TList();
2603 Double_t sumPt2 = 0.;
2604 Float_t leadTrackPt2 = 0;
2605
2606 if(GetFFRadius()<=0)
2607 {
2608 GetJetTracksTrackrefs(jettracklist1, jet1);
2609 GetJetTracksTrackrefs(jettracklist2, jet2);
2610 }
2611 else
2612 {
2613 GetJetTracksPointing(fTracksRecCuts, jettracklist1, jet1, GetFFRadius(), sumPt1);
2614 GetJetTracksPointing(fTracksRecCuts, jettracklist2, jet2, GetFFRadius(), sumPt2);
2615 }
2616
2617 Int_t nTracks = jettracklist1->GetSize();
2618 if (jettracklist1->GetSize() < jettracklist2->GetSize()) nTracks = jettracklist2->GetSize();
2619
2620 for(Int_t it=0; it<nTracks; ++it)
2621 {
2622 if (it < jettracklist1->GetSize())
2623 {
2624 Float_t trackPt1 = (dynamic_cast<AliVParticle*> (jettracklist1->At(it)))->Pt();
2625 Float_t jetPt1 = jet1->Pt();
2626
2627 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2628
2629 fFFDiJetHistosRecCuts->FillDiJetFF(1, trackPt1, jetPt1, jetBin, incrementJetPt);
2630 fFFDiJetHistosRecCuts->FillDiJetFF(0, trackPt1, jetPt1, jetBin, incrementJetPt);
2631
2632 if (it == 0)
2633 {
2634 leadTrackPt1 = trackPt1;
2635
2636 fFFDiJetHistosRecLeadingTrack->FillDiJetFF(1, leadTrackPt1, jetPt1, jetBin, kTRUE);
2637 fFFDiJetHistosRecLeadingTrack->FillDiJetFF(0, leadTrackPt1, jetPt1, jetBin, kTRUE);
2638 }
2639
2640 fFFDiJetHistosRecLeading->FillDiJetFF(1, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
2641 fFFDiJetHistosRecLeading->FillDiJetFF(0, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
2642 }
2643
2644 if (it < jettracklist2->GetSize())
2645 {
2646 Float_t trackPt2 = (dynamic_cast<AliVParticle*>(jettracklist2->At(it)))->Pt();
2647 Float_t jetPt2 = jet2->Pt();
2648
2649 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2650
2651 fFFDiJetHistosRecCuts->FillDiJetFF(2, trackPt2, jetPt2, jetBin, incrementJetPt);
2652 fFFDiJetHistosRecCuts->FillDiJetFF(0, trackPt2, jetPt2, jetBin, incrementJetPt);
2653
2654 if (it == 0)
2655 {
2656 leadTrackPt2 = trackPt2;
2657
2658 fFFDiJetHistosRecLeadingTrack->FillDiJetFF(2, leadTrackPt2, jetPt2, jetBin, kTRUE);
2659 fFFDiJetHistosRecLeadingTrack->FillDiJetFF(0, leadTrackPt2, jetPt2, jetBin, kTRUE);
2660 }
2661
2662 fFFDiJetHistosRecLeading->FillDiJetFF(2, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
2663 fFFDiJetHistosRecLeading->FillDiJetFF(0, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
2664 }
2665 } // End loop on tracks
2666
2667 delete jettracklist1;
2668 delete jettracklist2;
2669
2670 } // End if(jetBin > 0)
2671 else { Printf("Jet bins for di-jet studies not set !");}
2672 } // End if(go)
2673 } // End if(nRecJets > 1)
2674
2675 if (nGenJets > 1)
2676 {
2677 AliAODJet* jet1 = dynamic_cast<AliAODJet*>(fJetsGen->At(0));
2678 AliAODJet* jet2 = dynamic_cast<AliAODJet*>(fJetsGen->At(1));
2679
2680 Double_t deltaPhi = 0;
2681 Double_t phi1 = TVector2::Phi_0_2pi(jet1->Phi());
2682 Double_t phi2 = TVector2::Phi_0_2pi(jet2->Phi());
2683 deltaPhi = TMath::Abs(phi1-phi2);
2684 if (deltaPhi > TMath::Pi() && deltaPhi < 2*TMath::Pi()) deltaPhi = 2*TMath::Pi() - deltaPhi;
2685
2686 Double_t Et1 = TMath::Abs(jet1->E()*TMath::Sin(jet1->Theta()));
2687 Double_t Et2 = TMath::Abs(jet2->E()*TMath::Sin(jet2->Theta()));
2688 Double_t sumEt = Et1 + Et2;
2689 Double_t normEt1PlusEt2 = TMath::Sqrt(Et1*Et1+Et2*Et2+2*Et1*Et2*TMath::Cos(deltaPhi));
2690 Double_t ratio = (Double_t)(normEt1PlusEt2/sumEt);
2691
2692 // DiJet events selection
2693 Bool_t positionCut = 0;
2694 Bool_t positionEnergyCut = 0;
2695 Bool_t cdfCut = 0;
2696
2697 // Position cut :
2698 if (deltaPhi > fDiJetDeltaPhiCut) positionCut = 1;
2699 // Position-Energy cut :
2700 if ((deltaPhi > fDiJetDeltaPhiCut) && ((jet2->Pt()) >= fDiJetPtFractionCut*(jet1->Pt()))) positionEnergyCut = 1;
2701 // CDF cut :
2702 if (ratio < fDiJetCDFCut) cdfCut = 1;
2703
2704 Int_t go = 0;
2705
2706 if (fDiJetCut == 1 && positionCut == 1) go = 1;
2707 if (fDiJetCut == 2 && positionEnergyCut == 1) go = 1;
2708 if (fDiJetCut == 3 && cdfCut == 1) go = 1;
2709
2710 if (go)
2711 {
2712 Double_t deltaEta = TMath::Abs(jet1->Eta()-jet2->Eta());
2713 Double_t deltaPt = TMath::Abs(jet1->Pt()-jet2->Pt());
2714 Double_t meanEt = (Double_t)((Et1+Et2)/2.);
2715 Double_t invariantMass = (Double_t)InvMass(jet1,jet2);
2716
2717 Double_t jetBin = GetDiJetBin(invariantMass, jet1->Pt(), meanEt, fDiJetKindBins);
2718
2719 if(jetBin > 0)
2720 {
2721 fQADiJetHistosGen->FillDiJetQA(invariantMass, deltaPhi, deltaEta, deltaPt, jetBin);
2722
2723 TList* jettracklist1 = new TList();
2724 Double_t sumPt1 = 0.;
2725 Float_t leadTrackPt1 = 0.;
2726
2727 TList* jettracklist2 = new TList();
2728 Double_t sumPt2 = 0.;
2729 Float_t leadTrackPt2 = 0.;
2730
2731 if(GetFFRadius()<=0)
2732 {
2733 GetJetTracksTrackrefs(jettracklist1, jet1);
2734 GetJetTracksTrackrefs(jettracklist2, jet2);
2735 }
2736 else
2737 {
2738 GetJetTracksPointing(fTracksGen, jettracklist1, jet1, GetFFRadius(), sumPt1);
2739 GetJetTracksPointing(fTracksGen, jettracklist2, jet2, GetFFRadius(), sumPt2);
2740 }
2741
2742 Int_t nTracks = jettracklist1->GetSize();
2743 if (jettracklist1->GetSize() < jettracklist2->GetSize()) nTracks = jettracklist2->GetSize();
2744
2745 for(Int_t it=0; it<nTracks; ++it)
2746 {
2747 if (it < jettracklist1->GetSize())
2748 {
2749 Float_t trackPt1 = (dynamic_cast<AliAODTrack*>(jettracklist1->At(it)))->Pt();
2750 Float_t jetPt1 = jet1->Pt();
2751
2752 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2753
2754 fFFDiJetHistosGen->FillDiJetFF( 1, trackPt1, jetPt1, jetBin, incrementJetPt);
2755 fFFDiJetHistosGen->FillDiJetFF( 0, trackPt1, jetPt1, jetBin, incrementJetPt);
2756
2757 if(it==0)
2758 {
2759 leadTrackPt1 = trackPt1;
2760
2761 fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 1, leadTrackPt1, jetPt1, jetBin, kTRUE);
2762 fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 0, leadTrackPt1, jetPt1, jetBin, kTRUE);
2763 }
2764
2765 fFFDiJetHistosGenLeading->FillDiJetFF( 1, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
2766 fFFDiJetHistosGenLeading->FillDiJetFF( 0, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
2767 }
2768
2769 if (it < jettracklist2->GetSize())
2770 {
2771 Float_t trackPt2 = (dynamic_cast<AliAODTrack*>(jettracklist2->At(it)))->Pt();
2772 Float_t jetPt2 = jet2->Pt();
2773
2774 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2775
2776 fFFDiJetHistosGen->FillDiJetFF( 2, trackPt2, jetPt2, jetBin, incrementJetPt);
2777 fFFDiJetHistosGen->FillDiJetFF( 0, trackPt2, jetPt2, jetBin, incrementJetPt);
2778
2779 if (it==0)
2780 {
2781 leadTrackPt2 = trackPt2;
2782
2783 fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 2, leadTrackPt2, jetPt2, jetBin, kTRUE);
2784 fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 0, leadTrackPt2, jetPt2, jetBin, kTRUE);
2785 }
2786
2787 fFFDiJetHistosGenLeading->FillDiJetFF( 2, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
2788 fFFDiJetHistosGenLeading->FillDiJetFF( 0, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
2789 }
2790 } // End loop on tracks
2791
2792 delete jettracklist1;
2793 delete jettracklist2;
2794
2795 } // End if(jetBin > 0)
2796 else { Printf("Jet bins for di-jet studies not set !");}
2797 } // End if (go)
2798 } // End if(nGenJets > 1)
2799
2800
fe343c6b 2801 // ____ efficiency _______________________________
2802
2803 // arrays for generated particles: reconstructed AOD track index, isPrimary flag
2804 TArrayI indexAODTr;
2805 TArrayS isGenPrim;
2806
2807 // array for reconcstructed AOD tracks: generated particle index
2808 TArrayI indexMCTr;
2809
2810 Int_t nTracksAODMCCharged = GetListOfTracks(fTracksAODMCCharged, kTrackAODMCCharged);
2811 if(fDebug>2)Printf("%s:%d selected AODMC tracks: %d ",(char*)__FILE__,__LINE__,nTracksAODMCCharged);
2812
2813 Int_t nTracksRecQualityCuts = GetListOfTracks(fTracksRecQualityCuts, kTrackAODQualityCuts);
2814 if(fDebug>2)Printf("%s:%d selected rec tracks quality after cuts, full acceptance/pt : %d ",(char*)__FILE__,__LINE__,nTracksRecQualityCuts);
2815
2816 // associate gen and rec tracks, store indices in TArrays
2817 AssociateGenRec(fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,indexMCTr,isGenPrim);
2818
2819 // single track eff
2820 FillSingleTrackRecEffHisto(fhnSingleTrackRecEffHisto,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim);
2821
2822 // jet track eff
2823 for(Int_t ij=0; ij<nRecEffJets; ++ij){
2824
2825 AliAODJet* jet = dynamic_cast<AliAODJet*>(fJetsRecEff->At(ij));
2826
2827 if(ij==0){ // leading jet
2828
2829 TList* jettracklist = new TList();
2830 Double_t sumPt = 0.;
2831
2832 GetJetTracksPointing(fTracksGen, jettracklist, jet, GetFFRadius(), sumPt); // for efficiency: gen tracks from pointing with gen/rec jet
2833
2834 Double_t jetEta = jet->Eta();
2835 Double_t jetPhi = TVector2::Phi_0_2pi(jet->Phi());
2836 Double_t jetPt = sumPt;
2837
2838 fQAJetHistosRecEffLeading->FillJetQA( jetEta, jetPhi, jetPt );
2839 FillJetTrackRecEffHisto(fhnJetTrackRecEffHisto,jetPhi,jetEta,jetPt,jettracklist,fTracksAODMCCharged,indexAODTr,isGenPrim);
2840
2841 delete jettracklist;
2842 }
2843 }
2844
2845 //___________________
2846
656dc810 2847 fTracksRec->Clear();
2848 fTracksRecCuts->Clear();
2849 fTracksGen->Clear();
fe343c6b 2850 fTracksAODMCCharged->Clear();
2851 fTracksRecQualityCuts->Clear();
2852
656dc810 2853 fJetsRec->Clear();
2854 fJetsRecCuts->Clear();
2855 fJetsGen->Clear();
fe343c6b 2856 fJetsRecEff->Clear();
656dc810 2857
2858 //Post output data.
2859 PostData(1, fCommonHistList);
2860
2861}
2862
2863//________________________________________________________________________________________
2864Double_t AliAnalysisTaskFragmentationFunction::InvMass(AliAODJet* jet1, AliAODJet* jet2)
2865{
2866
2867 Double_t invMass = 0.;
2868 invMass = TMath::Sqrt(pow(jet1->E()+jet2->E(),2) - pow(jet1->Px()+jet2->Px(),2) -
2869 pow(jet1->Py()+jet2->Py(),2) - pow(jet1->Pz()+jet2->Pz(),2));
2870
2871 return invMass;
2872
2873}
2874
2875//________________________________________________________________________________________
2876Double_t AliAnalysisTaskFragmentationFunction::GetDiJetBin(Double_t invMass, Double_t leadingJetPt, Double_t EtMean, Int_t kindBins)
2877{
2878 Double_t jetBinOk = 0.;
2879 Double_t jetBin = 0.;
2880
2881 Float_t stepInvMass = (fDiJetJetInvMassMax - fDiJetJetInvMassMin)/fDiJetNBinsJetInvMass;
2882 Float_t stepPt = (fDiJetJetPtMax - fDiJetJetPtMin)/fDiJetNBinsJetPt;
2883
2884 if (kindBins == 1)
2885 {
2886 for(Int_t i=0; i<fDiJetNBinsJetInvMass; ++i)
2887 {
2888 jetBin = fDiJetJetInvMassMin + i*stepInvMass/2.;
2889 if(((fDiJetJetInvMassMin+i*stepInvMass) <= invMass) &&
2890 (fDiJetJetInvMassMin + (i+1)*stepInvMass) > invMass) jetBinOk = jetBin;
2891 }
2892 jetBinOk = -1.;
2893 }
2894 else if (kindBins == 3)
2895 {
2896 for(Int_t i=0; i<fDiJetNBinsJetPt; ++i)
2897 {
2898 jetBin = fDiJetJetPtMin + i*stepPt/2.;
2899 if(((fDiJetJetPtMin+i*stepPt) <= EtMean) &&
2900 (fDiJetJetPtMin + (i+1)*stepPt) > EtMean) jetBinOk = jetBin;
2901 }
2902 jetBinOk = -1.;
2903 }
2904 else if (kindBins == 2)
2905 {
2906 for(Int_t i=0; i<fDiJetNBinsJetPt; ++i)
2907 {
2908 jetBin = fDiJetJetPtMin + i*stepPt/2.;
2909 if(((fDiJetJetPtMin+i*stepPt) <= leadingJetPt) &&
2910 (fDiJetJetPtMin + (i+1)*stepPt) > leadingJetPt) jetBinOk = jetBin;
2911 }
2912 jetBinOk = -1.;
2913 }
2914 else {Printf("WARNING: kindBins wrongly set ! Please make sure to call SetKindSlices() and set the kind parameter to 1, 2 or 3.\n");}
2915
2916 return jetBinOk;
2917
2918}
2919
2920
2921//______________________________________________________________
2922void AliAnalysisTaskFragmentationFunction::Terminate(Option_t *)
2923{
2924 // terminated
2925
2926 if(fDebug > 1) printf("AliAnalysisTaskFragmentationFunction::Terminate() \n");
2927}
2928
2929//_________________________________________________________________________________
2930Int_t AliAnalysisTaskFragmentationFunction::GetListOfTracks(TList *list, Int_t type)
2931{
2932 // fill list of tracks selected according to type
2933
2934 if(fDebug > 2) Printf("%s:%d Selecting tracks with %d", (char*)__FILE__,__LINE__,type);
2935
2936 if(!list){
2937 if(fDebug>1) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
2938 return -1;
2939 }
2940
2941 if(type==kTrackUndef) return 0;
2942
2943 Int_t iCount = 0;
2944 if(type==kTrackAODCuts || type==kTrackAOD){
2945
2946 // all rec. tracks, esd filter mask, eta range
2947 if(!fAOD) return -1;
2948
2949 for(Int_t it=0; it<fAOD->GetNumberOfTracks(); ++it){
2950 AliAODTrack *tr = fAOD->GetTrack(it);
2951
2952 if(type == kTrackAODCuts){
2953 if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask))) continue;
2954 if(tr->Eta() < fTrackEtaMin || tr->Eta() > fTrackEtaMax) continue;
2955 if(tr->Phi() < fTrackPhiMin || tr->Phi() > fTrackPhiMax) continue;
2956 if(tr->Pt() < fTrackPtCut) continue;
2957 }
2958 list->Add(tr);
2959 iCount++;
2960 }
2961 }
2962 else if (type==kTrackKineAll || type==kTrackKineCharged || type==kTrackKineChargedAcceptance){
2963 // kine particles, all or rather charged
2964 if(!fMCEvent) return iCount;
2965
2966 for(Int_t it=0; it<fMCEvent->GetNumberOfTracks(); ++it){
2967 AliMCParticle* part = (AliMCParticle*) fMCEvent->GetTrack(it);
2968
2969 if(type == kTrackKineCharged || type == kTrackKineChargedAcceptance){
2970 if(part->Charge()==0) continue;
2971
2972 if(type == kTrackKineChargedAcceptance &&
2973 ( part->Eta() < fTrackEtaMin
2974 || part->Eta() > fTrackEtaMax
2975 || part->Phi() < fTrackPhiMin
2976 || part->Phi() > fTrackPhiMax
2977 || part->Pt() < fTrackPtCut)) continue;
2978 }
2979
2980 list->Add(part);
2981 iCount++;
2982 }
2983 }
2984 else if (type==kTrackAODMCCharged || type==kTrackAODMCAll || type==kTrackAODMCChargedAcceptance) {
2985 // MC particles (from AOD), physical primaries, all or rather charged or rather charged within acceptance
2986 if(!fAOD) return -1;
2987
2988 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
2989 if(!tca)return iCount;
2990
2991 for(int it=0; it<tca->GetEntriesFast(); ++it){
2992 AliAODMCParticle *part = dynamic_cast<AliAODMCParticle*>(tca->At(it));
2993 if(!part->IsPhysicalPrimary())continue;
2994
2995 if (type==kTrackAODMCCharged || type==kTrackAODMCChargedAcceptance){
2996 if(part->Charge()==0) continue;
2997 if(type==kTrackAODMCChargedAcceptance &&
2998 ( part->Eta() > fTrackEtaMax
2999 || part->Eta() < fTrackEtaMin
3000 || part->Phi() > fTrackPhiMax
3001 || part->Phi() < fTrackPhiMin
3002 || part->Pt() < fTrackPtCut)) continue;
3003 }
3004
3005 list->Add(part);
3006 iCount++;
3007 }
3008 }
3009
3010 list->Sort();
3011 return iCount;
3012
3013}
3014// _______________________________________________________________________________
3015Int_t AliAnalysisTaskFragmentationFunction::GetListOfJets(TList *list, Int_t type)
3016{
3017 // fill list of jets selected according to type
3018
3019 if(!list){
3020 if(fDebug>1) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
3021 return -1;
3022 }
3023
3024 if(type == kJetsRec || type == kJetsRecAcceptance){ // reconstructed jets
3025
3026 if(fBranchRecJets.Length()==0){
3027 Printf("%s:%d no rec jet branch specified", (char*)__FILE__,__LINE__);
3028 if(fDebug>1)fAOD->Print();
3029 return 0;
3030 }
3031
3032 TClonesArray *aodRecJets = new TClonesArray();
1db1733e 3033 if(fBranchRecJets.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchRecJets.Data()));\r
3034 if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAOD->GetList()->FindObject(fBranchRecJets.Data()));\r
656dc810 3035
3036 if(!aodRecJets){
3037 if(fBranchRecJets.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchRecJets.Data());
3038
3039 if(fDebug>1)fAOD->Print();
3040 return 0;
3041 }
3042
3043 Int_t nRecJets = 0;
3044
3045 for(Int_t ij=0; ij<aodRecJets->GetEntries(); ++ij){
3046
3047 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodRecJets->At(ij));
3048 if(!tmp) continue;
3049
3050 if( tmp->Pt() < fJetPtCut ) continue;
3051 if( type == kJetsRecAcceptance &&
3052 ( tmp->Eta() < fJetEtaMin
3053 || tmp->Eta() > fJetEtaMax
3054 || tmp->Phi() < fJetPhiMin
3055 || tmp->Phi() > fJetPhiMax )) continue;
3056
3057 list->Add(tmp);
3058
3059 nRecJets++;
3060 }
3061
3062 list->Sort();
3063 return nRecJets;
3064 delete aodRecJets;
3065 }
3066 else if(type == kJetsKine || type == kJetsKineAcceptance){
3067
3068 // generated jets
3069 Int_t nGenJets = 0;
3070
3071 if(!fMCEvent){
3072 if(fDebug>1) Printf("%s:%d no mcEvent",(char*)__FILE__,__LINE__);
3073 return 0;
3074 }
3075
3076 AliGenPythiaEventHeader* pythiaGenHeader = AliAnalysisHelperJetTasks::GetPythiaEventHeader(fMCEvent);
3077 if(!pythiaGenHeader){
3078 Printf("%s:%d no pythiaGenHeader found", (char*)__FILE__,__LINE__);
3079 return 0;
3080 }
3081
3082 // fetch the pythia generated jets
3083 for(int ip=0; ip<pythiaGenHeader->NTriggerJets(); ++ip){
3084
3085 Float_t p[4];
3086 AliAODJet *jet = new AliAODJet();
3087 pythiaGenHeader->TriggerJet(ip, p);
3088 jet->SetPxPyPzE(p[0], p[1], p[2], p[3]);
3089
3090 if( type == kJetsKineAcceptance &&
3091 ( jet->Eta() < fJetEtaMin
3092 || jet->Eta() > fJetEtaMax
3093 || jet->Phi() < fJetPhiMin
3094 || jet->Phi() > fJetPhiMax )) continue;
3095
3096 list->Add(jet);
3097 nGenJets++;
3098 }
3099 list->Sort();
3100 return nGenJets;
3101 }
3102 else if(type == kJetsGen || type == kJetsGenAcceptance ){
3103
3104 if(fBranchGenJets.Length()==0){
3105 if(fDebug>1) Printf("%s:%d no gen jet branch specified", (char*)__FILE__,__LINE__);
3106 return 0;
3107 }
3108
3109 TClonesArray *aodGenJets = new TClonesArray();
1db1733e 3110 if(fBranchGenJets.Length()) aodGenJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchGenJets.Data()));\r
3111 if(!aodGenJets) aodGenJets = dynamic_cast<TClonesArray*>(fAOD->GetList()->FindObject(fBranchGenJets.Data()));\r
656dc810 3112
3113 if(!aodGenJets){
3114 if(fDebug>0){
3115 if(fBranchGenJets.Length()) Printf("%s:%d Generated jet branch %s not found",(char*)__FILE__,__LINE__,fBranchGenJets.Data());
3116 }
3117 if(fDebug>1)fAOD->Print();
3118 return 0;
3119 }
3120
3121 Int_t nGenJets = 0;
3122
3123 for(Int_t ig=0; ig<aodGenJets->GetEntries(); ++ig){
3124
3125 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodGenJets->At(ig));
3126 if(!tmp) continue;
3127
3128 if( tmp->Pt() < fJetPtCut ) continue;
3129 if( type == kJetsGenAcceptance &&
3130 ( tmp->Eta() < fJetEtaMin
3131 || tmp->Eta() > fJetEtaMax
3132 || tmp->Phi() < fJetPhiMin
3133 || tmp->Phi() > fJetPhiMax )) continue;
3134
3135 list->Add(tmp);
3136
3137 nGenJets++;
3138 }
3139 list->Sort();
3140 return nGenJets;
3141 delete aodGenJets;
3142 }
3143 else{
3144 if(fDebug>0)Printf("%s:%d no such type %d",(char*)__FILE__,__LINE__,type);
3145 return 0;
3146 }
3147}
3148
3149// _________________________________________________________________________________________________________
3150void AliAnalysisTaskFragmentationFunction::SetProperties(THnSparse* h,const Int_t dim, const char** labels)
3151{
3152 //Set properties of THnSparse
3153
3154 for(Int_t i=0; i<dim; i++){
3155
3156 h->GetAxis(i)->SetTitle(labels[i]);
3157 h->GetAxis(i)->SetTitleColor(1);
3158 }
3159}
3160
3161// __________________________________________________________________________________________
3162void AliAnalysisTaskFragmentationFunction::SetProperties(TH1* h,const char* x, const char* y)
3163{
3164 //Set properties of histos (x and y title)
3165
3166 h->SetXTitle(x);
3167 h->SetYTitle(y);
3168 h->GetXaxis()->SetTitleColor(1);
3169 h->GetYaxis()->SetTitleColor(1);
3170}
3171
3172// _________________________________________________________________________________________________________
3173void AliAnalysisTaskFragmentationFunction::SetProperties(TH2* h,const char* x, const char* y, const char* z)
3174{
3175 //Set properties of histos (x,y and z title)
3176
3177 h->SetXTitle(x);
3178 h->SetYTitle(y);
3179 h->SetZTitle(z);
3180 h->GetXaxis()->SetTitleColor(1);
3181 h->GetYaxis()->SetTitleColor(1);
3182 h->GetZaxis()->SetTitleColor(1);
3183}
3184
3185// ________________________________________________________________________________________________________________________________________________________
3186void AliAnalysisTaskFragmentationFunction::GetJetTracksPointing(TList* inputlist, TList* outputlist, AliAODJet* jet, const Double_t radius,Double_t& sumPt)
3187{
3188 // fill list of tracks in cone around jet axis
3189
3190 sumPt = 0;
3191
3192 Double_t jetMom[3];
3193 jet->PxPyPz(jetMom);
3194 TVector3 jet3mom(jetMom);
3195
3196 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
3197
3198 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
3199
3200 Double_t trackMom[3];
3201 track->PxPyPz(trackMom);
3202 TVector3 track3mom(trackMom);
3203
3204 Double_t dR = jet3mom.DeltaR(track3mom);
3205
3206 if(dR<radius){
3207
3208 outputlist->Add(track);
3209
3210 sumPt += track->Pt();
3211 }
3212 }
3213
3214 outputlist->Sort();
3215}
3216
3217// ___________________________________________________________________________________________
3218void AliAnalysisTaskFragmentationFunction::GetJetTracksTrackrefs(TList* list, AliAODJet* jet)
3219{
3220 // list of jet tracks from trackrefs
3221
3222 Int_t nTracks = jet->GetRefTracks()->GetEntriesFast();
3223
3224 for (Int_t itrack=0; itrack<nTracks; itrack++) {
3225
3226 AliVParticle* track = dynamic_cast<AliVParticle*>(jet->GetRefTracks()->At(itrack));
3227 if(!track){
3228 AliError("expected ref track not found ");
3229 continue;
3230 }
3231
3232 list->Add(track);
3233 }
3234
3235 list->Sort();
3236}
fe343c6b 3237
3238// _ ________________________________________________________________________________________________________________________________
3239void AliAnalysisTaskFragmentationFunction::AssociateGenRec(TList* tracksAODMCCharged,TList* tracksRec, TArrayI& indexAODTr,TArrayI& indexMCTr,TArrayS& isGenPrim)
3240{
3241 // associate generated and reconstructed tracks, fill TArrays of list indices
3242
3243
3244 Int_t nTracksRec = tracksRec->GetSize();
3245 Int_t nTracksGen = tracksAODMCCharged->GetSize();
3246 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
3247
3248 if(!nTracksGen) return;
3249 if(!tca) return;
3250
3251 // set size
3252 indexAODTr.Set(nTracksGen);
3253 indexMCTr.Set(nTracksRec);
3254 isGenPrim.Set(nTracksGen);
3255
3256 indexAODTr.Reset(-1);
3257 indexMCTr.Reset(-1);
3258 isGenPrim.Reset(0);
3259
3260 // loop over reconstructed tracks, get generated track
3261
3262 for(Int_t iRec=0; iRec<nTracksRec; iRec++){
3263
3264 AliAODTrack* rectrack = dynamic_cast<AliAODTrack*>(tracksRec->At(iRec));
3265
3266 Int_t label = rectrack->GetLabel();
3267
3268 // find MC track in our list
3269 AliAODMCParticle* gentrack = 0x0;
3270 if(label>=0) gentrack = dynamic_cast<AliAODMCParticle*> (tca->At(label));
3271
3272 Int_t listIndex = -1;
3273 if(gentrack) listIndex = tracksAODMCCharged->IndexOf(gentrack);
3274
3275 if(listIndex>=0){
3276
3277 indexAODTr[listIndex] = iRec;
3278 indexMCTr[iRec] = listIndex;
3279 }
3280 }
3281
3282
3283 // define primary sample for reconstruction efficiency
3284
3285 for(Int_t iGen=0; iGen<nTracksGen; iGen++){
3286
3287 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tracksAODMCCharged->At(iGen));
3288
3289 Int_t pdg = gentrack->GetPdgCode();
3290
3291 // 211 - pi, 2212 - proton, 321 - Kaon, 11 - electron, 13 - muon
3292 if(TMath::Abs(pdg) == 211 || TMath::Abs(pdg) == 2212 || TMath::Abs(pdg) == 321 ||
3293 TMath::Abs(pdg) == 11 || TMath::Abs(pdg) == 13){
3294
3295 isGenPrim[iGen] = kTRUE;
3296 }
3297 }
3298}
3299
3300// _____________________________________________________________________________________________________________________________________________
3301void AliAnalysisTaskFragmentationFunction::FillSingleTrackRecEffHisto(THnSparse* histo, TList* tracksGen, TList* tracksRec, TArrayI& indexAODTr, TArrayS& isGenPrim){
3302
3303 // fill THnSparse for single track reconstruction efficiency
3304
3305 Int_t nTracksGen = tracksGen->GetSize();
3306
3307 if(!nTracksGen) return;
3308
3309 for(Int_t iGen=0; iGen<nTracksGen; iGen++){
3310
3311 if(isGenPrim[iGen] != 1) continue; // select primaries
3312
3313 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tracksGen->At(iGen));
3314
3315 Double_t ptGen = gentrack->Pt();
3316 Double_t etaGen = gentrack->Eta();
3317 Double_t phiGen = TVector2::Phi_0_2pi(gentrack->Phi());
3318
3319 // apply same acc & pt cuts as for FF
3320 // could in principle also be done setting THNsparse axis limits before projecting,
3321 // but then the binning needs to be fine grained enough
3322
3323 if(etaGen < fTrackEtaMin || etaGen > fTrackEtaMax) continue;
3324 if(phiGen < fTrackPhiMin || phiGen > fTrackPhiMax) continue;
3325 if(ptGen < fTrackPtCut) continue;
3326
3327 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
3328 Double_t isRec = 0;
3329 Double_t ptRec = -1;
3330
3331 if(iRec>=0){
3332
3333 AliAODTrack* rectrack = dynamic_cast<AliAODTrack*>(tracksRec->At(iRec));
3334 ptRec = rectrack->Pt();
3335 isRec = 1;
3336 }
3337
3338 Double_t entries[5] = {phiGen,etaGen,ptGen,ptRec,isRec};
3339 histo->Fill(entries);
3340 }
3341}
3342
3343// ______________________________________________________________________________________________________________________________________________________
3344void AliAnalysisTaskFragmentationFunction::FillJetTrackRecEffHisto(THnSparse* histo,Double_t jetPhi, Double_t jetEta, Double_t jetPt, TList* jetTrackList,
3345 TList* tracksGen, TArrayI& indexAODTr, TArrayS& isGenPrim)
3346{
3347 // fill THnSparse for jet track reconstruction efficiency
3348
3349 Int_t nTracksJet = jetTrackList->GetSize(); // list with AODMC tracks
3350
3351 if(!nTracksJet) return;
3352
3353 for(Int_t iTr=0; iTr<nTracksJet; iTr++){
3354
3355 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (jetTrackList->At(iTr));
3356
3357 // find jet track in gen tracks list
3358 Int_t iGen = tracksGen->IndexOf(gentrack);
3359
3360 if(iGen<0){
3361 if(fDebug>0) Printf("%s:%d gen jet track not found ",(char*)__FILE__,__LINE__);
3362 continue;
3363 }
3364
3365 if(isGenPrim[iGen] != 1) continue; // select primaries
3366
3367 Double_t ptGen = gentrack->Pt();
3368 Double_t etaGen = gentrack->Eta();
3369 Double_t phiGen = TVector2::Phi_0_2pi(gentrack->Phi());
3370
3371 // apply same acc & pt cuts as for FF
3372 // could in principle also be done setting THNsparse axis limits before projecting,
3373 // but then the binning needs to be fine grained enough
3374
3375 if(etaGen < fTrackEtaMin || etaGen > fTrackEtaMax) continue;
3376 if(phiGen < fTrackPhiMin || phiGen > fTrackPhiMax) continue;
3377 if(ptGen < fTrackPtCut) continue;
3378
3379 Double_t z = ptGen / jetPt;
3380 Double_t xi = 0;
3381 if(z>0) xi = TMath::Log(1/z);
3382
3383 Double_t isRec = 0;
3384 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
3385 if(iRec>=0) isRec = 1;
3386
3387 Double_t entries[7] = {jetPhi,jetEta,jetPt,ptGen,z,xi,isRec};
3388 histo->Fill(entries);
3389 }
3390}