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