1 // *************************************************************************
3 // * Task for Fragmentation Function Analysis in PWG4 Jet Task Force Train *
5 // *************************************************************************
8 /**************************************************************************
9 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
11 * Author: The ALICE Off-line Project. *
12 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
30 #include "THnSparse.h"
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"
47 #include "AliAnalysisHelperJetTasks.h"
48 #include "AliAnalysisManager.h"
49 #include "AliAnalysisTaskSE.h"
50 #include "AliVParticle.h"
51 #include "AliVEvent.h"
53 #include "AliAnalysisTaskFragmentationFunction.h"
58 ClassImp(AliAnalysisTaskFragmentationFunction)
60 //____________________________________________________________________________
61 AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction()
68 ,fBranchRecJets("jets")
69 ,fBranchRecBckgClusters("")
71 ,fBranchEmbeddedJets("")
75 ,fUseAODInputJets(kTRUE)
77 ,fUsePhysicsSelection(kTRUE)
87 ,fUseExtraTracksBgr(0)
88 ,fCutFractionPtEmbedded(0)
89 ,fUseEmbeddedJetAxis(0)
109 ,fTracksAODMCCharged(0)
110 ,fTracksAODMCChargedSecNS(0)
111 ,fTracksAODMCChargedSecS(0)
112 ,fTracksRecQualityCuts(0)
121 ,fQATrackHistosRecCuts(0)
122 ,fQATrackHistosGen(0)
124 ,fQAJetHistosRecCuts(0)
125 ,fQAJetHistosRecCutsLeading(0)
127 ,fQAJetHistosGenLeading(0)
128 ,fQAJetHistosRecEffLeading(0)
131 ,fQATrackHighPtThreshold(0)
164 ,fh1VertexNContributors(0)
176 ,fh1nRecBckgJetsCuts(0)
178 ,fh2PtRecVsGenPrim(0)
180 ,fQATrackHistosRecEffGen(0)
181 ,fQATrackHistosRecEffRec(0)
182 ,fQATrackHistosSecRecNS(0)
183 ,fQATrackHistosSecRecS(0)
184 ,fQATrackHistosSecRecSsc(0)
185 ,fFFHistosRecEffRec(0)
186 ,fFFHistosSecRecNS(0)
188 ,fFFHistosSecRecSsc(0)
195 ,fh1FractionPtEmbedded(0)
197 ,fh2DeltaPtVsJetPtEmbedded(0)
198 ,fh2DeltaPtVsRecJetPtEmbedded(0)
199 ,fh1DeltaREmbedded(0)
200 ,fQABckgHisto0RecCuts(0)
202 ,fQABckgHisto1RecCuts(0)
204 ,fQABckgHisto2RecCuts(0)
206 ,fQABckgHisto3RecCuts(0)
208 ,fQABckgHisto4RecCuts(0)
210 ,fFFBckgHisto0RecCuts(0)
212 ,fFFBckgHisto1RecCuts(0)
214 ,fFFBckgHisto2RecCuts(0)
216 ,fFFBckgHisto3RecCuts(0)
218 ,fFFBckgHisto4RecCuts(0)
220 ,fFFBckgHisto0RecEffRec(0)
221 ,fFFBckgHisto0SecRecNS(0)
222 ,fFFBckgHisto0SecRecS(0)
223 ,fFFBckgHisto0SecRecSsc(0)
225 ,fProNtracksLeadingJet(0)
227 ,fProNtracksLeadingJetGen(0)
228 ,fProDelR80pcPtGen(0)
229 ,fProNtracksLeadingJetBgrPerp2(0)
230 ,fProNtracksLeadingJetRecPrim(0)
231 ,fProDelR80pcPtRecPrim(0)
232 ,fProNtracksLeadingJetRecSecNS(0)
233 ,fProNtracksLeadingJetRecSecS(0)
234 ,fProNtracksLeadingJetRecSecSsc(0)
238 // default constructor
245 for(Int_t ii=0; ii<5; ii++){
246 fProDelRPtSum[ii] = 0;
247 fProDelRPtSumGen[ii] = 0;
248 fProDelRPtSumBgrPerp2[ii] = 0;
249 fProDelRPtSumRecPrim[ii] = 0;
250 fProDelRPtSumRecSecNS[ii] = 0;
251 fProDelRPtSumRecSecS[ii] = 0;
252 fProDelRPtSumRecSecSsc[ii] = 0;
256 //_______________________________________________________________________________________________
257 AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const char *name)
258 : AliAnalysisTaskSE(name)
264 ,fBranchRecJets("jets")
265 ,fBranchRecBckgClusters("")
267 ,fBranchEmbeddedJets("")
271 ,fUseAODInputJets(kTRUE)
273 ,fUsePhysicsSelection(kTRUE)
274 ,fEvtSelectionMask(0)
283 ,fUseExtraTracksBgr(0)
284 ,fCutFractionPtEmbedded(0)
285 ,fUseEmbeddedJetAxis(0)
286 ,fUseEmbeddedJetPt(0)
305 ,fTracksAODMCCharged(0)
306 ,fTracksAODMCChargedSecNS(0)
307 ,fTracksAODMCChargedSecS(0)
308 ,fTracksRecQualityCuts(0)
317 ,fQATrackHistosRecCuts(0)
318 ,fQATrackHistosGen(0)
320 ,fQAJetHistosRecCuts(0)
321 ,fQAJetHistosRecCutsLeading(0)
323 ,fQAJetHistosGenLeading(0)
324 ,fQAJetHistosRecEffLeading(0)
327 ,fQATrackHighPtThreshold(0)
360 ,fh1VertexNContributors(0)
372 ,fh1nRecBckgJetsCuts(0)
374 ,fh2PtRecVsGenPrim(0)
376 ,fQATrackHistosRecEffGen(0)
377 ,fQATrackHistosRecEffRec(0)
378 ,fQATrackHistosSecRecNS(0)
379 ,fQATrackHistosSecRecS(0)
380 ,fQATrackHistosSecRecSsc(0)
381 ,fFFHistosRecEffRec(0)
382 ,fFFHistosSecRecNS(0)
384 ,fFFHistosSecRecSsc(0)
391 ,fh1FractionPtEmbedded(0)
393 ,fh2DeltaPtVsJetPtEmbedded(0)
394 ,fh2DeltaPtVsRecJetPtEmbedded(0)
395 ,fh1DeltaREmbedded(0)
396 ,fQABckgHisto0RecCuts(0)
398 ,fQABckgHisto1RecCuts(0)
400 ,fQABckgHisto2RecCuts(0)
402 ,fQABckgHisto3RecCuts(0)
404 ,fQABckgHisto4RecCuts(0)
406 ,fFFBckgHisto0RecCuts(0)
408 ,fFFBckgHisto1RecCuts(0)
410 ,fFFBckgHisto2RecCuts(0)
412 ,fFFBckgHisto3RecCuts(0)
414 ,fFFBckgHisto4RecCuts(0)
416 ,fFFBckgHisto0RecEffRec(0)
417 ,fFFBckgHisto0SecRecNS(0)
418 ,fFFBckgHisto0SecRecS(0)
419 ,fFFBckgHisto0SecRecSsc(0)
421 ,fProNtracksLeadingJet(0)
423 ,fProNtracksLeadingJetGen(0)
424 ,fProDelR80pcPtGen(0)
425 ,fProNtracksLeadingJetBgrPerp2(0)
426 ,fProNtracksLeadingJetRecPrim(0)
427 ,fProDelR80pcPtRecPrim(0)
428 ,fProNtracksLeadingJetRecSecNS(0)
429 ,fProNtracksLeadingJetRecSecS(0)
430 ,fProNtracksLeadingJetRecSecSsc(0)
440 for(Int_t ii=0; ii<5; ii++){
441 fProDelRPtSum[ii] = 0;
442 fProDelRPtSumGen[ii] = 0;
443 fProDelRPtSumBgrPerp2[ii] = 0;
444 fProDelRPtSumRecPrim[ii] = 0;
445 fProDelRPtSumRecSecNS[ii] = 0;
446 fProDelRPtSumRecSecS[ii] = 0;
447 fProDelRPtSumRecSecSsc[ii] = 0;
450 DefineOutput(1,TList::Class());
453 //__________________________________________________________________________________________________________________________
454 AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(const AliAnalysisTaskFragmentationFunction ©)
455 : AliAnalysisTaskSE()
458 ,fAODJets(copy.fAODJets)
459 ,fAODExtension(copy.fAODExtension)
460 ,fNonStdFile(copy.fNonStdFile)
461 ,fBranchRecJets(copy.fBranchRecJets)
462 ,fBranchRecBckgClusters(copy.fBranchRecBckgClusters)
463 ,fBranchGenJets(copy.fBranchGenJets)
464 ,fBranchEmbeddedJets(copy.fBranchEmbeddedJets)
465 ,fTrackTypeGen(copy.fTrackTypeGen)
466 ,fJetTypeGen(copy.fJetTypeGen)
467 ,fJetTypeRecEff(copy.fJetTypeRecEff)
468 ,fUseAODInputJets(copy.fUseAODInputJets)
469 ,fFilterMask(copy.fFilterMask)
470 ,fUsePhysicsSelection(copy.fUsePhysicsSelection)
471 ,fEvtSelectionMask(copy.fEvtSelectionMask)
472 ,fEventClass(copy.fEventClass)
473 ,fMaxVertexZ(copy.fMaxVertexZ)
474 ,fTrackPtCut(copy.fTrackPtCut)
475 ,fTrackEtaMin(copy.fTrackEtaMin)
476 ,fTrackEtaMax(copy.fTrackEtaMax)
477 ,fTrackPhiMin(copy.fTrackPhiMin)
478 ,fTrackPhiMax(copy.fTrackPhiMax)
479 ,fUseExtraTracks(copy.fUseExtraTracks)
480 ,fUseExtraTracksBgr(copy.fUseExtraTracksBgr)
481 ,fCutFractionPtEmbedded(copy.fCutFractionPtEmbedded)
482 ,fUseEmbeddedJetAxis(copy.fUseEmbeddedJetAxis)
483 ,fUseEmbeddedJetPt(copy.fUseEmbeddedJetPt)
484 ,fJetPtCut(copy.fJetPtCut)
485 ,fJetEtaMin(copy.fJetEtaMin)
486 ,fJetEtaMax(copy.fJetEtaMax)
487 ,fJetPhiMin(copy.fJetPhiMin)
488 ,fJetPhiMax(copy.fJetPhiMax)
489 ,fFFRadius(copy.fFFRadius)
490 ,fFFMinLTrackPt(copy.fFFMinLTrackPt)
491 ,fFFMaxTrackPt(copy.fFFMaxTrackPt)
492 ,fFFMinnTracks(copy.fFFMinnTracks)
493 ,fFFBckgRadius(copy.fFFBckgRadius)
494 ,fBckgMode(copy.fBckgMode)
495 ,fQAMode(copy.fQAMode)
496 ,fFFMode(copy.fFFMode)
497 ,fEffMode(copy.fEffMode)
498 ,fJSMode(copy.fJSMode)
499 ,fAvgTrials(copy.fAvgTrials)
500 ,fTracksRecCuts(copy.fTracksRecCuts)
501 ,fTracksGen(copy.fTracksGen)
502 ,fTracksAODMCCharged(copy.fTracksAODMCCharged)
503 ,fTracksAODMCChargedSecNS(copy.fTracksAODMCChargedSecNS)
504 ,fTracksAODMCChargedSecS(copy.fTracksAODMCChargedSecS)
505 ,fTracksRecQualityCuts(copy.fTracksRecQualityCuts)
506 ,fJetsRec(copy.fJetsRec)
507 ,fJetsRecCuts(copy.fJetsRecCuts)
508 ,fJetsGen(copy.fJetsGen)
509 ,fJetsRecEff(copy.fJetsRecEff)
510 ,fJetsEmbedded(copy.fJetsEmbedded)
511 ,fBckgJetsRec(copy.fBckgJetsRec)
512 ,fBckgJetsRecCuts(copy.fBckgJetsRecCuts)
513 ,fBckgJetsGen(copy.fBckgJetsGen)
514 ,fQATrackHistosRecCuts(copy.fQATrackHistosRecCuts)
515 ,fQATrackHistosGen(copy.fQATrackHistosGen)
516 ,fQAJetHistosRec(copy.fQAJetHistosRec)
517 ,fQAJetHistosRecCuts(copy.fQAJetHistosRecCuts)
518 ,fQAJetHistosRecCutsLeading(copy.fQAJetHistosRecCutsLeading)
519 ,fQAJetHistosGen(copy.fQAJetHistosGen)
520 ,fQAJetHistosGenLeading(copy.fQAJetHistosGenLeading)
521 ,fQAJetHistosRecEffLeading(copy.fQAJetHistosRecEffLeading)
522 ,fFFHistosRecCuts(copy.fFFHistosRecCuts)
523 ,fFFHistosGen(copy.fFFHistosGen)
524 ,fQATrackHighPtThreshold(copy.fQATrackHighPtThreshold)
525 ,fFFNBinsJetPt(copy.fFFNBinsJetPt)
526 ,fFFJetPtMin(copy.fFFJetPtMin)
527 ,fFFJetPtMax(copy.fFFJetPtMax)
528 ,fFFNBinsPt(copy.fFFNBinsPt)
529 ,fFFPtMin(copy.fFFPtMin)
530 ,fFFPtMax(copy.fFFPtMax)
531 ,fFFNBinsXi(copy.fFFNBinsXi)
532 ,fFFXiMin(copy.fFFXiMin)
533 ,fFFXiMax(copy.fFFXiMax)
534 ,fFFNBinsZ(copy.fFFNBinsZ)
535 ,fFFZMin(copy.fFFZMin)
536 ,fFFZMax(copy.fFFZMax)
537 ,fQAJetNBinsPt(copy.fQAJetNBinsPt)
538 ,fQAJetPtMin(copy.fQAJetPtMin)
539 ,fQAJetPtMax(copy.fQAJetPtMax)
540 ,fQAJetNBinsEta(copy.fQAJetNBinsEta)
541 ,fQAJetEtaMin(copy.fQAJetEtaMin)
542 ,fQAJetEtaMax(copy.fQAJetEtaMax)
543 ,fQAJetNBinsPhi(copy.fQAJetNBinsPhi)
544 ,fQAJetPhiMin(copy.fQAJetPhiMin)
545 ,fQAJetPhiMax(copy.fQAJetPhiMax)
546 ,fQATrackNBinsPt(copy.fQATrackNBinsPt)
547 ,fQATrackPtMin(copy.fQATrackPtMin)
548 ,fQATrackPtMax(copy.fQATrackPtMax)
549 ,fQATrackNBinsEta(copy.fQATrackNBinsEta)
550 ,fQATrackEtaMin(copy.fQATrackEtaMin)
551 ,fQATrackEtaMax(copy.fQATrackEtaMax)
552 ,fQATrackNBinsPhi(copy.fQATrackNBinsPhi)
553 ,fQATrackPhiMin(copy.fQATrackPhiMin)
554 ,fQATrackPhiMax(copy.fQATrackPhiMax)
555 ,fCommonHistList(copy.fCommonHistList)
556 ,fh1EvtSelection(copy.fh1EvtSelection)
557 ,fh1VertexNContributors(copy.fh1VertexNContributors)
558 ,fh1VertexZ(copy.fh1VertexZ)
559 ,fh1EvtMult(copy.fh1EvtMult)
560 ,fh1EvtCent(copy.fh1EvtCent)
561 ,fh1Xsec(copy.fh1Xsec)
562 ,fh1Trials(copy.fh1Trials)
563 ,fh1PtHard(copy.fh1PtHard)
564 ,fh1PtHardTrials(copy.fh1PtHardTrials)
565 ,fh1nRecJetsCuts(copy.fh1nRecJetsCuts)
566 ,fh1nGenJets(copy.fh1nGenJets)
567 ,fh1nRecEffJets(copy.fh1nRecEffJets)
568 ,fh1nEmbeddedJets(copy.fh1nEmbeddedJets)
569 ,fh1nRecBckgJetsCuts(copy.fh1nRecBckgJetsCuts)
570 ,fh1nGenBckgJets(copy.fh1nGenBckgJets)
571 ,fh2PtRecVsGenPrim(copy.fh2PtRecVsGenPrim)
572 ,fh2PtRecVsGenSec(copy.fh2PtRecVsGenSec)
573 ,fQATrackHistosRecEffGen(copy.fQATrackHistosRecEffGen)
574 ,fQATrackHistosRecEffRec(copy.fQATrackHistosRecEffRec)
575 ,fQATrackHistosSecRecNS(copy.fQATrackHistosSecRecNS)
576 ,fQATrackHistosSecRecS(copy.fQATrackHistosSecRecS)
577 ,fQATrackHistosSecRecSsc(copy.fQATrackHistosSecRecSsc)
578 ,fFFHistosRecEffRec(copy.fFFHistosRecEffRec)
579 ,fFFHistosSecRecNS(copy.fFFHistosSecRecNS)
580 ,fFFHistosSecRecS(copy.fFFHistosSecRecS)
581 ,fFFHistosSecRecSsc(copy.fFFHistosSecRecSsc)
583 ,fh1BckgMult0(copy.fh1BckgMult0)
584 ,fh1BckgMult1(copy.fh1BckgMult1)
585 ,fh1BckgMult2(copy.fh1BckgMult2)
586 ,fh1BckgMult3(copy.fh1BckgMult3)
587 ,fh1BckgMult4(copy.fh1BckgMult4)
588 ,fh1FractionPtEmbedded(copy.fh1FractionPtEmbedded)
589 ,fh1IndexEmbedded(copy.fh1IndexEmbedded)
590 ,fh2DeltaPtVsJetPtEmbedded(copy.fh2DeltaPtVsJetPtEmbedded)
591 ,fh2DeltaPtVsRecJetPtEmbedded(copy.fh2DeltaPtVsRecJetPtEmbedded)
592 ,fh1DeltaREmbedded(copy.fh1DeltaREmbedded)
593 ,fQABckgHisto0RecCuts(copy.fQABckgHisto0RecCuts)
594 ,fQABckgHisto0Gen(copy.fQABckgHisto0Gen)
595 ,fQABckgHisto1RecCuts(copy.fQABckgHisto1RecCuts)
596 ,fQABckgHisto1Gen(copy.fQABckgHisto1Gen)
597 ,fQABckgHisto2RecCuts(copy.fQABckgHisto2RecCuts)
598 ,fQABckgHisto2Gen(copy.fQABckgHisto2Gen)
599 ,fQABckgHisto3RecCuts(copy.fQABckgHisto3RecCuts)
600 ,fQABckgHisto3Gen(copy.fQABckgHisto3Gen)
601 ,fQABckgHisto4RecCuts(copy.fQABckgHisto4RecCuts)
602 ,fQABckgHisto4Gen(copy.fQABckgHisto4Gen)
603 ,fFFBckgHisto0RecCuts(copy.fFFBckgHisto0RecCuts)
604 ,fFFBckgHisto0Gen(copy.fFFBckgHisto0Gen)
605 ,fFFBckgHisto1RecCuts(copy.fFFBckgHisto1RecCuts)
606 ,fFFBckgHisto1Gen(copy.fFFBckgHisto1Gen)
607 ,fFFBckgHisto2RecCuts(copy.fFFBckgHisto2RecCuts)
608 ,fFFBckgHisto2Gen(copy.fFFBckgHisto2Gen)
609 ,fFFBckgHisto3RecCuts(copy.fFFBckgHisto3RecCuts)
610 ,fFFBckgHisto3Gen(copy.fFFBckgHisto3Gen)
611 ,fFFBckgHisto4RecCuts(copy.fFFBckgHisto4RecCuts)
612 ,fFFBckgHisto4Gen(copy.fFFBckgHisto4Gen)
613 ,fFFBckgHisto0RecEffRec(copy.fFFBckgHisto0RecEffRec)
614 ,fFFBckgHisto0SecRecNS(copy.fFFBckgHisto0SecRecNS)
615 ,fFFBckgHisto0SecRecS(copy.fFFBckgHisto0SecRecS)
616 ,fFFBckgHisto0SecRecSsc(copy.fFFBckgHisto0SecRecSsc)
618 ,fProNtracksLeadingJet(copy.fProNtracksLeadingJet)
619 ,fProDelR80pcPt(copy.fProDelR80pcPt)
620 ,fProNtracksLeadingJetGen(copy.fProNtracksLeadingJetGen)
621 ,fProDelR80pcPtGen(copy.fProDelR80pcPtGen)
622 ,fProNtracksLeadingJetBgrPerp2(copy.fProNtracksLeadingJetBgrPerp2)
623 ,fProNtracksLeadingJetRecPrim(copy.fProNtracksLeadingJetRecPrim)
624 ,fProDelR80pcPtRecPrim(copy.fProDelR80pcPtRecPrim)
625 ,fProNtracksLeadingJetRecSecNS(copy.fProNtracksLeadingJetRecSecNS)
626 ,fProNtracksLeadingJetRecSecS(copy.fProNtracksLeadingJetRecSecS)
627 ,fProNtracksLeadingJetRecSecSsc(copy.fProNtracksLeadingJetRecSecSsc)
628 ,fRandom(copy.fRandom)
631 fBckgType[0] = copy.fBckgType[0];
632 fBckgType[1] = copy.fBckgType[1];
633 fBckgType[2] = copy.fBckgType[2];
634 fBckgType[3] = copy.fBckgType[3];
635 fBckgType[4] = copy.fBckgType[4];
638 for(Int_t ii=0; ii<5; ii++){
639 fProDelRPtSum[ii] = copy.fProDelRPtSum[ii];
640 fProDelRPtSumGen[ii] = copy.fProDelRPtSumGen[ii];
641 fProDelRPtSumBgrPerp2[ii] = copy.fProDelRPtSumBgrPerp2[ii];
642 fProDelRPtSumRecPrim[ii] = copy.fProDelRPtSumRecPrim[ii];
643 fProDelRPtSumRecSecNS[ii] = copy.fProDelRPtSumRecSecNS[ii];
644 fProDelRPtSumRecSecS[ii] = copy.fProDelRPtSumRecSecS[ii];
645 fProDelRPtSumRecSecSsc[ii] = copy.fProDelRPtSumRecSecSsc[ii];
649 // _________________________________________________________________________________________________________________________________
650 AliAnalysisTaskFragmentationFunction& AliAnalysisTaskFragmentationFunction::operator=(const AliAnalysisTaskFragmentationFunction& o)
656 AliAnalysisTaskSE::operator=(o);
659 fAODJets = o.fAODJets;
660 fAODExtension = o.fAODExtension;
661 fNonStdFile = o.fNonStdFile;
662 fBranchRecJets = o.fBranchRecJets;
663 fBranchRecBckgClusters = o.fBranchRecBckgClusters;
664 fBranchGenJets = o.fBranchGenJets;
665 fBranchEmbeddedJets = o.fBranchEmbeddedJets;
666 fTrackTypeGen = o.fTrackTypeGen;
667 fJetTypeGen = o.fJetTypeGen;
668 fJetTypeRecEff = o.fJetTypeRecEff;
669 fUseAODInputJets = o.fUseAODInputJets;
670 fFilterMask = o.fFilterMask;
671 fUsePhysicsSelection = o.fUsePhysicsSelection;
672 fEvtSelectionMask = o.fEvtSelectionMask;
673 fEventClass = o.fEventClass;
674 fMaxVertexZ = o.fMaxVertexZ;
675 fTrackPtCut = o.fTrackPtCut;
676 fTrackEtaMin = o.fTrackEtaMin;
677 fTrackEtaMax = o.fTrackEtaMax;
678 fTrackPhiMin = o.fTrackPhiMin;
679 fTrackPhiMax = o.fTrackPhiMax;
680 fUseExtraTracks = o.fUseExtraTracks;
681 fUseExtraTracksBgr = o.fUseExtraTracksBgr;
682 fCutFractionPtEmbedded = o.fCutFractionPtEmbedded;
683 fUseEmbeddedJetAxis = o.fUseEmbeddedJetAxis;
684 fUseEmbeddedJetPt = o.fUseEmbeddedJetPt;
685 fJetPtCut = o.fJetPtCut;
686 fJetEtaMin = o.fJetEtaMin;
687 fJetEtaMax = o.fJetEtaMax;
688 fJetPhiMin = o.fJetPhiMin;
689 fJetPhiMax = o.fJetPhiMin;
690 fFFRadius = o.fFFRadius;
691 fFFMinLTrackPt = o.fFFMinLTrackPt;
692 fFFMaxTrackPt = o.fFFMaxTrackPt;
693 fFFMinnTracks = o.fFFMinnTracks;
694 fFFBckgRadius = o.fFFBckgRadius;
695 fBckgMode = o.fBckgMode;
698 fEffMode = o.fEffMode;
700 fBckgType[0] = o.fBckgType[0];
701 fBckgType[1] = o.fBckgType[1];
702 fBckgType[2] = o.fBckgType[2];
703 fBckgType[3] = o.fBckgType[3];
704 fBckgType[4] = o.fBckgType[4];
705 fAvgTrials = o.fAvgTrials;
706 fTracksRecCuts = o.fTracksRecCuts;
707 fTracksGen = o.fTracksGen;
708 fTracksAODMCCharged = o.fTracksAODMCCharged;
709 fTracksAODMCChargedSecNS = o.fTracksAODMCChargedSecNS;
710 fTracksAODMCChargedSecS = o.fTracksAODMCChargedSecS;
711 fTracksRecQualityCuts = o.fTracksRecQualityCuts;
712 fJetsRec = o.fJetsRec;
713 fJetsRecCuts = o.fJetsRecCuts;
714 fJetsGen = o.fJetsGen;
715 fJetsRecEff = o.fJetsRecEff;
716 fJetsEmbedded = o.fJetsEmbedded;
717 fBckgJetsRec = o.fBckgJetsRec;
718 fBckgJetsRecCuts = o.fBckgJetsRecCuts;
719 fBckgJetsGen = o.fBckgJetsGen;
720 fQATrackHistosRecCuts = o.fQATrackHistosRecCuts;
721 fQATrackHistosGen = o.fQATrackHistosGen;
722 fQAJetHistosRec = o.fQAJetHistosRec;
723 fQAJetHistosRecCuts = o.fQAJetHistosRecCuts;
724 fQAJetHistosRecCutsLeading = o.fQAJetHistosRecCutsLeading;
725 fQAJetHistosGen = o.fQAJetHistosGen;
726 fQAJetHistosGenLeading = o.fQAJetHistosGenLeading;
727 fQAJetHistosRecEffLeading = o.fQAJetHistosRecEffLeading;
728 fFFHistosRecCuts = o.fFFHistosRecCuts;
729 fFFHistosGen = o.fFFHistosGen;
730 fQATrackHighPtThreshold = o.fQATrackHighPtThreshold;
731 fFFNBinsJetPt = o.fFFNBinsJetPt;
732 fFFJetPtMin = o.fFFJetPtMin;
733 fFFJetPtMax = o.fFFJetPtMax;
734 fFFNBinsPt = o.fFFNBinsPt;
735 fFFPtMin = o.fFFPtMin;
736 fFFPtMax = o.fFFPtMax;
737 fFFNBinsXi = o.fFFNBinsXi;
738 fFFXiMin = o.fFFXiMin;
739 fFFXiMax = o.fFFXiMax;
740 fFFNBinsZ = o.fFFNBinsZ;
743 fQAJetNBinsPt = o.fQAJetNBinsPt;
744 fQAJetPtMin = o.fQAJetPtMin;
745 fQAJetPtMax = o.fQAJetPtMax;
746 fQAJetNBinsEta = o.fQAJetNBinsEta;
747 fQAJetEtaMin = o.fQAJetEtaMin;
748 fQAJetEtaMax = o.fQAJetEtaMax;
749 fQAJetNBinsPhi = o.fQAJetNBinsPhi;
750 fQAJetPhiMin = o.fQAJetPhiMin;
751 fQAJetPhiMax = o.fQAJetPhiMax;
752 fQATrackNBinsPt = o.fQATrackNBinsPt;
753 fQATrackPtMin = o.fQATrackPtMin;
754 fQATrackPtMax = o.fQATrackPtMax;
755 fQATrackNBinsEta = o.fQATrackNBinsEta;
756 fQATrackEtaMin = o.fQATrackEtaMin;
757 fQATrackEtaMax = o.fQATrackEtaMax;
758 fQATrackNBinsPhi = o.fQATrackNBinsPhi;
759 fQATrackPhiMin = o.fQATrackPhiMin;
760 fQATrackPhiMax = o.fQATrackPhiMax;
761 fCommonHistList = o.fCommonHistList;
762 fh1EvtSelection = o.fh1EvtSelection;
763 fh1VertexNContributors = o.fh1VertexNContributors;
764 fh1VertexZ = o.fh1VertexZ;
765 fh1EvtMult = o.fh1EvtMult;
766 fh1EvtCent = o.fh1EvtCent;
768 fh1Trials = o.fh1Trials;
769 fh1PtHard = o.fh1PtHard;
770 fh1PtHardTrials = o.fh1PtHardTrials;
771 fh1nRecJetsCuts = o.fh1nRecJetsCuts;
772 fh1nGenJets = o.fh1nGenJets;
773 fh1nRecEffJets = o.fh1nRecEffJets;
774 fh1nEmbeddedJets = o.fh1nEmbeddedJets;
775 fh2PtRecVsGenPrim = o.fh2PtRecVsGenPrim;
776 fh2PtRecVsGenSec = o.fh2PtRecVsGenSec;
777 fQATrackHistosRecEffGen = o.fQATrackHistosRecEffGen;
778 fQATrackHistosRecEffRec = o.fQATrackHistosRecEffRec;
779 fQATrackHistosSecRecNS = o.fQATrackHistosSecRecNS;
780 fQATrackHistosSecRecS = o.fQATrackHistosSecRecS;
781 fQATrackHistosSecRecSsc = o.fQATrackHistosSecRecSsc;
782 fFFHistosRecEffRec = o.fFFHistosRecEffRec;
783 fFFHistosSecRecNS = o.fFFHistosSecRecNS;
784 fFFHistosSecRecS = o.fFFHistosSecRecS;
785 fFFHistosSecRecSsc = o.fFFHistosSecRecSsc;
787 fh1BckgMult0 = o.fh1BckgMult0;
788 fh1BckgMult1 = o.fh1BckgMult1;
789 fh1BckgMult2 = o.fh1BckgMult2;
790 fh1BckgMult3 = o.fh1BckgMult3;
791 fh1BckgMult4 = o.fh1BckgMult4;
792 fh1FractionPtEmbedded = o.fh1FractionPtEmbedded;
793 fh1IndexEmbedded = o.fh1IndexEmbedded;
794 fh2DeltaPtVsJetPtEmbedded = o.fh2DeltaPtVsJetPtEmbedded;
795 fh2DeltaPtVsRecJetPtEmbedded = o.fh2DeltaPtVsRecJetPtEmbedded;
796 fh1DeltaREmbedded = o.fh1DeltaREmbedded;
797 fQABckgHisto0RecCuts = o.fQABckgHisto0RecCuts;
798 fQABckgHisto0Gen = o.fQABckgHisto0Gen;
799 fQABckgHisto1RecCuts = o.fQABckgHisto1RecCuts;
800 fQABckgHisto1Gen = o.fQABckgHisto1Gen;
801 fQABckgHisto2RecCuts = o.fQABckgHisto2RecCuts;
802 fQABckgHisto2Gen = o.fQABckgHisto2Gen;
803 fQABckgHisto3RecCuts = o.fQABckgHisto3RecCuts;
804 fQABckgHisto3Gen = o.fQABckgHisto3Gen;
805 fQABckgHisto4RecCuts = o.fQABckgHisto4RecCuts;
806 fQABckgHisto4Gen = o.fQABckgHisto4Gen;
807 fFFBckgHisto0RecCuts = o.fFFBckgHisto0RecCuts;
808 fFFBckgHisto0Gen = o.fFFBckgHisto0Gen;
809 fFFBckgHisto1RecCuts = o.fFFBckgHisto1RecCuts;
810 fFFBckgHisto1Gen = o.fFFBckgHisto1Gen;
811 fFFBckgHisto2RecCuts = o.fFFBckgHisto2RecCuts;
812 fFFBckgHisto2Gen = o.fFFBckgHisto2Gen;
813 fFFBckgHisto3RecCuts = o.fFFBckgHisto3RecCuts;
814 fFFBckgHisto3Gen = o.fFFBckgHisto3Gen;
815 fFFBckgHisto4RecCuts = o.fFFBckgHisto4RecCuts;
816 fFFBckgHisto4Gen = o.fFFBckgHisto4Gen;
817 fFFBckgHisto0RecEffRec = o.fFFBckgHisto0RecEffRec;
818 fFFBckgHisto0SecRecNS = o.fFFBckgHisto0SecRecNS;
819 fFFBckgHisto0SecRecS = o.fFFBckgHisto0SecRecS;
820 fFFBckgHisto0SecRecSsc = o.fFFBckgHisto0SecRecSsc;
821 fProNtracksLeadingJet = o.fProNtracksLeadingJet;
822 fProDelR80pcPt = o.fProDelR80pcPt;
823 fProNtracksLeadingJetGen = o.fProNtracksLeadingJetGen;
824 fProDelR80pcPtGen = o.fProDelR80pcPtGen;
825 fProNtracksLeadingJetBgrPerp2 = o.fProNtracksLeadingJetBgrPerp2;
826 fProNtracksLeadingJetRecPrim = o.fProNtracksLeadingJetRecPrim;
827 fProDelR80pcPtRecPrim = o.fProDelR80pcPtRecPrim;
828 fProNtracksLeadingJetRecSecNS = o.fProNtracksLeadingJetRecSecNS;
829 fProNtracksLeadingJetRecSecS = o.fProNtracksLeadingJetRecSecS;
830 fProNtracksLeadingJetRecSecSsc = o.fProNtracksLeadingJetRecSecSsc;
833 for(Int_t ii=0; ii<5; ii++){
834 fProDelRPtSum[ii] = o.fProDelRPtSum[ii];
835 fProDelRPtSumGen[ii] = o.fProDelRPtSumGen[ii];
836 fProDelRPtSumBgrPerp2[ii] = o.fProDelRPtSumBgrPerp2[ii];
837 fProDelRPtSumRecPrim[ii] = o.fProDelRPtSumRecPrim[ii];
838 fProDelRPtSumRecSecNS[ii] = o.fProDelRPtSumRecSecNS[ii];
839 fProDelRPtSumRecSecS[ii] = o.fProDelRPtSumRecSecS[ii];
840 fProDelRPtSumRecSecSsc[ii] = o.fProDelRPtSumRecSecSsc[ii];
847 //___________________________________________________________________________
848 AliAnalysisTaskFragmentationFunction::~AliAnalysisTaskFragmentationFunction()
852 if(fTracksRecCuts) delete fTracksRecCuts;
853 if(fTracksGen) delete fTracksGen;
854 if(fTracksAODMCCharged) delete fTracksAODMCCharged;
855 if(fTracksAODMCChargedSecNS) delete fTracksAODMCChargedSecNS;
856 if(fTracksAODMCChargedSecS) delete fTracksAODMCChargedSecS;
857 if(fTracksRecQualityCuts) delete fTracksRecQualityCuts;
858 if(fJetsRec) delete fJetsRec;
859 if(fJetsRecCuts) delete fJetsRecCuts;
860 if(fJetsGen) delete fJetsGen;
861 if(fJetsRecEff) delete fJetsRecEff;
862 if(fJetsEmbedded) delete fJetsEmbedded;
865 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
866 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
867 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)){
869 if(fBckgJetsRec) delete fBckgJetsRec;
870 if(fBckgJetsRecCuts) delete fBckgJetsRecCuts;
871 if(fBckgJetsGen) delete fBckgJetsGen;
873 if(fRandom) delete fRandom;
876 //______________________________________________________________________________________________________
877 AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::AliFragFuncHistos(const char* name,
878 Int_t nJetPt, Float_t jetPtMin, Float_t jetPtMax,
879 Int_t nPt, Float_t ptMin, Float_t ptMax,
880 Int_t nXi, Float_t xiMin, Float_t xiMax,
881 Int_t nZ , Float_t zMin , Float_t zMax)
901 // default constructor
905 //___________________________________________________________________________
906 AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::AliFragFuncHistos(const AliFragFuncHistos& copy)
908 ,fNBinsJetPt(copy.fNBinsJetPt)
909 ,fJetPtMin(copy.fJetPtMin)
910 ,fJetPtMax(copy.fJetPtMax)
911 ,fNBinsPt(copy.fNBinsPt)
914 ,fNBinsXi(copy.fNBinsXi)
917 ,fNBinsZ(copy.fNBinsZ)
920 ,fh2TrackPt(copy.fh2TrackPt)
923 ,fh1JetPt(copy.fh1JetPt)
924 ,fNameFF(copy.fNameFF)
929 //_______________________________________________________________________________________________________________________________________________________________
930 AliAnalysisTaskFragmentationFunction::AliFragFuncHistos& AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::operator=(const AliAnalysisTaskFragmentationFunction::AliFragFuncHistos& o)
935 TObject::operator=(o);
936 fNBinsJetPt = o.fNBinsJetPt;
937 fJetPtMin = o.fJetPtMin;
938 fJetPtMax = o.fJetPtMax;
939 fNBinsPt = o.fNBinsPt;
942 fNBinsXi = o.fNBinsXi;
948 fh2TrackPt = o.fh2TrackPt;
951 fh1JetPt = o.fh1JetPt;
958 //_________________________________________________________
959 AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::~AliFragFuncHistos()
963 if(fh1JetPt) delete fh1JetPt;
964 if(fh2TrackPt) delete fh2TrackPt;
965 if(fh2Xi) delete fh2Xi;
966 if(fh2Z) delete fh2Z;
969 //_________________________________________________________________
970 void AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::DefineHistos()
974 fh1JetPt = new TH1F(Form("fh1FFJetPt%s", fNameFF.Data()),"",fNBinsJetPt,fJetPtMin,fJetPtMax);
975 fh2TrackPt = new TH2F(Form("fh2FFTrackPt%s",fNameFF.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax,fNBinsPt, fPtMin, fPtMax);
976 fh2Z = new TH2F(Form("fh2FFZ%s",fNameFF.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax, fNBinsZ, fZMin, fZMax);
977 fh2Xi = new TH2F(Form("fh2FFXi%s",fNameFF.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax, fNBinsXi, fXiMin, fXiMax);
979 AliAnalysisTaskFragmentationFunction::SetProperties(fh1JetPt, "p_{T} [GeV/c]", "entries");
980 AliAnalysisTaskFragmentationFunction::SetProperties(fh2TrackPt,"jet p_{T} [GeV/c]","p_{T} [GeV/c]","entries");
981 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Xi,"jet p_{T} [GeV/c]","#xi", "entries");
982 AliAnalysisTaskFragmentationFunction::SetProperties(fh2Z,"jet p_{T} [GeV/c]","z","entries");
985 //_______________________________________________________________________________________________________________
986 void AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::FillFF(Float_t trackPt, Float_t jetPt, Bool_t incrementJetPt, Float_t norm,
987 Bool_t scaleStrangeness, Float_t scaleFacStrangeness)
991 if(incrementJetPt && norm) fh1JetPt->Fill(jetPt,1/norm);
992 else if(incrementJetPt) fh1JetPt->Fill(jetPt);
994 // Added for proper normalization of FF background estimation
995 // when zero track are found in the background region
996 if((int)trackPt==-1) return;
998 if(norm)fh2TrackPt->Fill(jetPt,trackPt,1/norm);
999 else if(scaleStrangeness) fh2TrackPt->Fill(jetPt,trackPt,scaleFacStrangeness);
1000 else fh2TrackPt->Fill(jetPt,trackPt);
1003 if(jetPt>0) z = trackPt / jetPt;
1005 if(z>0) xi = TMath::Log(1/z);
1007 if(trackPt>(1-1e-06)*jetPt && trackPt<(1+1e-06)*jetPt){ // case z=1 : move entry to last histo bin <1
1014 fh2Xi->Fill(jetPt,xi,1/norm);
1015 fh2Z->Fill(jetPt,z,1/norm);
1017 else if(scaleStrangeness){
1018 fh2Xi->Fill(jetPt,xi,scaleFacStrangeness);
1019 fh2Z->Fill(jetPt,z,scaleFacStrangeness);
1022 fh2Xi->Fill(jetPt,xi);
1023 fh2Z->Fill(jetPt,z);
1027 //_________________________________________________________________________________
1028 void AliAnalysisTaskFragmentationFunction::AliFragFuncHistos::AddToOutput(TList* list) const
1030 // add histos to list
1032 list->Add(fh1JetPt);
1034 list->Add(fh2TrackPt);
1039 //_________________________________________________________________________________________________________
1040 AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::AliFragFuncQAJetHistos(const char* name,
1041 Int_t nPt, Float_t ptMin, Float_t ptMax,
1042 Int_t nEta, Float_t etaMin, Float_t etaMax,
1043 Int_t nPhi, Float_t phiMin, Float_t phiMax)
1058 // default constructor
1061 //____________________________________________________________________________________
1062 AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::AliFragFuncQAJetHistos(const AliFragFuncQAJetHistos& copy)
1064 ,fNBinsPt(copy.fNBinsPt)
1065 ,fPtMin(copy.fPtMin)
1066 ,fPtMax(copy.fPtMax)
1067 ,fNBinsEta(copy.fNBinsEta)
1068 ,fEtaMin(copy.fEtaMin)
1069 ,fEtaMax(copy.fEtaMax)
1070 ,fNBinsPhi(copy.fNBinsPhi)
1071 ,fPhiMin(copy.fPhiMin)
1072 ,fPhiMax(copy.fPhiMax)
1073 ,fh2EtaPhi(copy.fh2EtaPhi)
1075 ,fNameQAJ(copy.fNameQAJ)
1080 //________________________________________________________________________________________________________________________________________________________________________
1081 AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos& AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::operator=(const AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos& o)
1086 TObject::operator=(o);
1087 fNBinsPt = o.fNBinsPt;
1090 fNBinsEta = o.fNBinsEta;
1091 fEtaMin = o.fEtaMin;
1092 fEtaMax = o.fEtaMax;
1093 fNBinsPhi = o.fNBinsPhi;
1094 fPhiMin = o.fPhiMin;
1095 fPhiMax = o.fPhiMax;
1096 fh2EtaPhi = o.fh2EtaPhi;
1098 fNameQAJ = o.fNameQAJ;
1104 //______________________________________________________________
1105 AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::~AliFragFuncQAJetHistos()
1109 if(fh2EtaPhi) delete fh2EtaPhi;
1110 if(fh1Pt) delete fh1Pt;
1113 //____________________________________________________________________
1114 void AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::DefineHistos()
1116 // book jet QA histos
1118 fh2EtaPhi = new TH2F(Form("fh2JetQAEtaPhi%s", fNameQAJ.Data()), Form("%s: #eta - #phi distribution", fNameQAJ.Data()), fNBinsEta, fEtaMin, fEtaMax, fNBinsPhi, fPhiMin, fPhiMax);
1119 fh1Pt = new TH1F(Form("fh1JetQAPt%s", fNameQAJ.Data()), Form("%s: p_{T} distribution", fNameQAJ.Data()), fNBinsPt, fPtMin, fPtMax);
1121 AliAnalysisTaskFragmentationFunction::SetProperties(fh2EtaPhi, "#eta", "#phi");
1122 AliAnalysisTaskFragmentationFunction::SetProperties(fh1Pt, "p_{T} [GeV/c]", "entries");
1125 //____________________________________________________________________________________________________
1126 void AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::FillJetQA(Float_t eta, Float_t phi, Float_t pt)
1128 // fill jet QA histos
1130 fh2EtaPhi->Fill( eta, phi);
1134 //____________________________________________________________________________________
1135 void AliAnalysisTaskFragmentationFunction::AliFragFuncQAJetHistos::AddToOutput(TList* list) const
1137 // add histos to list
1139 list->Add(fh2EtaPhi);
1143 //___________________________________________________________________________________________________________
1144 AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::AliFragFuncQATrackHistos(const char* name,
1145 Int_t nPt, Float_t ptMin, Float_t ptMax,
1146 Int_t nEta, Float_t etaMin, Float_t etaMax,
1147 Int_t nPhi, Float_t phiMin, Float_t phiMax,
1159 ,fHighPtThreshold(ptThresh)
1166 // default constructor
1169 //__________________________________________________________________________________________
1170 AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::AliFragFuncQATrackHistos(const AliFragFuncQATrackHistos& copy)
1172 ,fNBinsPt(copy.fNBinsPt)
1173 ,fPtMin(copy.fPtMin)
1174 ,fPtMax(copy.fPtMax)
1175 ,fNBinsEta(copy.fNBinsEta)
1176 ,fEtaMin(copy.fEtaMin)
1177 ,fEtaMax(copy.fEtaMax)
1178 ,fNBinsPhi(copy.fNBinsPhi)
1179 ,fPhiMin(copy.fPhiMin)
1180 ,fPhiMax(copy.fPhiMax)
1181 ,fHighPtThreshold(copy.fHighPtThreshold)
1182 ,fh2EtaPhi(copy.fh2EtaPhi)
1184 ,fh2HighPtEtaPhi(copy.fh2HighPtEtaPhi)
1185 ,fh2PhiPt(copy.fh2PhiPt)
1186 ,fNameQAT(copy.fNameQAT)
1191 // _____________________________________________________________________________________________________________________________________________________________________________
1192 AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos& AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::operator=(const AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos& o)
1197 TObject::operator=(o);
1198 fNBinsPt = o.fNBinsPt;
1201 fNBinsEta = o.fNBinsEta;
1202 fEtaMin = o.fEtaMin;
1203 fEtaMax = o.fEtaMax;
1204 fNBinsPhi = o.fNBinsPhi;
1205 fPhiMin = o.fPhiMin;
1206 fPhiMax = o.fPhiMax;
1207 fHighPtThreshold = o.fHighPtThreshold;
1208 fh2EtaPhi = o.fh2EtaPhi;
1210 fh2HighPtEtaPhi = o.fh2HighPtEtaPhi;
1211 fh2PhiPt = o.fh2PhiPt;
1212 fNameQAT = o.fNameQAT;
1218 //___________________________________________________________________
1219 AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::~AliFragFuncQATrackHistos()
1223 if(fh2EtaPhi) delete fh2EtaPhi;
1224 if(fh2HighPtEtaPhi) delete fh2HighPtEtaPhi;
1225 if(fh1Pt) delete fh1Pt;
1226 if(fh2PhiPt) delete fh2PhiPt;
1229 //______________________________________________________________________
1230 void AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::DefineHistos()
1232 // book track QA histos
1234 fh2EtaPhi = new TH2F(Form("fh2TrackQAEtaPhi%s", fNameQAT.Data()), Form("%s: #eta - #phi distribution", fNameQAT.Data()), fNBinsEta, fEtaMin, fEtaMax, fNBinsPhi, fPhiMin, fPhiMax);
1235 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);
1236 fh1Pt = new TH1F(Form("fh1TrackQAPt%s", fNameQAT.Data()), Form("%s: p_{T} distribution", fNameQAT.Data()), fNBinsPt, fPtMin, fPtMax);
1237 fh2PhiPt = new TH2F(Form("fh2TrackQAPhiPt%s", fNameQAT.Data()), Form("%s: #phi - p_{T} distribution", fNameQAT.Data()), fNBinsPhi, fPhiMin, fPhiMax, fNBinsPt, fPtMin, fPtMax);
1239 AliAnalysisTaskFragmentationFunction::SetProperties(fh2EtaPhi, "#eta", "#phi");
1240 AliAnalysisTaskFragmentationFunction::SetProperties(fh2HighPtEtaPhi, "#eta", "#phi");
1241 AliAnalysisTaskFragmentationFunction::SetProperties(fh1Pt, "p_{T} [GeV/c]", "entries");
1242 AliAnalysisTaskFragmentationFunction::SetProperties(fh2PhiPt, "#phi", "p_{T} [GeV/c]");
1245 //________________________________________________________________________________________________________
1246 void AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::FillTrackQA(Float_t eta, Float_t phi, Float_t pt, Bool_t weightPt, Float_t norm,
1247 Bool_t scaleStrangeness, Float_t scaleFacStrangeness)
1249 // fill track QA histos
1250 Float_t weight = 1.;
1251 if(weightPt) weight = pt;
1252 fh2EtaPhi->Fill( eta, phi, weight);
1253 if(scaleStrangeness) fh2EtaPhi->Fill( eta, phi, scaleFacStrangeness);
1254 if(pt > fHighPtThreshold) fh2HighPtEtaPhi->Fill( eta, phi, weight);
1255 if(pt > fHighPtThreshold && scaleStrangeness) fh2HighPtEtaPhi->Fill( eta, phi, weight);
1256 if(norm) fh1Pt->Fill( pt, 1/norm );
1257 else if(scaleStrangeness) fh1Pt->Fill(pt,scaleFacStrangeness);
1258 else fh1Pt->Fill( pt );
1260 if(scaleFacStrangeness) fh2PhiPt->Fill(phi, pt, scaleFacStrangeness);
1261 else fh2PhiPt->Fill(phi, pt);
1264 //______________________________________________________________________________________
1265 void AliAnalysisTaskFragmentationFunction::AliFragFuncQATrackHistos::AddToOutput(TList* list) const
1267 // add histos to list
1269 list->Add(fh2EtaPhi);
1270 list->Add(fh2HighPtEtaPhi);
1272 list->Add(fh2PhiPt);
1275 //_________________________________________________________________________________
1276 Bool_t AliAnalysisTaskFragmentationFunction::Notify()
1279 // Implemented Notify() to read the cross sections
1280 // and number of trials from pyxsec.root
1281 // (taken from AliAnalysisTaskJetSpectrum2)
1283 TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
1284 Float_t xsection = 0;
1285 Float_t ftrials = 1;
1289 TFile *curfile = tree->GetCurrentFile();
1291 Error("Notify","No current file");
1294 if(!fh1Xsec||!fh1Trials){
1295 Printf("%s%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__);
1298 AliAnalysisHelperJetTasks::PythiaInfoFromFile(curfile->GetName(),xsection,ftrials);
1299 fh1Xsec->Fill("<#sigma>",xsection);
1300 // construct a poor man average trials
1301 Float_t nEntries = (Float_t)tree->GetTree()->GetEntries();
1302 if(ftrials>=nEntries && nEntries>0.)fAvgTrials = ftrials/nEntries;
1305 // Set seed for backg study
1306 fRandom = new TRandom3();
1307 fRandom->SetSeed(0);
1312 //__________________________________________________________________
1313 void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects()
1315 // create output objects
1317 if(fDebug > 1) Printf("AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects()");
1319 // create list of tracks and jets
1321 fTracksRecCuts = new TList();
1322 fTracksRecCuts->SetOwner(kFALSE);
1324 fTracksGen = new TList();
1325 fTracksGen->SetOwner(kFALSE);
1327 fTracksAODMCCharged = new TList();
1328 fTracksAODMCCharged->SetOwner(kFALSE);
1330 fTracksAODMCChargedSecNS = new TList();
1331 fTracksAODMCChargedSecNS->SetOwner(kFALSE);
1333 fTracksAODMCChargedSecS = new TList();
1334 fTracksAODMCChargedSecS->SetOwner(kFALSE);
1336 fTracksRecQualityCuts = new TList();
1337 fTracksRecQualityCuts->SetOwner(kFALSE);
1339 fJetsRec = new TList();
1340 fJetsRec->SetOwner(kFALSE);
1342 fJetsRecCuts = new TList();
1343 fJetsRecCuts->SetOwner(kFALSE);
1345 fJetsGen = new TList();
1346 fJetsGen->SetOwner(kFALSE);
1348 fJetsRecEff = new TList();
1349 fJetsRecEff->SetOwner(kFALSE);
1351 fJetsEmbedded = new TList();
1352 fJetsEmbedded->SetOwner(kFALSE);
1356 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
1357 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
1358 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)){
1360 fBckgJetsRec = new TList();
1361 fBckgJetsRec->SetOwner(kFALSE);
1363 fBckgJetsRecCuts = new TList();
1364 fBckgJetsRecCuts->SetOwner(kFALSE);
1366 fBckgJetsGen = new TList();
1367 fBckgJetsGen->SetOwner(kFALSE);
1371 // Create histograms / output container
1375 fCommonHistList = new TList();
1376 fCommonHistList->SetOwner(kTRUE);
1378 Bool_t oldStatus = TH1::AddDirectoryStatus();
1379 TH1::AddDirectory(kFALSE);
1383 fh1EvtSelection = new TH1F("fh1EvtSelection", "Event Selection", 6, -0.5, 5.5);
1384 fh1EvtSelection->GetXaxis()->SetBinLabel(1,"ACCEPTED");
1385 fh1EvtSelection->GetXaxis()->SetBinLabel(2,"event selection: rejected");
1386 fh1EvtSelection->GetXaxis()->SetBinLabel(3,"event class: rejected");
1387 fh1EvtSelection->GetXaxis()->SetBinLabel(4,"vertex Ncontr: rejected");
1388 fh1EvtSelection->GetXaxis()->SetBinLabel(5,"vertex z: rejected");
1389 fh1EvtSelection->GetXaxis()->SetBinLabel(6,"vertex type: rejected");
1391 fh1VertexNContributors = new TH1F("fh1VertexNContributors", "Vertex N contributors", 2500,-.5, 2499.5);
1392 fh1VertexZ = new TH1F("fh1VertexZ", "Vertex z distribution", 30, -15., 15.);
1393 fh1EvtMult = new TH1F("fh1EvtMult","Event multiplicity, track pT cut > 150 MeV/c, |#eta| < 0.9",120,0.,12000.);
1394 fh1EvtCent = new TH1F("fh1EvtCent","centrality",100,0.,100.);
1396 fh1Xsec = new TProfile("fh1Xsec","xsec from pyxsec.root",1,0,1);
1397 fh1Xsec->GetXaxis()->SetBinLabel(1,"<#sigma>");
1398 fh1Trials = new TH1F("fh1Trials","trials from pyxsec.root",1,0,1);
1399 fh1Trials->GetXaxis()->SetBinLabel(1,"#sum{ntrials}");
1400 fh1PtHard = new TH1F("fh1PtHard","PYTHIA Pt hard;p_{T,hard}",350,-.5,349.5);
1401 fh1PtHardTrials = new TH1F("fh1PtHardTrials","PYTHIA Pt hard weight with trials;p_{T,hard}",350,-.5,349.5);
1403 fh1nRecJetsCuts = new TH1F("fh1nRecJetsCuts","reconstructed jets per event",10,-0.5,9.5);
1404 fh1nGenJets = new TH1F("fh1nGenJets","generated jets per event",10,-0.5,9.5);
1405 fh1nRecEffJets = new TH1F("fh1nRecEffJets","reconstruction effiency: jets per event",10,-0.5,9.5);
1406 fh1nEmbeddedJets = new TH1F("fh1nEmbeddedJets","embedded jets per event",10,-0.5,9.5);
1408 fh2PtRecVsGenPrim = new TH2F("fh2PtRecVsGenPrim","rec vs gen pt",fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax,fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax);
1409 fh2PtRecVsGenSec = new TH2F("fh2PtRecVsGenSec","rec vs gen pt",fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax,fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax);
1412 if(fBranchEmbeddedJets.Length()){
1413 fh1FractionPtEmbedded = new TH1F("fh1FractionPtEmbedded","",200,0,2);
1414 fh1IndexEmbedded = new TH1F("fh1IndexEmbedded","",11,-1,10);
1415 fh2DeltaPtVsJetPtEmbedded = new TH2F("fh2DeltaPtVsJetPtEmbedded","",250,0,250,200,-100,100);
1416 fh2DeltaPtVsRecJetPtEmbedded = new TH2F("fh2DeltaPtVsRecJetPtEmbedded","",250,0,250,200,-100,100);
1417 fh1DeltaREmbedded = new TH1F("fh1DeltaREmbedded","",50,0,0.5);
1418 fh1nEmbeddedJets = new TH1F("fh1nEmbeddedJets","embedded jets per event",10,-0.5,9.5);
1423 if(fQAMode&1){ // track QA
1424 fQATrackHistosRecCuts = new AliFragFuncQATrackHistos("RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1425 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1426 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1427 fQATrackHighPtThreshold);
1428 fQATrackHistosGen = new AliFragFuncQATrackHistos("Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1429 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1430 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1431 fQATrackHighPtThreshold);
1434 if(fQAMode&2){ // jet QA
1435 fQAJetHistosRec = new AliFragFuncQAJetHistos("Rec", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1436 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1437 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1438 fQAJetHistosRecCuts = new AliFragFuncQAJetHistos("RecCuts", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1439 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1440 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1441 fQAJetHistosRecCutsLeading = new AliFragFuncQAJetHistos("RecCutsLeading", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1442 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1443 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1444 fQAJetHistosGen = new AliFragFuncQAJetHistos("Gen", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1445 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1446 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1447 fQAJetHistosGenLeading = new AliFragFuncQAJetHistos("GenLeading", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1448 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,
1449 fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1450 if(fEffMode) fQAJetHistosRecEffLeading = new AliFragFuncQAJetHistos("RecEffLeading", fQAJetNBinsPt, fQAJetPtMin, fQAJetPtMax,
1451 fQAJetNBinsEta, fQAJetEtaMin, fQAJetEtaMax,fQAJetNBinsPhi, fQAJetPhiMin, fQAJetPhiMax);
1457 fFFHistosRecCuts = new AliFragFuncHistos("RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1458 fFFNBinsPt, fFFPtMin, fFFPtMax,
1459 fFFNBinsXi, fFFXiMin, fFFXiMax,
1460 fFFNBinsZ , fFFZMin , fFFZMax );
1462 fFFHistosGen = new AliFragFuncHistos("Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1463 fFFNBinsPt, fFFPtMin, fFFPtMax,
1464 fFFNBinsXi, fFFXiMin, fFFXiMax,
1465 fFFNBinsZ , fFFZMin , fFFZMax);
1472 fQATrackHistosRecEffGen = new AliFragFuncQATrackHistos("RecEffGen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1473 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1474 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1475 fQATrackHighPtThreshold);
1477 fQATrackHistosRecEffRec = new AliFragFuncQATrackHistos("RecEffRec", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1478 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1479 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1480 fQATrackHighPtThreshold);
1482 fQATrackHistosSecRecNS = new AliFragFuncQATrackHistos("SecRecNS", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1483 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1484 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1485 fQATrackHighPtThreshold);
1487 fQATrackHistosSecRecS = new AliFragFuncQATrackHistos("SecRecS", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1488 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1489 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1490 fQATrackHighPtThreshold);
1492 fQATrackHistosSecRecSsc = new AliFragFuncQATrackHistos("SecRecSsc", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1493 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1494 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1495 fQATrackHighPtThreshold);
1499 fFFHistosRecEffRec = new AliFragFuncHistos("RecEffRec", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1500 fFFNBinsPt, fFFPtMin, fFFPtMax,
1501 fFFNBinsXi, fFFXiMin, fFFXiMax,
1502 fFFNBinsZ , fFFZMin , fFFZMax);
1504 fFFHistosSecRecNS = new AliFragFuncHistos("SecRecNS", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1505 fFFNBinsPt, fFFPtMin, fFFPtMax,
1506 fFFNBinsXi, fFFXiMin, fFFXiMax,
1507 fFFNBinsZ , fFFZMin , fFFZMax);
1509 fFFHistosSecRecS = new AliFragFuncHistos("SecRecS", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1510 fFFNBinsPt, fFFPtMin, fFFPtMax,
1511 fFFNBinsXi, fFFXiMin, fFFXiMax,
1512 fFFNBinsZ , fFFZMin , fFFZMax);
1514 fFFHistosSecRecSsc = new AliFragFuncHistos("SecRecSsc", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1515 fFFNBinsPt, fFFPtMin, fFFPtMax,
1516 fFFNBinsXi, fFFXiMin, fFFXiMax,
1517 fFFNBinsZ , fFFZMin , fFFZMax);
1520 } // end: efficiency
1524 if(fBckgType[0]==kBckgNone){
1525 AliError("no bgr method selected !");
1529 for(Int_t i=0; i<5; i++){
1530 if(fBckgType[i]==kBckgPerp) title[i]="Perp";
1531 else if(fBckgType[i]==kBckgPerp2) title[i]="Perp2";
1532 else if(fBckgType[i]==kBckgPerp2Area) title[i]="Perp2Area";
1533 else if(fBckgType[i]==kBckgPerpWindow) title[i]="PerpW";
1534 else if(fBckgType[i]==kBckgASide) title[i]="ASide";
1535 else if(fBckgType[i]==kBckgASideWindow) title[i]="ASideW";
1536 else if(fBckgType[i]==kBckgOutLJ) title[i]="OutLeadingJet";
1537 else if(fBckgType[i]==kBckgOut2J) title[i]="Out2Jets";
1538 else if(fBckgType[i]==kBckgOut3J) title[i]="Out3Jets";
1539 else if(fBckgType[i]==kBckgOutAJ) title[i]="AllJets";
1540 else if(fBckgType[i]==kBckgOutLJStat) title[i]="OutLeadingJetStat";
1541 else if(fBckgType[i]==kBckgOut2JStat) title[i]="Out2JetsStat";
1542 else if(fBckgType[i]==kBckgOut3JStat) title[i]="Out3JetsStat";
1543 else if(fBckgType[i]==kBckgOutAJStat) title[i]="AllJetsStat";
1544 else if(fBckgType[i]==kBckgClustersOutLeading) title[i]="OutClusters";
1545 else if(fBckgType[i]==kBckgClusters) title[i]="MedianClusters";
1546 else if(fBckgType[i]==kBckgNone) title[i]="";
1547 else printf("Please chose background method number %d!",i);
1551 if(fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
1552 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
1553 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading){
1555 fh1nRecBckgJetsCuts = new TH1F("fh1nRecBckgJetsCuts","reconstructed background jets per event",10,-0.5,9.5);
1556 fh1nGenBckgJets = new TH1F("fh1nGenBckgJets","generated background jets per event",10,-0.5,9.5);
1560 fh1BckgMult0 = new TH1F("fh1BckgMult0","bckg mult "+title[0],500,0,500);
1561 if(fBckgType[1] != kBckgNone) fh1BckgMult1 = new TH1F("fh1BckgMult1","bckg mult "+title[1],500,0,500);
1562 if(fBckgType[2] != kBckgNone) fh1BckgMult2 = new TH1F("fh1BckgMult2","bckg mult "+title[2],500,0,500);
1563 if(fBckgType[3] != kBckgNone) fh1BckgMult3 = new TH1F("fh1BckgMult3","bckg mult "+title[3],500,0,500);
1564 if(fBckgType[4] != kBckgNone) fh1BckgMult4 = new TH1F("fh1BckgMult4","bckg mult "+title[4],500,0,500);
1568 fQABckgHisto0RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[0]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1569 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1570 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1571 fQATrackHighPtThreshold);
1572 fQABckgHisto0Gen = new AliFragFuncQATrackHistos("Bckg"+title[0]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1573 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1574 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1575 fQATrackHighPtThreshold);
1577 if(fBckgType[1] != kBckgNone){
1578 fQABckgHisto1RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[1]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1579 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1580 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1581 fQATrackHighPtThreshold);
1582 fQABckgHisto1Gen = new AliFragFuncQATrackHistos("Bckg"+title[1]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1583 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1584 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1585 fQATrackHighPtThreshold);
1587 if(fBckgType[2] != kBckgNone){
1588 fQABckgHisto2RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[2]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1589 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1590 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1591 fQATrackHighPtThreshold);
1592 fQABckgHisto2Gen = new AliFragFuncQATrackHistos("Bckg"+title[2]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1593 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1594 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1595 fQATrackHighPtThreshold);
1597 if(fBckgType[3] != kBckgNone){
1598 fQABckgHisto3RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[3]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1599 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1600 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1601 fQATrackHighPtThreshold);
1602 fQABckgHisto3Gen = new AliFragFuncQATrackHistos("Bckg"+title[3]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1603 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1604 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1605 fQATrackHighPtThreshold);
1607 if(fBckgType[4] != kBckgNone){
1608 fQABckgHisto4RecCuts = new AliFragFuncQATrackHistos("Bckg"+title[4]+"RecCuts", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1609 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1610 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1611 fQATrackHighPtThreshold);
1612 fQABckgHisto4Gen = new AliFragFuncQATrackHistos("Bckg"+title[4]+"Gen", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1613 fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1614 fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1615 fQATrackHighPtThreshold);
1617 } // end: background QA
1620 fFFBckgHisto0RecCuts = new AliFragFuncHistos("Bckg"+title[0]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1621 fFFNBinsPt, fFFPtMin, fFFPtMax,
1622 fFFNBinsXi, fFFXiMin, fFFXiMax,
1623 fFFNBinsZ , fFFZMin , fFFZMax);
1625 fFFBckgHisto0Gen = new AliFragFuncHistos("Bckg"+title[0]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1626 fFFNBinsPt, fFFPtMin, fFFPtMax,
1627 fFFNBinsXi, fFFXiMin, fFFXiMax,
1628 fFFNBinsZ , fFFZMin , fFFZMax);
1630 if(fBckgType[1] != kBckgNone){
1631 fFFBckgHisto1RecCuts = new AliFragFuncHistos("Bckg"+title[1]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1632 fFFNBinsPt, fFFPtMin, fFFPtMax,
1633 fFFNBinsXi, fFFXiMin, fFFXiMax,
1634 fFFNBinsZ , fFFZMin , fFFZMax);
1635 fFFBckgHisto1Gen = new AliFragFuncHistos("Bckg"+title[1]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1636 fFFNBinsPt, fFFPtMin, fFFPtMax,
1637 fFFNBinsXi, fFFXiMin, fFFXiMax,
1638 fFFNBinsZ , fFFZMin , fFFZMax);
1640 if(fBckgType[2] != kBckgNone){
1641 fFFBckgHisto2RecCuts = new AliFragFuncHistos("Bckg"+title[2]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1642 fFFNBinsPt, fFFPtMin, fFFPtMax,
1643 fFFNBinsXi, fFFXiMin, fFFXiMax,
1644 fFFNBinsZ , fFFZMin , fFFZMax);
1646 fFFBckgHisto2Gen = new AliFragFuncHistos("Bckg"+title[2]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1647 fFFNBinsPt, fFFPtMin, fFFPtMax,
1648 fFFNBinsXi, fFFXiMin, fFFXiMax,
1649 fFFNBinsZ , fFFZMin , fFFZMax);
1651 if(fBckgType[3] != kBckgNone){
1652 fFFBckgHisto3RecCuts = new AliFragFuncHistos("Bckg"+title[3]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1653 fFFNBinsPt, fFFPtMin, fFFPtMax,
1654 fFFNBinsXi, fFFXiMin, fFFXiMax,
1655 fFFNBinsZ , fFFZMin , fFFZMax);
1657 fFFBckgHisto3Gen = new AliFragFuncHistos("Bckg"+title[3]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1658 fFFNBinsPt, fFFPtMin, fFFPtMax,
1659 fFFNBinsXi, fFFXiMin, fFFXiMax,
1660 fFFNBinsZ , fFFZMin , fFFZMax);
1662 if(fBckgType[4] != kBckgNone){
1663 fFFBckgHisto4RecCuts = new AliFragFuncHistos("Bckg"+title[4]+"RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1664 fFFNBinsPt, fFFPtMin, fFFPtMax,
1665 fFFNBinsXi, fFFXiMin, fFFXiMax,
1666 fFFNBinsZ , fFFZMin , fFFZMax);
1668 fFFBckgHisto4Gen = new AliFragFuncHistos("Bckg"+title[4]+"Gen", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1669 fFFNBinsPt, fFFPtMin, fFFPtMax,
1670 fFFNBinsXi, fFFXiMin, fFFXiMax,
1671 fFFNBinsZ , fFFZMin , fFFZMax);
1674 fFFBckgHisto0RecEffRec = new AliFragFuncHistos("Bckg"+title[0]+"RecEffRec", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1675 fFFNBinsPt, fFFPtMin, fFFPtMax,
1676 fFFNBinsXi, fFFXiMin, fFFXiMax,
1677 fFFNBinsZ , fFFZMin , fFFZMax);
1679 fFFBckgHisto0SecRecNS = new AliFragFuncHistos("Bckg"+title[0]+"SecRecNS", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1680 fFFNBinsPt, fFFPtMin, fFFPtMax,
1681 fFFNBinsXi, fFFXiMin, fFFXiMax,
1682 fFFNBinsZ , fFFZMin , fFFZMax);
1684 fFFBckgHisto0SecRecS = new AliFragFuncHistos("Bckg"+title[0]+"SecRecS", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1685 fFFNBinsPt, fFFPtMin, fFFPtMax,
1686 fFFNBinsXi, fFFXiMin, fFFXiMax,
1687 fFFNBinsZ , fFFZMin , fFFZMax);
1689 fFFBckgHisto0SecRecSsc = new AliFragFuncHistos("Bckg"+title[0]+"SecRecSsc", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1690 fFFNBinsPt, fFFPtMin, fFFPtMax,
1691 fFFNBinsXi, fFFXiMin, fFFXiMax,
1692 fFFNBinsZ , fFFZMin , fFFZMax);
1695 } // end: background FF
1698 } // end: background
1701 // ____________ define histograms ____________________
1704 if(fQAMode&1){ // track QA
1705 fQATrackHistosRecCuts->DefineHistos();
1706 fQATrackHistosGen->DefineHistos();
1709 if(fQAMode&2){ // jet QA
1710 fQAJetHistosRec->DefineHistos();
1711 fQAJetHistosRecCuts->DefineHistos();
1712 fQAJetHistosRecCutsLeading->DefineHistos();
1713 fQAJetHistosGen->DefineHistos();
1714 fQAJetHistosGenLeading->DefineHistos();
1715 if(fEffMode) fQAJetHistosRecEffLeading->DefineHistos();
1720 fFFHistosRecCuts->DefineHistos();
1721 fFFHistosGen->DefineHistos();
1726 fQATrackHistosRecEffGen->DefineHistos();
1727 fQATrackHistosRecEffRec->DefineHistos();
1728 fQATrackHistosSecRecNS->DefineHistos();
1729 fQATrackHistosSecRecS->DefineHistos();
1730 fQATrackHistosSecRecSsc->DefineHistos();
1733 fFFHistosRecEffRec->DefineHistos();
1734 fFFHistosSecRecNS->DefineHistos();
1735 fFFHistosSecRecS->DefineHistos();
1736 fFFHistosSecRecSsc->DefineHistos();
1738 } // end: efficiency
1743 fFFBckgHisto0RecCuts->DefineHistos();
1744 fFFBckgHisto0Gen->DefineHistos();
1745 if(fBckgType[1] != kBckgNone) fFFBckgHisto1RecCuts->DefineHistos();
1746 if(fBckgType[1] != kBckgNone) fFFBckgHisto1Gen->DefineHistos();
1747 if(fBckgType[2] != kBckgNone) fFFBckgHisto2RecCuts->DefineHistos();
1748 if(fBckgType[2] != kBckgNone) fFFBckgHisto2Gen->DefineHistos();
1749 if(fBckgType[3] != kBckgNone) fFFBckgHisto3RecCuts->DefineHistos();
1750 if(fBckgType[3] != kBckgNone) fFFBckgHisto3Gen->DefineHistos();
1751 if(fBckgType[4] != kBckgNone) fFFBckgHisto4RecCuts->DefineHistos();
1752 if(fBckgType[4] != kBckgNone) fFFBckgHisto4Gen->DefineHistos();
1755 fFFBckgHisto0RecEffRec->DefineHistos();
1756 fFFBckgHisto0SecRecNS->DefineHistos();
1757 fFFBckgHisto0SecRecS->DefineHistos();
1758 fFFBckgHisto0SecRecSsc->DefineHistos();
1763 fQABckgHisto0RecCuts->DefineHistos();
1764 fQABckgHisto0Gen->DefineHistos();
1765 if(fBckgType[1] != kBckgNone) fQABckgHisto1RecCuts->DefineHistos();
1766 if(fBckgType[1] != kBckgNone) fQABckgHisto1Gen->DefineHistos();
1767 if(fBckgType[2] != kBckgNone) fQABckgHisto2RecCuts->DefineHistos();
1768 if(fBckgType[2] != kBckgNone) fQABckgHisto2Gen->DefineHistos();
1769 if(fBckgType[3] != kBckgNone) fQABckgHisto3RecCuts->DefineHistos();
1770 if(fBckgType[3] != kBckgNone) fQABckgHisto3Gen->DefineHistos();
1771 if(fBckgType[4] != kBckgNone) fQABckgHisto4RecCuts->DefineHistos();
1772 if(fBckgType[4] != kBckgNone) fQABckgHisto4Gen->DefineHistos();
1774 } // end: background
1777 Bool_t genJets = (fJetTypeGen != kJetsUndef) ? kTRUE : kFALSE;
1778 Bool_t genTracks = (fTrackTypeGen != kTrackUndef) ? kTRUE : kFALSE;
1779 Bool_t recJetsEff = (fJetTypeRecEff != kJetsUndef) ? kTRUE : kFALSE;
1781 fCommonHistList->Add(fh1EvtSelection);
1782 fCommonHistList->Add(fh1EvtMult);
1783 fCommonHistList->Add(fh1EvtCent);
1784 fCommonHistList->Add(fh1VertexNContributors);
1785 fCommonHistList->Add(fh1VertexZ);
1786 fCommonHistList->Add(fh1nRecJetsCuts);
1787 fCommonHistList->Add(fh1Xsec);
1788 fCommonHistList->Add(fh1Trials);
1789 fCommonHistList->Add(fh1PtHard);
1790 fCommonHistList->Add(fh1PtHardTrials);
1792 if(genJets) fCommonHistList->Add(fh1nGenJets);
1796 fFFHistosRecCuts->AddToOutput(fCommonHistList);
1797 if(genJets && genTracks){
1798 fFFHistosGen->AddToOutput(fCommonHistList);
1805 fFFBckgHisto0RecCuts->AddToOutput(fCommonHistList);
1806 if(fBckgType[1] != kBckgNone) fFFBckgHisto1RecCuts->AddToOutput(fCommonHistList);
1807 if(fBckgType[2] != kBckgNone) fFFBckgHisto2RecCuts->AddToOutput(fCommonHistList);
1808 if(fBckgType[3] != kBckgNone) fFFBckgHisto3RecCuts->AddToOutput(fCommonHistList);
1809 if(fBckgType[4] != kBckgNone) fFFBckgHisto4RecCuts->AddToOutput(fCommonHistList);
1811 if(genJets && genTracks){
1812 fFFBckgHisto0Gen->AddToOutput(fCommonHistList);
1813 if(fBckgType[1] != kBckgNone) fFFBckgHisto1Gen->AddToOutput(fCommonHistList);
1814 if(fBckgType[2] != kBckgNone) fFFBckgHisto2Gen->AddToOutput(fCommonHistList);
1815 if(fBckgType[3] != kBckgNone) fFFBckgHisto3Gen->AddToOutput(fCommonHistList);
1816 if(fBckgType[4] != kBckgNone) fFFBckgHisto4Gen->AddToOutput(fCommonHistList);
1820 fFFBckgHisto0RecEffRec->AddToOutput(fCommonHistList);
1821 fFFBckgHisto0SecRecNS->AddToOutput(fCommonHistList);
1822 fFFBckgHisto0SecRecS->AddToOutput(fCommonHistList);
1823 fFFBckgHisto0SecRecSsc->AddToOutput(fCommonHistList);
1828 fQABckgHisto0RecCuts->AddToOutput(fCommonHistList);
1829 if(fBckgType[1] != kBckgNone) fQABckgHisto1RecCuts->AddToOutput(fCommonHistList);
1830 if(fBckgType[2] != kBckgNone) fQABckgHisto2RecCuts->AddToOutput(fCommonHistList);
1831 if(fBckgType[3] != kBckgNone) fQABckgHisto3RecCuts->AddToOutput(fCommonHistList);
1832 if(fBckgType[4] != kBckgNone) fQABckgHisto4RecCuts->AddToOutput(fCommonHistList);
1833 if(genJets && genTracks){
1834 fQABckgHisto0Gen->AddToOutput(fCommonHistList);
1835 if(fBckgType[1] != kBckgNone) fQABckgHisto1Gen->AddToOutput(fCommonHistList);
1836 if(fBckgType[2] != kBckgNone) fQABckgHisto2Gen->AddToOutput(fCommonHistList);
1837 if(fBckgType[3] != kBckgNone) fQABckgHisto3Gen->AddToOutput(fCommonHistList);
1838 if(fBckgType[4] != kBckgNone) fQABckgHisto4Gen->AddToOutput(fCommonHistList);
1842 if(fh1BckgMult0) fCommonHistList->Add(fh1BckgMult0);
1843 if(fBckgType[1] != kBckgNone) fCommonHistList->Add(fh1BckgMult1);
1844 if(fBckgType[2] != kBckgNone) fCommonHistList->Add(fh1BckgMult2);
1845 if(fBckgType[3] != kBckgNone) fCommonHistList->Add(fh1BckgMult3);
1846 if(fBckgType[4] != kBckgNone) fCommonHistList->Add(fh1BckgMult4);
1850 if(fBranchEmbeddedJets.Length()){
1851 fCommonHistList->Add(fh1FractionPtEmbedded);
1852 fCommonHistList->Add(fh1IndexEmbedded);
1853 fCommonHistList->Add(fh2DeltaPtVsJetPtEmbedded);
1854 fCommonHistList->Add(fh2DeltaPtVsRecJetPtEmbedded);
1855 fCommonHistList->Add(fh1DeltaREmbedded);
1856 fCommonHistList->Add(fh1nEmbeddedJets);
1862 if(fQAMode&1){ // track QA
1863 fQATrackHistosRecCuts->AddToOutput(fCommonHistList);
1864 if(genTracks) fQATrackHistosGen->AddToOutput(fCommonHistList);
1867 if(fQAMode&2){ // jet QA
1868 fQAJetHistosRec->AddToOutput(fCommonHistList);
1869 fQAJetHistosRecCuts->AddToOutput(fCommonHistList);
1870 fQAJetHistosRecCutsLeading->AddToOutput(fCommonHistList);
1871 if(recJetsEff && fEffMode) fQAJetHistosRecEffLeading->AddToOutput(fCommonHistList);
1873 fQAJetHistosGen->AddToOutput(fCommonHistList);
1874 fQAJetHistosGenLeading->AddToOutput(fCommonHistList);
1880 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
1881 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
1882 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)) {
1883 fCommonHistList->Add(fh1nRecBckgJetsCuts);
1884 if(genJets) fCommonHistList->Add(fh1nGenBckgJets);
1888 if(fEffMode && recJetsEff && genTracks){
1890 fQATrackHistosRecEffGen->AddToOutput(fCommonHistList);
1891 fQATrackHistosRecEffRec->AddToOutput(fCommonHistList);
1892 fQATrackHistosSecRecNS->AddToOutput(fCommonHistList);
1893 fQATrackHistosSecRecS->AddToOutput(fCommonHistList);
1894 fQATrackHistosSecRecSsc->AddToOutput(fCommonHistList);
1897 fFFHistosRecEffRec->AddToOutput(fCommonHistList);
1898 fFFHistosSecRecNS->AddToOutput(fCommonHistList);
1899 fFFHistosSecRecS->AddToOutput(fCommonHistList);
1900 fFFHistosSecRecSsc->AddToOutput(fCommonHistList);
1902 fCommonHistList->Add(fh1nRecEffJets);
1903 fCommonHistList->Add(fh2PtRecVsGenPrim);
1904 fCommonHistList->Add(fh2PtRecVsGenSec);
1910 fProNtracksLeadingJet = new TProfile("AvgNoOfTracksLeadingJet","AvgNoOfTracksLeadingJet",100,0,250,0,50);
1911 fProDelR80pcPt = new TProfile("AvgdelR80pcPt","AvgdelR80pcPt",100,0,250,0,1);
1913 if(genJets && genTracks){
1914 fProNtracksLeadingJetGen = new TProfile("AvgNoOfTracksLeadingJetGen","AvgNoOfTracksLeadingJetGen",100,0,250,0,50);
1915 fProDelR80pcPtGen = new TProfile("AvgdelR80pcPtGen","AvgdelR80pcPtGen",100,0,250,0,1);
1919 fProNtracksLeadingJetBgrPerp2 = new TProfile("AvgNoOfTracksLeadingJetBgrPerp2","AvgNoOfTracksLeadingJetBgrPerp2",100,0,250,0,50);
1922 fProNtracksLeadingJetRecPrim = new TProfile("AvgNoOfTracksLeadingJetRecPrim","AvgNoOfTracksLeadingJetRecPrim",100,0,250,0,50);
1923 fProDelR80pcPtRecPrim = new TProfile("AvgdelR80pcPtRecPrim","AvgdelR80pcPtRecPrim",100,0,250,0,1);
1924 fProNtracksLeadingJetRecSecNS = new TProfile("AvgNoOfTracksLeadingJetRecSecNS","AvgNoOfTracksLeadingJetRecSecNS",100,0,250,0,50);
1925 fProNtracksLeadingJetRecSecS = new TProfile("AvgNoOfTracksLeadingJetRecSecS","AvgNoOfTracksLeadingJetRecSecS",100,0,250,0,50);
1926 fProNtracksLeadingJetRecSecSsc = new TProfile("AvgNoOfTracksLeadingJetRecSecSsc","AvgNoOfTracksLeadingJetRecSecSsc",100,0,250,0,50);
1930 for(Int_t ii=0; ii<5; ii++){
1931 if(ii==0)strTitJS = "_JetPt20to30";
1932 if(ii==1)strTitJS = "_JetPt30to40";
1933 if(ii==2)strTitJS = "_JetPt40to60";
1934 if(ii==3)strTitJS = "_JetPt60to80";
1935 if(ii==4)strTitJS = "_JetPt80to100";
1937 fProDelRPtSum[ii] = new TProfile(Form("AvgPtSumDelR%s",strTitJS.Data()),Form("AvgPtSumDelR%s",strTitJS.Data()),50,0,1,0,250);
1938 if(genJets && genTracks)
1939 fProDelRPtSumGen[ii] = new TProfile(Form("AvgPtSumDelRGen%s",strTitJS.Data()),Form("AvgPtSumDelRGen%s",strTitJS.Data()),50,0,1,0,250);
1941 fProDelRPtSumBgrPerp2[ii] = new TProfile(Form("AvgPtSumDelRBgrPerp2%s",strTitJS.Data()),Form("AvgPtSumDelRBgrPerp2%s",strTitJS.Data()),50,0,1,0,250);
1943 fProDelRPtSumRecPrim[ii] = new TProfile(Form("AvgPtSumDelRRecPrim%s",strTitJS.Data()),Form("AvgPtSumDelRRecPrim%s",strTitJS.Data()),50,0,1,0,250);
1944 fProDelRPtSumRecSecNS[ii] = new TProfile(Form("AvgPtSumDelRRecSecNS%s",strTitJS.Data()),Form("AvgPtSumDelRRecSecNS%s",strTitJS.Data()),50,0,1,0,250);
1945 fProDelRPtSumRecSecS[ii] = new TProfile(Form("AvgPtSumDelRRecSecS%s",strTitJS.Data()),Form("AvgPtSumDelRRecSecS%s",strTitJS.Data()),50,0,1,0,250);
1946 fProDelRPtSumRecSecSsc[ii] = new TProfile(Form("AvgPtSumDelRRecSecSsc%s",strTitJS.Data()),Form("AvgPtSumDelRRecSecSsc%s",strTitJS.Data()),50,0,1,0,250);
1950 fCommonHistList->Add(fProNtracksLeadingJet);
1951 fCommonHistList->Add(fProDelR80pcPt);
1952 for(int ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSum[ii]);
1954 if(genJets && genTracks){
1955 fCommonHistList->Add(fProNtracksLeadingJetGen);
1956 fCommonHistList->Add(fProDelR80pcPtGen);
1957 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumGen[ii]);
1961 fCommonHistList->Add(fProNtracksLeadingJetBgrPerp2);
1962 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumBgrPerp2[ii]);
1966 fCommonHistList->Add(fProNtracksLeadingJetRecPrim);
1967 fCommonHistList->Add(fProDelR80pcPtRecPrim);
1968 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumRecPrim[ii]);
1970 fCommonHistList->Add(fProNtracksLeadingJetRecSecNS);
1971 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumRecSecNS[ii]);
1973 fCommonHistList->Add(fProNtracksLeadingJetRecSecS);
1974 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumRecSecS[ii]);
1976 fCommonHistList->Add(fProNtracksLeadingJetRecSecSsc);
1977 for(Int_t ii=0; ii<5; ii++) fCommonHistList->Add(fProDelRPtSumRecSecSsc[ii]);
1981 // =========== Switch on Sumw2 for all histos ===========
1982 for (Int_t i=0; i<fCommonHistList->GetEntries(); ++i){
1983 TH1 *h1 = dynamic_cast<TH1*>(fCommonHistList->At(i));
1984 if (h1) h1->Sumw2();
1986 THnSparse *hnSparse = dynamic_cast<THnSparse*>(fCommonHistList->At(i));
1987 if(hnSparse) hnSparse->Sumw2();
1991 TH1::AddDirectory(oldStatus);
1993 PostData(1, fCommonHistList);
1996 //_______________________________________________
1997 void AliAnalysisTaskFragmentationFunction::Init()
2000 if(fDebug > 1) Printf("AliAnalysisTaskFragmentationFunction::Init()");
2004 //_____________________________________________________________
2005 void AliAnalysisTaskFragmentationFunction::UserExec(Option_t *)
2008 // Called for each event
2009 if(fDebug > 1) Printf("AliAnalysisTaskFragmentationFunction::UserExec()");
2012 if(fDebug > 1) Printf("Analysis event #%5d", (Int_t) fEntry);
2014 // Trigger selection
2015 AliInputEventHandler* inputHandler = (AliInputEventHandler*)
2016 ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
2018 if(!(inputHandler->IsEventSelected() & fEvtSelectionMask)){
2019 fh1EvtSelection->Fill(1.);
2020 if (fDebug > 1 ) Printf(" Trigger Selection: event REJECTED ... ");
2021 PostData(1, fCommonHistList);
2025 fESD = dynamic_cast<AliESDEvent*>(InputEvent());
2027 if(fDebug>3) Printf("%s:%d ESDEvent not found in the input", (char*)__FILE__,__LINE__);
2030 fMCEvent = MCEvent();
2032 if(fDebug>3) Printf("%s:%d MCEvent not found in the input", (char*)__FILE__,__LINE__);
2035 // get AOD event from input/ouput
2036 TObject* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
2037 if( handler && handler->InheritsFrom("AliAODInputHandler") ) {
2038 fAOD = ((AliAODInputHandler*)handler)->GetEvent();
2039 if(fUseAODInputJets) fAODJets = fAOD;
2040 if (fDebug > 1) Printf("%s:%d AOD event from input", (char*)__FILE__,__LINE__);
2043 handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
2044 if( handler && handler->InheritsFrom("AliAODHandler") ) {
2045 fAOD = ((AliAODHandler*)handler)->GetAOD();
2047 if (fDebug > 1) Printf("%s:%d AOD event from output", (char*)__FILE__,__LINE__);
2051 if(!fAODJets && !fUseAODInputJets){ // case we have AOD in input & output and want jets from output
2052 TObject* outHandler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
2053 if( outHandler && outHandler->InheritsFrom("AliAODHandler") ) {
2054 fAODJets = ((AliAODHandler*)outHandler)->GetAOD();
2055 if (fDebug > 1) Printf("%s:%d jets from output AOD", (char*)__FILE__,__LINE__);
2059 if(fNonStdFile.Length()!=0){
2060 // case we have an AOD extension - fetch the jets from the extended output
2062 AliAODHandler *aodH = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
2063 fAODExtension = (aodH?aodH->GetExtension(fNonStdFile.Data()):0);
2065 if(fDebug>1)Printf("AODExtension not found for %s",fNonStdFile.Data());
2070 Printf("%s:%d AODEvent not found", (char*)__FILE__,__LINE__);
2074 Printf("%s:%d AODEvent with jet branch not found", (char*)__FILE__,__LINE__);
2079 // event selection **************************************************
2080 // *** event class ***
2081 Double_t centPercent = -1;
2084 if(handler->InheritsFrom("AliAODInputHandler")){
2085 // since it is not supported by the helper task define own classes
2086 centPercent = fAOD->GetHeader()->GetCentrality();
2088 if(centPercent>10) cl = 2;
2089 if(centPercent>30) cl = 3;
2090 if(centPercent>50) cl = 4;
2093 cl = AliAnalysisHelperJetTasks::EventClass();
2094 if(fESD) centPercent = fESD->GetCentrality()->GetCentralityPercentile("V0M"); // retrieve value 'by hand'
2097 if(cl!=fEventClass){
2098 // event not in selected event class, reject event
2099 if (fDebug > 1) Printf("%s:%d event not in selected event class: event REJECTED ...",(char*)__FILE__,__LINE__);
2100 fh1EvtSelection->Fill(2.);
2101 PostData(1, fCommonHistList);
2106 // *** vertex cut ***
2107 AliAODVertex* primVtx = fAOD->GetPrimaryVertex();
2108 Int_t nTracksPrim = primVtx->GetNContributors();
2109 fh1VertexNContributors->Fill(nTracksPrim);
2112 if (fDebug > 1) Printf("%s:%d primary vertex selection: %d", (char*)__FILE__,__LINE__,nTracksPrim);
2114 if (fDebug > 1) Printf("%s:%d primary vertex selection: event REJECTED...",(char*)__FILE__,__LINE__);
2115 fh1EvtSelection->Fill(3.);
2116 PostData(1, fCommonHistList);
2120 fh1VertexZ->Fill(primVtx->GetZ());
2122 if(TMath::Abs(primVtx->GetZ())>fMaxVertexZ){
2123 if (fDebug > 1) Printf("%s:%d primary vertex z = %f: event REJECTED...",(char*)__FILE__,__LINE__,primVtx->GetZ());
2124 fh1EvtSelection->Fill(4.);
2125 PostData(1, fCommonHistList);
2129 TString primVtxName(primVtx->GetName());
2131 if(primVtxName.CompareTo("TPCVertex",TString::kIgnoreCase) == 1){
2132 if (fDebug > 1) Printf("%s:%d primary vertex selection: TPC vertex, event REJECTED...",(char*)__FILE__,__LINE__);
2133 fh1EvtSelection->Fill(5.);
2134 PostData(1, fCommonHistList);
2138 if (fDebug > 1) Printf("%s:%d event ACCEPTED ...",(char*)__FILE__,__LINE__);
2139 fh1EvtSelection->Fill(0.);
2140 fh1EvtCent->Fill(centPercent);
2143 //___ get MC information __________________________________________________________________
2145 fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
2147 Double_t ptHard = 0.;
2148 Double_t nTrials = 1; // trials for MC trigger weight for real data
2151 AliGenEventHeader* genHeader = fMCEvent->GenEventHeader();
2155 AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
2156 AliGenHijingEventHeader* hijingGenHeader = 0x0;
2158 if(pythiaGenHeader){
2159 if(fDebug>3) Printf("%s:%d pythiaGenHeader found", (char*)__FILE__,__LINE__);
2160 nTrials = pythiaGenHeader->Trials();
2161 ptHard = pythiaGenHeader->GetPtHard();
2163 fh1PtHard->Fill(ptHard);
2164 fh1PtHardTrials->Fill(ptHard,nTrials);
2166 } else { // no pythia, hijing?
2168 if(fDebug>3) Printf("%s:%d no pythiaGenHeader found", (char*)__FILE__,__LINE__);
2170 hijingGenHeader = dynamic_cast<AliGenHijingEventHeader*>(genHeader);
2171 if(!hijingGenHeader){
2172 Printf("%s:%d no pythiaGenHeader or hjingGenHeader found", (char*)__FILE__,__LINE__);
2174 if(fDebug>3) Printf("%s:%d hijingGenHeader found", (char*)__FILE__,__LINE__);
2178 //fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
2182 //___ fetch jets __________________________________________________________________________
2184 Int_t nJ = GetListOfJets(fJetsRec, kJetsRec);
2186 if(nJ>=0) nRecJets = fJetsRec->GetEntries();
2187 if(fDebug>2)Printf("%s:%d Selected Rec jets: %d %d",(char*)__FILE__,__LINE__,nJ,nRecJets);
2188 if(nJ != nRecJets) Printf("%s:%d Mismatch Selected Rec Jets: %d %d",(char*)__FILE__,__LINE__,nJ,nRecJets);
2190 Int_t nJCuts = GetListOfJets(fJetsRecCuts, kJetsRecAcceptance);
2191 Int_t nRecJetsCuts = 0;
2192 if(nJCuts>=0) nRecJetsCuts = fJetsRecCuts->GetEntries();
2193 if(fDebug>2)Printf("%s:%d Selected Rec jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2194 if(nRecJetsCuts != nJCuts) Printf("%s:%d Mismatch selected Rec jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2195 fh1nRecJetsCuts->Fill(nRecJetsCuts);
2197 if(fJetTypeGen==kJetsKine || fJetTypeGen == kJetsKineAcceptance) fJetsGen->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2199 Int_t nJGen = GetListOfJets(fJetsGen, fJetTypeGen);
2201 if(nJGen>=0) nGenJets = fJetsGen->GetEntries();
2202 if(fDebug>2)Printf("%s:%d Selected Gen jets: %d %d",(char*)__FILE__,__LINE__,nJGen,nGenJets);
2204 if(nJGen != nGenJets) Printf("%s:%d Mismatch selected Gen jets: %d %d",(char*)__FILE__,__LINE__,nJGen,nGenJets);
2205 fh1nGenJets->Fill(nGenJets);
2208 if(fJetTypeRecEff==kJetsKine || fJetTypeRecEff == kJetsKineAcceptance) fJetsRecEff->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2209 Int_t nJRecEff = GetListOfJets(fJetsRecEff, fJetTypeRecEff);
2210 Int_t nRecEffJets = 0;
2211 if(nJRecEff>=0) nRecEffJets = fJetsRecEff->GetEntries();
2212 if(fDebug>2)Printf("%s:%d Selected RecEff jets: %d %d",(char*)__FILE__,__LINE__,nJRecEff,nRecEffJets);
2213 if(nJRecEff != nRecEffJets) Printf("%s:%d Mismatch selected RecEff jets: %d %d",(char*)__FILE__,__LINE__,nJRecEff,nRecEffJets);
2214 fh1nRecEffJets->Fill(nRecEffJets);
2217 Int_t nEmbeddedJets = 0;
2218 TArrayI iEmbeddedMatchIndex;
2219 TArrayF fEmbeddedPtFraction;
2222 if(fBranchEmbeddedJets.Length()){
2223 Int_t nJEmbedded = GetListOfJets(fJetsEmbedded, kJetsEmbedded);
2224 if(nJEmbedded>=0) nEmbeddedJets = fJetsEmbedded->GetEntries();
2225 if(fDebug>2)Printf("%s:%d Selected Embedded jets: %d %d",(char*)__FILE__,__LINE__,nJEmbedded,nEmbeddedJets);
2226 if(nJEmbedded != nEmbeddedJets) Printf("%s:%d Mismatch Selected Embedded Jets: %d %d",(char*)__FILE__,__LINE__,nJEmbedded,nEmbeddedJets);
2227 fh1nEmbeddedJets->Fill(nEmbeddedJets);
2229 Float_t maxDist = 0.3;
2231 iEmbeddedMatchIndex.Set(nEmbeddedJets);
2232 fEmbeddedPtFraction.Set(nEmbeddedJets);
2234 iEmbeddedMatchIndex.Reset(-1);
2235 fEmbeddedPtFraction.Reset(0);
2237 AliAnalysisHelperJetTasks::GetJetMatching(fJetsEmbedded, nEmbeddedJets,
2238 fJetsRecCuts, nRecJetsCuts,
2239 iEmbeddedMatchIndex, fEmbeddedPtFraction,
2244 //____ fetch background clusters ___________________________________________________
2246 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
2247 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
2248 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)){
2250 Int_t nBJ = GetListOfBckgJets(fBckgJetsRec, kJetsRec);
2251 Int_t nRecBckgJets = 0;
2252 if(nBJ>=0) nRecBckgJets = fBckgJetsRec->GetEntries();
2253 if(fDebug>2)Printf("%s:%d Selected Rec background jets: %d %d",(char*)__FILE__,__LINE__,nBJ,nRecBckgJets);
2254 if(nBJ != nRecBckgJets) Printf("%s:%d Mismatch Selected Rec background jets: %d %d",(char*)__FILE__,__LINE__,nBJ,nRecBckgJets);
2256 Int_t nBJCuts = GetListOfBckgJets(fBckgJetsRecCuts, kJetsRecAcceptance);
2257 Int_t nRecBckgJetsCuts = 0;
2258 if(nBJCuts>=0) nRecBckgJetsCuts = fBckgJetsRecCuts->GetEntries();
2259 if(fDebug>2)Printf("%s:%d Selected Rec background jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2260 if(nRecBckgJetsCuts != nBJCuts) Printf("%s:%d Mismatch selected Rec background jets after cuts: %d %d",(char*)__FILE__,__LINE__,nBJCuts,nRecBckgJetsCuts);
2261 fh1nRecBckgJetsCuts->Fill(nRecBckgJetsCuts);
2263 if(0){ // protection OB - not yet implemented
2264 if(fJetTypeGen==kJetsKine || fJetTypeGen == kJetsKineAcceptance) fBckgJetsGen->SetOwner(kTRUE); // kine aod jets allocated on heap, delete them with TList::Clear()
2265 Int_t nBJGen = GetListOfBckgJets(fBckgJetsGen, fJetTypeGen);
2266 Int_t nGenBckgJets = 0;
2267 if(nBJGen>=0) nGenBckgJets = fBckgJetsGen->GetEntries();
2268 if(fDebug>2)Printf("%s:%d Selected Gen background jets: %d %d",(char*)__FILE__,__LINE__,nBJGen,nGenBckgJets);
2269 if(nBJGen != nGenBckgJets) Printf("%s:%d Mismatch selected Gen background jets: %d %d",(char*)__FILE__,__LINE__,nBJGen,nGenBckgJets);
2270 fh1nGenBckgJets->Fill(nGenBckgJets);
2275 //____ fetch particles __________________________________________________________
2278 if(fUseExtraTracks == 1) nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODExtraCuts);
2279 else if(fUseExtraTracks == -1) nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODExtraonlyCuts);
2280 else nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODCuts);
2282 Int_t nRecPartCuts = 0;
2283 if(nTCuts>=0) nRecPartCuts = fTracksRecCuts->GetEntries();
2284 if(fDebug>2)Printf("%s:%d Selected Rec tracks after cuts: %d %d",(char*)__FILE__,__LINE__,nTCuts,nRecPartCuts);
2285 if(nRecPartCuts != nTCuts) Printf("%s:%d Mismatch selected Rec tracks after cuts: %d %d",(char*)__FILE__,__LINE__,nTCuts,nRecPartCuts);
2286 fh1EvtMult->Fill(nRecPartCuts);
2289 Int_t nTGen = GetListOfTracks(fTracksGen,fTrackTypeGen);
2291 if(nTGen>=0) nGenPart = fTracksGen->GetEntries();
2292 if(fDebug>2)Printf("%s:%d Selected Gen tracks: %d %d",(char*)__FILE__,__LINE__,nTGen,nGenPart);
2293 if(nGenPart != nTGen) Printf("%s:%d Mismatch selected Gen tracks: %d %d",(char*)__FILE__,__LINE__,nTGen,nGenPart);
2296 //____ analysis, fill histos ___________________________________________________
2301 for(Int_t it=0; it<nRecPartCuts; ++it){
2302 AliVParticle *part = dynamic_cast<AliVParticle*>(fTracksRecCuts->At(it));
2303 if(part)fQATrackHistosRecCuts->FillTrackQA( part->Eta(), TVector2::Phi_0_2pi(part->Phi()), part->Pt() );
2305 for(Int_t it=0; it<nGenPart; ++it){
2306 AliVParticle *part = dynamic_cast<AliVParticle*>(fTracksGen->At(it));
2307 if(part)fQATrackHistosGen->FillTrackQA( part->Eta(), TVector2::Phi_0_2pi(part->Phi()), part->Pt());
2313 for(Int_t ij=0; ij<nRecJets; ++ij){
2314 AliAODJet* jet = dynamic_cast<AliAODJet*>(fJetsRec->At(ij));
2315 if(jet)fQAJetHistosRec->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2320 if(fQAMode || fFFMode){
2321 for(Int_t ij=0; ij<nRecJetsCuts; ++ij){
2323 AliAODJet* jet = (AliAODJet*)(fJetsRecCuts->At(ij));
2324 if(fQAMode&2) fQAJetHistosRecCuts->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2326 if(ij==0){ // leading jet
2328 if(fQAMode&2) fQAJetHistosRecCutsLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
2330 Double_t ptFractionEmbedded = 0;
2331 AliAODJet* embeddedJet = 0;
2333 if(fBranchEmbeddedJets.Length()){ // find embedded jet
2335 Int_t indexEmbedded = -1;
2336 for(Int_t i=0; i<nEmbeddedJets; i++){
2337 if(iEmbeddedMatchIndex[i] == ij){
2339 ptFractionEmbedded = fEmbeddedPtFraction[i];
2343 fh1IndexEmbedded->Fill(indexEmbedded);
2344 fh1FractionPtEmbedded->Fill(ptFractionEmbedded);
2346 if(indexEmbedded>-1){
2348 embeddedJet = dynamic_cast<AliAODJet*>(fJetsEmbedded->At(indexEmbedded));
2349 if(!embeddedJet) continue;
2351 Double_t deltaPt = jet->Pt() - embeddedJet->Pt();
2352 Double_t deltaR = jet->DeltaR((AliVParticle*) (embeddedJet));
2354 fh2DeltaPtVsJetPtEmbedded->Fill(embeddedJet->Pt(),deltaPt);
2355 fh2DeltaPtVsRecJetPtEmbedded->Fill(jet->Pt(),deltaPt);
2356 fh1DeltaREmbedded->Fill(deltaR);
2360 // get tracks in jet
2361 TList* jettracklist = new TList();
2362 Double_t sumPt = 0.;
2363 Bool_t isBadJet = kFALSE;
2365 if(GetFFRadius()<=0){
2366 GetJetTracksTrackrefs(jettracklist, jet, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
2368 if(fUseEmbeddedJetAxis){
2369 if(embeddedJet) GetJetTracksPointing(fTracksRecCuts, jettracklist, embeddedJet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
2371 else GetJetTracksPointing(fTracksRecCuts, jettracklist, jet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
2374 if(GetFFMinNTracks()>0 && jettracklist->GetSize()<=GetFFMinNTracks()) isBadJet = kTRUE;
2376 if(isBadJet) continue;
2378 if(ptFractionEmbedded>=fCutFractionPtEmbedded){ // if no embedding: ptFraction = cutFraction = 0
2380 for(Int_t it=0; it<jettracklist->GetSize(); ++it){
2382 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(jettracklist->At(it));
2383 if(!trackVP)continue;
2385 AliAODTrack * aodtrack = dynamic_cast<AliAODTrack*>(jettracklist->At(it));
2386 if(!aodtrack) continue;
2388 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
2390 Float_t jetPt = jet->Pt();
2391 if(fUseEmbeddedJetPt){
2392 if(embeddedJet) jetPt = embeddedJet->Pt();
2395 Float_t trackPt = trackV->Pt();
2398 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2400 if(fFFMode) fFFHistosRecCuts->FillFF(trackPt, jetPt, incrementJetPt);
2407 if(fBckgType[0]!=kBckgNone)
2408 FillBckgHistos(fBckgType[0], fTracksRecCuts, fJetsRecCuts, jet,
2409 fFFBckgHisto0RecCuts,fQABckgHisto0RecCuts, fh1BckgMult0);
2410 if(fBckgType[1]!=kBckgNone)
2411 FillBckgHistos(fBckgType[1], fTracksRecCuts, fJetsRecCuts, jet,
2412 fFFBckgHisto1RecCuts,fQABckgHisto1RecCuts, fh1BckgMult1);
2413 if(fBckgType[2]!=kBckgNone)
2414 FillBckgHistos(fBckgType[2], fTracksRecCuts, fJetsRecCuts, jet,
2415 fFFBckgHisto2RecCuts,fQABckgHisto2RecCuts, fh1BckgMult2);
2416 if(fBckgType[3]!=kBckgNone)
2417 FillBckgHistos(fBckgType[3], fTracksRecCuts, fJetsRecCuts, jet,
2418 fFFBckgHisto3RecCuts,fQABckgHisto3RecCuts, fh1BckgMult3);
2419 if(fBckgType[4]!=kBckgNone)
2420 FillBckgHistos(fBckgType[4], fTracksRecCuts, fJetsRecCuts, jet,
2421 fFFBckgHisto4RecCuts,fQABckgHisto4RecCuts, fh1BckgMult4);
2422 } // end if(fBckgMode)
2425 if(fJSMode) FillJetShape(jet, jettracklist, fProNtracksLeadingJet, fProDelRPtSum, fProDelR80pcPt);
2427 delete jettracklist;
2429 } // end: cut embedded ratio
2430 } // end: leading jet
2431 } // end: rec. jets after cuts
2434 for(Int_t ij=0; ij<nGenJets; ++ij){
2436 AliAODJet* jet = dynamic_cast<AliAODJet*>(fJetsGen->At(ij));
2438 if(fQAMode&2) fQAJetHistosGen->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2440 if(ij==0){ // leading jet
2442 if(fQAMode&2) fQAJetHistosGenLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
2444 TList* jettracklist = new TList();
2445 Double_t sumPt = 0.;
2446 Bool_t isBadJet = kFALSE;
2448 if(GetFFRadius()<=0){
2449 GetJetTracksTrackrefs(jettracklist, jet, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
2451 GetJetTracksPointing(fTracksGen, jettracklist, jet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);
2454 if(GetFFMinNTracks()>0 && jettracklist->GetSize()<=GetFFMinNTracks()) isBadJet = kTRUE;;
2455 if(isBadJet) continue;
2457 for(Int_t it=0; it<jettracklist->GetSize(); ++it){
2459 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(jettracklist->At(it));
2460 if(!trackVP)continue;
2461 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
2463 Float_t jetPt = jet->Pt();
2464 Float_t trackPt = trackV->Pt();
2466 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2468 if(fFFMode) fFFHistosGen->FillFF( trackPt, jetPt, incrementJetPt );
2474 if(fBckgType[0]!=kBckgNone)
2475 FillBckgHistos(fBckgType[0], fTracksGen, fJetsGen, jet,
2476 fFFBckgHisto0Gen, fQABckgHisto0Gen);
2477 if(fBckgType[1]!=kBckgNone)
2478 FillBckgHistos(fBckgType[1], fTracksGen, fJetsGen, jet,
2479 fFFBckgHisto1Gen, fQABckgHisto1Gen);
2480 if(fBckgType[2]!=kBckgNone)
2481 FillBckgHistos(fBckgType[2], fTracksGen, fJetsGen, jet,
2482 fFFBckgHisto2Gen, fQABckgHisto2Gen);
2483 if(fBckgType[3]!=kBckgNone)
2484 FillBckgHistos(fBckgType[3], fTracksGen, fJetsGen, jet,
2485 fFFBckgHisto3Gen, fQABckgHisto3Gen);
2486 if(fBckgType[4]!=kBckgNone)
2487 FillBckgHistos(fBckgType[4], fTracksGen, fJetsGen, jet,
2488 fFFBckgHisto4Gen, fQABckgHisto4Gen);
2489 } // end if(fBckgMode)
2492 if(fJSMode) FillJetShape(jet, jettracklist, fProNtracksLeadingJetGen, fProDelRPtSumGen, fProDelR80pcPtGen);
2494 delete jettracklist;
2497 } // end: QA, FF and intra-jet
2500 // ____ efficiency _______________________________
2502 if(fEffMode && (fJetTypeRecEff != kJetsUndef)){
2504 // arrays holding for each generated particle the reconstructed AOD track index & isPrimary flag, are initialized in AssociateGenRec(...) function
2508 // array holding for each reconstructed AOD track generated particle index, initialized in AssociateGenRec(...) function
2511 // ... and another set for secondaries from strange/non strange mothers (secondary MC tracks are stored in different lists)
2512 TArrayI indexAODTrSecNS;
2514 TArrayI indexMCTrSecNS;
2516 TArrayI indexAODTrSecS;
2518 TArrayI indexMCTrSecS;
2520 Int_t nTracksAODMCCharged = GetListOfTracks(fTracksAODMCCharged, kTrackAODMCCharged);
2521 if(fDebug>2)Printf("%s:%d selected AODMC tracks: %d ",(char*)__FILE__,__LINE__,nTracksAODMCCharged);
2523 Int_t nTracksAODMCChargedSecNS = GetListOfTracks(fTracksAODMCChargedSecNS, kTrackAODMCChargedSecNS);
2524 if(fDebug>2)Printf("%s:%d selected AODMC secondary tracks NS: %d ",(char*)__FILE__,__LINE__,nTracksAODMCChargedSecNS);
2526 Int_t nTracksAODMCChargedSecS = GetListOfTracks(fTracksAODMCChargedSecS, kTrackAODMCChargedSecS);
2527 if(fDebug>2)Printf("%s:%d selected AODMC secondary tracks S: %d ",(char*)__FILE__,__LINE__,nTracksAODMCChargedSecS);
2529 Int_t nTracksRecQualityCuts = GetListOfTracks(fTracksRecQualityCuts, kTrackAODQualityCuts);
2530 if(fDebug>2)Printf("%s:%d selected rec tracks quality after cuts, full acceptance/pt : %d ",(char*)__FILE__,__LINE__,nTracksRecQualityCuts);
2532 // associate gen and rec tracks, store indices in TArrays
2533 AssociateGenRec(fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,indexMCTr,isGenPrim,fh2PtRecVsGenPrim);
2534 AssociateGenRec(fTracksAODMCChargedSecNS,fTracksRecQualityCuts,indexAODTrSecNS,indexMCTrSecNS,isGenSecNS,fh2PtRecVsGenSec);
2535 AssociateGenRec(fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,indexMCTrSecS,isGenSecS,fh2PtRecVsGenSec);
2538 if(fQAMode&1) FillSingleTrackHistosRecGen(fQATrackHistosRecEffGen,fQATrackHistosRecEffRec,fTracksAODMCCharged,indexAODTr,isGenPrim);
2541 if(fQAMode&1) FillSingleTrackHistosRecGen(0x0,fQATrackHistosSecRecNS,fTracksAODMCChargedSecNS,indexAODTrSecNS,isGenSecNS);
2542 if(fQAMode&1) FillSingleTrackHistosRecGen(0x0,fQATrackHistosSecRecS,fTracksAODMCChargedSecS,indexAODTrSecS,isGenSecS);
2543 if(fQAMode&1) FillSingleTrackHistosRecGen(0x0,fQATrackHistosSecRecSsc,fTracksAODMCChargedSecS,indexAODTrSecS,isGenSecS,kTRUE);
2547 Double_t sumPtGenLeadingJetRecEff = 0;
2548 Double_t sumPtGenLeadingJetSec = 0;
2549 Double_t sumPtRecLeadingJetRecEff = 0;
2551 for(Int_t ij=0; ij<nRecEffJets; ++ij){ // jet loop
2553 AliAODJet* jet = (AliAODJet*)(fJetsRecEff->At(ij));
2555 Bool_t isBadJetGenPrim = kFALSE;
2556 Bool_t isBadJetGenSec = kFALSE;
2557 Bool_t isBadJetRec = kFALSE;
2560 if(ij==0){ // leading jet
2562 // for efficiency: gen tracks from pointing with gen/rec jet
2563 TList* jettracklistGenPrim = new TList();
2565 // if radius<0 -> trackRefs: collect gen tracks in wide radius + fill FF recEff rec histos with tracks contained in track refs
2566 // note : FF recEff gen histos will be somewhat useless in this approach
2568 if(GetFFRadius() >0)
2569 GetJetTracksPointing(fTracksAODMCCharged, jettracklistGenPrim, jet, GetFFRadius(), sumPtGenLeadingJetRecEff, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetGenPrim);
2571 GetJetTracksPointing(fTracksAODMCCharged, jettracklistGenPrim, jet, TMath::Abs(GetFFRadius())+0.2, sumPtGenLeadingJetRecEff, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetGenPrim);
2573 TList* jettracklistGenSecNS = new TList();
2574 if(GetFFRadius() >0)
2575 GetJetTracksPointing(fTracksAODMCChargedSecNS, jettracklistGenSecNS, jet, GetFFRadius(), sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
2577 GetJetTracksPointing(fTracksAODMCChargedSecNS, jettracklistGenSecNS, jet, TMath::Abs(GetFFRadius())+0.2, sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
2579 TList* jettracklistGenSecS = new TList();
2580 if(GetFFRadius() >0)
2581 GetJetTracksPointing(fTracksAODMCChargedSecS, jettracklistGenSecS, jet, GetFFRadius(), sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
2583 GetJetTracksPointing(fTracksAODMCChargedSecS, jettracklistGenSecS, jet, TMath::Abs(GetFFRadius())+0.2, sumPtGenLeadingJetSec, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetGenSec);
2586 // bin efficiency in jet pt bins using rec tracks
2587 TList* jettracklistRec = new TList();
2588 if(GetFFRadius() >0) GetJetTracksPointing(fTracksRecCuts,jettracklistRec, jet, GetFFRadius(), sumPtRecLeadingJetRecEff, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetRec);
2589 else GetJetTracksTrackrefs(jettracklistRec, jet, GetFFMinLTrackPt() , GetFFMaxTrackPt(), isBadJetRec);
2592 Double_t jetEta = jet->Eta();
2593 Double_t jetPhi = TVector2::Phi_0_2pi(jet->Phi());
2595 if(GetFFMinNTracks()>0 && jettracklistGenPrim->GetSize()<=GetFFMinNTracks()) isBadJetGenPrim = kTRUE;
2596 if(GetFFMinNTracks()>0 && jettracklistGenSecNS->GetSize()<=GetFFMinNTracks()) isBadJetGenSec = kTRUE;
2597 if(GetFFMinNTracks()>0 && jettracklistRec->GetSize()<=GetFFMinNTracks()) isBadJetRec = kTRUE;
2599 if(isBadJetRec) continue;
2601 if(fQAMode&2) fQAJetHistosRecEffLeading->FillJetQA( jetEta, jetPhi, sumPtGenLeadingJetRecEff );
2605 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosRecEffRec,jet,
2606 jettracklistGenPrim,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim,
2607 0,kFALSE,fJSMode,fProNtracksLeadingJetRecPrim,fProDelRPtSumRecPrim,fProDelR80pcPtRecPrim);
2609 else FillJetTrackHistosRec(fFFHistosRecEffRec,jet,
2610 jettracklistGenPrim,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim,
2611 jettracklistRec,kFALSE,fJSMode,fProNtracksLeadingJetRecPrim,fProDelRPtSumRecPrim,fProDelR80pcPtRecPrim);
2614 // secondaries: use jet pt from primaries
2615 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosSecRecNS,jet,
2616 jettracklistGenSecNS,fTracksAODMCChargedSecNS,fTracksRecQualityCuts, indexAODTrSecNS,isGenSecNS,
2617 0,kFALSE,fJSMode,fProNtracksLeadingJetRecSecNS,fProDelRPtSumRecSecNS);
2619 else FillJetTrackHistosRec(fFFHistosSecRecNS,jet,
2620 jettracklistGenSecNS,fTracksAODMCChargedSecNS,fTracksRecQualityCuts,indexAODTrSecNS,isGenSecNS,
2621 jettracklistRec,kFALSE,fJSMode,fProNtracksLeadingJetRecSecNS,fProDelRPtSumRecSecNS);
2623 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosSecRecS,jet,
2624 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
2625 0,kFALSE,fJSMode,fProNtracksLeadingJetRecSecS,fProDelRPtSumRecSecS);
2627 else FillJetTrackHistosRec(fFFHistosSecRecS,jet,
2628 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
2629 jettracklistRec,kFALSE,fJSMode,fProNtracksLeadingJetRecSecS,fProDelRPtSumRecSecS);
2631 if(GetFFRadius()>0) FillJetTrackHistosRec(fFFHistosSecRecSsc,jet,
2632 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
2633 0,kTRUE,fJSMode,fProNtracksLeadingJetRecSecSsc,fProDelRPtSumRecSecSsc);
2635 else FillJetTrackHistosRec(fFFHistosSecRecSsc,jet,
2636 jettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,
2637 jettracklistRec,kTRUE,fJSMode,fProNtracksLeadingJetRecSecSsc,fProDelRPtSumRecSecSsc);
2640 delete jettracklistGenPrim;
2641 delete jettracklistGenSecNS;
2642 delete jettracklistGenSecS;
2643 delete jettracklistRec;
2646 if(fBckgMode && fFFMode){
2648 TList* perpjettracklistGen = new TList();
2649 TList* perpjettracklistGen1 = new TList();
2650 TList* perpjettracklistGen2 = new TList();
2652 Double_t sumPtGenPerp = 0.;
2653 Double_t sumPtGenPerp1 = 0.;
2654 Double_t sumPtGenPerp2 = 0.;
2655 GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksAODMCCharged, perpjettracklistGen1, jet, TMath::Abs(GetFFRadius()) , sumPtGenPerp1);
2656 GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2.,fTracksAODMCCharged, perpjettracklistGen2, jet, TMath::Abs(GetFFRadius()) , sumPtGenPerp2);
2658 perpjettracklistGen->AddAll(perpjettracklistGen1);
2659 perpjettracklistGen->AddAll(perpjettracklistGen2);
2660 sumPtGenPerp = 0.5*(sumPtGenPerp1+sumPtGenPerp2);
2662 TList* perpjettracklistGenSecNS = new TList();
2663 TList* perpjettracklistGenSecNS1 = new TList();
2664 TList* perpjettracklistGenSecNS2 = new TList();
2666 Double_t sumPtGenPerpNS;
2667 Double_t sumPtGenPerpNS1;
2668 Double_t sumPtGenPerpNS2;
2669 GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksAODMCChargedSecNS, perpjettracklistGenSecNS1, jet, TMath::Abs(GetFFRadius()) , sumPtGenPerpNS1);
2670 GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2.,fTracksAODMCChargedSecNS, perpjettracklistGenSecNS2, jet, TMath::Abs(GetFFRadius()) , sumPtGenPerpNS2);
2672 perpjettracklistGenSecNS->AddAll(perpjettracklistGenSecNS1);
2673 perpjettracklistGenSecNS->AddAll(perpjettracklistGenSecNS2);
2674 sumPtGenPerpNS = 0.5*(sumPtGenPerpNS1+sumPtGenPerpNS2);
2677 TList* perpjettracklistGenSecS = new TList();
2678 TList* perpjettracklistGenSecS1 = new TList();
2679 TList* perpjettracklistGenSecS2 = new TList();
2681 Double_t sumPtGenPerpS;
2682 Double_t sumPtGenPerpS1;
2683 Double_t sumPtGenPerpS2;
2684 GetTracksTiltedwrpJetAxis(TMath::Pi()/2.,fTracksAODMCChargedSecS, perpjettracklistGenSecS1, jet, TMath::Abs(GetFFRadius()) , sumPtGenPerpS1);
2685 GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2.,fTracksAODMCChargedSecS, perpjettracklistGenSecS2, jet, TMath::Abs(GetFFRadius()) , sumPtGenPerpS2);
2687 perpjettracklistGenSecS->AddAll(perpjettracklistGenSecS1);
2688 perpjettracklistGenSecS->AddAll(perpjettracklistGenSecS2);
2689 sumPtGenPerpS = 0.5*(sumPtGenPerpS1+sumPtGenPerpS2);
2692 if(perpjettracklistGen->GetSize() != perpjettracklistGen1->GetSize() + perpjettracklistGen2->GetSize()){
2693 cout<<" ERROR: perpjettracklistGen size "<<perpjettracklistGen->GetSize()<<" perp1 "<<perpjettracklistGen1->GetSize()
2694 <<" perp2 "<<perpjettracklistGen2->GetSize()<<endl;
2698 if(perpjettracklistGenSecNS->GetSize() != perpjettracklistGenSecNS1->GetSize() + perpjettracklistGenSecNS2->GetSize()){
2699 cout<<" ERROR: perpjettracklistGenSecNS size "<<perpjettracklistGenSecNS->GetSize()<<" perp1 "<<perpjettracklistGenSecNS1->GetSize()
2700 <<" perp2 "<<perpjettracklistGenSecNS2->GetSize()<<endl;
2704 if(perpjettracklistGenSecS->GetSize() != perpjettracklistGenSecS1->GetSize() + perpjettracklistGenSecS2->GetSize()){
2705 cout<<" ERROR: perpjettracklistGenSecS size "<<perpjettracklistGenSecS->GetSize()<<" perp1 "<<perpjettracklistGenSecS1->GetSize()
2706 <<" perp2 "<<perpjettracklistGenSecS2->GetSize()<<endl;
2711 FillJetTrackHistosRec(fFFBckgHisto0RecEffRec,jet,
2712 perpjettracklistGen,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim);
2714 FillJetTrackHistosRec(fFFBckgHisto0SecRecNS,jet,
2715 perpjettracklistGenSecNS,fTracksAODMCChargedSecNS,fTracksRecQualityCuts,indexAODTrSecNS,isGenSecNS);
2717 FillJetTrackHistosRec(fFFBckgHisto0SecRecS,jet,
2718 perpjettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS);
2720 FillJetTrackHistosRec(fFFBckgHisto0SecRecSsc,jet,
2721 perpjettracklistGenSecS,fTracksAODMCChargedSecS,fTracksRecQualityCuts,indexAODTrSecS,isGenSecS,0,kTRUE);
2724 delete perpjettracklistGen;
2725 delete perpjettracklistGen1;
2726 delete perpjettracklistGen2;
2728 delete perpjettracklistGenSecNS;
2729 delete perpjettracklistGenSecNS1;
2730 delete perpjettracklistGenSecNS2;
2732 delete perpjettracklistGenSecS;
2733 delete perpjettracklistGenSecS1;
2734 delete perpjettracklistGenSecS2;
2741 //___________________
2743 fTracksRecCuts->Clear();
2744 fTracksGen->Clear();
2745 fTracksAODMCCharged->Clear();
2746 fTracksAODMCChargedSecNS->Clear();
2747 fTracksAODMCChargedSecS->Clear();
2748 fTracksRecQualityCuts->Clear();
2751 fJetsRecCuts->Clear();
2753 fJetsRecEff->Clear();
2754 fJetsEmbedded->Clear();
2758 (fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
2759 fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
2760 fBckgType[3]==kBckgClustersOutLeading || fBckgType[4]==kBckgClustersOutLeading)){
2762 fBckgJetsRec->Clear();
2763 fBckgJetsRecCuts->Clear();
2764 fBckgJetsGen->Clear();
2769 PostData(1, fCommonHistList);
2772 //______________________________________________________________
2773 void AliAnalysisTaskFragmentationFunction::Terminate(Option_t *)
2777 if(fDebug > 1) printf("AliAnalysisTaskFragmentationFunction::Terminate() \n");
2780 //_________________________________________________________________________________
2781 Int_t AliAnalysisTaskFragmentationFunction::GetListOfTracks(TList *list, Int_t type)
2783 // fill list of tracks selected according to type
2785 if(fDebug > 2) Printf("%s:%d Selecting tracks with %d", (char*)__FILE__,__LINE__,type);
2788 if(fDebug>1) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
2792 if(!fAOD) return -1;
2794 if(!fAOD->GetTracks()) return 0;
2796 if(type==kTrackUndef) return 0;
2800 if(type==kTrackAODExtraCuts || type==kTrackAODExtraonlyCuts || type==kTrackAODExtra || type==kTrackAODExtraonly){
2802 TClonesArray *aodExtraTracks = dynamic_cast<TClonesArray*>(fAOD->FindListObject("aodExtraTracks"));
2803 if(!aodExtraTracks)return iCount;
2804 for(int it =0; it<aodExtraTracks->GetEntries(); it++) {
2805 AliVParticle *track = dynamic_cast<AliVParticle*> ((*aodExtraTracks)[it]);
2806 if (!track) continue;
2808 AliAODTrack *tr = dynamic_cast<AliAODTrack*> (track);
2811 if(type==kTrackAODExtraCuts || type==kTrackAODExtraonlyCuts){
2813 if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask))) continue;
2815 if(tr->Eta() < fTrackEtaMin || tr->Eta() > fTrackEtaMax) continue;
2816 if(tr->Phi() < fTrackPhiMin || tr->Phi() > fTrackPhiMax) continue;
2817 if(tr->Pt() < fTrackPtCut) continue;
2825 if(type==kTrackAODCuts || type==kTrackAODQualityCuts || type==kTrackAOD || type==kTrackAODExtraCuts || type==kTrackAODExtra){
2827 // all rec. tracks, esd filter mask, eta range
2829 for(Int_t it=0; it<fAOD->GetNumberOfTracks(); ++it){
2830 AliAODTrack *tr = fAOD->GetTrack(it);
2832 if(type == kTrackAODCuts || type==kTrackAODQualityCuts || type==kTrackAODExtraCuts){
2834 if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask))) continue;
2835 if(type == kTrackAODCuts){
2836 if(tr->Eta() < fTrackEtaMin || tr->Eta() > fTrackEtaMax) continue;
2837 if(tr->Phi() < fTrackPhiMin || tr->Phi() > fTrackPhiMax) continue;
2838 if(tr->Pt() < fTrackPtCut) continue;
2845 else if (type==kTrackKineAll || type==kTrackKineCharged || type==kTrackKineChargedAcceptance){
2846 // kine particles, all or rather charged
2847 if(!fMCEvent) return iCount;
2849 for(Int_t it=0; it<fMCEvent->GetNumberOfTracks(); ++it){
2850 AliMCParticle* part = (AliMCParticle*) fMCEvent->GetTrack(it);
2852 if(type == kTrackKineCharged || type == kTrackKineChargedAcceptance){
2853 if(part->Charge()==0) continue;
2855 if(type == kTrackKineChargedAcceptance &&
2856 ( part->Eta() < fTrackEtaMin
2857 || part->Eta() > fTrackEtaMax
2858 || part->Phi() < fTrackPhiMin
2859 || part->Phi() > fTrackPhiMax
2860 || part->Pt() < fTrackPtCut)) continue;
2867 else if (type==kTrackAODMCCharged || type==kTrackAODMCAll || type==kTrackAODMCChargedAcceptance || type==kTrackAODMCChargedSecNS || type==kTrackAODMCChargedSecS) {
2868 // MC particles (from AOD), physical primaries, all or rather charged or rather charged within acceptance
2869 if(!fAOD) return -1;
2871 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
2872 if(!tca)return iCount;
2874 for(int it=0; it<tca->GetEntriesFast(); ++it){
2875 AliAODMCParticle *part = dynamic_cast<AliAODMCParticle*>(tca->At(it));
2877 if(type != kTrackAODMCChargedSecNS && type != kTrackAODMCChargedSecS && !part->IsPhysicalPrimary())continue;
2878 if((type == kTrackAODMCChargedSecNS || type == kTrackAODMCChargedSecS) && part->IsPhysicalPrimary())continue;
2880 if (type==kTrackAODMCCharged || type==kTrackAODMCChargedAcceptance || type==kTrackAODMCChargedSecNS || type==kTrackAODMCChargedSecS){
2881 if(part->Charge()==0) continue;
2883 if(type==kTrackAODMCChargedSecNS || type==kTrackAODMCChargedSecS){
2884 Bool_t isFromStrange = kFALSE;
2885 Int_t iMother = part->GetMother();
2887 AliAODMCParticle *partM = dynamic_cast<AliAODMCParticle*>(tca->At(iMother));
2888 if(!partM) continue;
2890 Int_t codeM = TMath::Abs(partM->GetPdgCode());
2891 Int_t mfl = Int_t (codeM/ TMath::Power(10, Int_t(TMath::Log10(codeM))));
2892 if (mfl == 3 && codeM != 3) isFromStrange = kTRUE;
2895 // cout<<" mfl "<<mfl<<" codeM "<<partM->GetPdgCode()<<" code this track "<<part->GetPdgCode()<<endl;
2896 // cout<<" index this track "<<it<<" index daughter 0 "<<partM->GetDaughter(0)<<" 1 "<<partM->GetDaughter(1)<<endl;
2899 if(type==kTrackAODMCChargedSecNS && isFromStrange) continue;
2900 if(type==kTrackAODMCChargedSecS && !isFromStrange) continue;
2904 if(type==kTrackAODMCChargedAcceptance &&
2905 ( part->Eta() > fTrackEtaMax
2906 || part->Eta() < fTrackEtaMin
2907 || part->Phi() > fTrackPhiMax
2908 || part->Phi() < fTrackPhiMin
2909 || part->Pt() < fTrackPtCut)) continue;
2921 // _______________________________________________________________________________
2922 Int_t AliAnalysisTaskFragmentationFunction::GetListOfJets(TList *list, Int_t type)
2924 // fill list of jets selected according to type
2927 if(fDebug>1) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
2931 if(type == kJetsRec || type == kJetsRecAcceptance){ // reconstructed jets
2933 if(fBranchRecJets.Length()==0){
2934 Printf("%s:%d no rec jet branch specified", (char*)__FILE__,__LINE__);
2935 if(fDebug>1)fAOD->Print();
2939 TClonesArray *aodRecJets = 0;
2940 if(fBranchRecJets.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchRecJets.Data()));
2941 if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchRecJets.Data()));
2942 if(fAODExtension&&!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchRecJets.Data()));
2945 if(fBranchRecJets.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchRecJets.Data());
2946 if(fDebug>1)fAOD->Print();
2950 // Reorder jet pt and fill new temporary AliAODJet objects
2953 for(Int_t ij=0; ij<aodRecJets->GetEntries(); ++ij){
2955 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodRecJets->At(ij));
2958 if( tmp->Pt() < fJetPtCut ) continue;
2959 if( type == kJetsRecAcceptance &&
2960 ( tmp->Eta() < fJetEtaMin
2961 || tmp->Eta() > fJetEtaMax
2962 || tmp->Phi() < fJetPhiMin
2963 || tmp->Phi() > fJetPhiMax )) continue;
2974 else if(type == kJetsKine || type == kJetsKineAcceptance){
2980 if(fDebug>1) Printf("%s:%d no mcEvent",(char*)__FILE__,__LINE__);
2984 AliGenEventHeader* genHeader = fMCEvent->GenEventHeader();
2985 AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
2986 AliGenHijingEventHeader* hijingGenHeader = 0x0;
2988 if(!pythiaGenHeader){
2989 hijingGenHeader = dynamic_cast<AliGenHijingEventHeader*>(genHeader);
2991 if(!hijingGenHeader){
2992 Printf("%s:%d no pythiaGenHeader or hijingGenHeader found", (char*)__FILE__,__LINE__);
2995 TLorentzVector mom[4];
2997 hijingGenHeader->GetJets(mom[0], mom[1], mom[2], mom[3]);
2999 for(Int_t i=0; i<2; ++i){
3000 if(!mom[i].Pt()) continue;
3001 jet[i] = new AliAODJet(mom[i]);
3003 if( type == kJetsKineAcceptance &&
3004 ( jet[i]->Eta() < fJetEtaMin
3005 || jet[i]->Eta() > fJetEtaMax
3006 || jet[i]->Phi() < fJetPhiMin
3007 || jet[i]->Phi() > fJetPhiMax )) continue;
3017 // fetch the pythia generated jets
3018 for(int ip=0; ip<pythiaGenHeader->NTriggerJets(); ++ip){
3021 AliAODJet *jet = new AliAODJet();
3022 pythiaGenHeader->TriggerJet(ip, p);
3023 jet->SetPxPyPzE(p[0], p[1], p[2], p[3]);
3025 if( type == kJetsKineAcceptance &&
3026 ( jet->Eta() < fJetEtaMin
3027 || jet->Eta() > fJetEtaMax
3028 || jet->Phi() < fJetPhiMin
3029 || jet->Phi() > fJetPhiMax )) continue;
3037 else if(type == kJetsGen || type == kJetsGenAcceptance ){
3039 if(fBranchGenJets.Length()==0){
3040 if(fDebug>1) Printf("%s:%d no gen jet branch specified", (char*)__FILE__,__LINE__);
3044 TClonesArray *aodGenJets = 0;
3045 if(fBranchGenJets.Length()) aodGenJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchGenJets.Data()));
3046 if(!aodGenJets) aodGenJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchGenJets.Data()));
3047 if(fAODExtension&&!aodGenJets) aodGenJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchGenJets.Data()));
3051 if(fBranchGenJets.Length()) Printf("%s:%d Generated jet branch %s not found",(char*)__FILE__,__LINE__,fBranchGenJets.Data());
3053 if(fDebug>1)fAOD->Print();
3059 for(Int_t ig=0; ig<aodGenJets->GetEntries(); ++ig){
3061 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodGenJets->At(ig));
3064 if( tmp->Pt() < fJetPtCut ) continue;
3065 if( type == kJetsGenAcceptance &&
3066 ( tmp->Eta() < fJetEtaMin
3067 || tmp->Eta() > fJetEtaMax
3068 || tmp->Phi() < fJetPhiMin
3069 || tmp->Phi() > fJetPhiMax )) continue;
3077 else if(type == kJetsEmbedded){ // embedded jets
3079 if(fBranchEmbeddedJets.Length()==0){
3080 Printf("%s:%d no embedded jet branch specified", (char*)__FILE__,__LINE__);
3081 if(fDebug>1)fAOD->Print();
3085 TClonesArray *aodEmbeddedJets = 0;
3086 if(fBranchEmbeddedJets.Length()) aodEmbeddedJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchEmbeddedJets.Data()));
3087 if(!aodEmbeddedJets) aodEmbeddedJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchEmbeddedJets.Data()));
3088 if(fAODExtension&&!aodEmbeddedJets) aodEmbeddedJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchEmbeddedJets.Data()));
3090 if(!aodEmbeddedJets){
3091 if(fBranchEmbeddedJets.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchEmbeddedJets.Data());
3092 if(fDebug>1)fAOD->Print();
3096 // Reorder jet pt and fill new temporary AliAODJet objects
3097 Int_t nEmbeddedJets = 0;
3099 for(Int_t ij=0; ij<aodEmbeddedJets->GetEntries(); ++ij){
3101 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodEmbeddedJets->At(ij));
3104 if( tmp->Pt() < fJetPtCut ) continue;
3105 if( tmp->Eta() < fJetEtaMin
3106 || tmp->Eta() > fJetEtaMax
3107 || tmp->Phi() < fJetPhiMin
3108 || tmp->Phi() > fJetPhiMax ) continue;
3116 return nEmbeddedJets;
3119 if(fDebug>0)Printf("%s:%d no such type %d",(char*)__FILE__,__LINE__,type);
3124 // ___________________________________________________________________________________
3125 Int_t AliAnalysisTaskFragmentationFunction::GetListOfBckgJets(TList *list, Int_t type)
3127 // fill list of bgr clusters selected according to type
3129 if(type == kJetsRec || type == kJetsRecAcceptance){ // reconstructed jets
3131 if(fBranchRecBckgClusters.Length()==0){
3132 Printf("%s:%d no rec jet branch specified", (char*)__FILE__,__LINE__);
3133 if(fDebug>1)fAOD->Print();
3137 TClonesArray *aodRecJets = 0;
3138 if(fBranchRecBckgClusters.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchRecBckgClusters.Data()));
3139 if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchRecBckgClusters.Data()));
3140 if(fAODExtension&&!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchRecBckgClusters.Data()));
3143 if(fBranchRecBckgClusters.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchRecBckgClusters.Data());
3144 if(fDebug>1)fAOD->Print();
3148 // Reorder jet pt and fill new temporary AliAODJet objects
3151 for(Int_t ij=0; ij<aodRecJets->GetEntries(); ++ij){
3153 AliAODJet *tmp = dynamic_cast<AliAODJet*>(aodRecJets->At(ij));
3156 // if( tmp->Pt() < fJetPtCut ) continue; // no pt cut on bckg clusters !
3157 if( type == kJetsRecAcceptance &&
3158 ( tmp->Eta() < fJetEtaMin
3159 || tmp->Eta() > fJetEtaMax
3160 || tmp->Phi() < fJetPhiMin
3161 || tmp->Phi() > fJetPhiMax )) continue;
3175 // MC clusters still Under construction
3181 // _________________________________________________________________________________________________________
3182 void AliAnalysisTaskFragmentationFunction::SetProperties(THnSparse* h,const Int_t dim, const char** labels)
3184 // Set properties of THnSparse
3186 for(Int_t i=0; i<dim; i++){
3187 h->GetAxis(i)->SetTitle(labels[i]);
3188 h->GetAxis(i)->SetTitleColor(1);
3192 // __________________________________________________________________________________________
3193 void AliAnalysisTaskFragmentationFunction::SetProperties(TH1* h,const char* x, const char* y)
3195 //Set properties of histos (x and y title)
3199 h->GetXaxis()->SetTitleColor(1);
3200 h->GetYaxis()->SetTitleColor(1);
3203 // _________________________________________________________________________________________________________
3204 void AliAnalysisTaskFragmentationFunction::SetProperties(TH1* h,const char* x, const char* y, const char* z)
3206 //Set properties of histos (x,y and z title)
3211 h->GetXaxis()->SetTitleColor(1);
3212 h->GetYaxis()->SetTitleColor(1);
3213 h->GetZaxis()->SetTitleColor(1);
3216 // ________________________________________________________________________________________________________________________________________________________
3217 void AliAnalysisTaskFragmentationFunction::GetJetTracksPointing(TList* inputlist, TList* outputlist, const AliAODJet* jet,
3218 const Double_t radius, Double_t& sumPt, const Double_t minPtL, const Double_t maxPt, Bool_t& isBadPt)
3220 // fill list of tracks in cone around jet axis
3223 Bool_t isBadMaxPt = kFALSE;
3224 Bool_t isBadMinPt = kTRUE;
3227 jet->PxPyPz(jetMom);
3228 TVector3 jet3mom(jetMom);
3230 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
3232 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
3234 Double_t trackMom[3];
3235 track->PxPyPz(trackMom);
3236 TVector3 track3mom(trackMom);
3238 Double_t dR = jet3mom.DeltaR(track3mom);
3242 outputlist->Add(track);
3244 sumPt += track->Pt();
3246 if(maxPt>0 && track->Pt()>maxPt) isBadMaxPt = kTRUE;
3247 if(minPtL>0 && track->Pt()>minPtL) isBadMinPt = kFALSE;
3252 if(minPtL>0 && isBadMinPt) isBadPt = kTRUE;
3253 if(maxPt>0 && isBadMaxPt) isBadPt = kTRUE;
3258 // _________________________________________________________________________________________________________________________________________________________________
3259 void AliAnalysisTaskFragmentationFunction::GetJetTracksTrackrefs(TList* list, const AliAODJet* jet, const Double_t minPtL, const Double_t maxPt, Bool_t& isBadPt)
3261 // list of jet tracks from trackrefs
3263 Int_t nTracks = jet->GetRefTracks()->GetEntriesFast();
3265 Bool_t isBadMaxPt = kFALSE;
3266 Bool_t isBadMinPt = kTRUE;
3268 for(Int_t itrack=0; itrack<nTracks; itrack++) {
3270 AliVParticle* track = dynamic_cast<AliVParticle*>(jet->GetRefTracks()->At(itrack));
3272 AliError("expected ref track not found ");
3276 if(track->Pt() < fTrackPtCut) continue; // track refs may contain low pt cut (bug in AliFastJetInput)
3277 if(maxPt>0 && track->Pt()>maxPt) isBadMaxPt = kTRUE;
3278 if(minPtL>0 && track->Pt()>minPtL) isBadMinPt = kFALSE;
3284 if(minPtL>0 && isBadMinPt) isBadPt = kTRUE;
3285 if(maxPt>0 && isBadMaxPt) isBadPt = kTRUE;
3290 // _ ________________________________________________________________________________________________________________________________
3291 void AliAnalysisTaskFragmentationFunction::AssociateGenRec(TList* tracksAODMCCharged,TList* tracksRec, TArrayI& indexAODTr,TArrayI& indexMCTr,
3292 TArrayS& isRefGen,TH2F* fh2PtRecVsGen)
3294 // associate generated and reconstructed tracks, fill TArrays of list indices
3296 Int_t nTracksRec = tracksRec->GetSize();
3297 Int_t nTracksGen = tracksAODMCCharged->GetSize();
3298 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
3301 if(!nTracksGen) return;
3305 indexAODTr.Set(nTracksGen);
3306 indexMCTr.Set(nTracksRec);
3307 isRefGen.Set(nTracksGen);
3309 indexAODTr.Reset(-1);
3310 indexMCTr.Reset(-1);
3313 // loop over reconstructed tracks, get generated track
3315 for(Int_t iRec=0; iRec<nTracksRec; iRec++){
3317 AliAODTrack* rectrack = dynamic_cast<AliAODTrack*>(tracksRec->At(iRec));
3318 if(!rectrack)continue;
3319 Int_t label = TMath::Abs(rectrack->GetLabel());
3321 // find MC track in our list
3322 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tca->At(label));
3324 Int_t listIndex = -1;
3325 if(gentrack) listIndex = tracksAODMCCharged->IndexOf(gentrack);
3329 indexAODTr[listIndex] = iRec;
3330 indexMCTr[iRec] = listIndex;
3335 // define reference sample of primaries/secondaries (for reconstruction efficiency / contamination)
3337 for(Int_t iGen=0; iGen<nTracksGen; iGen++){
3339 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tracksAODMCCharged->At(iGen));
3340 if(!gentrack)continue;
3341 Int_t pdg = gentrack->GetPdgCode();
3343 // 211 - pi, 2212 - proton, 321 - Kaon, 11 - electron, 13 - muon
3344 if(TMath::Abs(pdg) == 211 || TMath::Abs(pdg) == 2212 || TMath::Abs(pdg) == 321 ||
3345 TMath::Abs(pdg) == 11 || TMath::Abs(pdg) == 13){
3347 isRefGen[iGen] = kTRUE;
3349 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
3352 Float_t genPt = gentrack->Pt();
3353 AliAODTrack* vt = dynamic_cast<AliAODTrack*>(tracksRec->At(iRec));
3355 Float_t recPt = vt->Pt();
3356 fh2PtRecVsGen->Fill(genPt,recPt);
3363 // _____________________________________________________________________________________________________________________________________________
3364 void AliAnalysisTaskFragmentationFunction::FillSingleTrackHistosRecGen(AliFragFuncQATrackHistos* trackQAGen, AliFragFuncQATrackHistos* trackQARec, TList* tracksGen,
3365 const TArrayI& indexAODTr, const TArrayS& isRefGen, const Bool_t scaleStrangeness){
3367 // fill QA for single track reconstruction efficiency
3369 Int_t nTracksGen = tracksGen->GetSize();
3371 if(!nTracksGen) return;
3373 for(Int_t iGen=0; iGen<nTracksGen; iGen++){
3375 if(isRefGen[iGen] != 1) continue; // select primaries
3377 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tracksGen->At(iGen));
3378 if(!gentrack) continue;
3379 Double_t ptGen = gentrack->Pt();
3380 Double_t etaGen = gentrack->Eta();
3381 Double_t phiGen = TVector2::Phi_0_2pi(gentrack->Phi());
3383 // apply same acc & pt cuts as for FF
3385 if(etaGen < fTrackEtaMin || etaGen > fTrackEtaMax) continue;
3386 if(phiGen < fTrackPhiMin || phiGen > fTrackPhiMax) continue;
3387 if(ptGen < fTrackPtCut) continue;
3389 if(trackQAGen) trackQAGen->FillTrackQA(etaGen, phiGen, ptGen);
3391 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
3393 if(iRec>=0 && trackQARec){
3394 if(scaleStrangeness){
3395 Double_t weight = GetMCStrangenessFactor(ptGen);
3396 trackQARec->FillTrackQA(etaGen, phiGen, ptGen, kFALSE, 0, kTRUE, weight);
3398 else trackQARec->FillTrackQA(etaGen, phiGen, ptGen);
3403 // ______________________________________________________________________________________________________________________________________________________
3405 void AliAnalysisTaskFragmentationFunction::FillJetTrackHistosRec(AliFragFuncHistos* ffhistRec, AliAODJet* jet,
3406 TList* jetTrackList, const TList* tracksGen, const TList* tracksRec, const TArrayI& indexAODTr,
3407 const TArrayS& isRefGen, TList* jetTrackListTR, const Bool_t scaleStrangeness,
3408 Bool_t fillJS, TProfile* hProNtracksLeadingJet, TProfile** hProDelRPtSum, TProfile* hProDelR80pcPt)
3410 // fill objects for jet track reconstruction efficiency or secondaries contamination
3411 // arguments histGen/histRec can be of different type: AliFragFuncHistos*, AliFragFuncIntraJetHistos*, ...
3412 // jetTrackListTR pointer: track refs if not NULL
3415 // ensure proper normalization, even for secondaries
3416 Double_t jetPtRec = jet->Pt();
3417 ffhistRec->FillFF(-1, jetPtRec, kTRUE);
3419 Int_t nTracksJet = jetTrackList->GetSize(); // list with AODMC tracks
3420 if(nTracksJet == 0) return;
3422 TList* listRecTracks = new TList();
3423 listRecTracks->Clear();
3425 for(Int_t iTr=0; iTr<nTracksJet; iTr++){ // jet tracks loop
3427 AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (jetTrackList->At(iTr));
3428 if(!gentrack)continue;
3429 // find jet track in gen tracks list
3430 Int_t iGen = tracksGen->IndexOf(gentrack);
3433 if(fDebug>0) Printf("%s:%d gen jet track not found ",(char*)__FILE__,__LINE__);
3437 if(isRefGen[iGen] != 1) continue; // select primaries
3439 Double_t ptGen = gentrack->Pt();
3440 Double_t etaGen = gentrack->Eta();
3441 Double_t phiGen = TVector2::Phi_0_2pi(gentrack->Phi());
3443 // gen level acc & pt cuts - skip in case of track refs
3444 if(!jetTrackListTR && (etaGen < fTrackEtaMin || etaGen > fTrackEtaMax)) continue;
3445 if(!jetTrackListTR && (phiGen < fTrackPhiMin || phiGen > fTrackPhiMax)) continue;
3446 if(!jetTrackListTR && ptGen < fTrackPtCut) continue;
3449 Double_t ptRec = -1;
3451 Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
3452 Bool_t isRec = (iRec>=0) ? kTRUE : kFALSE;
3454 Bool_t isJetTrack = kFALSE;
3455 if(!jetTrackListTR) isJetTrack = kTRUE; // skip trackRefs check for tracks in ideal cone
3459 AliAODTrack* rectrack = dynamic_cast<AliAODTrack*> (tracksRec->At(iRec));
3460 if(!rectrack) continue;
3462 ptRec = rectrack->Pt();
3465 Int_t iRecTR = jetTrackListTR->IndexOf(rectrack);
3466 if(iRecTR >=0 ) isJetTrack = kTRUE; // rec tracks assigned to jet
3471 Double_t trackPt = ptRec;
3472 Bool_t incrementJetPt = kFALSE;
3474 if(scaleStrangeness){
3475 Double_t weight = GetMCStrangenessFactor(ptGen);
3476 ffhistRec->FillFF( trackPt, jetPtRec, incrementJetPt, 0, kTRUE, weight );
3479 ffhistRec->FillFF( trackPt, jetPtRec, incrementJetPt );
3482 listRecTracks->Add(rectrack);
3489 if(fillJS) FillJetShape(jet,listRecTracks,hProNtracksLeadingJet, hProDelRPtSum, hProDelR80pcPt,0,0,scaleStrangeness);
3491 delete listRecTracks;
3495 // _____________________________________________________________________________________________________________________________________________________________________
3496 void AliAnalysisTaskFragmentationFunction::GetTracksTiltedwrpJetAxis(Float_t alpha, TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius,Double_t& sumPt)
3498 // List of tracks in cone perpendicular to the jet azimuthal direction
3501 jet->PxPyPz(jetMom);
3503 TVector3 jet3mom(jetMom);
3504 // Rotate phi and keep eta unchanged
3505 Double_t etaTilted = jet3mom.Eta();
3506 Double_t phiTilted = TVector2::Phi_0_2pi(jet3mom.Phi()) + alpha;
3507 if(phiTilted > 2*TMath::Pi()) phiTilted = phiTilted - 2*TMath::Pi();
3509 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
3512 if( fUseExtraTracksBgr != 1){
3513 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
3514 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3515 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3519 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
3521 Double_t trackMom[3];
3522 track->PxPyPz(trackMom);
3523 TVector3 track3mom(trackMom);
3525 Double_t deta = track3mom.Eta() - etaTilted;
3526 Double_t dphi = TMath::Abs(track3mom.Phi() - phiTilted);
3527 if (dphi > TMath::Pi()) dphi = 2. * TMath::Pi() - dphi;
3528 Double_t dR = TMath::Sqrt(deta * deta + dphi * dphi);
3532 outputlist->Add(track);
3533 sumPt += track->Pt();
3539 // ________________________________________________________________________________________________________________________________________________________
3540 void AliAnalysisTaskFragmentationFunction::GetTracksTiltedwrpJetAxisWindow(Float_t alpha, TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius,Double_t& sumPt,Double_t &normFactor)
3542 // List of tracks in cone perpendicular to the jet azimuthal direction
3545 jet->PxPyPz(jetMom);
3547 TVector3 jet3mom(jetMom);
3548 // Rotate phi and keep eta unchanged
3549 Double_t etaTilted = jet3mom.Eta();
3550 Double_t phiTilted = TVector2::Phi_0_2pi(jet3mom.Phi()) + alpha;
3551 if(phiTilted > 2*TMath::Pi()) phiTilted = phiTilted - 2*TMath::Pi();
3553 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++)
3557 if( fUseExtraTracksBgr != 1){
3558 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
3559 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3560 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3564 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
3566 Float_t trackEta = track->Eta();
3567 Float_t trackPhi = track->Phi();
3569 if( ( phiTilted-radius >= 0 ) && ( phiTilted+radius <= 2*TMath::Pi()))
3571 if((trackPhi<=phiTilted+radius) &&
3572 (trackPhi>=phiTilted-radius) &&
3573 (trackEta<=fTrackEtaMax)&&(trackEta>=fTrackEtaMin)) // 0.9 and - 0.9
3575 outputlist->Add(track);
3576 sumPt += track->Pt();
3579 else if( phiTilted-radius < 0 )
3581 if((( trackPhi < phiTilted+radius ) ||
3582 ( trackPhi > 2*TMath::Pi()-(radius-phiTilted) )) &&
3583 (( trackEta <= fTrackEtaMax ) && ( trackEta >= fTrackEtaMin )))
3585 outputlist->Add(track);
3586 sumPt += track->Pt();
3589 else if( phiTilted+radius > 2*TMath::Pi() )
3591 if((( trackPhi > phiTilted-radius ) ||
3592 ( trackPhi < phiTilted+radius-2*TMath::Pi() )) &&
3593 (( trackEta <= fTrackEtaMax ) && ( trackEta >= fTrackEtaMin )))
3595 outputlist->Add(track);
3596 sumPt += track->Pt();
3601 // Jet area - Temporarily added should be modified with the proper jet area value
3602 Float_t areaJet = CalcJetArea(etaTilted,radius);
3603 Float_t areaTilted = 2*radius*(fTrackEtaMax-fTrackEtaMin);
3605 normFactor = (Float_t) 1. / (areaJet / areaTilted);
3610 // ________________________________________________________________________________________________________________________________________________________
3611 void AliAnalysisTaskFragmentationFunction::GetTracksOutOfNJets(Int_t nCases, TList* inputlist, TList* outputlist, TList* jetlist, Double_t& sumPt)
3613 // List of tracks outside cone around N jet axis
3614 // Particles taken randomly
3617 // Int_t nj = jetlist->GetSize();
3618 Float_t rc = TMath::Abs(GetFFRadius());
3619 Float_t rcl = GetFFBckgRadius();
3621 // Estimate jet and background areas
3622 Float_t* areaJet = new Float_t[nCases];
3623 memset(areaJet, 0, sizeof(Float_t) * nCases);
3624 Float_t* areaJetLarge = new Float_t[nCases];
3625 memset(areaJetLarge, 0, sizeof(Float_t) * nCases);
3626 Float_t areaFull = (fTrackEtaMax-fTrackEtaMin)*(fTrackPhiMax-fTrackPhiMin);
3627 Float_t areaOut = areaFull;
3629 //estimate jets and background areas
3632 TList* templist = new TList();
3633 TClonesArray *vect3Jet = new TClonesArray("TVector3",nCases);
3635 for(Int_t ij=0; ij<nCases; ++ij)
3637 // Get jet information
3638 AliAODJet* jet = dynamic_cast<AliAODJet*>(jetlist->At(ij));
3641 jet3mom.SetPtEtaPhi(jet->Pt(),jet->Eta(),jet->Phi());
3642 new((*vect3Jet)[ijet]) TVector3((TVector3)jet3mom);
3643 Float_t etaJet = (Float_t)((TVector3*) vect3Jet->At(ij))->Eta();
3646 areaJet[ij] = CalcJetArea(etaJet,rc);
3648 // Area jet larger angle
3649 areaJetLarge[ij] = CalcJetArea(etaJet,rcl);
3652 areaOut = areaOut - areaJetLarge[ij];
3656 // List of all tracks outside jet areas
3657 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
3660 if( fUseExtraTracksBgr != 1){
3661 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
3662 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3663 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3667 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
3670 Double_t trackMom[3];
3671 track->PxPyPz(trackMom);
3672 TVector3 track3mom(trackMom);
3674 Double_t *dR = new Double_t[nCases];
3675 for(Int_t ij=0; ij<nCases; ij++)
3676 dR[ij] = (Double_t)((TVector3*) vect3Jet->At(ij))->DeltaR(track3mom);
3678 if((nCases==1 && (dR[0]>rcl)) ||
3679 (nCases==2 && (dR[0]>rcl && dR[1]>rcl)) ||
3680 (nCases==3 && (dR[0]>rcl && dR[1]>rcl && dR[2]>rcl)))
3682 templist->Add(track);
3688 // Take tracks randomly
3689 Int_t nScaled = (Int_t) (nOut * areaJet[0] / areaOut + 0.5);
3690 TArrayI* ar = new TArrayI(nOut);
3692 for(Int_t init=0; init<nOut; init++)
3695 Int_t *randIndex = new Int_t[nScaled];
3696 for(Int_t init2=0; init2<nScaled; init2++)
3697 randIndex[init2] = -1;
3699 // Select nScaled different random numbers in nOut
3700 for(Int_t i=0; i<nScaled; i++)
3702 Int_t* tmpArr = new Int_t[nOut-i];
3703 Int_t temp = fRandom->Integer(nOut-i);
3704 for(Int_t ind = 0; ind< ar->GetSize()-1; ind++)
3706 if(ind<temp) tmpArr[ind] = (*ar)[ind];
3707 else tmpArr[ind] = (*ar)[ind+1];
3709 randIndex[i] = (*ar)[temp];
3711 ar->Set(nOut-i-1,tmpArr);
3717 for(Int_t ipart=0; ipart<nScaled; ipart++)
3719 AliVParticle* track = (AliVParticle*)(templist->At(randIndex[ipart]));
3720 outputlist->Add(track);
3721 sumPt += track->Pt();
3728 delete [] areaJetLarge;
3731 delete [] randIndex;
3735 // ________________________________________________________________________________________________________________________________________________________
3736 void AliAnalysisTaskFragmentationFunction::GetTracksOutOfNJetsStat(Int_t nCases, TList* inputlist, TList* outputlist, TList* jetlist, Double_t& sumPt, Double_t &normFactor)
3738 // List of tracks outside cone around N jet axis
3739 // All particles taken + final scaling factor
3742 Float_t rc = TMath::Abs(GetFFRadius());
3743 Float_t rcl = GetFFBckgRadius();
3745 // Estimate jet and background areas
3746 Float_t* areaJet = new Float_t[nCases];
3747 memset(areaJet, 0, sizeof(Float_t) * nCases);
3748 Float_t* areaJetLarge = new Float_t[nCases];
3749 memset(areaJetLarge, 0, sizeof(Float_t) * nCases);
3750 Float_t areaFull = (fTrackEtaMax-fTrackEtaMin)*(fTrackPhiMax-fTrackPhiMin);
3751 Float_t areaOut = areaFull;
3753 //estimate jets and background areas
3756 TClonesArray *vect3Jet = new TClonesArray("TVector3",nCases);
3758 for(Int_t ij=0; ij<nCases; ++ij)
3760 // Get jet information
3761 AliAODJet* jet = dynamic_cast<AliAODJet*>(jetlist->At(ij));
3764 jet3mom.SetPtEtaPhi(jet->Pt(),jet->Eta(),jet->Phi());
3765 new((*vect3Jet)[ijet]) TVector3((TVector3)jet3mom);
3766 Float_t etaJet = (Float_t)((TVector3*) vect3Jet->At(ij))->Eta();
3769 areaJet[ij] = CalcJetArea(etaJet,rc);
3771 // Area jet larger angle
3772 areaJetLarge[ij] = CalcJetArea(etaJet,rcl);
3774 // Outside jets area
3775 areaOut = areaOut - areaJetLarge[ij];
3779 for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){
3782 if( fUseExtraTracksBgr != 1){
3783 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (inputlist->At(itrack))){
3784 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3785 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3789 AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
3791 Double_t trackMom[3];
3792 track->PxPyPz(trackMom);
3793 TVector3 track3mom(trackMom);
3795 Double_t *dR = new Double_t[nCases];
3796 for(Int_t ij=0; ij<nCases; ij++)
3797 dR[ij] = (Double_t)((TVector3*) vect3Jet->At(ij))->DeltaR(track3mom);
3800 (nCases==1 && (dR[0]>rcl)) ||
3801 (nCases==2 && (dR[0]>rcl && dR[1]>rcl)) ||
3802 (nCases==3 && (dR[0]>rcl && dR[1]>rcl && dR[2]>rcl)))
3804 outputlist->Add(track);
3805 sumPt += track->Pt();
3811 if(nCases==0) areaJet[0] = TMath::Pi()*rc*rc;
3812 normFactor = (Float_t) 1./(areaJet[0] / areaOut);
3817 delete [] areaJetLarge;
3822 // ______________________________________________________________________________________________________________________________________________________
3823 Float_t AliAnalysisTaskFragmentationFunction::CalcJetArea(const Float_t etaJet, const Float_t rc) const
3825 // calculate area of jet with eta etaJet and radius rc
3827 Float_t detamax = etaJet + rc;
3828 Float_t detamin = etaJet - rc;
3829 Float_t accmax = 0.0; Float_t accmin = 0.0;
3830 if(detamax > fTrackEtaMax){ // sector outside etamax
3831 Float_t h = fTrackEtaMax - etaJet;
3832 accmax = rc*rc*TMath::ACos(h/rc) - h*TMath::Sqrt(rc*rc - h*h);
3834 if(detamin < fTrackEtaMin){ // sector outside etamin
3835 Float_t h = fTrackEtaMax + etaJet;
3836 accmin = rc*rc*TMath::ACos(h/rc) - h*TMath::Sqrt(rc*rc - h*h);
3838 Float_t areaJet = rc*rc*TMath::Pi() - accmax - accmin;
3844 // ___________________________________________________________________________________________________________________________
3845 void AliAnalysisTaskFragmentationFunction::GetClusterTracksOutOf1Jet(AliAODJet* jet, TList* outputlist, Double_t &normFactor)
3847 // fill tracks from bckgCluster branch in list,
3848 // for all clusters outside jet cone
3849 // sum up total area of clusters
3851 Double_t rc = GetFFRadius();
3852 Double_t rcl = GetFFBckgRadius();
3854 Double_t areaTotal = 0;
3855 Double_t sumPtTotal = 0;
3857 for(Int_t ij=0; ij<fBckgJetsRec->GetEntries(); ++ij){
3859 AliAODJet* bgrCluster = (AliAODJet*)(fBckgJetsRec->At(ij)); // not 'recCuts': use all clusters in full eta range
3861 Double_t dR = jet->DeltaR(bgrCluster);
3863 if(dR<rcl) continue;
3865 Double_t clusterPt = bgrCluster->Pt();
3866 Double_t area = bgrCluster->EffectiveAreaCharged();
3868 sumPtTotal += clusterPt;
3870 Int_t nTracksJet = bgrCluster->GetRefTracks()->GetEntries();
3872 for(Int_t it = 0; it<nTracksJet; it++){
3874 // embedded tracks - note: using ref tracks here, fBranchRecBckgClusters has to be consistent
3875 if( fUseExtraTracksBgr != 1){
3876 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (bgrCluster->GetTrack(it))){
3877 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3878 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3882 AliVParticle* track = dynamic_cast<AliVParticle*>(bgrCluster->GetTrack(it));
3883 if(!track) continue;
3885 Float_t trackPt = track->Pt();
3886 Float_t trackEta = track->Eta();
3887 Float_t trackPhi = TVector2::Phi_0_2pi(track->Phi());
3889 if(trackEta < fTrackEtaMin || trackEta > fTrackEtaMax) continue;
3890 if(trackPhi < fTrackPhiMin || trackPhi > fTrackPhiMax) continue;
3891 if(trackPt < fTrackPtCut) continue;
3893 outputlist->Add(track);
3897 Double_t areaJet = TMath::Pi()*rc*rc;
3898 if(areaTotal) normFactor = (Float_t) 1./(areaJet / areaTotal);
3903 // _______________________________________________________________________________________________________________________
3904 void AliAnalysisTaskFragmentationFunction::GetClusterTracksMedian(TList* outputlist, Double_t &normFactor)
3906 // fill tracks from bckgCluster branch,
3907 // using cluster with median density (odd number of clusters)
3908 // or picking randomly one of the two closest to median (even number)
3912 Int_t nBckgClusters = fBckgJetsRec->GetEntries(); // not 'recCuts': use all clusters in full eta range
3914 if(nBckgClusters<3) return; // need at least 3 clusters (skipping 2 highest)
3916 Double_t* bgrDensity = new Double_t[nBckgClusters];
3917 Int_t* indices = new Int_t[nBckgClusters];
3919 for(Int_t ij=0; ij<nBckgClusters; ++ij){
3921 AliAODJet* bgrCluster = (AliAODJet*)(fBckgJetsRec->At(ij));
3922 Double_t clusterPt = bgrCluster->Pt();
3923 Double_t area = bgrCluster->EffectiveAreaCharged();
3925 Double_t density = 0;
3926 if(area>0) density = clusterPt/area;
3928 bgrDensity[ij] = density;
3932 TMath::Sort(nBckgClusters, bgrDensity, indices);
3934 // get median cluster
3936 AliAODJet* medianCluster = 0;
3937 Double_t medianDensity = 0;
3939 if(TMath::Odd(nBckgClusters)){
3941 Int_t medianIndex = indices[(Int_t) (0.5*(nBckgClusters-1))];
3942 medianCluster = (AliAODJet*)(fBckgJetsRec->At(medianIndex));
3944 Double_t clusterPt = medianCluster->Pt();
3945 Double_t area = medianCluster->EffectiveAreaCharged();
3947 if(area>0) medianDensity = clusterPt/area;
3951 Int_t medianIndex1 = indices[(Int_t) (0.5*nBckgClusters-1)];
3952 Int_t medianIndex2 = indices[(Int_t) (0.5*nBckgClusters)];
3954 AliAODJet* medianCluster1 = (AliAODJet*)(fBckgJetsRec->At(medianIndex1));
3955 AliAODJet* medianCluster2 = (AliAODJet*)(fBckgJetsRec->At(medianIndex2));
3957 Double_t density1 = 0;
3958 Double_t clusterPt1 = medianCluster1->Pt();
3959 Double_t area1 = medianCluster1->EffectiveAreaCharged();
3960 if(area1>0) density1 = clusterPt1/area1;
3962 Double_t density2 = 0;
3963 Double_t clusterPt2 = medianCluster2->Pt();
3964 Double_t area2 = medianCluster2->EffectiveAreaCharged();
3965 if(area2>0) density2 = clusterPt2/area2;
3967 medianDensity = 0.5*(density1+density2);
3969 medianCluster = ( (fRandom->Rndm()>0.5) ? medianCluster1 : medianCluster2 ); // select one randomly to avoid adding areas
3972 Int_t nTracksJet = medianCluster->GetRefTracks()->GetEntries();
3974 for(Int_t it = 0; it<nTracksJet; it++){
3976 // embedded tracks - note: using ref tracks here, fBranchRecBckgClusters has to be consistent
3977 if( fUseExtraTracksBgr != 1){
3978 if(AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*> (medianCluster->GetTrack(it))){
3979 if(fUseExtraTracksBgr == 0 && ((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3980 if(fUseExtraTracksBgr == -1 && !((trackAOD->GetFlags() & AliESDtrack::kEmbedded)>0)) continue;
3984 AliVParticle* track = dynamic_cast<AliVParticle*>(medianCluster->GetTrack(it));
3985 if(!track) continue;
3987 Float_t trackPt = track->Pt();
3988 Float_t trackEta = track->Eta();
3989 Float_t trackPhi = TVector2::Phi_0_2pi(track->Phi());
3991 if(trackEta < fTrackEtaMin || trackEta > fTrackEtaMax) continue;
3992 if(trackPhi < fTrackPhiMin || trackPhi > fTrackPhiMax) continue;
3993 if(trackPt < fTrackPtCut) continue;
3995 outputlist->Add(track);
3998 Double_t areaMedian = medianCluster->EffectiveAreaCharged();
3999 Double_t areaJet = TMath::Pi()*GetFFRadius()*GetFFRadius();
4001 if(areaMedian) normFactor = (Float_t) 1./(areaJet / areaMedian);
4005 delete[] bgrDensity;
4009 // ______________________________________________________________________________________________________________________________________________________
4010 void AliAnalysisTaskFragmentationFunction::FillBckgHistos(Int_t type, TList* inputtracklist, TList* inputjetlist, AliAODJet* jet,
4011 AliFragFuncHistos* ffbckghistocuts, AliFragFuncQATrackHistos* qabckghistocuts, TH1F* fh1Mult){
4013 // List of tracks outside jets for background study
4014 TList* tracklistout2jets = new TList();
4015 TList* tracklistout3jets = new TList();
4016 TList* tracklistout2jetsStat = new TList();
4017 TList* tracklistout3jetsStat = new TList();
4018 Double_t sumPtOut2Jets = 0.;
4019 Double_t sumPtOut3Jets = 0.;
4020 Double_t sumPtOut2JetsStat = 0.;
4021 Double_t sumPtOut3JetsStat = 0.;
4022 Double_t normFactor2Jets = 0.;
4023 Double_t normFactor3Jets = 0.;
4025 Int_t nRecJetsCuts = inputjetlist->GetEntries();
4027 if(nRecJetsCuts>1) {
4028 GetTracksOutOfNJets(2,inputtracklist, tracklistout2jets, inputjetlist, sumPtOut2Jets);
4029 GetTracksOutOfNJetsStat(2,inputtracklist, tracklistout2jetsStat, inputjetlist,sumPtOut2JetsStat, normFactor2Jets);
4032 if(nRecJetsCuts>2) {
4033 GetTracksOutOfNJets(3,inputtracklist, tracklistout3jets, inputjetlist, sumPtOut3Jets);
4034 GetTracksOutOfNJetsStat(3,inputtracklist, tracklistout3jetsStat, inputjetlist, sumPtOut3JetsStat, normFactor3Jets);
4037 if(type==kBckgOutLJ || type==kBckgOutAJ)
4039 TList* tracklistoutleading = new TList();
4040 Double_t sumPtOutLeading = 0.;
4041 GetTracksOutOfNJets(1,inputtracklist, tracklistoutleading, inputjetlist, sumPtOutLeading);
4042 if(type==kBckgOutLJ && fh1Mult) fh1Mult->Fill(tracklistoutleading->GetSize());
4044 for(Int_t it=0; it<tracklistoutleading->GetSize(); ++it){
4046 AliVParticle* trackVP = (AliVParticle*)(tracklistoutleading->At(it));
4047 if(!trackVP) continue;
4048 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4050 Float_t jetPt = jet->Pt();
4051 Float_t trackPt = trackV->Pt();
4053 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4055 if(type==kBckgOutLJ)
4057 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt);
4059 // Fill track QA for background
4060 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
4063 // All cases included
4064 if(nRecJetsCuts==1 && type==kBckgOutAJ)
4066 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
4070 // Increment jet pt with one entry in case #tracks outside jets = 0
4071 if(tracklistoutleading->GetSize()==0) {
4072 Float_t jetPt = jet->Pt();
4073 Bool_t incrementJetPt = kTRUE;
4074 if(type==kBckgOutLJ)
4076 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4078 // All cases included
4079 if(nRecJetsCuts==1 && type==kBckgOutAJ)
4081 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4084 delete tracklistoutleading;
4086 if(type==kBckgOutLJStat || type==kBckgOutAJStat)
4088 TList* tracklistoutleadingStat = new TList();
4089 Double_t sumPtOutLeadingStat = 0.;
4090 Double_t normFactorLeading = 0.;
4092 GetTracksOutOfNJetsStat(1,inputtracklist, tracklistoutleadingStat, inputjetlist, sumPtOutLeadingStat, normFactorLeading);
4093 if(type==kBckgOutLJStat && fh1Mult) fh1Mult->Fill(tracklistoutleadingStat->GetSize());
4095 for(Int_t it=0; it<tracklistoutleadingStat->GetSize(); ++it){
4097 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistoutleadingStat->At(it));
4098 if(!trackVP) continue;
4099 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4101 Float_t jetPt = jet->Pt();
4102 Float_t trackPt = trackV->Pt();
4103 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4106 if(type==kBckgOutLJStat)
4108 if(fFFMode)ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorLeading);
4110 // Fill track QA for background
4111 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt); // OB added bgr QA
4114 // All cases included
4115 if(nRecJetsCuts==1 && type==kBckgOutAJStat)
4117 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorLeading);
4118 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
4123 // Increment jet pt with one entry in case #tracks outside jets = 0
4124 if(tracklistoutleadingStat->GetSize()==0) {
4125 Float_t jetPt = jet->Pt();
4126 Bool_t incrementJetPt = kTRUE;
4127 if(type==kBckgOutLJStat)
4129 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorLeading);
4131 // All cases included
4132 if(nRecJetsCuts==1 && type==kBckgOutLJStat)
4134 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorLeading);
4138 delete tracklistoutleadingStat;
4141 if(type==kBckgPerp || type==kBckgPerp2 || type==kBckgPerp2Area)
4143 Double_t sumPtPerp1 = 0.;
4144 Double_t sumPtPerp2 = 0.;
4145 TList* tracklistperp = new TList();
4146 TList* tracklistperp1 = new TList();
4147 TList* tracklistperp2 = new TList();
4150 if(type == kBckgPerp2) norm = 2; // in FillFF() scaleFac = 1/norm = 0.5 - account for double area;
4151 if(type == kBckgPerp2Area) norm = 2*TMath::Pi()*TMath::Abs(GetFFRadius())*TMath::Abs(GetFFRadius()) / jet->EffectiveAreaCharged(); // in FillFF() scaleFac = 1/norm;
4153 GetTracksTiltedwrpJetAxis(TMath::Pi()/2., inputtracklist,tracklistperp1,jet,TMath::Abs(GetFFRadius()),sumPtPerp1);
4154 if(type==kBckgPerp2 || type==kBckgPerp2Area) GetTracksTiltedwrpJetAxis(-1*TMath::Pi()/2., inputtracklist,tracklistperp2,jet,TMath::Abs(GetFFRadius()),sumPtPerp2);
4156 tracklistperp->AddAll(tracklistperp1);
4157 tracklistperp->AddAll(tracklistperp2);
4159 if(tracklistperp->GetSize() != tracklistperp1->GetSize() + tracklistperp2->GetSize()){
4160 cout<<" ERROR: tracklistperp size "<<tracklistperp->GetSize()<<" perp1 "<<tracklistperp1->GetSize()<<" perp2 "<<tracklistperp2->GetSize()<<endl;
4164 if(fh1Mult) fh1Mult->Fill(tracklistperp->GetSize());
4166 for(Int_t it=0; it<tracklistperp->GetSize(); ++it){
4168 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistperp->At(it));
4169 if(!trackVP)continue;
4170 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4172 Float_t jetPt = jet->Pt();
4173 Float_t trackPt = trackV->Pt();
4175 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4177 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, norm );
4179 // Fill track QA for background
4180 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
4184 // Increment jet pt with one entry in case #tracks outside jets = 0
4185 if(tracklistperp->GetSize()==0) {
4186 Float_t jetPt = jet->Pt();
4187 Bool_t incrementJetPt = kTRUE;
4188 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4193 // fill for tracklistperp1/2 separately, divide norm by 2
4194 if(type==kBckgPerp){
4195 FillJetShape(jet, tracklistperp, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, TMath::Pi()/2., 0., kFALSE);
4197 if(type==kBckgPerp2){
4198 FillJetShape(jet, tracklistperp1, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, TMath::Pi()/2., 0., kFALSE);
4199 FillJetShape(jet, tracklistperp2, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, -1*TMath::Pi()/2., 0., kFALSE);
4201 if(type==kBckgPerp2Area){ // divide norm by 2: listperp1/2 filled separately
4202 FillJetShape(jet, tracklistperp1, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, TMath::Pi()/2., 0.5*norm, kFALSE);
4203 FillJetShape(jet, tracklistperp2, fProNtracksLeadingJetBgrPerp2, fProDelRPtSumBgrPerp2, 0, -1*TMath::Pi()/2., 0.5*norm, kFALSE);
4207 delete tracklistperp;
4208 delete tracklistperp1;
4209 delete tracklistperp2;
4212 if(type==kBckgASide)
4214 Double_t sumPtASide = 0.;
4215 TList* tracklistaside = new TList();
4216 GetTracksTiltedwrpJetAxis(TMath::Pi(),inputtracklist,tracklistaside,jet,TMath::Abs(GetFFRadius()),sumPtASide);
4217 if(fh1Mult) fh1Mult->Fill(tracklistaside->GetSize());
4219 for(Int_t it=0; it<tracklistaside->GetSize(); ++it){
4221 AliVParticle* trackVP = (AliVParticle*)(tracklistaside->At(it));
4222 if(!trackVP) continue;
4223 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4225 Float_t jetPt = jet->Pt();
4226 Float_t trackPt = trackV->Pt();
4228 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4230 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
4232 // Fill track QA for background
4233 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
4237 if(tracklistaside->GetSize()==0) {
4238 Float_t jetPt = jet->Pt();
4239 Bool_t incrementJetPt = kTRUE;
4240 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4243 delete tracklistaside;
4246 if(type==kBckgASideWindow)
4248 Double_t normFactorASide = 0.;
4249 Double_t sumPtASideW = 0.;
4250 TList* tracklistasidew = new TList();
4251 GetTracksTiltedwrpJetAxisWindow(TMath::Pi(),inputtracklist,tracklistasidew,jet,TMath::Abs(GetFFRadius()),sumPtASideW,normFactorASide);
4252 if(fh1Mult) fh1Mult->Fill(tracklistasidew->GetSize());
4254 for(Int_t it=0; it<tracklistasidew->GetSize(); ++it){
4256 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistasidew->At(it));
4257 if(!trackVP) continue;
4258 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4260 Float_t jetPt = jet->Pt();
4261 Float_t trackPt = trackV->Pt();
4262 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4264 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorASide);
4266 // Fill track QA for background
4267 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt, kFALSE, normFactorASide);
4271 if(tracklistasidew->GetSize()==0) {
4272 Float_t jetPt = jet->Pt();
4273 Bool_t incrementJetPt = kTRUE;
4274 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorASide);
4277 delete tracklistasidew;
4280 if(type==kBckgPerpWindow)
4282 Double_t normFactorPerp = 0.;
4283 Double_t sumPtPerpW = 0.;
4284 TList* tracklistperpw = new TList();
4285 GetTracksTiltedwrpJetAxisWindow(TMath::Pi()/2.,inputtracklist,tracklistperpw,jet,TMath::Abs(GetFFRadius()),sumPtPerpW,normFactorPerp);
4286 if(fh1Mult) fh1Mult->Fill(tracklistperpw->GetSize());
4288 for(Int_t it=0; it<tracklistperpw->GetSize(); ++it){
4290 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistperpw->At(it));
4291 if(!trackVP) continue;
4292 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4294 Float_t jetPt = jet->Pt();
4295 Float_t trackPt = trackV->Pt();
4296 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4298 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorPerp);
4300 // Fill track QA for background
4301 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt, kFALSE, normFactorPerp);
4305 if(tracklistperpw->GetSize()==0) {
4306 Float_t jetPt = jet->Pt();
4307 Bool_t incrementJetPt = kTRUE;
4308 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactorPerp);
4311 delete tracklistperpw;
4315 if(type==kBckgOut2J || type==kBckgOutAJ)
4317 if(type==kBckgOut2J && fh1Mult) fh1Mult->Fill(tracklistout2jets->GetSize());
4318 for(Int_t it=0; it<tracklistout2jets->GetSize(); ++it){
4320 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout2jets->At(it));
4321 if(!trackVP) continue;
4322 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4324 Float_t jetPt = jet->Pt();
4325 Float_t trackPt = trackV->Pt();
4327 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4329 if(type==kBckgOut2J)
4331 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
4332 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
4335 // All cases included
4336 if(nRecJetsCuts==2 && type==kBckgOutAJ)
4338 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
4343 // Increment jet pt with one entry in case #tracks outside jets = 0
4344 if(tracklistout2jets->GetSize()==0) {
4345 Float_t jetPt = jet->Pt();
4346 Bool_t incrementJetPt = kTRUE;
4347 if(type==kBckgOut2J)
4349 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4351 // All cases included
4352 if(nRecJetsCuts==2 && type==kBckgOutAJ)
4354 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4359 if(type==kBckgOut2JStat || type==kBckgOutAJStat)
4361 for(Int_t it=0; it<tracklistout2jetsStat->GetSize(); ++it){
4363 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout2jetsStat->At(it));
4364 if(!trackVP) continue;
4365 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4367 Float_t jetPt = jet->Pt();
4368 Float_t trackPt = trackV->Pt();
4369 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4371 if(type==kBckgOut2JStat)
4373 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor2Jets);
4375 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
4378 // All cases included
4379 if(nRecJetsCuts==2 && type==kBckgOutAJStat)
4381 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor2Jets);
4383 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt ); // OB added bgr QA
4387 // Increment jet pt with one entry in case #tracks outside jets = 0
4388 if(tracklistout2jetsStat->GetSize()==0) {
4389 Float_t jetPt = jet->Pt();
4390 Bool_t incrementJetPt = kTRUE;
4391 if(type==kBckgOut2JStat)
4393 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor2Jets);
4395 // All cases included
4396 if(nRecJetsCuts==2 && type==kBckgOutAJStat)
4398 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor2Jets);
4404 if(type==kBckgOut3J || type==kBckgOutAJ)
4406 if(type==kBckgOut3J && fh1Mult) fh1Mult->Fill(tracklistout3jets->GetSize());
4408 for(Int_t it=0; it<tracklistout3jets->GetSize(); ++it){
4410 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout3jets->At(it));
4411 if(!trackVP) continue;
4412 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4414 Float_t jetPt = jet->Pt();
4415 Float_t trackPt = trackV->Pt();
4417 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4419 if(type==kBckgOut3J)
4421 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
4423 qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt);
4426 // All cases included
4427 if(nRecJetsCuts==3 && type==kBckgOutAJ)
4429 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt );
4434 // Increment jet pt with one entry in case #tracks outside jets = 0
4435 if(tracklistout3jets->GetSize()==0) {
4436 Float_t jetPt = jet->Pt();
4437 Bool_t incrementJetPt = kTRUE;
4438 if(type==kBckgOut3J)
4440 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4442 // All cases included
4443 if(nRecJetsCuts==3 && type==kBckgOutAJ)
4445 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt );
4450 if(type==kBckgOut3JStat || type==kBckgOutAJStat)
4452 for(Int_t it=0; it<tracklistout3jetsStat->GetSize(); ++it){
4454 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistout3jetsStat->At(it));
4455 if(!trackVP) continue;
4456 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4458 Float_t jetPt = jet->Pt();
4459 Float_t trackPt = trackV->Pt();
4460 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4462 if(type==kBckgOut3JStat)
4464 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor3Jets);
4466 //if(fQAMode&1) qabckghistocuts->FillTrackQA( trackEta, TVector2::Phi_0_2pi(trackPhi), trackPt);
4469 // All cases included
4470 if(nRecJetsCuts==3 && type==kBckgOutAJStat)
4472 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactor3Jets );
4474 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
4479 // Increment jet pt with one entry in case #tracks outside jets = 0
4480 if(tracklistout3jetsStat->GetSize()==0) {
4481 Float_t jetPt = jet->Pt();
4482 Bool_t incrementJetPt = kTRUE;
4483 if(type==kBckgOut3JStat)
4485 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor3Jets);
4487 // All cases included
4488 if(nRecJetsCuts==3 && type==kBckgOutAJStat)
4490 if(fFFMode) ffbckghistocuts->FillFF( -1., jetPt, incrementJetPt, normFactor3Jets);
4496 if(type==kBckgClustersOutLeading){ // clusters bgr: all tracks in clusters out of leading jet
4498 TList* tracklistClustersOutLeading = new TList();
4499 Double_t normFactorClusters = 0;
4500 Float_t jetPt = jet->Pt();
4502 GetClusterTracksOutOf1Jet(jet, tracklistClustersOutLeading, normFactorClusters);
4503 if(fh1Mult) fh1Mult->Fill(tracklistClustersOutLeading->GetSize());
4505 for(Int_t it=0; it<tracklistClustersOutLeading->GetSize(); ++it){
4507 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistClustersOutLeading->At(it));
4508 if(!trackVP) continue;
4509 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4511 Float_t trackPt = trackVP->Pt();
4513 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4515 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorClusters );
4516 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
4521 delete tracklistClustersOutLeading;
4525 if(type == kBckgClusters){ // clusters bgr: all tracks in 'median cluster'
4527 TList* tracklistClustersMedian = new TList();
4528 Double_t normFactorClusters = 0;
4529 Float_t jetPt = jet->Pt();
4531 GetClusterTracksMedian(tracklistClustersMedian, normFactorClusters);
4532 if(fh1Mult) fh1Mult->Fill(tracklistClustersMedian->GetSize());
4534 for(Int_t it=0; it<tracklistClustersMedian->GetSize(); ++it){
4536 AliVParticle* trackVP = dynamic_cast<AliVParticle*>(tracklistClustersMedian->At(it));
4537 if(!trackVP) continue;
4538 TLorentzVector* trackV = new TLorentzVector(trackVP->Px(),trackVP->Py(),trackVP->Pz(),trackVP->P());
4540 Float_t trackPt = trackVP->Pt();
4542 Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4544 if(fFFMode) ffbckghistocuts->FillFF( trackPt, jetPt, incrementJetPt, normFactorClusters );
4545 if(fQAMode&1) qabckghistocuts->FillTrackQA( trackV->Eta(), TVector2::Phi_0_2pi(trackV->Phi()), trackPt );
4550 delete tracklistClustersMedian;
4553 delete tracklistout2jets;
4554 delete tracklistout3jets;
4555 delete tracklistout2jetsStat;
4556 delete tracklistout3jetsStat;
4559 // -----------------------------------------------------------------
4561 Double_t AliAnalysisTaskFragmentationFunction::GetMCStrangenessFactor(const Double_t pt)
4563 // factor strangeness data/MC as function of pt from UE analysis (Sara Vallero)
4567 if(0.150<pt && pt<0.200) alpha = 3.639;
4568 if(0.200<pt && pt<0.250) alpha = 2.097;
4569 if(0.250<pt && pt<0.300) alpha = 1.930;
4570 if(0.300<pt && pt<0.350) alpha = 1.932;
4571 if(0.350<pt && pt<0.400) alpha = 1.943;
4572 if(0.400<pt && pt<0.450) alpha = 1.993;
4573 if(0.450<pt && pt<0.500) alpha = 1.989;
4574 if(0.500<pt && pt<0.600) alpha = 1.963;
4575 if(0.600<pt && pt<0.700) alpha = 1.917;
4576 if(0.700<pt && pt<0.800) alpha = 1.861;
4577 if(0.800<pt && pt<0.900) alpha = 1.820;
4578 if(0.900<pt && pt<1.000) alpha = 1.741;
4579 if(1.000<pt && pt<1.500) alpha = 0.878;
4584 // ---------------------------------------------------------------------------------------------------------------------------------
4585 void AliAnalysisTaskFragmentationFunction::FillJetShape(AliAODJet* jet, TList* list,
4586 TProfile* hProNtracksLeadingJet, TProfile** hProDelRPtSum, TProfile* hProDelR80pcPt,
4587 Double_t dPhiUE, Double_t normUE, Bool_t scaleStrangeness){
4589 const Int_t kNbinsR = 50;
4590 const Float_t kBinWidthR = 0.02;
4592 Int_t nJetTracks = list->GetEntries();
4594 Float_t PtSumA[kNbinsR] = {0.0};
4596 Float_t *delRA = new Float_t[nJetTracks];
4597 Float_t *trackPtA = new Float_t[nJetTracks];
4598 Int_t *index = new Int_t[nJetTracks];
4600 for(Int_t i=0; i<nJetTracks; i++){
4607 jet->PxPyPz(jetMom);
4608 TVector3 jet3mom(jetMom);
4610 if(TMath::Abs(dPhiUE)>0){
4611 Double_t phiTilted = jet3mom.Phi();
4612 phiTilted += dPhiUE;
4613 phiTilted = TVector2::Phi_0_2pi(phiTilted);
4614 jet3mom.SetPhi(phiTilted);
4617 Double_t jetPt = jet->Pt();
4618 Double_t sumWeights = 0;
4620 for (Int_t j =0; j<nJetTracks; j++){
4622 AliVParticle* track = dynamic_cast<AliVParticle*>(list->At(j));
4625 Double_t trackMom[3];
4626 track->PxPyPz(trackMom);
4627 TVector3 track3mom(trackMom);
4629 Double_t dR = jet3mom.DeltaR(track3mom);
4632 trackPtA[j] = track->Pt();
4634 Double_t weight = GetMCStrangenessFactor(track->Pt()); // more correctly should be gen pt
4635 sumWeights += weight;
4637 for(Int_t ibin=1; ibin<=kNbinsR; ibin++){
4638 Float_t xlow = kBinWidthR*(ibin-1);
4639 Float_t xup = kBinWidthR*ibin;
4640 if(xlow <= dR && dR < xup){
4642 if(scaleStrangeness) PtSumA[ibin-1] += track->Pt()*weight;
4643 else PtSumA[ibin-1] += track->Pt();
4651 for(Int_t ibin=0; ibin<kNbinsR; ibin++){
4652 Float_t fR = kBinWidthR*(ibin+0.5);
4654 for(Int_t k=0; k<5; k++){
4655 if(k==0){jetPtMin=20.0;jetPtMax=30.0;}
4656 if(k==1){jetPtMin=30.0;jetPtMax=40.0;}
4657 if(k==2){jetPtMin=40.0;jetPtMax=60.0;}
4658 if(k==3){jetPtMin=60.0;jetPtMax=80.0;}
4659 if(k==4){jetPtMin=80.0;jetPtMax=100.0;}
4660 if(jetPt>jetPtMin && jetPt<jetPtMax){
4662 hProDelRPtSum[k]->Fill(fR,PtSumA[ibin]);
4668 if(scaleStrangeness) hProNtracksLeadingJet->Fill(jetPt,sumWeights);
4669 else hProNtracksLeadingJet->Fill(jetPt,nJetTracks);
4671 if(normUE) hProNtracksLeadingJet->Fill(jetPt,nJetTracks/normUE);
4676 Float_t delRPtSum80pc = 0;
4678 TMath::Sort(nJetTracks,delRA,index,0);
4680 for(Int_t ii=0; ii<nJetTracks; ii++){
4682 if(scaleStrangeness){
4683 Double_t weight = GetMCStrangenessFactor(trackPtA[index[ii]]); // more correctly should be gen pt
4684 PtSum += weight*trackPtA[index[ii]];
4686 else PtSum += trackPtA[index[ii]];
4689 if(PtSum/jetPt >= 0.8000){
4690 delRPtSum80pc = delRA[index[ii]];
4694 hProDelR80pcPt->Fill(jetPt,delRPtSum80pc);