]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGJE/UserTasks/AliAnalysisTaskIDFragmentationFunction.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Changes to compile with Root6 on macosx64
[u/mrichter/AliRoot.git] / PWGJE / UserTasks / AliAnalysisTaskIDFragmentationFunction.cxx
CommitLineData
e131b05f 1// *************************************************************************
2// * *
3// * Task for ID Fragmentation Function Analysis *
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 "TH3F.h"
29#include "TString.h"
30#include "THnSparse.h"
31#include "TProfile.h"
32#include "TFile.h"
33#include "TKey.h"
34#include "TRandom3.h"
35#include "TAxis.h"
36
37#include "AliAODInputHandler.h"
38#include "AliAODHandler.h"
39#include "AliESDEvent.h"
40#include "AliAODMCParticle.h"
41#include "AliAODJet.h"
42#include "AliAODJetEventBackground.h"
43#include "AliGenPythiaEventHeader.h"
44#include "AliGenHijingEventHeader.h"
45#include "AliInputEventHandler.h"
46
47#include "AliAnalysisHelperJetTasks.h"
48#include "AliAnalysisManager.h"
49#include "AliAnalysisTaskSE.h"
50#include "AliVParticle.h"
51#include "AliVEvent.h"
52
53#include "AliAnalysisTaskPID.h"
54#include "AliPIDResponse.h"
55
56#include "AliAnalysisTaskIDFragmentationFunction.h"
57using std::cout;
58using std::endl;
59using std::cerr;
60
61ClassImp(AliAnalysisTaskIDFragmentationFunction)
62
63//____________________________________________________________________________
64AliAnalysisTaskIDFragmentationFunction::AliAnalysisTaskIDFragmentationFunction()
65 : AliAnalysisTaskSE()
66 ,fESD(0)
67 ,fAOD(0)
68 ,fAODJets(0)
69 ,fAODExtension(0)
70 ,fNonStdFile("")
71 ,fBranchRecJets("jets")
72 ,fBranchRecBckgClusters("")
73 ,fBranchGenJets("")
74 ,fBranchEmbeddedJets("")
75 ,fTrackTypeGen(0)
76 ,fJetTypeGen(0)
77 ,fJetTypeRecEff(0)
78 ,fUseAODInputJets(kTRUE)
79 ,fFilterMask(0)
80 ,fUsePhysicsSelection(kTRUE)
81 ,fEvtSelectionMask(0)
82 ,fEventClass(0)
83 ,fMaxVertexZ(10)
84 ,fTrackPtCut(0)
85 ,fTrackEtaMin(0)
86 ,fTrackEtaMax(0)
87 ,fTrackPhiMin(0)
88 ,fTrackPhiMax(0)
89 ,fUseExtraTracks(0)
90 ,fUseExtraTracksBgr(0)
91 ,fCutFractionPtEmbedded(0)
92 ,fUseEmbeddedJetAxis(0)
93 ,fUseEmbeddedJetPt(0)
94 ,fJetPtCut(0)
95 ,fJetEtaMin(0)
96 ,fJetEtaMax(0)
97 ,fJetPhiMin(0)
98 ,fJetPhiMax(0)
99 ,fFFRadius(0)
100 ,fFFMinLTrackPt(-1)
101 ,fFFMaxTrackPt(-1)
102 ,fFFMinnTracks(0)
103 ,fFFBckgRadius(0)
104 ,fBckgMode(0)
105 ,fQAMode(0)
106 ,fFFMode(0)
107 ,fIDFFMode(0)
108 ,fEffMode(0)
109 ,fJSMode(0)
110 ,fAvgTrials(0)
111 ,fTracksRecCuts(0)
112 ,fTracksRecCutsEfficiency(0)
113 ,fTracksGen(0)
114 ,fTracksAODMCCharged(0)
115 ,fTracksAODMCChargedSecNS(0)
116 ,fTracksAODMCChargedSecS(0)
117 ,fTracksRecQualityCuts(0)
118 ,fJetsRec(0)
119 ,fJetsRecCuts(0)
120 ,fJetsGen(0)
121 ,fJetsRecEff(0)
122 ,fJetsEmbedded(0)
123 ,fBckgJetsRec(0)
124 ,fBckgJetsRecCuts(0)
125 ,fBckgJetsGen(0)
126 ,fQATrackHistosRecCuts(0)
127 ,fQATrackHistosGen(0)
128 ,fQAJetHistosRec(0)
129 ,fQAJetHistosRecCuts(0)
130 ,fQAJetHistosRecCutsLeading(0)
131 ,fQAJetHistosGen(0)
132 ,fQAJetHistosGenLeading(0)
133 ,fQAJetHistosRecEffLeading(0)
134 ,fFFHistosRecCuts(0)
135 ,fFFHistosRecCutsInc(0)
136 ,fFFHistosRecLeadingTrack(0)
137 ,fFFHistosGen(0)
138 ,fFFHistosGenInc(0)
139 ,fFFHistosGenLeadingTrack(0)
140 ,fQATrackHighPtThreshold(0)
141 ,fFFNBinsJetPt(0)
142 ,fFFJetPtMin(0)
143 ,fFFJetPtMax(0)
144 ,fFFNBinsPt(0)
145 ,fFFPtMin(0)
146 ,fFFPtMax(0)
147 ,fFFNBinsXi(0)
148 ,fFFXiMin(0)
149 ,fFFXiMax(0)
150 ,fFFNBinsZ(0)
151 ,fFFZMin(0)
152 ,fFFZMax(0)
153 ,fQAJetNBinsPt(0)
154 ,fQAJetPtMin(0)
155 ,fQAJetPtMax(0)
156 ,fQAJetNBinsEta(0)
157 ,fQAJetEtaMin(0)
158 ,fQAJetEtaMax(0)
159 ,fQAJetNBinsPhi(0)
160 ,fQAJetPhiMin(0)
161 ,fQAJetPhiMax(0)
162 ,fQATrackNBinsPt(0)
163 ,fQATrackPtMin(0)
164 ,fQATrackPtMax(0)
165 ,fQATrackNBinsEta(0)
166 ,fQATrackEtaMin(0)
167 ,fQATrackEtaMax(0)
168 ,fQATrackNBinsPhi(0)
169 ,fQATrackPhiMin(0)
170 ,fQATrackPhiMax(0)
171 ,fCommonHistList(0)
172 ,fh1EvtSelection(0)
173 ,fh1VertexNContributors(0)
174 ,fh1VertexZ(0)
175 ,fh1EvtMult(0)
176 ,fh1EvtCent(0)
177 ,fh1Xsec(0)
178 ,fh1Trials(0)
179 ,fh1PtHard(0)
180 ,fh1PtHardTrials(0)
181 ,fh1nRecJetsCuts(0)
182 ,fh1nGenJets(0)
183 ,fh1nRecEffJets(0)
184 ,fh1nEmbeddedJets(0)
185 ,fh1nRecBckgJetsCuts(0)
186 ,fh1nGenBckgJets(0)
187 ,fh2PtRecVsGenPrim(0)
188 ,fh2PtRecVsGenSec(0)
189 ,fQATrackHistosRecEffGen(0)
190 ,fQATrackHistosRecEffRec(0)
191 ,fQATrackHistosSecRecNS(0)
192 ,fQATrackHistosSecRecS(0)
193 ,fQATrackHistosSecRecSsc(0)
194 ,fFFHistosRecEffRec(0)
195 ,fFFHistosSecRecNS(0)
196 ,fFFHistosSecRecS(0)
197 ,fFFHistosSecRecSsc(0)
198 // Background
199 ,fh1BckgMult0(0)
200 ,fh1BckgMult1(0)
201 ,fh1BckgMult2(0)
202 ,fh1BckgMult3(0)
203 ,fh1BckgMult4(0)
204 ,fh1FractionPtEmbedded(0)
205 ,fh1IndexEmbedded(0)
206 ,fh2DeltaPtVsJetPtEmbedded(0)
207 ,fh2DeltaPtVsRecJetPtEmbedded(0)
208 ,fh1DeltaREmbedded(0)
209 ,fQABckgHisto0RecCuts(0)
210 ,fQABckgHisto0Gen(0)
211 ,fQABckgHisto1RecCuts(0)
212 ,fQABckgHisto1Gen(0)
213 ,fQABckgHisto2RecCuts(0)
214 ,fQABckgHisto2Gen(0)
215 ,fQABckgHisto3RecCuts(0)
216 ,fQABckgHisto3Gen(0)
217 ,fQABckgHisto4RecCuts(0)
218 ,fQABckgHisto4Gen(0)
219 ,fFFBckgHisto0RecCuts(0)
220 ,fFFBckgHisto0Gen(0)
221 ,fFFBckgHisto1RecCuts(0)
222 ,fFFBckgHisto1Gen(0)
223 ,fFFBckgHisto2RecCuts(0)
224 ,fFFBckgHisto2Gen(0)
225 ,fFFBckgHisto3RecCuts(0)
226 ,fFFBckgHisto3Gen(0)
227 ,fFFBckgHisto4RecCuts(0)
228 ,fFFBckgHisto4Gen(0)
229 ,fFFBckgHisto0RecEffRec(0)
230 ,fFFBckgHisto0SecRecNS(0)
231 ,fFFBckgHisto0SecRecS(0)
232 ,fFFBckgHisto0SecRecSsc(0)
233 // jet shape
234 ,fProNtracksLeadingJet(0)
235 ,fProDelR80pcPt(0)
236 ,fProNtracksLeadingJetGen(0)
237 ,fProDelR80pcPtGen(0)
238 ,fProNtracksLeadingJetBgrPerp2(0)
239 ,fProNtracksLeadingJetRecPrim(0)
240 ,fProDelR80pcPtRecPrim(0)
241 ,fProNtracksLeadingJetRecSecNS(0)
242 ,fProNtracksLeadingJetRecSecS(0)
243 ,fProNtracksLeadingJetRecSecSsc(0)
244
245 ,fRandom(0)
246
c4856fb1 247 ,fOnlyLeadingJets(kFALSE)
248
e131b05f 249 // PID framework
250 ,fNumInclusivePIDtasks(0)
251 ,fNumJetPIDtasks(0)
252 ,fNameInclusivePIDtask(0x0)
253 ,fNameJetPIDtask(0x0)
254 ,fInclusivePIDtask(0x0)
255 ,fJetPIDtask(0x0)
256 ,fUseInclusivePIDtask(kFALSE)
257 ,fUseJetPIDtask(kFALSE)
258 ,fIsPP(kFALSE)
259{
260 // default constructor
261 fBckgType[0] = 0;
262 fBckgType[1] = 0;
263 fBckgType[2] = 0;
264 fBckgType[3] = 0;
265 fBckgType[4] = 0;
266
267 for(Int_t ii=0; ii<5; ii++){
268 fProDelRPtSum[ii] = 0;
269 fProDelRPtSumGen[ii] = 0;
270 fProDelRPtSumBgrPerp2[ii] = 0;
271 fProDelRPtSumRecPrim[ii] = 0;
272 fProDelRPtSumRecSecNS[ii] = 0;
273 fProDelRPtSumRecSecS[ii] = 0;
274 fProDelRPtSumRecSecSsc[ii] = 0;
275 }
276
277 for (Int_t i = 0; i < AliPID::kSPECIES; i++) {
278 fIDFFHistosRecCuts[i] = 0x0;
279 fIDFFHistosGen[i] = 0x0;
280 }
281}
282
283//_______________________________________________________________________________________________
284AliAnalysisTaskIDFragmentationFunction::AliAnalysisTaskIDFragmentationFunction(const char *name)
285 : AliAnalysisTaskSE(name)
286 ,fESD(0)
287 ,fAOD(0)
288 ,fAODJets(0)
289 ,fAODExtension(0)
290 ,fNonStdFile("")
291 ,fBranchRecJets("jets")
292 ,fBranchRecBckgClusters("")
293 ,fBranchGenJets("")
294 ,fBranchEmbeddedJets("")
295 ,fTrackTypeGen(0)
296 ,fJetTypeGen(0)
297 ,fJetTypeRecEff(0)
298 ,fUseAODInputJets(kTRUE)
299 ,fFilterMask(0)
300 ,fUsePhysicsSelection(kTRUE)
301 ,fEvtSelectionMask(0)
302 ,fEventClass(0)
303 ,fMaxVertexZ(10)
304 ,fTrackPtCut(0)
305 ,fTrackEtaMin(0)
306 ,fTrackEtaMax(0)
307 ,fTrackPhiMin(0)
308 ,fTrackPhiMax(0)
309 ,fUseExtraTracks(0)
310 ,fUseExtraTracksBgr(0)
311 ,fCutFractionPtEmbedded(0)
312 ,fUseEmbeddedJetAxis(0)
313 ,fUseEmbeddedJetPt(0)
314 ,fJetPtCut(0)
315 ,fJetEtaMin(0)
316 ,fJetEtaMax(0)
317 ,fJetPhiMin(0)
318 ,fJetPhiMax(0)
319 ,fFFRadius(0)
320 ,fFFMinLTrackPt(-1)
321 ,fFFMaxTrackPt(-1)
322 ,fFFMinnTracks(0)
323 ,fFFBckgRadius(0)
324 ,fBckgMode(0)
325 ,fQAMode(0)
326 ,fFFMode(0)
327 ,fIDFFMode(0)
328 ,fEffMode(0)
329 ,fJSMode(0)
330 ,fAvgTrials(0)
331 ,fTracksRecCuts(0)
332 ,fTracksRecCutsEfficiency(0)
333 ,fTracksGen(0)
334 ,fTracksAODMCCharged(0)
335 ,fTracksAODMCChargedSecNS(0)
336 ,fTracksAODMCChargedSecS(0)
337 ,fTracksRecQualityCuts(0)
338 ,fJetsRec(0)
339 ,fJetsRecCuts(0)
340 ,fJetsGen(0)
341 ,fJetsRecEff(0)
342 ,fJetsEmbedded(0)
343 ,fBckgJetsRec(0)
344 ,fBckgJetsRecCuts(0)
345 ,fBckgJetsGen(0)
346 ,fQATrackHistosRecCuts(0)
347 ,fQATrackHistosGen(0)
348 ,fQAJetHistosRec(0)
349 ,fQAJetHistosRecCuts(0)
350 ,fQAJetHistosRecCutsLeading(0)
351 ,fQAJetHistosGen(0)
352 ,fQAJetHistosGenLeading(0)
353 ,fQAJetHistosRecEffLeading(0)
354 ,fFFHistosRecCuts(0)
355 ,fFFHistosRecCutsInc(0)
356 ,fFFHistosRecLeadingTrack(0)
357 ,fFFHistosGen(0)
358 ,fFFHistosGenInc(0)
359 ,fFFHistosGenLeadingTrack(0)
360 ,fQATrackHighPtThreshold(0)
361 ,fFFNBinsJetPt(0)
362 ,fFFJetPtMin(0)
363 ,fFFJetPtMax(0)
364 ,fFFNBinsPt(0)
365 ,fFFPtMin(0)
366 ,fFFPtMax(0)
367 ,fFFNBinsXi(0)
368 ,fFFXiMin(0)
369 ,fFFXiMax(0)
370 ,fFFNBinsZ(0)
371 ,fFFZMin(0)
372 ,fFFZMax(0)
373 ,fQAJetNBinsPt(0)
374 ,fQAJetPtMin(0)
375 ,fQAJetPtMax(0)
376 ,fQAJetNBinsEta(0)
377 ,fQAJetEtaMin(0)
378 ,fQAJetEtaMax(0)
379 ,fQAJetNBinsPhi(0)
380 ,fQAJetPhiMin(0)
381 ,fQAJetPhiMax(0)
382 ,fQATrackNBinsPt(0)
383 ,fQATrackPtMin(0)
384 ,fQATrackPtMax(0)
385 ,fQATrackNBinsEta(0)
386 ,fQATrackEtaMin(0)
387 ,fQATrackEtaMax(0)
388 ,fQATrackNBinsPhi(0)
389 ,fQATrackPhiMin(0)
390 ,fQATrackPhiMax(0)
391 ,fCommonHistList(0)
392 ,fh1EvtSelection(0)
393 ,fh1VertexNContributors(0)
394 ,fh1VertexZ(0)
395 ,fh1EvtMult(0)
396 ,fh1EvtCent(0)
397 ,fh1Xsec(0)
398 ,fh1Trials(0)
399 ,fh1PtHard(0)
400 ,fh1PtHardTrials(0)
401 ,fh1nRecJetsCuts(0)
402 ,fh1nGenJets(0)
403 ,fh1nRecEffJets(0)
404 ,fh1nEmbeddedJets(0)
405 ,fh1nRecBckgJetsCuts(0)
406 ,fh1nGenBckgJets(0)
407 ,fh2PtRecVsGenPrim(0)
408 ,fh2PtRecVsGenSec(0)
409 ,fQATrackHistosRecEffGen(0)
410 ,fQATrackHistosRecEffRec(0)
411 ,fQATrackHistosSecRecNS(0)
412 ,fQATrackHistosSecRecS(0)
413 ,fQATrackHistosSecRecSsc(0)
414 ,fFFHistosRecEffRec(0)
415 ,fFFHistosSecRecNS(0)
416 ,fFFHistosSecRecS(0)
417 ,fFFHistosSecRecSsc(0)
418 // Background
419 ,fh1BckgMult0(0)
420 ,fh1BckgMult1(0)
421 ,fh1BckgMult2(0)
422 ,fh1BckgMult3(0)
423 ,fh1BckgMult4(0)
424 ,fh1FractionPtEmbedded(0)
425 ,fh1IndexEmbedded(0)
426 ,fh2DeltaPtVsJetPtEmbedded(0)
427 ,fh2DeltaPtVsRecJetPtEmbedded(0)
428 ,fh1DeltaREmbedded(0)
429 ,fQABckgHisto0RecCuts(0)
430 ,fQABckgHisto0Gen(0)
431 ,fQABckgHisto1RecCuts(0)
432 ,fQABckgHisto1Gen(0)
433 ,fQABckgHisto2RecCuts(0)
434 ,fQABckgHisto2Gen(0)
435 ,fQABckgHisto3RecCuts(0)
436 ,fQABckgHisto3Gen(0)
437 ,fQABckgHisto4RecCuts(0)
438 ,fQABckgHisto4Gen(0)
439 ,fFFBckgHisto0RecCuts(0)
440 ,fFFBckgHisto0Gen(0)
441 ,fFFBckgHisto1RecCuts(0)
442 ,fFFBckgHisto1Gen(0)
443 ,fFFBckgHisto2RecCuts(0)
444 ,fFFBckgHisto2Gen(0)
445 ,fFFBckgHisto3RecCuts(0)
446 ,fFFBckgHisto3Gen(0)
447 ,fFFBckgHisto4RecCuts(0)
448 ,fFFBckgHisto4Gen(0)
449 ,fFFBckgHisto0RecEffRec(0)
450 ,fFFBckgHisto0SecRecNS(0)
451 ,fFFBckgHisto0SecRecS(0)
452 ,fFFBckgHisto0SecRecSsc(0)
453 // jet shape
454 ,fProNtracksLeadingJet(0)
455 ,fProDelR80pcPt(0)
456 ,fProNtracksLeadingJetGen(0)
457 ,fProDelR80pcPtGen(0)
458 ,fProNtracksLeadingJetBgrPerp2(0)
459 ,fProNtracksLeadingJetRecPrim(0)
460 ,fProDelR80pcPtRecPrim(0)
461 ,fProNtracksLeadingJetRecSecNS(0)
462 ,fProNtracksLeadingJetRecSecS(0)
463 ,fProNtracksLeadingJetRecSecSsc(0)
464 ,fRandom(0)
c4856fb1 465 ,fOnlyLeadingJets(kFALSE)
e131b05f 466 // PID framework
467 ,fNumInclusivePIDtasks(0)
468 ,fNumJetPIDtasks(0)
469 ,fNameInclusivePIDtask(0x0)
470 ,fNameJetPIDtask(0x0)
471 ,fInclusivePIDtask(0x0)
472 ,fJetPIDtask(0x0)
473 ,fUseInclusivePIDtask(kFALSE)
474 ,fUseJetPIDtask(kFALSE)
475 ,fIsPP(kFALSE)
476{
477 // constructor
478 fBckgType[0] = 0;
479 fBckgType[1] = 0;
480 fBckgType[2] = 0;
481 fBckgType[3] = 0;
482 fBckgType[4] = 0;
483
484 for(Int_t ii=0; ii<5; ii++){
485 fProDelRPtSum[ii] = 0;
486 fProDelRPtSumGen[ii] = 0;
487 fProDelRPtSumBgrPerp2[ii] = 0;
488 fProDelRPtSumRecPrim[ii] = 0;
489 fProDelRPtSumRecSecNS[ii] = 0;
490 fProDelRPtSumRecSecS[ii] = 0;
491 fProDelRPtSumRecSecSsc[ii] = 0;
492 }
493
494 for (Int_t i = 0; i < AliPID::kSPECIES; i++) {
495 fIDFFHistosRecCuts[i] = 0x0;
496 fIDFFHistosGen[i] = 0x0;
497 }
498
499 DefineOutput(1,TList::Class());
500}
501
502//__________________________________________________________________________________________________________________________
503AliAnalysisTaskIDFragmentationFunction::AliAnalysisTaskIDFragmentationFunction(const AliAnalysisTaskIDFragmentationFunction &copy)
504 : AliAnalysisTaskSE()
505 ,fESD(copy.fESD)
506 ,fAOD(copy.fAOD)
507 ,fAODJets(copy.fAODJets)
508 ,fAODExtension(copy.fAODExtension)
509 ,fNonStdFile(copy.fNonStdFile)
510 ,fBranchRecJets(copy.fBranchRecJets)
511 ,fBranchRecBckgClusters(copy.fBranchRecBckgClusters)
512 ,fBranchGenJets(copy.fBranchGenJets)
513 ,fBranchEmbeddedJets(copy.fBranchEmbeddedJets)
514 ,fTrackTypeGen(copy.fTrackTypeGen)
515 ,fJetTypeGen(copy.fJetTypeGen)
516 ,fJetTypeRecEff(copy.fJetTypeRecEff)
517 ,fUseAODInputJets(copy.fUseAODInputJets)
518 ,fFilterMask(copy.fFilterMask)
519 ,fUsePhysicsSelection(copy.fUsePhysicsSelection)
520 ,fEvtSelectionMask(copy.fEvtSelectionMask)
521 ,fEventClass(copy.fEventClass)
522 ,fMaxVertexZ(copy.fMaxVertexZ)
523 ,fTrackPtCut(copy.fTrackPtCut)
524 ,fTrackEtaMin(copy.fTrackEtaMin)
525 ,fTrackEtaMax(copy.fTrackEtaMax)
526 ,fTrackPhiMin(copy.fTrackPhiMin)
527 ,fTrackPhiMax(copy.fTrackPhiMax)
528 ,fUseExtraTracks(copy.fUseExtraTracks)
529 ,fUseExtraTracksBgr(copy.fUseExtraTracksBgr)
530 ,fCutFractionPtEmbedded(copy.fCutFractionPtEmbedded)
531 ,fUseEmbeddedJetAxis(copy.fUseEmbeddedJetAxis)
532 ,fUseEmbeddedJetPt(copy.fUseEmbeddedJetPt)
533 ,fJetPtCut(copy.fJetPtCut)
534 ,fJetEtaMin(copy.fJetEtaMin)
535 ,fJetEtaMax(copy.fJetEtaMax)
536 ,fJetPhiMin(copy.fJetPhiMin)
537 ,fJetPhiMax(copy.fJetPhiMax)
538 ,fFFRadius(copy.fFFRadius)
539 ,fFFMinLTrackPt(copy.fFFMinLTrackPt)
540 ,fFFMaxTrackPt(copy.fFFMaxTrackPt)
541 ,fFFMinnTracks(copy.fFFMinnTracks)
542 ,fFFBckgRadius(copy.fFFBckgRadius)
543 ,fBckgMode(copy.fBckgMode)
544 ,fQAMode(copy.fQAMode)
545 ,fFFMode(copy.fFFMode)
546 ,fIDFFMode(copy.fIDFFMode)
547 ,fEffMode(copy.fEffMode)
548 ,fJSMode(copy.fJSMode)
549 ,fAvgTrials(copy.fAvgTrials)
550 ,fTracksRecCuts(copy.fTracksRecCuts)
551 ,fTracksRecCutsEfficiency(copy.fTracksRecCutsEfficiency)
552 ,fTracksGen(copy.fTracksGen)
553 ,fTracksAODMCCharged(copy.fTracksAODMCCharged)
554 ,fTracksAODMCChargedSecNS(copy.fTracksAODMCChargedSecNS)
555 ,fTracksAODMCChargedSecS(copy.fTracksAODMCChargedSecS)
556 ,fTracksRecQualityCuts(copy.fTracksRecQualityCuts)
557 ,fJetsRec(copy.fJetsRec)
558 ,fJetsRecCuts(copy.fJetsRecCuts)
559 ,fJetsGen(copy.fJetsGen)
560 ,fJetsRecEff(copy.fJetsRecEff)
561 ,fJetsEmbedded(copy.fJetsEmbedded)
562 ,fBckgJetsRec(copy.fBckgJetsRec)
563 ,fBckgJetsRecCuts(copy.fBckgJetsRecCuts)
564 ,fBckgJetsGen(copy.fBckgJetsGen)
565 ,fQATrackHistosRecCuts(copy.fQATrackHistosRecCuts)
566 ,fQATrackHistosGen(copy.fQATrackHistosGen)
567 ,fQAJetHistosRec(copy.fQAJetHistosRec)
568 ,fQAJetHistosRecCuts(copy.fQAJetHistosRecCuts)
569 ,fQAJetHistosRecCutsLeading(copy.fQAJetHistosRecCutsLeading)
570 ,fQAJetHistosGen(copy.fQAJetHistosGen)
571 ,fQAJetHistosGenLeading(copy.fQAJetHistosGenLeading)
572 ,fQAJetHistosRecEffLeading(copy.fQAJetHistosRecEffLeading)
573 ,fFFHistosRecCuts(copy.fFFHistosRecCuts)
574 ,fFFHistosRecCutsInc(copy.fFFHistosRecCutsInc)
575 ,fFFHistosRecLeadingTrack(copy.fFFHistosRecLeadingTrack)
576 ,fFFHistosGen(copy.fFFHistosGen)
577 ,fFFHistosGenInc(copy.fFFHistosGenInc)
578 ,fFFHistosGenLeadingTrack(copy.fFFHistosGenLeadingTrack)
579 ,fQATrackHighPtThreshold(copy.fQATrackHighPtThreshold)
580 ,fFFNBinsJetPt(copy.fFFNBinsJetPt)
581 ,fFFJetPtMin(copy.fFFJetPtMin)
582 ,fFFJetPtMax(copy.fFFJetPtMax)
583 ,fFFNBinsPt(copy.fFFNBinsPt)
584 ,fFFPtMin(copy.fFFPtMin)
585 ,fFFPtMax(copy.fFFPtMax)
586 ,fFFNBinsXi(copy.fFFNBinsXi)
587 ,fFFXiMin(copy.fFFXiMin)
588 ,fFFXiMax(copy.fFFXiMax)
589 ,fFFNBinsZ(copy.fFFNBinsZ)
590 ,fFFZMin(copy.fFFZMin)
591 ,fFFZMax(copy.fFFZMax)
592 ,fQAJetNBinsPt(copy.fQAJetNBinsPt)
593 ,fQAJetPtMin(copy.fQAJetPtMin)
594 ,fQAJetPtMax(copy.fQAJetPtMax)
595 ,fQAJetNBinsEta(copy.fQAJetNBinsEta)
596 ,fQAJetEtaMin(copy.fQAJetEtaMin)
597 ,fQAJetEtaMax(copy.fQAJetEtaMax)
598 ,fQAJetNBinsPhi(copy.fQAJetNBinsPhi)
599 ,fQAJetPhiMin(copy.fQAJetPhiMin)
600 ,fQAJetPhiMax(copy.fQAJetPhiMax)
601 ,fQATrackNBinsPt(copy.fQATrackNBinsPt)
602 ,fQATrackPtMin(copy.fQATrackPtMin)
603 ,fQATrackPtMax(copy.fQATrackPtMax)
604 ,fQATrackNBinsEta(copy.fQATrackNBinsEta)
605 ,fQATrackEtaMin(copy.fQATrackEtaMin)
606 ,fQATrackEtaMax(copy.fQATrackEtaMax)
607 ,fQATrackNBinsPhi(copy.fQATrackNBinsPhi)
608 ,fQATrackPhiMin(copy.fQATrackPhiMin)
609 ,fQATrackPhiMax(copy.fQATrackPhiMax)
610 ,fCommonHistList(copy.fCommonHistList)
611 ,fh1EvtSelection(copy.fh1EvtSelection)
612 ,fh1VertexNContributors(copy.fh1VertexNContributors)
613 ,fh1VertexZ(copy.fh1VertexZ)
614 ,fh1EvtMult(copy.fh1EvtMult)
615 ,fh1EvtCent(copy.fh1EvtCent)
616 ,fh1Xsec(copy.fh1Xsec)
617 ,fh1Trials(copy.fh1Trials)
618 ,fh1PtHard(copy.fh1PtHard)
619 ,fh1PtHardTrials(copy.fh1PtHardTrials)
620 ,fh1nRecJetsCuts(copy.fh1nRecJetsCuts)
621 ,fh1nGenJets(copy.fh1nGenJets)
622 ,fh1nRecEffJets(copy.fh1nRecEffJets)
623 ,fh1nEmbeddedJets(copy.fh1nEmbeddedJets)
624 ,fh1nRecBckgJetsCuts(copy.fh1nRecBckgJetsCuts)
625 ,fh1nGenBckgJets(copy.fh1nGenBckgJets)
626 ,fh2PtRecVsGenPrim(copy.fh2PtRecVsGenPrim)
627 ,fh2PtRecVsGenSec(copy.fh2PtRecVsGenSec)
628 ,fQATrackHistosRecEffGen(copy.fQATrackHistosRecEffGen)
629 ,fQATrackHistosRecEffRec(copy.fQATrackHistosRecEffRec)
630 ,fQATrackHistosSecRecNS(copy.fQATrackHistosSecRecNS)
631 ,fQATrackHistosSecRecS(copy.fQATrackHistosSecRecS)
632 ,fQATrackHistosSecRecSsc(copy.fQATrackHistosSecRecSsc)
633 ,fFFHistosRecEffRec(copy.fFFHistosRecEffRec)
634 ,fFFHistosSecRecNS(copy.fFFHistosSecRecNS)
635 ,fFFHistosSecRecS(copy.fFFHistosSecRecS)
636 ,fFFHistosSecRecSsc(copy.fFFHistosSecRecSsc)
637 // Background
638 ,fh1BckgMult0(copy.fh1BckgMult0)
639 ,fh1BckgMult1(copy.fh1BckgMult1)
640 ,fh1BckgMult2(copy.fh1BckgMult2)
641 ,fh1BckgMult3(copy.fh1BckgMult3)
642 ,fh1BckgMult4(copy.fh1BckgMult4)
643 ,fh1FractionPtEmbedded(copy.fh1FractionPtEmbedded)
644 ,fh1IndexEmbedded(copy.fh1IndexEmbedded)
645 ,fh2DeltaPtVsJetPtEmbedded(copy.fh2DeltaPtVsJetPtEmbedded)
646 ,fh2DeltaPtVsRecJetPtEmbedded(copy.fh2DeltaPtVsRecJetPtEmbedded)
647 ,fh1DeltaREmbedded(copy.fh1DeltaREmbedded)
648 ,fQABckgHisto0RecCuts(copy.fQABckgHisto0RecCuts)
649 ,fQABckgHisto0Gen(copy.fQABckgHisto0Gen)
650 ,fQABckgHisto1RecCuts(copy.fQABckgHisto1RecCuts)
651 ,fQABckgHisto1Gen(copy.fQABckgHisto1Gen)
652 ,fQABckgHisto2RecCuts(copy.fQABckgHisto2RecCuts)
653 ,fQABckgHisto2Gen(copy.fQABckgHisto2Gen)
654 ,fQABckgHisto3RecCuts(copy.fQABckgHisto3RecCuts)
655 ,fQABckgHisto3Gen(copy.fQABckgHisto3Gen)
656 ,fQABckgHisto4RecCuts(copy.fQABckgHisto4RecCuts)
657 ,fQABckgHisto4Gen(copy.fQABckgHisto4Gen)
658 ,fFFBckgHisto0RecCuts(copy.fFFBckgHisto0RecCuts)
659 ,fFFBckgHisto0Gen(copy.fFFBckgHisto0Gen)
660 ,fFFBckgHisto1RecCuts(copy.fFFBckgHisto1RecCuts)
661 ,fFFBckgHisto1Gen(copy.fFFBckgHisto1Gen)
662 ,fFFBckgHisto2RecCuts(copy.fFFBckgHisto2RecCuts)
663 ,fFFBckgHisto2Gen(copy.fFFBckgHisto2Gen)
664 ,fFFBckgHisto3RecCuts(copy.fFFBckgHisto3RecCuts)
665 ,fFFBckgHisto3Gen(copy.fFFBckgHisto3Gen)
666 ,fFFBckgHisto4RecCuts(copy.fFFBckgHisto4RecCuts)
667 ,fFFBckgHisto4Gen(copy.fFFBckgHisto4Gen)
668 ,fFFBckgHisto0RecEffRec(copy.fFFBckgHisto0RecEffRec)
669 ,fFFBckgHisto0SecRecNS(copy.fFFBckgHisto0SecRecNS)
670 ,fFFBckgHisto0SecRecS(copy.fFFBckgHisto0SecRecS)
671 ,fFFBckgHisto0SecRecSsc(copy.fFFBckgHisto0SecRecSsc)
672 // jet shape
673 ,fProNtracksLeadingJet(copy.fProNtracksLeadingJet)
674 ,fProDelR80pcPt(copy.fProDelR80pcPt)
675 ,fProNtracksLeadingJetGen(copy.fProNtracksLeadingJetGen)
676 ,fProDelR80pcPtGen(copy.fProDelR80pcPtGen)
677 ,fProNtracksLeadingJetBgrPerp2(copy.fProNtracksLeadingJetBgrPerp2)
678 ,fProNtracksLeadingJetRecPrim(copy.fProNtracksLeadingJetRecPrim)
679 ,fProDelR80pcPtRecPrim(copy.fProDelR80pcPtRecPrim)
680 ,fProNtracksLeadingJetRecSecNS(copy.fProNtracksLeadingJetRecSecNS)
681 ,fProNtracksLeadingJetRecSecS(copy.fProNtracksLeadingJetRecSecS)
682 ,fProNtracksLeadingJetRecSecSsc(copy.fProNtracksLeadingJetRecSecSsc)
683 ,fRandom(copy.fRandom)
c4856fb1 684 ,fOnlyLeadingJets(copy.fOnlyLeadingJets)
e131b05f 685 // PID framework
686 ,fNumInclusivePIDtasks(copy.fNumInclusivePIDtasks)
687 ,fNumJetPIDtasks(copy.fNumJetPIDtasks)
688 ,fNameInclusivePIDtask(0x0)
689 ,fNameJetPIDtask(0x0)
690 ,fInclusivePIDtask(0x0)
691 ,fJetPIDtask(0x0)
692 ,fUseInclusivePIDtask(copy.fUseInclusivePIDtask)
693 ,fUseJetPIDtask(copy.fUseJetPIDtask)
694 ,fIsPP(copy.fIsPP)
695{
696 // copy constructor
697 fBckgType[0] = copy.fBckgType[0];
698 fBckgType[1] = copy.fBckgType[1];
699 fBckgType[2] = copy.fBckgType[2];
700 fBckgType[3] = copy.fBckgType[3];
701 fBckgType[4] = copy.fBckgType[4];
702
703
704 for(Int_t ii=0; ii<5; ii++){
705 fProDelRPtSum[ii] = copy.fProDelRPtSum[ii];
706 fProDelRPtSumGen[ii] = copy.fProDelRPtSumGen[ii];
707 fProDelRPtSumBgrPerp2[ii] = copy.fProDelRPtSumBgrPerp2[ii];
708 fProDelRPtSumRecPrim[ii] = copy.fProDelRPtSumRecPrim[ii];
709 fProDelRPtSumRecSecNS[ii] = copy.fProDelRPtSumRecSecNS[ii];
710 fProDelRPtSumRecSecS[ii] = copy.fProDelRPtSumRecSecS[ii];
711 fProDelRPtSumRecSecSsc[ii] = copy.fProDelRPtSumRecSecSsc[ii];
712 }
713
714 for (Int_t i = 0; i < AliPID::kSPECIES; i++) {
715 fIDFFHistosRecCuts[i] = 0x0;
716 if (copy.fIDFFHistosRecCuts[i])
717 fIDFFHistosRecCuts[i] = copy.fIDFFHistosRecCuts[i];
718
719 fIDFFHistosGen[i] = 0x0;
720 if (copy.fIDFFHistosGen[i])
721 fIDFFHistosGen[i] = copy.fIDFFHistosGen[i];
722 }
723
724 if (fNumInclusivePIDtasks > 0) {
725 fNameInclusivePIDtask = new TString[fNumInclusivePIDtasks];
726 fInclusivePIDtask = new AliAnalysisTaskPID*[fNumInclusivePIDtasks];
727
728 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
729 fNameInclusivePIDtask[i] = "";
730 fInclusivePIDtask[i] = 0x0;
731
732 if (copy.fNameInclusivePIDtask[i])
733 fNameInclusivePIDtask[i] = copy.fNameInclusivePIDtask[i];
734
735 if (copy.fInclusivePIDtask[i])
736 fInclusivePIDtask[i] = copy.fInclusivePIDtask[i];
737 }
738 }
739
740 if (fNumJetPIDtasks > 0) {
741 fNameJetPIDtask = new TString[fNumJetPIDtasks];
742 fJetPIDtask = new AliAnalysisTaskPID*[fNumJetPIDtasks];
743
744 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
745 fNameJetPIDtask[i] = "";
746 fJetPIDtask[i] = 0x0;
747
748 if (copy.fNameJetPIDtask[i])
749 fNameJetPIDtask[i] = copy.fNameJetPIDtask[i];
750
751 if (copy.fJetPIDtask[i])
752 fJetPIDtask[i] = copy.fJetPIDtask[i];
753 }
754 }
755}
756
757// _________________________________________________________________________________________________________________________________
758AliAnalysisTaskIDFragmentationFunction& AliAnalysisTaskIDFragmentationFunction::operator=(const AliAnalysisTaskIDFragmentationFunction& o)
759{
760 // assignment
761
762 if(this!=&o){
763
764 AliAnalysisTaskSE::operator=(o);
765 fESD = o.fESD;
766 fAOD = o.fAOD;
767 fAODJets = o.fAODJets;
768 fAODExtension = o.fAODExtension;
769 fNonStdFile = o.fNonStdFile;
770 fBranchRecJets = o.fBranchRecJets;
771 fBranchRecBckgClusters = o.fBranchRecBckgClusters;
772 fBranchGenJets = o.fBranchGenJets;
773 fBranchEmbeddedJets = o.fBranchEmbeddedJets;
774 fTrackTypeGen = o.fTrackTypeGen;
775 fJetTypeGen = o.fJetTypeGen;
776 fJetTypeRecEff = o.fJetTypeRecEff;
777 fUseAODInputJets = o.fUseAODInputJets;
778 fFilterMask = o.fFilterMask;
779 fUsePhysicsSelection = o.fUsePhysicsSelection;
780 fEvtSelectionMask = o.fEvtSelectionMask;
781 fEventClass = o.fEventClass;
782 fMaxVertexZ = o.fMaxVertexZ;
783 fTrackPtCut = o.fTrackPtCut;
784 fTrackEtaMin = o.fTrackEtaMin;
785 fTrackEtaMax = o.fTrackEtaMax;
786 fTrackPhiMin = o.fTrackPhiMin;
787 fTrackPhiMax = o.fTrackPhiMax;
788 fUseExtraTracks = o.fUseExtraTracks;
789 fUseExtraTracksBgr = o.fUseExtraTracksBgr;
790 fCutFractionPtEmbedded = o.fCutFractionPtEmbedded;
791 fUseEmbeddedJetAxis = o.fUseEmbeddedJetAxis;
792 fUseEmbeddedJetPt = o.fUseEmbeddedJetPt;
793 fJetPtCut = o.fJetPtCut;
794 fJetEtaMin = o.fJetEtaMin;
795 fJetEtaMax = o.fJetEtaMax;
796 fJetPhiMin = o.fJetPhiMin;
797 fJetPhiMax = o.fJetPhiMin;
798 fFFRadius = o.fFFRadius;
799 fFFMinLTrackPt = o.fFFMinLTrackPt;
800 fFFMaxTrackPt = o.fFFMaxTrackPt;
801 fFFMinnTracks = o.fFFMinnTracks;
802 fFFBckgRadius = o.fFFBckgRadius;
803 fBckgMode = o.fBckgMode;
804 fQAMode = o.fQAMode;
805 fFFMode = o.fFFMode;
806 fIDFFMode = o.fIDFFMode;
807 fEffMode = o.fEffMode;
808 fJSMode = o.fJSMode;
809 fBckgType[0] = o.fBckgType[0];
810 fBckgType[1] = o.fBckgType[1];
811 fBckgType[2] = o.fBckgType[2];
812 fBckgType[3] = o.fBckgType[3];
813 fBckgType[4] = o.fBckgType[4];
814 fAvgTrials = o.fAvgTrials;
815 fTracksRecCuts = o.fTracksRecCuts;
816 fTracksRecCutsEfficiency = o.fTracksRecCutsEfficiency;
817 fTracksGen = o.fTracksGen;
818 fTracksAODMCCharged = o.fTracksAODMCCharged;
819 fTracksAODMCChargedSecNS = o.fTracksAODMCChargedSecNS;
820 fTracksAODMCChargedSecS = o.fTracksAODMCChargedSecS;
821 fTracksRecQualityCuts = o.fTracksRecQualityCuts;
822 fJetsRec = o.fJetsRec;
823 fJetsRecCuts = o.fJetsRecCuts;
824 fJetsGen = o.fJetsGen;
825 fJetsRecEff = o.fJetsRecEff;
826 fJetsEmbedded = o.fJetsEmbedded;
827 fBckgJetsRec = o.fBckgJetsRec;
828 fBckgJetsRecCuts = o.fBckgJetsRecCuts;
829 fBckgJetsGen = o.fBckgJetsGen;
830 fQATrackHistosRecCuts = o.fQATrackHistosRecCuts;
831 fQATrackHistosGen = o.fQATrackHistosGen;
832 fQAJetHistosRec = o.fQAJetHistosRec;
833 fQAJetHistosRecCuts = o.fQAJetHistosRecCuts;
834 fQAJetHistosRecCutsLeading = o.fQAJetHistosRecCutsLeading;
835 fQAJetHistosGen = o.fQAJetHistosGen;
836 fQAJetHistosGenLeading = o.fQAJetHistosGenLeading;
837 fQAJetHistosRecEffLeading = o.fQAJetHistosRecEffLeading;
838 fFFHistosRecCuts = o.fFFHistosRecCuts;
839 fFFHistosRecCutsInc = o.fFFHistosRecCutsInc;
840 fFFHistosRecLeadingTrack = o.fFFHistosRecLeadingTrack;
841 fFFHistosGen = o.fFFHistosGen;
842 fFFHistosGenInc = o.fFFHistosGenInc;
843 fFFHistosGenLeadingTrack = o.fFFHistosGenLeadingTrack;
844 fQATrackHighPtThreshold = o.fQATrackHighPtThreshold;
845 fFFNBinsJetPt = o.fFFNBinsJetPt;
846 fFFJetPtMin = o.fFFJetPtMin;
847 fFFJetPtMax = o.fFFJetPtMax;
848 fFFNBinsPt = o.fFFNBinsPt;
849 fFFPtMin = o.fFFPtMin;
850 fFFPtMax = o.fFFPtMax;
851 fFFNBinsXi = o.fFFNBinsXi;
852 fFFXiMin = o.fFFXiMin;
853 fFFXiMax = o.fFFXiMax;
854 fFFNBinsZ = o.fFFNBinsZ;
855 fFFZMin = o.fFFZMin;
856 fFFZMax = o.fFFZMax;
857 fQAJetNBinsPt = o.fQAJetNBinsPt;
858 fQAJetPtMin = o.fQAJetPtMin;
859 fQAJetPtMax = o.fQAJetPtMax;
860 fQAJetNBinsEta = o.fQAJetNBinsEta;
861 fQAJetEtaMin = o.fQAJetEtaMin;
862 fQAJetEtaMax = o.fQAJetEtaMax;
863 fQAJetNBinsPhi = o.fQAJetNBinsPhi;
864 fQAJetPhiMin = o.fQAJetPhiMin;
865 fQAJetPhiMax = o.fQAJetPhiMax;
866 fQATrackNBinsPt = o.fQATrackNBinsPt;
867 fQATrackPtMin = o.fQATrackPtMin;
868 fQATrackPtMax = o.fQATrackPtMax;
869 fQATrackNBinsEta = o.fQATrackNBinsEta;
870 fQATrackEtaMin = o.fQATrackEtaMin;
871 fQATrackEtaMax = o.fQATrackEtaMax;
872 fQATrackNBinsPhi = o.fQATrackNBinsPhi;
873 fQATrackPhiMin = o.fQATrackPhiMin;
874 fQATrackPhiMax = o.fQATrackPhiMax;
875 fCommonHistList = o.fCommonHistList;
876 fh1EvtSelection = o.fh1EvtSelection;
877 fh1VertexNContributors = o.fh1VertexNContributors;
878 fh1VertexZ = o.fh1VertexZ;
879 fh1EvtMult = o.fh1EvtMult;
880 fh1EvtCent = o.fh1EvtCent;
881 fh1Xsec = o.fh1Xsec;
882 fh1Trials = o.fh1Trials;
883 fh1PtHard = o.fh1PtHard;
884 fh1PtHardTrials = o.fh1PtHardTrials;
885 fh1nRecJetsCuts = o.fh1nRecJetsCuts;
886 fh1nGenJets = o.fh1nGenJets;
887 fh1nRecEffJets = o.fh1nRecEffJets;
888 fh1nEmbeddedJets = o.fh1nEmbeddedJets;
889 fh2PtRecVsGenPrim = o.fh2PtRecVsGenPrim;
890 fh2PtRecVsGenSec = o.fh2PtRecVsGenSec;
891 fQATrackHistosRecEffGen = o.fQATrackHistosRecEffGen;
892 fQATrackHistosRecEffRec = o.fQATrackHistosRecEffRec;
893 fQATrackHistosSecRecNS = o.fQATrackHistosSecRecNS;
894 fQATrackHistosSecRecS = o.fQATrackHistosSecRecS;
895 fQATrackHistosSecRecSsc = o.fQATrackHistosSecRecSsc;
896 fFFHistosRecEffRec = o.fFFHistosRecEffRec;
897 fFFHistosSecRecNS = o.fFFHistosSecRecNS;
898 fFFHistosSecRecS = o.fFFHistosSecRecS;
899 fFFHistosSecRecSsc = o.fFFHistosSecRecSsc;
900 // Background
901 fh1BckgMult0 = o.fh1BckgMult0;
902 fh1BckgMult1 = o.fh1BckgMult1;
903 fh1BckgMult2 = o.fh1BckgMult2;
904 fh1BckgMult3 = o.fh1BckgMult3;
905 fh1BckgMult4 = o.fh1BckgMult4;
906 fh1FractionPtEmbedded = o.fh1FractionPtEmbedded;
907 fh1IndexEmbedded = o.fh1IndexEmbedded;
908 fh2DeltaPtVsJetPtEmbedded = o.fh2DeltaPtVsJetPtEmbedded;
909 fh2DeltaPtVsRecJetPtEmbedded = o.fh2DeltaPtVsRecJetPtEmbedded;
910 fh1DeltaREmbedded = o.fh1DeltaREmbedded;
911 fQABckgHisto0RecCuts = o.fQABckgHisto0RecCuts;
912 fQABckgHisto0Gen = o.fQABckgHisto0Gen;
913 fQABckgHisto1RecCuts = o.fQABckgHisto1RecCuts;
914 fQABckgHisto1Gen = o.fQABckgHisto1Gen;
915 fQABckgHisto2RecCuts = o.fQABckgHisto2RecCuts;
916 fQABckgHisto2Gen = o.fQABckgHisto2Gen;
917 fQABckgHisto3RecCuts = o.fQABckgHisto3RecCuts;
918 fQABckgHisto3Gen = o.fQABckgHisto3Gen;
919 fQABckgHisto4RecCuts = o.fQABckgHisto4RecCuts;
920 fQABckgHisto4Gen = o.fQABckgHisto4Gen;
921 fFFBckgHisto0RecCuts = o.fFFBckgHisto0RecCuts;
922 fFFBckgHisto0Gen = o.fFFBckgHisto0Gen;
923 fFFBckgHisto1RecCuts = o.fFFBckgHisto1RecCuts;
924 fFFBckgHisto1Gen = o.fFFBckgHisto1Gen;
925 fFFBckgHisto2RecCuts = o.fFFBckgHisto2RecCuts;
926 fFFBckgHisto2Gen = o.fFFBckgHisto2Gen;
927 fFFBckgHisto3RecCuts = o.fFFBckgHisto3RecCuts;
928 fFFBckgHisto3Gen = o.fFFBckgHisto3Gen;
929 fFFBckgHisto4RecCuts = o.fFFBckgHisto4RecCuts;
930 fFFBckgHisto4Gen = o.fFFBckgHisto4Gen;
931 fFFBckgHisto0RecEffRec = o.fFFBckgHisto0RecEffRec;
932 fFFBckgHisto0SecRecNS = o.fFFBckgHisto0SecRecNS;
933 fFFBckgHisto0SecRecS = o.fFFBckgHisto0SecRecS;
934 fFFBckgHisto0SecRecSsc = o.fFFBckgHisto0SecRecSsc;
935 fProNtracksLeadingJet = o.fProNtracksLeadingJet;
936 fProDelR80pcPt = o.fProDelR80pcPt;
937 fProNtracksLeadingJetGen = o.fProNtracksLeadingJetGen;
938 fProDelR80pcPtGen = o.fProDelR80pcPtGen;
939 fProNtracksLeadingJetBgrPerp2 = o.fProNtracksLeadingJetBgrPerp2;
940 fProNtracksLeadingJetRecPrim = o.fProNtracksLeadingJetRecPrim;
941 fProDelR80pcPtRecPrim = o.fProDelR80pcPtRecPrim;
942 fProNtracksLeadingJetRecSecNS = o.fProNtracksLeadingJetRecSecNS;
943 fProNtracksLeadingJetRecSecS = o.fProNtracksLeadingJetRecSecS;
944 fProNtracksLeadingJetRecSecSsc = o.fProNtracksLeadingJetRecSecSsc;
945 fRandom = o.fRandom;
c4856fb1 946 fOnlyLeadingJets = o.fOnlyLeadingJets;
e131b05f 947
948 // PID framework
949 fUseInclusivePIDtask = o.fUseInclusivePIDtask;
950 fUseJetPIDtask = o.fUseJetPIDtask;
951
952 fIsPP = o.fIsPP;
953
954 for(Int_t ii=0; ii<5; ii++){
955 fProDelRPtSum[ii] = o.fProDelRPtSum[ii];
956 fProDelRPtSumGen[ii] = o.fProDelRPtSumGen[ii];
957 fProDelRPtSumBgrPerp2[ii] = o.fProDelRPtSumBgrPerp2[ii];
958 fProDelRPtSumRecPrim[ii] = o.fProDelRPtSumRecPrim[ii];
959 fProDelRPtSumRecSecNS[ii] = o.fProDelRPtSumRecSecNS[ii];
960 fProDelRPtSumRecSecS[ii] = o.fProDelRPtSumRecSecS[ii];
961 fProDelRPtSumRecSecSsc[ii] = o.fProDelRPtSumRecSecSsc[ii];
962 }
963
964 for (Int_t i = 0; i < AliPID::kSPECIES; i++) {
965 fIDFFHistosRecCuts[i] = 0x0;
966 if (o.fIDFFHistosRecCuts[i])
967 fIDFFHistosRecCuts[i] = o.fIDFFHistosRecCuts[i];
968
969 fIDFFHistosGen[i] = 0x0;
970 if (o.fIDFFHistosGen[i])
971 fIDFFHistosGen[i] = o.fIDFFHistosGen[i];
972 }
973 }
974
975
976 if (fNumJetPIDtasks > 0) {
977 delete [] fNameJetPIDtask;
978 fNameJetPIDtask = 0x0;
979
980 delete [] fJetPIDtask;
981 fJetPIDtask = 0x0;
982 }
983
984 fNumJetPIDtasks = o.fNumJetPIDtasks;
985
986
987 if (fNumInclusivePIDtasks > 0) {
988 delete [] fNameInclusivePIDtask;
989 fNameInclusivePIDtask = 0x0;
990
991 delete [] fInclusivePIDtask;
992 fInclusivePIDtask = 0x0;
993 }
994
995 fNumInclusivePIDtasks = o.fNumInclusivePIDtasks;
996
997
998 if (fNumInclusivePIDtasks > 0) {
999 fNameInclusivePIDtask = new TString[fNumInclusivePIDtasks];
1000 fInclusivePIDtask = new AliAnalysisTaskPID*[fNumInclusivePIDtasks];
1001
1002 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
1003 fNameInclusivePIDtask[i] = "";
1004 fInclusivePIDtask[i] = 0x0;
1005
1006 if (o.fNameInclusivePIDtask[i])
1007 fNameInclusivePIDtask[i] = o.fNameInclusivePIDtask[i];
1008
1009 if (o.fInclusivePIDtask[i])
1010 fInclusivePIDtask[i] = o.fInclusivePIDtask[i];
1011 }
1012 }
1013
1014 if (fNumJetPIDtasks > 0) {
1015 fNameJetPIDtask = new TString[fNumJetPIDtasks];
1016 fJetPIDtask = new AliAnalysisTaskPID*[fNumJetPIDtasks];
1017
1018 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
1019 fNameJetPIDtask[i] = "";
1020 fJetPIDtask[i] = 0x0;
1021
1022 if (o.fNameJetPIDtask[i])
1023 fNameJetPIDtask[i] = o.fNameJetPIDtask[i];
1024
1025 if (o.fJetPIDtask[i])
1026 fJetPIDtask[i] = o.fJetPIDtask[i];
1027 }
1028 }
1029
1030 return *this;
1031}
1032
1033//___________________________________________________________________________
1034AliAnalysisTaskIDFragmentationFunction::~AliAnalysisTaskIDFragmentationFunction()
1035{
1036 // destructor
1037
1038 if(fTracksRecCuts) delete fTracksRecCuts;
1039 if(fTracksRecCutsEfficiency) delete fTracksRecCutsEfficiency;
1040 if(fTracksGen) delete fTracksGen;
1041 if(fTracksAODMCCharged) delete fTracksAODMCCharged;
1042 if(fTracksAODMCChargedSecNS) delete fTracksAODMCChargedSecNS;
1043 if(fTracksAODMCChargedSecS) delete fTracksAODMCChargedSecS;
1044 if(fTracksRecQualityCuts) delete fTracksRecQualityCuts;
1045 if(fJetsRec) delete fJetsRec;
1046 if(fJetsRecCuts) delete fJetsRecCuts;
1047 if(fJetsGen) delete fJetsGen;
1048 if(fJetsRecEff) delete fJetsRecEff;
1049 if(fJetsEmbedded) delete fJetsEmbedded;
1050
1051 if(fBckgMode &&
1052 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
1053 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
1054 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)){
1055
1056 if(fBckgJetsRec) delete fBckgJetsRec;
1057 if(fBckgJetsRecCuts) delete fBckgJetsRecCuts;
1058 if(fBckgJetsGen) delete fBckgJetsGen;
1059 }
1060 if(fRandom) delete fRandom;
1061
1062 delete [] fNameInclusivePIDtask;
1063 fNameInclusivePIDtask = 0x0;
1064
1065 delete [] fInclusivePIDtask;
1066 fInclusivePIDtask = 0x0;
1067
1068 delete [] fNameJetPIDtask;
1069 fNameJetPIDtask = 0x0;
1070
1071 delete [] fJetPIDtask;
1072 fJetPIDtask = 0x0;
1073}
1074
1075//______________________________________________________________________________________________________
1076AliAnalysisTaskIDFragmentationFunction::AliFragFuncHistos::AliFragFuncHistos(const char* name,
1077 Int_t nJetPt, Float_t jetPtMin, Float_t jetPtMax,
1078 Int_t nPt, Float_t ptMin, Float_t ptMax,
1079 Int_t nXi, Float_t xiMin, Float_t xiMax,
1080 Int_t nZ , Float_t zMin , Float_t zMax)
1081 : TObject()
1082 ,fNBinsJetPt(nJetPt)
1083 ,fJetPtMin(jetPtMin)
1084 ,fJetPtMax(jetPtMax)
1085 ,fNBinsPt(nPt)
1086 ,fPtMin(ptMin)
1087 ,fPtMax(ptMax)
1088 ,fNBinsXi(nXi)
1089 ,fXiMin(xiMin)
1090 ,fXiMax(xiMax)
1091 ,fNBinsZ(nZ)
1092 ,fZMin(zMin)
1093 ,fZMax(zMax)
1094 ,fh2TrackPt(0)
1095 ,fh2Xi(0)
1096 ,fh2Z(0)
1097 ,fh1JetPt(0)
1098 ,fNameFF(name)
1099{
1100 // default constructor
1101
1102}
1103
1104//___________________________________________________________________________
1105AliAnalysisTaskIDFragmentationFunction::AliFragFuncHistos::AliFragFuncHistos(const AliFragFuncHistos& copy)
1106 : TObject()
1107 ,fNBinsJetPt(copy.fNBinsJetPt)
1108 ,fJetPtMin(copy.fJetPtMin)
1109 ,fJetPtMax(copy.fJetPtMax)
1110 ,fNBinsPt(copy.fNBinsPt)
1111 ,fPtMin(copy.fPtMin)
1112 ,fPtMax(copy.fPtMax)
1113 ,fNBinsXi(copy.fNBinsXi)
1114 ,fXiMin(copy.fXiMin)
1115 ,fXiMax(copy.fXiMax)
1116 ,fNBinsZ(copy.fNBinsZ)
1117 ,fZMin(copy.fZMin)
1118 ,fZMax(copy.fZMax)
1119 ,fh2TrackPt(copy.fh2TrackPt)
1120 ,fh2Xi(copy.fh2Xi)
1121 ,fh2Z(copy.fh2Z)
1122 ,fh1JetPt(copy.fh1JetPt)
1123 ,fNameFF(copy.fNameFF)
1124{
1125 // copy constructor
1126}
1127
1128//_______________________________________________________________________________________________________________________________________________________________
1129AliAnalysisTaskIDFragmentationFunction::AliFragFuncHistos& AliAnalysisTaskIDFragmentationFunction::AliFragFuncHistos::operator=(const AliAnalysisTaskIDFragmentationFunction::AliFragFuncHistos& o)
1130{
1131 // assignment
1132
1133 if(this!=&o){
1134 TObject::operator=(o);
1135 fNBinsJetPt = o.fNBinsJetPt;
1136 fJetPtMin = o.fJetPtMin;
1137 fJetPtMax = o.fJetPtMax;
1138 fNBinsPt = o.fNBinsPt;
1139 fPtMin = o.fPtMin;
1140 fPtMax = o.fPtMax;
1141 fNBinsXi = o.fNBinsXi;
1142 fXiMin = o.fXiMin;
1143 fXiMax = o.fXiMax;
1144 fNBinsZ = o.fNBinsZ;
1145 fZMin = o.fZMin;
1146 fZMax = o.fZMax;
1147 fh2TrackPt = o.fh2TrackPt;
1148 fh2Xi = o.fh2Xi;
1149 fh2Z = o.fh2Z;
1150 fh1JetPt = o.fh1JetPt;
1151 fNameFF = o.fNameFF;
1152 }
1153
1154 return *this;
1155}
1156
1157//_________________________________________________________
1158AliAnalysisTaskIDFragmentationFunction::AliFragFuncHistos::~AliFragFuncHistos()
1159{
1160 // destructor
1161
1162 if(fh1JetPt) delete fh1JetPt;
1163 if(fh2TrackPt) delete fh2TrackPt;
1164 if(fh2Xi) delete fh2Xi;
1165 if(fh2Z) delete fh2Z;
1166}
1167
1168//_________________________________________________________________
1169void AliAnalysisTaskIDFragmentationFunction::AliFragFuncHistos::DefineHistos()
1170{
1171 // book FF histos
1172
1173 fh1JetPt = new TH1F(Form("fh1FFJetPt%s", fNameFF.Data()),"",fNBinsJetPt,fJetPtMin,fJetPtMax);
1174 fh2TrackPt = new TH2F(Form("fh2FFTrackPt%s",fNameFF.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax,fNBinsPt, fPtMin, fPtMax);
1175 fh2Z = new TH2F(Form("fh2FFZ%s",fNameFF.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax, fNBinsZ, fZMin, fZMax);
1176 fh2Xi = new TH2F(Form("fh2FFXi%s",fNameFF.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax, fNBinsXi, fXiMin, fXiMax);
1177
1178 AliAnalysisTaskIDFragmentationFunction::SetProperties(fh1JetPt, "p_{T} [GeV/c]", "entries");
1179 AliAnalysisTaskIDFragmentationFunction::SetProperties(fh2TrackPt,"jet p_{T} [GeV/c]","p_{T} [GeV/c]","entries");
1180 AliAnalysisTaskIDFragmentationFunction::SetProperties(fh2Xi,"jet p_{T} [GeV/c]","#xi", "entries");
1181 AliAnalysisTaskIDFragmentationFunction::SetProperties(fh2Z,"jet p_{T} [GeV/c]","z","entries");
1182}
1183
1184//_______________________________________________________________________________________________________________
1185void AliAnalysisTaskIDFragmentationFunction::AliFragFuncHistos::FillFF(Float_t trackPt, Float_t jetPt, Bool_t incrementJetPt, Float_t norm,
1186 Bool_t scaleStrangeness, Float_t scaleFacStrangeness)
1187{
1188 // fill FF
1189
1190 if(incrementJetPt && norm) fh1JetPt->Fill(jetPt,1/norm);
1191 else if(incrementJetPt) fh1JetPt->Fill(jetPt);
1192
1193 // Added for proper normalization of FF background estimation
1194 // when zero track are found in the background region
1195 if((int)trackPt==-1) return;
1196
1197 if(norm)fh2TrackPt->Fill(jetPt,trackPt,1/norm);
1198 else if(scaleStrangeness) fh2TrackPt->Fill(jetPt,trackPt,scaleFacStrangeness);
1199 else fh2TrackPt->Fill(jetPt,trackPt);
1200
1201 Double_t z = -1., xi = -1.;
1202 AliAnalysisTaskPID::GetJetTrackObservables(trackPt, jetPt, z, xi);
1203
1204
1205 if(norm){
1206 fh2Xi->Fill(jetPt,xi,1/norm);
1207 fh2Z->Fill(jetPt,z,1/norm);
1208 }
1209 else if(scaleStrangeness){
1210 fh2Xi->Fill(jetPt,xi,scaleFacStrangeness);
1211 fh2Z->Fill(jetPt,z,scaleFacStrangeness);
1212 }
1213 else {
1214 fh2Xi->Fill(jetPt,xi);
1215 fh2Z->Fill(jetPt,z);
1216 }
1217}
1218
1219//_________________________________________________________________________________
1220void AliAnalysisTaskIDFragmentationFunction::AliFragFuncHistos::AddToOutput(TList* list) const
1221{
1222 // add histos to list
1223
1224 list->Add(fh1JetPt);
1225
1226 list->Add(fh2TrackPt);
1227 list->Add(fh2Xi);
1228 list->Add(fh2Z);
1229}
1230
1231//_________________________________________________________________________________________________________
1232AliAnalysisTaskIDFragmentationFunction::AliFragFuncQAJetHistos::AliFragFuncQAJetHistos(const char* name,
1233 Int_t nPt, Float_t ptMin, Float_t ptMax,
1234 Int_t nEta, Float_t etaMin, Float_t etaMax,
1235 Int_t nPhi, Float_t phiMin, Float_t phiMax)
1236 : TObject()
1237 ,fNBinsPt(nPt)
1238 ,fPtMin(ptMin)
1239 ,fPtMax(ptMax)
1240 ,fNBinsEta(nEta)
1241 ,fEtaMin(etaMin)
1242 ,fEtaMax(etaMax)
1243 ,fNBinsPhi(nPhi)
1244 ,fPhiMin(phiMin)
1245 ,fPhiMax(phiMax)
1246 ,fh2EtaPhi(0)
1247 ,fh1Pt(0)
1248 ,fNameQAJ(name)
1249{
1250 // default constructor
1251}
1252
1253//____________________________________________________________________________________
1254AliAnalysisTaskIDFragmentationFunction::AliFragFuncQAJetHistos::AliFragFuncQAJetHistos(const AliFragFuncQAJetHistos& copy)
1255 : TObject()
1256 ,fNBinsPt(copy.fNBinsPt)
1257 ,fPtMin(copy.fPtMin)
1258 ,fPtMax(copy.fPtMax)
1259 ,fNBinsEta(copy.fNBinsEta)
1260 ,fEtaMin(copy.fEtaMin)
1261 ,fEtaMax(copy.fEtaMax)
1262 ,fNBinsPhi(copy.fNBinsPhi)
1263 ,fPhiMin(copy.fPhiMin)
1264 ,fPhiMax(copy.fPhiMax)
1265 ,fh2EtaPhi(copy.fh2EtaPhi)
1266 ,fh1Pt(copy.fh1Pt)
1267 ,fNameQAJ(copy.fNameQAJ)
1268{
1269 // copy constructor
1270}
1271
1272//________________________________________________________________________________________________________________________________________________________________________
1273AliAnalysisTaskIDFragmentationFunction::AliFragFuncQAJetHistos& AliAnalysisTaskIDFragmentationFunction::AliFragFuncQAJetHistos::operator=(const AliAnalysisTaskIDFragmentationFunction::AliFragFuncQAJetHistos& o)
1274{
1275 // assignment
1276
1277 if(this!=&o){
1278 TObject::operator=(o);
1279 fNBinsPt = o.fNBinsPt;
1280 fPtMin = o.fPtMin;
1281 fPtMax = o.fPtMax;
1282 fNBinsEta = o.fNBinsEta;
1283 fEtaMin = o.fEtaMin;
1284 fEtaMax = o.fEtaMax;
1285 fNBinsPhi = o.fNBinsPhi;
1286 fPhiMin = o.fPhiMin;
1287 fPhiMax = o.fPhiMax;
1288 fh2EtaPhi = o.fh2EtaPhi;
1289 fh1Pt = o.fh1Pt;
1290 fNameQAJ = o.fNameQAJ;
1291 }
1292
1293 return *this;
1294}
1295
1296//______________________________________________________________
1297AliAnalysisTaskIDFragmentationFunction::AliFragFuncQAJetHistos::~AliFragFuncQAJetHistos()
1298{
1299 // destructor
1300
1301 if(fh2EtaPhi) delete fh2EtaPhi;
1302 if(fh1Pt) delete fh1Pt;
1303}
1304
1305//____________________________________________________________________
1306void AliAnalysisTaskIDFragmentationFunction::AliFragFuncQAJetHistos::DefineHistos()
1307{
1308 // book jet QA histos
1309
1310 fh2EtaPhi = new TH2F(Form("fh2JetQAEtaPhi%s", fNameQAJ.Data()), Form("%s: #eta - #phi distribution", fNameQAJ.Data()), fNBinsEta, fEtaMin, fEtaMax, fNBinsPhi, fPhiMin, fPhiMax);
1311 fh1Pt = new TH1F(Form("fh1JetQAPt%s", fNameQAJ.Data()), Form("%s: p_{T} distribution", fNameQAJ.Data()), fNBinsPt, fPtMin, fPtMax);
1312
1313 AliAnalysisTaskIDFragmentationFunction::SetProperties(fh2EtaPhi, "#eta", "#phi");
1314 AliAnalysisTaskIDFragmentationFunction::SetProperties(fh1Pt, "p_{T} [GeV/c]", "entries");
1315}
1316
1317//____________________________________________________________________________________________________
1318void AliAnalysisTaskIDFragmentationFunction::AliFragFuncQAJetHistos::FillJetQA(Float_t eta, Float_t phi, Float_t pt)
1319{
1320 // fill jet QA histos
1321
1322 fh2EtaPhi->Fill( eta, phi);
1323 fh1Pt->Fill( pt );
1324}
1325
1326//____________________________________________________________________________________
1327void AliAnalysisTaskIDFragmentationFunction::AliFragFuncQAJetHistos::AddToOutput(TList* list) const
1328{
1329 // add histos to list
1330
1331 list->Add(fh2EtaPhi);
1332 list->Add(fh1Pt);
1333}
1334
1335//___________________________________________________________________________________________________________
1336AliAnalysisTaskIDFragmentationFunction::AliFragFuncQATrackHistos::AliFragFuncQATrackHistos(const char* name,
1337 Int_t nPt, Float_t ptMin, Float_t ptMax,
1338 Int_t nEta, Float_t etaMin, Float_t etaMax,
1339 Int_t nPhi, Float_t phiMin, Float_t phiMax,
1340 Float_t ptThresh)
1341 : TObject()
1342 ,fNBinsPt(nPt)
1343 ,fPtMin(ptMin)
1344 ,fPtMax(ptMax)
1345 ,fNBinsEta(nEta)
1346 ,fEtaMin(etaMin)
1347 ,fEtaMax(etaMax)
1348 ,fNBinsPhi(nPhi)
1349 ,fPhiMin(phiMin)
1350 ,fPhiMax(phiMax)
1351 ,fHighPtThreshold(ptThresh)
1352 ,fh2EtaPhi(0)
1353 ,fh1Pt(0)
1354 ,fh2HighPtEtaPhi(0)
1355 ,fh2PhiPt(0)
1356 ,fNameQAT(name)
1357{
1358 // default constructor
1359}
1360
1361//__________________________________________________________________________________________
1362AliAnalysisTaskIDFragmentationFunction::AliFragFuncQATrackHistos::AliFragFuncQATrackHistos(const AliFragFuncQATrackHistos& copy)
1363 : TObject()
1364 ,fNBinsPt(copy.fNBinsPt)
1365 ,fPtMin(copy.fPtMin)
1366 ,fPtMax(copy.fPtMax)
1367 ,fNBinsEta(copy.fNBinsEta)
1368 ,fEtaMin(copy.fEtaMin)
1369 ,fEtaMax(copy.fEtaMax)
1370 ,fNBinsPhi(copy.fNBinsPhi)
1371 ,fPhiMin(copy.fPhiMin)
1372 ,fPhiMax(copy.fPhiMax)
1373 ,fHighPtThreshold(copy.fHighPtThreshold)
1374 ,fh2EtaPhi(copy.fh2EtaPhi)
1375 ,fh1Pt(copy.fh1Pt)
1376 ,fh2HighPtEtaPhi(copy.fh2HighPtEtaPhi)
1377 ,fh2PhiPt(copy.fh2PhiPt)
1378 ,fNameQAT(copy.fNameQAT)
1379{
1380 // copy constructor
1381}
1382
1383// _____________________________________________________________________________________________________________________________________________________________________________
1384AliAnalysisTaskIDFragmentationFunction::AliFragFuncQATrackHistos& AliAnalysisTaskIDFragmentationFunction::AliFragFuncQATrackHistos::operator=(const AliAnalysisTaskIDFragmentationFunction::AliFragFuncQATrackHistos& o)
1385{
1386 // assignment
1387
1388 if(this!=&o){
1389 TObject::operator=(o);
1390 fNBinsPt = o.fNBinsPt;
1391 fPtMin = o.fPtMin;
1392 fPtMax = o.fPtMax;
1393 fNBinsEta = o.fNBinsEta;
1394 fEtaMin = o.fEtaMin;
1395 fEtaMax = o.fEtaMax;
1396 fNBinsPhi = o.fNBinsPhi;
1397 fPhiMin = o.fPhiMin;
1398 fPhiMax = o.fPhiMax;
1399 fHighPtThreshold = o.fHighPtThreshold;
1400 fh2EtaPhi = o.fh2EtaPhi;
1401 fh1Pt = o.fh1Pt;
1402 fh2HighPtEtaPhi = o.fh2HighPtEtaPhi;
1403 fh2PhiPt = o.fh2PhiPt;
1404 fNameQAT = o.fNameQAT;
1405 }
1406
1407 return *this;
1408}
1409
1410//___________________________________________________________________
1411AliAnalysisTaskIDFragmentationFunction::AliFragFuncQATrackHistos::~AliFragFuncQATrackHistos()
1412{
1413 // destructor
1414
1415 if(fh2EtaPhi) delete fh2EtaPhi;
1416 if(fh2HighPtEtaPhi) delete fh2HighPtEtaPhi;
1417 if(fh1Pt) delete fh1Pt;
1418 if(fh2PhiPt) delete fh2PhiPt;
1419}
1420
1421//______________________________________________________________________
1422void AliAnalysisTaskIDFragmentationFunction::AliFragFuncQATrackHistos::DefineHistos()
1423{
1424 // book track QA histos
1425
1426 fh2EtaPhi = new TH2F(Form("fh2TrackQAEtaPhi%s", fNameQAT.Data()), Form("%s: #eta - #phi distribution", fNameQAT.Data()), fNBinsEta, fEtaMin, fEtaMax, fNBinsPhi, fPhiMin, fPhiMax);
1427 fh2HighPtEtaPhi = new TH2F(Form("fh2TrackQAHighPtEtaPhi%s", fNameQAT.Data()), Form("%s: #eta - #phi distribution for high-p_{T}", fNameQAT.Data()), fNBinsEta, fEtaMin, fEtaMax, fNBinsPhi, fPhiMin, fPhiMax);
1428 fh1Pt = new TH1F(Form("fh1TrackQAPt%s", fNameQAT.Data()), Form("%s: p_{T} distribution", fNameQAT.Data()), fNBinsPt, fPtMin, fPtMax);
1429 fh2PhiPt = new TH2F(Form("fh2TrackQAPhiPt%s", fNameQAT.Data()), Form("%s: #phi - p_{T} distribution", fNameQAT.Data()), fNBinsPhi, fPhiMin, fPhiMax, fNBinsPt, fPtMin, fPtMax);
1430
1431 AliAnalysisTaskIDFragmentationFunction::SetProperties(fh2EtaPhi, "#eta", "#phi");
1432 AliAnalysisTaskIDFragmentationFunction::SetProperties(fh2HighPtEtaPhi, "#eta", "#phi");
1433 AliAnalysisTaskIDFragmentationFunction::SetProperties(fh1Pt, "p_{T} [GeV/c]", "entries");
1434 AliAnalysisTaskIDFragmentationFunction::SetProperties(fh2PhiPt, "#phi", "p_{T} [GeV/c]");
1435}
1436
1437//________________________________________________________________________________________________________
1438void AliAnalysisTaskIDFragmentationFunction::AliFragFuncQATrackHistos::FillTrackQA(Float_t eta, Float_t phi, Float_t pt, Bool_t weightPt, Float_t norm,
1439 Bool_t scaleStrangeness, Float_t scaleFacStrangeness)
1440{
1441 // fill track QA histos
1442 Float_t weight = 1.;
1443 if(weightPt) weight = pt;
1444 fh2EtaPhi->Fill( eta, phi, weight);
1445 if(scaleStrangeness) fh2EtaPhi->Fill( eta, phi, scaleFacStrangeness);
1446 if(pt > fHighPtThreshold) fh2HighPtEtaPhi->Fill( eta, phi, weight);
1447 if(pt > fHighPtThreshold && scaleStrangeness) fh2HighPtEtaPhi->Fill( eta, phi, weight);
1448 if(norm) fh1Pt->Fill( pt, 1/norm );
1449 else if(scaleStrangeness) fh1Pt->Fill(pt,scaleFacStrangeness);
1450 else fh1Pt->Fill( pt );
1451
1452 if(scaleFacStrangeness) fh2PhiPt->Fill(phi, pt, scaleFacStrangeness);
1453 else fh2PhiPt->Fill(phi, pt);
1454}
1455
1456//______________________________________________________________________________________
1457void AliAnalysisTaskIDFragmentationFunction::AliFragFuncQATrackHistos::AddToOutput(TList* list) const
1458{
1459 // add histos to list
1460
1461 list->Add(fh2EtaPhi);
1462 list->Add(fh2HighPtEtaPhi);
1463 list->Add(fh1Pt);
1464 list->Add(fh2PhiPt);
1465}
1466
1467//_________________________________________________________________________________
1468Bool_t AliAnalysisTaskIDFragmentationFunction::Notify()
1469{
1470 //
1471 // Implemented Notify() to read the cross sections
1472 // and number of trials from pyxsec.root
1473 // (taken from AliAnalysisTaskJetSpectrum2)
1474 //
1475 TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
1476 Float_t xsection = 0;
1477 Float_t ftrials = 1;
1478
1479 fAvgTrials = 1;
1480 if(tree){
1481 TFile *curfile = tree->GetCurrentFile();
1482 if (!curfile) {
1483 Error("Notify","No current file");
1484 return kFALSE;
1485 }
1486
1487 AliAnalysisHelperJetTasks::PythiaInfoFromFile(curfile->GetName(),xsection,ftrials);
1488
1489 if (fUseInclusivePIDtask) {
1490 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
1491 fInclusivePIDtask[i]->FillXsec(xsection);
1492 }
1493
1494 if (fUseJetPIDtask) {
1495 for (Int_t i = 0; i < fNumJetPIDtasks; i++)
1496 fJetPIDtask[i]->FillXsec(xsection);
1497 }
1498
1499 if(!fh1Xsec||!fh1Trials){
9e95a906 1500 Printf("%s:%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__);
e131b05f 1501 return kFALSE;
1502 }
1503
1504 fh1Xsec->Fill("<#sigma>",xsection);
1505 // construct a poor man average trials
1506 Float_t nEntries = (Float_t)tree->GetTree()->GetEntries();
1507 if(ftrials>=nEntries && nEntries>0.)fAvgTrials = ftrials/nEntries;
1508 }
1509
1510 // Set seed for backg study
9d7ad2e4 1511 delete fRandom;
e131b05f 1512 fRandom = new TRandom3();
1513 fRandom->SetSeed(0);
1514
1515 return kTRUE;
1516}
1517
1518//__________________________________________________________________
1519void AliAnalysisTaskIDFragmentationFunction::UserCreateOutputObjects()
1520{
1521 // create output objects
1522
1523 if(fDebug > 1) Printf("AliAnalysisTaskIDFragmentationFunction::UserCreateOutputObjects()");
1524
1525 // create list of tracks and jets
1526
1527 fTracksRecCuts = new TList();
1528 fTracksRecCuts->SetOwner(kFALSE);
1529
1530 fTracksRecCutsEfficiency = new TList();
1531 fTracksRecCutsEfficiency->SetOwner(kFALSE);
1532
1533 fTracksGen = new TList();
1534 fTracksGen->SetOwner(kFALSE);
1535
1536 fTracksAODMCCharged = new TList();
1537 fTracksAODMCCharged->SetOwner(kFALSE);
1538
1539 fTracksAODMCChargedSecNS = new TList();
1540 fTracksAODMCChargedSecNS->SetOwner(kFALSE);
1541
1542 fTracksAODMCChargedSecS = new TList();
1543 fTracksAODMCChargedSecS->SetOwner(kFALSE);
1544
1545 fTracksRecQualityCuts = new TList();
1546 fTracksRecQualityCuts->SetOwner(kFALSE);
1547
1548 fJetsRec = new TList();
1549 fJetsRec->SetOwner(kFALSE);
1550
1551 fJetsRecCuts = new TList();
1552 fJetsRecCuts->SetOwner(kFALSE);
1553
1554 fJetsGen = new TList();
1555 fJetsGen->SetOwner(kFALSE);
1556
1557 fJetsRecEff = new TList();
1558 fJetsRecEff->SetOwner(kFALSE);
1559
1560 fJetsEmbedded = new TList();
1561 fJetsEmbedded->SetOwner(kFALSE);
1562
1563
1564 if(fBckgMode &&
1565 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
1566 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
1567 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)){
1568
1569 fBckgJetsRec = new TList();
1570 fBckgJetsRec->SetOwner(kFALSE);
1571
1572 fBckgJetsRecCuts = new TList();
1573 fBckgJetsRecCuts->SetOwner(kFALSE);
1574
1575 fBckgJetsGen = new TList();
1576 fBckgJetsGen->SetOwner(kFALSE);
1577 }
1578
1579 //
1580 // Create histograms / output container
1581 //
1582
1583 OpenFile(1);
1584 fCommonHistList = new TList();
1585 fCommonHistList->SetOwner(kTRUE);
1586
1587 Bool_t oldStatus = TH1::AddDirectoryStatus();
1588 TH1::AddDirectory(kFALSE);
1589
1590
1591 // Histograms
1592 fh1EvtSelection = new TH1F("fh1EvtSelection", "Event Selection", 6, -0.5, 5.5);
1593 fh1EvtSelection->GetXaxis()->SetBinLabel(1,"ACCEPTED");
1594 fh1EvtSelection->GetXaxis()->SetBinLabel(2,"event selection: rejected");
1595 fh1EvtSelection->GetXaxis()->SetBinLabel(3,"event class: rejected");
1596 fh1EvtSelection->GetXaxis()->SetBinLabel(4,"vertex Ncontr: rejected");
1597 fh1EvtSelection->GetXaxis()->SetBinLabel(5,"vertex z: rejected");
1598 fh1EvtSelection->GetXaxis()->SetBinLabel(6,"vertex type: rejected");
1599
1600 fh1VertexNContributors = new TH1F("fh1VertexNContributors", "Vertex N contributors", 2500,-.5, 2499.5);
1601 fh1VertexZ = new TH1F("fh1VertexZ", "Vertex z distribution", 30, -15., 15.);
1602 fh1EvtMult = new TH1F("fh1EvtMult","Event multiplicity, track pT cut > 150 MeV/c, |#eta| < 0.9",120,0.,12000.);
1603 fh1EvtCent = new TH1F("fh1EvtCent","centrality",100,0.,100.);
1604
1605 fh1Xsec = new TProfile("fh1Xsec","xsec from pyxsec.root",1,0,1);
1606 fh1Xsec->GetXaxis()->SetBinLabel(1,"<#sigma>");
1607 fh1Trials = new TH1F("fh1Trials","trials from pyxsec.root",1,0,1);
1608 fh1Trials->GetXaxis()->SetBinLabel(1,"#sum{ntrials}");
1609 fh1PtHard = new TH1F("fh1PtHard","PYTHIA Pt hard;p_{T,hard}",350,-.5,349.5);
1610 fh1PtHardTrials = new TH1F("fh1PtHardTrials","PYTHIA Pt hard weight with trials;p_{T,hard}",350,-.5,349.5);
1611
1612 fh1nRecJetsCuts = new TH1F("fh1nRecJetsCuts","reconstructed jets per event",10,-0.5,9.5);
1613 fh1nGenJets = new TH1F("fh1nGenJets","generated jets per event",10,-0.5,9.5);
1614 fh1nRecEffJets = new TH1F("fh1nRecEffJets","reconstruction effiency: jets per event",10,-0.5,9.5);
1615 fh1nEmbeddedJets = new TH1F("fh1nEmbeddedJets","embedded jets per event",10,-0.5,9.5);
1616
1617 fh2PtRecVsGenPrim = new TH2F("fh2PtRecVsGenPrim","rec vs gen pt",fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax,fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax);
1618 fh2PtRecVsGenSec = new TH2F("fh2PtRecVsGenSec","rec vs gen pt",fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax,fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax);
1619
1620 // embedding
1621 if(fBranchEmbeddedJets.Length()){
1622 fh1FractionPtEmbedded = new TH1F("fh1FractionPtEmbedded","",200,0,2);
1623 fh1IndexEmbedded = new TH1F("fh1IndexEmbedded","",11,-1,10);
1624 fh2DeltaPtVsJetPtEmbedded = new TH2F("fh2DeltaPtVsJetPtEmbedded","",250,0,250,200,-100,100);
1625 fh2DeltaPtVsRecJetPtEmbedded = new TH2F("fh2DeltaPtVsRecJetPtEmbedded","",250,0,250,200,-100,100);
1626 fh1DeltaREmbedded = new TH1F("fh1DeltaREmbedded","",50,0,0.5);
1627 fh1nEmbeddedJets = new TH1F("fh1nEmbeddedJets","embedded jets per event",10,-0.5,9.5);
1628 }
1629
1630
1631 if(fQAMode){
1632 if(fQAMode&1){ // track QA
1633 fQATrackHistosRecCuts = new AliFragFuncQATrackHistos("RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1634 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1635 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1636 fQATrackHighPtThreshold);
1637 fQATrackHistosGen = new AliFragFuncQATrackHistos("Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1638 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1639 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1640 fQATrackHighPtThreshold);
1641 }
1642
1643 if(fQAMode&2){ // jet QA
1644 fQAJetHistosRec = new AliFragFuncQAJetHistos("Rec", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1645 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1646 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1647 fQAJetHistosRecCuts = new AliFragFuncQAJetHistos("RecCuts", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1648 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1649 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1650 fQAJetHistosRecCutsLeading = new AliFragFuncQAJetHistos("RecCutsLeading", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1651 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1652 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1653 fQAJetHistosGen = new AliFragFuncQAJetHistos("Gen", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1654 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1655 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1656 fQAJetHistosGenLeading = new AliFragFuncQAJetHistos("GenLeading", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1657 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1658 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1659 if(fEffMode) fQAJetHistosRecEffLeading = new AliFragFuncQAJetHistos("RecEffLeading", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1660 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1661 }
1662 } // end: QA
1663
1664 if(fFFMode || fIDFFMode){
1665
1666 fFFHistosRecCuts = new AliFragFuncHistos("RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1667 fFFNBinsPt, fFFPtMin, fFFPtMax,
1668 fFFNBinsXi, fFFXiMin, fFFXiMax,
1669 fFFNBinsZ , fFFZMin , fFFZMax );
1670
1671
1672 fFFHistosRecCutsInc = new AliFragFuncHistos("RecCutsInc", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1673 fFFNBinsPt, fFFPtMin, fFFPtMax,
1674 fFFNBinsXi, fFFXiMin, fFFXiMax,
1675 fFFNBinsZ , fFFZMin , fFFZMax );
1676
1677
1678 fFFHistosRecLeadingTrack = new AliFragFuncHistos("RecLeadingTrack", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1679 fFFNBinsPt, fFFPtMin, fFFPtMax,
1680 fFFNBinsXi, fFFXiMin, fFFXiMax,
1681 fFFNBinsZ , fFFZMin , fFFZMax );
1682
1683 fFFHistosGen = new AliFragFuncHistos("Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1684 fFFNBinsPt, fFFPtMin, fFFPtMax,
1685 fFFNBinsXi, fFFXiMin, fFFXiMax,
1686 fFFNBinsZ , fFFZMin , fFFZMax);
1687
1688 fFFHistosGenInc = new AliFragFuncHistos("GenInc", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1689 fFFNBinsPt, fFFPtMin, fFFPtMax,
1690 fFFNBinsXi, fFFXiMin, fFFXiMax,
1691 fFFNBinsZ , fFFZMin , fFFZMax);
1692
1693 fFFHistosGenLeadingTrack = new AliFragFuncHistos("GenLeadingTrack", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1694 fFFNBinsPt, fFFPtMin, fFFPtMax,
1695 fFFNBinsXi, fFFXiMin, fFFXiMax,
1696 fFFNBinsZ , fFFZMin , fFFZMax);
1697
1698 if (fIDFFMode) {
1699 for (Int_t i = 0; i < AliPID::kSPECIES; i++) {
1700 fIDFFHistosRecCuts[i] = new AliFragFuncHistos(Form("RecCuts_%s", AliPID::ParticleName(i)), fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1701 fFFNBinsPt, fFFPtMin, fFFPtMax,
1702 fFFNBinsXi, fFFXiMin, fFFXiMax,
1703 fFFNBinsZ , fFFZMin , fFFZMax );
1704 fIDFFHistosGen[i] = new AliFragFuncHistos(Form("Gen_%s", AliPID::ParticleName(i)), fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1705 fFFNBinsPt, fFFPtMin, fFFPtMax,
1706 fFFNBinsXi, fFFXiMin, fFFXiMax,
1707 fFFNBinsZ , fFFZMin , fFFZMax );
1708 }
1709 }
1710 } // end: FF
1711
1712 // efficiency
1713
1714 if(fEffMode){
1715 if(fQAMode&1){
1716 fQATrackHistosRecEffGen = new AliFragFuncQATrackHistos("RecEffGen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1717 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1718 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1719 fQATrackHighPtThreshold);
1720
1721 fQATrackHistosRecEffRec = new AliFragFuncQATrackHistos("RecEffRec", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1722 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1723 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1724 fQATrackHighPtThreshold);
1725
1726 fQATrackHistosSecRecNS = new AliFragFuncQATrackHistos("SecRecNS", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1727 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1728 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1729 fQATrackHighPtThreshold);
1730
1731 fQATrackHistosSecRecS = new AliFragFuncQATrackHistos("SecRecS", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1732 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1733 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1734 fQATrackHighPtThreshold);
1735
1736 fQATrackHistosSecRecSsc = new AliFragFuncQATrackHistos("SecRecSsc", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1737 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1738 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1739 fQATrackHighPtThreshold);
1740
1741 }
1742 if(fFFMode){
1743 fFFHistosRecEffRec = new AliFragFuncHistos("RecEffRec", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1744 fFFNBinsPt, fFFPtMin, fFFPtMax,
1745 fFFNBinsXi, fFFXiMin, fFFXiMax,
1746 fFFNBinsZ , fFFZMin , fFFZMax);
1747
1748 fFFHistosSecRecNS = new AliFragFuncHistos("SecRecNS", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1749 fFFNBinsPt, fFFPtMin, fFFPtMax,
1750 fFFNBinsXi, fFFXiMin, fFFXiMax,
1751 fFFNBinsZ , fFFZMin , fFFZMax);
1752
1753 fFFHistosSecRecS = new AliFragFuncHistos("SecRecS", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1754 fFFNBinsPt, fFFPtMin, fFFPtMax,
1755 fFFNBinsXi, fFFXiMin, fFFXiMax,
1756 fFFNBinsZ , fFFZMin , fFFZMax);
1757
1758 fFFHistosSecRecSsc = new AliFragFuncHistos("SecRecSsc", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1759 fFFNBinsPt, fFFPtMin, fFFPtMax,
1760 fFFNBinsXi, fFFXiMin, fFFXiMax,
1761 fFFNBinsZ , fFFZMin , fFFZMax);
1762
1763 }
1764 } // end: efficiency
1765
1766 // Background
1767 if(fBckgMode){
1768 if(fBckgType[0]==kBckgNone){
1769 AliError("no bgr method selected !");
1770 }
1771
1772 TString title[5];
1773 for(Int_t i=0; i<5; i++){
1774 if(fBckgType[i]==kBckgPerp) title[i]="Perp";
1775 else if(fBckgType[i]==kBckgPerp2) title[i]="Perp2";
1776 else if(fBckgType[i]==kBckgPerp2Area) title[i]="Perp2Area";
1777 else if(fBckgType[i]==kBckgPerpWindow) title[i]="PerpW";
1778 else if(fBckgType[i]==kBckgASide) title[i]="ASide";
1779 else if(fBckgType[i]==kBckgASideWindow) title[i]="ASideW";
1780 else if(fBckgType[i]==kBckgOutLJ) title[i]="OutLeadingJet";
1781 else if(fBckgType[i]==kBckgOut2J) title[i]="Out2Jets";
1782 else if(fBckgType[i]==kBckgOut3J) title[i]="Out3Jets";
1783 else if(fBckgType[i]==kBckgOutAJ) title[i]="AllJets";
1784 else if(fBckgType[i]==kBckgOutLJStat) title[i]="OutLeadingJetStat";
1785 else if(fBckgType[i]==kBckgOut2JStat) title[i]="Out2JetsStat";
1786 else if(fBckgType[i]==kBckgOut3JStat) title[i]="Out3JetsStat";
1787 else if(fBckgType[i]==kBckgOutAJStat) title[i]="AllJetsStat";
1788 else if(fBckgType[i]==kBckgClustersOutLeading) title[i]="OutClusters";
1789 else if(fBckgType[i]==kBckgClusters) title[i]="MedianClusters";
1790 else if(fBckgType[i]==kBckgNone) title[i]="";
1791 else printf("Please chose background method number %d!",i);
1792 }
1793
1794
1795 if(fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
1796 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
1797 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading){
1798
1799 fh1nRecBckgJetsCuts = new TH1F("fh1nRecBckgJetsCuts","reconstructed background jets per event",10,-0.5,9.5);
1800 fh1nGenBckgJets = new TH1F("fh1nGenBckgJets","generated background jets per event",10,-0.5,9.5);
1801 }
1802
1803
1804 fh1BckgMult0 = new TH1F("fh1BckgMult0","bckg mult "+title[0],500,0,500);
1805 if(fBckgType[1] != kBckgNone) fh1BckgMult1 = new TH1F("fh1BckgMult1","bckg mult "+title[1],500,0,500);
1806 if(fBckgType[2] != kBckgNone) fh1BckgMult2 = new TH1F("fh1BckgMult2","bckg mult "+title[2],500,0,500);
1807 if(fBckgType[3] != kBckgNone) fh1BckgMult3 = new TH1F("fh1BckgMult3","bckg mult "+title[3],500,0,500);
1808 if(fBckgType[4] != kBckgNone) fh1BckgMult4 = new TH1F("fh1BckgMult4","bckg mult "+title[4],500,0,500);
1809
1810
1811 if(fQAMode&1){
1812 fQABckgHisto0RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[0]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1813 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1814 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1815 fQATrackHighPtThreshold);
1816 fQABckgHisto0Gen = new AliFragFuncQATrackHistos("Bckg"+title[0]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1817 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1818 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1819 fQATrackHighPtThreshold);
1820
1821 if(fBckgType[1] != kBckgNone){
1822 fQABckgHisto1RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[1]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1823 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1824 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1825 fQATrackHighPtThreshold);
1826 fQABckgHisto1Gen = new AliFragFuncQATrackHistos("Bckg"+title[1]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1827 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1828 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1829 fQATrackHighPtThreshold);
1830 }
1831 if(fBckgType[2] != kBckgNone){
1832 fQABckgHisto2RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[2]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1833 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1834 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1835 fQATrackHighPtThreshold);
1836 fQABckgHisto2Gen = new AliFragFuncQATrackHistos("Bckg"+title[2]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1837 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1838 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1839 fQATrackHighPtThreshold);
1840 }
1841 if(fBckgType[3] != kBckgNone){
1842 fQABckgHisto3RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[3]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1843 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1844 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1845 fQATrackHighPtThreshold);
1846 fQABckgHisto3Gen = new AliFragFuncQATrackHistos("Bckg"+title[3]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1847 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1848 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1849 fQATrackHighPtThreshold);
1850 }
1851 if(fBckgType[4] != kBckgNone){
1852 fQABckgHisto4RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[4]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1853 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1854 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1855 fQATrackHighPtThreshold);
1856 fQABckgHisto4Gen = new AliFragFuncQATrackHistos("Bckg"+title[4]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1857 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1858 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1859 fQATrackHighPtThreshold);
1860 }
1861 } // end: background QA
1862
1863 if(fFFMode){
1864 fFFBckgHisto0RecCuts = new AliFragFuncHistos("Bckg"+title[0]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1865 fFFNBinsPt, fFFPtMin, fFFPtMax,
1866 fFFNBinsXi, fFFXiMin, fFFXiMax,
1867 fFFNBinsZ , fFFZMin , fFFZMax);
1868
1869 fFFBckgHisto0Gen = new AliFragFuncHistos("Bckg"+title[0]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1870 fFFNBinsPt, fFFPtMin, fFFPtMax,
1871 fFFNBinsXi, fFFXiMin, fFFXiMax,
1872 fFFNBinsZ , fFFZMin , fFFZMax);
1873
1874 if(fBckgType[1] != kBckgNone){
1875 fFFBckgHisto1RecCuts = new AliFragFuncHistos("Bckg"+title[1]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1876 fFFNBinsPt, fFFPtMin, fFFPtMax,
1877 fFFNBinsXi, fFFXiMin, fFFXiMax,
1878 fFFNBinsZ , fFFZMin , fFFZMax);
1879 fFFBckgHisto1Gen = new AliFragFuncHistos("Bckg"+title[1]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1880 fFFNBinsPt, fFFPtMin, fFFPtMax,
1881 fFFNBinsXi, fFFXiMin, fFFXiMax,
1882 fFFNBinsZ , fFFZMin , fFFZMax);
1883 }
1884 if(fBckgType[2] != kBckgNone){
1885 fFFBckgHisto2RecCuts = new AliFragFuncHistos("Bckg"+title[2]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1886 fFFNBinsPt, fFFPtMin, fFFPtMax,
1887 fFFNBinsXi, fFFXiMin, fFFXiMax,
1888 fFFNBinsZ , fFFZMin , fFFZMax);
1889
1890 fFFBckgHisto2Gen = new AliFragFuncHistos("Bckg"+title[2]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1891 fFFNBinsPt, fFFPtMin, fFFPtMax,
1892 fFFNBinsXi, fFFXiMin, fFFXiMax,
1893 fFFNBinsZ , fFFZMin , fFFZMax);
1894 }
1895 if(fBckgType[3] != kBckgNone){
1896 fFFBckgHisto3RecCuts = new AliFragFuncHistos("Bckg"+title[3]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1897 fFFNBinsPt, fFFPtMin, fFFPtMax,
1898 fFFNBinsXi, fFFXiMin, fFFXiMax,
1899 fFFNBinsZ , fFFZMin , fFFZMax);
1900
1901 fFFBckgHisto3Gen = new AliFragFuncHistos("Bckg"+title[3]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1902 fFFNBinsPt, fFFPtMin, fFFPtMax,
1903 fFFNBinsXi, fFFXiMin, fFFXiMax,
1904 fFFNBinsZ , fFFZMin , fFFZMax);
1905 }
1906 if(fBckgType[4] != kBckgNone){
1907 fFFBckgHisto4RecCuts = new AliFragFuncHistos("Bckg"+title[4]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1908 fFFNBinsPt, fFFPtMin, fFFPtMax,
1909 fFFNBinsXi, fFFXiMin, fFFXiMax,
1910 fFFNBinsZ , fFFZMin , fFFZMax);
1911
1912 fFFBckgHisto4Gen = new AliFragFuncHistos("Bckg"+title[4]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1913 fFFNBinsPt, fFFPtMin, fFFPtMax,
1914 fFFNBinsXi, fFFXiMin, fFFXiMax,
1915 fFFNBinsZ , fFFZMin , fFFZMax);
1916 }
1917 if(fEffMode){
1918 fFFBckgHisto0RecEffRec = new AliFragFuncHistos("Bckg"+title[0]+"RecEffRec", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1919 fFFNBinsPt, fFFPtMin, fFFPtMax,
1920 fFFNBinsXi, fFFXiMin, fFFXiMax,
1921 fFFNBinsZ , fFFZMin , fFFZMax);
1922
1923 fFFBckgHisto0SecRecNS = new AliFragFuncHistos("Bckg"+title[0]+"SecRecNS", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1924 fFFNBinsPt, fFFPtMin, fFFPtMax,
1925 fFFNBinsXi, fFFXiMin, fFFXiMax,
1926 fFFNBinsZ , fFFZMin , fFFZMax);
1927
1928 fFFBckgHisto0SecRecS = new AliFragFuncHistos("Bckg"+title[0]+"SecRecS", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1929 fFFNBinsPt, fFFPtMin, fFFPtMax,
1930 fFFNBinsXi, fFFXiMin, fFFXiMax,
1931 fFFNBinsZ , fFFZMin , fFFZMax);
1932
1933 fFFBckgHisto0SecRecSsc = new AliFragFuncHistos("Bckg"+title[0]+"SecRecSsc", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1934 fFFNBinsPt, fFFPtMin, fFFPtMax,
1935 fFFNBinsXi, fFFXiMin, fFFXiMax,
1936 fFFNBinsZ , fFFZMin , fFFZMax);
1937
1938 }
1939 } // end: background FF
1940
1941
1942 } // end: background
1943
1944
1945 // ____________ define histograms ____________________
1946
1947 if(fQAMode){
1948 if(fQAMode&1){ // track QA
1949 fQATrackHistosRecCuts->DefineHistos();
1950 fQATrackHistosGen->DefineHistos();
1951 }
1952
1953 if(fQAMode&2){ // jet QA
1954 fQAJetHistosRec->DefineHistos();
1955 fQAJetHistosRecCuts->DefineHistos();
1956 fQAJetHistosRecCutsLeading->DefineHistos();
1957 fQAJetHistosGen->DefineHistos();
1958 fQAJetHistosGenLeading->DefineHistos();
1959 if(fEffMode) fQAJetHistosRecEffLeading->DefineHistos();
1960 }
1961 }
1962
1963 if(fFFMode || fIDFFMode){
1964 fFFHistosRecCuts->DefineHistos();
1965 fFFHistosRecCutsInc->DefineHistos();
1966 fFFHistosRecLeadingTrack->DefineHistos();
1967 fFFHistosGen->DefineHistos();
1968 fFFHistosGenInc->DefineHistos();
1969 fFFHistosGenLeadingTrack->DefineHistos();
1970
1971 if (fIDFFMode) {
1972 for (Int_t i = 0; i < AliPID::kSPECIES; i++) {
1973 fIDFFHistosRecCuts[i]->DefineHistos();
1974 fIDFFHistosGen[i]->DefineHistos();
1975 }
1976 }
1977 }
1978
1979 if(fEffMode){
1980 if(fQAMode&1){
1981 fQATrackHistosRecEffGen->DefineHistos();
1982 fQATrackHistosRecEffRec->DefineHistos();
1983 fQATrackHistosSecRecNS->DefineHistos();
1984 fQATrackHistosSecRecS->DefineHistos();
1985 fQATrackHistosSecRecSsc->DefineHistos();
1986 }
1987 if(fFFMode){
1988 fFFHistosRecEffRec->DefineHistos();
1989 fFFHistosSecRecNS->DefineHistos();
1990 fFFHistosSecRecS->DefineHistos();
1991 fFFHistosSecRecSsc->DefineHistos();
1992 }
1993 } // end: efficiency
1994
1995 // Background
1996 if(fBckgMode){
1997 if(fFFMode){
1998 fFFBckgHisto0RecCuts->DefineHistos();
1999 fFFBckgHisto0Gen->DefineHistos();
2000 if(fBckgType[1] != kBckgNone) fFFBckgHisto1RecCuts->DefineHistos();
2001 if(fBckgType[1] != kBckgNone) fFFBckgHisto1Gen->DefineHistos();
2002 if(fBckgType[2] != kBckgNone) fFFBckgHisto2RecCuts->DefineHistos();
2003 if(fBckgType[2] != kBckgNone) fFFBckgHisto2Gen->DefineHistos();
2004 if(fBckgType[3] != kBckgNone) fFFBckgHisto3RecCuts->DefineHistos();
2005 if(fBckgType[3] != kBckgNone) fFFBckgHisto3Gen->DefineHistos();
2006 if(fBckgType[4] != kBckgNone) fFFBckgHisto4RecCuts->DefineHistos();
2007 if(fBckgType[4] != kBckgNone) fFFBckgHisto4Gen->DefineHistos();
2008
2009 if(fEffMode){
2010 fFFBckgHisto0RecEffRec->DefineHistos();
2011 fFFBckgHisto0SecRecNS->DefineHistos();
2012 fFFBckgHisto0SecRecS->DefineHistos();
2013 fFFBckgHisto0SecRecSsc->DefineHistos();
2014 }
2015 }
2016
2017 if(fQAMode&1){
2018 fQABckgHisto0RecCuts->DefineHistos();
2019 fQABckgHisto0Gen->DefineHistos();
2020 if(fBckgType[1] != kBckgNone) fQABckgHisto1RecCuts->DefineHistos();
2021 if(fBckgType[1] != kBckgNone) fQABckgHisto1Gen->DefineHistos();
2022 if(fBckgType[2] != kBckgNone) fQABckgHisto2RecCuts->DefineHistos();
2023 if(fBckgType[2] != kBckgNone) fQABckgHisto2Gen->DefineHistos();
2024 if(fBckgType[3] != kBckgNone) fQABckgHisto3RecCuts->DefineHistos();
2025 if(fBckgType[3] != kBckgNone) fQABckgHisto3Gen->DefineHistos();
2026 if(fBckgType[4] != kBckgNone) fQABckgHisto4RecCuts->DefineHistos();
2027 if(fBckgType[4] != kBckgNone) fQABckgHisto4Gen->DefineHistos();
2028 }
2029 } // end: background
2030
2031
2032 Bool_t genJets = (fJetTypeGen != kJetsUndef) ? kTRUE : kFALSE;
2033 Bool_t genTracks = (fTrackTypeGen != kTrackUndef) ? kTRUE : kFALSE;
2034 Bool_t recJetsEff = (fJetTypeRecEff != kJetsUndef) ? kTRUE : kFALSE;
2035
2036 fCommonHistList->Add(fh1EvtSelection);
2037 fCommonHistList->Add(fh1EvtMult);
2038 fCommonHistList->Add(fh1EvtCent);
2039 fCommonHistList->Add(fh1VertexNContributors);
2040 fCommonHistList->Add(fh1VertexZ);
2041 fCommonHistList->Add(fh1nRecJetsCuts);
2042 fCommonHistList->Add(fh1Xsec);
2043 fCommonHistList->Add(fh1Trials);
2044 fCommonHistList->Add(fh1PtHard);
2045 fCommonHistList->Add(fh1PtHardTrials);
2046
2047 if(genJets) fCommonHistList->Add(fh1nGenJets);
2048
2049 // FF histograms
2050 if(fFFMode){
2051 fFFHistosRecCuts->AddToOutput(fCommonHistList);
2052 fFFHistosRecCutsInc->AddToOutput(fCommonHistList);
2053 fFFHistosRecLeadingTrack->AddToOutput(fCommonHistList);
2054
2055 if(genJets && genTracks){
2056 fFFHistosGen->AddToOutput(fCommonHistList);
2057 fFFHistosGenInc->AddToOutput(fCommonHistList);
2058 fFFHistosGenLeadingTrack->AddToOutput(fCommonHistList);
2059 }
2060
2061 if (fIDFFMode) {
2062 for (Int_t i = 0; i < AliPID::kSPECIES; i++) {
2063 if(genJets && genTracks)
2064 fIDFFHistosGen[i]->AddToOutput(fCommonHistList);
2065 fIDFFHistosRecCuts[i]->AddToOutput(fCommonHistList);
2066 }
2067 }
2068 }
2069
2070 // Background
2071 if(fBckgMode){
2072 if(fFFMode){
2073 fFFBckgHisto0RecCuts->AddToOutput(fCommonHistList);
2074 if(fBckgType[1] != kBckgNone) fFFBckgHisto1RecCuts->AddToOutput(fCommonHistList);
2075 if(fBckgType[2] != kBckgNone) fFFBckgHisto2RecCuts->AddToOutput(fCommonHistList);
2076 if(fBckgType[3] != kBckgNone) fFFBckgHisto3RecCuts->AddToOutput(fCommonHistList);
2077 if(fBckgType[4] != kBckgNone) fFFBckgHisto4RecCuts->AddToOutput(fCommonHistList);
2078
2079 if(genJets && genTracks){
2080 fFFBckgHisto0Gen->AddToOutput(fCommonHistList);
2081 if(fBckgType[1] != kBckgNone) fFFBckgHisto1Gen->AddToOutput(fCommonHistList);
2082 if(fBckgType[2] != kBckgNone) fFFBckgHisto2Gen->AddToOutput(fCommonHistList);
2083 if(fBckgType[3] != kBckgNone) fFFBckgHisto3Gen->AddToOutput(fCommonHistList);
2084 if(fBckgType[4] != kBckgNone) fFFBckgHisto4Gen->AddToOutput(fCommonHistList);
2085 }
2086
2087 if(fEffMode){
2088 fFFBckgHisto0RecEffRec->AddToOutput(fCommonHistList);
2089 fFFBckgHisto0SecRecNS->AddToOutput(fCommonHistList);
2090 fFFBckgHisto0SecRecS->AddToOutput(fCommonHistList);
2091 fFFBckgHisto0SecRecSsc->AddToOutput(fCommonHistList);
2092 }
2093 }
2094
2095 if(fQAMode&1){
2096 fQABckgHisto0RecCuts->AddToOutput(fCommonHistList);
2097 if(fBckgType[1] != kBckgNone) fQABckgHisto1RecCuts->AddToOutput(fCommonHistList);
2098 if(fBckgType[2] != kBckgNone) fQABckgHisto2RecCuts->AddToOutput(fCommonHistList);
2099 if(fBckgType[3] != kBckgNone) fQABckgHisto3RecCuts->AddToOutput(fCommonHistList);
2100 if(fBckgType[4] != kBckgNone) fQABckgHisto4RecCuts->AddToOutput(fCommonHistList);
2101 if(genJets && genTracks){
2102 fQABckgHisto0Gen->AddToOutput(fCommonHistList);
2103 if(fBckgType[1] != kBckgNone) fQABckgHisto1Gen->AddToOutput(fCommonHistList);
2104 if(fBckgType[2] != kBckgNone) fQABckgHisto2Gen->AddToOutput(fCommonHistList);
2105 if(fBckgType[3] != kBckgNone) fQABckgHisto3Gen->AddToOutput(fCommonHistList);
2106 if(fBckgType[4] != kBckgNone) fQABckgHisto4Gen->AddToOutput(fCommonHistList);
2107 }
2108 }
2109
2110 if(fh1BckgMult0) fCommonHistList->Add(fh1BckgMult0);
2111 if(fBckgType[1] != kBckgNone) fCommonHistList->Add(fh1BckgMult1);
2112 if(fBckgType[2] != kBckgNone) fCommonHistList->Add(fh1BckgMult2);
2113 if(fBckgType[3] != kBckgNone) fCommonHistList->Add(fh1BckgMult3);
2114 if(fBckgType[4] != kBckgNone) fCommonHistList->Add(fh1BckgMult4);
2115 }
2116
2117
2118 if(fBranchEmbeddedJets.Length()){
2119 fCommonHistList->Add(fh1FractionPtEmbedded);
2120 fCommonHistList->Add(fh1IndexEmbedded);
2121 fCommonHistList->Add(fh2DeltaPtVsJetPtEmbedded);
2122 fCommonHistList->Add(fh2DeltaPtVsRecJetPtEmbedded);
2123 fCommonHistList->Add(fh1DeltaREmbedded);
2124 fCommonHistList->Add(fh1nEmbeddedJets);
2125 }
2126
2127
2128 // QA
2129 if(fQAMode){
2130 if(fQAMode&1){ // track QA
2131 fQATrackHistosRecCuts->AddToOutput(fCommonHistList);
2132 if(genTracks) fQATrackHistosGen->AddToOutput(fCommonHistList);
2133 }
2134
2135 if(fQAMode&2){ // jet QA
2136 fQAJetHistosRec->AddToOutput(fCommonHistList);
2137 fQAJetHistosRecCuts->AddToOutput(fCommonHistList);
2138 fQAJetHistosRecCutsLeading->AddToOutput(fCommonHistList);
2139 if(recJetsEff && fEffMode) fQAJetHistosRecEffLeading->AddToOutput(fCommonHistList);
2140 if(genJets){
2141 fQAJetHistosGen->AddToOutput(fCommonHistList);
2142 fQAJetHistosGenLeading->AddToOutput(fCommonHistList);
2143 }
2144 }
2145 }
2146
2147 if(fBckgMode &&
2148 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
2149 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
2150 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)) {
2151 fCommonHistList->Add(fh1nRecBckgJetsCuts);
2152 if(genJets) fCommonHistList->Add(fh1nGenBckgJets);
2153 }
2154
2155
2156 if(fEffMode && recJetsEff && genTracks){
2157 if(fQAMode&1){
2158 fQATrackHistosRecEffGen->AddToOutput(fCommonHistList);
2159 fQATrackHistosRecEffRec->AddToOutput(fCommonHistList);
2160 fQATrackHistosSecRecNS->AddToOutput(fCommonHistList);
2161 fQATrackHistosSecRecS->AddToOutput(fCommonHistList);
2162 fQATrackHistosSecRecSsc->AddToOutput(fCommonHistList);
2163 }
2164 if(fFFMode){
2165 fFFHistosRecEffRec->AddToOutput(fCommonHistList);
2166 fFFHistosSecRecNS->AddToOutput(fCommonHistList);
2167 fFFHistosSecRecS->AddToOutput(fCommonHistList);
2168 fFFHistosSecRecSsc->AddToOutput(fCommonHistList);
2169 }
2170 fCommonHistList->Add(fh1nRecEffJets);
2171 fCommonHistList->Add(fh2PtRecVsGenPrim);
2172 fCommonHistList->Add(fh2PtRecVsGenSec);
2173 }
2174
2175 // jet shape
2176 if(fJSMode){
2177
2178 fProNtracksLeadingJet = new TProfile("AvgNoOfTracksLeadingJet","AvgNoOfTracksLeadingJet",100,0,250,0,50);
2179 fProDelR80pcPt = new TProfile("AvgdelR80pcPt","AvgdelR80pcPt",100,0,250,0,1);
2180
2181 if(genJets && genTracks){
2182 fProNtracksLeadingJetGen = new TProfile("AvgNoOfTracksLeadingJetGen","AvgNoOfTracksLeadingJetGen",100,0,250,0,50);
2183 fProDelR80pcPtGen = new TProfile("AvgdelR80pcPtGen","AvgdelR80pcPtGen",100,0,250,0,1);
2184 }
2185
2186 if(fBckgMode)
2187 fProNtracksLeadingJetBgrPerp2 = new TProfile("AvgNoOfTracksLeadingJetBgrPerp2","AvgNoOfTracksLeadingJetBgrPerp2",100,0,250,0,50);
2188
2189 if(fEffMode){
2190 fProNtracksLeadingJetRecPrim = new TProfile("AvgNoOfTracksLeadingJetRecPrim","AvgNoOfTracksLeadingJetRecPrim",100,0,250,0,50);
2191 fProDelR80pcPtRecPrim = new TProfile("AvgdelR80pcPtRecPrim","AvgdelR80pcPtRecPrim",100,0,250,0,1);
2192 fProNtracksLeadingJetRecSecNS = new TProfile("AvgNoOfTracksLeadingJetRecSecNS","AvgNoOfTracksLeadingJetRecSecNS",100,0,250,0,50);
2193 fProNtracksLeadingJetRecSecS = new TProfile("AvgNoOfTracksLeadingJetRecSecS","AvgNoOfTracksLeadingJetRecSecS",100,0,250,0,50);
2194 fProNtracksLeadingJetRecSecSsc = new TProfile("AvgNoOfTracksLeadingJetRecSecSsc","AvgNoOfTracksLeadingJetRecSecSsc",100,0,250,0,50);
2195 }
2196
2197 TString strTitJS;
2198 for(Int_t ii=0; ii<5; ii++){
2199 if(ii==0)strTitJS = "_JetPt20to30";
2200 if(ii==1)strTitJS = "_JetPt30to40";
2201 if(ii==2)strTitJS = "_JetPt40to60";
2202 if(ii==3)strTitJS = "_JetPt60to80";
2203 if(ii==4)strTitJS = "_JetPt80to100";
2204
2205 fProDelRPtSum[ii] = new TProfile(Form("AvgPtSumDelR%s",strTitJS.Data()),Form("AvgPtSumDelR%s",strTitJS.Data()),50,0,1,0,250);
2206 if(genJets && genTracks)
2207 fProDelRPtSumGen[ii] = new TProfile(Form("AvgPtSumDelRGen%s",strTitJS.Data()),Form("AvgPtSumDelRGen%s",strTitJS.Data()),50,0,1,0,250);
2208 if(fBckgMode)
2209 fProDelRPtSumBgrPerp2[ii] = new TProfile(Form("AvgPtSumDelRBgrPerp2%s",strTitJS.Data()),Form("AvgPtSumDelRBgrPerp2%s",strTitJS.Data()),50,0,1,0,250);
2210 if(fEffMode){
2211 fProDelRPtSumRecPrim[ii] = new TProfile(Form("AvgPtSumDelRRecPrim%s",strTitJS.Data()),Form("AvgPtSumDelRRecPrim%s",strTitJS.Data()),50,0,1,0,250);
2212 fProDelRPtSumRecSecNS[ii] = new TProfile(Form("AvgPtSumDelRRecSecNS%s",strTitJS.Data()),Form("AvgPtSumDelRRecSecNS%s",strTitJS.Data()),50,0,1,0,250);
2213 fProDelRPtSumRecSecS[ii] = new TProfile(Form("AvgPtSumDelRRecSecS%s",strTitJS.Data()),Form("AvgPtSumDelRRecSecS%s",strTitJS.Data()),50,0,1,0,250);
2214 fProDelRPtSumRecSecSsc[ii] = new TProfile(Form("AvgPtSumDelRRecSecSsc%s",strTitJS.Data()),Form("AvgPtSumDelRRecSecSsc%s",strTitJS.Data()),50,0,1,0,250);
2215 }
2216 }
2217
2218 fCommonHistList->Add(fProNtracksLeadingJet);
2219 fCommonHistList->Add(fProDelR80pcPt);
2220 for(int ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSum[ii]);
2221
2222 if(genJets && genTracks){
2223 fCommonHistList->Add(fProNtracksLeadingJetGen);
2224 fCommonHistList->Add(fProDelR80pcPtGen);
2225 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumGen[ii]);
2226 }
2227
2228 if(fBckgMode){
2229 fCommonHistList->Add(fProNtracksLeadingJetBgrPerp2);
2230 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumBgrPerp2[ii]);
2231 }
2232
2233 if(fEffMode){
2234 fCommonHistList->Add(fProNtracksLeadingJetRecPrim);
2235 fCommonHistList->Add(fProDelR80pcPtRecPrim);
2236 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumRecPrim[ii]);
2237
2238 fCommonHistList->Add(fProNtracksLeadingJetRecSecNS);
2239 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumRecSecNS[ii]);
2240
2241 fCommonHistList->Add(fProNtracksLeadingJetRecSecS);
2242 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumRecSecS[ii]);
2243
2244 fCommonHistList->Add(fProNtracksLeadingJetRecSecSsc);
2245 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumRecSecSsc[ii]);
2246 }
2247 }
2248
2249 // =========== Switch on Sumw2 for all histos ===========
2250 for (Int_t i=0; i<fCommonHistList->GetEntries(); ++i){
2251 TH1 *h1 = dynamic_cast<TH1*>(fCommonHistList->At(i));
2252 if (h1) h1->Sumw2();
2253 else{
2254 THnSparse *hnSparse = dynamic_cast<THnSparse*>(fCommonHistList->At(i));
2255 if(hnSparse) hnSparse->Sumw2();
2256 }
2257 }
2258
2259 TH1::AddDirectory(oldStatus);
2260
2261
2262
2263 // Load PID framework if desired
9e95a906 2264 if(fDebug > 1) Printf("AliAnalysisTaskIDFragmentationFunction::UserCreateOutputObjects() -> Loading PID framework");
e131b05f 2265
2266 fUseJetPIDtask = fIDFFMode || fFFMode;
2267 fUseInclusivePIDtask = fQAMode && (fQAMode&1);
2268
2269 if (fUseJetPIDtask || fUseInclusivePIDtask) {
2270 TObjArray* tasks = AliAnalysisManager::GetAnalysisManager()->GetTasks();
2271 if (!tasks) {
2272 Printf("ERROR loading PID tasks: Failed to retrieve tasks from analysis manager!\n");
2273
2274 fUseJetPIDtask = kFALSE;
2275 fUseInclusivePIDtask = kFALSE;
2276 }
2277
2278 if (fUseJetPIDtask) {
93fb15f0
ML		 2279 delete [] fJetPIDtask;
2280 fJetPIDtask = 0x0;
2281
e131b05f 2282 if (fNumJetPIDtasks > 0) {
93fb15f0
ML		 2283 fJetPIDtask = new AliAnalysisTaskPID*[fNumJetPIDtasks];
2284
e131b05f 2285 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
2286 fJetPIDtask[i] = (AliAnalysisTaskPID*)tasks->FindObject(fNameJetPIDtask[i].Data());
2287
2288 if (!fJetPIDtask[i]) {
2289 Printf("ERROR: Failed to load jet pid task!\n");
2290 fUseJetPIDtask = kFALSE;
2291 }
2292 }
2293 }
2294 else {
77324970 2295 Printf("WARNING: zero jet pid tasks!\n");
e131b05f 2296 fUseJetPIDtask = kFALSE;
2297 }
2298 }
2299
2300 if (fUseInclusivePIDtask) {
93fb15f0
ML		 2301 delete [] fInclusivePIDtask;
2302 fInclusivePIDtask = 0x0;
2303
e131b05f 2304 if (fNumInclusivePIDtasks > 0) {
93fb15f0
ML		 2305 fInclusivePIDtask = new AliAnalysisTaskPID*[fNumInclusivePIDtasks];
2306
e131b05f 2307 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
2308 fInclusivePIDtask[i] = (AliAnalysisTaskPID*)tasks->FindObject(fNameInclusivePIDtask[i].Data());
2309
2310 if (!fInclusivePIDtask[i]) {
2311 Printf("ERROR: Failed to load inclusive pid task!\n");
2312 fUseInclusivePIDtask = kFALSE;
2313 }
2314 }
2315 }
2316 else {
77324970
CKB		 2317 Printf("WARNING: zero inclusive pid tasks!\n");
2318 fUseInclusivePIDtask = kFALSE;
e131b05f 2319 }
2320 }
2321 }
2322
9e95a906 2323 if(fDebug > 2) Printf("AliAnalysisTaskIDFragmentationFunction::UserCreateOutputObjects() -> Posting Output");
2324
e131b05f 2325 PostData(1, fCommonHistList);
9e95a906 2326
2327 if(fDebug > 2) Printf("AliAnalysisTaskIDFragmentationFunction::UserCreateOutputObjects() -> Done");
e131b05f 2328}
2329
2330//_______________________________________________
2331void AliAnalysisTaskIDFragmentationFunction::Init()
2332{
2333 // Initialization
2334 if(fDebug > 1) Printf("AliAnalysisTaskIDFragmentationFunction::Init()");
2335
2336}
2337
2338//_____________________________________________________________
2339void AliAnalysisTaskIDFragmentationFunction::UserExec(Option_t *)
2340{
2341 // Main loop
2342 // Called for each event
2343
2344 if(fDebug > 1) Printf("AliAnalysisTaskIDFragmentationFunction::UserExec()");
2345
2346
2347 if(fDebug > 1) Printf("Analysis event #%5d", (Int_t) fEntry);
2348
2349 // Trigger selection
2350 AliInputEventHandler* inputHandler = (AliInputEventHandler*)
2351 ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
2352
2353 if(!(inputHandler->IsEventSelected() & fEvtSelectionMask)){
2354 fh1EvtSelection->Fill(1.);
2355 if (fDebug > 1 ) Printf(" Trigger Selection: event REJECTED ... ");
2356 PostData(1, fCommonHistList);
2357 return;
2358 }
2359
2360 fESD = dynamic_cast<AliESDEvent*>(InputEvent());
2361 if(!fESD){
2362 if(fDebug>3) Printf("%s:%d ESDEvent not found in the input", (char*)__FILE__,__LINE__);
2363 }
2364
2365 fMCEvent = MCEvent();
2366 if(!fMCEvent){
2367 if(fDebug>3) Printf("%s:%d MCEvent not found in the input", (char*)__FILE__,__LINE__);
2368 }
2369
2370 // get AOD event from input/ouput
2371 TObject* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
2372 if( handler && handler->InheritsFrom("AliAODInputHandler") ) {
2373 fAOD = ((AliAODInputHandler*)handler)->GetEvent();
2374 if(fUseAODInputJets) fAODJets = fAOD;
2375 if (fDebug > 1) Printf("%s:%d AOD event from input", (char*)__FILE__,__LINE__);
2376 }
2377 else {
2378 handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
2379 if( handler && handler->InheritsFrom("AliAODHandler") ) {
2380 fAOD = ((AliAODHandler*)handler)->GetAOD();
2381 fAODJets = fAOD;
2382 if (fDebug > 1) Printf("%s:%d AOD event from output", (char*)__FILE__,__LINE__);
2383 }
2384 }
2385
2386 if(!fAODJets && !fUseAODInputJets){ // case we have AOD in input & output and want jets from output
2387 TObject* outHandler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
2388 if( outHandler && outHandler->InheritsFrom("AliAODHandler") ) {
2389 fAODJets = ((AliAODHandler*)outHandler)->GetAOD();
2390 if (fDebug > 1) Printf("%s:%d jets from output AOD", (char*)__FILE__,__LINE__);
2391 }
2392 }
2393
2394 if(fNonStdFile.Length()!=0){
2395 // case we have an AOD extension - fetch the jets from the extended output
2396
2397 AliAODHandler *aodH = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
2398 fAODExtension = (aodH?aodH->GetExtension(fNonStdFile.Data()):0);
2399 if(!fAODExtension){
2400 if(fDebug>1)Printf("AODExtension not found for %s",fNonStdFile.Data());
2401 }
2402 }
2403
2404 if(!fAOD){
2405 Printf("%s:%d AODEvent not found", (char*)__FILE__,__LINE__);
2406 return;
2407 }
2408 if(!fAODJets){
2409 Printf("%s:%d AODEvent with jet branch not found", (char*)__FILE__,__LINE__);
2410 return;
2411 }
2412
2413
2414 // event selection **************************************************
2415 // *** event class ***
2416 AliVEvent* evtForCentDetermination = handler->InheritsFrom("AliAODInputHandler") ? fAOD : InputEvent();
2417
2418 Double_t centPercent = -1;
2419 if(fEventClass>0){
2420 Int_t cl = 0;
2421 if(handler->InheritsFrom("AliAODInputHandler")){
2422 // since it is not supported by the helper task define own classes
2423 centPercent = fAOD->GetHeader()->GetCentrality();
2424 cl = 1;
2425 if(centPercent>10) cl = 2;
2426 if(centPercent>30) cl = 3;
2427 if(centPercent>50) cl = 4;
2428 }
2429 else {
2430 cl = AliAnalysisHelperJetTasks::EventClass();
2431 if(fESD) centPercent = fESD->GetCentrality()->GetCentralityPercentile("V0M"); // retrieve value 'by hand'
2432 }
2433
2434 if(cl!=fEventClass){
2435 // event not in selected event class, reject event
2436 if (fDebug > 1) Printf("%s:%d event not in selected event class: event REJECTED ...",(char*)__FILE__,__LINE__);
2437 fh1EvtSelection->Fill(2.);
2438 PostData(1, fCommonHistList);
2439 return;
2440 }
2441 }
4b4d71d4 2442
2443
2444 // Count events with trigger selection, note: Set centrality percentile fix to -1 for pp for PID framework
2445 if (fUseJetPIDtask) {
2446 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
2447 fJetPIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSel);
2448 }
2449 }
2450
2451 if (fUseInclusivePIDtask) {
2452 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
2453 fInclusivePIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSel);
2454 }
2455 }
e131b05f 2456
2457 // *** vertex cut ***
2458 AliAODVertex* primVtx = fAOD->GetPrimaryVertex();
2459 if (!primVtx) {
2460 Printf("%s:%d Primary vertex not found", (char*)__FILE__,__LINE__);
2461 return;
2462 }
2463
2464 Int_t nTracksPrim = primVtx->GetNContributors();
2465 fh1VertexNContributors->Fill(nTracksPrim);
2466
2467
2468 if (fDebug > 1) Printf("%s:%d primary vertex selection: %d", (char*)__FILE__,__LINE__,nTracksPrim);
4b4d71d4 2469 if(nTracksPrim <= 0) {
e131b05f 2470 if (fDebug > 1) Printf("%s:%d primary vertex selection: event REJECTED...",(char*)__FILE__,__LINE__);
2471 fh1EvtSelection->Fill(3.);
2472 PostData(1, fCommonHistList);
2473 return;
2474 }
2475
4b4d71d4 2476 TString primVtxName(primVtx->GetName());
2477
2478 if(primVtxName.CompareTo("TPCVertex",TString::kIgnoreCase) == 1){
2479 if (fDebug > 1) Printf("%s:%d primary vertex selection: TPC vertex, event REJECTED...",(char*)__FILE__,__LINE__);
2480 fh1EvtSelection->Fill(5.);
2481 PostData(1, fCommonHistList);
2482 return;
2483 }
2484
2485 // Count events with trigger selection and vtx cut, note: Set centrality percentile fix to -1 for pp for PID framework
2486 if (fUseJetPIDtask) {
2487 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
2488 fJetPIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSelAndVtxCut);
2489 }
2490 }
2491
2492 if (fUseInclusivePIDtask) {
2493 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
2494 fInclusivePIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSelAndVtxCut);
2495 }
2496 }
2497
e131b05f 2498 fh1VertexZ->Fill(primVtx->GetZ());
2499
2500 if(TMath::Abs(primVtx->GetZ())>fMaxVertexZ){
2501 if (fDebug > 1) Printf("%s:%d primary vertex z = %f: event REJECTED...",(char*)__FILE__,__LINE__,primVtx->GetZ());
2502 fh1EvtSelection->Fill(4.);
2503 PostData(1, fCommonHistList);
2504 return;
2505 }
2506
4b4d71d4 2507 // Count events with trigger selection and vtx cut, note: Set centrality percentile fix to -1 for pp for PID framework
2508 if (fUseJetPIDtask) {
2509 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
2510 fJetPIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSelAndVtxCutAndZvtxCut);
2511 }
e131b05f 2512 }
4b4d71d4 2513
2514 if (fUseInclusivePIDtask) {
2515 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
2516 fInclusivePIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSelAndVtxCutAndZvtxCut);
2517 }
2518 }
2519
e131b05f 2520 if (fDebug > 1) Printf("%s:%d event ACCEPTED ...",(char*)__FILE__,__LINE__);
2521 fh1EvtSelection->Fill(0.);
2522 fh1EvtCent->Fill(centPercent);
2523
2524 // Set centrality percentile fix to -1 for pp to be used for the PID framework
2525 if (fIsPP)
2526 centPercent = -1;
2527
2528
2529 //___ get MC information __________________________________________________________________
2530
2531 fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
2532
2533 if (fUseInclusivePIDtask) {
2534 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
2535 fInclusivePIDtask[i]->FillPythiaTrials(fAvgTrials);
2536 }
2537
2538 if (fUseJetPIDtask) {
2539 for (Int_t i = 0; i < fNumJetPIDtasks; i++)
2540 fJetPIDtask[i]->FillPythiaTrials(fAvgTrials);
2541 }
2542
2543 Double_t ptHard = 0.;
2544 Double_t nTrials = 1; // trials for MC trigger weight for real data
2545
2546 if(fMCEvent){
2547 AliGenEventHeader* genHeader = fMCEvent->GenEventHeader();
2548
2549 if(genHeader){
2550
2551 AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
2552 AliGenHijingEventHeader* hijingGenHeader = 0x0;
2553
2554 if(pythiaGenHeader){
2555 if(fDebug>3) Printf("%s:%d pythiaGenHeader found", (char*)__FILE__,__LINE__);
2556 nTrials = pythiaGenHeader->Trials();
2557 ptHard = pythiaGenHeader->GetPtHard();
2558
2559 fh1PtHard->Fill(ptHard);
2560 fh1PtHardTrials->Fill(ptHard,nTrials);
2561
2562 } else { // no pythia, hijing?
2563
2564 if(fDebug>3) Printf("%s:%d no pythiaGenHeader found", (char*)__FILE__,__LINE__);
2565
2566 hijingGenHeader = dynamic_cast<AliGenHijingEventHeader*>(genHeader);
2567 if(!hijingGenHeader){
2568 Printf("%s:%d no pythiaGenHeader or hjingGenHeader found", (char*)__FILE__,__LINE__);
2569 } else {
2570 if(fDebug>3) Printf("%s:%d hijingGenHeader found", (char*)__FILE__,__LINE__);
2571 }
2572 }
2573
2574 //fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
2575 }
2576 }
2577
2578 //___ fetch jets __________________________________________________________________________
2579
2580 Int_t nJ = GetListOfJets(fJetsRec, kJetsRec);
2581 Int_t nRecJets = 0;
2582 if(nJ>=0) nRecJets = fJetsRec->GetEntries();
2583 if(fDebug>2)Printf("%s:%d Selected Rec jets: %d %d",(char*)__FILE__,__LINE__,nJ,nRecJets);
2584 if(nJ != nRecJets) Printf("%s:%d Mismatch Selected Rec Jets: %d %d",(char*)__FILE__,__LINE__,nJ,nRecJets);
2585
2586 Int_t nJCuts = GetListOfJets(fJetsRecCuts, kJetsRecAcceptance);
2587 Int_t nRecJetsCuts = 0;
2588 if(nJCuts>=0) nRecJetsCuts = fJetsRecCuts->GetEntries();
2589 if(fDebug>2)Printf("%s:%d Selected Rec jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2590 if(nRecJetsCuts != nJCuts) Printf("%s:%d Mismatch selected Rec jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2591 fh1nRecJetsCuts->Fill(nRecJetsCuts);
2592
2593 if(fJetTypeGen==kJetsKine || fJetTypeGen == kJetsKineAcceptance) fJetsGen->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2594
2595 Int_t nJGen = GetListOfJets(fJetsGen, fJetTypeGen);
2596 Int_t nGenJets = 0;
2597 if(nJGen>=0) nGenJets = fJetsGen->GetEntries();
2598 if(fDebug>2)Printf("%s:%d Selected Gen jets: %d %d",(char*)__FILE__,__LINE__,nJGen,nGenJets);
2599
2600 if(nJGen != nGenJets) Printf("%s:%d Mismatch selected Gen jets: %d %d",(char*)__FILE__,__LINE__,nJGen,nGenJets);
2601 fh1nGenJets->Fill(nGenJets);
2602
2603
2604 if(fJetTypeRecEff==kJetsKine || fJetTypeRecEff == kJetsKineAcceptance) fJetsRecEff->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2605 Int_t nJRecEff = GetListOfJets(fJetsRecEff, fJetTypeRecEff);
2606 Int_t nRecEffJets = 0;
2607 if(nJRecEff>=0) nRecEffJets = fJetsRecEff->GetEntries();
2608 if(fDebug>2)Printf("%s:%d Selected RecEff jets: %d %d",(char*)__FILE__,__LINE__,nJRecEff,nRecEffJets);
2609 if(nJRecEff != nRecEffJets) Printf("%s:%d Mismatch selected RecEff jets: %d %d",(char*)__FILE__,__LINE__,nJRecEff,nRecEffJets);
2610 fh1nRecEffJets->Fill(nRecEffJets);
2611
2612
2613 Int_t nEmbeddedJets = 0;
2614 TArrayI iEmbeddedMatchIndex;
2615 TArrayF fEmbeddedPtFraction;
2616
2617
2618 if(fBranchEmbeddedJets.Length()){
2619 Int_t nJEmbedded = GetListOfJets(fJetsEmbedded, kJetsEmbedded);
2620 if(nJEmbedded>=0) nEmbeddedJets = fJetsEmbedded->GetEntries();
2621 if(fDebug>2)Printf("%s:%d Selected Embedded jets: %d %d",(char*)__FILE__,__LINE__,nJEmbedded,nEmbeddedJets);
2622 if(nJEmbedded != nEmbeddedJets) Printf("%s:%d Mismatch Selected Embedded Jets: %d %d",(char*)__FILE__,__LINE__,nJEmbedded,nEmbeddedJets);
2623 fh1nEmbeddedJets->Fill(nEmbeddedJets);
2624
2625 Float_t maxDist = 0.3;
2626
2627 iEmbeddedMatchIndex.Set(nEmbeddedJets);
2628 fEmbeddedPtFraction.Set(nEmbeddedJets);
2629
2630 iEmbeddedMatchIndex.Reset(-1);
2631 fEmbeddedPtFraction.Reset(0);
2632
2633 AliAnalysisHelperJetTasks::GetJetMatching(fJetsEmbedded, nEmbeddedJets,
2634 fJetsRecCuts, nRecJetsCuts,
2635 iEmbeddedMatchIndex, fEmbeddedPtFraction,
2636 fDebug, maxDist);
2637
2638 }
2639
2640 //____ fetch background clusters ___________________________________________________
2641 if(fBckgMode &&
2642 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
2643 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
2644 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)){
2645
2646 Int_t nBJ = GetListOfBckgJets(fBckgJetsRec, kJetsRec);
2647 Int_t nRecBckgJets = 0;
2648 if(nBJ>=0) nRecBckgJets = fBckgJetsRec->GetEntries();
2649 if(fDebug>2)Printf("%s:%d Selected Rec background jets: %d %d",(char*)__FILE__,__LINE__,nBJ,nRecBckgJets);
2650 if(nBJ != nRecBckgJets) Printf("%s:%d Mismatch Selected Rec background jets: %d %d",(char*)__FILE__,__LINE__,nBJ,nRecBckgJets);
2651
2652 Int_t nBJCuts = GetListOfBckgJets(fBckgJetsRecCuts, kJetsRecAcceptance);
2653 Int_t nRecBckgJetsCuts = 0;
2654 if(nBJCuts>=0) nRecBckgJetsCuts = fBckgJetsRecCuts->GetEntries();
2655 if(fDebug>2)Printf("%s:%d Selected Rec background jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2656 if(nRecBckgJetsCuts != nBJCuts) Printf("%s:%d Mismatch selected Rec background jets after cuts: %d %d",(char*)__FILE__,__LINE__,nBJCuts,nRecBckgJetsCuts);
2657 fh1nRecBckgJetsCuts->Fill(nRecBckgJetsCuts);
2658
2659 if(0){ // protection OB - not yet implemented
2660 if(fJetTypeGen==kJetsKine || fJetTypeGen == kJetsKineAcceptance) fBckgJetsGen->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2661 Int_t nBJGen = GetListOfBckgJets(fBckgJetsGen, fJetTypeGen);
2662 Int_t nGenBckgJets = 0;
2663 if(nBJGen>=0) nGenBckgJets = fBckgJetsGen->GetEntries();
2664 if(fDebug>2)Printf("%s:%d Selected Gen background jets: %d %d",(char*)__FILE__,__LINE__,nBJGen,nGenBckgJets);
2665 if(nBJGen != nGenBckgJets) Printf("%s:%d Mismatch selected Gen background jets: %d %d",(char*)__FILE__,__LINE__,nBJGen,nGenBckgJets);
2666 fh1nGenBckgJets->Fill(nGenBckgJets);
2667 }
2668 }
2669
2670
2671 //____ fetch particles __________________________________________________________
2672
2673 Int_t nTCuts;
2674 if(fUseExtraTracks == 1) nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODExtraCuts);
2675 else if(fUseExtraTracks == -1) nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODExtraonlyCuts);
2676 else nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODCuts);
2677
2678 Int_t nRecPartCuts = 0;
2679 if(nTCuts>=0) nRecPartCuts = fTracksRecCuts->GetEntries();
2680 if(fDebug>2)Printf("%s:%d Selected Rec tracks after cuts: %d %d",(char*)__FILE__,__LINE__,nTCuts,nRecPartCuts);
2681 if(nRecPartCuts != nTCuts) Printf("%s:%d Mismatch selected Rec tracks after cuts: %d %d",
2682 (char*)__FILE__,__LINE__,nTCuts,nRecPartCuts);
2683 fh1EvtMult->Fill(nRecPartCuts);
2684
2685
2686 Int_t nTGen = GetListOfTracks(fTracksGen,fTrackTypeGen);
2687 Int_t nGenPart = 0;
2688 if(nTGen>=0) nGenPart = fTracksGen->GetEntries();
2689 if(fDebug>2)Printf("%s:%d Selected Gen tracks: %d %d",(char*)__FILE__,__LINE__,nTGen,nGenPart);
2690 if(nGenPart != nTGen) Printf("%s:%d Mismatch selected Gen tracks: %d %d",(char*)__FILE__,__LINE__,nTGen,nGenPart);
2691
2692 // Just cut on filterBit, but take the full acceptance
2693 Int_t nTCutsEfficiency = GetListOfTracks(fTracksRecCutsEfficiency, kTrackAODQualityCuts);
2694 Int_t nRecPartCutsEfficiency = 0;
2695 if(nTCutsEfficiency>=0) nRecPartCutsEfficiency = fTracksRecCutsEfficiency->GetEntries();
2696 if(fDebug>2)Printf("%s:%d Selected Rec tracks efficiency after cuts: %d %d",(char*)__FILE__,__LINE__,
2697 nTCutsEfficiency,nRecPartCutsEfficiency);
2698 if(nRecPartCutsEfficiency != nTCutsEfficiency) Printf("%s:%d Mismatch selected Rec tracks after cuts: %d %d",
2699 (char*)__FILE__,__LINE__,nTCutsEfficiency,nRecPartCutsEfficiency);
2700
2701 AliPIDResponse* pidResponse = 0x0;
856f1166 2702 Bool_t tuneOnDataTPC = kFALSE;
e131b05f 2703 if (fUseJetPIDtask || fUseInclusivePIDtask) {
c4856fb1 2704 if (!inputHandler) {
e131b05f 2705 AliFatal("Input handler needed");
c4856fb1 2706 return;
2707 }
e131b05f 2708 else {
2709 // PID response object
2710 pidResponse = inputHandler->GetPIDResponse();
c4856fb1 2711 if (!pidResponse) {
e131b05f 2712 AliFatal("PIDResponse object was not created");
c4856fb1 2713 return;
2714 }
856f1166 2715 else {
2716 tuneOnDataTPC = pidResponse->IsTunedOnData() &&
2717 ((pidResponse->GetTunedOnDataMask() & AliPIDResponse::kDetTPC) == AliPIDResponse::kDetTPC);
2718 }
e131b05f 2719 }
2720 }
2721
9e95a906 2722 if(fDebug>2)Printf("%s:%d Starting processing...",(char*)__FILE__,__LINE__);
2723
e131b05f 2724 //____ analysis, fill histos ___________________________________________________
2725
2726 if(fQAMode){
2727 // loop over tracks
2728 if(fQAMode&1){
2729 TClonesArray *tca = fUseInclusivePIDtask ? dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName())) : 0x0;
2730
2731 // Fill efficiency for generated primaries and also fill histos for generated yields (primaries + all)
2732 // Efficiency, inclusive - particle level
2733 if (fUseInclusivePIDtask && tca) {
2734 for (Int_t it = 0; it < tca->GetEntriesFast(); it++) {
2735 AliAODMCParticle* part = dynamic_cast<AliAODMCParticle*>(tca->At(it));
2736 if (!part)
2737 continue;
2738
2739 // Define clean MC sample with corresponding particle level track cuts:
2740 // - MC-track must be in desired eta range
2741 // - MC-track must be physical primary
2742 // - Species must be one of those in question
2743
2744 if (part->Eta() > fTrackEtaMax || part->Eta() < fTrackEtaMin)
2745 continue;
2746
2747 Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(part->GetPdgCode());
2748
2749 // Following lines are not needed - just keep other species (like casecades) - will end up in overflow bin
2750 // and only affect the efficiencies for all (i.e. not identified) what is desired!
2751 //if (mcID == AliPID::kUnknown)
2752 // continue;
2753
2754 if (!part->IsPhysicalPrimary())
2755 continue;
2756 /*
2757 Int_t iMother = part->GetMother();
2758 if (iMother >= 0)
2759 continue; // Not a physical primary
2760 */
2761
2762 Double_t pT = part->Pt();
2763
2764 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
2765 Double_t chargeMC = part->Charge() / 3.;
2766
2767 if (TMath::Abs(chargeMC) < 0.01)
2768 continue; // Reject neutral particles (only relevant, if mcID is not used)
2769
2942f542 2770 Double_t valuesGenYield[AliAnalysisTaskPID::kGenYieldNumAxes] = { static_cast<Double_t>(mcID), pT, centPercent, -1, -1, -1, -1 };
e131b05f 2771
2772 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
77324970
CKB		 2773 if (fInclusivePIDtask[i]->IsInAcceptedEtaRange(TMath::Abs(part->Eta()))) {
2774 valuesGenYield[fInclusivePIDtask[i]->GetIndexOfChargeAxisGenYield()] = chargeMC;
2775 fInclusivePIDtask[i]->FillGeneratedYield(valuesGenYield);
2776 }
e131b05f 2777 }
2778
2942f542 2779 Double_t valuesEff[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), pT, part->Eta(), chargeMC,
e131b05f 2780 centPercent, -1, -1, -1 };// no jet pT etc since inclusive spectrum
2781 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
2782 fInclusivePIDtask[i]->FillEfficiencyContainer(valuesEff, AliAnalysisTaskPID::kStepGenWithGenCuts);
2783 }
2784 }
2785
2786 if(fUseInclusivePIDtask){
2787 //Efficiency, inclusive - detector level
2788 for(Int_t it=0; it<nRecPartCutsEfficiency; ++it){
2789 // fill inclusive tracks XXX, they have the same track cuts!
2790 AliAODTrack * inclusiveaod = dynamic_cast<AliAODTrack*>(fTracksRecCutsEfficiency->At(it));
2791 if(inclusiveaod){
856f1166 2792 Double_t dEdxTPC = tuneOnDataTPC ? pidResponse->GetTPCsignalTunedOnData(inclusiveaod)
2793 : inclusiveaod->GetTPCsignal();
e131b05f 2794
2795 if (dEdxTPC <= 0)
2796 continue;
2797
a6852ea8 2798 Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(inclusiveaod, InputEvent());
493982d9 2799 Bool_t survivedTPCnclCut = AliAnalysisTaskPID::TPCnclCut(inclusiveaod);
a6852ea8 2800
e131b05f 2801 Int_t label = TMath::Abs(inclusiveaod->GetLabel());
2802
2803 // find MC track in our list, if available
2804 AliAODMCParticle* gentrack = tca ? dynamic_cast<AliAODMCParticle*>(tca->At(label)) : 0x0;
2805 Int_t pdg = 0;
2806
2807 if (gentrack)
2808 pdg = gentrack->GetPdgCode();
2809
2810 // For efficiency: Reconstructed track has survived all cuts on the detector level (no cut on eta acceptance)
2811 // and has an associated MC track
2812 // -> Check whether associated MC track belongs to the clean MC sample defined above,
2813 // i.e. survives the particle level track cuts
2814 if (gentrack) {
2815 Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(pdg);
2816
2817 // Following lines are not needed - just keep other species (like casecades) - will end up in overflow bin
2818 // and only affect the efficiencies for all (i.e. not identified) what is desired!
2819 //if (mcID == AliPID::kUnknown)
2820 // continue;
2821
2822 // Fill efficiency for reconstructed primaries
2823 if (!gentrack->IsPhysicalPrimary())
2824 continue;
2825 /*
2826 * Int_t iMother = gentrack->GetMother();
2827 * if (iMother >= 0)
2828 * continue; // Not a physical primary
2829 */
2830
2831 if (gentrack->Eta() > fTrackEtaMax || gentrack->Eta() < fTrackEtaMin)
2832 continue;
2833
2834 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
2942f542 2835 Double_t value[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), gentrack->Pt(), gentrack->Eta(), gentrack->Charge() / 3.,
e131b05f 2836 centPercent,
2837 -1, -1, -1 };// no jet pT etc since inclusive spectrum
a6852ea8 2838 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
493982d9
ML		 2839 if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
2840 (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
2841 (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut()))
a6852ea8 2842 fInclusivePIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
2843 }
e131b05f 2844
2942f542 2845 Double_t valueMeas[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), inclusiveaod->Pt(), inclusiveaod->Eta(),
2846 static_cast<Double_t>(inclusiveaod->Charge()), centPercent,
e131b05f 2847 -1, -1, -1 };// no jet pT etc since inclusive spectrum
a6852ea8 2848 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
493982d9
ML		 2849 if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
2850 (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
2851 (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut()))
a6852ea8 2852 fInclusivePIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
2853 }
e131b05f 2854 }
2855 }
2856 }
2857 }
2858
2859
2860 for(Int_t it=0; it<nRecPartCuts; ++it){
2861 AliVParticle *part = dynamic_cast<AliVParticle*>(fTracksRecCuts->At(it));
2862 if(part)fQATrackHistosRecCuts->FillTrackQA( part->Eta(), TVector2::Phi_0_2pi(part->Phi()), part->Pt() );
2863
2864 // fill inclusive tracks XXX, they have the same track cuts!
2865 AliAODTrack * inclusiveaod = dynamic_cast<AliAODTrack*>(fTracksRecCuts->At(it));
2866 if(inclusiveaod){
2867 if(fUseInclusivePIDtask){
856f1166 2868 Double_t dEdxTPC = tuneOnDataTPC ? pidResponse->GetTPCsignalTunedOnData(inclusiveaod)
2869 : inclusiveaod->GetTPCsignal();
e131b05f 2870
2871 if (dEdxTPC <= 0)
2872 continue;
2873
a6852ea8 2874 Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(inclusiveaod, InputEvent());
493982d9 2875 Bool_t survivedTPCnclCut = AliAnalysisTaskPID::TPCnclCut(inclusiveaod);
a6852ea8 2876
e131b05f 2877 Int_t label = TMath::Abs(inclusiveaod->GetLabel());
2878
2879 // find MC track in our list, if available
2880 AliAODMCParticle* gentrack = tca ? dynamic_cast<AliAODMCParticle*>(tca->At(label)) : 0x0;
2881 Int_t pdg = 0;
2882
2883 if (gentrack)
2884 pdg = gentrack->GetPdgCode();
2885
a6852ea8 2886 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
493982d9
ML		 2887 if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
2888 (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
77324970
CKB		 2889 (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut())) {
2890 if (fInclusivePIDtask[i]->IsInAcceptedEtaRange(TMath::Abs(inclusiveaod->Eta())))
2891 fInclusivePIDtask[i]->ProcessTrack(inclusiveaod, pdg, centPercent, -1); // no jet pT since inclusive spectrum
2892 }
a6852ea8 2893 }
e131b05f 2894
2895 if (gentrack) {
2896 Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(pdg);
2942f542 2897 Double_t valueRecAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), inclusiveaod->Pt(), inclusiveaod->Eta(),
2898 static_cast<Double_t>(inclusiveaod->Charge()), centPercent,
e131b05f 2899 -1, -1, -1 };
a6852ea8 2900 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
493982d9
ML		 2901 if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
2902 (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
2903 (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut()))
a6852ea8 2904 fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
2905 }
e131b05f 2906
2907 Double_t weight = IsSecondaryWithStrangeMotherMC(gentrack) ? GetMCStrangenessFactorCMS(gentrack) : 1.0;
a6852ea8 2908 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
493982d9
ML		 2909 if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
2910 (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
2911 (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut()))
a6852ea8 2912 fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
2913 AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
2914 weight);
2915 }
9e95a906 2916
e131b05f 2917 if (gentrack->IsPhysicalPrimary()) {
9e95a906 2918 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
2942f542 2919 Double_t valueGenAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), gentrack->Pt(), gentrack->Eta(),
9e95a906 2920 gentrack->Charge() / 3., centPercent, -1, -1,
2921 -1 };
2922
e4351829 2923 Double_t valuePtResolution[AliAnalysisTaskPID::kPtResNumAxes] = { -1, gentrack->Pt(), inclusiveaod->Pt(),
2924 gentrack->Charge() / 3., centPercent };
9e95a906 2925
2926 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
493982d9
ML		 2927 if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
2928 (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
2929 (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut())) {
a6852ea8 2930 fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
2931 AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
2932 fInclusivePIDtask[i]->FillEfficiencyContainer(valueGenAllCuts,
2933 AliAnalysisTaskPID::kStepRecWithRecCutsPrimaries);
2934
2935 fInclusivePIDtask[i]->FillPtResolution(mcID, valuePtResolution);
2936 }
9e95a906 2937 }
e131b05f 2938 }
2939 }
2940 }
2941 }
2942 }
2943 for(Int_t it=0; it<nGenPart; ++it){
2944 AliVParticle *part = dynamic_cast<AliVParticle*>(fTracksGen->At(it));
2945 if(part)fQATrackHistosGen->FillTrackQA( part->Eta(), TVector2::Phi_0_2pi(part->Phi()), part->Pt());
2946 }
2947 }
2948
2949 // loop over jets
2950 if(fQAMode&2){
2951 for(Int_t ij=0; ij<nRecJets; ++ij){
2952 AliAODJet* jet = dynamic_cast<AliAODJet*>(fJetsRec->At(ij));
2953 if(jet)fQAJetHistosRec->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2954 }
2955 }
2956 }
2957
2958 if(fQAMode || fFFMode){
2959 // generated jets
2960 for(Int_t ij=0; ij<nGenJets; ++ij){
2961 AliAODJet* jet = dynamic_cast<AliAODJet*>(fJetsGen->At(ij));
2962
2963 if(!jet)continue;
2964
2965 if(fQAMode&2) fQAJetHistosGen->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2966
2967 if(fQAMode&2 && (ij==0)) fQAJetHistosGenLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
2968
c4856fb1 2969 if((ij==0) || !fOnlyLeadingJets){ // leading jets or all jets
e131b05f 2970 TList* jettracklist = new TList();
2971 Double_t sumPt = 0.;
2972 Bool_t isBadJet = kFALSE;
2973
2974 if(GetFFRadius()<=0){
2975 GetJetTracksTrackrefs(jettracklist, jet, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
2976 } else {
2977 GetJetTracksPointing(fTracksGen, jettracklist, jet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
2978 }
2979
2980 if(GetFFMinNTracks()>0 && jettracklist->GetSize()<=GetFFMinNTracks()) isBadJet = kTRUE;
2981 if(isBadJet) continue;
2982
2983 for(Int_t it=0; it<jettracklist->GetSize(); ++it){
2984
2985 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(jettracklist->At(it));
2986 if(!trackVP)continue;
2987 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
2988
2989 Float_t jetPt = jet->Pt();
2990 Float_t trackPt = trackV->Pt();
2991
2992 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2993
2994 if(fFFMode && (ij==0)) fFFHistosGen->FillFF( trackPt, jetPt, incrementJetPt );
2995 if(fFFMode) fFFHistosGenInc->FillFF( trackPt, jetPt, incrementJetPt );
2996 if(it==0){ // leading track
2997 if(fFFMode) fFFHistosGenLeadingTrack->FillFF( trackPt, jetPt, kTRUE );
2998 }
2999
3000 if (fUseJetPIDtask && incrementJetPt) {
3001 for (Int_t i = 0; i < fNumJetPIDtasks; i++)
3002 fJetPIDtask[i]->FillGenJets(fJetPIDtask[i]->GetCentralityPercentile(evtForCentDetermination), jetPt);
3003 }
3004
3005 if (fIDFFMode) {
3006 Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(trackVP->PdgCode());
3007 if (mcID != AliPID::kUnknown) {
3008 // WARNING: The number of jets for the different species does not make sense -> One has to take
3009 // the number of jets for ALL particles. Thus, just do not fill the num of jet histos in order
3010 // not to get confused
3011 fIDFFHistosGen[mcID]->FillFF(trackPt, jetPt, kFALSE);
3012 }
3013 /*
3014 Int_t pidWeightedSpecies = fJetPIDtask->GetRandomParticleTypeAccordingToParticleFractions(trackPt, jetPt, centPercent, kTRUE);
3015 if (pidWeightedSpecies < 0 || pidWeightedSpecies >= AliPID::kSPECIES) {
3016 Printf("Failed to determine particle ID for track in jet (gen) -> ID FF histos not filled with this track!");
3017 Printf("Track details: trackPt %f, jetPt %f, centrality %f!", trackPt, jetPt, centPercent);
3018 }
3019 else {
3020 // WARNING: The number of jets for the different species does not make sense -> One has to take
3021 // the number of jets for ALL particles. Thus, just do not fill the num of jet histos in order
3022 // not to get confused
3023 fIDFFHistosGen[pidWeightedSpecies]->FillFF(trackPt, jetPt, kFALSE);
3024 }
3025 */
3026 }
3027
3028 delete trackV;
3029
3030 // Efficiency, jets - particle level
3031 if (fUseJetPIDtask) {
3032 AliAODMCParticle* part = dynamic_cast<AliAODMCParticle*>(jettracklist->At(it));
3033 if (!part) {
3034 AliError("expected ref track not found ");
3035 continue;
3036 }
3037 // Fill efficiency for generated primaries and also fill histos for generated yields (primaries + all)
3038 if (part->Eta() > fTrackEtaMax || part->Eta() < fTrackEtaMin)
3039 continue;
3040
3041 Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(part->GetPdgCode());
3042
3043 // Following lines are not needed - just keep other species (like casecades) - will end up in overflow bin
3044 // and only affect the efficiencies for all (i.e. not identified) what is desired!
3045 //if (mcID == AliPID::kUnknown)
3046 // continue;
3047
3048 if (!part->IsPhysicalPrimary())
3049 continue;
3050 //
3051 // Int_t iMother = part->GetMother();
3052 // if (iMother >= 0)
3053 // continue; // Not a physical primary
3054 //
3055
3056 Double_t z = -1., xi = -1.;
3057 AliAnalysisTaskPID::GetJetTrackObservables(trackPt, jetPt, z, xi);
3058
3059 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
3060 Double_t chargeMC = part->Charge() / 3.;
3061
3062 if (TMath::Abs(chargeMC) < 0.01)
3063 continue; // Reject neutral particles (only relevant, if mcID is not used)
3064
2942f542 3065 Double_t valuesGenYield[AliAnalysisTaskPID::kGenYieldNumAxes] = { static_cast<Double_t>(mcID), trackPt, centPercent, jetPt, z, xi, chargeMC };
e131b05f 3066
3067 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
77324970
CKB		 3068 if (fJetPIDtask[i]->IsInAcceptedEtaRange(TMath::Abs(part->Eta()))) {
3069 valuesGenYield[fJetPIDtask[i]->GetIndexOfChargeAxisGenYield()] = chargeMC;
3070 fJetPIDtask[i]->FillGeneratedYield(valuesGenYield);
3071 }
e131b05f 3072 }
3073
3074
2942f542 3075 Double_t valuesEff[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), trackPt, part->Eta(), chargeMC,
e131b05f 3076 centPercent, jetPt, z, xi };
3077 for (Int_t i = 0; i < fNumJetPIDtasks; i++)
3078 fJetPIDtask[i]->FillEfficiencyContainer(valuesEff, AliAnalysisTaskPID::kStepGenWithGenCuts);
3079 }
3080 }
3081
3082 if(fBckgMode){
3083 if(fBckgType[0]!=kBckgNone)
3084 FillBckgHistos(fBckgType[0], fTracksGen, fJetsGen, jet,
3085 fFFBckgHisto0Gen, fQABckgHisto0Gen);
3086 if(fBckgType[1]!=kBckgNone)
3087 FillBckgHistos(fBckgType[1], fTracksGen, fJetsGen, jet,
3088 fFFBckgHisto1Gen, fQABckgHisto1Gen);
3089 if(fBckgType[2]!=kBckgNone)
3090 FillBckgHistos(fBckgType[2], fTracksGen, fJetsGen, jet,
3091 fFFBckgHisto2Gen, fQABckgHisto2Gen);
3092 if(fBckgType[3]!=kBckgNone)
3093 FillBckgHistos(fBckgType[3], fTracksGen, fJetsGen, jet,
3094 fFFBckgHisto3Gen, fQABckgHisto3Gen);
3095 if(fBckgType[4]!=kBckgNone)
3096 FillBckgHistos(fBckgType[4], fTracksGen, fJetsGen, jet,
3097 fFFBckgHisto4Gen, fQABckgHisto4Gen);
3098 } // end if(fBckgMode)
3099
3100
3101 if(fJSMode) FillJetShape(jet, jettracklist, fProNtracksLeadingJetGen, fProDelRPtSumGen, fProDelR80pcPtGen);
3102
3103 delete jettracklist;
3104 }
3105 }
3106
3107
3108 for(Int_t ij=0; ij<nRecJetsCuts; ++ij){
3109
3110 AliAODJet* jet = (AliAODJet*)(fJetsRecCuts->At(ij));
3111 if(fQAMode&2) fQAJetHistosRecCuts->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
3112 if(fQAMode&2 && (ij==0)) fQAJetHistosRecCutsLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
3113
c4856fb1 3114 if((ij==0) || !fOnlyLeadingJets){ // leading jets or all jets
e131b05f 3115
3116 Double_t ptFractionEmbedded = 0;
3117 AliAODJet* embeddedJet = 0;
3118
3119 if(fBranchEmbeddedJets.Length()){ // find embedded jet
3120
3121 Int_t indexEmbedded = -1;
3122 for(Int_t i=0; i<nEmbeddedJets; i++){
3123 if(iEmbeddedMatchIndex[i] == ij){
3124 indexEmbedded = i;
3125 ptFractionEmbedded = fEmbeddedPtFraction[i];
3126 }
3127 }
3128
3129 fh1IndexEmbedded->Fill(indexEmbedded);
3130 fh1FractionPtEmbedded->Fill(ptFractionEmbedded);
3131
3132 if(indexEmbedded>-1){
3133
3134 embeddedJet = dynamic_cast<AliAODJet*>(fJetsEmbedded->At(indexEmbedded));
3135 if(!embeddedJet) continue;
3136
3137 Double_t deltaPt = jet->Pt() - embeddedJet->Pt();
3138 Double_t deltaR = jet->DeltaR((AliVParticle*) (embeddedJet));
3139
3140 fh2DeltaPtVsJetPtEmbedded->Fill(embeddedJet->Pt(),deltaPt);
3141 fh2DeltaPtVsRecJetPtEmbedded->Fill(jet->Pt(),deltaPt);
3142 fh1DeltaREmbedded->Fill(deltaR);
3143 }
3144 }
3145
3146 // get tracks in jet
3147 TList* jettracklist = new TList();
3148 Double_t sumPt = 0.;
3149 Bool_t isBadJet = kFALSE;
3150
3151 if(GetFFRadius()<=0){
3152 GetJetTracksTrackrefs(jettracklist, jet, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
3153 } else {
3154 if(fUseEmbeddedJetAxis){
3155 if(embeddedJet) GetJetTracksPointing(fTracksRecCuts, jettracklist, embeddedJet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
3156 }
3157 else GetJetTracksPointing(fTracksRecCuts, jettracklist, jet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
3158 }
3159
3160 if(GetFFMinNTracks()>0 && jettracklist->GetSize()<=GetFFMinNTracks()) isBadJet = kTRUE;
3161
3162 if(isBadJet) continue;
3163
3164 if(ptFractionEmbedded>=fCutFractionPtEmbedded){ // if no embedding: ptFraction = cutFraction = 0
3165
3166 TClonesArray *tca = fUseJetPIDtask ? dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName())) : 0x0;
3167
3168 for(Int_t it=0; it<jettracklist->GetSize(); ++it){
3169 AliAODTrack * aodtrack = dynamic_cast<AliAODTrack*>(jettracklist->At(it));
3170 if(!aodtrack) continue;
3171
3172 Double_t pT = aodtrack->Pt();
3173 Float_t jetPt = jet->Pt();
3174 if(fUseEmbeddedJetPt){
3175 if(embeddedJet) jetPt = embeddedJet->Pt();
3176 else jetPt = 0;
3177 }
3178
3179 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
3180
3181 if(fFFMode && (ij==0)) fFFHistosRecCuts->FillFF(pT, jetPt, incrementJetPt);
3182 if(fFFMode) fFFHistosRecCutsInc->FillFF(pT, jetPt, incrementJetPt);
3183
3184 if(it==0){ // leading track
3185 if(fFFMode) fFFHistosRecLeadingTrack->FillFF(pT, jetPt, kTRUE);
3186 }
3187
3188 if (fUseJetPIDtask && incrementJetPt) {
3189 for (Int_t i = 0; i < fNumJetPIDtasks; i++)
3190 fJetPIDtask[i]->FillRecJets(fJetPIDtask[i]->GetCentralityPercentile(evtForCentDetermination), jetPt);
3191 }
3192
3193 if (fUseJetPIDtask) {
856f1166 3194 Double_t dEdxTPC = tuneOnDataTPC ? pidResponse->GetTPCsignalTunedOnData(aodtrack)
3195 : aodtrack->GetTPCsignal();
e131b05f 3196
3197 if (dEdxTPC <= 0)
3198 continue;
3199
a6852ea8 3200 Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(aodtrack, InputEvent());
493982d9 3201 Bool_t survivedTPCnclCut = AliAnalysisTaskPID::TPCnclCut(aodtrack);
a6852ea8 3202
e131b05f 3203 Int_t label = TMath::Abs(aodtrack->GetLabel());
3204
3205 // Find MC track in our list, if available
3206 AliAODMCParticle* gentrack = tca ? dynamic_cast<AliAODMCParticle*>(tca->At(label)) : 0x0;
3207 Int_t pdg = 0;
3208 Int_t mcID = AliPID::kUnknown;
3209
3210 if (gentrack) {
3211 pdg = gentrack->GetPdgCode();
3212
3213 // Secondaries, jets
3214 mcID = AliAnalysisTaskPID::PDGtoMCID(pdg);
3215
3216 Double_t z = -1., xi = -1.;
3217 AliAnalysisTaskPID::GetJetTrackObservables(pT, jetPt, z, xi);
3218
2942f542 3219 Double_t valueRecAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), pT, aodtrack->Eta(), static_cast<Double_t>(aodtrack->Charge()),
e131b05f 3220 centPercent, jetPt, z, xi };
a6852ea8 3221 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
493982d9
ML		 3222 if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
3223 (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
3224 (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut()))
a6852ea8 3225 fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
3226 }
e131b05f 3227
3228 Double_t weight = IsSecondaryWithStrangeMotherMC(gentrack) ? GetMCStrangenessFactorCMS(gentrack) : 1.0;
a6852ea8 3229 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
493982d9
ML		 3230 if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
3231 (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
3232 (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut()))
a6852ea8 3233 fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
3234 AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
3235 weight);
3236 }
9e95a906 3237
e131b05f 3238 if (gentrack->IsPhysicalPrimary()) {
9e95a906 3239 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
3240 Double_t genPt = gentrack->Pt();
3241 Double_t genZ = -1., genXi = -1.;
3242 AliAnalysisTaskPID::GetJetTrackObservables(genPt, jetPt, genZ, genXi);
2942f542 3243 Double_t valueGenAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), genPt, gentrack->Eta(),
9e95a906 3244 gentrack->Charge() / 3., centPercent, jetPt, genZ,
3245 genXi };
3246
e4351829 3247 Double_t valuePtResolution[AliAnalysisTaskPID::kPtResNumAxes] = { jetPt, genPt, pT, gentrack->Charge() / 3., centPercent };
9e95a906 3248
3249 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
493982d9
ML		 3250 if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
3251 (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
3252 (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut())) {
a6852ea8 3253 fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
3254 AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
3255 fJetPIDtask[i]->FillEfficiencyContainer(valueGenAllCuts,
3256 AliAnalysisTaskPID::kStepRecWithRecCutsPrimaries);
3257
3258 fJetPIDtask[i]->FillPtResolution(mcID, valuePtResolution);
3259 }
9e95a906 3260 }
e131b05f 3261 }
3262 }
3263
a6852ea8 3264 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
493982d9
ML		 3265 if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
3266 (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
77324970
CKB		 3267 (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut())) {
3268 if (fJetPIDtask[i]->IsInAcceptedEtaRange(TMath::Abs(aodtrack->Eta())))
3269 fJetPIDtask[i]->ProcessTrack(aodtrack, pdg, centPercent, jetPt);
3270 }
a6852ea8 3271 }
e131b05f 3272
493982d9
ML		 3273 if (fIDFFMode && ((!fJetPIDtask[0]->GetUseTPCCutMIGeo() && !fJetPIDtask[0]->GetUseTPCnclCut()) ||
3274 (survivedTPCCutMIGeo && fJetPIDtask[0]->GetUseTPCCutMIGeo()) ||
3275 (survivedTPCnclCut && fJetPIDtask[0]->GetUseTPCnclCut()))) {
e131b05f 3276 // NOTE: Just take particle fraction from first task (should anyway be the same for all tasks)
3277 Int_t pidWeightedSpecies = fJetPIDtask[0]->GetRandomParticleTypeAccordingToParticleFractions(pT, jetPt,
3278 centPercent, kTRUE);
3279 if (pidWeightedSpecies < 0 || pidWeightedSpecies >= AliPID::kSPECIES) {
3280 Printf("Failed to determine particle ID for track in jet (recCuts) -> ID FF histos not filled with this track!");
3281 Printf("Track details: trackPt %f, jetPt %f, centrality %f!", pT, jetPt, centPercent);
3282 }
3283 else {
3284 // WARNING: The number of jets for the different species does not make sense -> One has to take
3285 // the number of jets for ALL particles. Thus, just do not fill the num of jet histos in order
3286 // not to get confused
3287 fIDFFHistosRecCuts[pidWeightedSpecies]->FillFF(aodtrack->Pt(), jetPt, kFALSE);
3288 }
3289 }
3290
3291 // Efficiency, jets - detector level
3292 if (gentrack) {
3293 // Following lines are not needed - just keep other species (like casecades) - will end up in overflow bin
3294 // and only affect the efficiencies for all (i.e. not identified) what is desired!
3295 //if (mcID == AliPID::kUnknown)
3296 // continue;
3297
3298 // Fill efficiency for reconstructed primaries
3299 if (!gentrack->IsPhysicalPrimary())
3300 continue;
3301 /*
3302 Int_t iMother = gentrack->GetMother();
3303 if (iMother >= 0)
3304 continue; // Not a physical primary
3305 */
3306
3307 if (gentrack->Eta() > fTrackEtaMax || gentrack->Eta() < fTrackEtaMin)
3308 continue;
3309
3310 Double_t genZ = -1., genXi = -1.;
3311 Double_t genPt = gentrack->Pt();
3312 AliAnalysisTaskPID::GetJetTrackObservables(genPt, jetPt, genZ, genXi);
3313
3314 Double_t measZ = -1., measXi = -1.;
3315 Double_t measPt = aodtrack->Pt();
3316 AliAnalysisTaskPID::GetJetTrackObservables(measPt, jetPt, measZ, measXi);
3317
3318
3319 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
2942f542 3320 Double_t value[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), genPt, gentrack->Eta(), gentrack->Charge() / 3.,
e131b05f 3321 centPercent, jetPt, genZ, genXi };
a6852ea8 3322 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
493982d9
ML		 3323 if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
3324 (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
3325 (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut()))
a6852ea8 3326 fJetPIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
3327 }
e131b05f 3328
2942f542 3329 Double_t valueMeas[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), measPt, aodtrack->Eta(), static_cast<Double_t>(aodtrack->Charge()),
e131b05f 3330 centPercent, jetPt, measZ, measXi };
a6852ea8 3331 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
493982d9
ML		 3332 if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
3333 (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
3334 (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut()))
a6852ea8 3335 fJetPIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
3336 }
e131b05f 3337 }
3338 }
3339 }
3340
3341 // background ff
3342 if(fBckgMode && (ij==0)){
3343 if(fBckgType[0]!=kBckgNone)
3344 FillBckgHistos(fBckgType[0], fTracksRecCuts, fJetsRecCuts, jet,
3345 fFFBckgHisto0RecCuts,fQABckgHisto0RecCuts, fh1BckgMult0);
3346 if(fBckgType[1]!=kBckgNone)
3347 FillBckgHistos(fBckgType[1], fTracksRecCuts, fJetsRecCuts, jet,
3348 fFFBckgHisto1RecCuts,fQABckgHisto1RecCuts, fh1BckgMult1);
3349 if(fBckgType[2]!=kBckgNone)
3350 FillBckgHistos(fBckgType[2], fTracksRecCuts, fJetsRecCuts, jet,
3351 fFFBckgHisto2RecCuts,fQABckgHisto2RecCuts, fh1BckgMult1);
3352 if(fBckgType[3]!=kBckgNone)
3353 FillBckgHistos(fBckgType[3], fTracksRecCuts, fJetsRecCuts, jet,
3354 fFFBckgHisto3RecCuts,fQABckgHisto3RecCuts, fh1BckgMult2);
3355 if(fBckgType[4]!=kBckgNone)
3356 FillBckgHistos(fBckgType[4], fTracksRecCuts, fJetsRecCuts, jet,
3357 fFFBckgHisto4RecCuts,fQABckgHisto4RecCuts, fh1BckgMult3);
3358 } // end if(fBckgMode)
3359
3360
3361 if(fJSMode && (ij==0)) FillJetShape(jet, jettracklist, fProNtracksLeadingJet, fProDelRPtSum, fProDelR80pcPt);
3362
3363 delete jettracklist;
3364
3365 } // end: cut embedded ratio
c4856fb1 3366 } // end: leading jet or all jets
e131b05f 3367 } // end: rec. jets after cuts
3368 } // end: QA, FF and intra-jet
3369
3370
3371 // ____ efficiency _______________________________
3372
3373 if(fEffMode && (fJetTypeRecEff != kJetsUndef)){
3374
3375 // arrays holding for each generated particle the reconstructed AOD track index & isPrimary flag, are initialized in AssociateGenRec(...) function
3376 TArrayI indexAODTr;
3377 TArrayS isGenPrim;
3378
3379 // array holding for each reconstructed AOD track generated particle index, initialized in AssociateGenRec(...) function
3380 TArrayI indexMCTr;
3381
3382 // ... and another set for secondaries from strange/non strange mothers (secondary MC tracks are stored in different lists)
3383 TArrayI indexAODTrSecNS;
3384 TArrayS isGenSecNS;
3385 TArrayI indexMCTrSecNS;
3386
3387 TArrayI indexAODTrSecS;
3388 TArrayS isGenSecS;
3389 TArrayI indexMCTrSecS;
3390
3391 Int_t nTracksAODMCCharged = GetListOfTracks(fTracksAODMCCharged, kTrackAODMCCharged);
3392 if(fDebug>2)Printf("%s:%d selected AODMC tracks: %d ",(char*)__FILE__,__LINE__,nTracksAODMCCharged);
3393
3394 Int_t nTracksAODMCChargedSecNS = GetListOfTracks(fTracksAODMCChargedSecNS, kTrackAODMCChargedSecNS);
3395 if(fDebug>2)Printf("%s:%d selected AODMC secondary tracks NS: %d ",(char*)__FILE__,__LINE__,nTracksAODMCChargedSecNS);
3396
3397 Int_t nTracksAODMCChargedSecS = GetListOfTracks(fTracksAODMCChargedSecS, kTrackAODMCChargedSecS);
3398 if(fDebug>2)Printf("%s:%d selected AODMC secondary tracks S: %d ",(char*)__FILE__,__LINE__,nTracksAODMCChargedSecS);
3399
3400 Int_t nTracksRecQualityCuts = GetListOfTracks(fTracksRecQualityCuts, kTrackAODQualityCuts);
3401 if(fDebug>2)Printf("%s:%d selected rec tracks quality after cuts, full acceptance/pt : %d ",(char*)__FILE__,__LINE__,nTracksRecQualityCuts);
3402
3403 // associate gen and rec tracks, store indices in TArrays
3404 AssociateGenRec(fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,indexMCTr,isGenPrim,fh2PtRecVsGenPrim);
3405 AssociateGenRec(fTracksAODMCChargedSecNS,fTracksRecQualityCuts,indexAODTrSecNS,indexMCTrSecNS,isGenSecNS,fh2PtRecVsGenSec);
3406 AssociateGenRec(fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,indexMCTrSecS,isGenSecS,fh2PtRecVsGenSec);
3407
3408 // single track eff
3409 if(fQAMode&1) FillSingleTrackHistosRecGen(fQATrackHistosRecEffGen,fQATrackHistosRecEffRec,fTracksAODMCCharged,indexAODTr,isGenPrim);
3410
3411 // secondaries
3412 if(fQAMode&1) FillSingleTrackHistosRecGen(0x0,fQATrackHistosSecRecNS,fTracksAODMCChargedSecNS,indexAODTrSecNS,isGenSecNS);
3413 if(fQAMode&1) FillSingleTrackHistosRecGen(0x0,fQATrackHistosSecRecS,fTracksAODMCChargedSecS,indexAODTrSecS,isGenSecS);
3414 if(fQAMode&1) FillSingleTrackHistosRecGen(0x0,fQATrackHistosSecRecSsc,fTracksAODMCChargedSecS,indexAODTrSecS,isGenSecS,kTRUE);
3415
3416
3417 // jet track eff
3418 Double_t sumPtGenLeadingJetRecEff = 0;
3419 Double_t sumPtGenLeadingJetSec = 0;
3420 Double_t sumPtRecLeadingJetRecEff = 0;
3421
3422 for(Int_t ij=0; ij<nRecEffJets; ++ij){ // jet loop
3423
3424 AliAODJet* jet = (AliAODJet*)(fJetsRecEff->At(ij));
3425
3426 Bool_t isBadJetGenPrim = kFALSE;
3427 Bool_t isBadJetGenSec = kFALSE;
3428 Bool_t isBadJetRec = kFALSE;
3429
3430
c4856fb1 3431 if((ij==0) || !fOnlyLeadingJets){ // leading jets or all jets
e131b05f 3432
3433 // for efficiency: gen tracks from pointing with gen/rec jet
3434 TList* jettracklistGenPrim = new TList();
3435
3436 // if radius<0 -> trackRefs: collect gen tracks in wide radius + fill FF recEff rec histos with tracks contained in track refs
3437 // note : FF recEff gen histos will be somewhat useless in this approach
3438
3439 if(GetFFRadius() >0)
3440 GetJetTracksPointing(fTracksAODMCCharged, jettracklistGenPrim, jet, GetFFRadius(), sumPtGenLeadingJetRecEff, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetGenPrim);
3441 else
3442 GetJetTracksPointing(fTracksAODMCCharged, jettracklistGenPrim, jet, TMath::Abs(GetFFRadius())+0.2, sumPtGenLeadingJetRecEff, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetGenPrim);
3443
3444 TList* jettracklistGenSecNS = new TList();
3445 if(GetFFRadius() >0)
3446 GetJetTracksPointing(fTracksAODMCChargedSecNS, jettracklistGenSecNS, jet, GetFFRadius(), sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
3447 else
3448 GetJetTracksPointing(fTracksAODMCChargedSecNS, jettracklistGenSecNS, jet, TMath::Abs(GetFFRadius())+0.2, sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
3449
3450 TList* jettracklistGenSecS = new TList();
3451 if(GetFFRadius() >0)
3452 GetJetTracksPointing(fTracksAODMCChargedSecS, jettracklistGenSecS, jet, GetFFRadius(), sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
3453 else
3454 GetJetTracksPointing(fTracksAODMCChargedSecS, jettracklistGenSecS, jet, TMath::Abs(GetFFRadius())+0.2, sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
3455
3456
3457 // bin efficiency in jet pt bins using rec tracks
3458 TList* jettracklistRec = new TList();
3459 if(GetFFRadius() >0) GetJetTracksPointing(fTracksRecCuts,jettracklistRec, jet, GetFFRadius(), sumPtRecLeadingJetRecEff, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetRec);
3460 else GetJetTracksTrackrefs(jettracklistRec, jet, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetRec);
3461
3462
3463 Double_t jetEta = jet->Eta();
3464 Double_t jetPhi = TVector2::Phi_0_2pi(jet->Phi());
3465
3466 if(GetFFMinNTracks()>0 && jettracklistGenPrim->GetSize()<=GetFFMinNTracks()) isBadJetGenPrim = kTRUE;
3467 if(GetFFMinNTracks()>0 && jettracklistGenSecNS->GetSize()<=GetFFMinNTracks()) isBadJetGenSec = kTRUE;
3468 if(GetFFMinNTracks()>0 && jettracklistRec->GetSize()<=GetFFMinNTracks()) isBadJetRec = kTRUE;
3469
3470 if(isBadJetRec) continue;
3471
3472 if(fQAMode&2) fQAJetHistosRecEffLeading->FillJetQA( jetEta, jetPhi, sumPtGenLeadingJetRecEff );
3473
3474 if(fFFMode){
3475
3476 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosRecEffRec,jet,
3477 jettracklistGenPrim,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim,
3478 0,kFALSE,fJSMode,fProNtracksLeadingJetRecPrim,fProDelRPtSumRecPrim,fProDelR80pcPtRecPrim);
3479
3480 else FillJetTrackHistosRec(fFFHistosRecEffRec,jet,
3481 jettracklistGenPrim,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim,
3482 jettracklistRec,kFALSE,fJSMode,fProNtracksLeadingJetRecPrim,fProDelRPtSumRecPrim,fProDelR80pcPtRecPrim);
3483
3484
3485 // secondaries: use jet pt from primaries
3486 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosSecRecNS,jet,
3487 jettracklistGenSecNS,fTracksAODMCChargedSecNS,fTracksRecQualityCuts, indexAODTrSecNS,isGenSecNS,
3488 0,kFALSE,fJSMode,fProNtracksLeadingJetRecSecNS,fProDelRPtSumRecSecNS);
3489
3490 else FillJetTrackHistosRec(fFFHistosSecRecNS,jet,
3491 jettracklistGenSecNS,fTracksAODMCChargedSecNS,fTracksRecQualityCuts,indexAODTrSecNS,isGenSecNS,
3492 jettracklistRec,kFALSE,fJSMode,fProNtracksLeadingJetRecSecNS,fProDelRPtSumRecSecNS);
3493
3494 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosSecRecS,jet,
3495 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
3496 0,kFALSE,fJSMode,fProNtracksLeadingJetRecSecS,fProDelRPtSumRecSecS);
3497
3498 else FillJetTrackHistosRec(fFFHistosSecRecS,jet,
3499 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
3500 jettracklistRec,kFALSE,fJSMode,fProNtracksLeadingJetRecSecS,fProDelRPtSumRecSecS);
3501
3502 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosSecRecSsc,jet,
3503 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
3504 0,kTRUE,fJSMode,fProNtracksLeadingJetRecSecSsc,fProDelRPtSumRecSecSsc);
3505
3506 else FillJetTrackHistosRec(fFFHistosSecRecSsc,jet,
3507 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
3508 jettracklistRec,kTRUE,fJSMode,fProNtracksLeadingJetRecSecSsc,fProDelRPtSumRecSecSsc);
3509 }
3510
3511 delete jettracklistGenPrim;
3512 delete jettracklistGenSecNS;
3513 delete jettracklistGenSecS;
3514 delete jettracklistRec;
3515
3516
3517 if(fBckgMode && fFFMode){
3518
3519 TList* perpjettracklistGen = new TList();
3520 TList* perpjettracklistGen1 = new TList();
3521 TList* perpjettracklistGen2 = new TList();
3522
3523 //Double_t sumPtGenPerp = 0.;
3524 Double_t sumPtGenPerp1 = 0.;
3525 Double_t sumPtGenPerp2 = 0.;
3526 GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksAODMCCharged, perpjettracklistGen1, jet, TMath::Abs(GetFFRadius()) , sumPtGenPerp1);
3527 GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2.,fTracksAODMCCharged, perpjettracklistGen2, jet, TMath::Abs(GetFFRadius()) ,
3528 sumPtGenPerp2);
3529
3530 perpjettracklistGen->AddAll(perpjettracklistGen1);
3531 perpjettracklistGen->AddAll(perpjettracklistGen2);
3532 //sumPtGenPerp = 0.5*(sumPtGenPerp1+sumPtGenPerp2);
3533
3534 TList* perpjettracklistGenSecNS = new TList();
3535 TList* perpjettracklistGenSecNS1 = new TList();
3536 TList* perpjettracklistGenSecNS2 = new TList();
3537
3538 //Double_t sumPtGenPerpNS = 0.;
3539 Double_t sumPtGenPerpNS1 = 0.;
3540 Double_t sumPtGenPerpNS2 = 0.;
3541 GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksAODMCChargedSecNS, perpjettracklistGenSecNS1, jet, TMath::Abs(GetFFRadius()) ,
3542 sumPtGenPerpNS1);
3543 GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2.,fTracksAODMCChargedSecNS, perpjettracklistGenSecNS2, jet, TMath::Abs(GetFFRadius()) ,
3544 sumPtGenPerpNS2);
3545
3546 perpjettracklistGenSecNS->AddAll(perpjettracklistGenSecNS1);
3547 perpjettracklistGenSecNS->AddAll(perpjettracklistGenSecNS2);
3548 //sumPtGenPerpNS = 0.5*(sumPtGenPerpNS1+sumPtGenPerpNS2);
3549
3550
3551 TList* perpjettracklistGenSecS = new TList();
3552 TList* perpjettracklistGenSecS1 = new TList();
3553 TList* perpjettracklistGenSecS2 = new TList();
3554
3555 //Double_t sumPtGenPerpS = 0.;
3556 Double_t sumPtGenPerpS1 = 0.;
3557 Double_t sumPtGenPerpS2 = 0.;
3558 GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksAODMCChargedSecS, perpjettracklistGenSecS1, jet, TMath::Abs(GetFFRadius()) ,
3559 sumPtGenPerpS1);
3560 GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2.,fTracksAODMCChargedSecS, perpjettracklistGenSecS2, jet, TMath::Abs(GetFFRadius()) ,
3561 sumPtGenPerpS2);
3562
3563 perpjettracklistGenSecS->AddAll(perpjettracklistGenSecS1);
3564 perpjettracklistGenSecS->AddAll(perpjettracklistGenSecS2);
3565 //sumPtGenPerpS = 0.5*(sumPtGenPerpS1+sumPtGenPerpS2);
3566
3567
3568 if(perpjettracklistGen->GetSize() != perpjettracklistGen1->GetSize() + perpjettracklistGen2->GetSize()){
3569 cout<<" ERROR: perpjettracklistGen size "<<perpjettracklistGen->GetSize()<<" perp1 "<<perpjettracklistGen1->GetSize()
3570 <<" perp2 "<<perpjettracklistGen2->GetSize()<<endl;
3571 exit(0);
3572 }
3573
3574 if(perpjettracklistGenSecNS->GetSize() != perpjettracklistGenSecNS1->GetSize() + perpjettracklistGenSecNS2->GetSize()){
3575 cout<<" ERROR: perpjettracklistGenSecNS size "<<perpjettracklistGenSecNS->GetSize()<<" perp1 "<<perpjettracklistGenSecNS1->GetSize()
3576 <<" perp2 "<<perpjettracklistGenSecNS2->GetSize()<<endl;
3577 exit(0);
3578 }
3579
3580 if(perpjettracklistGenSecS->GetSize() != perpjettracklistGenSecS1->GetSize() + perpjettracklistGenSecS2->GetSize()){
3581 cout<<" ERROR: perpjettracklistGenSecS size "<<perpjettracklistGenSecS->GetSize()<<" perp1 "<<perpjettracklistGenSecS1->GetSize()
3582 <<" perp2 "<<perpjettracklistGenSecS2->GetSize()<<endl;
3583 exit(0);
3584 }
3585
3586
3587 FillJetTrackHistosRec(fFFBckgHisto0RecEffRec,jet,
3588 perpjettracklistGen,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim);
3589
3590 FillJetTrackHistosRec(fFFBckgHisto0SecRecNS,jet,
3591 perpjettracklistGenSecNS,fTracksAODMCChargedSecNS,fTracksRecQualityCuts,indexAODTrSecNS,isGenSecNS);
3592
3593 FillJetTrackHistosRec(fFFBckgHisto0SecRecS,jet,
3594 perpjettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS);
3595
3596 FillJetTrackHistosRec(fFFBckgHisto0SecRecSsc,jet,
3597 perpjettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,0,kTRUE);
3598
3599
3600 delete perpjettracklistGen;
3601 delete perpjettracklistGen1;
3602 delete perpjettracklistGen2;
3603
3604 delete perpjettracklistGenSecNS;
3605 delete perpjettracklistGenSecNS1;
3606 delete perpjettracklistGenSecNS2;
3607
3608 delete perpjettracklistGenSecS;
3609 delete perpjettracklistGenSecS1;
3610 delete perpjettracklistGenSecS2;
3611
3612 }
3613 }
3614 }
3615 }
3616
3617 //___________________
3618
3619 fTracksRecCuts->Clear();
3620 fTracksRecCutsEfficiency->Clear();
3621 fTracksGen->Clear();
3622 fTracksAODMCCharged->Clear();
3623 fTracksAODMCChargedSecNS->Clear();
3624 fTracksAODMCChargedSecS->Clear();
3625 fTracksRecQualityCuts->Clear();
3626
3627 fJetsRec->Clear();
3628 fJetsRecCuts->Clear();
3629 fJetsGen->Clear();
3630 fJetsRecEff->Clear();
3631 fJetsEmbedded->Clear();
3632
3633
3634 if(fBckgMode &&
3635 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
3636 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
3637 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)){
3638
3639 fBckgJetsRec->Clear();
3640 fBckgJetsRecCuts->Clear();
3641 fBckgJetsGen->Clear();
3642 }
3643
3644
3645 //Post output data.
3646 PostData(1, fCommonHistList);
3647
3648 if (fUseJetPIDtask) {
3649 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
3650 fJetPIDtask[i]->PostOutputData();
e131b05f 3651 }
3652 }
3653
3654 if (fUseInclusivePIDtask) {
3655 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
3656 fInclusivePIDtask[i]->PostOutputData();
e131b05f 3657 }
3658 }
3659}
3660
3661//______________________________________________________________
3662void AliAnalysisTaskIDFragmentationFunction::Terminate(Option_t *)
3663{
3664 // terminated
3665
3666 if(fDebug > 1) printf("AliAnalysisTaskIDFragmentationFunction::Terminate() \n");
3667}
3668
3669//_________________________________________________________________________________
3670Int_t AliAnalysisTaskIDFragmentationFunction::GetListOfTracks(TList *list, Int_t type)
3671{
3672 // fill list of tracks selected according to type
3673
3674 if(fDebug > 2) Printf("%s:%d Selecting tracks with %d", (char*)__FILE__,__LINE__,type);
3675
3676 if(!list){
3677 if(fDebug>1) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
3678 return -1;
3679 }
3680
3681 if(!fAOD) return -1;
3682
3683 if(!fAOD->GetTracks()) return 0;
3684
3685 if(type==kTrackUndef) return 0;
3686
3687 Int_t iCount = 0;
3688
3689 if(type==kTrackAODExtraCuts || type==kTrackAODExtraonlyCuts || type==kTrackAODExtra || type==kTrackAODExtraonly){
3690
3691 TClonesArray *aodExtraTracks = dynamic_cast<TClonesArray*>(fAOD->FindListObject("aodExtraTracks"));
3692 if(!aodExtraTracks)return iCount;
3693 for(int it =0; it<aodExtraTracks->GetEntries(); it++) {
3694 AliVParticle *track = dynamic_cast<AliVParticle*> ((*aodExtraTracks)[it]);
3695 if (!track) continue;
3696
3697 AliAODTrack *tr = dynamic_cast<AliAODTrack*> (track);
3698 if(!tr)continue;
3699
3700 if(type==kTrackAODExtraCuts || type==kTrackAODExtraonlyCuts){
3701
3702 if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask))) continue;
3703
3704 if(tr->Eta() < fTrackEtaMin || tr->Eta() > fTrackEtaMax) continue;
3705 if(tr->Phi() < fTrackPhiMin || tr->Phi() > fTrackPhiMax) continue;
3706 if(tr->Pt() < fTrackPtCut) continue;
3707 }
3708
3709 list->Add(tr);
3710 iCount++;
3711 }
3712 }
3713
3714 if(type==kTrackAODCuts || type==kTrackAODQualityCuts || type==kTrackAOD || type==kTrackAODExtraCuts || type==kTrackAODExtra){
3715
3716 // all rec. tracks, esd filter mask, eta range
3717
3718 for(Int_t it=0; it<fAOD->GetNumberOfTracks(); ++it){
3719 AliAODTrack *tr = fAOD->GetTrack(it);
3720
3721 if(type == kTrackAODCuts || type==kTrackAODQualityCuts || type==kTrackAODExtraCuts){
3722
3723 if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask))) continue;
3724 if(type == kTrackAODCuts){
3725 if(tr->Eta() < fTrackEtaMin || tr->Eta() > fTrackEtaMax) continue;
3726 if(tr->Phi() < fTrackPhiMin || tr->Phi() > fTrackPhiMax) continue;
3727 if(tr->Pt() < fTrackPtCut) continue;
3728 }
3729 }
3730 list->Add(tr);
3731 iCount++;
3732 }
3733 }
3734 else if (type==kTrackKineAll || type==kTrackKineCharged || type==kTrackKineChargedAcceptance){
3735 // kine particles, all or rather charged
3736 if(!fMCEvent) return iCount;
3737
3738 for(Int_t it=0; it<fMCEvent->GetNumberOfTracks(); ++it){
3739 AliMCParticle* part = (AliMCParticle*) fMCEvent->GetTrack(it);
3740
3741 if(type == kTrackKineCharged || type == kTrackKineChargedAcceptance){
3742 if(part->Charge()==0) continue;
3743
3744 if(type == kTrackKineChargedAcceptance &&
3745 ( part->Eta() < fTrackEtaMin
3746 || part->Eta() > fTrackEtaMax
3747 || part->Phi() < fTrackPhiMin
3748 || part->Phi() > fTrackPhiMax
3749 || part->Pt() < fTrackPtCut)) continue;
3750 }
3751
3752 list->Add(part);
3753 iCount++;
3754 }
3755 }
3756 else if (type==kTrackAODMCCharged || type==kTrackAODMCAll || type==kTrackAODMCChargedAcceptance || type==kTrackAODMCChargedSecNS || type==kTrackAODMCChargedSecS) {
3757 // MC particles (from AOD), physical primaries, all or rather charged or rather charged within acceptance
3758 if(!fAOD) return -1;
3759
3760 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
3761 if(!tca)return iCount;
3762
3763 for(int it=0; it<tca->GetEntriesFast(); ++it){
3764 AliAODMCParticle *part = dynamic_cast<AliAODMCParticle*>(tca->At(it));
3765 if(!part)continue;
3766 if(type != kTrackAODMCChargedSecNS && type != kTrackAODMCChargedSecS && !part->IsPhysicalPrimary())continue;
3767 if((type == kTrackAODMCChargedSecNS || type == kTrackAODMCChargedSecS) && part->IsPhysicalPrimary())continue;
3768
3769 if (type==kTrackAODMCCharged || type==kTrackAODMCChargedAcceptance || type==kTrackAODMCChargedSecNS || type==kTrackAODMCChargedSecS){
3770 if(part->Charge()==0) continue;
3771
3772 if(type==kTrackAODMCChargedSecNS || type==kTrackAODMCChargedSecS){
3773 Bool_t isFromStrange = kFALSE;
3774 Int_t iMother = part->GetMother();
3775 if(iMother >= 0){
3776 AliAODMCParticle *partM = dynamic_cast<AliAODMCParticle*>(tca->At(iMother));
3777 if(!partM) continue;
3778
3779 Int_t codeM = TMath::Abs(partM->GetPdgCode());
3780 Int_t mfl = Int_t (codeM/ TMath::Power(10, Int_t(TMath::Log10(codeM))));
3781
3782 if (mfl == 3 && codeM != 3) isFromStrange = kTRUE;
3783 if(codeM == 130) isFromStrange = kTRUE; // K0 long
3784 if(part->IsSecondaryFromMaterial()) isFromStrange = kFALSE; // strange resonances from hadronic showers ?
3785
3786 // if(mfl ==3){
3787 // cout<<" mfl "<<mfl<<" codeM "<<partM->GetPdgCode()<<" code this track "<<part->GetPdgCode()<<endl;
3788 // cout<<" index this track "<<it<<" index daughter 0 "<<partM->GetDaughter(0)<<" 1 "<<partM->GetDaughter(1)<<endl;
3789 // }
3790
3791 if(type==kTrackAODMCChargedSecNS && isFromStrange) continue;
3792 if(type==kTrackAODMCChargedSecS && !isFromStrange) continue;
3793 }
3794 }
3795
3796 if(type==kTrackAODMCChargedAcceptance &&
3797 ( part->Eta() > fTrackEtaMax
3798 || part->Eta() < fTrackEtaMin
3799 || part->Phi() > fTrackPhiMax
3800 || part->Phi() < fTrackPhiMin
3801 || part->Pt() < fTrackPtCut)) continue;
3802 }
3803
3804 list->Add(part);
3805 iCount++;
3806 }
3807 }
3808
3809 list->Sort();
3810 return iCount;
3811
3812}
3813// _______________________________________________________________________________
3814Int_t AliAnalysisTaskIDFragmentationFunction::GetListOfJets(TList *list, Int_t type)
3815{
3816 // fill list of jets selected according to type
3817
3818 if(!list){
3819 if(fDebug>1) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
3820 return -1;
3821 }
3822
3823 if(type == kJetsRec || type == kJetsRecAcceptance){ // reconstructed jets
3824
3825 if(fBranchRecJets.Length()==0){
3826 Printf("%s:%d no rec jet branch specified", (char*)__FILE__,__LINE__);
3827 if(fDebug>1)fAOD->Print();
3828 return 0;
3829 }
3830
3831 TClonesArray *aodRecJets = 0;
3832 if(fBranchRecJets.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchRecJets.Data()));
3833 if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchRecJets.Data()));
3834 if(fAODExtension&&!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchRecJets.Data()));
3835
3836 if(!aodRecJets){
3837 if(fBranchRecJets.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchRecJets.Data());
3838 if(fDebug>1)fAOD->Print();
3839 return 0;
3840 }
3841
3842 // Reorder jet pt and fill new temporary AliAODJet objects
3843 Int_t nRecJets = 0;
3844
3845 for(Int_t ij=0; ij<aodRecJets->GetEntries(); ++ij){
3846
3847 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodRecJets->At(ij));
3848 if(!tmp) continue;
3849
3850 if( tmp->Pt() < fJetPtCut ) continue;
3851 if( type == kJetsRecAcceptance &&
3852 ( tmp->Eta() < fJetEtaMin
3853 || tmp->Eta() > fJetEtaMax
3854 || tmp->Phi() < fJetPhiMin
3855 || tmp->Phi() > fJetPhiMax )) continue;
3856
3857
3858 list->Add(tmp);
3859 nRecJets++;
3860 }
3861
3862 list->Sort();
3863
3864 return nRecJets;
3865 }
3866 else if(type == kJetsKine || type == kJetsKineAcceptance){
3867
3868 // generated jets
3869 Int_t nGenJets = 0;
3870
3871 if(!fMCEvent){
3872 if(fDebug>1) Printf("%s:%d no mcEvent",(char*)__FILE__,__LINE__);
3873 return 0;
3874 }
3875
3876 AliGenEventHeader* genHeader = fMCEvent->GenEventHeader();
3877 AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
3878 AliGenHijingEventHeader* hijingGenHeader = 0x0;
3879
3880 if(!pythiaGenHeader){
3881 hijingGenHeader = dynamic_cast<AliGenHijingEventHeader*>(genHeader);
3882
3883 if(!hijingGenHeader){
3884 Printf("%s:%d no pythiaGenHeader or hijingGenHeader found", (char*)__FILE__,__LINE__);
3885 return 0;
3886 }else{
3887 TLorentzVector mom[4];
3888 AliAODJet* jet[4];
3889 hijingGenHeader->GetJets(mom[0], mom[1], mom[2], mom[3]);
3890
3891 for(Int_t i=0; i<2; ++i){
3892 if(!mom[i].Pt()) continue;
3893 jet[i] = new AliAODJet(mom[i]);
3894
3895 if( type == kJetsKineAcceptance &&
3896 ( jet[i]->Eta() < fJetEtaMin
3897 || jet[i]->Eta() > fJetEtaMax
3898 || jet[i]->Phi() < fJetPhiMin
3899 || jet[i]->Phi() > fJetPhiMax )) continue;
3900
3901 list->Add(jet[i]);
3902 nGenJets++;
3903 }
3904 list->Sort();
3905 return nGenJets;
3906 }
3907 }
3908
3909 // fetch the pythia generated jets
3910 for(int ip=0; ip<pythiaGenHeader->NTriggerJets(); ++ip){
3911
3912 Float_t p[4];
3913 AliAODJet *jet = new AliAODJet();
3914 pythiaGenHeader->TriggerJet(ip, p);
3915 jet->SetPxPyPzE(p[0], p[1], p[2], p[3]);
3916
3917 if( type == kJetsKineAcceptance &&
3918 ( jet->Eta() < fJetEtaMin
3919 || jet->Eta() > fJetEtaMax
3920 || jet->Phi() < fJetPhiMin
3921 || jet->Phi() > fJetPhiMax )) continue;
3922
3923 list->Add(jet);
3924 nGenJets++;
3925 }
3926 list->Sort();
3927 return nGenJets;
3928 }
3929 else if(type == kJetsGen || type == kJetsGenAcceptance ){
3930
3931 if(fBranchGenJets.Length()==0){
3932 if(fDebug>1) Printf("%s:%d no gen jet branch specified", (char*)__FILE__,__LINE__);
3933 return 0;
3934 }
3935
3936 TClonesArray *aodGenJets = 0;
3937 if(fBranchGenJets.Length()) aodGenJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchGenJets.Data()));
3938 if(!aodGenJets) aodGenJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchGenJets.Data()));
3939 if(fAODExtension&&!aodGenJets) aodGenJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchGenJets.Data()));
3940
3941 if(!aodGenJets){
3942 if(fDebug>0){
3943 if(fBranchGenJets.Length()) Printf("%s:%d Generated jet branch %s not found",(char*)__FILE__,__LINE__,fBranchGenJets.Data());
3944 }
3945 if(fDebug>1)fAOD->Print();
3946 return 0;
3947 }
3948
3949 Int_t nGenJets = 0;
3950
3951 for(Int_t ig=0; ig<aodGenJets->GetEntries(); ++ig){
3952
3953 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodGenJets->At(ig));
3954 if(!tmp) continue;
3955
3956 if( tmp->Pt() < fJetPtCut ) continue;
3957 if( type == kJetsGenAcceptance &&
3958 ( tmp->Eta() < fJetEtaMin
3959 || tmp->Eta() > fJetEtaMax
3960 || tmp->Phi() < fJetPhiMin
3961 || tmp->Phi() > fJetPhiMax )) continue;
3962
3963 list->Add(tmp);
3964 nGenJets++;
3965 }
3966 list->Sort();
3967 return nGenJets;
3968 }
3969 else if(type == kJetsEmbedded){ // embedded jets
3970
3971 if(fBranchEmbeddedJets.Length()==0){
3972 Printf("%s:%d no embedded jet branch specified", (char*)__FILE__,__LINE__);
3973 if(fDebug>1)fAOD->Print();
3974 return 0;
3975 }
3976
3977 TClonesArray *aodEmbeddedJets = 0;
3978 if(fBranchEmbeddedJets.Length()) aodEmbeddedJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchEmbeddedJets.Data()));
3979 if(!aodEmbeddedJets) aodEmbeddedJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchEmbeddedJets.Data()));
3980 if(fAODExtension&&!aodEmbeddedJets) aodEmbeddedJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchEmbeddedJets.Data()));
3981
3982 if(!aodEmbeddedJets){
3983 if(fBranchEmbeddedJets.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchEmbeddedJets.Data());
3984 if(fDebug>1)fAOD->Print();
3985 return 0;
3986 }
3987
3988 // Reorder jet pt and fill new temporary AliAODJet objects
3989 Int_t nEmbeddedJets = 0;
3990
3991 for(Int_t ij=0; ij<aodEmbeddedJets->GetEntries(); ++ij){
3992
3993 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodEmbeddedJets->At(ij));
3994 if(!tmp) continue;
3995
3996 if( tmp->Pt() < fJetPtCut ) continue;
3997 if( tmp->Eta() < fJetEtaMin
3998 || tmp->Eta() > fJetEtaMax
3999 || tmp->Phi() < fJetPhiMin
4000 || tmp->Phi() > fJetPhiMax ) continue;
4001
4002 list->Add(tmp);
4003 nEmbeddedJets++;
4004 }
4005
4006 list->Sort();
4007
4008 return nEmbeddedJets;
4009 }
4010 else{
4011 if(fDebug>0)Printf("%s:%d no such type %d",(char*)__FILE__,__LINE__,type);
4012 return 0;
4013 }
4014}
4015
4016// ___________________________________________________________________________________
4017Int_t AliAnalysisTaskIDFragmentationFunction::GetListOfBckgJets(TList *list, Int_t type)
4018{
4019 // fill list of bgr clusters selected according to type
4020
4021 if(type == kJetsRec || type == kJetsRecAcceptance){ // reconstructed jets
4022
4023 if(fBranchRecBckgClusters.Length()==0){
4024 Printf("%s:%d no rec jet branch specified", (char*)__FILE__,__LINE__);
4025 if(fDebug>1)fAOD->Print();
4026 return 0;
4027 }
4028
4029 TClonesArray *aodRecJets = 0;
4030 if(fBranchRecBckgClusters.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchRecBckgClusters.Data()));
4031 if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchRecBckgClusters.Data()));
4032 if(fAODExtension&&!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchRecBckgClusters.Data()));
4033
4034 if(!aodRecJets){
4035 if(fBranchRecBckgClusters.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchRecBckgClusters.Data());
4036 if(fDebug>1)fAOD->Print();
4037 return 0;
4038 }
4039
4040 // Reorder jet pt and fill new temporary AliAODJet objects
4041 Int_t nRecJets = 0;
4042
4043 for(Int_t ij=0; ij<aodRecJets->GetEntries(); ++ij){
4044
4045 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodRecJets->At(ij));
4046 if(!tmp) continue;
4047
4048 // if( tmp->Pt() < fJetPtCut ) continue; // no pt cut on bckg clusters !
4049 if( type == kJetsRecAcceptance &&
4050 ( tmp->Eta() < fJetEtaMin
4051 || tmp->Eta() > fJetEtaMax
4052 || tmp->Phi() < fJetPhiMin
4053 || tmp->Phi() > fJetPhiMax )) continue;
4054
4055 list->Add(tmp);
4056
4057 nRecJets++;
4058
4059 }
4060
4061 list->Sort();
4062
4063 return nRecJets;
4064 }
4065
4066 // /*
4067 // MC clusters still Under construction
4068 // */
4069
4070 return 0;
4071}
4072
4073// _________________________________________________________________________________________________________
9d7ad2e4 4074void AliAnalysisTaskIDFragmentationFunction::SetProperties(THnSparse* h, Int_t dim, const char** labels)
e131b05f 4075{
4076 // Set properties of THnSparse
4077
4078 for(Int_t i=0; i<dim; i++){
4079 h->GetAxis(i)->SetTitle(labels[i]);
4080 h->GetAxis(i)->SetTitleColor(1);
4081 }
4082}
4083
4084// __________________________________________________________________________________________
4085void AliAnalysisTaskIDFragmentationFunction::SetProperties(TH1* h,const char* x, const char* y)
4086{
4087 //Set properties of histos (x and y title)
4088
4089 h->SetXTitle(x);
4090 h->SetYTitle(y);
4091 h->GetXaxis()->SetTitleColor(1);
4092 h->GetYaxis()->SetTitleColor(1);
4093}
4094
4095// _________________________________________________________________________________________________________
4096void AliAnalysisTaskIDFragmentationFunction::SetProperties(TH1* h,const char* x, const char* y, const char* z)
4097{
4098 //Set properties of histos (x,y and z title)
4099
4100 h->SetXTitle(x);
4101 h->SetYTitle(y);
4102 h->SetZTitle(z);
4103 h->GetXaxis()->SetTitleColor(1);
4104 h->GetYaxis()->SetTitleColor(1);
4105 h->GetZaxis()->SetTitleColor(1);
4106}
4107
4108// ________________________________________________________________________________________________________________________________________________________
4109void AliAnalysisTaskIDFragmentationFunction::GetJetTracksPointing(TList* inputlist, TList* outputlist, const AliAODJet* jet,
9d7ad2e4 4110 Double_t radius, Double_t& sumPt, Double_t minPtL, Double_t maxPt, Bool_t& isBadPt)
e131b05f 4111{
4112 // fill list of tracks in cone around jet axis
4113
4114 sumPt = 0;
4115 Bool_t isBadMaxPt = kFALSE;
4116 Bool_t isBadMinPt = kTRUE;
4117
4118 Double_t jetMom[3];
4119 jet->PxPyPz(jetMom);
4120 TVector3 jet3mom(jetMom);
4121
4122 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
4123
4124 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
4125 if(!track)continue;
4126 Double_t trackMom[3];
4127 track->PxPyPz(trackMom);
4128 TVector3 track3mom(trackMom);
4129
4130 Double_t dR = jet3mom.DeltaR(track3mom);
4131
4132 if(dR<radius){
4133
4134 outputlist->Add(track);
4135
4136 sumPt += track->Pt();
4137
4138 if(maxPt>0 && track->Pt()>maxPt) isBadMaxPt = kTRUE;
4139 if(minPtL>0 && track->Pt()>minPtL) isBadMinPt = kFALSE;
4140 }
4141 }
4142
4143 isBadPt = kFALSE;
4144 if(minPtL>0 && isBadMinPt) isBadPt = kTRUE;
4145 if(maxPt>0 && isBadMaxPt) isBadPt = kTRUE;
4146
4147 outputlist->Sort();
4148}
4149
4150// _________________________________________________________________________________________________________________________________________________________________
9d7ad2e4 4151void AliAnalysisTaskIDFragmentationFunction::GetJetTracksTrackrefs(TList* list, const AliAODJet* jet, Double_t minPtL, Double_t maxPt, Bool_t& isBadPt)
e131b05f 4152{
4153 // list of jet tracks from trackrefs
4154
4155 Int_t nTracks = jet->GetRefTracks()->GetEntriesFast();
4156
4157 Bool_t isBadMaxPt = kFALSE;
4158 Bool_t isBadMinPt = kTRUE;
4159
4160 for(Int_t itrack=0; itrack<nTracks; itrack++) {
4161
4162 AliVParticle* track = dynamic_cast<AliVParticle*>(jet->GetRefTracks()->At(itrack));
4163 if(!track){
4164 AliError("expected ref track not found ");
4165 continue;
4166 }
4167
4168 if(track->Pt() < fTrackPtCut) continue; // track refs may contain low pt cut (bug in AliFastJetInput)
4169 if(maxPt>0 && track->Pt()>maxPt) isBadMaxPt = kTRUE;
4170 if(minPtL>0 && track->Pt()>minPtL) isBadMinPt = kFALSE;
4171
4172 list->Add(track);
4173 }
4174
4175 isBadPt = kFALSE;
4176 if(minPtL>0 && isBadMinPt) isBadPt = kTRUE;
4177 if(maxPt>0 && isBadMaxPt) isBadPt = kTRUE;
4178
4179 list->Sort();
4180}
4181
4182// _ ________________________________________________________________________________________________________________________________
4183void AliAnalysisTaskIDFragmentationFunction::AssociateGenRec(TList* tracksAODMCCharged,TList* tracksRec, TArrayI& indexAODTr,TArrayI& indexMCTr,
4184 TArrayS& isRefGen,TH2F* fh2PtRecVsGen)
4185{
4186 // associate generated and reconstructed tracks, fill TArrays of list indices
4187
4188 Int_t nTracksRec = tracksRec->GetSize();
4189 Int_t nTracksGen = tracksAODMCCharged->GetSize();
4190 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
4191
4192
4193 if(!nTracksGen) return;
4194 if(!tca) return;
4195
4196 // set size
4197 indexAODTr.Set(nTracksGen);
4198 indexMCTr.Set(nTracksRec);
4199 isRefGen.Set(nTracksGen);
4200
4201 indexAODTr.Reset(-1);
4202 indexMCTr.Reset(-1);
4203 isRefGen.Reset(0);
4204
4205 // loop over reconstructed tracks, get generated track
4206
4207 for(Int_t iRec=0; iRec<nTracksRec; iRec++){
4208
4209 AliAODTrack* rectrack = dynamic_cast<AliAODTrack*>(tracksRec->At(iRec));
4210 if(!rectrack)continue;
4211 Int_t label = TMath::Abs(rectrack->GetLabel());
4212
4213 // find MC track in our list
4214 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tca->At(label));
4215
4216 Int_t listIndex = -1;
4217 if(gentrack) listIndex = tracksAODMCCharged->IndexOf(gentrack);
4218
4219 if(listIndex>=0){
4220
4221 indexAODTr[listIndex] = iRec;
4222 indexMCTr[iRec] = listIndex;
4223 }
4224 }
4225
4226
4227 // define reference sample of primaries/secondaries (for reconstruction efficiency / contamination)
4228
4229 for(Int_t iGen=0; iGen<nTracksGen; iGen++){
4230
4231 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tracksAODMCCharged->At(iGen));
4232 if(!gentrack)continue;
4233 Int_t pdg = gentrack->GetPdgCode();
4234
4235 // 211 - pi, 2212 - proton, 321 - Kaon, 11 - electron, 13 - muon
4236 if(TMath::Abs(pdg) == 211 || TMath::Abs(pdg) == 2212 || TMath::Abs(pdg) == 321 ||
4237 TMath::Abs(pdg) == 11 || TMath::Abs(pdg) == 13){
4238
4239 isRefGen[iGen] = kTRUE;
4240
4241 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
4242
4243 if(iRec>=0){
4244 Float_t genPt = gentrack->Pt();
4245 AliAODTrack* vt = dynamic_cast<AliAODTrack*>(tracksRec->At(iRec));
4246 if(vt){
4247 Float_t recPt = vt->Pt();
4248 fh2PtRecVsGen->Fill(genPt,recPt);
4249 }
4250 }
4251 }
4252 }
4253}
4254
4255// _____________________________________________________________________________________________________________________________________________
4256void AliAnalysisTaskIDFragmentationFunction::FillSingleTrackHistosRecGen(AliFragFuncQATrackHistos* trackQAGen, AliFragFuncQATrackHistos* trackQARec, TList* tracksGen,
9d7ad2e4 4257 const TArrayI& indexAODTr, const TArrayS& isRefGen, Bool_t scaleStrangeness){
e131b05f 4258
4259 // fill QA for single track reconstruction efficiency
4260
4261 Int_t nTracksGen = tracksGen->GetSize();
4262
4263 if(!nTracksGen) return;
4264
4265 for(Int_t iGen=0; iGen<nTracksGen; iGen++){
4266
4267 if(isRefGen[iGen] != 1) continue; // select primaries
4268
4269 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tracksGen->At(iGen));
4270 if(!gentrack) continue;
4271 Double_t ptGen = gentrack->Pt();
4272 Double_t etaGen = gentrack->Eta();
4273 Double_t phiGen = TVector2::Phi_0_2pi(gentrack->Phi());
4274
4275 // apply same acc & pt cuts as for FF GetMCStrangenessFactorCMS
4276
4277 if(etaGen < fTrackEtaMin || etaGen > fTrackEtaMax) continue;
4278 if(phiGen < fTrackPhiMin || phiGen > fTrackPhiMax) continue;
4279 if(ptGen < fTrackPtCut) continue;
4280
4281 if(trackQAGen) trackQAGen->FillTrackQA(etaGen, phiGen, ptGen);
4282
4283 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
4284
4285 if(iRec>=0 && trackQARec){
4286 if(scaleStrangeness){
4287 //Double_t weight = GetMCStrangenessFactor(ptGen);
4288 Double_t weight = GetMCStrangenessFactorCMS(gentrack);
4289 trackQARec->FillTrackQA(etaGen, phiGen, ptGen, kFALSE, 0, kTRUE, weight);
4290 }
4291 else trackQARec->FillTrackQA(etaGen, phiGen, ptGen);
4292 }
4293 }
4294}
4295
4296// ______________________________________________________________________________________________________________________________________________________
4297
4298void AliAnalysisTaskIDFragmentationFunction::FillJetTrackHistosRec(AliFragFuncHistos* ffhistRec, AliAODJet* jet,
4299 TList* jetTrackList, const TList* tracksGen, const TList* tracksRec, const TArrayI& indexAODTr,
9d7ad2e4 4300 const TArrayS& isRefGen, TList* jetTrackListTR, Bool_t scaleStrangeness,
e131b05f 4301 Bool_t fillJS, TProfile* hProNtracksLeadingJet, TProfile** hProDelRPtSum, TProfile* hProDelR80pcPt)
4302{
4303 // fill objects for jet track reconstruction efficiency or secondaries contamination
4304 // arguments histGen/histRec can be of different type: AliFragFuncHistos*, AliFragFuncIntraJetHistos*, ...
4305 // jetTrackListTR pointer: track refs if not NULL
4306
4307
4308 // ensure proper normalization, even for secondaries
4309 Double_t jetPtRec = jet->Pt();
4310 ffhistRec->FillFF(-1, jetPtRec, kTRUE);
4311
4312 Int_t nTracksJet = jetTrackList->GetSize(); // list with AODMC tracks
4313 if(nTracksJet == 0) return;
4314
4315 TList* listRecTracks = new TList();
4316 listRecTracks->Clear();
4317
4318 for(Int_t iTr=0; iTr<nTracksJet; iTr++){ // jet tracks loop
4319
4320 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (jetTrackList->At(iTr));
4321 if(!gentrack)continue;
4322 // find jet track in gen tracks list
4323 Int_t iGen = tracksGen->IndexOf(gentrack);
4324
4325 if(iGen<0){
4326 if(fDebug>0) Printf("%s:%d gen jet track not found ",(char*)__FILE__,__LINE__);
4327 continue;
4328 }
4329
4330 if(isRefGen[iGen] != 1) continue; // select primaries
4331
4332 Double_t ptGen = gentrack->Pt();
4333 Double_t etaGen = gentrack->Eta();
4334 Double_t phiGen = TVector2::Phi_0_2pi(gentrack->Phi());
4335
4336 // gen level acc & pt cuts - skip in case of track refs
4337 if(!jetTrackListTR && (etaGen < fTrackEtaMin || etaGen > fTrackEtaMax)) continue;
4338 if(!jetTrackListTR && (phiGen < fTrackPhiMin || phiGen > fTrackPhiMax)) continue;
4339 if(!jetTrackListTR && ptGen < fTrackPtCut) continue;
4340
4341
4342 Double_t ptRec = -1;
4343
4344 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
4345 Bool_t isRec = (iRec>=0) ? kTRUE : kFALSE;
4346
4347 Bool_t isJetTrack = kFALSE;
4348 if(!jetTrackListTR) isJetTrack = kTRUE; // skip trackRefs check for tracks in ideal cone
4349
4350 if(isRec){
4351
4352 AliAODTrack* rectrack = dynamic_cast<AliAODTrack*> (tracksRec->At(iRec));
4353 if(!rectrack) continue;
4354
4355 ptRec = rectrack->Pt();
4356
4357 if(jetTrackListTR){
4358 Int_t iRecTR = jetTrackListTR->IndexOf(rectrack);
4359 if(iRecTR >=0 ) isJetTrack = kTRUE; // rec tracks assigned to jet
4360 }
4361
4362 if(isJetTrack){
4363
4364 Double_t trackPt = ptRec;
4365 Bool_t incrementJetPt = kFALSE;
4366
4367 if(scaleStrangeness){
4368 //Double_t weight = GetMCStrangenessFactor(ptGen);
4369 Double_t weight = GetMCStrangenessFactorCMS(gentrack);
4370
4371 ffhistRec->FillFF( trackPt, jetPtRec, incrementJetPt, 0, kTRUE, weight );
4372 }
4373 else{
4374 ffhistRec->FillFF( trackPt, jetPtRec, incrementJetPt );
4375 }
4376
4377 listRecTracks->Add(rectrack);
4378
4379 }
4380 }
4381 }
4382
4383
4384 if(fillJS) FillJetShape(jet,listRecTracks,hProNtracksLeadingJet, hProDelRPtSum, hProDelR80pcPt,0,0,scaleStrangeness);
4385
4386 delete listRecTracks;
4387
4388}
4389
4390// _____________________________________________________________________________________________________________________________________________________________________
4391void AliAnalysisTaskIDFragmentationFunction::GetTracksTiltedwrpJetAxis(Float_t alpha, TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius,Double_t& sumPt)
4392{
4393 // List of tracks in cone perpendicular to the jet azimuthal direction
4394
4395 Double_t jetMom[3];
4396 jet->PxPyPz(jetMom);
4397
4398 TVector3 jet3mom(jetMom);
4399 // Rotate phi and keep eta unchanged
4400 Double_t etaTilted = jet3mom.Eta();
4401 Double_t phiTilted = TVector2::Phi_0_2pi(jet3mom.Phi()) + alpha;
4402 if(phiTilted > 2*TMath::Pi()) phiTilted = phiTilted - 2*TMath::Pi();
4403
4404 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
4405
4406 // embedded tracks
4407 if( fUseExtraTracksBgr != 1){
4408 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
4409 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4410 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4411 }
4412 }
4413
4414 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
4415 if(!track)continue;
4416 Double_t trackMom[3];
4417 track->PxPyPz(trackMom);
4418 TVector3 track3mom(trackMom);
4419
4420 Double_t deta = track3mom.Eta() - etaTilted;
4421 Double_t dphi = TMath::Abs(track3mom.Phi() - phiTilted);
4422 if (dphi > TMath::Pi()) dphi = 2. * TMath::Pi() - dphi;
4423 Double_t dR = TMath::Sqrt(deta * deta + dphi * dphi);
4424
4425
4426 if(dR<=radius){
4427 outputlist->Add(track);
4428 sumPt += track->Pt();
4429 }
4430 }
4431
4432}
4433
4434// ________________________________________________________________________________________________________________________________________________________
4435void AliAnalysisTaskIDFragmentationFunction::GetTracksTiltedwrpJetAxisWindow(Float_t alpha, TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius,Double_t& sumPt,Double_t &normFactor)
4436{
4437 // List of tracks in cone perpendicular to the jet azimuthal direction
4438
4439 Double_t jetMom[3];
4440 jet->PxPyPz(jetMom);
4441
4442 TVector3 jet3mom(jetMom);
4443 // Rotate phi and keep eta unchanged
4444 Double_t etaTilted = jet3mom.Eta();
4445 Double_t phiTilted = TVector2::Phi_0_2pi(jet3mom.Phi()) + alpha;
4446 if(phiTilted > 2*TMath::Pi()) phiTilted = phiTilted - 2*TMath::Pi();
4447
4448 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++)
4449 {
4450
4451 // embedded tracks
4452 if( fUseExtraTracksBgr != 1){
4453 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
4454 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4455 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4456 }
4457 }
4458
4459 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
4460 if(!track)continue;
4461 Float_t trackEta = track->Eta();
4462 Float_t trackPhi = track->Phi();
4463
4464 if( ( phiTilted-radius >= 0 ) && ( phiTilted+radius <= 2*TMath::Pi()))
4465 {
4466 if((trackPhi<=phiTilted+radius) &&
4467 (trackPhi>=phiTilted-radius) &&
4468 (trackEta<=fTrackEtaMax)&&(trackEta>=fTrackEtaMin)) // 0.9 and - 0.9
4469 {
4470 outputlist->Add(track);
4471 sumPt += track->Pt();
4472 }
4473 }
4474 else if( phiTilted-radius < 0 )
4475 {
4476 if((( trackPhi < phiTilted+radius ) ||
4477 ( trackPhi > 2*TMath::Pi()-(radius-phiTilted) )) &&
4478 (( trackEta <= fTrackEtaMax ) && ( trackEta >= fTrackEtaMin )))
4479 {
4480 outputlist->Add(track);
4481 sumPt += track->Pt();
4482 }
4483 }
4484 else if( phiTilted+radius > 2*TMath::Pi() )
4485 {
4486 if((( trackPhi > phiTilted-radius ) ||
4487 ( trackPhi < phiTilted+radius-2*TMath::Pi() )) &&
4488 (( trackEta <= fTrackEtaMax ) && ( trackEta >= fTrackEtaMin )))
4489 {
4490 outputlist->Add(track);
4491 sumPt += track->Pt();
4492 }
4493 }
4494 }
4495
4496 // Jet area - Temporarily added should be modified with the proper jet area value
4497 Float_t areaJet = CalcJetArea(etaTilted,radius);
4498 Float_t areaTilted = 2*radius*(fTrackEtaMax-fTrackEtaMin);
4499
4500 normFactor = (Float_t) 1. / (areaJet / areaTilted);
4501
4502}
4503
4504
4505// ________________________________________________________________________________________________________________________________________________________
4506void AliAnalysisTaskIDFragmentationFunction::GetTracksOutOfNJets(Int_t nCases, TList* inputlist, TList* outputlist, const TList* jetlist,
4507 Double_t& sumPt)
4508{
4509 // List of tracks outside cone around N jet axis
4510 // Particles taken randomly
4511
4512 sumPt = 0;
4513 // Int_t nj = jetlist->GetSize();
4514 Float_t rc = TMath::Abs(GetFFRadius());
4515 Float_t rcl = GetFFBckgRadius();
4516
4517 // Estimate jet and background areas
4518 Float_t* areaJet = new Float_t[nCases];
4519 memset(areaJet, 0, sizeof(Float_t) * nCases);
4520 Float_t* areaJetLarge = new Float_t[nCases];
4521 memset(areaJetLarge, 0, sizeof(Float_t) * nCases);
4522 Float_t areaFull = (fTrackEtaMax-fTrackEtaMin)*(fTrackPhiMax-fTrackPhiMin);
4523 Float_t areaOut = areaFull;
4524
4525 //estimate jets and background areas
4526 Int_t nOut = 0;
4527 Int_t ijet = 0;
4528 TList* templist = new TList();
4529 TClonesArray *vect3Jet = new TClonesArray("TVector3",nCases);
4530
4531 for(Int_t ij=0; ij<nCases; ++ij)
4532 {
4533 // Get jet information
4534 AliAODJet* jet = dynamic_cast<AliAODJet*>(jetlist->At(ij));
4535 if(!jet)continue;
4536 TVector3 jet3mom;
4537 jet3mom.SetPtEtaPhi(jet->Pt(),jet->Eta(),jet->Phi());
4538 new((*vect3Jet)[ijet]) TVector3((TVector3)jet3mom);
4539 Float_t etaJet = (Float_t)((TVector3*) vect3Jet->At(ij))->Eta();
4540
4541 // Jet area
4542 areaJet[ij] = CalcJetArea(etaJet,rc);
4543
4544 // Area jet larger angle
4545 areaJetLarge[ij] = CalcJetArea(etaJet,rcl);
4546
4547 // Outside jet area
4548 areaOut = areaOut - areaJetLarge[ij];
4549 ijet++;
4550 }
4551
4552 // List of all tracks outside jet areas
4553 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
4554
4555 // embedded tracks
4556 if( fUseExtraTracksBgr != 1){
4557 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
4558 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4559 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4560 }
4561 }
4562
4563 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
4564
4565 if(!track)continue;
4566 Double_t trackMom[3];
4567 track->PxPyPz(trackMom);
4568 TVector3 track3mom(trackMom);
4569
4570 Double_t *dR = new Double_t[nCases];
4571 for(Int_t ij=0; ij<nCases; ij++)
4572 dR[ij] = (Double_t)((TVector3*) vect3Jet->At(ij))->DeltaR(track3mom);
4573
4574 if((nCases==1 && (dR[0]>rcl)) ||
4575 (nCases==2 && (dR[0]>rcl && dR[1]>rcl)) ||
4576 (nCases==3 && (dR[0]>rcl && dR[1]>rcl && dR[2]>rcl)))
4577 {
4578 templist->Add(track);
4579 nOut++;
4580 }
4581 delete [] dR;
4582 }
4583
4584 // Take tracks randomly
4585 Int_t nScaled = (Int_t) (nOut * areaJet[0] / areaOut + 0.5);
4586 TArrayI* ar = new TArrayI(nOut);
4587
4588 for(Int_t init=0; init<nOut; init++)
4589 (*ar)[init] = init;
4590
4591 Int_t *randIndex = new Int_t[nScaled];
4592 for(Int_t init2=0; init2<nScaled; init2++)
4593 randIndex[init2] = -1;
4594
4595 // Select nScaled different random numbers in nOut
4596 for(Int_t i=0; i<nScaled; i++)
4597 {
4598 Int_t* tmpArr = new Int_t[nOut-i];
4599 Int_t temp = fRandom->Integer(nOut-i);
4600 for(Int_t ind = 0; ind< ar->GetSize()-1; ind++)
4601 {
4602 if(ind<temp) tmpArr[ind] = (*ar)[ind];
4603 else tmpArr[ind] = (*ar)[ind+1];
4604 }
4605 randIndex[i] = (*ar)[temp];
4606
4607 ar->Set(nOut-i-1,tmpArr);
4608
4609 delete [] tmpArr;
4610
4611 }
4612
4613 for(Int_t ipart=0; ipart<nScaled; ipart++)
4614 {
4615 AliVParticle* track = (AliVParticle*)(templist->At(randIndex[ipart]));
4616 outputlist->Add(track);
4617 sumPt += track->Pt();
4618 }
4619
4620 outputlist->Sort();
4621
4622 delete vect3Jet;
4623 delete templist;
4624 delete [] areaJetLarge;
4625 delete [] areaJet;
4626 delete ar;
4627 delete [] randIndex;
4628
4629}
4630
4631// ________________________________________________________________________________________________________________________________________________________
4632void AliAnalysisTaskIDFragmentationFunction::GetTracksOutOfNJetsStat(Int_t nCases, TList* inputlist, TList* outputlist,
4633 const TList* jetlist, Double_t& sumPt, Double_t &normFactor)
4634{
4635 // List of tracks outside cone around N jet axis
4636 // All particles taken + final scaling factor
4637
4638 sumPt = 0;
4639 Float_t rc = TMath::Abs(GetFFRadius());
4640 Float_t rcl = GetFFBckgRadius();
4641
4642 // Estimate jet and background areas
4643 Float_t* areaJet = new Float_t[nCases];
4644 memset(areaJet, 0, sizeof(Float_t) * nCases);
4645 Float_t* areaJetLarge = new Float_t[nCases];
4646 memset(areaJetLarge, 0, sizeof(Float_t) * nCases);
4647 Float_t areaFull = (fTrackEtaMax-fTrackEtaMin)*(fTrackPhiMax-fTrackPhiMin);
4648 Float_t areaOut = areaFull;
4649
4650 //estimate jets and background areas
4651 Int_t nOut = 0;
4652 Int_t ijet = 0;
4653 TClonesArray *vect3Jet = new TClonesArray("TVector3",nCases);
4654
4655 for(Int_t ij=0; ij<nCases; ++ij)
4656 {
4657 // Get jet information
4658 AliAODJet* jet = dynamic_cast<AliAODJet*>(jetlist->At(ij));
4659 if(!jet)continue;
4660 TVector3 jet3mom;
4661 jet3mom.SetPtEtaPhi(jet->Pt(),jet->Eta(),jet->Phi());
4662 new((*vect3Jet)[ijet]) TVector3((TVector3)jet3mom);
4663 Float_t etaJet = (Float_t)((TVector3*) vect3Jet->At(ij))->Eta();
4664
4665 // Jet area
4666 areaJet[ij] = CalcJetArea(etaJet,rc);
4667
4668 // Area jet larger angle
4669 areaJetLarge[ij] = CalcJetArea(etaJet,rcl);
4670
4671 // Outside jets area
4672 areaOut = areaOut - areaJetLarge[ij];
4673 ijet++;
4674 }
4675
4676 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
4677
4678 // embedded tracks
4679 if( fUseExtraTracksBgr != 1){
4680 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
4681 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4682 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4683 }
4684 }
4685
4686 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
4687 if(!track)continue;
4688 Double_t trackMom[3];
4689 track->PxPyPz(trackMom);
4690 TVector3 track3mom(trackMom);
4691
4692 Double_t *dR = new Double_t[nCases];
4693 for(Int_t ij=0; ij<nCases; ij++)
4694 dR[ij] = (Double_t)((TVector3*) vect3Jet->At(ij))->DeltaR(track3mom);
4695
4696 if((nCases==0) ||
4697 (nCases==1 && (dR[0]>rcl)) ||
4698 (nCases==2 && (dR[0]>rcl && dR[1]>rcl)) ||
4699 (nCases==3 && (dR[0]>rcl && dR[1]>rcl && dR[2]>rcl)))
4700 {
4701 outputlist->Add(track);
4702 sumPt += track->Pt();
4703 nOut++;
4704 }
4705 delete [] dR;
4706 }
4707
4708 if(nCases==0) areaJet[0] = TMath::Pi()*rc*rc;
4709 normFactor = (Float_t) 1./(areaJet[0] / areaOut);
4710
4711 outputlist->Sort();
4712
4713 delete vect3Jet;
4714 delete [] areaJetLarge;
4715 delete [] areaJet;
4716
4717}
4718
4719// ______________________________________________________________________________________________________________________________________________________
9d7ad2e4 4720Float_t AliAnalysisTaskIDFragmentationFunction::CalcJetArea(Float_t etaJet, Float_t rc) const
e131b05f 4721{
4722 // calculate area of jet with eta etaJet and radius rc
4723
4724 Float_t detamax = etaJet + rc;
4725 Float_t detamin = etaJet - rc;
4726 Float_t accmax = 0.0; Float_t accmin = 0.0;
4727 if(detamax > fTrackEtaMax){ // sector outside etamax
4728 Float_t h = fTrackEtaMax - etaJet;
4729 accmax = rc*rc*TMath::ACos(h/rc) - h*TMath::Sqrt(rc*rc - h*h);
4730 }
4731 if(detamin < fTrackEtaMin){ // sector outside etamin
4732 Float_t h = fTrackEtaMax + etaJet;
4733 accmin = rc*rc*TMath::ACos(h/rc) - h*TMath::Sqrt(rc*rc - h*h);
4734 }
4735 Float_t areaJet = rc*rc*TMath::Pi() - accmax - accmin;
4736
4737 return areaJet;
4738
4739}
4740
4741// ___________________________________________________________________________________________________________________________
4742void AliAnalysisTaskIDFragmentationFunction::GetClusterTracksOutOf1Jet(AliAODJet* jet, TList* outputlist, Double_t &normFactor)
4743{
4744 // fill tracks from bckgCluster branch in list,
4745 // for all clusters outside jet cone
4746 // sum up total area of clusters
4747
4748 Double_t rc = GetFFRadius();
4749 Double_t rcl = GetFFBckgRadius();
4750
4751 Double_t areaTotal = 0;
4752 Double_t sumPtTotal = 0;
4753
4754 for(Int_t ij=0; ij<fBckgJetsRec->GetEntries(); ++ij){
4755
4756 AliAODJet* bgrCluster = (AliAODJet*)(fBckgJetsRec->At(ij)); // not 'recCuts': use all clusters in full eta range
4757
4758 Double_t dR = jet->DeltaR(bgrCluster);
4759
4760 if(dR<rcl) continue;
4761
4762 Double_t clusterPt = bgrCluster->Pt();
4763 Double_t area = bgrCluster->EffectiveAreaCharged();
4764 areaTotal += area;
4765 sumPtTotal += clusterPt;
4766
4767 Int_t nTracksJet = bgrCluster->GetRefTracks()->GetEntries();
4768
4769 for(Int_t it = 0; it<nTracksJet; it++){
4770
4771 // embedded tracks - note: using ref tracks here, fBranchRecBckgClusters has to be consistent
4772 if( fUseExtraTracksBgr != 1){
4773 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (bgrCluster->GetTrack(it))){
4774 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4775 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4776 }
4777 }
4778
4779 AliVParticle* track = dynamic_cast<AliVParticle*>(bgrCluster->GetTrack(it));
4780 if(!track) continue;
4781
4782 Float_t trackPt = track->Pt();
4783 Float_t trackEta = track->Eta();
4784 Float_t trackPhi = TVector2::Phi_0_2pi(track->Phi());
4785
4786 if(trackEta < fTrackEtaMin || trackEta > fTrackEtaMax) continue;
4787 if(trackPhi < fTrackPhiMin || trackPhi > fTrackPhiMax) continue;
4788 if(trackPt < fTrackPtCut) continue;
4789
4790 outputlist->Add(track);
4791 }
4792 }
4793
4794 Double_t areaJet = TMath::Pi()*rc*rc;
4795 if(areaTotal) normFactor = (Float_t) 1./(areaJet / areaTotal);
4796
4797 outputlist->Sort();
4798}
4799
4800// _______________________________________________________________________________________________________________________
4801void AliAnalysisTaskIDFragmentationFunction::GetClusterTracksMedian(TList* outputlist, Double_t &normFactor)
4802{
4803 // fill tracks from bckgCluster branch,
4804 // using cluster with median density (odd number of clusters)
4805 // or picking randomly one of the two closest to median (even number)
4806
4807 normFactor = 0;
4808
c4856fb1 4809 const Int_t nBckgClusters = fBckgJetsRec->GetEntries(); // not 'recCuts': use all clusters in full eta range
e131b05f 4810
4811 if(nBckgClusters<3) return; // need at least 3 clusters (skipping 2 highest)
4812
4813 Double_t* bgrDensity = new Double_t[nBckgClusters];
4814 Int_t* indices = new Int_t[nBckgClusters];
4815
4816 for(Int_t ij=0; ij<nBckgClusters; ++ij){
4817
4818 AliAODJet* bgrCluster = (AliAODJet*)(fBckgJetsRec->At(ij));
4819 Double_t clusterPt = bgrCluster->Pt();
4820 Double_t area = bgrCluster->EffectiveAreaCharged();
4821
4822 Double_t density = 0;
4823 if(area>0) density = clusterPt/area;
4824
4825 bgrDensity[ij] = density;
4826 indices[ij] = ij;
4827 }
4828
4829 TMath::Sort(nBckgClusters, bgrDensity, indices);
4830
4831 // get median cluster
4832
4833 AliAODJet* medianCluster = 0;
4834 //Double_t medianDensity = 0;
4835
4836 if(TMath::Odd(nBckgClusters)){
4837
4838 Int_t medianIndex = indices[(Int_t) (0.5*(nBckgClusters-1))];
4839 medianCluster = (AliAODJet*)(fBckgJetsRec->At(medianIndex));
4840
4841 //Double_t clusterPt = medianCluster->Pt();
4842 //Double_t area = medianCluster->EffectiveAreaCharged();
4843
4844 //if(area>0) medianDensity = clusterPt/area;
4845 }
4846 else{
4847
4848 Int_t medianIndex1 = indices[(Int_t) (0.5*nBckgClusters-1)];
4849 Int_t medianIndex2 = indices[(Int_t) (0.5*nBckgClusters)];
4850
4851 AliAODJet* medianCluster1 = (AliAODJet*)(fBckgJetsRec->At(medianIndex1));
4852 AliAODJet* medianCluster2 = (AliAODJet*)(fBckgJetsRec->At(medianIndex2));
4853
4854 //Double_t density1 = 0;
4855 //Double_t clusterPt1 = medianCluster1->Pt();
4856 //Double_t area1 = medianCluster1->EffectiveAreaCharged();
4857 //if(area1>0) density1 = clusterPt1/area1;
4858
4859 //Double_t density2 = 0;
4860 //Double_t clusterPt2 = medianCluster2->Pt();
4861 //Double_t area2 = medianCluster2->EffectiveAreaCharged();
4862 //if(area2>0) density2 = clusterPt2/area2;
4863
4864 //medianDensity = 0.5*(density1+density2);
4865
4866 medianCluster = ( (fRandom->Rndm()>0.5) ? medianCluster1 : medianCluster2 ); // select one randomly to avoid adding areas
4867 }
4868
4869 Int_t nTracksJet = medianCluster->GetRefTracks()->GetEntries();
4870
4871 for(Int_t it = 0; it<nTracksJet; it++){
4872
4873 // embedded tracks - note: using ref tracks here, fBranchRecBckgClusters has to be consistent
4874 if( fUseExtraTracksBgr != 1){
4875 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (medianCluster->GetTrack(it))){
4876 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4877 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4878 }
4879 }
4880
4881 AliVParticle* track = dynamic_cast<AliVParticle*>(medianCluster->GetTrack(it));
4882 if(!track) continue;
4883
4884 Float_t trackPt = track->Pt();
4885 Float_t trackEta = track->Eta();
4886 Float_t trackPhi = TVector2::Phi_0_2pi(track->Phi());
4887
4888 if(trackEta < fTrackEtaMin || trackEta > fTrackEtaMax) continue;
4889 if(trackPhi < fTrackPhiMin || trackPhi > fTrackPhiMax) continue;
4890 if(trackPt < fTrackPtCut) continue;
4891
4892 outputlist->Add(track);
4893 }
4894
4895 Double_t areaMedian = medianCluster->EffectiveAreaCharged();
4896 Double_t areaJet = TMath::Pi()*GetFFRadius()*GetFFRadius();
4897
4898 if(areaMedian) normFactor = (Float_t) 1./(areaJet / areaMedian);
4899
4900 outputlist->Sort();
4901
4902 delete[] bgrDensity;
4903 delete[] indices;
4904}
4905
4906// ______________________________________________________________________________________________________________________________________________________
4907void AliAnalysisTaskIDFragmentationFunction::FillBckgHistos(Int_t type, TList* inputtracklist, TList* inputjetlist, AliAODJet* jet,
4908 AliFragFuncHistos* ffbckghistocuts, AliFragFuncQATrackHistos* qabckghistocuts, TH1F* fh1Mult){
4909
4910 // List of tracks outside jets for background study
4911 TList* tracklistout2jets = new TList();
4912 TList* tracklistout3jets = new TList();
4913 TList* tracklistout2jetsStat = new TList();
4914 TList* tracklistout3jetsStat = new TList();
4915 Double_t sumPtOut2Jets = 0.;
4916 Double_t sumPtOut3Jets = 0.;
4917 Double_t sumPtOut2JetsStat = 0.;
4918 Double_t sumPtOut3JetsStat = 0.;
4919 Double_t normFactor2Jets = 0.;
4920 Double_t normFactor3Jets = 0.;
4921
4922 Int_t nRecJetsCuts = inputjetlist->GetEntries();
4923
4924 if(nRecJetsCuts>1) {
4925 GetTracksOutOfNJets(2,inputtracklist, tracklistout2jets, inputjetlist, sumPtOut2Jets);
4926 GetTracksOutOfNJetsStat(2,inputtracklist, tracklistout2jetsStat, inputjetlist,sumPtOut2JetsStat, normFactor2Jets);
4927
4928 }
4929 if(nRecJetsCuts>2) {
4930 GetTracksOutOfNJets(3,inputtracklist, tracklistout3jets, inputjetlist, sumPtOut3Jets);
4931 GetTracksOutOfNJetsStat(3,inputtracklist, tracklistout3jetsStat, inputjetlist, sumPtOut3JetsStat, normFactor3Jets);
4932 }
4933
4934 if(type==kBckgOutLJ || type==kBckgOutAJ)
4935 {
4936 TList* tracklistoutleading = new TList();
4937 Double_t sumPtOutLeading = 0.;
4938 GetTracksOutOfNJets(1,inputtracklist, tracklistoutleading, inputjetlist, sumPtOutLeading);
4939 if(type==kBckgOutLJ && fh1Mult) fh1Mult->Fill(tracklistoutleading->GetSize());
4940
4941 for(Int_t it=0; it<tracklistoutleading->GetSize(); ++it){
4942
4943 AliVParticle* trackVP = (AliVParticle*)(tracklistoutleading->At(it));
4944 if(!trackVP) continue;
4945 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4946
4947 Float_t jetPt = jet->Pt();
4948 Float_t trackPt = trackV->Pt();
4949
4950 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4951
4952 if(type==kBckgOutLJ)
4953 {
4954 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt);
4955
4956 // Fill track QA for background
4957 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
4958 }
4959
4960 // All cases included
4961 if(nRecJetsCuts==1 && type==kBckgOutAJ)
4962 {
4963 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
4964 }
4965 delete trackV;
4966 }
4967 // Increment jet pt with one entry in case #tracks outside jets = 0
4968 if(tracklistoutleading->GetSize()==0) {
4969 Float_t jetPt = jet->Pt();
4970 Bool_t incrementJetPt = kTRUE;
4971 if(type==kBckgOutLJ)
4972 {
4973 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4974 }
4975 // All cases included
4976 if(nRecJetsCuts==1 && type==kBckgOutAJ)
4977 {
4978 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4979 }
4980 }
4981 delete tracklistoutleading;
4982 }
4983 if(type==kBckgOutLJStat || type==kBckgOutAJStat)
4984 {
4985 TList* tracklistoutleadingStat = new TList();
4986 Double_t sumPtOutLeadingStat = 0.;
4987 Double_t normFactorLeading = 0.;
4988
4989 GetTracksOutOfNJetsStat(1,inputtracklist, tracklistoutleadingStat, inputjetlist, sumPtOutLeadingStat, normFactorLeading);
4990 if(type==kBckgOutLJStat && fh1Mult) fh1Mult->Fill(tracklistoutleadingStat->GetSize());
4991
4992 for(Int_t it=0; it<tracklistoutleadingStat->GetSize(); ++it){
4993
4994 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistoutleadingStat->At(it));
4995 if(!trackVP) continue;
4996 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4997
4998 Float_t jetPt = jet->Pt();
4999 Float_t trackPt = trackV->Pt();
5000 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5001
5002 // Stat plots
5003 if(type==kBckgOutLJStat)
5004 {
5005 if(fFFMode)ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorLeading);
5006
5007 // Fill track QA for background
5008 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt); // OB added bgr QA
5009 }
5010
5011 // All cases included
5012 if(nRecJetsCuts==1 && type==kBckgOutAJStat)
5013 {
5014 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorLeading);
5015 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
5016
5017 }
5018 delete trackV;
5019 }
5020 // Increment jet pt with one entry in case #tracks outside jets = 0
5021 if(tracklistoutleadingStat->GetSize()==0) {
5022 Float_t jetPt = jet->Pt();
5023 Bool_t incrementJetPt = kTRUE;
5024 if(type==kBckgOutLJStat)
5025 {
5026 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorLeading);
5027 }
5028 // All cases included
5029 if(nRecJetsCuts==1 && type==kBckgOutLJStat)
5030 {
5031 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorLeading);
5032 }
5033 }
5034
5035 delete tracklistoutleadingStat;
5036 }
5037
5038 if(type==kBckgPerp || type==kBckgPerp2 || type==kBckgPerp2Area)
5039 {
5040 Double_t sumPtPerp1 = 0.;
5041 Double_t sumPtPerp2 = 0.;
5042 TList* tracklistperp = new TList();
5043 TList* tracklistperp1 = new TList();
5044 TList* tracklistperp2 = new TList();
5045
5046 Double_t norm = 1;
5047 if(type == kBckgPerp2) norm = 2; // in FillFF() scaleFac = 1/norm = 0.5 - account for double area;
5048 if(type == kBckgPerp2Area) norm = 2*TMath::Pi()*TMath::Abs(GetFFRadius())*TMath::Abs(GetFFRadius()) / jet->EffectiveAreaCharged(); // in FillFF() scaleFac = 1/norm;
5049
5050 GetTracksTiltedwrpJetAxis(TMath::Pi()/2., inputtracklist,tracklistperp1,jet,TMath::Abs(GetFFRadius()),sumPtPerp1);
5051 if(type==kBckgPerp2 || type==kBckgPerp2Area) GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2., inputtracklist,tracklistperp2,jet,TMath::Abs(GetFFRadius()),sumPtPerp2);
5052
5053 tracklistperp->AddAll(tracklistperp1);
5054 tracklistperp->AddAll(tracklistperp2);
5055
5056 if(tracklistperp->GetSize() != tracklistperp1->GetSize() + tracklistperp2->GetSize()){
5057 cout<<" ERROR: tracklistperp size "<<tracklistperp->GetSize()<<" perp1 "<<tracklistperp1->GetSize()<<" perp2 "<<tracklistperp2->GetSize()<<endl;
5058 exit(0);
5059 }
5060
5061 if(fh1Mult) fh1Mult->Fill(tracklistperp->GetSize());
5062
5063 for(Int_t it=0; it<tracklistperp->GetSize(); ++it){
5064
5065 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistperp->At(it));
5066 if(!trackVP)continue;
5067 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5068
5069 Float_t jetPt = jet->Pt();
5070 Float_t trackPt = trackV->Pt();
5071
5072 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5073
5074 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, norm );
5075
5076 // Fill track QA for background
5077 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
5078
5079 delete trackV;
5080 }
5081 // Increment jet pt with one entry in case #tracks outside jets = 0
5082 if(tracklistperp->GetSize()==0) {
5083 Float_t jetPt = jet->Pt();
5084 Bool_t incrementJetPt = kTRUE;
5085 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5086 }
5087
5088
5089 if(fJSMode){
5090 // fill for tracklistperp1/2 separately, divide norm by 2
5091 if(type==kBckgPerp){
5092 FillJetShape(jet, tracklistperp, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, TMath::Pi()/2., 0., kFALSE);
5093 }
5094 if(type==kBckgPerp2){
5095 FillJetShape(jet, tracklistperp1, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, TMath::Pi()/2., 0., kFALSE);
5096 FillJetShape(jet, tracklistperp2, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, -1*TMath::Pi()/2., 0., kFALSE);
5097 }
5098 if(type==kBckgPerp2Area){ // divide norm by 2: listperp1/2 filled separately
5099 FillJetShape(jet, tracklistperp1, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, TMath::Pi()/2., 0.5*norm, kFALSE);
5100 FillJetShape(jet, tracklistperp2, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, -1*TMath::Pi()/2., 0.5*norm, kFALSE);
5101 }
5102 }
5103
5104 delete tracklistperp;
5105 delete tracklistperp1;
5106 delete tracklistperp2;
5107 }
5108
5109 if(type==kBckgASide)
5110 {
5111 Double_t sumPtASide = 0.;
5112 TList* tracklistaside = new TList();
5113 GetTracksTiltedwrpJetAxis(TMath::Pi(),inputtracklist,tracklistaside,jet,TMath::Abs(GetFFRadius()),sumPtASide);
5114 if(fh1Mult) fh1Mult->Fill(tracklistaside->GetSize());
5115
5116 for(Int_t it=0; it<tracklistaside->GetSize(); ++it){
5117
5118 AliVParticle* trackVP = (AliVParticle*)(tracklistaside->At(it));
5119 if(!trackVP) continue;
5120 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5121
5122 Float_t jetPt = jet->Pt();
5123 Float_t trackPt = trackV->Pt();
5124
5125 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5126
5127 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
5128
5129 // Fill track QA for background
5130 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
5131
5132 delete trackV;
5133 }
5134 if(tracklistaside->GetSize()==0) {
5135 Float_t jetPt = jet->Pt();
5136 Bool_t incrementJetPt = kTRUE;
5137 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5138 }
5139
5140 delete tracklistaside;
5141 }
5142
5143 if(type==kBckgASideWindow)
5144 {
5145 Double_t normFactorASide = 0.;
5146 Double_t sumPtASideW = 0.;
5147 TList* tracklistasidew = new TList();
5148 GetTracksTiltedwrpJetAxisWindow(TMath::Pi(),inputtracklist,tracklistasidew,jet,TMath::Abs(GetFFRadius()),sumPtASideW,normFactorASide);
5149 if(fh1Mult) fh1Mult->Fill(tracklistasidew->GetSize());
5150
5151 for(Int_t it=0; it<tracklistasidew->GetSize(); ++it){
5152
5153 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistasidew->At(it));
5154 if(!trackVP) continue;
5155 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5156
5157 Float_t jetPt = jet->Pt();
5158 Float_t trackPt = trackV->Pt();
5159 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5160
5161 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorASide);
5162
5163 // Fill track QA for background
5164 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt, kFALSE, normFactorASide);
5165
5166 delete trackV;
5167 }
5168 if(tracklistasidew->GetSize()==0) {
5169 Float_t jetPt = jet->Pt();
5170 Bool_t incrementJetPt = kTRUE;
5171 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorASide);
5172 }
5173
5174 delete tracklistasidew;
5175 }
5176
5177 if(type==kBckgPerpWindow)
5178 {
5179 Double_t normFactorPerp = 0.;
5180 Double_t sumPtPerpW = 0.;
5181 TList* tracklistperpw = new TList();
5182 GetTracksTiltedwrpJetAxisWindow(TMath::Pi()/2.,inputtracklist,tracklistperpw,jet,TMath::Abs(GetFFRadius()),sumPtPerpW,normFactorPerp);
5183 if(fh1Mult) fh1Mult->Fill(tracklistperpw->GetSize());
5184
5185 for(Int_t it=0; it<tracklistperpw->GetSize(); ++it){
5186
5187 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistperpw->At(it));
5188 if(!trackVP) continue;
5189 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5190
5191 Float_t jetPt = jet->Pt();
5192 Float_t trackPt = trackV->Pt();
5193 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5194
5195 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorPerp);
5196
5197 // Fill track QA for background
5198 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt, kFALSE, normFactorPerp);
5199
5200 delete trackV;
5201 }
5202 if(tracklistperpw->GetSize()==0) {
5203 Float_t jetPt = jet->Pt();
5204 Bool_t incrementJetPt = kTRUE;
5205 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorPerp);
5206 }
5207
5208 delete tracklistperpw;
5209 }
5210
5211
5212 if(type==kBckgOut2J || type==kBckgOutAJ)
5213 {
5214 if(type==kBckgOut2J && fh1Mult) fh1Mult->Fill(tracklistout2jets->GetSize());
5215 for(Int_t it=0; it<tracklistout2jets->GetSize(); ++it){
5216
5217 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout2jets->At(it));
5218 if(!trackVP) continue;
5219 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5220
5221 Float_t jetPt = jet->Pt();
5222 Float_t trackPt = trackV->Pt();
5223
5224 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5225
5226 if(type==kBckgOut2J)
5227 {
5228 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
5229 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
5230 }
5231
5232 // All cases included
5233 if(nRecJetsCuts==2 && type==kBckgOutAJ)
5234 {
5235 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
5236
5237 }
5238 delete trackV;
5239 }
5240 // Increment jet pt with one entry in case #tracks outside jets = 0
5241 if(tracklistout2jets->GetSize()==0) {
5242 Float_t jetPt = jet->Pt();
5243 Bool_t incrementJetPt = kTRUE;
5244 if(type==kBckgOut2J)
5245 {
5246 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5247 }
5248 // All cases included
5249 if(nRecJetsCuts==2 && type==kBckgOutAJ)
5250 {
5251 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5252 }
5253 }
5254 }
5255
5256 if(type==kBckgOut2JStat || type==kBckgOutAJStat)
5257 {
5258 for(Int_t it=0; it<tracklistout2jetsStat->GetSize(); ++it){
5259
5260 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout2jetsStat->At(it));
5261 if(!trackVP) continue;
5262 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5263
5264 Float_t jetPt = jet->Pt();
5265 Float_t trackPt = trackV->Pt();
5266 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5267
5268 if(type==kBckgOut2JStat)
5269 {
5270 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor2Jets);
5271
5272 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
5273 }
5274
5275 // All cases included
5276 if(nRecJetsCuts==2 && type==kBckgOutAJStat)
5277 {
5278 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor2Jets);
5279
5280 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
5281 }
5282 delete trackV;
5283 }
5284 // Increment jet pt with one entry in case #tracks outside jets = 0
5285 if(tracklistout2jetsStat->GetSize()==0) {
5286 Float_t jetPt = jet->Pt();
5287 Bool_t incrementJetPt = kTRUE;
5288 if(type==kBckgOut2JStat)
5289 {
5290 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor2Jets);
5291 }
5292 // All cases included
5293 if(nRecJetsCuts==2 && type==kBckgOutAJStat)
5294 {
5295 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor2Jets);
5296 }
5297 }
5298
5299 }
5300
5301 if(type==kBckgOut3J || type==kBckgOutAJ)
5302 {
5303 if(type==kBckgOut3J && fh1Mult) fh1Mult->Fill(tracklistout3jets->GetSize());
5304
5305 for(Int_t it=0; it<tracklistout3jets->GetSize(); ++it){
5306
5307 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout3jets->At(it));
5308 if(!trackVP) continue;
5309 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5310
5311 Float_t jetPt = jet->Pt();
5312 Float_t trackPt = trackV->Pt();
5313
5314 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5315
5316 if(type==kBckgOut3J)
5317 {
5318 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
5319
5320 qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
5321 }
5322
5323 // All cases included
5324 if(nRecJetsCuts==3 && type==kBckgOutAJ)
5325 {
5326 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
5327
5328 }
5329 delete trackV;
5330 }
5331 // Increment jet pt with one entry in case #tracks outside jets = 0
5332 if(tracklistout3jets->GetSize()==0) {
5333 Float_t jetPt = jet->Pt();
5334 Bool_t incrementJetPt = kTRUE;
5335 if(type==kBckgOut3J)
5336 {
5337 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5338 }
5339 // All cases included
5340 if(nRecJetsCuts==3 && type==kBckgOutAJ)
5341 {
5342 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5343 }
5344 }
5345 }
5346
5347 if(type==kBckgOut3JStat || type==kBckgOutAJStat)
5348 {
5349 for(Int_t it=0; it<tracklistout3jetsStat->GetSize(); ++it){
5350
5351 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout3jetsStat->At(it));
5352 if(!trackVP) continue;
5353 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5354
5355 Float_t jetPt = jet->Pt();
5356 Float_t trackPt = trackV->Pt();
5357 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5358
5359 if(type==kBckgOut3JStat)
5360 {
5361 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor3Jets);
5362
5363 //if(fQAMode&1) qabckghistocuts->FillTrackQA( trackEta, TVector2::Phi_0_2pi(trackPhi), trackPt);
5364 }
5365
5366 // All cases included
5367 if(nRecJetsCuts==3 && type==kBckgOutAJStat)
5368 {
5369 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor3Jets );
5370
5371 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
5372
5373 }
5374 delete trackV;
5375 }
5376 // Increment jet pt with one entry in case #tracks outside jets = 0
5377 if(tracklistout3jetsStat->GetSize()==0) {
5378 Float_t jetPt = jet->Pt();
5379 Bool_t incrementJetPt = kTRUE;
5380 if(type==kBckgOut3JStat)
5381 {
5382 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor3Jets);
5383 }
5384 // All cases included
5385 if(nRecJetsCuts==3 && type==kBckgOutAJStat)
5386 {
5387 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor3Jets);
5388 }
5389 }
5390
5391 }
5392
5393 if(type==kBckgClustersOutLeading){ // clusters bgr: all tracks in clusters out of leading jet
5394
5395 TList* tracklistClustersOutLeading = new TList();
5396 Double_t normFactorClusters = 0;
5397 Float_t jetPt = jet->Pt();
5398
5399 GetClusterTracksOutOf1Jet(jet, tracklistClustersOutLeading, normFactorClusters);
5400 if(fh1Mult) fh1Mult->Fill(tracklistClustersOutLeading->GetSize());
5401
5402 for(Int_t it=0; it<tracklistClustersOutLeading->GetSize(); ++it){
5403
5404 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistClustersOutLeading->At(it));
5405 if(!trackVP) continue;
5406 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5407
5408 Float_t trackPt = trackVP->Pt();
5409
5410 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5411
5412 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorClusters );
5413 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
5414
5415 delete trackV;
5416 }
5417
5418 delete tracklistClustersOutLeading;
5419
5420 }
5421
5422 if(type == kBckgClusters){ // clusters bgr: all tracks in 'median cluster'
5423
5424 TList* tracklistClustersMedian = new TList();
5425 Double_t normFactorClusters = 0;
5426 Float_t jetPt = jet->Pt();
5427
5428 GetClusterTracksMedian(tracklistClustersMedian, normFactorClusters);
5429 if(fh1Mult) fh1Mult->Fill(tracklistClustersMedian->GetSize());
5430
5431 for(Int_t it=0; it<tracklistClustersMedian->GetSize(); ++it){
5432
5433 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistClustersMedian->At(it));
5434 if(!trackVP) continue;
5435 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5436
5437 Float_t trackPt = trackVP->Pt();
5438
5439 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5440
5441 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorClusters );
5442 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
5443
5444 delete trackV;
5445 }
5446
5447 delete tracklistClustersMedian;
5448 }
5449
5450 delete tracklistout2jets;
5451 delete tracklistout3jets;
5452 delete tracklistout2jetsStat;
5453 delete tracklistout3jetsStat;
5454}
5455
5456//_____________________________________________________________________________________
9d7ad2e4 5457Double_t AliAnalysisTaskIDFragmentationFunction::GetMCStrangenessFactor(Double_t pt) const
e131b05f 5458{
5459 // factor strangeness data/MC as function of pt from UE analysis (Sara Vallero)
5460
5461 Double_t alpha = 1;
5462
5463 if(0.150<pt && pt<0.200) alpha = 3.639;
5464 if(0.200<pt && pt<0.250) alpha = 2.097;
5465 if(0.250<pt && pt<0.300) alpha = 1.930;
5466 if(0.300<pt && pt<0.350) alpha = 1.932;
5467 if(0.350<pt && pt<0.400) alpha = 1.943;
5468 if(0.400<pt && pt<0.450) alpha = 1.993;
5469 if(0.450<pt && pt<0.500) alpha = 1.989;
5470 if(0.500<pt && pt<0.600) alpha = 1.963;
5471 if(0.600<pt && pt<0.700) alpha = 1.917;
5472 if(0.700<pt && pt<0.800) alpha = 1.861;
5473 if(0.800<pt && pt<0.900) alpha = 1.820;
5474 if(0.900<pt && pt<1.000) alpha = 1.741;
5475 if(1.000<pt && pt<1.500) alpha = 0.878;
5476
5477 return alpha;
5478}
5479
5480//__________________________________________________________________________________________________
5481Double_t AliAnalysisTaskIDFragmentationFunction::GetMCStrangenessFactorCMS(AliAODMCParticle* daughter) const
5482{
5483 // strangeness ratio MC/data as function of mother pt from CMS data in |eta|<2.0
5484
5485 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
5486 if(!tca) return 1;
5487
5488 AliAODMCParticle* currentMother = daughter;
5489 AliAODMCParticle* currentDaughter = daughter;
5490
5491
5492 // find first primary mother K0s, Lambda or Xi
5493 while(1){
5494
5495 Int_t daughterPDG = currentDaughter->GetPdgCode();
5496
5497 Int_t motherLabel = currentDaughter->GetMother();
5498 if(motherLabel >= tca->GetEntriesFast()){ // protection
5499 currentMother = currentDaughter;
5500 break;
5501 }
5502
5503 currentMother = (AliAODMCParticle*) tca->At(motherLabel);
5504
5505 if(!currentMother){
5506 currentMother = currentDaughter;
5507 break;
5508 }
5509
5510 Int_t motherPDG = currentMother->GetPdgCode();
5511
5512 // phys. primary found ?
5513 if(currentMother->IsPhysicalPrimary()) break;
5514
5515 if(TMath::Abs(daughterPDG) == 321){ // K+/K- e.g. from phi (ref data not feeddown corrected)
5516 currentMother = currentDaughter; break;
5517 }
5518 if(TMath::Abs(motherPDG) == 310 ){ // K0s e.g. from phi (ref data not feeddown corrected)
5519 break;
5520 }
5521 if(TMath::Abs(motherPDG) == 3212 && TMath::Abs(daughterPDG) == 3122){ // mother Sigma0, daughter Lambda (this case not included in feeddown corr.)
5522 currentMother = currentDaughter; break;
5523 }
5524
5525 currentDaughter = currentMother;
5526 }
5527
5528
5529 Int_t motherPDG = currentMother->GetPdgCode();
5530 Double_t motherGenPt = currentMother->Pt();
5531
5532 return AliAnalysisTaskPID::GetMCStrangenessFactorCMS(motherPDG, motherGenPt);
5533}
5534
5535// _________________________________________________________________________________
5536void AliAnalysisTaskIDFragmentationFunction::FillJetShape(AliAODJet* jet, TList* list,
5537 TProfile* hProNtracksLeadingJet, TProfile** hProDelRPtSum, TProfile* hProDelR80pcPt,
5538 Double_t dPhiUE, Double_t normUE, Bool_t scaleStrangeness)
5539{
5540 // Fill jet shape histos
5541
5542 const Int_t kNbinsR = 50;
5543 const Float_t kBinWidthR = 0.02;
5544
5545 Int_t nJetTracks = list->GetEntries();
5546
5547 Float_t pTsumA[kNbinsR] = {0.0};
5548
5549 Float_t *delRA = new Float_t[nJetTracks];
5550 Float_t *trackPtA = new Float_t[nJetTracks];
5551 Int_t *index = new Int_t[nJetTracks];
5552
5553 for(Int_t i=0; i<nJetTracks; i++){
5554 delRA[i] = 0;
5555 trackPtA[i] = 0;
5556 index[i] = 0;
5557 }
5558
5559 Double_t jetMom[3];
5560 jet->PxPyPz(jetMom);
5561 TVector3 jet3mom(jetMom);
5562
5563 if(TMath::Abs(dPhiUE)>0){
5564 Double_t phiTilted = jet3mom.Phi();
5565 phiTilted += dPhiUE;
5566 phiTilted = TVector2::Phi_0_2pi(phiTilted);
5567 jet3mom.SetPhi(phiTilted);
5568 }
5569
5570 Double_t jetPt = jet->Pt();
5571 Double_t sumWeights = 0;
5572
5573 for (Int_t j =0; j<nJetTracks; j++){
5574
5575 AliVParticle* track = dynamic_cast<AliVParticle*>(list->At(j));
5576 if(!track)continue;
5577
5578 Double_t trackMom[3];
5579 track->PxPyPz(trackMom);
5580 TVector3 track3mom(trackMom);
5581
5582 Double_t dR = jet3mom.DeltaR(track3mom);
5583
5584 delRA[j] = dR;
5585 trackPtA[j] = track->Pt();
5586
5587 Double_t weight = GetMCStrangenessFactor(track->Pt()); // more correctly should be gen pt
5588 sumWeights += weight;
5589
5590 for(Int_t ibin=1; ibin<=kNbinsR; ibin++){
5591 Float_t xlow = kBinWidthR*(ibin-1);
5592 Float_t xup = kBinWidthR*ibin;
5593 if(xlow <= dR && dR < xup){
5594
5595 if(scaleStrangeness) pTsumA[ibin-1] += track->Pt()*weight;
5596 else pTsumA[ibin-1] += track->Pt();
5597 }
5598 }
5599 } // track loop
5600
5601 Float_t jetPtMin=0;
5602 Float_t jetPtMax=0;
5603
5604 for(Int_t ibin=0; ibin<kNbinsR; ibin++){
5605 Float_t fR = kBinWidthR*(ibin+0.5);
5606
5607 for(Int_t k=0; k<5; k++){
5608 if(k==0){jetPtMin=20.0;jetPtMax=30.0;}
5609 if(k==1){jetPtMin=30.0;jetPtMax=40.0;}
5610 if(k==2){jetPtMin=40.0;jetPtMax=60.0;}
5611 if(k==3){jetPtMin=60.0;jetPtMax=80.0;}
5612 if(k==4){jetPtMin=80.0;jetPtMax=100.0;}
5613 if(jetPt>jetPtMin && jetPt<jetPtMax){
5614
5615 hProDelRPtSum[k]->Fill(fR,pTsumA[ibin]);
5616
5617 }
5618 }
5619 }
5620
5621 if(scaleStrangeness) hProNtracksLeadingJet->Fill(jetPt,sumWeights);
5622 else hProNtracksLeadingJet->Fill(jetPt,nJetTracks);
5623
5624 if(normUE) hProNtracksLeadingJet->Fill(jetPt,nJetTracks/normUE);
5625
5626 if(hProDelR80pcPt){
5627
5628 Float_t pTsum = 0;
5629 Float_t delRPtSum80pc = 0;
5630
5631 TMath::Sort(nJetTracks,delRA,index,0);
5632
5633 for(Int_t ii=0; ii<nJetTracks; ii++){
5634
5635 if(scaleStrangeness){
5636 Double_t weight = GetMCStrangenessFactor(trackPtA[index[ii]]); // more correctly should be gen pt
5637 pTsum += weight*trackPtA[index[ii]];
5638 }
5639 else pTsum += trackPtA[index[ii]];
5640
5641
5642 if(pTsum/jetPt >= 0.8000){
5643 delRPtSum80pc = delRA[index[ii]];
5644 break;
5645 }
5646 }
5647 hProDelR80pcPt->Fill(jetPt,delRPtSum80pc);
5648 }
5649
5650 delete[] delRA;
5651 delete[] trackPtA;
5652 delete[] index;
5653}
5654
5655
5656// _________________________________________________________________________________
5657Bool_t AliAnalysisTaskIDFragmentationFunction::IsSecondaryWithStrangeMotherMC(AliAODMCParticle* part)
5658{
5659 // Check whether particle is a secondary with strange mother, i.e. returns kTRUE if a strange mother is found
5660 // and the particle is NOT a physical primary. In all other cases kFALSE is returned
5661
5662 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
5663 if (!tca || !part)
5664 return kFALSE;
5665
5666 if (part->IsPhysicalPrimary())
5667 return kFALSE;
5668
5669 Int_t iMother = part->GetMother();
5670 if (iMother < 0)
5671 return kFALSE;
5672
5673
5674 AliAODMCParticle* partM = dynamic_cast<AliAODMCParticle*>(tca->At(iMother));
5675 if (!partM)
5676 return kFALSE;
5677
5678 Int_t codeM = TMath::Abs(partM->GetPdgCode());
5679 Int_t mfl = Int_t(codeM / TMath::Power(10, Int_t(TMath::Log10(codeM))));
5680 if (mfl == 3 && codeM != 3) // codeM = 3 is for s quark
5681 return kTRUE;
5682
5683 return kFALSE;
5684}