PWGJE/AliAnalysisTaskFragmentationFunction.cxx

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