PWGJE/UserTasks/AliAnalysisTaskIDFragmentationFunction.cxx

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