]> 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
Moved initialisation of pointer (to PIDtasks) array to UserCreateOutputObjects, since...
[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 {
2295 Printf("ERROR: zero jet pid tasks!\n");
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 {
2317 Printf("ERROR: zero inclusive pid tasks!\n");
2318 fUseJetPIDtask = kFALSE;
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 }
2442
2443 // *** vertex cut ***
2444 AliAODVertex* primVtx = fAOD->GetPrimaryVertex();
2445 if (!primVtx) {
2446 Printf("%s:%d Primary vertex not found", (char*)__FILE__,__LINE__);
2447 return;
2448 }
2449
2450 Int_t nTracksPrim = primVtx->GetNContributors();
2451 fh1VertexNContributors->Fill(nTracksPrim);
2452
2453
2454 if (fDebug > 1) Printf("%s:%d primary vertex selection: %d", (char*)__FILE__,__LINE__,nTracksPrim);
2455 if(!nTracksPrim){
2456 if (fDebug > 1) Printf("%s:%d primary vertex selection: event REJECTED...",(char*)__FILE__,__LINE__);
2457 fh1EvtSelection->Fill(3.);
2458 PostData(1, fCommonHistList);
2459 return;
2460 }
2461
2462 fh1VertexZ->Fill(primVtx->GetZ());
2463
2464 if(TMath::Abs(primVtx->GetZ())>fMaxVertexZ){
2465 if (fDebug > 1) Printf("%s:%d primary vertex z = %f: event REJECTED...",(char*)__FILE__,__LINE__,primVtx->GetZ());
2466 fh1EvtSelection->Fill(4.);
2467 PostData(1, fCommonHistList);
2468 return;
2469 }
2470
2471 TString primVtxName(primVtx->GetName());
2472
2473 if(primVtxName.CompareTo("TPCVertex",TString::kIgnoreCase) == 1){
2474 if (fDebug > 1) Printf("%s:%d primary vertex selection: TPC vertex, event REJECTED...",(char*)__FILE__,__LINE__);
2475 fh1EvtSelection->Fill(5.);
2476 PostData(1, fCommonHistList);
2477 return;
2478 }
2479
2480 if (fDebug > 1) Printf("%s:%d event ACCEPTED ...",(char*)__FILE__,__LINE__);
2481 fh1EvtSelection->Fill(0.);
2482 fh1EvtCent->Fill(centPercent);
2483
2484 // Set centrality percentile fix to -1 for pp to be used for the PID framework
2485 if (fIsPP)
2486 centPercent = -1;
2487
2488
2489 //___ get MC information __________________________________________________________________
2490
2491 fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
2492
2493 if (fUseInclusivePIDtask) {
2494 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
2495 fInclusivePIDtask[i]->FillPythiaTrials(fAvgTrials);
2496 }
2497
2498 if (fUseJetPIDtask) {
2499 for (Int_t i = 0; i < fNumJetPIDtasks; i++)
2500 fJetPIDtask[i]->FillPythiaTrials(fAvgTrials);
2501 }
2502
2503 Double_t ptHard = 0.;
2504 Double_t nTrials = 1; // trials for MC trigger weight for real data
2505
2506 if(fMCEvent){
2507 AliGenEventHeader* genHeader = fMCEvent->GenEventHeader();
2508
2509 if(genHeader){
2510
2511 AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
2512 AliGenHijingEventHeader* hijingGenHeader = 0x0;
2513
2514 if(pythiaGenHeader){
2515 if(fDebug>3) Printf("%s:%d pythiaGenHeader found", (char*)__FILE__,__LINE__);
2516 nTrials = pythiaGenHeader->Trials();
2517 ptHard = pythiaGenHeader->GetPtHard();
2518
2519 fh1PtHard->Fill(ptHard);
2520 fh1PtHardTrials->Fill(ptHard,nTrials);
2521
2522 } else { // no pythia, hijing?
2523
2524 if(fDebug>3) Printf("%s:%d no pythiaGenHeader found", (char*)__FILE__,__LINE__);
2525
2526 hijingGenHeader = dynamic_cast<AliGenHijingEventHeader*>(genHeader);
2527 if(!hijingGenHeader){
2528 Printf("%s:%d no pythiaGenHeader or hjingGenHeader found", (char*)__FILE__,__LINE__);
2529 } else {
2530 if(fDebug>3) Printf("%s:%d hijingGenHeader found", (char*)__FILE__,__LINE__);
2531 }
2532 }
2533
2534 //fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
2535 }
2536 }
2537
2538 //___ fetch jets __________________________________________________________________________
2539
2540 Int_t nJ = GetListOfJets(fJetsRec, kJetsRec);
2541 Int_t nRecJets = 0;
2542 if(nJ>=0) nRecJets = fJetsRec->GetEntries();
2543 if(fDebug>2)Printf("%s:%d Selected Rec jets: %d %d",(char*)__FILE__,__LINE__,nJ,nRecJets);
2544 if(nJ != nRecJets) Printf("%s:%d Mismatch Selected Rec Jets: %d %d",(char*)__FILE__,__LINE__,nJ,nRecJets);
2545
2546 Int_t nJCuts = GetListOfJets(fJetsRecCuts, kJetsRecAcceptance);
2547 Int_t nRecJetsCuts = 0;
2548 if(nJCuts>=0) nRecJetsCuts = fJetsRecCuts->GetEntries();
2549 if(fDebug>2)Printf("%s:%d Selected Rec jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2550 if(nRecJetsCuts != nJCuts) Printf("%s:%d Mismatch selected Rec jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2551 fh1nRecJetsCuts->Fill(nRecJetsCuts);
2552
2553 if(fJetTypeGen==kJetsKine || fJetTypeGen == kJetsKineAcceptance) fJetsGen->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2554
2555 Int_t nJGen = GetListOfJets(fJetsGen, fJetTypeGen);
2556 Int_t nGenJets = 0;
2557 if(nJGen>=0) nGenJets = fJetsGen->GetEntries();
2558 if(fDebug>2)Printf("%s:%d Selected Gen jets: %d %d",(char*)__FILE__,__LINE__,nJGen,nGenJets);
2559
2560 if(nJGen != nGenJets) Printf("%s:%d Mismatch selected Gen jets: %d %d",(char*)__FILE__,__LINE__,nJGen,nGenJets);
2561 fh1nGenJets->Fill(nGenJets);
2562
2563
2564 if(fJetTypeRecEff==kJetsKine || fJetTypeRecEff == kJetsKineAcceptance) fJetsRecEff->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2565 Int_t nJRecEff = GetListOfJets(fJetsRecEff, fJetTypeRecEff);
2566 Int_t nRecEffJets = 0;
2567 if(nJRecEff>=0) nRecEffJets = fJetsRecEff->GetEntries();
2568 if(fDebug>2)Printf("%s:%d Selected RecEff jets: %d %d",(char*)__FILE__,__LINE__,nJRecEff,nRecEffJets);
2569 if(nJRecEff != nRecEffJets) Printf("%s:%d Mismatch selected RecEff jets: %d %d",(char*)__FILE__,__LINE__,nJRecEff,nRecEffJets);
2570 fh1nRecEffJets->Fill(nRecEffJets);
2571
2572
2573 Int_t nEmbeddedJets = 0;
2574 TArrayI iEmbeddedMatchIndex;
2575 TArrayF fEmbeddedPtFraction;
2576
2577
2578 if(fBranchEmbeddedJets.Length()){
2579 Int_t nJEmbedded = GetListOfJets(fJetsEmbedded, kJetsEmbedded);
2580 if(nJEmbedded>=0) nEmbeddedJets = fJetsEmbedded->GetEntries();
2581 if(fDebug>2)Printf("%s:%d Selected Embedded jets: %d %d",(char*)__FILE__,__LINE__,nJEmbedded,nEmbeddedJets);
2582 if(nJEmbedded != nEmbeddedJets) Printf("%s:%d Mismatch Selected Embedded Jets: %d %d",(char*)__FILE__,__LINE__,nJEmbedded,nEmbeddedJets);
2583 fh1nEmbeddedJets->Fill(nEmbeddedJets);
2584
2585 Float_t maxDist = 0.3;
2586
2587 iEmbeddedMatchIndex.Set(nEmbeddedJets);
2588 fEmbeddedPtFraction.Set(nEmbeddedJets);
2589
2590 iEmbeddedMatchIndex.Reset(-1);
2591 fEmbeddedPtFraction.Reset(0);
2592
2593 AliAnalysisHelperJetTasks::GetJetMatching(fJetsEmbedded, nEmbeddedJets,
2594 fJetsRecCuts, nRecJetsCuts,
2595 iEmbeddedMatchIndex, fEmbeddedPtFraction,
2596 fDebug, maxDist);
2597
2598 }
2599
2600 //____ fetch background clusters ___________________________________________________
2601 if(fBckgMode &&
2602 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
2603 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
2604 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)){
2605
2606 Int_t nBJ = GetListOfBckgJets(fBckgJetsRec, kJetsRec);
2607 Int_t nRecBckgJets = 0;
2608 if(nBJ>=0) nRecBckgJets = fBckgJetsRec->GetEntries();
2609 if(fDebug>2)Printf("%s:%d Selected Rec background jets: %d %d",(char*)__FILE__,__LINE__,nBJ,nRecBckgJets);
2610 if(nBJ != nRecBckgJets) Printf("%s:%d Mismatch Selected Rec background jets: %d %d",(char*)__FILE__,__LINE__,nBJ,nRecBckgJets);
2611
2612 Int_t nBJCuts = GetListOfBckgJets(fBckgJetsRecCuts, kJetsRecAcceptance);
2613 Int_t nRecBckgJetsCuts = 0;
2614 if(nBJCuts>=0) nRecBckgJetsCuts = fBckgJetsRecCuts->GetEntries();
2615 if(fDebug>2)Printf("%s:%d Selected Rec background jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2616 if(nRecBckgJetsCuts != nBJCuts) Printf("%s:%d Mismatch selected Rec background jets after cuts: %d %d",(char*)__FILE__,__LINE__,nBJCuts,nRecBckgJetsCuts);
2617 fh1nRecBckgJetsCuts->Fill(nRecBckgJetsCuts);
2618
2619 if(0){ // protection OB - not yet implemented
2620 if(fJetTypeGen==kJetsKine || fJetTypeGen == kJetsKineAcceptance) fBckgJetsGen->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2621 Int_t nBJGen = GetListOfBckgJets(fBckgJetsGen, fJetTypeGen);
2622 Int_t nGenBckgJets = 0;
2623 if(nBJGen>=0) nGenBckgJets = fBckgJetsGen->GetEntries();
2624 if(fDebug>2)Printf("%s:%d Selected Gen background jets: %d %d",(char*)__FILE__,__LINE__,nBJGen,nGenBckgJets);
2625 if(nBJGen != nGenBckgJets) Printf("%s:%d Mismatch selected Gen background jets: %d %d",(char*)__FILE__,__LINE__,nBJGen,nGenBckgJets);
2626 fh1nGenBckgJets->Fill(nGenBckgJets);
2627 }
2628 }
2629
2630
2631 //____ fetch particles __________________________________________________________
2632
2633 Int_t nTCuts;
2634 if(fUseExtraTracks == 1) nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODExtraCuts);
2635 else if(fUseExtraTracks == -1) nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODExtraonlyCuts);
2636 else nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODCuts);
2637
2638 Int_t nRecPartCuts = 0;
2639 if(nTCuts>=0) nRecPartCuts = fTracksRecCuts->GetEntries();
2640 if(fDebug>2)Printf("%s:%d Selected Rec tracks after cuts: %d %d",(char*)__FILE__,__LINE__,nTCuts,nRecPartCuts);
2641 if(nRecPartCuts != nTCuts) Printf("%s:%d Mismatch selected Rec tracks after cuts: %d %d",
2642 (char*)__FILE__,__LINE__,nTCuts,nRecPartCuts);
2643 fh1EvtMult->Fill(nRecPartCuts);
2644
2645
2646 Int_t nTGen = GetListOfTracks(fTracksGen,fTrackTypeGen);
2647 Int_t nGenPart = 0;
2648 if(nTGen>=0) nGenPart = fTracksGen->GetEntries();
2649 if(fDebug>2)Printf("%s:%d Selected Gen tracks: %d %d",(char*)__FILE__,__LINE__,nTGen,nGenPart);
2650 if(nGenPart != nTGen) Printf("%s:%d Mismatch selected Gen tracks: %d %d",(char*)__FILE__,__LINE__,nTGen,nGenPart);
2651
2652 // Just cut on filterBit, but take the full acceptance
2653 Int_t nTCutsEfficiency = GetListOfTracks(fTracksRecCutsEfficiency, kTrackAODQualityCuts);
2654 Int_t nRecPartCutsEfficiency = 0;
2655 if(nTCutsEfficiency>=0) nRecPartCutsEfficiency = fTracksRecCutsEfficiency->GetEntries();
2656 if(fDebug>2)Printf("%s:%d Selected Rec tracks efficiency after cuts: %d %d",(char*)__FILE__,__LINE__,
2657 nTCutsEfficiency,nRecPartCutsEfficiency);
2658 if(nRecPartCutsEfficiency != nTCutsEfficiency) Printf("%s:%d Mismatch selected Rec tracks after cuts: %d %d",
2659 (char*)__FILE__,__LINE__,nTCutsEfficiency,nRecPartCutsEfficiency);
2660
2661 AliPIDResponse* pidResponse = 0x0;
2662 if (fUseJetPIDtask || fUseInclusivePIDtask) {
c4856fb1 2663 if (!inputHandler) {
e131b05f 2664 AliFatal("Input handler needed");
c4856fb1 2665 return;
2666 }
e131b05f 2667 else {
2668 // PID response object
2669 pidResponse = inputHandler->GetPIDResponse();
c4856fb1 2670 if (!pidResponse) {
e131b05f 2671 AliFatal("PIDResponse object was not created");
c4856fb1 2672 return;
2673 }
e131b05f 2674 }
2675 }
2676
9e95a906 2677 if(fDebug>2)Printf("%s:%d Starting processing...",(char*)__FILE__,__LINE__);
2678
e131b05f 2679 //____ analysis, fill histos ___________________________________________________
2680
2681 if(fQAMode){
2682 // loop over tracks
2683 if(fQAMode&1){
2684 TClonesArray *tca = fUseInclusivePIDtask ? dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName())) : 0x0;
2685
2686 // Fill efficiency for generated primaries and also fill histos for generated yields (primaries + all)
2687 // Efficiency, inclusive - particle level
2688 if (fUseInclusivePIDtask && tca) {
2689 for (Int_t it = 0; it < tca->GetEntriesFast(); it++) {
2690 AliAODMCParticle* part = dynamic_cast<AliAODMCParticle*>(tca->At(it));
2691 if (!part)
2692 continue;
2693
2694 // Define clean MC sample with corresponding particle level track cuts:
2695 // - MC-track must be in desired eta range
2696 // - MC-track must be physical primary
2697 // - Species must be one of those in question
2698
2699 if (part->Eta() > fTrackEtaMax || part->Eta() < fTrackEtaMin)
2700 continue;
2701
2702 Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(part->GetPdgCode());
2703
2704 // Following lines are not needed - just keep other species (like casecades) - will end up in overflow bin
2705 // and only affect the efficiencies for all (i.e. not identified) what is desired!
2706 //if (mcID == AliPID::kUnknown)
2707 // continue;
2708
2709 if (!part->IsPhysicalPrimary())
2710 continue;
2711 /*
2712 Int_t iMother = part->GetMother();
2713 if (iMother >= 0)
2714 continue; // Not a physical primary
2715 */
2716
2717 Double_t pT = part->Pt();
2718
2719 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
2720 Double_t chargeMC = part->Charge() / 3.;
2721
2722 if (TMath::Abs(chargeMC) < 0.01)
2723 continue; // Reject neutral particles (only relevant, if mcID is not used)
2724
2725 Double_t valuesGenYield[AliAnalysisTaskPID::kGenYieldNumAxes] = { mcID, pT, centPercent, -1, -1, -1, -1 };
2726
2727 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
2728 valuesGenYield[fInclusivePIDtask[i]->GetIndexOfChargeAxisGenYield()] = chargeMC;
2729 fInclusivePIDtask[i]->FillGeneratedYield(valuesGenYield);
2730 }
2731
2732 Double_t valuesEff[AliAnalysisTaskPID::kEffNumAxes] = { mcID, pT, part->Eta(), chargeMC,
2733 centPercent, -1, -1, -1 };// no jet pT etc since inclusive spectrum
2734 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
2735 fInclusivePIDtask[i]->FillEfficiencyContainer(valuesEff, AliAnalysisTaskPID::kStepGenWithGenCuts);
2736 }
2737 }
2738
2739 if(fUseInclusivePIDtask){
2740 //Efficiency, inclusive - detector level
2741 for(Int_t it=0; it<nRecPartCutsEfficiency; ++it){
2742 // fill inclusive tracks XXX, they have the same track cuts!
2743 AliAODTrack * inclusiveaod = dynamic_cast<AliAODTrack*>(fTracksRecCutsEfficiency->At(it));
2744 if(inclusiveaod){
a6852ea8 2745 Double_t dEdxTPC = pidResponse->IsTunedOnData() ? pidResponse->GetTPCsignalTunedOnData(inclusiveaod)
2746 : inclusiveaod->GetTPCsignal();
e131b05f 2747
2748 if (dEdxTPC <= 0)
2749 continue;
2750
a6852ea8 2751 Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(inclusiveaod, InputEvent());
2752
e131b05f 2753 Int_t label = TMath::Abs(inclusiveaod->GetLabel());
2754
2755 // find MC track in our list, if available
2756 AliAODMCParticle* gentrack = tca ? dynamic_cast<AliAODMCParticle*>(tca->At(label)) : 0x0;
2757 Int_t pdg = 0;
2758
2759 if (gentrack)
2760 pdg = gentrack->GetPdgCode();
2761
2762 // For efficiency: Reconstructed track has survived all cuts on the detector level (no cut on eta acceptance)
2763 // and has an associated MC track
2764 // -> Check whether associated MC track belongs to the clean MC sample defined above,
2765 // i.e. survives the particle level track cuts
2766 if (gentrack) {
2767 Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(pdg);
2768
2769 // Following lines are not needed - just keep other species (like casecades) - will end up in overflow bin
2770 // and only affect the efficiencies for all (i.e. not identified) what is desired!
2771 //if (mcID == AliPID::kUnknown)
2772 // continue;
2773
2774 // Fill efficiency for reconstructed primaries
2775 if (!gentrack->IsPhysicalPrimary())
2776 continue;
2777 /*
2778 * Int_t iMother = gentrack->GetMother();
2779 * if (iMother >= 0)
2780 * continue; // Not a physical primary
2781 */
2782
2783 if (gentrack->Eta() > fTrackEtaMax || gentrack->Eta() < fTrackEtaMin)
2784 continue;
2785
2786 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
2787 Double_t value[AliAnalysisTaskPID::kEffNumAxes] = { mcID, gentrack->Pt(), gentrack->Eta(), gentrack->Charge() / 3.,
2788 centPercent,
2789 -1, -1, -1 };// no jet pT etc since inclusive spectrum
a6852ea8 2790 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
2791 if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo())
2792 fInclusivePIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
2793 }
e131b05f 2794
2795 Double_t valueMeas[AliAnalysisTaskPID::kEffNumAxes] = { mcID, inclusiveaod->Pt(), inclusiveaod->Eta(),
2796 inclusiveaod->Charge(), centPercent,
2797 -1, -1, -1 };// no jet pT etc since inclusive spectrum
a6852ea8 2798 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
2799 if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo())
2800 fInclusivePIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
2801 }
e131b05f 2802 }
2803 }
2804 }
2805 }
2806
2807
2808 for(Int_t it=0; it<nRecPartCuts; ++it){
2809 AliVParticle *part = dynamic_cast<AliVParticle*>(fTracksRecCuts->At(it));
2810 if(part)fQATrackHistosRecCuts->FillTrackQA( part->Eta(), TVector2::Phi_0_2pi(part->Phi()), part->Pt() );
2811
2812 // fill inclusive tracks XXX, they have the same track cuts!
2813 AliAODTrack * inclusiveaod = dynamic_cast<AliAODTrack*>(fTracksRecCuts->At(it));
2814 if(inclusiveaod){
2815 if(fUseInclusivePIDtask){
2816 Double_t dEdxTPC = pidResponse->IsTunedOnData() ? pidResponse->GetTPCsignalTunedOnData(inclusiveaod)
2817 : inclusiveaod->GetTPCsignal();
2818
2819 if (dEdxTPC <= 0)
2820 continue;
2821
a6852ea8 2822 Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(inclusiveaod, InputEvent());
2823
e131b05f 2824 Int_t label = TMath::Abs(inclusiveaod->GetLabel());
2825
2826 // find MC track in our list, if available
2827 AliAODMCParticle* gentrack = tca ? dynamic_cast<AliAODMCParticle*>(tca->At(label)) : 0x0;
2828 Int_t pdg = 0;
2829
2830 if (gentrack)
2831 pdg = gentrack->GetPdgCode();
2832
a6852ea8 2833 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
2834 if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo())
2835 fInclusivePIDtask[i]->ProcessTrack(inclusiveaod, pdg, centPercent, -1); // no jet pT since inclusive spectrum
2836 }
e131b05f 2837
2838 if (gentrack) {
2839 Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(pdg);
2840 Double_t valueRecAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { mcID, inclusiveaod->Pt(), inclusiveaod->Eta(),
2841 inclusiveaod->Charge(), centPercent,
2842 -1, -1, -1 };
a6852ea8 2843 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
2844 if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo())
2845 fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
2846 }
e131b05f 2847
2848 Double_t weight = IsSecondaryWithStrangeMotherMC(gentrack) ? GetMCStrangenessFactorCMS(gentrack) : 1.0;
a6852ea8 2849 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
2850 if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo())
2851 fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
2852 AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
2853 weight);
2854 }
9e95a906 2855
e131b05f 2856 if (gentrack->IsPhysicalPrimary()) {
9e95a906 2857 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
2858 Double_t valueGenAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { mcID, gentrack->Pt(), gentrack->Eta(),
2859 gentrack->Charge() / 3., centPercent, -1, -1,
2860 -1 };
2861
e4351829 2862 Double_t valuePtResolution[AliAnalysisTaskPID::kPtResNumAxes] = { -1, gentrack->Pt(), inclusiveaod->Pt(),
2863 gentrack->Charge() / 3., centPercent };
9e95a906 2864
2865 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
a6852ea8 2866 if (survivedTPCCutMIGeo || !fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) {
2867 fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
2868 AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
2869 fInclusivePIDtask[i]->FillEfficiencyContainer(valueGenAllCuts,
2870 AliAnalysisTaskPID::kStepRecWithRecCutsPrimaries);
2871
2872 fInclusivePIDtask[i]->FillPtResolution(mcID, valuePtResolution);
2873 }
9e95a906 2874 }
e131b05f 2875 }
2876 }
2877 }
2878 }
2879 }
2880 for(Int_t it=0; it<nGenPart; ++it){
2881 AliVParticle *part = dynamic_cast<AliVParticle*>(fTracksGen->At(it));
2882 if(part)fQATrackHistosGen->FillTrackQA( part->Eta(), TVector2::Phi_0_2pi(part->Phi()), part->Pt());
2883 }
2884 }
2885
2886 // loop over jets
2887 if(fQAMode&2){
2888 for(Int_t ij=0; ij<nRecJets; ++ij){
2889 AliAODJet* jet = dynamic_cast<AliAODJet*>(fJetsRec->At(ij));
2890 if(jet)fQAJetHistosRec->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2891 }
2892 }
2893 }
2894
2895 if(fQAMode || fFFMode){
2896 // generated jets
2897 for(Int_t ij=0; ij<nGenJets; ++ij){
2898 AliAODJet* jet = dynamic_cast<AliAODJet*>(fJetsGen->At(ij));
2899
2900 if(!jet)continue;
2901
2902 if(fQAMode&2) fQAJetHistosGen->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2903
2904 if(fQAMode&2 && (ij==0)) fQAJetHistosGenLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
2905
c4856fb1 2906 if((ij==0) || !fOnlyLeadingJets){ // leading jets or all jets
e131b05f 2907 TList* jettracklist = new TList();
2908 Double_t sumPt = 0.;
2909 Bool_t isBadJet = kFALSE;
2910
2911 if(GetFFRadius()<=0){
2912 GetJetTracksTrackrefs(jettracklist, jet, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
2913 } else {
2914 GetJetTracksPointing(fTracksGen, jettracklist, jet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
2915 }
2916
2917 if(GetFFMinNTracks()>0 && jettracklist->GetSize()<=GetFFMinNTracks()) isBadJet = kTRUE;
2918 if(isBadJet) continue;
2919
2920 for(Int_t it=0; it<jettracklist->GetSize(); ++it){
2921
2922 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(jettracklist->At(it));
2923 if(!trackVP)continue;
2924 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
2925
2926 Float_t jetPt = jet->Pt();
2927 Float_t trackPt = trackV->Pt();
2928
2929 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2930
2931 if(fFFMode && (ij==0)) fFFHistosGen->FillFF( trackPt, jetPt, incrementJetPt );
2932 if(fFFMode) fFFHistosGenInc->FillFF( trackPt, jetPt, incrementJetPt );
2933 if(it==0){ // leading track
2934 if(fFFMode) fFFHistosGenLeadingTrack->FillFF( trackPt, jetPt, kTRUE );
2935 }
2936
2937 if (fUseJetPIDtask && incrementJetPt) {
2938 for (Int_t i = 0; i < fNumJetPIDtasks; i++)
2939 fJetPIDtask[i]->FillGenJets(fJetPIDtask[i]->GetCentralityPercentile(evtForCentDetermination), jetPt);
2940 }
2941
2942 if (fIDFFMode) {
2943 Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(trackVP->PdgCode());
2944 if (mcID != AliPID::kUnknown) {
2945 // WARNING: The number of jets for the different species does not make sense -> One has to take
2946 // the number of jets for ALL particles. Thus, just do not fill the num of jet histos in order
2947 // not to get confused
2948 fIDFFHistosGen[mcID]->FillFF(trackPt, jetPt, kFALSE);
2949 }
2950 /*
2951 Int_t pidWeightedSpecies = fJetPIDtask->GetRandomParticleTypeAccordingToParticleFractions(trackPt, jetPt, centPercent, kTRUE);
2952 if (pidWeightedSpecies < 0 || pidWeightedSpecies >= AliPID::kSPECIES) {
2953 Printf("Failed to determine particle ID for track in jet (gen) -> ID FF histos not filled with this track!");
2954 Printf("Track details: trackPt %f, jetPt %f, centrality %f!", trackPt, jetPt, centPercent);
2955 }
2956 else {
2957 // WARNING: The number of jets for the different species does not make sense -> One has to take
2958 // the number of jets for ALL particles. Thus, just do not fill the num of jet histos in order
2959 // not to get confused
2960 fIDFFHistosGen[pidWeightedSpecies]->FillFF(trackPt, jetPt, kFALSE);
2961 }
2962 */
2963 }
2964
2965 delete trackV;
2966
2967 // Efficiency, jets - particle level
2968 if (fUseJetPIDtask) {
2969 AliAODMCParticle* part = dynamic_cast<AliAODMCParticle*>(jettracklist->At(it));
2970 if (!part) {
2971 AliError("expected ref track not found ");
2972 continue;
2973 }
2974 // Fill efficiency for generated primaries and also fill histos for generated yields (primaries + all)
2975 if (part->Eta() > fTrackEtaMax || part->Eta() < fTrackEtaMin)
2976 continue;
2977
2978 Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(part->GetPdgCode());
2979
2980 // Following lines are not needed - just keep other species (like casecades) - will end up in overflow bin
2981 // and only affect the efficiencies for all (i.e. not identified) what is desired!
2982 //if (mcID == AliPID::kUnknown)
2983 // continue;
2984
2985 if (!part->IsPhysicalPrimary())
2986 continue;
2987 //
2988 // Int_t iMother = part->GetMother();
2989 // if (iMother >= 0)
2990 // continue; // Not a physical primary
2991 //
2992
2993 Double_t z = -1., xi = -1.;
2994 AliAnalysisTaskPID::GetJetTrackObservables(trackPt, jetPt, z, xi);
2995
2996 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
2997 Double_t chargeMC = part->Charge() / 3.;
2998
2999 if (TMath::Abs(chargeMC) < 0.01)
3000 continue; // Reject neutral particles (only relevant, if mcID is not used)
3001
3002 Double_t valuesGenYield[AliAnalysisTaskPID::kGenYieldNumAxes] = { mcID, trackPt, centPercent, jetPt, z, xi, chargeMC };
3003
3004 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
3005 valuesGenYield[fJetPIDtask[i]->GetIndexOfChargeAxisGenYield()] = chargeMC;
3006 fJetPIDtask[i]->FillGeneratedYield(valuesGenYield);
3007 }
3008
3009
3010 Double_t valuesEff[AliAnalysisTaskPID::kEffNumAxes] = { mcID, trackPt, part->Eta(), chargeMC,
3011 centPercent, jetPt, z, xi };
3012 for (Int_t i = 0; i < fNumJetPIDtasks; i++)
3013 fJetPIDtask[i]->FillEfficiencyContainer(valuesEff, AliAnalysisTaskPID::kStepGenWithGenCuts);
3014 }
3015 }
3016
3017 if(fBckgMode){
3018 if(fBckgType[0]!=kBckgNone)
3019 FillBckgHistos(fBckgType[0], fTracksGen, fJetsGen, jet,
3020 fFFBckgHisto0Gen, fQABckgHisto0Gen);
3021 if(fBckgType[1]!=kBckgNone)
3022 FillBckgHistos(fBckgType[1], fTracksGen, fJetsGen, jet,
3023 fFFBckgHisto1Gen, fQABckgHisto1Gen);
3024 if(fBckgType[2]!=kBckgNone)
3025 FillBckgHistos(fBckgType[2], fTracksGen, fJetsGen, jet,
3026 fFFBckgHisto2Gen, fQABckgHisto2Gen);
3027 if(fBckgType[3]!=kBckgNone)
3028 FillBckgHistos(fBckgType[3], fTracksGen, fJetsGen, jet,
3029 fFFBckgHisto3Gen, fQABckgHisto3Gen);
3030 if(fBckgType[4]!=kBckgNone)
3031 FillBckgHistos(fBckgType[4], fTracksGen, fJetsGen, jet,
3032 fFFBckgHisto4Gen, fQABckgHisto4Gen);
3033 } // end if(fBckgMode)
3034
3035
3036 if(fJSMode) FillJetShape(jet, jettracklist, fProNtracksLeadingJetGen, fProDelRPtSumGen, fProDelR80pcPtGen);
3037
3038 delete jettracklist;
3039 }
3040 }
3041
3042
3043 for(Int_t ij=0; ij<nRecJetsCuts; ++ij){
3044
3045 AliAODJet* jet = (AliAODJet*)(fJetsRecCuts->At(ij));
3046 if(fQAMode&2) fQAJetHistosRecCuts->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
3047 if(fQAMode&2 && (ij==0)) fQAJetHistosRecCutsLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
3048
c4856fb1 3049 if((ij==0) || !fOnlyLeadingJets){ // leading jets or all jets
e131b05f 3050
3051 Double_t ptFractionEmbedded = 0;
3052 AliAODJet* embeddedJet = 0;
3053
3054 if(fBranchEmbeddedJets.Length()){ // find embedded jet
3055
3056 Int_t indexEmbedded = -1;
3057 for(Int_t i=0; i<nEmbeddedJets; i++){
3058 if(iEmbeddedMatchIndex[i] == ij){
3059 indexEmbedded = i;
3060 ptFractionEmbedded = fEmbeddedPtFraction[i];
3061 }
3062 }
3063
3064 fh1IndexEmbedded->Fill(indexEmbedded);
3065 fh1FractionPtEmbedded->Fill(ptFractionEmbedded);
3066
3067 if(indexEmbedded>-1){
3068
3069 embeddedJet = dynamic_cast<AliAODJet*>(fJetsEmbedded->At(indexEmbedded));
3070 if(!embeddedJet) continue;
3071
3072 Double_t deltaPt = jet->Pt() - embeddedJet->Pt();
3073 Double_t deltaR = jet->DeltaR((AliVParticle*) (embeddedJet));
3074
3075 fh2DeltaPtVsJetPtEmbedded->Fill(embeddedJet->Pt(),deltaPt);
3076 fh2DeltaPtVsRecJetPtEmbedded->Fill(jet->Pt(),deltaPt);
3077 fh1DeltaREmbedded->Fill(deltaR);
3078 }
3079 }
3080
3081 // get tracks in jet
3082 TList* jettracklist = new TList();
3083 Double_t sumPt = 0.;
3084 Bool_t isBadJet = kFALSE;
3085
3086 if(GetFFRadius()<=0){
3087 GetJetTracksTrackrefs(jettracklist, jet, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
3088 } else {
3089 if(fUseEmbeddedJetAxis){
3090 if(embeddedJet) GetJetTracksPointing(fTracksRecCuts, jettracklist, embeddedJet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
3091 }
3092 else GetJetTracksPointing(fTracksRecCuts, jettracklist, jet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
3093 }
3094
3095 if(GetFFMinNTracks()>0 && jettracklist->GetSize()<=GetFFMinNTracks()) isBadJet = kTRUE;
3096
3097 if(isBadJet) continue;
3098
3099 if(ptFractionEmbedded>=fCutFractionPtEmbedded){ // if no embedding: ptFraction = cutFraction = 0
3100
3101 TClonesArray *tca = fUseJetPIDtask ? dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName())) : 0x0;
3102
3103 for(Int_t it=0; it<jettracklist->GetSize(); ++it){
3104 AliAODTrack * aodtrack = dynamic_cast<AliAODTrack*>(jettracklist->At(it));
3105 if(!aodtrack) continue;
3106
3107 Double_t pT = aodtrack->Pt();
3108 Float_t jetPt = jet->Pt();
3109 if(fUseEmbeddedJetPt){
3110 if(embeddedJet) jetPt = embeddedJet->Pt();
3111 else jetPt = 0;
3112 }
3113
3114 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
3115
3116 if(fFFMode && (ij==0)) fFFHistosRecCuts->FillFF(pT, jetPt, incrementJetPt);
3117 if(fFFMode) fFFHistosRecCutsInc->FillFF(pT, jetPt, incrementJetPt);
3118
3119 if(it==0){ // leading track
3120 if(fFFMode) fFFHistosRecLeadingTrack->FillFF(pT, jetPt, kTRUE);
3121 }
3122
3123 if (fUseJetPIDtask && incrementJetPt) {
3124 for (Int_t i = 0; i < fNumJetPIDtasks; i++)
3125 fJetPIDtask[i]->FillRecJets(fJetPIDtask[i]->GetCentralityPercentile(evtForCentDetermination), jetPt);
3126 }
3127
3128 if (fUseJetPIDtask) {
3129 Double_t dEdxTPC = pidResponse->IsTunedOnData() ? pidResponse->GetTPCsignalTunedOnData(aodtrack)
3130 : aodtrack->GetTPCsignal();
3131
3132 if (dEdxTPC <= 0)
3133 continue;
3134
a6852ea8 3135 Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(aodtrack, InputEvent());
3136
e131b05f 3137 Int_t label = TMath::Abs(aodtrack->GetLabel());
3138
3139 // Find MC track in our list, if available
3140 AliAODMCParticle* gentrack = tca ? dynamic_cast<AliAODMCParticle*>(tca->At(label)) : 0x0;
3141 Int_t pdg = 0;
3142 Int_t mcID = AliPID::kUnknown;
3143
3144 if (gentrack) {
3145 pdg = gentrack->GetPdgCode();
3146
3147 // Secondaries, jets
3148 mcID = AliAnalysisTaskPID::PDGtoMCID(pdg);
3149
3150 Double_t z = -1., xi = -1.;
3151 AliAnalysisTaskPID::GetJetTrackObservables(pT, jetPt, z, xi);
3152
3153 Double_t valueRecAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { mcID, pT, aodtrack->Eta(), aodtrack->Charge(),
3154 centPercent, jetPt, z, xi };
a6852ea8 3155 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
3156 if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo())
3157 fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
3158 }
e131b05f 3159
3160 Double_t weight = IsSecondaryWithStrangeMotherMC(gentrack) ? GetMCStrangenessFactorCMS(gentrack) : 1.0;
a6852ea8 3161 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
3162 if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo())
3163 fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
3164 AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
3165 weight);
3166 }
9e95a906 3167
e131b05f 3168 if (gentrack->IsPhysicalPrimary()) {
9e95a906 3169 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
3170 Double_t genPt = gentrack->Pt();
3171 Double_t genZ = -1., genXi = -1.;
3172 AliAnalysisTaskPID::GetJetTrackObservables(genPt, jetPt, genZ, genXi);
3173 Double_t valueGenAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { mcID, genPt, gentrack->Eta(),
3174 gentrack->Charge() / 3., centPercent, jetPt, genZ,
3175 genXi };
3176
e4351829 3177 Double_t valuePtResolution[AliAnalysisTaskPID::kPtResNumAxes] = { jetPt, genPt, pT, gentrack->Charge() / 3., centPercent };
9e95a906 3178
3179 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
a6852ea8 3180 if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo()) {
3181 fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
3182 AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
3183 fJetPIDtask[i]->FillEfficiencyContainer(valueGenAllCuts,
3184 AliAnalysisTaskPID::kStepRecWithRecCutsPrimaries);
3185
3186 fJetPIDtask[i]->FillPtResolution(mcID, valuePtResolution);
3187 }
9e95a906 3188 }
e131b05f 3189 }
3190 }
3191
a6852ea8 3192 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
3193 if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo())
3194 fJetPIDtask[i]->ProcessTrack(aodtrack, pdg, centPercent, jetPt);
3195 }
e131b05f 3196
a6852ea8 3197 if (fIDFFMode && (survivedTPCCutMIGeo || !fJetPIDtask[0]->GetUseTPCCutMIGeo())) {
e131b05f 3198 // NOTE: Just take particle fraction from first task (should anyway be the same for all tasks)
3199 Int_t pidWeightedSpecies = fJetPIDtask[0]->GetRandomParticleTypeAccordingToParticleFractions(pT, jetPt,
3200 centPercent, kTRUE);
3201 if (pidWeightedSpecies < 0 || pidWeightedSpecies >= AliPID::kSPECIES) {
3202 Printf("Failed to determine particle ID for track in jet (recCuts) -> ID FF histos not filled with this track!");
3203 Printf("Track details: trackPt %f, jetPt %f, centrality %f!", pT, jetPt, centPercent);
3204 }
3205 else {
3206 // WARNING: The number of jets for the different species does not make sense -> One has to take
3207 // the number of jets for ALL particles. Thus, just do not fill the num of jet histos in order
3208 // not to get confused
3209 fIDFFHistosRecCuts[pidWeightedSpecies]->FillFF(aodtrack->Pt(), jetPt, kFALSE);
3210 }
3211 }
3212
3213 // Efficiency, jets - detector level
3214 if (gentrack) {
3215 // Following lines are not needed - just keep other species (like casecades) - will end up in overflow bin
3216 // and only affect the efficiencies for all (i.e. not identified) what is desired!
3217 //if (mcID == AliPID::kUnknown)
3218 // continue;
3219
3220 // Fill efficiency for reconstructed primaries
3221 if (!gentrack->IsPhysicalPrimary())
3222 continue;
3223 /*
3224 Int_t iMother = gentrack->GetMother();
3225 if (iMother >= 0)
3226 continue; // Not a physical primary
3227 */
3228
3229 if (gentrack->Eta() > fTrackEtaMax || gentrack->Eta() < fTrackEtaMin)
3230 continue;
3231
3232 Double_t genZ = -1., genXi = -1.;
3233 Double_t genPt = gentrack->Pt();
3234 AliAnalysisTaskPID::GetJetTrackObservables(genPt, jetPt, genZ, genXi);
3235
3236 Double_t measZ = -1., measXi = -1.;
3237 Double_t measPt = aodtrack->Pt();
3238 AliAnalysisTaskPID::GetJetTrackObservables(measPt, jetPt, measZ, measXi);
3239
3240
3241 // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
3242 Double_t value[AliAnalysisTaskPID::kEffNumAxes] = { mcID, genPt, gentrack->Eta(), gentrack->Charge() / 3.,
3243 centPercent, jetPt, genZ, genXi };
a6852ea8 3244 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
3245 if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo())
3246 fJetPIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
3247 }
e131b05f 3248
3249 Double_t valueMeas[AliAnalysisTaskPID::kEffNumAxes] = { mcID, measPt, aodtrack->Eta(), aodtrack->Charge(),
3250 centPercent, jetPt, measZ, measXi };
a6852ea8 3251 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
3252 if (survivedTPCCutMIGeo || !fJetPIDtask[i]->GetUseTPCCutMIGeo())
3253 fJetPIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
3254 }
e131b05f 3255 }
3256 }
3257 }
3258
3259 // background ff
3260 if(fBckgMode && (ij==0)){
3261 if(fBckgType[0]!=kBckgNone)
3262 FillBckgHistos(fBckgType[0], fTracksRecCuts, fJetsRecCuts, jet,
3263 fFFBckgHisto0RecCuts,fQABckgHisto0RecCuts, fh1BckgMult0);
3264 if(fBckgType[1]!=kBckgNone)
3265 FillBckgHistos(fBckgType[1], fTracksRecCuts, fJetsRecCuts, jet,
3266 fFFBckgHisto1RecCuts,fQABckgHisto1RecCuts, fh1BckgMult1);
3267 if(fBckgType[2]!=kBckgNone)
3268 FillBckgHistos(fBckgType[2], fTracksRecCuts, fJetsRecCuts, jet,
3269 fFFBckgHisto2RecCuts,fQABckgHisto2RecCuts, fh1BckgMult1);
3270 if(fBckgType[3]!=kBckgNone)
3271 FillBckgHistos(fBckgType[3], fTracksRecCuts, fJetsRecCuts, jet,
3272 fFFBckgHisto3RecCuts,fQABckgHisto3RecCuts, fh1BckgMult2);
3273 if(fBckgType[4]!=kBckgNone)
3274 FillBckgHistos(fBckgType[4], fTracksRecCuts, fJetsRecCuts, jet,
3275 fFFBckgHisto4RecCuts,fQABckgHisto4RecCuts, fh1BckgMult3);
3276 } // end if(fBckgMode)
3277
3278
3279 if(fJSMode && (ij==0)) FillJetShape(jet, jettracklist, fProNtracksLeadingJet, fProDelRPtSum, fProDelR80pcPt);
3280
3281 delete jettracklist;
3282
3283 } // end: cut embedded ratio
c4856fb1 3284 } // end: leading jet or all jets
e131b05f 3285 } // end: rec. jets after cuts
3286 } // end: QA, FF and intra-jet
3287
3288
3289 // ____ efficiency _______________________________
3290
3291 if(fEffMode && (fJetTypeRecEff != kJetsUndef)){
3292
3293 // arrays holding for each generated particle the reconstructed AOD track index & isPrimary flag, are initialized in AssociateGenRec(...) function
3294 TArrayI indexAODTr;
3295 TArrayS isGenPrim;
3296
3297 // array holding for each reconstructed AOD track generated particle index, initialized in AssociateGenRec(...) function
3298 TArrayI indexMCTr;
3299
3300 // ... and another set for secondaries from strange/non strange mothers (secondary MC tracks are stored in different lists)
3301 TArrayI indexAODTrSecNS;
3302 TArrayS isGenSecNS;
3303 TArrayI indexMCTrSecNS;
3304
3305 TArrayI indexAODTrSecS;
3306 TArrayS isGenSecS;
3307 TArrayI indexMCTrSecS;
3308
3309 Int_t nTracksAODMCCharged = GetListOfTracks(fTracksAODMCCharged, kTrackAODMCCharged);
3310 if(fDebug>2)Printf("%s:%d selected AODMC tracks: %d ",(char*)__FILE__,__LINE__,nTracksAODMCCharged);
3311
3312 Int_t nTracksAODMCChargedSecNS = GetListOfTracks(fTracksAODMCChargedSecNS, kTrackAODMCChargedSecNS);
3313 if(fDebug>2)Printf("%s:%d selected AODMC secondary tracks NS: %d ",(char*)__FILE__,__LINE__,nTracksAODMCChargedSecNS);
3314
3315 Int_t nTracksAODMCChargedSecS = GetListOfTracks(fTracksAODMCChargedSecS, kTrackAODMCChargedSecS);
3316 if(fDebug>2)Printf("%s:%d selected AODMC secondary tracks S: %d ",(char*)__FILE__,__LINE__,nTracksAODMCChargedSecS);
3317
3318 Int_t nTracksRecQualityCuts = GetListOfTracks(fTracksRecQualityCuts, kTrackAODQualityCuts);
3319 if(fDebug>2)Printf("%s:%d selected rec tracks quality after cuts, full acceptance/pt : %d ",(char*)__FILE__,__LINE__,nTracksRecQualityCuts);
3320
3321 // associate gen and rec tracks, store indices in TArrays
3322 AssociateGenRec(fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,indexMCTr,isGenPrim,fh2PtRecVsGenPrim);
3323 AssociateGenRec(fTracksAODMCChargedSecNS,fTracksRecQualityCuts,indexAODTrSecNS,indexMCTrSecNS,isGenSecNS,fh2PtRecVsGenSec);
3324 AssociateGenRec(fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,indexMCTrSecS,isGenSecS,fh2PtRecVsGenSec);
3325
3326 // single track eff
3327 if(fQAMode&1) FillSingleTrackHistosRecGen(fQATrackHistosRecEffGen,fQATrackHistosRecEffRec,fTracksAODMCCharged,indexAODTr,isGenPrim);
3328
3329 // secondaries
3330 if(fQAMode&1) FillSingleTrackHistosRecGen(0x0,fQATrackHistosSecRecNS,fTracksAODMCChargedSecNS,indexAODTrSecNS,isGenSecNS);
3331 if(fQAMode&1) FillSingleTrackHistosRecGen(0x0,fQATrackHistosSecRecS,fTracksAODMCChargedSecS,indexAODTrSecS,isGenSecS);
3332 if(fQAMode&1) FillSingleTrackHistosRecGen(0x0,fQATrackHistosSecRecSsc,fTracksAODMCChargedSecS,indexAODTrSecS,isGenSecS,kTRUE);
3333
3334
3335 // jet track eff
3336 Double_t sumPtGenLeadingJetRecEff = 0;
3337 Double_t sumPtGenLeadingJetSec = 0;
3338 Double_t sumPtRecLeadingJetRecEff = 0;
3339
3340 for(Int_t ij=0; ij<nRecEffJets; ++ij){ // jet loop
3341
3342 AliAODJet* jet = (AliAODJet*)(fJetsRecEff->At(ij));
3343
3344 Bool_t isBadJetGenPrim = kFALSE;
3345 Bool_t isBadJetGenSec = kFALSE;
3346 Bool_t isBadJetRec = kFALSE;
3347
3348
c4856fb1 3349 if((ij==0) || !fOnlyLeadingJets){ // leading jets or all jets
e131b05f 3350
3351 // for efficiency: gen tracks from pointing with gen/rec jet
3352 TList* jettracklistGenPrim = new TList();
3353
3354 // if radius<0 -> trackRefs: collect gen tracks in wide radius + fill FF recEff rec histos with tracks contained in track refs
3355 // note : FF recEff gen histos will be somewhat useless in this approach
3356
3357 if(GetFFRadius() >0)
3358 GetJetTracksPointing(fTracksAODMCCharged, jettracklistGenPrim, jet, GetFFRadius(), sumPtGenLeadingJetRecEff, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetGenPrim);
3359 else
3360 GetJetTracksPointing(fTracksAODMCCharged, jettracklistGenPrim, jet, TMath::Abs(GetFFRadius())+0.2, sumPtGenLeadingJetRecEff, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetGenPrim);
3361
3362 TList* jettracklistGenSecNS = new TList();
3363 if(GetFFRadius() >0)
3364 GetJetTracksPointing(fTracksAODMCChargedSecNS, jettracklistGenSecNS, jet, GetFFRadius(), sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
3365 else
3366 GetJetTracksPointing(fTracksAODMCChargedSecNS, jettracklistGenSecNS, jet, TMath::Abs(GetFFRadius())+0.2, sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
3367
3368 TList* jettracklistGenSecS = new TList();
3369 if(GetFFRadius() >0)
3370 GetJetTracksPointing(fTracksAODMCChargedSecS, jettracklistGenSecS, jet, GetFFRadius(), sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
3371 else
3372 GetJetTracksPointing(fTracksAODMCChargedSecS, jettracklistGenSecS, jet, TMath::Abs(GetFFRadius())+0.2, sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
3373
3374
3375 // bin efficiency in jet pt bins using rec tracks
3376 TList* jettracklistRec = new TList();
3377 if(GetFFRadius() >0) GetJetTracksPointing(fTracksRecCuts,jettracklistRec, jet, GetFFRadius(), sumPtRecLeadingJetRecEff, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetRec);
3378 else GetJetTracksTrackrefs(jettracklistRec, jet, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetRec);
3379
3380
3381 Double_t jetEta = jet->Eta();
3382 Double_t jetPhi = TVector2::Phi_0_2pi(jet->Phi());
3383
3384 if(GetFFMinNTracks()>0 && jettracklistGenPrim->GetSize()<=GetFFMinNTracks()) isBadJetGenPrim = kTRUE;
3385 if(GetFFMinNTracks()>0 && jettracklistGenSecNS->GetSize()<=GetFFMinNTracks()) isBadJetGenSec = kTRUE;
3386 if(GetFFMinNTracks()>0 && jettracklistRec->GetSize()<=GetFFMinNTracks()) isBadJetRec = kTRUE;
3387
3388 if(isBadJetRec) continue;
3389
3390 if(fQAMode&2) fQAJetHistosRecEffLeading->FillJetQA( jetEta, jetPhi, sumPtGenLeadingJetRecEff );
3391
3392 if(fFFMode){
3393
3394 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosRecEffRec,jet,
3395 jettracklistGenPrim,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim,
3396 0,kFALSE,fJSMode,fProNtracksLeadingJetRecPrim,fProDelRPtSumRecPrim,fProDelR80pcPtRecPrim);
3397
3398 else FillJetTrackHistosRec(fFFHistosRecEffRec,jet,
3399 jettracklistGenPrim,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim,
3400 jettracklistRec,kFALSE,fJSMode,fProNtracksLeadingJetRecPrim,fProDelRPtSumRecPrim,fProDelR80pcPtRecPrim);
3401
3402
3403 // secondaries: use jet pt from primaries
3404 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosSecRecNS,jet,
3405 jettracklistGenSecNS,fTracksAODMCChargedSecNS,fTracksRecQualityCuts, indexAODTrSecNS,isGenSecNS,
3406 0,kFALSE,fJSMode,fProNtracksLeadingJetRecSecNS,fProDelRPtSumRecSecNS);
3407
3408 else FillJetTrackHistosRec(fFFHistosSecRecNS,jet,
3409 jettracklistGenSecNS,fTracksAODMCChargedSecNS,fTracksRecQualityCuts,indexAODTrSecNS,isGenSecNS,
3410 jettracklistRec,kFALSE,fJSMode,fProNtracksLeadingJetRecSecNS,fProDelRPtSumRecSecNS);
3411
3412 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosSecRecS,jet,
3413 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
3414 0,kFALSE,fJSMode,fProNtracksLeadingJetRecSecS,fProDelRPtSumRecSecS);
3415
3416 else FillJetTrackHistosRec(fFFHistosSecRecS,jet,
3417 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
3418 jettracklistRec,kFALSE,fJSMode,fProNtracksLeadingJetRecSecS,fProDelRPtSumRecSecS);
3419
3420 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosSecRecSsc,jet,
3421 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
3422 0,kTRUE,fJSMode,fProNtracksLeadingJetRecSecSsc,fProDelRPtSumRecSecSsc);
3423
3424 else FillJetTrackHistosRec(fFFHistosSecRecSsc,jet,
3425 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
3426 jettracklistRec,kTRUE,fJSMode,fProNtracksLeadingJetRecSecSsc,fProDelRPtSumRecSecSsc);
3427 }
3428
3429 delete jettracklistGenPrim;
3430 delete jettracklistGenSecNS;
3431 delete jettracklistGenSecS;
3432 delete jettracklistRec;
3433
3434
3435 if(fBckgMode && fFFMode){
3436
3437 TList* perpjettracklistGen = new TList();
3438 TList* perpjettracklistGen1 = new TList();
3439 TList* perpjettracklistGen2 = new TList();
3440
3441 //Double_t sumPtGenPerp = 0.;
3442 Double_t sumPtGenPerp1 = 0.;
3443 Double_t sumPtGenPerp2 = 0.;
3444 GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksAODMCCharged, perpjettracklistGen1, jet, TMath::Abs(GetFFRadius()) , sumPtGenPerp1);
3445 GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2.,fTracksAODMCCharged, perpjettracklistGen2, jet, TMath::Abs(GetFFRadius()) ,
3446 sumPtGenPerp2);
3447
3448 perpjettracklistGen->AddAll(perpjettracklistGen1);
3449 perpjettracklistGen->AddAll(perpjettracklistGen2);
3450 //sumPtGenPerp = 0.5*(sumPtGenPerp1+sumPtGenPerp2);
3451
3452 TList* perpjettracklistGenSecNS = new TList();
3453 TList* perpjettracklistGenSecNS1 = new TList();
3454 TList* perpjettracklistGenSecNS2 = new TList();
3455
3456 //Double_t sumPtGenPerpNS = 0.;
3457 Double_t sumPtGenPerpNS1 = 0.;
3458 Double_t sumPtGenPerpNS2 = 0.;
3459 GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksAODMCChargedSecNS, perpjettracklistGenSecNS1, jet, TMath::Abs(GetFFRadius()) ,
3460 sumPtGenPerpNS1);
3461 GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2.,fTracksAODMCChargedSecNS, perpjettracklistGenSecNS2, jet, TMath::Abs(GetFFRadius()) ,
3462 sumPtGenPerpNS2);
3463
3464 perpjettracklistGenSecNS->AddAll(perpjettracklistGenSecNS1);
3465 perpjettracklistGenSecNS->AddAll(perpjettracklistGenSecNS2);
3466 //sumPtGenPerpNS = 0.5*(sumPtGenPerpNS1+sumPtGenPerpNS2);
3467
3468
3469 TList* perpjettracklistGenSecS = new TList();
3470 TList* perpjettracklistGenSecS1 = new TList();
3471 TList* perpjettracklistGenSecS2 = new TList();
3472
3473 //Double_t sumPtGenPerpS = 0.;
3474 Double_t sumPtGenPerpS1 = 0.;
3475 Double_t sumPtGenPerpS2 = 0.;
3476 GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksAODMCChargedSecS, perpjettracklistGenSecS1, jet, TMath::Abs(GetFFRadius()) ,
3477 sumPtGenPerpS1);
3478 GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2.,fTracksAODMCChargedSecS, perpjettracklistGenSecS2, jet, TMath::Abs(GetFFRadius()) ,
3479 sumPtGenPerpS2);
3480
3481 perpjettracklistGenSecS->AddAll(perpjettracklistGenSecS1);
3482 perpjettracklistGenSecS->AddAll(perpjettracklistGenSecS2);
3483 //sumPtGenPerpS = 0.5*(sumPtGenPerpS1+sumPtGenPerpS2);
3484
3485
3486 if(perpjettracklistGen->GetSize() != perpjettracklistGen1->GetSize() + perpjettracklistGen2->GetSize()){
3487 cout<<" ERROR: perpjettracklistGen size "<<perpjettracklistGen->GetSize()<<" perp1 "<<perpjettracklistGen1->GetSize()
3488 <<" perp2 "<<perpjettracklistGen2->GetSize()<<endl;
3489 exit(0);
3490 }
3491
3492 if(perpjettracklistGenSecNS->GetSize() != perpjettracklistGenSecNS1->GetSize() + perpjettracklistGenSecNS2->GetSize()){
3493 cout<<" ERROR: perpjettracklistGenSecNS size "<<perpjettracklistGenSecNS->GetSize()<<" perp1 "<<perpjettracklistGenSecNS1->GetSize()
3494 <<" perp2 "<<perpjettracklistGenSecNS2->GetSize()<<endl;
3495 exit(0);
3496 }
3497
3498 if(perpjettracklistGenSecS->GetSize() != perpjettracklistGenSecS1->GetSize() + perpjettracklistGenSecS2->GetSize()){
3499 cout<<" ERROR: perpjettracklistGenSecS size "<<perpjettracklistGenSecS->GetSize()<<" perp1 "<<perpjettracklistGenSecS1->GetSize()
3500 <<" perp2 "<<perpjettracklistGenSecS2->GetSize()<<endl;
3501 exit(0);
3502 }
3503
3504
3505 FillJetTrackHistosRec(fFFBckgHisto0RecEffRec,jet,
3506 perpjettracklistGen,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim);
3507
3508 FillJetTrackHistosRec(fFFBckgHisto0SecRecNS,jet,
3509 perpjettracklistGenSecNS,fTracksAODMCChargedSecNS,fTracksRecQualityCuts,indexAODTrSecNS,isGenSecNS);
3510
3511 FillJetTrackHistosRec(fFFBckgHisto0SecRecS,jet,
3512 perpjettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS);
3513
3514 FillJetTrackHistosRec(fFFBckgHisto0SecRecSsc,jet,
3515 perpjettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,0,kTRUE);
3516
3517
3518 delete perpjettracklistGen;
3519 delete perpjettracklistGen1;
3520 delete perpjettracklistGen2;
3521
3522 delete perpjettracklistGenSecNS;
3523 delete perpjettracklistGenSecNS1;
3524 delete perpjettracklistGenSecNS2;
3525
3526 delete perpjettracklistGenSecS;
3527 delete perpjettracklistGenSecS1;
3528 delete perpjettracklistGenSecS2;
3529
3530 }
3531 }
3532 }
3533 }
3534
3535 //___________________
3536
3537 fTracksRecCuts->Clear();
3538 fTracksRecCutsEfficiency->Clear();
3539 fTracksGen->Clear();
3540 fTracksAODMCCharged->Clear();
3541 fTracksAODMCChargedSecNS->Clear();
3542 fTracksAODMCChargedSecS->Clear();
3543 fTracksRecQualityCuts->Clear();
3544
3545 fJetsRec->Clear();
3546 fJetsRecCuts->Clear();
3547 fJetsGen->Clear();
3548 fJetsRecEff->Clear();
3549 fJetsEmbedded->Clear();
3550
3551
3552 if(fBckgMode &&
3553 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
3554 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
3555 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)){
3556
3557 fBckgJetsRec->Clear();
3558 fBckgJetsRecCuts->Clear();
3559 fBckgJetsGen->Clear();
3560 }
3561
3562
3563 //Post output data.
3564 PostData(1, fCommonHistList);
3565
3566 if (fUseJetPIDtask) {
3567 for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
3568 fJetPIDtask[i]->PostOutputData();
3569 fJetPIDtask[i]->IncrementEventsProcessed(centPercent);
3570 }
3571 }
3572
3573 if (fUseInclusivePIDtask) {
3574 for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
3575 fInclusivePIDtask[i]->PostOutputData();
3576 fInclusivePIDtask[i]->IncrementEventsProcessed(centPercent);
3577 }
3578 }
3579}
3580
3581//______________________________________________________________
3582void AliAnalysisTaskIDFragmentationFunction::Terminate(Option_t *)
3583{
3584 // terminated
3585
3586 if(fDebug > 1) printf("AliAnalysisTaskIDFragmentationFunction::Terminate() \n");
3587}
3588
3589//_________________________________________________________________________________
3590Int_t AliAnalysisTaskIDFragmentationFunction::GetListOfTracks(TList *list, Int_t type)
3591{
3592 // fill list of tracks selected according to type
3593
3594 if(fDebug > 2) Printf("%s:%d Selecting tracks with %d", (char*)__FILE__,__LINE__,type);
3595
3596 if(!list){
3597 if(fDebug>1) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
3598 return -1;
3599 }
3600
3601 if(!fAOD) return -1;
3602
3603 if(!fAOD->GetTracks()) return 0;
3604
3605 if(type==kTrackUndef) return 0;
3606
3607 Int_t iCount = 0;
3608
3609 if(type==kTrackAODExtraCuts || type==kTrackAODExtraonlyCuts || type==kTrackAODExtra || type==kTrackAODExtraonly){
3610
3611 TClonesArray *aodExtraTracks = dynamic_cast<TClonesArray*>(fAOD->FindListObject("aodExtraTracks"));
3612 if(!aodExtraTracks)return iCount;
3613 for(int it =0; it<aodExtraTracks->GetEntries(); it++) {
3614 AliVParticle *track = dynamic_cast<AliVParticle*> ((*aodExtraTracks)[it]);
3615 if (!track) continue;
3616
3617 AliAODTrack *tr = dynamic_cast<AliAODTrack*> (track);
3618 if(!tr)continue;
3619
3620 if(type==kTrackAODExtraCuts || type==kTrackAODExtraonlyCuts){
3621
3622 if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask))) continue;
3623
3624 if(tr->Eta() < fTrackEtaMin || tr->Eta() > fTrackEtaMax) continue;
3625 if(tr->Phi() < fTrackPhiMin || tr->Phi() > fTrackPhiMax) continue;
3626 if(tr->Pt() < fTrackPtCut) continue;
3627 }
3628
3629 list->Add(tr);
3630 iCount++;
3631 }
3632 }
3633
3634 if(type==kTrackAODCuts || type==kTrackAODQualityCuts || type==kTrackAOD || type==kTrackAODExtraCuts || type==kTrackAODExtra){
3635
3636 // all rec. tracks, esd filter mask, eta range
3637
3638 for(Int_t it=0; it<fAOD->GetNumberOfTracks(); ++it){
3639 AliAODTrack *tr = fAOD->GetTrack(it);
3640
3641 if(type == kTrackAODCuts || type==kTrackAODQualityCuts || type==kTrackAODExtraCuts){
3642
3643 if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask))) continue;
3644 if(type == kTrackAODCuts){
3645 if(tr->Eta() < fTrackEtaMin || tr->Eta() > fTrackEtaMax) continue;
3646 if(tr->Phi() < fTrackPhiMin || tr->Phi() > fTrackPhiMax) continue;
3647 if(tr->Pt() < fTrackPtCut) continue;
3648 }
3649 }
3650 list->Add(tr);
3651 iCount++;
3652 }
3653 }
3654 else if (type==kTrackKineAll || type==kTrackKineCharged || type==kTrackKineChargedAcceptance){
3655 // kine particles, all or rather charged
3656 if(!fMCEvent) return iCount;
3657
3658 for(Int_t it=0; it<fMCEvent->GetNumberOfTracks(); ++it){
3659 AliMCParticle* part = (AliMCParticle*) fMCEvent->GetTrack(it);
3660
3661 if(type == kTrackKineCharged || type == kTrackKineChargedAcceptance){
3662 if(part->Charge()==0) continue;
3663
3664 if(type == kTrackKineChargedAcceptance &&
3665 ( part->Eta() < fTrackEtaMin
3666 || part->Eta() > fTrackEtaMax
3667 || part->Phi() < fTrackPhiMin
3668 || part->Phi() > fTrackPhiMax
3669 || part->Pt() < fTrackPtCut)) continue;
3670 }
3671
3672 list->Add(part);
3673 iCount++;
3674 }
3675 }
3676 else if (type==kTrackAODMCCharged || type==kTrackAODMCAll || type==kTrackAODMCChargedAcceptance || type==kTrackAODMCChargedSecNS || type==kTrackAODMCChargedSecS) {
3677 // MC particles (from AOD), physical primaries, all or rather charged or rather charged within acceptance
3678 if(!fAOD) return -1;
3679
3680 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
3681 if(!tca)return iCount;
3682
3683 for(int it=0; it<tca->GetEntriesFast(); ++it){
3684 AliAODMCParticle *part = dynamic_cast<AliAODMCParticle*>(tca->At(it));
3685 if(!part)continue;
3686 if(type != kTrackAODMCChargedSecNS && type != kTrackAODMCChargedSecS && !part->IsPhysicalPrimary())continue;
3687 if((type == kTrackAODMCChargedSecNS || type == kTrackAODMCChargedSecS) && part->IsPhysicalPrimary())continue;
3688
3689 if (type==kTrackAODMCCharged || type==kTrackAODMCChargedAcceptance || type==kTrackAODMCChargedSecNS || type==kTrackAODMCChargedSecS){
3690 if(part->Charge()==0) continue;
3691
3692 if(type==kTrackAODMCChargedSecNS || type==kTrackAODMCChargedSecS){
3693 Bool_t isFromStrange = kFALSE;
3694 Int_t iMother = part->GetMother();
3695 if(iMother >= 0){
3696 AliAODMCParticle *partM = dynamic_cast<AliAODMCParticle*>(tca->At(iMother));
3697 if(!partM) continue;
3698
3699 Int_t codeM = TMath::Abs(partM->GetPdgCode());
3700 Int_t mfl = Int_t (codeM/ TMath::Power(10, Int_t(TMath::Log10(codeM))));
3701
3702 if (mfl == 3 && codeM != 3) isFromStrange = kTRUE;
3703 if(codeM == 130) isFromStrange = kTRUE; // K0 long
3704 if(part->IsSecondaryFromMaterial()) isFromStrange = kFALSE; // strange resonances from hadronic showers ?
3705
3706 // if(mfl ==3){
3707 // cout<<" mfl "<<mfl<<" codeM "<<partM->GetPdgCode()<<" code this track "<<part->GetPdgCode()<<endl;
3708 // cout<<" index this track "<<it<<" index daughter 0 "<<partM->GetDaughter(0)<<" 1 "<<partM->GetDaughter(1)<<endl;
3709 // }
3710
3711 if(type==kTrackAODMCChargedSecNS && isFromStrange) continue;
3712 if(type==kTrackAODMCChargedSecS && !isFromStrange) continue;
3713 }
3714 }
3715
3716 if(type==kTrackAODMCChargedAcceptance &&
3717 ( part->Eta() > fTrackEtaMax
3718 || part->Eta() < fTrackEtaMin
3719 || part->Phi() > fTrackPhiMax
3720 || part->Phi() < fTrackPhiMin
3721 || part->Pt() < fTrackPtCut)) continue;
3722 }
3723
3724 list->Add(part);
3725 iCount++;
3726 }
3727 }
3728
3729 list->Sort();
3730 return iCount;
3731
3732}
3733// _______________________________________________________________________________
3734Int_t AliAnalysisTaskIDFragmentationFunction::GetListOfJets(TList *list, Int_t type)
3735{
3736 // fill list of jets selected according to type
3737
3738 if(!list){
3739 if(fDebug>1) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
3740 return -1;
3741 }
3742
3743 if(type == kJetsRec || type == kJetsRecAcceptance){ // reconstructed jets
3744
3745 if(fBranchRecJets.Length()==0){
3746 Printf("%s:%d no rec jet branch specified", (char*)__FILE__,__LINE__);
3747 if(fDebug>1)fAOD->Print();
3748 return 0;
3749 }
3750
3751 TClonesArray *aodRecJets = 0;
3752 if(fBranchRecJets.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchRecJets.Data()));
3753 if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchRecJets.Data()));
3754 if(fAODExtension&&!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchRecJets.Data()));
3755
3756 if(!aodRecJets){
3757 if(fBranchRecJets.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchRecJets.Data());
3758 if(fDebug>1)fAOD->Print();
3759 return 0;
3760 }
3761
3762 // Reorder jet pt and fill new temporary AliAODJet objects
3763 Int_t nRecJets = 0;
3764
3765 for(Int_t ij=0; ij<aodRecJets->GetEntries(); ++ij){
3766
3767 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodRecJets->At(ij));
3768 if(!tmp) continue;
3769
3770 if( tmp->Pt() < fJetPtCut ) continue;
3771 if( type == kJetsRecAcceptance &&
3772 ( tmp->Eta() < fJetEtaMin
3773 || tmp->Eta() > fJetEtaMax
3774 || tmp->Phi() < fJetPhiMin
3775 || tmp->Phi() > fJetPhiMax )) continue;
3776
3777
3778 list->Add(tmp);
3779 nRecJets++;
3780 }
3781
3782 list->Sort();
3783
3784 return nRecJets;
3785 }
3786 else if(type == kJetsKine || type == kJetsKineAcceptance){
3787
3788 // generated jets
3789 Int_t nGenJets = 0;
3790
3791 if(!fMCEvent){
3792 if(fDebug>1) Printf("%s:%d no mcEvent",(char*)__FILE__,__LINE__);
3793 return 0;
3794 }
3795
3796 AliGenEventHeader* genHeader = fMCEvent->GenEventHeader();
3797 AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
3798 AliGenHijingEventHeader* hijingGenHeader = 0x0;
3799
3800 if(!pythiaGenHeader){
3801 hijingGenHeader = dynamic_cast<AliGenHijingEventHeader*>(genHeader);
3802
3803 if(!hijingGenHeader){
3804 Printf("%s:%d no pythiaGenHeader or hijingGenHeader found", (char*)__FILE__,__LINE__);
3805 return 0;
3806 }else{
3807 TLorentzVector mom[4];
3808 AliAODJet* jet[4];
3809 hijingGenHeader->GetJets(mom[0], mom[1], mom[2], mom[3]);
3810
3811 for(Int_t i=0; i<2; ++i){
3812 if(!mom[i].Pt()) continue;
3813 jet[i] = new AliAODJet(mom[i]);
3814
3815 if( type == kJetsKineAcceptance &&
3816 ( jet[i]->Eta() < fJetEtaMin
3817 || jet[i]->Eta() > fJetEtaMax
3818 || jet[i]->Phi() < fJetPhiMin
3819 || jet[i]->Phi() > fJetPhiMax )) continue;
3820
3821 list->Add(jet[i]);
3822 nGenJets++;
3823 }
3824 list->Sort();
3825 return nGenJets;
3826 }
3827 }
3828
3829 // fetch the pythia generated jets
3830 for(int ip=0; ip<pythiaGenHeader->NTriggerJets(); ++ip){
3831
3832 Float_t p[4];
3833 AliAODJet *jet = new AliAODJet();
3834 pythiaGenHeader->TriggerJet(ip, p);
3835 jet->SetPxPyPzE(p[0], p[1], p[2], p[3]);
3836
3837 if( type == kJetsKineAcceptance &&
3838 ( jet->Eta() < fJetEtaMin
3839 || jet->Eta() > fJetEtaMax
3840 || jet->Phi() < fJetPhiMin
3841 || jet->Phi() > fJetPhiMax )) continue;
3842
3843 list->Add(jet);
3844 nGenJets++;
3845 }
3846 list->Sort();
3847 return nGenJets;
3848 }
3849 else if(type == kJetsGen || type == kJetsGenAcceptance ){
3850
3851 if(fBranchGenJets.Length()==0){
3852 if(fDebug>1) Printf("%s:%d no gen jet branch specified", (char*)__FILE__,__LINE__);
3853 return 0;
3854 }
3855
3856 TClonesArray *aodGenJets = 0;
3857 if(fBranchGenJets.Length()) aodGenJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchGenJets.Data()));
3858 if(!aodGenJets) aodGenJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchGenJets.Data()));
3859 if(fAODExtension&&!aodGenJets) aodGenJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchGenJets.Data()));
3860
3861 if(!aodGenJets){
3862 if(fDebug>0){
3863 if(fBranchGenJets.Length()) Printf("%s:%d Generated jet branch %s not found",(char*)__FILE__,__LINE__,fBranchGenJets.Data());
3864 }
3865 if(fDebug>1)fAOD->Print();
3866 return 0;
3867 }
3868
3869 Int_t nGenJets = 0;
3870
3871 for(Int_t ig=0; ig<aodGenJets->GetEntries(); ++ig){
3872
3873 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodGenJets->At(ig));
3874 if(!tmp) continue;
3875
3876 if( tmp->Pt() < fJetPtCut ) continue;
3877 if( type == kJetsGenAcceptance &&
3878 ( tmp->Eta() < fJetEtaMin
3879 || tmp->Eta() > fJetEtaMax
3880 || tmp->Phi() < fJetPhiMin
3881 || tmp->Phi() > fJetPhiMax )) continue;
3882
3883 list->Add(tmp);
3884 nGenJets++;
3885 }
3886 list->Sort();
3887 return nGenJets;
3888 }
3889 else if(type == kJetsEmbedded){ // embedded jets
3890
3891 if(fBranchEmbeddedJets.Length()==0){
3892 Printf("%s:%d no embedded jet branch specified", (char*)__FILE__,__LINE__);
3893 if(fDebug>1)fAOD->Print();
3894 return 0;
3895 }
3896
3897 TClonesArray *aodEmbeddedJets = 0;
3898 if(fBranchEmbeddedJets.Length()) aodEmbeddedJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchEmbeddedJets.Data()));
3899 if(!aodEmbeddedJets) aodEmbeddedJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchEmbeddedJets.Data()));
3900 if(fAODExtension&&!aodEmbeddedJets) aodEmbeddedJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchEmbeddedJets.Data()));
3901
3902 if(!aodEmbeddedJets){
3903 if(fBranchEmbeddedJets.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchEmbeddedJets.Data());
3904 if(fDebug>1)fAOD->Print();
3905 return 0;
3906 }
3907
3908 // Reorder jet pt and fill new temporary AliAODJet objects
3909 Int_t nEmbeddedJets = 0;
3910
3911 for(Int_t ij=0; ij<aodEmbeddedJets->GetEntries(); ++ij){
3912
3913 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodEmbeddedJets->At(ij));
3914 if(!tmp) continue;
3915
3916 if( tmp->Pt() < fJetPtCut ) continue;
3917 if( tmp->Eta() < fJetEtaMin
3918 || tmp->Eta() > fJetEtaMax
3919 || tmp->Phi() < fJetPhiMin
3920 || tmp->Phi() > fJetPhiMax ) continue;
3921
3922 list->Add(tmp);
3923 nEmbeddedJets++;
3924 }
3925
3926 list->Sort();
3927
3928 return nEmbeddedJets;
3929 }
3930 else{
3931 if(fDebug>0)Printf("%s:%d no such type %d",(char*)__FILE__,__LINE__,type);
3932 return 0;
3933 }
3934}
3935
3936// ___________________________________________________________________________________
3937Int_t AliAnalysisTaskIDFragmentationFunction::GetListOfBckgJets(TList *list, Int_t type)
3938{
3939 // fill list of bgr clusters selected according to type
3940
3941 if(type == kJetsRec || type == kJetsRecAcceptance){ // reconstructed jets
3942
3943 if(fBranchRecBckgClusters.Length()==0){
3944 Printf("%s:%d no rec jet branch specified", (char*)__FILE__,__LINE__);
3945 if(fDebug>1)fAOD->Print();
3946 return 0;
3947 }
3948
3949 TClonesArray *aodRecJets = 0;
3950 if(fBranchRecBckgClusters.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchRecBckgClusters.Data()));
3951 if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchRecBckgClusters.Data()));
3952 if(fAODExtension&&!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchRecBckgClusters.Data()));
3953
3954 if(!aodRecJets){
3955 if(fBranchRecBckgClusters.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchRecBckgClusters.Data());
3956 if(fDebug>1)fAOD->Print();
3957 return 0;
3958 }
3959
3960 // Reorder jet pt and fill new temporary AliAODJet objects
3961 Int_t nRecJets = 0;
3962
3963 for(Int_t ij=0; ij<aodRecJets->GetEntries(); ++ij){
3964
3965 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodRecJets->At(ij));
3966 if(!tmp) continue;
3967
3968 // if( tmp->Pt() < fJetPtCut ) continue; // no pt cut on bckg clusters !
3969 if( type == kJetsRecAcceptance &&
3970 ( tmp->Eta() < fJetEtaMin
3971 || tmp->Eta() > fJetEtaMax
3972 || tmp->Phi() < fJetPhiMin
3973 || tmp->Phi() > fJetPhiMax )) continue;
3974
3975 list->Add(tmp);
3976
3977 nRecJets++;
3978
3979 }
3980
3981 list->Sort();
3982
3983 return nRecJets;
3984 }
3985
3986 // /*
3987 // MC clusters still Under construction
3988 // */
3989
3990 return 0;
3991}
3992
3993// _________________________________________________________________________________________________________
9d7ad2e4 3994void AliAnalysisTaskIDFragmentationFunction::SetProperties(THnSparse* h, Int_t dim, const char** labels)
e131b05f 3995{
3996 // Set properties of THnSparse
3997
3998 for(Int_t i=0; i<dim; i++){
3999 h->GetAxis(i)->SetTitle(labels[i]);
4000 h->GetAxis(i)->SetTitleColor(1);
4001 }
4002}
4003
4004// __________________________________________________________________________________________
4005void AliAnalysisTaskIDFragmentationFunction::SetProperties(TH1* h,const char* x, const char* y)
4006{
4007 //Set properties of histos (x and y title)
4008
4009 h->SetXTitle(x);
4010 h->SetYTitle(y);
4011 h->GetXaxis()->SetTitleColor(1);
4012 h->GetYaxis()->SetTitleColor(1);
4013}
4014
4015// _________________________________________________________________________________________________________
4016void AliAnalysisTaskIDFragmentationFunction::SetProperties(TH1* h,const char* x, const char* y, const char* z)
4017{
4018 //Set properties of histos (x,y and z title)
4019
4020 h->SetXTitle(x);
4021 h->SetYTitle(y);
4022 h->SetZTitle(z);
4023 h->GetXaxis()->SetTitleColor(1);
4024 h->GetYaxis()->SetTitleColor(1);
4025 h->GetZaxis()->SetTitleColor(1);
4026}
4027
4028// ________________________________________________________________________________________________________________________________________________________
4029void AliAnalysisTaskIDFragmentationFunction::GetJetTracksPointing(TList* inputlist, TList* outputlist, const AliAODJet* jet,
9d7ad2e4 4030 Double_t radius, Double_t& sumPt, Double_t minPtL, Double_t maxPt, Bool_t& isBadPt)
e131b05f 4031{
4032 // fill list of tracks in cone around jet axis
4033
4034 sumPt = 0;
4035 Bool_t isBadMaxPt = kFALSE;
4036 Bool_t isBadMinPt = kTRUE;
4037
4038 Double_t jetMom[3];
4039 jet->PxPyPz(jetMom);
4040 TVector3 jet3mom(jetMom);
4041
4042 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
4043
4044 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
4045 if(!track)continue;
4046 Double_t trackMom[3];
4047 track->PxPyPz(trackMom);
4048 TVector3 track3mom(trackMom);
4049
4050 Double_t dR = jet3mom.DeltaR(track3mom);
4051
4052 if(dR<radius){
4053
4054 outputlist->Add(track);
4055
4056 sumPt += track->Pt();
4057
4058 if(maxPt>0 && track->Pt()>maxPt) isBadMaxPt = kTRUE;
4059 if(minPtL>0 && track->Pt()>minPtL) isBadMinPt = kFALSE;
4060 }
4061 }
4062
4063 isBadPt = kFALSE;
4064 if(minPtL>0 && isBadMinPt) isBadPt = kTRUE;
4065 if(maxPt>0 && isBadMaxPt) isBadPt = kTRUE;
4066
4067 outputlist->Sort();
4068}
4069
4070// _________________________________________________________________________________________________________________________________________________________________
9d7ad2e4 4071void AliAnalysisTaskIDFragmentationFunction::GetJetTracksTrackrefs(TList* list, const AliAODJet* jet, Double_t minPtL, Double_t maxPt, Bool_t& isBadPt)
e131b05f 4072{
4073 // list of jet tracks from trackrefs
4074
4075 Int_t nTracks = jet->GetRefTracks()->GetEntriesFast();
4076
4077 Bool_t isBadMaxPt = kFALSE;
4078 Bool_t isBadMinPt = kTRUE;
4079
4080 for(Int_t itrack=0; itrack<nTracks; itrack++) {
4081
4082 AliVParticle* track = dynamic_cast<AliVParticle*>(jet->GetRefTracks()->At(itrack));
4083 if(!track){
4084 AliError("expected ref track not found ");
4085 continue;
4086 }
4087
4088 if(track->Pt() < fTrackPtCut) continue; // track refs may contain low pt cut (bug in AliFastJetInput)
4089 if(maxPt>0 && track->Pt()>maxPt) isBadMaxPt = kTRUE;
4090 if(minPtL>0 && track->Pt()>minPtL) isBadMinPt = kFALSE;
4091
4092 list->Add(track);
4093 }
4094
4095 isBadPt = kFALSE;
4096 if(minPtL>0 && isBadMinPt) isBadPt = kTRUE;
4097 if(maxPt>0 && isBadMaxPt) isBadPt = kTRUE;
4098
4099 list->Sort();
4100}
4101
4102// _ ________________________________________________________________________________________________________________________________
4103void AliAnalysisTaskIDFragmentationFunction::AssociateGenRec(TList* tracksAODMCCharged,TList* tracksRec, TArrayI& indexAODTr,TArrayI& indexMCTr,
4104 TArrayS& isRefGen,TH2F* fh2PtRecVsGen)
4105{
4106 // associate generated and reconstructed tracks, fill TArrays of list indices
4107
4108 Int_t nTracksRec = tracksRec->GetSize();
4109 Int_t nTracksGen = tracksAODMCCharged->GetSize();
4110 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
4111
4112
4113 if(!nTracksGen) return;
4114 if(!tca) return;
4115
4116 // set size
4117 indexAODTr.Set(nTracksGen);
4118 indexMCTr.Set(nTracksRec);
4119 isRefGen.Set(nTracksGen);
4120
4121 indexAODTr.Reset(-1);
4122 indexMCTr.Reset(-1);
4123 isRefGen.Reset(0);
4124
4125 // loop over reconstructed tracks, get generated track
4126
4127 for(Int_t iRec=0; iRec<nTracksRec; iRec++){
4128
4129 AliAODTrack* rectrack = dynamic_cast<AliAODTrack*>(tracksRec->At(iRec));
4130 if(!rectrack)continue;
4131 Int_t label = TMath::Abs(rectrack->GetLabel());
4132
4133 // find MC track in our list
4134 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tca->At(label));
4135
4136 Int_t listIndex = -1;
4137 if(gentrack) listIndex = tracksAODMCCharged->IndexOf(gentrack);
4138
4139 if(listIndex>=0){
4140
4141 indexAODTr[listIndex] = iRec;
4142 indexMCTr[iRec] = listIndex;
4143 }
4144 }
4145
4146
4147 // define reference sample of primaries/secondaries (for reconstruction efficiency / contamination)
4148
4149 for(Int_t iGen=0; iGen<nTracksGen; iGen++){
4150
4151 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tracksAODMCCharged->At(iGen));
4152 if(!gentrack)continue;
4153 Int_t pdg = gentrack->GetPdgCode();
4154
4155 // 211 - pi, 2212 - proton, 321 - Kaon, 11 - electron, 13 - muon
4156 if(TMath::Abs(pdg) == 211 || TMath::Abs(pdg) == 2212 || TMath::Abs(pdg) == 321 ||
4157 TMath::Abs(pdg) == 11 || TMath::Abs(pdg) == 13){
4158
4159 isRefGen[iGen] = kTRUE;
4160
4161 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
4162
4163 if(iRec>=0){
4164 Float_t genPt = gentrack->Pt();
4165 AliAODTrack* vt = dynamic_cast<AliAODTrack*>(tracksRec->At(iRec));
4166 if(vt){
4167 Float_t recPt = vt->Pt();
4168 fh2PtRecVsGen->Fill(genPt,recPt);
4169 }
4170 }
4171 }
4172 }
4173}
4174
4175// _____________________________________________________________________________________________________________________________________________
4176void AliAnalysisTaskIDFragmentationFunction::FillSingleTrackHistosRecGen(AliFragFuncQATrackHistos* trackQAGen, AliFragFuncQATrackHistos* trackQARec, TList* tracksGen,
9d7ad2e4 4177 const TArrayI& indexAODTr, const TArrayS& isRefGen, Bool_t scaleStrangeness){
e131b05f 4178
4179 // fill QA for single track reconstruction efficiency
4180
4181 Int_t nTracksGen = tracksGen->GetSize();
4182
4183 if(!nTracksGen) return;
4184
4185 for(Int_t iGen=0; iGen<nTracksGen; iGen++){
4186
4187 if(isRefGen[iGen] != 1) continue; // select primaries
4188
4189 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tracksGen->At(iGen));
4190 if(!gentrack) continue;
4191 Double_t ptGen = gentrack->Pt();
4192 Double_t etaGen = gentrack->Eta();
4193 Double_t phiGen = TVector2::Phi_0_2pi(gentrack->Phi());
4194
4195 // apply same acc & pt cuts as for FF GetMCStrangenessFactorCMS
4196
4197 if(etaGen < fTrackEtaMin || etaGen > fTrackEtaMax) continue;
4198 if(phiGen < fTrackPhiMin || phiGen > fTrackPhiMax) continue;
4199 if(ptGen < fTrackPtCut) continue;
4200
4201 if(trackQAGen) trackQAGen->FillTrackQA(etaGen, phiGen, ptGen);
4202
4203 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
4204
4205 if(iRec>=0 && trackQARec){
4206 if(scaleStrangeness){
4207 //Double_t weight = GetMCStrangenessFactor(ptGen);
4208 Double_t weight = GetMCStrangenessFactorCMS(gentrack);
4209 trackQARec->FillTrackQA(etaGen, phiGen, ptGen, kFALSE, 0, kTRUE, weight);
4210 }
4211 else trackQARec->FillTrackQA(etaGen, phiGen, ptGen);
4212 }
4213 }
4214}
4215
4216// ______________________________________________________________________________________________________________________________________________________
4217
4218void AliAnalysisTaskIDFragmentationFunction::FillJetTrackHistosRec(AliFragFuncHistos* ffhistRec, AliAODJet* jet,
4219 TList* jetTrackList, const TList* tracksGen, const TList* tracksRec, const TArrayI& indexAODTr,
9d7ad2e4 4220 const TArrayS& isRefGen, TList* jetTrackListTR, Bool_t scaleStrangeness,
e131b05f 4221 Bool_t fillJS, TProfile* hProNtracksLeadingJet, TProfile** hProDelRPtSum, TProfile* hProDelR80pcPt)
4222{
4223 // fill objects for jet track reconstruction efficiency or secondaries contamination
4224 // arguments histGen/histRec can be of different type: AliFragFuncHistos*, AliFragFuncIntraJetHistos*, ...
4225 // jetTrackListTR pointer: track refs if not NULL
4226
4227
4228 // ensure proper normalization, even for secondaries
4229 Double_t jetPtRec = jet->Pt();
4230 ffhistRec->FillFF(-1, jetPtRec, kTRUE);
4231
4232 Int_t nTracksJet = jetTrackList->GetSize(); // list with AODMC tracks
4233 if(nTracksJet == 0) return;
4234
4235 TList* listRecTracks = new TList();
4236 listRecTracks->Clear();
4237
4238 for(Int_t iTr=0; iTr<nTracksJet; iTr++){ // jet tracks loop
4239
4240 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (jetTrackList->At(iTr));
4241 if(!gentrack)continue;
4242 // find jet track in gen tracks list
4243 Int_t iGen = tracksGen->IndexOf(gentrack);
4244
4245 if(iGen<0){
4246 if(fDebug>0) Printf("%s:%d gen jet track not found ",(char*)__FILE__,__LINE__);
4247 continue;
4248 }
4249
4250 if(isRefGen[iGen] != 1) continue; // select primaries
4251
4252 Double_t ptGen = gentrack->Pt();
4253 Double_t etaGen = gentrack->Eta();
4254 Double_t phiGen = TVector2::Phi_0_2pi(gentrack->Phi());
4255
4256 // gen level acc & pt cuts - skip in case of track refs
4257 if(!jetTrackListTR && (etaGen < fTrackEtaMin || etaGen > fTrackEtaMax)) continue;
4258 if(!jetTrackListTR && (phiGen < fTrackPhiMin || phiGen > fTrackPhiMax)) continue;
4259 if(!jetTrackListTR && ptGen < fTrackPtCut) continue;
4260
4261
4262 Double_t ptRec = -1;
4263
4264 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
4265 Bool_t isRec = (iRec>=0) ? kTRUE : kFALSE;
4266
4267 Bool_t isJetTrack = kFALSE;
4268 if(!jetTrackListTR) isJetTrack = kTRUE; // skip trackRefs check for tracks in ideal cone
4269
4270 if(isRec){
4271
4272 AliAODTrack* rectrack = dynamic_cast<AliAODTrack*> (tracksRec->At(iRec));
4273 if(!rectrack) continue;
4274
4275 ptRec = rectrack->Pt();
4276
4277 if(jetTrackListTR){
4278 Int_t iRecTR = jetTrackListTR->IndexOf(rectrack);
4279 if(iRecTR >=0 ) isJetTrack = kTRUE; // rec tracks assigned to jet
4280 }
4281
4282 if(isJetTrack){
4283
4284 Double_t trackPt = ptRec;
4285 Bool_t incrementJetPt = kFALSE;
4286
4287 if(scaleStrangeness){
4288 //Double_t weight = GetMCStrangenessFactor(ptGen);
4289 Double_t weight = GetMCStrangenessFactorCMS(gentrack);
4290
4291 ffhistRec->FillFF( trackPt, jetPtRec, incrementJetPt, 0, kTRUE, weight );
4292 }
4293 else{
4294 ffhistRec->FillFF( trackPt, jetPtRec, incrementJetPt );
4295 }
4296
4297 listRecTracks->Add(rectrack);
4298
4299 }
4300 }
4301 }
4302
4303
4304 if(fillJS) FillJetShape(jet,listRecTracks,hProNtracksLeadingJet, hProDelRPtSum, hProDelR80pcPt,0,0,scaleStrangeness);
4305
4306 delete listRecTracks;
4307
4308}
4309
4310// _____________________________________________________________________________________________________________________________________________________________________
4311void AliAnalysisTaskIDFragmentationFunction::GetTracksTiltedwrpJetAxis(Float_t alpha, TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius,Double_t& sumPt)
4312{
4313 // List of tracks in cone perpendicular to the jet azimuthal direction
4314
4315 Double_t jetMom[3];
4316 jet->PxPyPz(jetMom);
4317
4318 TVector3 jet3mom(jetMom);
4319 // Rotate phi and keep eta unchanged
4320 Double_t etaTilted = jet3mom.Eta();
4321 Double_t phiTilted = TVector2::Phi_0_2pi(jet3mom.Phi()) + alpha;
4322 if(phiTilted > 2*TMath::Pi()) phiTilted = phiTilted - 2*TMath::Pi();
4323
4324 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
4325
4326 // embedded tracks
4327 if( fUseExtraTracksBgr != 1){
4328 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
4329 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4330 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4331 }
4332 }
4333
4334 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
4335 if(!track)continue;
4336 Double_t trackMom[3];
4337 track->PxPyPz(trackMom);
4338 TVector3 track3mom(trackMom);
4339
4340 Double_t deta = track3mom.Eta() - etaTilted;
4341 Double_t dphi = TMath::Abs(track3mom.Phi() - phiTilted);
4342 if (dphi > TMath::Pi()) dphi = 2. * TMath::Pi() - dphi;
4343 Double_t dR = TMath::Sqrt(deta * deta + dphi * dphi);
4344
4345
4346 if(dR<=radius){
4347 outputlist->Add(track);
4348 sumPt += track->Pt();
4349 }
4350 }
4351
4352}
4353
4354// ________________________________________________________________________________________________________________________________________________________
4355void AliAnalysisTaskIDFragmentationFunction::GetTracksTiltedwrpJetAxisWindow(Float_t alpha, TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius,Double_t& sumPt,Double_t &normFactor)
4356{
4357 // List of tracks in cone perpendicular to the jet azimuthal direction
4358
4359 Double_t jetMom[3];
4360 jet->PxPyPz(jetMom);
4361
4362 TVector3 jet3mom(jetMom);
4363 // Rotate phi and keep eta unchanged
4364 Double_t etaTilted = jet3mom.Eta();
4365 Double_t phiTilted = TVector2::Phi_0_2pi(jet3mom.Phi()) + alpha;
4366 if(phiTilted > 2*TMath::Pi()) phiTilted = phiTilted - 2*TMath::Pi();
4367
4368 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++)
4369 {
4370
4371 // embedded tracks
4372 if( fUseExtraTracksBgr != 1){
4373 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
4374 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4375 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4376 }
4377 }
4378
4379 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
4380 if(!track)continue;
4381 Float_t trackEta = track->Eta();
4382 Float_t trackPhi = track->Phi();
4383
4384 if( ( phiTilted-radius >= 0 ) && ( phiTilted+radius <= 2*TMath::Pi()))
4385 {
4386 if((trackPhi<=phiTilted+radius) &&
4387 (trackPhi>=phiTilted-radius) &&
4388 (trackEta<=fTrackEtaMax)&&(trackEta>=fTrackEtaMin)) // 0.9 and - 0.9
4389 {
4390 outputlist->Add(track);
4391 sumPt += track->Pt();
4392 }
4393 }
4394 else if( phiTilted-radius < 0 )
4395 {
4396 if((( trackPhi < phiTilted+radius ) ||
4397 ( trackPhi > 2*TMath::Pi()-(radius-phiTilted) )) &&
4398 (( trackEta <= fTrackEtaMax ) && ( trackEta >= fTrackEtaMin )))
4399 {
4400 outputlist->Add(track);
4401 sumPt += track->Pt();
4402 }
4403 }
4404 else if( phiTilted+radius > 2*TMath::Pi() )
4405 {
4406 if((( trackPhi > phiTilted-radius ) ||
4407 ( trackPhi < phiTilted+radius-2*TMath::Pi() )) &&
4408 (( trackEta <= fTrackEtaMax ) && ( trackEta >= fTrackEtaMin )))
4409 {
4410 outputlist->Add(track);
4411 sumPt += track->Pt();
4412 }
4413 }
4414 }
4415
4416 // Jet area - Temporarily added should be modified with the proper jet area value
4417 Float_t areaJet = CalcJetArea(etaTilted,radius);
4418 Float_t areaTilted = 2*radius*(fTrackEtaMax-fTrackEtaMin);
4419
4420 normFactor = (Float_t) 1. / (areaJet / areaTilted);
4421
4422}
4423
4424
4425// ________________________________________________________________________________________________________________________________________________________
4426void AliAnalysisTaskIDFragmentationFunction::GetTracksOutOfNJets(Int_t nCases, TList* inputlist, TList* outputlist, const TList* jetlist,
4427 Double_t& sumPt)
4428{
4429 // List of tracks outside cone around N jet axis
4430 // Particles taken randomly
4431
4432 sumPt = 0;
4433 // Int_t nj = jetlist->GetSize();
4434 Float_t rc = TMath::Abs(GetFFRadius());
4435 Float_t rcl = GetFFBckgRadius();
4436
4437 // Estimate jet and background areas
4438 Float_t* areaJet = new Float_t[nCases];
4439 memset(areaJet, 0, sizeof(Float_t) * nCases);
4440 Float_t* areaJetLarge = new Float_t[nCases];
4441 memset(areaJetLarge, 0, sizeof(Float_t) * nCases);
4442 Float_t areaFull = (fTrackEtaMax-fTrackEtaMin)*(fTrackPhiMax-fTrackPhiMin);
4443 Float_t areaOut = areaFull;
4444
4445 //estimate jets and background areas
4446 Int_t nOut = 0;
4447 Int_t ijet = 0;
4448 TList* templist = new TList();
4449 TClonesArray *vect3Jet = new TClonesArray("TVector3",nCases);
4450
4451 for(Int_t ij=0; ij<nCases; ++ij)
4452 {
4453 // Get jet information
4454 AliAODJet* jet = dynamic_cast<AliAODJet*>(jetlist->At(ij));
4455 if(!jet)continue;
4456 TVector3 jet3mom;
4457 jet3mom.SetPtEtaPhi(jet->Pt(),jet->Eta(),jet->Phi());
4458 new((*vect3Jet)[ijet]) TVector3((TVector3)jet3mom);
4459 Float_t etaJet = (Float_t)((TVector3*) vect3Jet->At(ij))->Eta();
4460
4461 // Jet area
4462 areaJet[ij] = CalcJetArea(etaJet,rc);
4463
4464 // Area jet larger angle
4465 areaJetLarge[ij] = CalcJetArea(etaJet,rcl);
4466
4467 // Outside jet area
4468 areaOut = areaOut - areaJetLarge[ij];
4469 ijet++;
4470 }
4471
4472 // List of all tracks outside jet areas
4473 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
4474
4475 // embedded tracks
4476 if( fUseExtraTracksBgr != 1){
4477 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
4478 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4479 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4480 }
4481 }
4482
4483 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
4484
4485 if(!track)continue;
4486 Double_t trackMom[3];
4487 track->PxPyPz(trackMom);
4488 TVector3 track3mom(trackMom);
4489
4490 Double_t *dR = new Double_t[nCases];
4491 for(Int_t ij=0; ij<nCases; ij++)
4492 dR[ij] = (Double_t)((TVector3*) vect3Jet->At(ij))->DeltaR(track3mom);
4493
4494 if((nCases==1 && (dR[0]>rcl)) ||
4495 (nCases==2 && (dR[0]>rcl && dR[1]>rcl)) ||
4496 (nCases==3 && (dR[0]>rcl && dR[1]>rcl && dR[2]>rcl)))
4497 {
4498 templist->Add(track);
4499 nOut++;
4500 }
4501 delete [] dR;
4502 }
4503
4504 // Take tracks randomly
4505 Int_t nScaled = (Int_t) (nOut * areaJet[0] / areaOut + 0.5);
4506 TArrayI* ar = new TArrayI(nOut);
4507
4508 for(Int_t init=0; init<nOut; init++)
4509 (*ar)[init] = init;
4510
4511 Int_t *randIndex = new Int_t[nScaled];
4512 for(Int_t init2=0; init2<nScaled; init2++)
4513 randIndex[init2] = -1;
4514
4515 // Select nScaled different random numbers in nOut
4516 for(Int_t i=0; i<nScaled; i++)
4517 {
4518 Int_t* tmpArr = new Int_t[nOut-i];
4519 Int_t temp = fRandom->Integer(nOut-i);
4520 for(Int_t ind = 0; ind< ar->GetSize()-1; ind++)
4521 {
4522 if(ind<temp) tmpArr[ind] = (*ar)[ind];
4523 else tmpArr[ind] = (*ar)[ind+1];
4524 }
4525 randIndex[i] = (*ar)[temp];
4526
4527 ar->Set(nOut-i-1,tmpArr);
4528
4529 delete [] tmpArr;
4530
4531 }
4532
4533 for(Int_t ipart=0; ipart<nScaled; ipart++)
4534 {
4535 AliVParticle* track = (AliVParticle*)(templist->At(randIndex[ipart]));
4536 outputlist->Add(track);
4537 sumPt += track->Pt();
4538 }
4539
4540 outputlist->Sort();
4541
4542 delete vect3Jet;
4543 delete templist;
4544 delete [] areaJetLarge;
4545 delete [] areaJet;
4546 delete ar;
4547 delete [] randIndex;
4548
4549}
4550
4551// ________________________________________________________________________________________________________________________________________________________
4552void AliAnalysisTaskIDFragmentationFunction::GetTracksOutOfNJetsStat(Int_t nCases, TList* inputlist, TList* outputlist,
4553 const TList* jetlist, Double_t& sumPt, Double_t &normFactor)
4554{
4555 // List of tracks outside cone around N jet axis
4556 // All particles taken + final scaling factor
4557
4558 sumPt = 0;
4559 Float_t rc = TMath::Abs(GetFFRadius());
4560 Float_t rcl = GetFFBckgRadius();
4561
4562 // Estimate jet and background areas
4563 Float_t* areaJet = new Float_t[nCases];
4564 memset(areaJet, 0, sizeof(Float_t) * nCases);
4565 Float_t* areaJetLarge = new Float_t[nCases];
4566 memset(areaJetLarge, 0, sizeof(Float_t) * nCases);
4567 Float_t areaFull = (fTrackEtaMax-fTrackEtaMin)*(fTrackPhiMax-fTrackPhiMin);
4568 Float_t areaOut = areaFull;
4569
4570 //estimate jets and background areas
4571 Int_t nOut = 0;
4572 Int_t ijet = 0;
4573 TClonesArray *vect3Jet = new TClonesArray("TVector3",nCases);
4574
4575 for(Int_t ij=0; ij<nCases; ++ij)
4576 {
4577 // Get jet information
4578 AliAODJet* jet = dynamic_cast<AliAODJet*>(jetlist->At(ij));
4579 if(!jet)continue;
4580 TVector3 jet3mom;
4581 jet3mom.SetPtEtaPhi(jet->Pt(),jet->Eta(),jet->Phi());
4582 new((*vect3Jet)[ijet]) TVector3((TVector3)jet3mom);
4583 Float_t etaJet = (Float_t)((TVector3*) vect3Jet->At(ij))->Eta();
4584
4585 // Jet area
4586 areaJet[ij] = CalcJetArea(etaJet,rc);
4587
4588 // Area jet larger angle
4589 areaJetLarge[ij] = CalcJetArea(etaJet,rcl);
4590
4591 // Outside jets area
4592 areaOut = areaOut - areaJetLarge[ij];
4593 ijet++;
4594 }
4595
4596 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
4597
4598 // embedded tracks
4599 if( fUseExtraTracksBgr != 1){
4600 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
4601 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4602 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4603 }
4604 }
4605
4606 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
4607 if(!track)continue;
4608 Double_t trackMom[3];
4609 track->PxPyPz(trackMom);
4610 TVector3 track3mom(trackMom);
4611
4612 Double_t *dR = new Double_t[nCases];
4613 for(Int_t ij=0; ij<nCases; ij++)
4614 dR[ij] = (Double_t)((TVector3*) vect3Jet->At(ij))->DeltaR(track3mom);
4615
4616 if((nCases==0) ||
4617 (nCases==1 && (dR[0]>rcl)) ||
4618 (nCases==2 && (dR[0]>rcl && dR[1]>rcl)) ||
4619 (nCases==3 && (dR[0]>rcl && dR[1]>rcl && dR[2]>rcl)))
4620 {
4621 outputlist->Add(track);
4622 sumPt += track->Pt();
4623 nOut++;
4624 }
4625 delete [] dR;
4626 }
4627
4628 if(nCases==0) areaJet[0] = TMath::Pi()*rc*rc;
4629 normFactor = (Float_t) 1./(areaJet[0] / areaOut);
4630
4631 outputlist->Sort();
4632
4633 delete vect3Jet;
4634 delete [] areaJetLarge;
4635 delete [] areaJet;
4636
4637}
4638
4639// ______________________________________________________________________________________________________________________________________________________
9d7ad2e4 4640Float_t AliAnalysisTaskIDFragmentationFunction::CalcJetArea(Float_t etaJet, Float_t rc) const
e131b05f 4641{
4642 // calculate area of jet with eta etaJet and radius rc
4643
4644 Float_t detamax = etaJet + rc;
4645 Float_t detamin = etaJet - rc;
4646 Float_t accmax = 0.0; Float_t accmin = 0.0;
4647 if(detamax > fTrackEtaMax){ // sector outside etamax
4648 Float_t h = fTrackEtaMax - etaJet;
4649 accmax = rc*rc*TMath::ACos(h/rc) - h*TMath::Sqrt(rc*rc - h*h);
4650 }
4651 if(detamin < fTrackEtaMin){ // sector outside etamin
4652 Float_t h = fTrackEtaMax + etaJet;
4653 accmin = rc*rc*TMath::ACos(h/rc) - h*TMath::Sqrt(rc*rc - h*h);
4654 }
4655 Float_t areaJet = rc*rc*TMath::Pi() - accmax - accmin;
4656
4657 return areaJet;
4658
4659}
4660
4661// ___________________________________________________________________________________________________________________________
4662void AliAnalysisTaskIDFragmentationFunction::GetClusterTracksOutOf1Jet(AliAODJet* jet, TList* outputlist, Double_t &normFactor)
4663{
4664 // fill tracks from bckgCluster branch in list,
4665 // for all clusters outside jet cone
4666 // sum up total area of clusters
4667
4668 Double_t rc = GetFFRadius();
4669 Double_t rcl = GetFFBckgRadius();
4670
4671 Double_t areaTotal = 0;
4672 Double_t sumPtTotal = 0;
4673
4674 for(Int_t ij=0; ij<fBckgJetsRec->GetEntries(); ++ij){
4675
4676 AliAODJet* bgrCluster = (AliAODJet*)(fBckgJetsRec->At(ij)); // not 'recCuts': use all clusters in full eta range
4677
4678 Double_t dR = jet->DeltaR(bgrCluster);
4679
4680 if(dR<rcl) continue;
4681
4682 Double_t clusterPt = bgrCluster->Pt();
4683 Double_t area = bgrCluster->EffectiveAreaCharged();
4684 areaTotal += area;
4685 sumPtTotal += clusterPt;
4686
4687 Int_t nTracksJet = bgrCluster->GetRefTracks()->GetEntries();
4688
4689 for(Int_t it = 0; it<nTracksJet; it++){
4690
4691 // embedded tracks - note: using ref tracks here, fBranchRecBckgClusters has to be consistent
4692 if( fUseExtraTracksBgr != 1){
4693 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (bgrCluster->GetTrack(it))){
4694 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4695 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4696 }
4697 }
4698
4699 AliVParticle* track = dynamic_cast<AliVParticle*>(bgrCluster->GetTrack(it));
4700 if(!track) continue;
4701
4702 Float_t trackPt = track->Pt();
4703 Float_t trackEta = track->Eta();
4704 Float_t trackPhi = TVector2::Phi_0_2pi(track->Phi());
4705
4706 if(trackEta < fTrackEtaMin || trackEta > fTrackEtaMax) continue;
4707 if(trackPhi < fTrackPhiMin || trackPhi > fTrackPhiMax) continue;
4708 if(trackPt < fTrackPtCut) continue;
4709
4710 outputlist->Add(track);
4711 }
4712 }
4713
4714 Double_t areaJet = TMath::Pi()*rc*rc;
4715 if(areaTotal) normFactor = (Float_t) 1./(areaJet / areaTotal);
4716
4717 outputlist->Sort();
4718}
4719
4720// _______________________________________________________________________________________________________________________
4721void AliAnalysisTaskIDFragmentationFunction::GetClusterTracksMedian(TList* outputlist, Double_t &normFactor)
4722{
4723 // fill tracks from bckgCluster branch,
4724 // using cluster with median density (odd number of clusters)
4725 // or picking randomly one of the two closest to median (even number)
4726
4727 normFactor = 0;
4728
c4856fb1 4729 const Int_t nBckgClusters = fBckgJetsRec->GetEntries(); // not 'recCuts': use all clusters in full eta range
e131b05f 4730
4731 if(nBckgClusters<3) return; // need at least 3 clusters (skipping 2 highest)
4732
4733 Double_t* bgrDensity = new Double_t[nBckgClusters];
4734 Int_t* indices = new Int_t[nBckgClusters];
4735
4736 for(Int_t ij=0; ij<nBckgClusters; ++ij){
4737
4738 AliAODJet* bgrCluster = (AliAODJet*)(fBckgJetsRec->At(ij));
4739 Double_t clusterPt = bgrCluster->Pt();
4740 Double_t area = bgrCluster->EffectiveAreaCharged();
4741
4742 Double_t density = 0;
4743 if(area>0) density = clusterPt/area;
4744
4745 bgrDensity[ij] = density;
4746 indices[ij] = ij;
4747 }
4748
4749 TMath::Sort(nBckgClusters, bgrDensity, indices);
4750
4751 // get median cluster
4752
4753 AliAODJet* medianCluster = 0;
4754 //Double_t medianDensity = 0;
4755
4756 if(TMath::Odd(nBckgClusters)){
4757
4758 Int_t medianIndex = indices[(Int_t) (0.5*(nBckgClusters-1))];
4759 medianCluster = (AliAODJet*)(fBckgJetsRec->At(medianIndex));
4760
4761 //Double_t clusterPt = medianCluster->Pt();
4762 //Double_t area = medianCluster->EffectiveAreaCharged();
4763
4764 //if(area>0) medianDensity = clusterPt/area;
4765 }
4766 else{
4767
4768 Int_t medianIndex1 = indices[(Int_t) (0.5*nBckgClusters-1)];
4769 Int_t medianIndex2 = indices[(Int_t) (0.5*nBckgClusters)];
4770
4771 AliAODJet* medianCluster1 = (AliAODJet*)(fBckgJetsRec->At(medianIndex1));
4772 AliAODJet* medianCluster2 = (AliAODJet*)(fBckgJetsRec->At(medianIndex2));
4773
4774 //Double_t density1 = 0;
4775 //Double_t clusterPt1 = medianCluster1->Pt();
4776 //Double_t area1 = medianCluster1->EffectiveAreaCharged();
4777 //if(area1>0) density1 = clusterPt1/area1;
4778
4779 //Double_t density2 = 0;
4780 //Double_t clusterPt2 = medianCluster2->Pt();
4781 //Double_t area2 = medianCluster2->EffectiveAreaCharged();
4782 //if(area2>0) density2 = clusterPt2/area2;
4783
4784 //medianDensity = 0.5*(density1+density2);
4785
4786 medianCluster = ( (fRandom->Rndm()>0.5) ? medianCluster1 : medianCluster2 ); // select one randomly to avoid adding areas
4787 }
4788
4789 Int_t nTracksJet = medianCluster->GetRefTracks()->GetEntries();
4790
4791 for(Int_t it = 0; it<nTracksJet; it++){
4792
4793 // embedded tracks - note: using ref tracks here, fBranchRecBckgClusters has to be consistent
4794 if( fUseExtraTracksBgr != 1){
4795 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (medianCluster->GetTrack(it))){
4796 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4797 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
4798 }
4799 }
4800
4801 AliVParticle* track = dynamic_cast<AliVParticle*>(medianCluster->GetTrack(it));
4802 if(!track) continue;
4803
4804 Float_t trackPt = track->Pt();
4805 Float_t trackEta = track->Eta();
4806 Float_t trackPhi = TVector2::Phi_0_2pi(track->Phi());
4807
4808 if(trackEta < fTrackEtaMin || trackEta > fTrackEtaMax) continue;
4809 if(trackPhi < fTrackPhiMin || trackPhi > fTrackPhiMax) continue;
4810 if(trackPt < fTrackPtCut) continue;
4811
4812 outputlist->Add(track);
4813 }
4814
4815 Double_t areaMedian = medianCluster->EffectiveAreaCharged();
4816 Double_t areaJet = TMath::Pi()*GetFFRadius()*GetFFRadius();
4817
4818 if(areaMedian) normFactor = (Float_t) 1./(areaJet / areaMedian);
4819
4820 outputlist->Sort();
4821
4822 delete[] bgrDensity;
4823 delete[] indices;
4824}
4825
4826// ______________________________________________________________________________________________________________________________________________________
4827void AliAnalysisTaskIDFragmentationFunction::FillBckgHistos(Int_t type, TList* inputtracklist, TList* inputjetlist, AliAODJet* jet,
4828 AliFragFuncHistos* ffbckghistocuts, AliFragFuncQATrackHistos* qabckghistocuts, TH1F* fh1Mult){
4829
4830 // List of tracks outside jets for background study
4831 TList* tracklistout2jets = new TList();
4832 TList* tracklistout3jets = new TList();
4833 TList* tracklistout2jetsStat = new TList();
4834 TList* tracklistout3jetsStat = new TList();
4835 Double_t sumPtOut2Jets = 0.;
4836 Double_t sumPtOut3Jets = 0.;
4837 Double_t sumPtOut2JetsStat = 0.;
4838 Double_t sumPtOut3JetsStat = 0.;
4839 Double_t normFactor2Jets = 0.;
4840 Double_t normFactor3Jets = 0.;
4841
4842 Int_t nRecJetsCuts = inputjetlist->GetEntries();
4843
4844 if(nRecJetsCuts>1) {
4845 GetTracksOutOfNJets(2,inputtracklist, tracklistout2jets, inputjetlist, sumPtOut2Jets);
4846 GetTracksOutOfNJetsStat(2,inputtracklist, tracklistout2jetsStat, inputjetlist,sumPtOut2JetsStat, normFactor2Jets);
4847
4848 }
4849 if(nRecJetsCuts>2) {
4850 GetTracksOutOfNJets(3,inputtracklist, tracklistout3jets, inputjetlist, sumPtOut3Jets);
4851 GetTracksOutOfNJetsStat(3,inputtracklist, tracklistout3jetsStat, inputjetlist, sumPtOut3JetsStat, normFactor3Jets);
4852 }
4853
4854 if(type==kBckgOutLJ || type==kBckgOutAJ)
4855 {
4856 TList* tracklistoutleading = new TList();
4857 Double_t sumPtOutLeading = 0.;
4858 GetTracksOutOfNJets(1,inputtracklist, tracklistoutleading, inputjetlist, sumPtOutLeading);
4859 if(type==kBckgOutLJ && fh1Mult) fh1Mult->Fill(tracklistoutleading->GetSize());
4860
4861 for(Int_t it=0; it<tracklistoutleading->GetSize(); ++it){
4862
4863 AliVParticle* trackVP = (AliVParticle*)(tracklistoutleading->At(it));
4864 if(!trackVP) continue;
4865 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4866
4867 Float_t jetPt = jet->Pt();
4868 Float_t trackPt = trackV->Pt();
4869
4870 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4871
4872 if(type==kBckgOutLJ)
4873 {
4874 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt);
4875
4876 // Fill track QA for background
4877 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
4878 }
4879
4880 // All cases included
4881 if(nRecJetsCuts==1 && type==kBckgOutAJ)
4882 {
4883 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
4884 }
4885 delete trackV;
4886 }
4887 // Increment jet pt with one entry in case #tracks outside jets = 0
4888 if(tracklistoutleading->GetSize()==0) {
4889 Float_t jetPt = jet->Pt();
4890 Bool_t incrementJetPt = kTRUE;
4891 if(type==kBckgOutLJ)
4892 {
4893 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4894 }
4895 // All cases included
4896 if(nRecJetsCuts==1 && type==kBckgOutAJ)
4897 {
4898 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4899 }
4900 }
4901 delete tracklistoutleading;
4902 }
4903 if(type==kBckgOutLJStat || type==kBckgOutAJStat)
4904 {
4905 TList* tracklistoutleadingStat = new TList();
4906 Double_t sumPtOutLeadingStat = 0.;
4907 Double_t normFactorLeading = 0.;
4908
4909 GetTracksOutOfNJetsStat(1,inputtracklist, tracklistoutleadingStat, inputjetlist, sumPtOutLeadingStat, normFactorLeading);
4910 if(type==kBckgOutLJStat && fh1Mult) fh1Mult->Fill(tracklistoutleadingStat->GetSize());
4911
4912 for(Int_t it=0; it<tracklistoutleadingStat->GetSize(); ++it){
4913
4914 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistoutleadingStat->At(it));
4915 if(!trackVP) continue;
4916 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4917
4918 Float_t jetPt = jet->Pt();
4919 Float_t trackPt = trackV->Pt();
4920 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4921
4922 // Stat plots
4923 if(type==kBckgOutLJStat)
4924 {
4925 if(fFFMode)ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorLeading);
4926
4927 // Fill track QA for background
4928 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt); // OB added bgr QA
4929 }
4930
4931 // All cases included
4932 if(nRecJetsCuts==1 && type==kBckgOutAJStat)
4933 {
4934 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorLeading);
4935 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
4936
4937 }
4938 delete trackV;
4939 }
4940 // Increment jet pt with one entry in case #tracks outside jets = 0
4941 if(tracklistoutleadingStat->GetSize()==0) {
4942 Float_t jetPt = jet->Pt();
4943 Bool_t incrementJetPt = kTRUE;
4944 if(type==kBckgOutLJStat)
4945 {
4946 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorLeading);
4947 }
4948 // All cases included
4949 if(nRecJetsCuts==1 && type==kBckgOutLJStat)
4950 {
4951 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorLeading);
4952 }
4953 }
4954
4955 delete tracklistoutleadingStat;
4956 }
4957
4958 if(type==kBckgPerp || type==kBckgPerp2 || type==kBckgPerp2Area)
4959 {
4960 Double_t sumPtPerp1 = 0.;
4961 Double_t sumPtPerp2 = 0.;
4962 TList* tracklistperp = new TList();
4963 TList* tracklistperp1 = new TList();
4964 TList* tracklistperp2 = new TList();
4965
4966 Double_t norm = 1;
4967 if(type == kBckgPerp2) norm = 2; // in FillFF() scaleFac = 1/norm = 0.5 - account for double area;
4968 if(type == kBckgPerp2Area) norm = 2*TMath::Pi()*TMath::Abs(GetFFRadius())*TMath::Abs(GetFFRadius()) / jet->EffectiveAreaCharged(); // in FillFF() scaleFac = 1/norm;
4969
4970 GetTracksTiltedwrpJetAxis(TMath::Pi()/2., inputtracklist,tracklistperp1,jet,TMath::Abs(GetFFRadius()),sumPtPerp1);
4971 if(type==kBckgPerp2 || type==kBckgPerp2Area) GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2., inputtracklist,tracklistperp2,jet,TMath::Abs(GetFFRadius()),sumPtPerp2);
4972
4973 tracklistperp->AddAll(tracklistperp1);
4974 tracklistperp->AddAll(tracklistperp2);
4975
4976 if(tracklistperp->GetSize() != tracklistperp1->GetSize() + tracklistperp2->GetSize()){
4977 cout<<" ERROR: tracklistperp size "<<tracklistperp->GetSize()<<" perp1 "<<tracklistperp1->GetSize()<<" perp2 "<<tracklistperp2->GetSize()<<endl;
4978 exit(0);
4979 }
4980
4981 if(fh1Mult) fh1Mult->Fill(tracklistperp->GetSize());
4982
4983 for(Int_t it=0; it<tracklistperp->GetSize(); ++it){
4984
4985 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistperp->At(it));
4986 if(!trackVP)continue;
4987 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4988
4989 Float_t jetPt = jet->Pt();
4990 Float_t trackPt = trackV->Pt();
4991
4992 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4993
4994 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, norm );
4995
4996 // Fill track QA for background
4997 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
4998
4999 delete trackV;
5000 }
5001 // Increment jet pt with one entry in case #tracks outside jets = 0
5002 if(tracklistperp->GetSize()==0) {
5003 Float_t jetPt = jet->Pt();
5004 Bool_t incrementJetPt = kTRUE;
5005 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5006 }
5007
5008
5009 if(fJSMode){
5010 // fill for tracklistperp1/2 separately, divide norm by 2
5011 if(type==kBckgPerp){
5012 FillJetShape(jet, tracklistperp, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, TMath::Pi()/2., 0., kFALSE);
5013 }
5014 if(type==kBckgPerp2){
5015 FillJetShape(jet, tracklistperp1, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, TMath::Pi()/2., 0., kFALSE);
5016 FillJetShape(jet, tracklistperp2, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, -1*TMath::Pi()/2., 0., kFALSE);
5017 }
5018 if(type==kBckgPerp2Area){ // divide norm by 2: listperp1/2 filled separately
5019 FillJetShape(jet, tracklistperp1, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, TMath::Pi()/2., 0.5*norm, kFALSE);
5020 FillJetShape(jet, tracklistperp2, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, -1*TMath::Pi()/2., 0.5*norm, kFALSE);
5021 }
5022 }
5023
5024 delete tracklistperp;
5025 delete tracklistperp1;
5026 delete tracklistperp2;
5027 }
5028
5029 if(type==kBckgASide)
5030 {
5031 Double_t sumPtASide = 0.;
5032 TList* tracklistaside = new TList();
5033 GetTracksTiltedwrpJetAxis(TMath::Pi(),inputtracklist,tracklistaside,jet,TMath::Abs(GetFFRadius()),sumPtASide);
5034 if(fh1Mult) fh1Mult->Fill(tracklistaside->GetSize());
5035
5036 for(Int_t it=0; it<tracklistaside->GetSize(); ++it){
5037
5038 AliVParticle* trackVP = (AliVParticle*)(tracklistaside->At(it));
5039 if(!trackVP) continue;
5040 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5041
5042 Float_t jetPt = jet->Pt();
5043 Float_t trackPt = trackV->Pt();
5044
5045 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5046
5047 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
5048
5049 // Fill track QA for background
5050 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
5051
5052 delete trackV;
5053 }
5054 if(tracklistaside->GetSize()==0) {
5055 Float_t jetPt = jet->Pt();
5056 Bool_t incrementJetPt = kTRUE;
5057 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5058 }
5059
5060 delete tracklistaside;
5061 }
5062
5063 if(type==kBckgASideWindow)
5064 {
5065 Double_t normFactorASide = 0.;
5066 Double_t sumPtASideW = 0.;
5067 TList* tracklistasidew = new TList();
5068 GetTracksTiltedwrpJetAxisWindow(TMath::Pi(),inputtracklist,tracklistasidew,jet,TMath::Abs(GetFFRadius()),sumPtASideW,normFactorASide);
5069 if(fh1Mult) fh1Mult->Fill(tracklistasidew->GetSize());
5070
5071 for(Int_t it=0; it<tracklistasidew->GetSize(); ++it){
5072
5073 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistasidew->At(it));
5074 if(!trackVP) continue;
5075 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5076
5077 Float_t jetPt = jet->Pt();
5078 Float_t trackPt = trackV->Pt();
5079 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5080
5081 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorASide);
5082
5083 // Fill track QA for background
5084 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt, kFALSE, normFactorASide);
5085
5086 delete trackV;
5087 }
5088 if(tracklistasidew->GetSize()==0) {
5089 Float_t jetPt = jet->Pt();
5090 Bool_t incrementJetPt = kTRUE;
5091 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorASide);
5092 }
5093
5094 delete tracklistasidew;
5095 }
5096
5097 if(type==kBckgPerpWindow)
5098 {
5099 Double_t normFactorPerp = 0.;
5100 Double_t sumPtPerpW = 0.;
5101 TList* tracklistperpw = new TList();
5102 GetTracksTiltedwrpJetAxisWindow(TMath::Pi()/2.,inputtracklist,tracklistperpw,jet,TMath::Abs(GetFFRadius()),sumPtPerpW,normFactorPerp);
5103 if(fh1Mult) fh1Mult->Fill(tracklistperpw->GetSize());
5104
5105 for(Int_t it=0; it<tracklistperpw->GetSize(); ++it){
5106
5107 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistperpw->At(it));
5108 if(!trackVP) continue;
5109 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5110
5111 Float_t jetPt = jet->Pt();
5112 Float_t trackPt = trackV->Pt();
5113 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5114
5115 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorPerp);
5116
5117 // Fill track QA for background
5118 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt, kFALSE, normFactorPerp);
5119
5120 delete trackV;
5121 }
5122 if(tracklistperpw->GetSize()==0) {
5123 Float_t jetPt = jet->Pt();
5124 Bool_t incrementJetPt = kTRUE;
5125 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorPerp);
5126 }
5127
5128 delete tracklistperpw;
5129 }
5130
5131
5132 if(type==kBckgOut2J || type==kBckgOutAJ)
5133 {
5134 if(type==kBckgOut2J && fh1Mult) fh1Mult->Fill(tracklistout2jets->GetSize());
5135 for(Int_t it=0; it<tracklistout2jets->GetSize(); ++it){
5136
5137 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout2jets->At(it));
5138 if(!trackVP) continue;
5139 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5140
5141 Float_t jetPt = jet->Pt();
5142 Float_t trackPt = trackV->Pt();
5143
5144 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5145
5146 if(type==kBckgOut2J)
5147 {
5148 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
5149 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
5150 }
5151
5152 // All cases included
5153 if(nRecJetsCuts==2 && type==kBckgOutAJ)
5154 {
5155 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
5156
5157 }
5158 delete trackV;
5159 }
5160 // Increment jet pt with one entry in case #tracks outside jets = 0
5161 if(tracklistout2jets->GetSize()==0) {
5162 Float_t jetPt = jet->Pt();
5163 Bool_t incrementJetPt = kTRUE;
5164 if(type==kBckgOut2J)
5165 {
5166 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5167 }
5168 // All cases included
5169 if(nRecJetsCuts==2 && type==kBckgOutAJ)
5170 {
5171 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5172 }
5173 }
5174 }
5175
5176 if(type==kBckgOut2JStat || type==kBckgOutAJStat)
5177 {
5178 for(Int_t it=0; it<tracklistout2jetsStat->GetSize(); ++it){
5179
5180 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout2jetsStat->At(it));
5181 if(!trackVP) continue;
5182 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5183
5184 Float_t jetPt = jet->Pt();
5185 Float_t trackPt = trackV->Pt();
5186 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5187
5188 if(type==kBckgOut2JStat)
5189 {
5190 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor2Jets);
5191
5192 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
5193 }
5194
5195 // All cases included
5196 if(nRecJetsCuts==2 && type==kBckgOutAJStat)
5197 {
5198 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor2Jets);
5199
5200 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
5201 }
5202 delete trackV;
5203 }
5204 // Increment jet pt with one entry in case #tracks outside jets = 0
5205 if(tracklistout2jetsStat->GetSize()==0) {
5206 Float_t jetPt = jet->Pt();
5207 Bool_t incrementJetPt = kTRUE;
5208 if(type==kBckgOut2JStat)
5209 {
5210 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor2Jets);
5211 }
5212 // All cases included
5213 if(nRecJetsCuts==2 && type==kBckgOutAJStat)
5214 {
5215 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor2Jets);
5216 }
5217 }
5218
5219 }
5220
5221 if(type==kBckgOut3J || type==kBckgOutAJ)
5222 {
5223 if(type==kBckgOut3J && fh1Mult) fh1Mult->Fill(tracklistout3jets->GetSize());
5224
5225 for(Int_t it=0; it<tracklistout3jets->GetSize(); ++it){
5226
5227 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout3jets->At(it));
5228 if(!trackVP) continue;
5229 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5230
5231 Float_t jetPt = jet->Pt();
5232 Float_t trackPt = trackV->Pt();
5233
5234 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5235
5236 if(type==kBckgOut3J)
5237 {
5238 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
5239
5240 qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
5241 }
5242
5243 // All cases included
5244 if(nRecJetsCuts==3 && type==kBckgOutAJ)
5245 {
5246 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
5247
5248 }
5249 delete trackV;
5250 }
5251 // Increment jet pt with one entry in case #tracks outside jets = 0
5252 if(tracklistout3jets->GetSize()==0) {
5253 Float_t jetPt = jet->Pt();
5254 Bool_t incrementJetPt = kTRUE;
5255 if(type==kBckgOut3J)
5256 {
5257 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5258 }
5259 // All cases included
5260 if(nRecJetsCuts==3 && type==kBckgOutAJ)
5261 {
5262 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
5263 }
5264 }
5265 }
5266
5267 if(type==kBckgOut3JStat || type==kBckgOutAJStat)
5268 {
5269 for(Int_t it=0; it<tracklistout3jetsStat->GetSize(); ++it){
5270
5271 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout3jetsStat->At(it));
5272 if(!trackVP) continue;
5273 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5274
5275 Float_t jetPt = jet->Pt();
5276 Float_t trackPt = trackV->Pt();
5277 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5278
5279 if(type==kBckgOut3JStat)
5280 {
5281 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor3Jets);
5282
5283 //if(fQAMode&1) qabckghistocuts->FillTrackQA( trackEta, TVector2::Phi_0_2pi(trackPhi), trackPt);
5284 }
5285
5286 // All cases included
5287 if(nRecJetsCuts==3 && type==kBckgOutAJStat)
5288 {
5289 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor3Jets );
5290
5291 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
5292
5293 }
5294 delete trackV;
5295 }
5296 // Increment jet pt with one entry in case #tracks outside jets = 0
5297 if(tracklistout3jetsStat->GetSize()==0) {
5298 Float_t jetPt = jet->Pt();
5299 Bool_t incrementJetPt = kTRUE;
5300 if(type==kBckgOut3JStat)
5301 {
5302 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor3Jets);
5303 }
5304 // All cases included
5305 if(nRecJetsCuts==3 && type==kBckgOutAJStat)
5306 {
5307 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor3Jets);
5308 }
5309 }
5310
5311 }
5312
5313 if(type==kBckgClustersOutLeading){ // clusters bgr: all tracks in clusters out of leading jet
5314
5315 TList* tracklistClustersOutLeading = new TList();
5316 Double_t normFactorClusters = 0;
5317 Float_t jetPt = jet->Pt();
5318
5319 GetClusterTracksOutOf1Jet(jet, tracklistClustersOutLeading, normFactorClusters);
5320 if(fh1Mult) fh1Mult->Fill(tracklistClustersOutLeading->GetSize());
5321
5322 for(Int_t it=0; it<tracklistClustersOutLeading->GetSize(); ++it){
5323
5324 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistClustersOutLeading->At(it));
5325 if(!trackVP) continue;
5326 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5327
5328 Float_t trackPt = trackVP->Pt();
5329
5330 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5331
5332 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorClusters );
5333 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
5334
5335 delete trackV;
5336 }
5337
5338 delete tracklistClustersOutLeading;
5339
5340 }
5341
5342 if(type == kBckgClusters){ // clusters bgr: all tracks in 'median cluster'
5343
5344 TList* tracklistClustersMedian = new TList();
5345 Double_t normFactorClusters = 0;
5346 Float_t jetPt = jet->Pt();
5347
5348 GetClusterTracksMedian(tracklistClustersMedian, normFactorClusters);
5349 if(fh1Mult) fh1Mult->Fill(tracklistClustersMedian->GetSize());
5350
5351 for(Int_t it=0; it<tracklistClustersMedian->GetSize(); ++it){
5352
5353 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistClustersMedian->At(it));
5354 if(!trackVP) continue;
5355 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
5356
5357 Float_t trackPt = trackVP->Pt();
5358
5359 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
5360
5361 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorClusters );
5362 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
5363
5364 delete trackV;
5365 }
5366
5367 delete tracklistClustersMedian;
5368 }
5369
5370 delete tracklistout2jets;
5371 delete tracklistout3jets;
5372 delete tracklistout2jetsStat;
5373 delete tracklistout3jetsStat;
5374}
5375
5376//_____________________________________________________________________________________
9d7ad2e4 5377Double_t AliAnalysisTaskIDFragmentationFunction::GetMCStrangenessFactor(Double_t pt) const
e131b05f 5378{
5379 // factor strangeness data/MC as function of pt from UE analysis (Sara Vallero)
5380
5381 Double_t alpha = 1;
5382
5383 if(0.150<pt && pt<0.200) alpha = 3.639;
5384 if(0.200<pt && pt<0.250) alpha = 2.097;
5385 if(0.250<pt && pt<0.300) alpha = 1.930;
5386 if(0.300<pt && pt<0.350) alpha = 1.932;
5387 if(0.350<pt && pt<0.400) alpha = 1.943;
5388 if(0.400<pt && pt<0.450) alpha = 1.993;
5389 if(0.450<pt && pt<0.500) alpha = 1.989;
5390 if(0.500<pt && pt<0.600) alpha = 1.963;
5391 if(0.600<pt && pt<0.700) alpha = 1.917;
5392 if(0.700<pt && pt<0.800) alpha = 1.861;
5393 if(0.800<pt && pt<0.900) alpha = 1.820;
5394 if(0.900<pt && pt<1.000) alpha = 1.741;
5395 if(1.000<pt && pt<1.500) alpha = 0.878;
5396
5397 return alpha;
5398}
5399
5400//__________________________________________________________________________________________________
5401Double_t AliAnalysisTaskIDFragmentationFunction::GetMCStrangenessFactorCMS(AliAODMCParticle* daughter) const
5402{
5403 // strangeness ratio MC/data as function of mother pt from CMS data in |eta|<2.0
5404
5405 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
5406 if(!tca) return 1;
5407
5408 AliAODMCParticle* currentMother = daughter;
5409 AliAODMCParticle* currentDaughter = daughter;
5410
5411
5412 // find first primary mother K0s, Lambda or Xi
5413 while(1){
5414
5415 Int_t daughterPDG = currentDaughter->GetPdgCode();
5416
5417 Int_t motherLabel = currentDaughter->GetMother();
5418 if(motherLabel >= tca->GetEntriesFast()){ // protection
5419 currentMother = currentDaughter;
5420 break;
5421 }
5422
5423 currentMother = (AliAODMCParticle*) tca->At(motherLabel);
5424
5425 if(!currentMother){
5426 currentMother = currentDaughter;
5427 break;
5428 }
5429
5430 Int_t motherPDG = currentMother->GetPdgCode();
5431
5432 // phys. primary found ?
5433 if(currentMother->IsPhysicalPrimary()) break;
5434
5435 if(TMath::Abs(daughterPDG) == 321){ // K+/K- e.g. from phi (ref data not feeddown corrected)
5436 currentMother = currentDaughter; break;
5437 }
5438 if(TMath::Abs(motherPDG) == 310 ){ // K0s e.g. from phi (ref data not feeddown corrected)
5439 break;
5440 }
5441 if(TMath::Abs(motherPDG) == 3212 && TMath::Abs(daughterPDG) == 3122){ // mother Sigma0, daughter Lambda (this case not included in feeddown corr.)
5442 currentMother = currentDaughter; break;
5443 }
5444
5445 currentDaughter = currentMother;
5446 }
5447
5448
5449 Int_t motherPDG = currentMother->GetPdgCode();
5450 Double_t motherGenPt = currentMother->Pt();
5451
5452 return AliAnalysisTaskPID::GetMCStrangenessFactorCMS(motherPDG, motherGenPt);
5453}
5454
5455// _________________________________________________________________________________
5456void AliAnalysisTaskIDFragmentationFunction::FillJetShape(AliAODJet* jet, TList* list,
5457 TProfile* hProNtracksLeadingJet, TProfile** hProDelRPtSum, TProfile* hProDelR80pcPt,
5458 Double_t dPhiUE, Double_t normUE, Bool_t scaleStrangeness)
5459{
5460 // Fill jet shape histos
5461
5462 const Int_t kNbinsR = 50;
5463 const Float_t kBinWidthR = 0.02;
5464
5465 Int_t nJetTracks = list->GetEntries();
5466
5467 Float_t pTsumA[kNbinsR] = {0.0};
5468
5469 Float_t *delRA = new Float_t[nJetTracks];
5470 Float_t *trackPtA = new Float_t[nJetTracks];
5471 Int_t *index = new Int_t[nJetTracks];
5472
5473 for(Int_t i=0; i<nJetTracks; i++){
5474 delRA[i] = 0;
5475 trackPtA[i] = 0;
5476 index[i] = 0;
5477 }
5478
5479 Double_t jetMom[3];
5480 jet->PxPyPz(jetMom);
5481 TVector3 jet3mom(jetMom);
5482
5483 if(TMath::Abs(dPhiUE)>0){
5484 Double_t phiTilted = jet3mom.Phi();
5485 phiTilted += dPhiUE;
5486 phiTilted = TVector2::Phi_0_2pi(phiTilted);
5487 jet3mom.SetPhi(phiTilted);
5488 }
5489
5490 Double_t jetPt = jet->Pt();
5491 Double_t sumWeights = 0;
5492
5493 for (Int_t j =0; j<nJetTracks; j++){
5494
5495 AliVParticle* track = dynamic_cast<AliVParticle*>(list->At(j));
5496 if(!track)continue;
5497
5498 Double_t trackMom[3];
5499 track->PxPyPz(trackMom);
5500 TVector3 track3mom(trackMom);
5501
5502 Double_t dR = jet3mom.DeltaR(track3mom);
5503
5504 delRA[j] = dR;
5505 trackPtA[j] = track->Pt();
5506
5507 Double_t weight = GetMCStrangenessFactor(track->Pt()); // more correctly should be gen pt
5508 sumWeights += weight;
5509
5510 for(Int_t ibin=1; ibin<=kNbinsR; ibin++){
5511 Float_t xlow = kBinWidthR*(ibin-1);
5512 Float_t xup = kBinWidthR*ibin;
5513 if(xlow <= dR && dR < xup){
5514
5515 if(scaleStrangeness) pTsumA[ibin-1] += track->Pt()*weight;
5516 else pTsumA[ibin-1] += track->Pt();
5517 }
5518 }
5519 } // track loop
5520
5521 Float_t jetPtMin=0;
5522 Float_t jetPtMax=0;
5523
5524 for(Int_t ibin=0; ibin<kNbinsR; ibin++){
5525 Float_t fR = kBinWidthR*(ibin+0.5);
5526
5527 for(Int_t k=0; k<5; k++){
5528 if(k==0){jetPtMin=20.0;jetPtMax=30.0;}
5529 if(k==1){jetPtMin=30.0;jetPtMax=40.0;}
5530 if(k==2){jetPtMin=40.0;jetPtMax=60.0;}
5531 if(k==3){jetPtMin=60.0;jetPtMax=80.0;}
5532 if(k==4){jetPtMin=80.0;jetPtMax=100.0;}
5533 if(jetPt>jetPtMin && jetPt<jetPtMax){
5534
5535 hProDelRPtSum[k]->Fill(fR,pTsumA[ibin]);
5536
5537 }
5538 }
5539 }
5540
5541 if(scaleStrangeness) hProNtracksLeadingJet->Fill(jetPt,sumWeights);
5542 else hProNtracksLeadingJet->Fill(jetPt,nJetTracks);
5543
5544 if(normUE) hProNtracksLeadingJet->Fill(jetPt,nJetTracks/normUE);
5545
5546 if(hProDelR80pcPt){
5547
5548 Float_t pTsum = 0;
5549 Float_t delRPtSum80pc = 0;
5550
5551 TMath::Sort(nJetTracks,delRA,index,0);
5552
5553 for(Int_t ii=0; ii<nJetTracks; ii++){
5554
5555 if(scaleStrangeness){
5556 Double_t weight = GetMCStrangenessFactor(trackPtA[index[ii]]); // more correctly should be gen pt
5557 pTsum += weight*trackPtA[index[ii]];
5558 }
5559 else pTsum += trackPtA[index[ii]];
5560
5561
5562 if(pTsum/jetPt >= 0.8000){
5563 delRPtSum80pc = delRA[index[ii]];
5564 break;
5565 }
5566 }
5567 hProDelR80pcPt->Fill(jetPt,delRPtSum80pc);
5568 }
5569
5570 delete[] delRA;
5571 delete[] trackPtA;
5572 delete[] index;
5573}
5574
5575
5576// _________________________________________________________________________________
5577Bool_t AliAnalysisTaskIDFragmentationFunction::IsSecondaryWithStrangeMotherMC(AliAODMCParticle* part)
5578{
5579 // Check whether particle is a secondary with strange mother, i.e. returns kTRUE if a strange mother is found
5580 // and the particle is NOT a physical primary. In all other cases kFALSE is returned
5581
5582 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
5583 if (!tca || !part)
5584 return kFALSE;
5585
5586 if (part->IsPhysicalPrimary())
5587 return kFALSE;
5588
5589 Int_t iMother = part->GetMother();
5590 if (iMother < 0)
5591 return kFALSE;
5592
5593
5594 AliAODMCParticle* partM = dynamic_cast<AliAODMCParticle*>(tca->At(iMother));
5595 if (!partM)
5596 return kFALSE;
5597
5598 Int_t codeM = TMath::Abs(partM->GetPdgCode());
5599 Int_t mfl = Int_t(codeM / TMath::Power(10, Int_t(TMath::Log10(codeM))));
5600 if (mfl == 3 && codeM != 3) // codeM = 3 is for s quark
5601 return kTRUE;
5602
5603 return kFALSE;
5604}