PWGJE/StrangenessInJets/AliAnalysisTaskJetChem.cxx

   1 /*************************************************************************
   2  *                                                                       *
   3  *                                                                       *
   4  *      Task for Jet Chemistry Analysis in PWG4 Jet Task Force Train     *
   5  *    Analysis of K0s, Lambda and Antilambda with and without Jetevents  *
   6  *                                                                       *
   7  *************************************************************************/
   8
   9 /**************************************************************************
  10  * Copyright(c) 1998-2012, ALICE Experiment at CERN, All rights reserved. *
  11  *                                                                        *
  12  * Author: The ALICE Off-line Project.                                    *
  13  * Contributors are mentioned in the code where appropriate.              *
  14  *                                                                        *
  15  * Permission to use, copy, modify and distribute this software and its   *
  16  * documentation strictly for non-commercial purposes is hereby grante    *
  17  *                                                                        *
  18  * without fee, provided that the above copyright notice appears in all   *
  19  * copies and that both the copyright notice and this permission notice   *
  20  * appear in the supporting documentation. The authors make no claims     *
  21  * about the suitability of this software for any purpose. It is          *
  22  * provided "as is" without express or implied warranty.                  *
  23  **************************************************************************/
  24 //Task for K0s, Lambda and Antilambda analysis in jets
  25 //Author: Alice Zimmermann (zimmermann@physi.uni-heidelberg.de)
  26
  27
  28 /* $Id: */
  29
  30 #include <iostream>
  31 #include "TH2.h"
  32 #include "TH3.h"
  33 #include "TH2F.h"
  34 #include "TH3F.h"
  35 #include "TH2D.h"
  36 #include "TH3D.h"
  37 #include "TChain.h"
  38 #include "TTree.h"
  39 #include "TList.h"
  40 #include "TCanvas.h"
  41 #include "TPDGCode.h"
  42 #include "TProfile.h"
  43 #include "THnSparse.h"
  44 #include <algorithm>
  45 #include <string>
  46 #include "AliAnalysisHelperJetTasks.h"
  47 #include "TDatabasePDG.h"
  48 #include "TPDGCode.h"
  49 #include "AliAnalysisManager.h"
  50 #include "AliAODHandler.h"
  51 #include "AliAODInputHandler.h"
  52 #include "AliESDEvent.h"
  53 #include "AliGenPythiaEventHeader.h"
  54 #include "AliGenHijingEventHeader.h"
  55 #include "AliGenEventHeader.h"
  56 #include "TLorentzVector.h"
  57 #include "AliAODEvent.h"
  58 #include "AliAODJet.h"
  59 #include "AliAODv0.h"
  60 #include "AliAODTrack.h"
  61 #include "AliCentrality.h"
  62 #include "AliAnalysisTaskSE.h"
  63 #include "AliESDtrack.h"
  64 #include "AliESDtrackCuts.h"
  65 #include "AliESDEvent.h"
  66 #include "AliESDInputHandler.h"
  67 #include "AliPID.h"
  68 #include "AliPIDResponse.h"
  69 #include "AliAODPid.h"
  70 #include "AliExternalTrackParam.h"
  71 #include "AliAnalysisTaskJetChem.h"
  72 #include "AliPhysicsSelection.h"
  73 #include "AliBackgroundSelection.h"
  74 #include "AliInputEventHandler.h"
  75 #include "AliAODMCHeader.h"
  76 #include "AliAODPid.h"
  77 #include "AliVEvent.h"
  78 #include "AliAODMCParticle.h"
  79 #include "TVector3.h"
  80 #include "TRandom3.h"
  81
  82 ClassImp(AliAnalysisTaskJetChem)
  83
  84 //____________________________________________________________________________
  85 AliAnalysisTaskJetChem::AliAnalysisTaskJetChem()
  86    : AliAnalysisTaskFragmentationFunction()
  87
  88    ,fRandom(0)
  89    ,fAnalysisMC(0)
  90    ,fDeltaVertexZ(0)
  91    ,fCutjetEta(0)
  92    ,fCuttrackNegNcls(0)
  93    ,fCuttrackPosNcls(0)
  94    ,fCutPostrackRap(0)
  95    ,fCutNegtrackRap(0)
  96    ,fCutRap(0)
  97    ,fCutPostrackEta(0)
  98    ,fCutNegtrackEta(0)
  99    ,fCutEta(0)
 100    ,fCutV0cosPointAngle(0)
 101    ,fKinkDaughters(0)
 102    ,fRequireTPCRefit(0)
 103    ,fCutArmenteros(0)
 104    ,fCutV0DecayMin(0)
 105    ,fCutV0DecayMax(0)
 106    ,fCutV0totMom(0)
 107    ,fCutDcaV0Daughters(0)
 108    ,fCutDcaPosToPrimVertex(0)
 109    ,fCutDcaNegToPrimVertex(0)
 110    ,fCutV0RadiusMin(0)
 111    ,fCutV0RadiusMax(0)
 112    ,fCutBetheBloch(0)
 113    ,fCutRatio(0)
 114    ,fK0Type(0)
 115    ,fFilterMaskK0(0)
 116    ,jettracklist(0)
 117    ,jetConeK0list(0)
 118    ,jetConeLalist(0)
 119    ,jetConeALalist(0)
 120    ,jetPerpConeK0list(0)
 121    ,jetPerpConeLalist(0)
 122    ,jetPerpConeALalist(0)
 123    ,jetMedianConeK0list(0)
 124    ,jetMedianConeLalist(0)
 125    ,jetMedianConeALalist(0)
 126    ,fListK0sRC(0)
 127    ,fListLaRC(0)
 128    ,fListALaRC(0)
 129    ,fListK0s(0)
 130    ,fPIDResponse(0)
 131    ,fV0QAK0(0)
 132    ,fFFHistosRecCutsK0Evt(0)
 133   //,fFFHistosIMK0AllEvt(0)
 134   //,fFFHistosIMK0Jet(0)
 135   //,fFFHistosIMK0Cone(0)
 136    ,fLaType(0)
 137    ,fFilterMaskLa(0)
 138    ,fListLa(0)
 139   // ,fFFHistosIMLaAllEvt(0)
 140   // ,fFFHistosIMLaJet(0)
 141   //,fFFHistosIMLaCone(0)
 142    ,fALaType(0)
 143    ,fFilterMaskALa(0)
 144    ,fListALa(0)
 145    ,fListFeeddownLaCand(0)
 146    ,fListFeeddownALaCand(0)
 147    ,jetConeFDLalist(0)
 148    ,jetConeFDALalist(0)
 149    ,fListMCgenK0s(0)
 150    ,fListMCgenLa(0)
 151    ,fListMCgenALa(0)
 152    ,fListMCgenK0sCone(0)
 153    ,fListMCgenLaCone(0)
 154    ,fListMCgenALaCone(0)
 155    ,IsArmenterosSelected(0)
 156   // ,fFFHistosIMALaAllEvt(0)
 157   // ,fFFHistosIMALaJet(0)
 158   // ,fFFHistosIMALaCone(0)
 159    ,fFFIMNBinsJetPt(0)
 160    ,fFFIMJetPtMin(0)
 161    ,fFFIMJetPtMax(0)
 162    ,fFFIMNBinsInvM(0)
 163    ,fFFIMInvMMin(0)
 164    ,fFFIMInvMMax(0)
 165    ,fFFIMNBinsPt(0)
 166    ,fFFIMPtMin(0)
 167    ,fFFIMPtMax(0)
 168    ,fFFIMNBinsXi(0)
 169    ,fFFIMXiMin(0)
 170    ,fFFIMXiMax(0)
 171    ,fFFIMNBinsZ(0)
 172    ,fFFIMZMin(0)
 173    ,fFFIMZMax(0)
 174    ,fFFIMLaNBinsJetPt(0)
 175    ,fFFIMLaJetPtMin(0)
 176    ,fFFIMLaJetPtMax(0)
 177    ,fFFIMLaNBinsInvM(0)
 178    ,fFFIMLaInvMMin(0)
 179    ,fFFIMLaInvMMax(0)
 180    ,fFFIMLaNBinsPt(0)
 181    ,fFFIMLaPtMin(0)
 182    ,fFFIMLaPtMax(0)
 183    ,fFFIMLaNBinsXi(0)
 184    ,fFFIMLaXiMin(0)
 185    ,fFFIMLaXiMax(0)
 186    ,fFFIMLaNBinsZ(0)
 187    ,fFFIMLaZMin(0)
 188    ,fFFIMLaZMax(0)
 189    ,fh1EvtAllCent(0)
 190    ,fh1Evt(0)
 191    ,fh1K0Mult(0)
 192    ,fh1dPhiJetK0(0)
 193    ,fh1LaMult(0)
 194    ,fh1dPhiJetLa(0)
 195    ,fh1ALaMult(0)
 196    ,fh1dPhiJetALa(0)
 197    ,fh1JetEta(0)
 198    ,fh1JetPhi(0)
 199    ,fh2JetEtaPhi(0)
 200   //,fh1V0JetPt(0)
 201    ,fh1IMK0Cone(0)
 202    ,fh1IMLaCone(0)
 203    ,fh1IMALaCone(0)
 204    ,fh2FFJetTrackEta(0)
 205   //,fh1trackPosNCls(0)
 206   //,fh1trackNegNCls(0)
 207    ,fh1trackPosRap(0)
 208    ,fh1trackNegRap(0)
 209   //,fh1V0Rap(0)
 210    ,fh1trackPosEta(0)
 211    ,fh1trackNegEta(0)
 212    ,fh1V0Eta(0)
 213   //,fh1V0totMom(0)
 214    ,fh1CosPointAngle(0)
 215    ,fh1DecayLengthV0(0)
 216    ,fh2ProperLifetimeK0sVsPtBeforeCut(0)
 217    ,fh2ProperLifetimeK0sVsPtAfterCut(0)
 218    ,fh1V0Radius(0)
 219    ,fh1DcaV0Daughters(0)
 220    ,fh1DcaPosToPrimVertex(0)
 221    ,fh1DcaNegToPrimVertex(0)
 222    ,fh2ArmenterosBeforeCuts(0)
 223    ,fh2ArmenterosAfterCuts(0)
 224    ,fh2BBLaPos(0)
 225    ,fh2BBLaNeg(0)
 226    ,fh1PosDaughterCharge(0)
 227    ,fh1NegDaughterCharge(0)
 228    ,fh1PtMCK0s(0)
 229    ,fh1PtMCLa(0)
 230    ,fh1PtMCALa(0)
 231    ,fh1EtaK0s(0)
 232    ,fh1EtaLa(0)
 233    ,fh1EtaALa(0)
 234    ,fh1RC(0)
 235    ,fh1RCBiasK0(0)
 236    ,fh1RCBiasLa(0)
 237    ,fh1RCBiasALa(0)
 238    ,fh1MCC(0)
 239    ,fh1OC(0)
 240    ,fh1NJ(0)
 241    ,fhnInvMassEtaTrackPtK0s(0)
 242    ,fhnInvMassEtaTrackPtLa(0)
 243    ,fhnInvMassEtaTrackPtALa(0)
 244    ,fh1TrackMultCone(0)
 245    ,fh2TrackMultCone(0)
 246    ,fhnNJK0(0)
 247    ,fhnNJLa(0)
 248    ,fhnNJALa(0)
 249   // ,fh2MCgenK0Cone(0)
 250   // ,fh2MCgenLaCone(0)
 251   // ,fh2MCgenALaCone(0)
 252   // ,fh2MCEtagenK0Cone(0)
 253   // ,fh2MCEtagenLaCone(0)
 254   // ,fh2MCEtagenALaCone(0)
 255    ,fh2CorrHijingLaProton(0)
 256    ,fh2CorrInjectLaProton(0)
 257    ,fh2CorrHijingALaAProton(0)
 258    ,fh2CorrInjectALaAProton(0)
 259    ,fh1IMK0ConeSmear(0)
 260    ,fh1IMLaConeSmear(0)
 261    ,fh1IMALaConeSmear(0)
 262    ,fh2MCEtaVsPtHijingLa(0)
 263    ,fh2MCEtaVsPtInjectLa(0)
 264    ,fh2MCEtaVsPtHijingALa(0)
 265    ,fh2MCEtaVsPtInjectALa(0)
 266    ,fhnrecMCHijingLaIncl(0)
 267    ,fhnrecMCHijingLaCone(0)
 268    ,fhnrecMCHijingALaIncl(0)
 269    ,fhnrecMCHijingALaCone(0)
 270    ,fhnrecMCInjectLaIncl(0)
 271    ,fhnrecMCInjectLaCone(0)
 272    ,fhnrecMCInjectALaIncl(0)
 273    ,fhnrecMCInjectALaCone(0)
 274    ,fhnMCrecK0Cone(0)
 275    ,fhnMCrecLaCone(0)
 276    ,fhnMCrecALaCone(0)
 277    ,fhnMCrecK0ConeSmear(0)
 278    ,fhnMCrecLaConeSmear(0)
 279    ,fhnMCrecALaConeSmear(0)
 280    ,fhnK0sSecContinCone(0)
 281    ,fhnLaSecContinCone(0)
 282    ,fhnALaSecContinCone(0)
 283    ,fhnK0sIncl(0)
 284    ,fhnK0sCone(0)
 285    ,fhnLaIncl(0)
 286    ,fhnLaCone(0)
 287    ,fhnALaIncl(0)
 288    ,fhnALaCone(0)
 289    ,fhnK0sPC(0)
 290    ,fhnLaPC(0)
 291    ,fhnALaPC(0)
 292    ,fhnK0sMCC(0)
 293    ,fhnLaMCC(0)
 294    ,fhnALaMCC(0)
 295    ,fhnK0sRC(0)
 296    ,fhnLaRC(0)
 297    ,fhnALaRC(0)
 298    ,fhnK0sRCBias(0)
 299    ,fhnLaRCBias(0)
 300    ,fhnALaRCBias(0)
 301    ,fhnK0sOC(0)
 302    ,fhnLaOC(0)
 303    ,fhnALaOC(0)
 304    ,fh1AreaExcluded(0)
 305    ,fh1MedianEta(0)
 306    ,fh1JetPtMedian(0)
 307    ,fh1MCMultiplicityPrimary(0)
 308    ,fh1MCMultiplicityTracks(0)
 309    ,fhnFeedDownLa(0)
 310    ,fhnFeedDownALa(0)
 311    ,fhnFeedDownLaCone(0)
 312    ,fhnFeedDownALaCone(0)
 313    ,fh1MCProdRadiusK0s(0)
 314    ,fh1MCProdRadiusLambda(0)
 315    ,fh1MCProdRadiusAntiLambda(0)
 316    ,fh1MCPtV0s(0)
 317    ,fh1MCPtK0s(0)
 318    ,fh1MCPtLambda(0)
 319    ,fh1MCPtAntiLambda(0)
 320    ,fh1MCXiPt(0)
 321    ,fh1MCXibarPt(0)
 322    ,fh2MCEtaVsPtK0s(0)
 323    ,fh2MCEtaVsPtLa(0)
 324    ,fh2MCEtaVsPtALa(0)
 325   //,fh1MCRapK0s(0)
 326   //,fh1MCRapLambda(0)
 327   //,fh1MCRapAntiLambda(0)
 328    ,fh1MCEtaAllK0s(0)
 329    ,fh1MCEtaK0s(0)
 330    ,fh1MCEtaLambda(0)
 331    ,fh1MCEtaAntiLambda(0)
 332
 333 {
 334    // default constructor
 335 }
 336
 337 //__________________________________________________________________________________________
 338 AliAnalysisTaskJetChem::AliAnalysisTaskJetChem(const char *name)
 339   : AliAnalysisTaskFragmentationFunction(name)
 340
 341   ,fRandom(0)
 342   ,fAnalysisMC(0)
 343   ,fDeltaVertexZ(0)
 344   ,fCutjetEta(0)
 345   ,fCuttrackNegNcls(0)
 346   ,fCuttrackPosNcls(0)
 347   ,fCutPostrackRap(0)
 348   ,fCutNegtrackRap(0)
 349   ,fCutRap(0)
 350   ,fCutPostrackEta(0)
 351   ,fCutNegtrackEta(0)
 352   ,fCutEta(0)
 353   ,fCutV0cosPointAngle(0)
 354   ,fKinkDaughters(0)
 355   ,fRequireTPCRefit(0)
 356   ,fCutArmenteros(0)
 357   ,fCutV0DecayMin(0)
 358   ,fCutV0DecayMax(0)
 359   ,fCutV0totMom(0)
 360   ,fCutDcaV0Daughters(0)
 361   ,fCutDcaPosToPrimVertex(0)
 362   ,fCutDcaNegToPrimVertex(0)
 363   ,fCutV0RadiusMin(0)
 364   ,fCutV0RadiusMax(0)
 365   ,fCutBetheBloch(0)
 366   ,fCutRatio(0)
 367   ,fK0Type(0)
 368   ,fFilterMaskK0(0)
 369   ,jettracklist(0)
 370   ,jetConeK0list(0)
 371   ,jetConeLalist(0)
 372   ,jetConeALalist(0)
 373   ,jetPerpConeK0list(0)
 374   ,jetPerpConeLalist(0)
 375   ,jetPerpConeALalist(0)
 376   ,jetMedianConeK0list(0)
 377   ,jetMedianConeLalist(0)
 378   ,jetMedianConeALalist(0)
 379   ,fListK0sRC(0)
 380   ,fListLaRC(0)
 381   ,fListALaRC(0)
 382   ,fListK0s(0)
 383   ,fPIDResponse(0)
 384   ,fV0QAK0(0)
 385   ,fFFHistosRecCutsK0Evt(0)
 386     //,fFFHistosIMK0AllEvt(0)
 387     //,fFFHistosIMK0Jet(0)
 388     //,fFFHistosIMK0Cone(0)
 389   ,fLaType(0)
 390   ,fFilterMaskLa(0)
 391   ,fListLa(0)
 392     //,fFFHistosIMLaAllEvt(0)
 393     //,fFFHistosIMLaJet(0)
 394     //,fFFHistosIMLaCone(0)
 395   ,fALaType(0)
 396   ,fFilterMaskALa(0)
 397   ,fListALa(0)
 398   ,fListFeeddownLaCand(0)
 399   ,fListFeeddownALaCand(0)
 400   ,jetConeFDLalist(0)
 401   ,jetConeFDALalist(0)
 402   ,fListMCgenK0s(0)
 403   ,fListMCgenLa(0)
 404   ,fListMCgenALa(0)
 405   ,fListMCgenK0sCone(0)
 406   ,fListMCgenLaCone(0)
 407   ,fListMCgenALaCone(0)
 408   ,IsArmenterosSelected(0)
 409     //,fFFHistosIMALaAllEvt(0)
 410     //,fFFHistosIMALaJet(0)
 411     // ,fFFHistosIMALaCone(0)
 412   ,fFFIMNBinsJetPt(0)
 413   ,fFFIMJetPtMin(0)
 414   ,fFFIMJetPtMax(0)
 415   ,fFFIMNBinsInvM(0)
 416   ,fFFIMInvMMin(0)
 417   ,fFFIMInvMMax(0)
 418   ,fFFIMNBinsPt(0)
 419   ,fFFIMPtMin(0)
 420   ,fFFIMPtMax(0)
 421   ,fFFIMNBinsXi(0)
 422   ,fFFIMXiMin(0)
 423   ,fFFIMXiMax(0)
 424   ,fFFIMNBinsZ(0)
 425   ,fFFIMZMin(0)
 426   ,fFFIMZMax(0)
 427   ,fFFIMLaNBinsJetPt(0)
 428   ,fFFIMLaJetPtMin(0)
 429   ,fFFIMLaJetPtMax(0)
 430   ,fFFIMLaNBinsInvM(0)
 431   ,fFFIMLaInvMMin(0)
 432   ,fFFIMLaInvMMax(0)
 433   ,fFFIMLaNBinsPt(0)
 434   ,fFFIMLaPtMin(0)
 435   ,fFFIMLaPtMax(0)
 436   ,fFFIMLaNBinsXi(0)
 437   ,fFFIMLaXiMin(0)
 438   ,fFFIMLaXiMax(0)
 439   ,fFFIMLaNBinsZ(0)
 440   ,fFFIMLaZMin(0)
 441   ,fFFIMLaZMax(0)
 442   ,fh1EvtAllCent(0)
 443   ,fh1Evt(0)
 444   ,fh1K0Mult(0)
 445   ,fh1dPhiJetK0(0)
 446   ,fh1LaMult(0)
 447   ,fh1dPhiJetLa(0)
 448   ,fh1ALaMult(0)
 449   ,fh1dPhiJetALa(0)
 450   ,fh1JetEta(0)
 451   ,fh1JetPhi(0)
 452   ,fh2JetEtaPhi(0)
 453     //  ,fh1V0JetPt(0)
 454   ,fh1IMK0Cone(0)
 455   ,fh1IMLaCone(0)
 456   ,fh1IMALaCone(0)
 457   ,fh2FFJetTrackEta(0)
 458     //  ,fh1trackPosNCls(0)
 459     // ,fh1trackNegNCls(0)
 460   ,fh1trackPosRap(0)
 461   ,fh1trackNegRap(0)
 462     //,fh1V0Rap(0)
 463   ,fh1trackPosEta(0)
 464   ,fh1trackNegEta(0)
 465   ,fh1V0Eta(0)
 466     // ,fh1V0totMom(0)
 467   ,fh1CosPointAngle(0)
 468   ,fh1DecayLengthV0(0)
 469   ,fh2ProperLifetimeK0sVsPtBeforeCut(0)
 470   ,fh2ProperLifetimeK0sVsPtAfterCut(0)
 471   ,fh1V0Radius(0)
 472   ,fh1DcaV0Daughters(0)
 473   ,fh1DcaPosToPrimVertex(0)
 474   ,fh1DcaNegToPrimVertex(0)
 475   ,fh2ArmenterosBeforeCuts(0)
 476   ,fh2ArmenterosAfterCuts(0)
 477   ,fh2BBLaPos(0)
 478   ,fh2BBLaNeg(0)
 479   ,fh1PosDaughterCharge(0)
 480   ,fh1NegDaughterCharge(0)
 481   ,fh1PtMCK0s(0)
 482   ,fh1PtMCLa(0)
 483   ,fh1PtMCALa(0)
 484   ,fh1EtaK0s(0)
 485   ,fh1EtaLa(0)
 486   ,fh1EtaALa(0)
 487   ,fh1RC(0)
 488   ,fh1RCBiasK0(0)
 489   ,fh1RCBiasLa(0)
 490   ,fh1RCBiasALa(0)
 491   ,fh1MCC(0)
 492   ,fh1OC(0)
 493   ,fh1NJ(0)
 494   ,fhnInvMassEtaTrackPtK0s(0)
 495   ,fhnInvMassEtaTrackPtLa(0)
 496   ,fhnInvMassEtaTrackPtALa(0)
 497   ,fh1TrackMultCone(0)
 498   ,fh2TrackMultCone(0)
 499   ,fhnNJK0(0)
 500   ,fhnNJLa(0)
 501   ,fhnNJALa(0)
 502     //,fh2MCgenK0Cone(0)
 503     //,fh2MCgenLaCone(0)
 504     //,fh2MCgenALaCone(0)
 505     //,fh2MCEtagenK0Cone(0)
 506     //,fh2MCEtagenLaCone(0)
 507     //,fh2MCEtagenALaCone(0)
 508   ,fh2CorrHijingLaProton(0)
 509   ,fh2CorrInjectLaProton(0)
 510   ,fh2CorrHijingALaAProton(0)
 511   ,fh2CorrInjectALaAProton(0)
 512   ,fh1IMK0ConeSmear(0)
 513   ,fh1IMLaConeSmear(0)
 514   ,fh1IMALaConeSmear(0)
 515   ,fh2MCEtaVsPtHijingLa(0)
 516   ,fh2MCEtaVsPtInjectLa(0)
 517   ,fh2MCEtaVsPtHijingALa(0)
 518   ,fh2MCEtaVsPtInjectALa(0)
 519   ,fhnrecMCHijingLaIncl(0)
 520   ,fhnrecMCHijingLaCone(0)
 521   ,fhnrecMCHijingALaIncl(0)
 522   ,fhnrecMCHijingALaCone(0)
 523   ,fhnrecMCInjectLaIncl(0)
 524   ,fhnrecMCInjectLaCone(0)
 525   ,fhnrecMCInjectALaIncl(0)
 526   ,fhnrecMCInjectALaCone(0)
 527   ,fhnMCrecK0Cone(0)
 528   ,fhnMCrecLaCone(0)
 529   ,fhnMCrecALaCone(0)
 530   ,fhnMCrecK0ConeSmear(0)
 531   ,fhnMCrecLaConeSmear(0)
 532   ,fhnMCrecALaConeSmear(0)
 533   ,fhnK0sSecContinCone(0)
 534   ,fhnLaSecContinCone(0)
 535   ,fhnALaSecContinCone(0)
 536   ,fhnK0sIncl(0)
 537   ,fhnK0sCone(0)
 538   ,fhnLaIncl(0)
 539   ,fhnLaCone(0)
 540   ,fhnALaIncl(0)
 541   ,fhnALaCone(0)
 542   ,fhnK0sPC(0)
 543   ,fhnLaPC(0)
 544   ,fhnALaPC(0)
 545   ,fhnK0sMCC(0)
 546   ,fhnLaMCC(0)
 547   ,fhnALaMCC(0)
 548   ,fhnK0sRC(0)
 549   ,fhnLaRC(0)
 550   ,fhnALaRC(0)
 551   ,fhnK0sRCBias(0)
 552   ,fhnLaRCBias(0)
 553   ,fhnALaRCBias(0)
 554   ,fhnK0sOC(0)
 555   ,fhnLaOC(0)
 556   ,fhnALaOC(0)
 557   ,fh1AreaExcluded(0)
 558   ,fh1MedianEta(0)
 559   ,fh1JetPtMedian(0)
 560   ,fh1MCMultiplicityPrimary(0)
 561   ,fh1MCMultiplicityTracks(0)
 562   ,fhnFeedDownLa(0)
 563   ,fhnFeedDownALa(0)
 564   ,fhnFeedDownLaCone(0)
 565   ,fhnFeedDownALaCone(0)
 566   ,fh1MCProdRadiusK0s(0)
 567   ,fh1MCProdRadiusLambda(0)
 568   ,fh1MCProdRadiusAntiLambda(0)
 569   ,fh1MCPtV0s(0)
 570   ,fh1MCPtK0s(0)
 571   ,fh1MCPtLambda(0)
 572   ,fh1MCPtAntiLambda(0)
 573   ,fh1MCXiPt(0)
 574   ,fh1MCXibarPt(0)
 575   ,fh2MCEtaVsPtK0s(0)
 576   ,fh2MCEtaVsPtLa(0)
 577   ,fh2MCEtaVsPtALa(0)
 578     //,fh1MCRapK0s(0)
 579     //,fh1MCRapLambda(0)
 580     //,fh1MCRapAntiLambda(0)
 581   ,fh1MCEtaAllK0s(0)
 582   ,fh1MCEtaK0s(0)
 583   ,fh1MCEtaLambda(0)
 584   ,fh1MCEtaAntiLambda(0)
 585
 586
 587 {
 588   // constructor
 589
 590   DefineOutput(1,TList::Class());
 591 }
 592
 593 //__________________________________________________________________________________________________________________________
 594 AliAnalysisTaskJetChem::AliAnalysisTaskJetChem(const  AliAnalysisTaskJetChem &copy)
 595   : AliAnalysisTaskFragmentationFunction()
 596
 597   ,fRandom(copy.fRandom)
 598   ,fAnalysisMC(copy.fAnalysisMC)
 599   ,fDeltaVertexZ(copy.fDeltaVertexZ)
 600   ,fCutjetEta(copy.fCutjetEta)
 601   ,fCuttrackNegNcls(copy.fCuttrackNegNcls)
 602   ,fCuttrackPosNcls(copy.fCuttrackPosNcls)
 603   ,fCutPostrackRap(copy.fCutPostrackRap)
 604   ,fCutNegtrackRap(copy.fCutNegtrackRap)
 605   ,fCutRap(copy.fCutRap)
 606   ,fCutPostrackEta(copy.fCutPostrackEta)
 607   ,fCutNegtrackEta(copy.fCutNegtrackEta)
 608   ,fCutEta(copy.fCutEta)
 609   ,fCutV0cosPointAngle(copy.fCutV0cosPointAngle)
 610   ,fKinkDaughters(copy.fKinkDaughters)
 611   ,fRequireTPCRefit(copy.fRequireTPCRefit)
 612   ,fCutArmenteros(copy.fCutArmenteros)
 613   ,fCutV0DecayMin(copy.fCutV0DecayMin)
 614   ,fCutV0DecayMax(copy.fCutV0DecayMax)
 615   ,fCutV0totMom(copy.fCutV0totMom)
 616   ,fCutDcaV0Daughters(copy.fCutDcaV0Daughters)
 617   ,fCutDcaPosToPrimVertex(copy.fCutDcaPosToPrimVertex)
 618   ,fCutDcaNegToPrimVertex(copy.fCutDcaNegToPrimVertex)
 619   ,fCutV0RadiusMin(copy.fCutV0RadiusMin)
 620   ,fCutV0RadiusMax(copy.fCutV0RadiusMax)
 621   ,fCutBetheBloch(copy.fCutBetheBloch)
 622   ,fCutRatio(copy.fCutRatio)
 623   ,fK0Type(copy.fK0Type)
 624   ,fFilterMaskK0(copy.fFilterMaskK0)
 625   ,jettracklist(copy.jettracklist)
 626   ,jetConeK0list(copy.jetConeK0list)
 627   ,jetConeLalist(copy.jetConeLalist)
 628   ,jetConeALalist(copy.jetConeALalist)
 629   ,jetPerpConeK0list(copy.jetPerpConeK0list)
 630   ,jetPerpConeLalist(copy.jetPerpConeLalist)
 631   ,jetPerpConeALalist(copy.jetPerpConeALalist)
 632   ,jetMedianConeK0list(copy.jetMedianConeK0list)
 633   ,jetMedianConeLalist(copy.jetMedianConeLalist)
 634   ,jetMedianConeALalist(copy.jetMedianConeALalist)
 635   ,fListK0sRC(copy.fListK0sRC)
 636   ,fListLaRC(copy.fListLaRC)
 637   ,fListALaRC(copy.fListALaRC)
 638   ,fListK0s(copy.fListK0s)
 639   ,fPIDResponse(copy.fPIDResponse)
 640   ,fV0QAK0(copy.fV0QAK0)
 641   ,fFFHistosRecCutsK0Evt(copy.fFFHistosRecCutsK0Evt)
 642     //,fFFHistosIMK0AllEvt(copy.fFFHistosIMK0AllEvt)
 643     //,fFFHistosIMK0Jet(copy.fFFHistosIMK0Jet)
 644     //,fFFHistosIMK0Cone(copy.fFFHistosIMK0Cone)
 645   ,fLaType(copy.fLaType)
 646   ,fFilterMaskLa(copy.fFilterMaskLa)
 647   ,fListLa(copy.fListLa)
 648     //,fFFHistosIMLaAllEvt(copy.fFFHistosIMLaAllEvt)
 649     //,fFFHistosIMLaJet(copy.fFFHistosIMLaJet)
 650     //,fFFHistosIMLaCone(copy.fFFHistosIMLaCone)
 651   ,fALaType(copy.fALaType)
 652   ,fFilterMaskALa(copy.fFilterMaskALa)
 653   ,fListALa(copy.fListALa)
 654   ,fListFeeddownLaCand(copy.fListFeeddownLaCand)
 655   ,fListFeeddownALaCand(copy.fListFeeddownALaCand)
 656   ,jetConeFDLalist(copy.jetConeFDLalist)
 657   ,jetConeFDALalist(copy.jetConeFDALalist)
 658   ,fListMCgenK0s(copy.fListMCgenK0s)
 659   ,fListMCgenLa(copy.fListMCgenLa)
 660   ,fListMCgenALa(copy.fListMCgenALa)
 661   ,fListMCgenK0sCone(copy.fListMCgenK0sCone)
 662   ,fListMCgenLaCone(copy.fListMCgenLaCone)
 663   ,fListMCgenALaCone(copy.fListMCgenALaCone)
 664   ,IsArmenterosSelected(copy.IsArmenterosSelected)
 665     //,fFFHistosIMALaAllEvt(copy.fFFHistosIMALaAllEvt)
 666     //,fFFHistosIMALaJet(copy.fFFHistosIMALaJet)
 667     //,fFFHistosIMALaCone(copy.fFFHistosIMALaCone)
 668   ,fFFIMNBinsJetPt(copy.fFFIMNBinsJetPt)
 669   ,fFFIMJetPtMin(copy.fFFIMJetPtMin)
 670   ,fFFIMJetPtMax(copy.fFFIMJetPtMax)
 671   ,fFFIMNBinsInvM(copy.fFFIMNBinsInvM)
 672   ,fFFIMInvMMin(copy.fFFIMInvMMin)
 673   ,fFFIMInvMMax(copy.fFFIMInvMMax)
 674   ,fFFIMNBinsPt(copy.fFFIMNBinsPt)
 675   ,fFFIMPtMin(copy.fFFIMPtMin)
 676   ,fFFIMPtMax(copy.fFFIMPtMax)
 677   ,fFFIMNBinsXi(copy.fFFIMNBinsXi)
 678   ,fFFIMXiMin(copy.fFFIMXiMin)
 679   ,fFFIMXiMax(copy.fFFIMXiMax)
 680   ,fFFIMNBinsZ(copy.fFFIMNBinsZ)
 681   ,fFFIMZMin(copy.fFFIMZMin)
 682   ,fFFIMZMax(copy.fFFIMZMax)
 683   ,fFFIMLaNBinsJetPt(copy.fFFIMLaNBinsJetPt)
 684   ,fFFIMLaJetPtMin(copy.fFFIMLaJetPtMin)
 685   ,fFFIMLaJetPtMax(copy.fFFIMLaJetPtMax)
 686   ,fFFIMLaNBinsInvM(copy.fFFIMLaNBinsInvM)
 687   ,fFFIMLaInvMMin(copy.fFFIMLaInvMMin)
 688   ,fFFIMLaInvMMax(copy.fFFIMLaInvMMax)
 689   ,fFFIMLaNBinsPt(copy.fFFIMLaNBinsPt)
 690   ,fFFIMLaPtMin(copy.fFFIMLaPtMin)
 691   ,fFFIMLaPtMax(copy.fFFIMLaPtMax)
 692   ,fFFIMLaNBinsXi(copy.fFFIMLaNBinsXi)
 693   ,fFFIMLaXiMin(copy.fFFIMLaXiMin)
 694   ,fFFIMLaXiMax(copy.fFFIMLaXiMax)
 695   ,fFFIMLaNBinsZ(copy.fFFIMLaNBinsZ)
 696   ,fFFIMLaZMin(copy.fFFIMLaZMin)
 697   ,fFFIMLaZMax(copy.fFFIMLaZMax)
 698   ,fh1EvtAllCent(copy.fh1EvtAllCent)
 699   ,fh1Evt(copy.fh1Evt)
 700   ,fh1K0Mult(copy.fh1K0Mult)
 701   ,fh1dPhiJetK0(copy.fh1dPhiJetK0)
 702   ,fh1LaMult(copy.fh1LaMult)
 703   ,fh1dPhiJetLa(copy.fh1dPhiJetLa)
 704   ,fh1ALaMult(copy.fh1ALaMult)
 705   ,fh1dPhiJetALa(copy.fh1dPhiJetALa)
 706   ,fh1JetEta(copy.fh1JetEta)
 707   ,fh1JetPhi(copy.fh1JetPhi)
 708   ,fh2JetEtaPhi(copy.fh2JetEtaPhi)
 709     //,fh1V0JetPt(copy.fh1V0JetPt)
 710   ,fh1IMK0Cone(copy.fh1IMK0Cone)
 711   ,fh1IMLaCone(copy.fh1IMLaCone)
 712   ,fh1IMALaCone(copy.fh1IMALaCone)
 713   ,fh2FFJetTrackEta(copy.fh2FFJetTrackEta)
 714     //,fh1trackPosNCls(copy.fh1trackPosNCls)
 715     //,fh1trackNegNCls(copy.fh1trackNegNCls)
 716   ,fh1trackPosRap(copy.fh1trackPosRap)
 717   ,fh1trackNegRap(copy.fh1trackNegRap)
 718     //,fh1V0Rap(copy.fh1V0Rap)
 719   ,fh1trackPosEta(copy.fh1trackPosEta)
 720   ,fh1trackNegEta(copy.fh1trackNegEta)
 721   ,fh1V0Eta(copy.fh1V0Eta)
 722     //,fh1V0totMom(copy.fh1V0totMom)
 723   ,fh1CosPointAngle(copy.fh1CosPointAngle)
 724   ,fh1DecayLengthV0(copy.fh1DecayLengthV0)
 725   ,fh2ProperLifetimeK0sVsPtBeforeCut(copy.fh2ProperLifetimeK0sVsPtBeforeCut)
 726   ,fh2ProperLifetimeK0sVsPtAfterCut(copy.fh2ProperLifetimeK0sVsPtAfterCut)
 727   ,fh1V0Radius(copy.fh1V0Radius)
 728   ,fh1DcaV0Daughters(copy.fh1DcaV0Daughters)
 729   ,fh1DcaPosToPrimVertex(copy.fh1DcaPosToPrimVertex)
 730   ,fh1DcaNegToPrimVertex(copy.fh1DcaNegToPrimVertex)
 731   ,fh2ArmenterosBeforeCuts(copy.fh2ArmenterosBeforeCuts)
 732   ,fh2ArmenterosAfterCuts(copy.fh2ArmenterosAfterCuts)
 733   ,fh2BBLaPos(copy.fh2BBLaPos)
 734   ,fh2BBLaNeg(copy.fh2BBLaPos)
 735   ,fh1PosDaughterCharge(copy.fh1PosDaughterCharge)
 736   ,fh1NegDaughterCharge(copy.fh1NegDaughterCharge)
 737   ,fh1PtMCK0s(copy.fh1PtMCK0s)
 738   ,fh1PtMCLa(copy.fh1PtMCLa)
 739   ,fh1PtMCALa(copy.fh1PtMCALa)
 740   ,fh1EtaK0s(copy.fh1EtaK0s)
 741   ,fh1EtaLa(copy.fh1EtaLa)
 742   ,fh1EtaALa(copy.fh1EtaALa)
 743   ,fh1RC(copy.fh1RC)
 744   ,fh1RCBiasK0(copy.fh1RCBiasK0)
 745   ,fh1RCBiasLa(copy.fh1RCBiasLa)
 746   ,fh1RCBiasALa(copy.fh1RCBiasALa)
 747   ,fh1MCC(copy.fh1MCC)
 748   ,fh1OC(copy.fh1OC)
 749   ,fh1NJ(copy.fh1NJ)
 750   ,fhnInvMassEtaTrackPtK0s(copy.fhnInvMassEtaTrackPtK0s)
 751   ,fhnInvMassEtaTrackPtLa(copy.fhnInvMassEtaTrackPtLa)
 752   ,fhnInvMassEtaTrackPtALa(copy.fhnInvMassEtaTrackPtALa)
 753   ,fh1TrackMultCone(copy.fh1TrackMultCone)
 754   ,fh2TrackMultCone(copy.fh2TrackMultCone)
 755   ,fhnNJK0(copy.fhnNJK0)
 756   ,fhnNJLa(copy.fhnNJLa)
 757   ,fhnNJALa(copy.fhnNJALa)
 758     //,fh2MCgenK0Cone(copy.fh2MCgenK0Cone)
 759     //,fh2MCgenLaCone(copy.fh2MCgenLaCone)
 760     //,fh2MCgenALaCone(copy.fh2MCgenALaCone)
 761     //,fh2MCEtagenK0Cone(copy.fh2MCEtagenK0Cone)
 762     //,fh2MCEtagenLaCone(copy.fh2MCEtagenLaCone)
 763     //,fh2MCEtagenALaCone(copy.fh2MCEtagenALaCone)
 764   ,fh2CorrHijingLaProton(copy.fh2CorrHijingLaProton)
 765   ,fh2CorrInjectLaProton(copy.fh2CorrInjectLaProton)
 766   ,fh2CorrHijingALaAProton(copy.fh2CorrHijingALaAProton)
 767   ,fh2CorrInjectALaAProton(copy.fh2CorrInjectALaAProton)
 768   ,fh1IMK0ConeSmear(copy.fh1IMK0ConeSmear)
 769   ,fh1IMLaConeSmear(copy.fh1IMLaConeSmear)
 770   ,fh1IMALaConeSmear(copy.fh1IMALaConeSmear)
 771   ,fh2MCEtaVsPtHijingLa(copy.fh2MCEtaVsPtHijingLa)
 772   ,fh2MCEtaVsPtInjectLa(copy.fh2MCEtaVsPtInjectLa)
 773   ,fh2MCEtaVsPtHijingALa(copy.fh2MCEtaVsPtHijingALa)
 774   ,fh2MCEtaVsPtInjectALa(copy.fh2MCEtaVsPtInjectALa)
 775   ,fhnrecMCHijingLaIncl(copy.fhnrecMCHijingLaIncl)
 776   ,fhnrecMCHijingLaCone(copy.fhnrecMCHijingLaCone)
 777   ,fhnrecMCHijingALaIncl(copy.fhnrecMCHijingALaIncl)
 778   ,fhnrecMCHijingALaCone(copy.fhnrecMCHijingALaCone)
 779   ,fhnrecMCInjectLaIncl(copy.fhnrecMCInjectLaIncl)
 780   ,fhnrecMCInjectLaCone(copy.fhnrecMCInjectLaCone)
 781   ,fhnrecMCInjectALaIncl(copy.fhnrecMCInjectALaIncl)
 782   ,fhnrecMCInjectALaCone(copy.fhnrecMCInjectALaCone)
 783   ,fhnMCrecK0Cone(copy.fhnMCrecK0Cone)
 784   ,fhnMCrecLaCone(copy.fhnMCrecLaCone)
 785   ,fhnMCrecALaCone(copy.fhnMCrecALaCone)
 786   ,fhnMCrecK0ConeSmear(copy.fhnMCrecK0ConeSmear)
 787   ,fhnMCrecLaConeSmear(copy.fhnMCrecLaConeSmear)
 788   ,fhnMCrecALaConeSmear(copy.fhnMCrecALaConeSmear)
 789   ,fhnK0sSecContinCone(copy.fhnK0sSecContinCone)
 790   ,fhnLaSecContinCone(copy.fhnLaSecContinCone)
 791   ,fhnALaSecContinCone(copy.fhnALaSecContinCone)
 792   ,fhnK0sIncl(copy.fhnK0sIncl)
 793   ,fhnK0sCone(copy.fhnK0sCone)
 794   ,fhnLaIncl(copy.fhnLaIncl)
 795   ,fhnLaCone(copy.fhnLaCone)
 796   ,fhnALaIncl(copy.fhnALaIncl)
 797   ,fhnALaCone(copy.fhnALaCone)
 798   ,fhnK0sPC(copy.fhnK0sPC)
 799   ,fhnLaPC(copy.fhnLaPC)
 800   ,fhnALaPC(copy.fhnALaPC)
 801   ,fhnK0sMCC(copy.fhnK0sMCC)
 802   ,fhnLaMCC(copy.fhnLaMCC)
 803   ,fhnALaMCC(copy.fhnALaMCC)
 804   ,fhnK0sRC(copy.fhnK0sRC)
 805   ,fhnLaRC(copy.fhnLaRC)
 806   ,fhnALaRC(copy.fhnALaRC)
 807   ,fhnK0sRCBias(copy.fhnK0sRCBias)
 808   ,fhnLaRCBias(copy.fhnLaRCBias)
 809   ,fhnALaRCBias(copy.fhnALaRCBias)
 810   ,fhnK0sOC(copy.fhnK0sOC)
 811   ,fhnLaOC(copy.fhnLaOC)
 812   ,fhnALaOC(copy.fhnALaOC)
 813   ,fh1AreaExcluded(copy.fh1AreaExcluded)
 814   ,fh1MedianEta(copy.fh1MedianEta)
 815   ,fh1JetPtMedian(copy.fh1JetPtMedian)
 816   ,fh1MCMultiplicityPrimary(copy.fh1MCMultiplicityPrimary)
 817   ,fh1MCMultiplicityTracks(copy.fh1MCMultiplicityTracks)
 818   ,fhnFeedDownLa(copy.fhnFeedDownLa)
 819   ,fhnFeedDownALa(copy.fhnFeedDownALa)
 820   ,fhnFeedDownLaCone(copy.fhnFeedDownLaCone)
 821   ,fhnFeedDownALaCone(copy.fhnFeedDownALaCone)
 822   ,fh1MCProdRadiusK0s(copy.fh1MCProdRadiusK0s)
 823   ,fh1MCProdRadiusLambda(copy.fh1MCProdRadiusLambda)
 824   ,fh1MCProdRadiusAntiLambda(copy.fh1MCProdRadiusAntiLambda)
 825   ,fh1MCPtV0s(copy.fh1MCPtV0s)
 826   ,fh1MCPtK0s(copy.fh1MCPtK0s)
 827   ,fh1MCPtLambda(copy.fh1MCPtLambda)
 828   ,fh1MCPtAntiLambda(copy.fh1MCPtAntiLambda)
 829   ,fh1MCXiPt(copy.fh1MCXiPt)
 830   ,fh1MCXibarPt(copy.fh1MCXibarPt)
 831   ,fh2MCEtaVsPtK0s(copy.fh2MCEtaVsPtK0s)
 832   ,fh2MCEtaVsPtLa(copy.fh2MCEtaVsPtLa)
 833   ,fh2MCEtaVsPtALa(copy.fh2MCEtaVsPtALa)
 834     //,fh1MCRapK0s(copy.fh1MCRapK0s)
 835     //,fh1MCRapLambda(copy.fh1MCRapLambda)
 836     //,fh1MCRapAntiLambda(copy.fh1MCRapAntiLambda)
 837   ,fh1MCEtaAllK0s(copy.fh1MCEtaAllK0s)
 838   ,fh1MCEtaK0s(copy.fh1MCEtaK0s)
 839   ,fh1MCEtaLambda(copy.fh1MCEtaLambda)
 840   ,fh1MCEtaAntiLambda(copy.fh1MCEtaAntiLambda)
 841
 842 {
 843   // copy constructor
 844
 845 }
 846
 847 // _________________________________________________________________________________________________________________________________
 848 AliAnalysisTaskJetChem& AliAnalysisTaskJetChem::operator=(const AliAnalysisTaskJetChem& o)
 849 {
 850   // assignment
 851
 852   if(this!=&o){
 853     AliAnalysisTaskFragmentationFunction::operator=(o);
 854
 855     fRandom                         = o.fRandom;
 856     fAnalysisMC                     = o.fAnalysisMC;
 857     fDeltaVertexZ                   = o.fDeltaVertexZ;
 858     fCutjetEta                      = o.fCutjetEta;
 859     fCuttrackNegNcls                = o.fCuttrackNegNcls;
 860     fCuttrackPosNcls                = o.fCuttrackPosNcls;
 861     fCutPostrackRap                 = o.fCutPostrackRap;
 862     fCutNegtrackRap                 = o.fCutNegtrackRap;
 863     fCutRap                         = o.fCutRap;
 864     fCutPostrackEta                 = o.fCutPostrackEta;
 865     fCutNegtrackEta                 = o.fCutNegtrackEta;
 866     fCutEta                         = o.fCutEta;
 867     fCutV0cosPointAngle             = o.fCutV0cosPointAngle;
 868     fKinkDaughters                  = o.fKinkDaughters;
 869     fRequireTPCRefit                = o.fRequireTPCRefit;
 870     fCutArmenteros                  = o.fCutArmenteros;
 871     fCutV0DecayMin                  = o.fCutV0DecayMin;
 872     fCutV0DecayMax                  = o.fCutV0DecayMax;
 873     fCutV0totMom                    = o.fCutV0totMom;
 874     fCutDcaV0Daughters              = o.fCutDcaV0Daughters;
 875     fCutDcaPosToPrimVertex          = o.fCutDcaPosToPrimVertex;
 876     fCutDcaNegToPrimVertex          = o.fCutDcaNegToPrimVertex;
 877     fCutV0RadiusMin                 = o.fCutV0RadiusMin;
 878     fCutV0RadiusMax                 = o.fCutV0RadiusMax;
 879     fCutBetheBloch                  = o.fCutBetheBloch;
 880     fCutRatio                       = o.fCutRatio;
 881     fK0Type                         = o.fK0Type;
 882     fFilterMaskK0                   = o.fFilterMaskK0;
 883     jettracklist                    = o.jettracklist;
 884     jetConeK0list                   = o.jetConeK0list;
 885     jetConeLalist                   = o.jetConeLalist;
 886     jetConeALalist                  = o.jetConeALalist;
 887     jetPerpConeK0list               = o.jetPerpConeK0list;
 888     jetPerpConeLalist               = o.jetPerpConeLalist;
 889     jetPerpConeALalist              = o.jetPerpConeALalist;
 890     jetMedianConeK0list             = o.jetMedianConeK0list;
 891     jetMedianConeLalist             = o.jetMedianConeLalist;
 892     jetMedianConeALalist            = o.jetMedianConeALalist;
 893     fListK0sRC                      = o.fListK0sRC;
 894     fListLaRC                       = o.fListLaRC;
 895     fListALaRC                      = o.fListALaRC;
 896     fListK0s                        = o.fListK0s;
 897     fPIDResponse                    = o.fPIDResponse;
 898     fV0QAK0                         = o.fV0QAK0;
 899     fFFHistosRecCutsK0Evt           = o.fFFHistosRecCutsK0Evt;
 900     //fFFHistosIMK0AllEvt             = o.fFFHistosIMK0AllEvt;
 901     //fFFHistosIMK0Jet                = o.fFFHistosIMK0Jet;
 902     //fFFHistosIMK0Cone               = o.fFFHistosIMK0Cone;
 903     fLaType                         = o.fLaType;
 904     fFilterMaskLa                   = o.fFilterMaskLa;
 905     fListLa                         = o.fListLa;
 906     //fFFHistosIMLaAllEvt             = o.fFFHistosIMLaAllEvt;
 907     //fFFHistosIMLaJet                = o.fFFHistosIMLaJet;
 908     //fFFHistosIMLaCone               = o.fFFHistosIMLaCone;
 909     fALaType                        = o.fALaType;
 910     fFilterMaskALa                  = o.fFilterMaskALa;
 911     fListFeeddownLaCand             = o.fListFeeddownLaCand;
 912     fListFeeddownALaCand            = o.fListFeeddownALaCand;
 913     jetConeFDLalist                 = o.jetConeFDLalist;
 914     jetConeFDALalist                = o.jetConeFDALalist;
 915     fListMCgenK0s                   = o.fListMCgenK0s;
 916     fListMCgenLa                    = o.fListMCgenLa;
 917     fListMCgenALa                   = o.fListMCgenALa;
 918     fListMCgenK0sCone               = o.fListMCgenK0sCone;
 919     fListMCgenLaCone                = o.fListMCgenLaCone;
 920     fListMCgenALaCone               = o.fListMCgenALaCone;
 921     IsArmenterosSelected            = o.IsArmenterosSelected;
 922     // fFFHistosIMALaAllEvt            = o.fFFHistosIMALaAllEvt;
 923     // fFFHistosIMALaJet               = o.fFFHistosIMALaJet;
 924     // fFFHistosIMALaCone              = o.fFFHistosIMALaCone;
 925     fFFIMNBinsJetPt                 = o.fFFIMNBinsJetPt;
 926     fFFIMJetPtMin                   = o.fFFIMJetPtMin;
 927     fFFIMJetPtMax                   = o.fFFIMJetPtMax;
 928     fFFIMNBinsPt                    = o.fFFIMNBinsPt;
 929     fFFIMPtMin                      = o.fFFIMPtMin;
 930     fFFIMPtMax                      = o.fFFIMPtMax;
 931     fFFIMNBinsXi                    = o.fFFIMNBinsXi;
 932     fFFIMXiMin                      = o.fFFIMXiMin;
 933     fFFIMXiMax                      = o.fFFIMXiMax;
 934     fFFIMNBinsZ                     = o.fFFIMNBinsZ;
 935     fFFIMZMin                       = o.fFFIMZMin;
 936     fFFIMZMax                       = o.fFFIMZMax;
 937     fFFIMLaNBinsJetPt               = o.fFFIMLaNBinsJetPt;
 938     fFFIMLaJetPtMin                 = o.fFFIMLaJetPtMin;
 939     fFFIMLaJetPtMax                 = o.fFFIMLaJetPtMax;
 940     fFFIMLaNBinsPt                  = o.fFFIMLaNBinsPt;
 941     fFFIMLaPtMin                    = o.fFFIMLaPtMin;
 942     fFFIMLaPtMax                    = o.fFFIMLaPtMax;
 943     fFFIMLaNBinsXi                  = o.fFFIMLaNBinsXi;
 944     fFFIMLaXiMin                    = o.fFFIMLaXiMin;
 945     fFFIMLaXiMax                    = o.fFFIMLaXiMax;
 946     fFFIMLaNBinsZ                   = o.fFFIMLaNBinsZ;
 947     fFFIMLaZMin                     = o.fFFIMLaZMin;
 948     fFFIMLaZMax                     = o.fFFIMLaZMax;
 949     fh1EvtAllCent                   = o.fh1EvtAllCent;
 950     fh1Evt                          = o.fh1Evt;
 951     fh1K0Mult                       = o.fh1K0Mult;
 952     fh1dPhiJetK0                    = o.fh1dPhiJetK0;
 953     fh1LaMult                       = o.fh1LaMult;
 954     fh1dPhiJetLa                    = o.fh1dPhiJetLa;
 955     fh1ALaMult                      = o.fh1ALaMult;
 956     fh1dPhiJetALa                   = o.fh1dPhiJetALa;
 957     fh1JetEta                       = o.fh1JetEta;
 958     fh1JetPhi                       = o.fh1JetPhi;
 959     fh2JetEtaPhi                    = o.fh2JetEtaPhi;
 960     //fh1V0JetPt                     = o.fh1V0JetPt;
 961     fh1IMK0Cone                     = o.fh1IMK0Cone;
 962     fh1IMLaCone                     = o.fh1IMLaCone;
 963     fh1IMALaCone                    = o.fh1IMALaCone;
 964     fh2FFJetTrackEta                = o.fh2FFJetTrackEta;
 965     //fh1trackPosNCls                 = o.fh1trackPosNCls;
 966     //fh1trackNegNCls                 = o.fh1trackNegNCls;
 967     fh1trackPosRap                  = o.fh1trackPosRap;
 968     fh1trackNegRap                  = o.fh1trackNegRap;
 969     //fh1V0Rap                        = o.fh1V0Rap;
 970     fh1trackPosEta                  = o.fh1trackPosEta;
 971     fh1trackNegEta                  = o.fh1trackNegEta;
 972     fh1V0Eta                        = o.fh1V0Eta;
 973     // fh1V0totMom                     = o.fh1V0totMom;
 974     fh1CosPointAngle                = o.fh1CosPointAngle;
 975     fh1DecayLengthV0                = o.fh1DecayLengthV0;
 976     fh2ProperLifetimeK0sVsPtBeforeCut = o.fh2ProperLifetimeK0sVsPtBeforeCut;
 977     fh2ProperLifetimeK0sVsPtAfterCut= o.fh2ProperLifetimeK0sVsPtAfterCut;
 978     fh1V0Radius                     = o.fh1V0Radius;
 979     fh1DcaV0Daughters               = o.fh1DcaV0Daughters;
 980     fh1DcaPosToPrimVertex           = o.fh1DcaPosToPrimVertex;
 981     fh1DcaNegToPrimVertex           = o.fh1DcaNegToPrimVertex;
 982     fh2ArmenterosBeforeCuts         = o.fh2ArmenterosBeforeCuts;
 983     fh2ArmenterosAfterCuts          = o.fh2ArmenterosAfterCuts;
 984     fh2BBLaPos                      = o.fh2BBLaPos;
 985     fh2BBLaNeg                      = o.fh2BBLaPos;
 986     fh1PosDaughterCharge            = o.fh1PosDaughterCharge;
 987     fh1NegDaughterCharge            = o.fh1NegDaughterCharge;
 988     fh1PtMCK0s                      = o.fh1PtMCK0s;
 989     fh1PtMCLa                       = o.fh1PtMCLa;
 990     fh1PtMCALa                      = o.fh1PtMCALa;
 991     fh1EtaK0s                       = o.fh1EtaK0s;
 992     fh1EtaLa                        = o.fh1EtaLa;
 993     fh1EtaALa                       = o.fh1EtaALa;
 994     fh1RC                           = o.fh1RC;
 995     fh1RCBiasK0                     = o.fh1RCBiasK0;
 996     fh1RCBiasLa                     = o.fh1RCBiasLa;
 997     fh1RCBiasALa                    = o.fh1RCBiasALa;
 998     fh1MCC                          = o.fh1MCC;
 999     fh1OC                           = o.fh1OC;
1000     fh1NJ                           = o.fh1NJ;
1001     fhnInvMassEtaTrackPtK0s         = o.fhnInvMassEtaTrackPtK0s;
1002     fhnInvMassEtaTrackPtLa          = o.fhnInvMassEtaTrackPtLa;
1003     fhnInvMassEtaTrackPtALa         = o.fhnInvMassEtaTrackPtALa;
1004     fh1TrackMultCone                = o.fh1TrackMultCone;
1005     fh2TrackMultCone                = o.fh2TrackMultCone;
1006     fhnNJK0                         = o.fhnNJK0;
1007     fhnNJLa                         = o.fhnNJLa;
1008     fhnNJALa                        = o.fhnNJALa;
1009     //fh2MCgenK0Cone                  = o.fh2MCgenK0Cone;
1010     //fh2MCgenLaCone                  = o.fh2MCgenLaCone;
1011     //fh2MCgenALaCone                 = o.fh2MCgenALaCone;
1012     //fh2MCEtagenK0Cone               = o.fh2MCEtagenK0Cone;
1013     //fh2MCEtagenLaCone               = o.fh2MCEtagenLaCone;
1014     //fh2MCEtagenALaCone              = o.fh2MCEtagenALaCone;
1015     fh1IMK0ConeSmear                = o.fh1IMK0ConeSmear;
1016     fh1IMLaConeSmear                = o.fh1IMLaConeSmear;
1017     fh1IMALaConeSmear               = o.fh1IMALaConeSmear;
1018     fh2MCEtaVsPtHijingLa            = o.fh2MCEtaVsPtHijingLa;
1019     fh2MCEtaVsPtInjectLa            = o.fh2MCEtaVsPtInjectLa;
1020     fh2MCEtaVsPtHijingALa           = o.fh2MCEtaVsPtHijingALa;
1021     fh2MCEtaVsPtInjectALa           = o.fh2MCEtaVsPtInjectALa;
1022     fhnrecMCHijingLaIncl            = o.fhnrecMCHijingLaIncl;
1023     fhnrecMCHijingLaCone            = o.fhnrecMCHijingLaCone;
1024     fhnrecMCHijingALaIncl           = o.fhnrecMCHijingALaIncl;
1025     fhnrecMCHijingALaCone           = o.fhnrecMCHijingALaCone;
1026     fhnrecMCInjectLaIncl            = o.fhnrecMCInjectLaIncl;
1027     fhnrecMCInjectLaCone            = o.fhnrecMCInjectLaCone;
1028     fhnrecMCInjectALaIncl           = o.fhnrecMCInjectALaIncl;
1029     fhnrecMCInjectALaCone           = o.fhnrecMCInjectALaCone;
1030     fhnMCrecK0Cone                  = o.fhnMCrecK0Cone;
1031     fhnMCrecLaCone                  = o.fhnMCrecLaCone;
1032     fhnMCrecALaCone                 = o.fhnMCrecALaCone;
1033     fhnMCrecK0ConeSmear             = o.fhnMCrecK0ConeSmear;
1034     fhnMCrecLaConeSmear             = o.fhnMCrecLaConeSmear;
1035     fhnMCrecALaConeSmear            = o.fhnMCrecALaConeSmear;
1036     fhnK0sSecContinCone             = o.fhnK0sSecContinCone;
1037     fhnLaSecContinCone              = o.fhnLaSecContinCone;
1038     fhnALaSecContinCone             = o.fhnALaSecContinCone;
1039     fhnK0sIncl                      = o.fhnK0sIncl;
1040     fhnK0sCone                      = o.fhnK0sCone;
1041     fhnLaIncl                       = o.fhnLaIncl;
1042     fhnLaCone                       = o.fhnLaCone;
1043     fhnALaIncl                      = o.fhnALaIncl;
1044     fhnALaCone                      = o.fhnALaCone;
1045     fhnK0sPC                        = o.fhnK0sPC;
1046     fhnLaPC                         = o.fhnLaPC;
1047     fhnALaPC                        = o.fhnALaPC;
1048     fhnK0sRC                        = o.fhnK0sRC;
1049     fhnLaRC                         = o.fhnLaRC;
1050     fhnALaRC                        = o.fhnALaRC;
1051     fhnK0sRCBias                    = o.fhnK0sRCBias;
1052     fhnLaRCBias                     = o.fhnLaRCBias;
1053     fhnALaRCBias                    = o.fhnALaRCBias;
1054     fhnK0sOC                        = o.fhnK0sOC;
1055     fhnLaOC                         = o.fhnLaOC;
1056     fhnALaOC                        = o.fhnALaOC;
1057     fh1AreaExcluded                 = o.fh1AreaExcluded;
1058     fh1MedianEta                    = o.fh1MedianEta;
1059     fh1JetPtMedian                  = o.fh1JetPtMedian;
1060     fh1MCMultiplicityPrimary        = o.fh1MCMultiplicityPrimary;
1061     fh1MCMultiplicityTracks         = o.fh1MCMultiplicityTracks;
1062     fhnFeedDownLa                   = o.fhnFeedDownLa;
1063     fhnFeedDownALa                  = o.fhnFeedDownALa;
1064     fhnFeedDownLaCone               = o.fhnFeedDownLaCone;
1065     fhnFeedDownALaCone              = o.fhnFeedDownALaCone;
1066     fh1MCProdRadiusK0s              = o.fh1MCProdRadiusK0s;
1067     fh1MCProdRadiusLambda           = o.fh1MCProdRadiusLambda;
1068     fh1MCProdRadiusAntiLambda       = o.fh1MCProdRadiusAntiLambda;
1069     fh1MCPtV0s                      = o.fh1MCPtV0s;
1070     fh1MCPtK0s                      = o.fh1MCPtK0s;
1071     fh1MCPtLambda                   = o.fh1MCPtLambda;
1072     fh1MCPtAntiLambda               = o.fh1MCPtAntiLambda;
1073     fh1MCXiPt                       = o.fh1MCXiPt;
1074     fh1MCXibarPt                    = o.fh1MCXibarPt;
1075     fh2MCEtaVsPtK0s                 = o.fh2MCEtaVsPtK0s;
1076     fh2MCEtaVsPtLa                  = o.fh2MCEtaVsPtLa;
1077     fh2MCEtaVsPtALa                 = o.fh2MCEtaVsPtALa;
1078     //fh1MCRapK0s                     = o.fh1MCRapK0s;
1079     //fh1MCRapLambda                  = o.fh1MCRapLambda;
1080     //fh1MCRapAntiLambda              = o.fh1MCRapAntiLambda;
1081     fh1MCEtaAllK0s                  = o.fh1MCEtaAllK0s;
1082     fh1MCEtaK0s                     = o.fh1MCEtaK0s;
1083     fh1MCEtaLambda                  = o.fh1MCEtaLambda;
1084     fh1MCEtaAntiLambda              = o.fh1MCEtaAntiLambda;
1085 }
1086
1087   return *this;
1088 }
1089
1090 //_______________________________________________
1091 AliAnalysisTaskJetChem::~AliAnalysisTaskJetChem()
1092 {
1093   // destructor
1094
1095   if(jettracklist) delete jettracklist;
1096   if(jetConeK0list) delete jetConeK0list;
1097   if(jetConeLalist) delete jetConeLalist;
1098   if(jetConeALalist) delete jetConeALalist;
1099   if(jetPerpConeK0list) delete jetPerpConeK0list;
1100   if(jetPerpConeLalist) delete jetPerpConeLalist;
1101   if(jetPerpConeALalist) delete jetPerpConeALalist;
1102   if(jetMedianConeK0list) delete jetMedianConeK0list;
1103   if(jetMedianConeLalist) delete jetMedianConeLalist;
1104   if(jetMedianConeALalist) delete jetMedianConeALalist;
1105   if(fListK0sRC) delete fListK0sRC;
1106   if(fListLaRC) delete fListLaRC;
1107   if(fListALaRC) delete fListALaRC;
1108   if(fListK0s) delete fListK0s;
1109   if(fListLa) delete fListLa;
1110   if(fListALa) delete fListALa;
1111   if(fListFeeddownLaCand) delete fListFeeddownLaCand;
1112   if(fListFeeddownALaCand) delete fListFeeddownALaCand;
1113   if(jetConeFDLalist) delete jetConeFDLalist;
1114   if(jetConeFDALalist) delete jetConeFDALalist;
1115   if(fListMCgenK0s) delete fListMCgenK0s;
1116   if(fListMCgenLa) delete fListMCgenLa;
1117   if(fListMCgenALa) delete fListMCgenALa;
1118   if(fListMCgenK0sCone) delete fListMCgenK0sCone;
1119   if(fListMCgenLaCone) delete fListMCgenLaCone;
1120   if(fListMCgenALaCone) delete fListMCgenALaCone;
1121   if(fRandom) delete fRandom;
1122 }
1123
1124 //________________________________________________________________________________________________________________________________
1125 AliAnalysisTaskJetChem::AliFragFuncHistosInvMass::AliFragFuncHistosInvMass(const char* name,
1126                                                                            Int_t nJetPt, Float_t jetPtMin, Float_t jetPtMax,
1127                                                                            Int_t nInvMass, Float_t invMassMin, Float_t invMassMax,
1128                                                                            Int_t nPt, Float_t ptMin, Float_t ptMax,
1129                                                                            Int_t nXi, Float_t xiMin, Float_t xiMax,
1130                                                                            Int_t nZ , Float_t zMin , Float_t zMax )
1131   : TObject()
1132   ,fNBinsJetPt(nJetPt)
1133   ,fJetPtMin(jetPtMin)
1134   ,fJetPtMax(jetPtMax)
1135   ,fNBinsInvMass(nInvMass)
1136   ,fInvMassMin(invMassMin)
1137   ,fInvMassMax(invMassMax)
1138   ,fNBinsPt(nPt)
1139   ,fPtMin(ptMin)
1140   ,fPtMax(ptMax)
1141   ,fNBinsXi(nXi)
1142   ,fXiMin(xiMin)
1143   ,fXiMax(xiMax)
1144   ,fNBinsZ(nZ)
1145   ,fZMin(zMin)
1146   ,fZMax(zMax)
1147   ,fh3TrackPt(0)
1148   ,fh3Xi(0)
1149   ,fh3Z(0)
1150   ,fh1JetPt(0)
1151   ,fNameFF(name)
1152 {
1153   // default constructor
1154
1155 }
1156
1157 //______________________________________________________________________________________________________________
1158 AliAnalysisTaskJetChem::AliFragFuncHistosInvMass::AliFragFuncHistosInvMass(const AliFragFuncHistosInvMass& copy)
1159   : TObject()
1160   ,fNBinsJetPt(copy.fNBinsJetPt)
1161   ,fJetPtMin(copy.fJetPtMin)
1162   ,fJetPtMax(copy.fJetPtMax)
1163   ,fNBinsInvMass(copy.fNBinsInvMass)
1164   ,fInvMassMin(copy.fInvMassMin)
1165   ,fInvMassMax(copy.fInvMassMax)
1166   ,fNBinsPt(copy.fNBinsPt)
1167   ,fPtMin(copy.fPtMin)
1168   ,fPtMax(copy.fPtMax)
1169   ,fNBinsXi(copy.fNBinsXi)
1170   ,fXiMin(copy.fXiMin)
1171   ,fXiMax(copy.fXiMax)
1172   ,fNBinsZ(copy.fNBinsZ)
1173   ,fZMin(copy.fZMin)
1174   ,fZMax(copy.fZMax)
1175   ,fh3TrackPt(copy.fh3TrackPt)
1176   ,fh3Xi(copy.fh3Xi)
1177   ,fh3Z(copy.fh3Z)
1178   ,fh1JetPt(copy.fh1JetPt)
1179   ,fNameFF(copy.fNameFF)
1180 {
1181   // copy constructor
1182 }
1183
1184 //______________________________________________________________________________________________________________________________________________________________________
1185 AliAnalysisTaskJetChem::AliFragFuncHistosInvMass& AliAnalysisTaskJetChem::AliFragFuncHistosInvMass::operator=(const AliAnalysisTaskJetChem::AliFragFuncHistosInvMass& o)
1186 {
1187   // assignment
1188
1189   if(this!=&o){
1190     TObject::operator=(o);
1191     fNBinsJetPt   = o.fNBinsJetPt;
1192     fJetPtMin     = o.fJetPtMin;
1193     fJetPtMax     = o.fJetPtMax;
1194     fNBinsInvMass = o.fNBinsInvMass;
1195     fInvMassMin   = o.fInvMassMin;
1196     fInvMassMax   = o.fInvMassMax;
1197     fNBinsPt      = o.fNBinsPt;
1198     fPtMin        = o.fPtMin;
1199     fPtMax        = o.fPtMax;
1200     fNBinsXi      = o.fNBinsXi;
1201     fXiMin        = o.fXiMin;
1202     fXiMax        = o.fXiMax;
1203     fNBinsZ       = o.fNBinsZ;
1204     fZMin         = o.fZMin;
1205     fZMax         = o.fZMax;
1206     fh3TrackPt    = o.fh3TrackPt;
1207     fh3Xi         = o.fh3Xi;
1208     fh3Z          = o.fh3Z;
1209     fh1JetPt      = o.fh1JetPt;
1210     fNameFF       = o.fNameFF;
1211   }
1212
1213   return *this;
1214 }
1215
1216 //___________________________________________________________________________
1217 AliAnalysisTaskJetChem::AliFragFuncHistosInvMass::~AliFragFuncHistosInvMass()
1218 {
1219   // destructor
1220
1221   if(fh1JetPt)   delete fh1JetPt;
1222   if(fh3TrackPt) delete fh3TrackPt;
1223   if(fh3Xi)      delete fh3Xi;
1224   if(fh3Z)       delete fh3Z;
1225 }
1226
1227 //_________________________________________________________________
1228 void AliAnalysisTaskJetChem::AliFragFuncHistosInvMass::DefineHistos()
1229 {
1230   // book FF histos
1231
1232   fh1JetPt   = new TH1F(Form("fh1FFJetPtIM%s", fNameFF.Data()),"",fNBinsJetPt,fJetPtMin,fJetPtMax);
1233   fh3TrackPt = new TH3F(Form("fh3FFTrackPtIM%s",fNameFF.Data()),"",fNBinsJetPt, fJetPtMin, fJetPtMax, fNBinsInvMass, fInvMassMin, fInvMassMax, fNBinsPt, fPtMin, fPtMax);
1234   fh3Xi      = new TH3F(Form("fh3FFXiIM%s", fNameFF.Data()),"", fNBinsJetPt, fJetPtMin, fJetPtMax, fNBinsInvMass, fInvMassMin, fInvMassMax, fNBinsXi, fXiMin, fXiMax);
1235   fh3Z       = new TH3F(Form("fh3FFZIM%s", fNameFF.Data()),"", fNBinsJetPt, fJetPtMin, fJetPtMax, fNBinsInvMass, fInvMassMin, fInvMassMax, fNBinsZ, fZMin, fZMax);
1236
1237   AliAnalysisTaskFragmentationFunction::SetProperties(fh1JetPt, "p_{t} (GeV/c)", "entries");
1238   AliAnalysisTaskJetChem::SetProperties(fh3TrackPt,"jet p_{t} (GeV/c)","inv Mass (GeV/c^2)","p_{t} (GeV/c)");
1239   AliAnalysisTaskJetChem::SetProperties(fh3Xi,"jet p_{t} (GeV/c)","inv Mass (GeV/c^2)","#xi");
1240   AliAnalysisTaskJetChem::SetProperties(fh3Z,"jet p_{t} (GeV/c)","inv Mass (GeV/c^2)","z");
1241 }
1242
1243 //________________________________________________________________________________________________________________________________
1244 void AliAnalysisTaskJetChem::AliFragFuncHistosInvMass::FillFF(Float_t trackPt, Float_t invM, Float_t jetPt, Bool_t incrementJetPt)
1245 {
1246   // fill FF, don't use TH3F anymore use THnSparse instead to save memory
1247
1248   if(incrementJetPt) fh1JetPt->Fill(jetPt);
1249   //fh3TrackPt->Fill(jetPt,invM,trackPt);//Fill(x,y,z)
1250   //  invM = 0;
1251   //  Double_t z = 0.;
1252   // if(jetPt>0) z = trackPt / jetPt;
1253   // Double_t xi = 0;
1254   //if(z>0) xi = TMath::Log(1/z);
1255
1256   //fh3Xi->Fill(jetPt,invM,xi);
1257   //fh3Z->Fill(jetPt,invM,z);
1258 }
1259
1260 //___________________________________________________________________________________
1261 void AliAnalysisTaskJetChem::AliFragFuncHistosInvMass::AddToOutput(TList* list) const
1262 {
1263   // add histos to list
1264
1265   list->Add(fh1JetPt);
1266   //list->Add(fh3TrackPt);
1267   //list->Add(fh3Xi);
1268   //list->Add(fh3Z);
1269 }
1270
1271
1272 //____________________________________________________
1273 void AliAnalysisTaskJetChem::UserCreateOutputObjects()
1274 {
1275   // create output objects
1276
1277   fRandom = new TRandom3(0);
1278   fRandom->SetSeed(0);
1279
1280   if(fDebug > 1) Printf("AliAnalysisTaskJetChem::UserCreateOutputObjects()");
1281
1282   // create list of tracks and jets
1283   jettracklist = new TList();
1284   jettracklist->SetOwner(kFALSE);
1285   jetConeK0list = new TList();
1286   jetConeK0list->SetOwner(kFALSE);
1287   jetConeLalist = new TList();
1288   jetConeLalist->SetOwner(kFALSE);
1289   jetConeALalist = new TList();
1290   jetConeALalist->SetOwner(kFALSE);
1291   jetPerpConeK0list = new TList();
1292   jetPerpConeK0list->SetOwner(kFALSE);
1293   jetPerpConeLalist = new TList();
1294   jetPerpConeLalist->SetOwner(kFALSE);
1295   jetPerpConeALalist = new TList();
1296   jetPerpConeALalist->SetOwner(kFALSE);
1297   jetMedianConeK0list = new TList();
1298   jetMedianConeK0list->SetOwner(kFALSE);
1299   jetMedianConeLalist = new TList();
1300   jetMedianConeLalist->SetOwner(kFALSE);
1301   jetMedianConeALalist = new TList();
1302   jetMedianConeALalist->SetOwner(kFALSE);
1303   fListK0sRC = new TList();
1304   fListK0sRC->SetOwner(kFALSE);
1305   fListLaRC = new TList();
1306   fListLaRC->SetOwner(kFALSE);
1307   fListALaRC = new TList();
1308   fListALaRC->SetOwner(kFALSE);
1309   fTracksRecCuts = new TList();
1310   fTracksRecCuts->SetOwner(kFALSE); //objects in TList wont be deleted when TList is deleted
1311   fJetsRecCuts = new TList();
1312   fJetsRecCuts->SetOwner(kFALSE);
1313   fBckgJetsRec = new TList();
1314   fBckgJetsRec->SetOwner(kFALSE);
1315   fListK0s = new TList();
1316   fListK0s->SetOwner(kFALSE);
1317   fListLa = new TList();
1318   fListLa->SetOwner(kFALSE);
1319   fListALa = new TList();
1320   fListALa->SetOwner(kFALSE);
1321   fListFeeddownLaCand = new TList();    //feeddown Lambda candidates
1322   fListFeeddownLaCand->SetOwner(kFALSE);
1323   fListFeeddownALaCand = new TList();   //feeddown Antilambda candidates
1324   fListFeeddownALaCand->SetOwner(kFALSE);
1325   jetConeFDLalist = new TList();
1326   jetConeFDLalist->SetOwner(kFALSE);  //feeddown Lambda candidates in jet cone
1327   jetConeFDALalist = new TList();
1328   jetConeFDALalist->SetOwner(kFALSE); //feeddown Antilambda candidates in jet cone
1329   fListMCgenK0s = new TList();          //MC generated K0s
1330   fListMCgenK0s->SetOwner(kFALSE);
1331   fListMCgenLa = new TList();           //MC generated Lambdas
1332   fListMCgenLa->SetOwner(kFALSE);
1333   fListMCgenALa = new TList();          //MC generated Antilambdas
1334   fListMCgenALa->SetOwner(kFALSE);
1335   fListMCgenK0sCone = new TList();
1336   fListMCgenK0sCone->SetOwner(kFALSE);
1337   fListMCgenLaCone = new TList();
1338   fListMCgenLaCone->SetOwner(kFALSE);
1339   fListMCgenALaCone = new TList();
1340   fListMCgenALaCone->SetOwner(kFALSE);
1341
1342   // Create histograms / output container
1343
1344   fCommonHistList = new TList();
1345   fCommonHistList->SetOwner();
1346
1347   Bool_t oldStatus = TH1::AddDirectoryStatus();
1348   TH1::AddDirectory(kFALSE);//By default (fAddDirectory = kTRUE), histograms are automatically added to the list of objects in memory
1349
1350   // histograms inherited from AliAnalysisTaskFragmentationFunction
1351
1352   fh1EvtSelection            = new TH1F("fh1EvtSelection", "Event Selection", 6, -0.5, 5.5);
1353   fh1EvtSelection->GetXaxis()->SetBinLabel(1,"ACCEPTED");
1354   fh1EvtSelection->GetXaxis()->SetBinLabel(2,"event trigger selection: rejected");
1355   fh1EvtSelection->GetXaxis()->SetBinLabel(3,"event class: rejected");
1356   fh1EvtSelection->GetXaxis()->SetBinLabel(4,"vertex Ncontr: rejected");
1357   fh1EvtSelection->GetXaxis()->SetBinLabel(5,"vertex z: rejected");
1358   fh1EvtSelection->GetXaxis()->SetBinLabel(6,"vertex type: rejected");
1359
1360
1361   fh1EvtCent                 = new TH1F("fh1EvtCent","centrality",100,0.,100.);
1362   fh1VertexNContributors     = new TH1F("fh1VertexNContributors", "Vertex N contributors", 11,-.5, 10.5);
1363   fh1VertexZ                 = new TH1F("fh1VertexZ", "Vertex z distribution", 30, -15., 15.);
1364   fh1Xsec                    = new TProfile("fh1Xsec","xsec from pyxsec.root",1,0,1);
1365   fh1Xsec->GetXaxis()->SetBinLabel(1,"<#sigma>");
1366   fh1Trials                  = new TH1F("fh1Trials","trials from pyxsec.root",1,0,1);
1367   fh1Trials->GetXaxis()->SetBinLabel(1,"#sum{ntrials}");
1368   fh1PtHard                  = new TH1F("fh1PtHard","PYTHIA Pt hard;p_{T,hard}",350,-.5,349.5);
1369   fh1PtHardTrials            = new TH1F("fh1PtHardTrials","PYTHIA Pt hard weight with trials;p_{T,hard}",350,-.5,349.5);
1370   fh1nRecJetsCuts            = new TH1F("fh1nRecJetsCuts","reconstructed jets per event",100,-0.5,99.5);
1371
1372   // histograms JetChem task
1373
1374   fh1EvtAllCent                 = new TH1F("fh1EvtAllCent","before centrality selection",100,0.,100.);
1375   fh1Evt                        = new TH1F("fh1Evt", "All events runned over", 3, 0.,1.);
1376   fh1EvtMult                    = new TH1F("fh1EvtMult","multiplicity",240,0.,240.);
1377   fh1K0Mult                     = new TH1F("fh1K0Mult","K0 multiplicity",100,0.,100.);//500. all
1378   fh1dPhiJetK0                  = new TH1F("fh1dPhiJetK0","",64,-1,5.4);
1379   fh1LaMult                     = new TH1F("fh1LaMult","La multiplicity",100,0.,100.);
1380   fh1dPhiJetLa                  = new TH1F("fh1dPhiJetLa","",64,-1,5.4);
1381   fh1ALaMult                    = new TH1F("fh1ALaMult","ALa multiplicity",100,0.,100.);
1382   fh1dPhiJetALa                 = new TH1F("fh1dPhiJetALa","",64,-1,5.4);
1383   fh1JetEta                     = new TH1F("fh1JetEta","#eta distribution of all jets",40,-2.,2.);
1384   fh1JetPhi                     = new TH1F("fh1JetPhi","#phi distribution of all jets",63,0.,6.3);
1385   fh2JetEtaPhi                  = new TH2F("fh2JetEtaPhi","#eta and #phi distribution of all jets",400,-2.,2.,63,0.,6.3);
1386
1387
1388   //fh1V0JetPt                    = new TH1F("fh1V0JetPt","p_{T} distribution of all jets containing v0s",200,0.,200.);
1389   fh1IMK0Cone                     = new TH1F("fh1IMK0Cone","p_{T} distribution of all jets containing K0s candidates",19,5.,100.);
1390   fh1IMLaCone                     = new TH1F("fh1IMLaCone","p_{T} distribution of all jets containing #Lambda candidates",19,5.,100.);
1391   fh1IMALaCone                    = new TH1F("fh1IMALaCone","p_{T} distribution of all jets containing #bar{#Lambda} candidates",19,5.,100.);
1392
1393   fh2FFJetTrackEta              = new TH2F("fh2FFJetTrackEta","charged track eta distr. in jet cone",200,-1.,1.,40,0.,200.);
1394   //fh1trackPosNCls               = new TH1F("fh1trackPosNCls","NTPC clusters positive daughters",10,0.,100.);
1395   //fh1trackNegNCls               = new TH1F("fh1trackNegNCls","NTPC clusters negative daughters",10,0.,100.);
1396   fh1trackPosEta                = new TH1F("fh1trackPosEta","eta positive daughters",100,-2.,2.);
1397   fh1trackNegEta                = new TH1F("fh1trackNegEta","eta negative daughters",100,-2.,2.);
1398   fh1V0Eta                      = new TH1F("fh1V0Eta","V0 eta",60,-1.5,1.5);
1399   //fh1V0totMom                   = new TH1F("fh1V0totMom","V0 tot mom",100,0.,20.);
1400   fh1CosPointAngle              = new TH1F("fh1CosPointAngle", "Cosine of V0's pointing angle",50,0.99,1.0);
1401   fh1DecayLengthV0              = new TH1F("fh1DecayLengthV0", "V0s decay Length;decay length(cm)",1200,0.,120.);
1402   fh2ProperLifetimeK0sVsPtBeforeCut = new TH2F("fh2ProperLifetimeK0sVsPtBeforeCut"," K0s ProperLifetime vs Pt; p_{T} (GeV/#it{c})",150,0.,15.,250,0.,250.);
1403   fh2ProperLifetimeK0sVsPtAfterCut = new TH2F("fh2ProperLifetimeK0sVsPtAfterCut"," K0s ProperLifetime vs Pt; p_{T} (GeV/#it{c})",150,0.,15.,250,0.,250.);
1404   fh1V0Radius                   = new TH1F("fh1V0Radius", "V0s Radius;Radius(cm)",200,0.,40.);
1405   fh1DcaV0Daughters             = new TH1F("fh1DcaV0Daughters", "DCA between daughters;dca(cm)",200,0.,2.);
1406   fh1DcaPosToPrimVertex         = new TH1F("fh1DcaPosToPrimVertex", "Positive V0 daughter;dca(cm)",100,0.,10.);
1407   fh1DcaNegToPrimVertex         = new TH1F("fh1DcaNegToPrimVertex", "Negative V0 daughter;dca(cm)",100,0.,10.);
1408   fh2ArmenterosBeforeCuts       = new TH2F("fh2ArmenterosBeforeCuts","Armenteros Podolanski Plot for K0s Candidates;#alpha;(p^{arm})_{T}/(GeV/#it{c})",200,-1.2,1.2,350,0.,0.35);
1409   fh2ArmenterosAfterCuts        = new TH2F("fh2ArmenterosAfterCuts","Armenteros Podolanski Plot for K0s Candidates;#alpha;(p^{arm})_{T}/(GeV/#it{c});",200,-1.2,1.2,350,0.,0.35);
1410   fh2BBLaPos                    = new TH2F("fh2BBLaPos","PID of the positive daughter of La candidates; P (GeV); -dE/dx (keV/cm ?)",100,0,10,200,0,200);
1411   fh2BBLaNeg                    = new TH2F("fh2BBLaNeg","PID of the negative daughter of La candidates; P (GeV); -dE/dx (keV/cm ?)",100,0,10,200,0,200);
1412   fh1PosDaughterCharge          = new TH1F("fh1PosDaughterCharge","charge of V0 positive daughters; V0 daughters",3,-2.,2.);
1413   fh1NegDaughterCharge          = new TH1F("fh1NegDaughterCharge","charge of V0 negative daughters; V0 daughters",3,-2.,2.);
1414   fh1PtMCK0s                    = new TH1F("fh1PtMCK0s","Pt of MC rec K0s; #it{p}_{T} (GeV/#it{c})",200,0.,20.);
1415   fh1PtMCLa                     = new TH1F("fh1PtMCLa","Pt of MC rec La; #it{p}_{T} (GeV/#it{c})",200,0.,20.);
1416   fh1PtMCALa                    = new TH1F("fh1PtMCALa","Pt of MC rec ALa; #it{p}_{T} (GeV/#it{c})",200,0.,20.);
1417   fh1EtaK0s                     = new TH1F("fh1EtaK0s","K^{0}_{s} entries ;#eta",200,-1.,1.);
1418   fh1EtaLa                      = new TH1F("fh1EtaLa","#Lambda entries ;#eta",200,-1.,1.);
1419   fh1EtaALa                     = new TH1F("fh1EtaALa","#bar{#Lambda} entries ;#eta",200,-1.,1.);
1420
1421   //histos for normalisation of MCC, RC, OC and NJ
1422
1423   fh1RC                         = new TH1F("fh1RC"," # random cones used",1,0.5,1.5);
1424   fh1RCBiasK0                   = new TH1F("fh1RCBiasK0"," # random cones with K0s trigger particle",1,0.5,1.5);
1425   fh1RCBiasLa                   = new TH1F("fh1RCBiasLa"," # random cones with La trigger particle",1,0.5,1.5);
1426   fh1RCBiasALa                  = new TH1F("fh1RCBiasALa"," # random cones with ALa trigger particle",1,0.5,1.5);
1427   fh1MCC                        = new TH1F("fh1MCC","# median cluster cones used",1,0.5,1.5);
1428   fh1OC                         = new TH1F("fh1OC","# outside cones used, number of jet events",1,0.5,1.5);
1429   fh1NJ                         = new TH1F("fh1NJ","# non-jet events used",1,0.5,1.5);
1430
1431   Int_t binsInvMassEtaTrackPtK0s[3] = {200, 200, 120};//eta,invM,trackPt
1432   Double_t xminInvMassEtaTrackPtK0s[3] = {-1.,0.3,0.};
1433   Double_t xmaxInvMassEtaTrackPtK0s[3] = {1.,0.7,12.};
1434
1435   fhnInvMassEtaTrackPtK0s       = new THnSparseF("fhnInvMassEtaTrackPtK0s","#eta; K0s invM (GeV/{#it{c}}^{2}); #it{p}_{T} (GeV/#it{c})",3,binsInvMassEtaTrackPtK0s,xminInvMassEtaTrackPtK0s,xmaxInvMassEtaTrackPtK0s);
1436
1437   Int_t binsInvMassEtaTrackPtLa[3] = {200, 200, 120};//eta,invM,trackPt
1438   Double_t xminInvMassEtaTrackPtLa[3] = {-1.,1.05,0.};
1439   Double_t xmaxInvMassEtaTrackPtLa[3] = {1.,1.25,12.};
1440
1441   fhnInvMassEtaTrackPtLa       = new THnSparseF("fhnInvMassEtaTrackPtLa","#eta; #Lambda invM (GeV/{#it{c}}^{2}); #it{p}_{T} (GeV/#it{c})",3,binsInvMassEtaTrackPtLa,xminInvMassEtaTrackPtLa,xmaxInvMassEtaTrackPtLa);
1442
1443   Int_t binsInvMassEtaTrackPtALa[3] = {200, 200, 120};//eta,invM,trackPt
1444   Double_t xminInvMassEtaTrackPtALa[3] = {-1.,1.05,0.};
1445   Double_t xmaxInvMassEtaTrackPtALa[3] = {1.,1.25,12.};
1446
1447   fhnInvMassEtaTrackPtALa       = new THnSparseF("fhnInvMassEtaTrackPtALa","#eta; #bar{#Lambda} invM (GeV/{#it{c}}^{2}); #it{p}_{T} (GeV/#it{c})",3,binsInvMassEtaTrackPtALa,xminInvMassEtaTrackPtALa,xmaxInvMassEtaTrackPtALa);
1448
1449   Int_t binsK0sPC[4] = {19, 200, 120, 200};
1450   Double_t xminK0sPC[4] = {5.,0.3, 0., -1.};
1451   Double_t xmaxK0sPC[4] = {100.,0.7, 12., 1.};
1452   fhnK0sPC                      = new THnSparseF("fhnK0sPC","jet pT; K0s invM; particle pT; particle #eta",4,binsK0sPC,xminK0sPC,xmaxK0sPC);
1453
1454   Int_t binsLaPC[4] = {19, 200, 120, 200};
1455   Double_t xminLaPC[4] = {5.,1.05, 0., -1.};
1456   Double_t xmaxLaPC[4] = {100.,1.25, 12., 1.};
1457   fhnLaPC                       = new THnSparseF("fhnLaPC","jet pT; #Lambda invM; particle pT; particle #eta",4,binsLaPC,xminLaPC,xmaxLaPC);
1458
1459   Int_t binsALaPC[4] = {19, 200, 120, 200};
1460   Double_t xminALaPC[4] = {5.,1.05, 0., -1.};
1461   Double_t xmaxALaPC[4] = {100.,1.25, 12., 1.};
1462   fhnALaPC                      = new THnSparseF("fhnALaPC","jet pT; #bar#Lambda invM; particle pT; particle #eta",4,binsALaPC,xminALaPC,xmaxALaPC);
1463
1464   Int_t binsK0sMCC[3] = {200, 120, 200};
1465   Double_t xminK0sMCC[3] = {0.3, 0., -1.};
1466   Double_t xmaxK0sMCC[3] = {0.7, 12., 1.};
1467   fhnK0sMCC                     = new THnSparseF("fhnK0sMCC","jet pT; K0s invM; particle pT; particle #eta",3,binsK0sMCC,xminK0sMCC,xmaxK0sMCC);
1468
1469   Int_t binsLaMCC[3] = {200, 120, 200};
1470   Double_t xminLaMCC[3] = {1.05, 0., -1.};
1471   Double_t xmaxLaMCC[3] = {1.25, 12., 1.};
1472   fhnLaMCC                      = new THnSparseF("fhnLaMCC","jet pT; #Lambda invM; particle pT; particle #eta",3,binsLaMCC,xminLaMCC,xmaxLaMCC);
1473
1474   Int_t binsALaMCC[3] = {200, 120, 200};
1475   Double_t xminALaMCC[3] = {1.05, 0., -1.};
1476   Double_t xmaxALaMCC[3] = {1.25, 12., 1.};
1477   fhnALaMCC                = new THnSparseF("fhnALaMCC","jet pT; #bara#Lambda invM; particle pT; particle #eta",3,binsALaMCC,xminALaMCC,xmaxALaMCC);
1478
1479   Int_t binsK0sRC[3] = {200, 120, 200};
1480   Double_t xminK0sRC[3] = {0.3, 0., -1.};
1481   Double_t xmaxK0sRC[3] = {0.7, 12., 1.};
1482   fhnK0sRC                 = new THnSparseF("fhnK0sRC","jet pT; K0s invM; particle pT; particle #eta",3,binsK0sRC,xminK0sRC,xmaxK0sRC);
1483
1484   Int_t binsLaRC[3] = {200, 120, 200};
1485   Double_t xminLaRC[3] = {1.05, 0., -1.};
1486   Double_t xmaxLaRC[3] = {1.25, 12., 1.};
1487   fhnLaRC                  = new THnSparseF("fhnLaRC","jet pT; #Lambda invM; particle pT; particle #eta",3,binsLaRC,xminLaRC,xmaxLaRC);
1488
1489   Int_t binsALaRC[3] = {200, 120, 200};
1490   Double_t xminALaRC[3] = {1.05, 0., -1.};
1491   Double_t xmaxALaRC[3] = {1.25, 12., 1.};
1492   fhnALaRC                 = new THnSparseF("fhnALaRC","jet pT; #bara#Lambda invM; particle pT; particle #eta",3,binsALaRC,xminALaRC,xmaxALaRC);
1493
1494   Int_t binsK0sRCBias[3] = {200, 120, 200};
1495   Double_t xminK0sRCBias[3] = {0.3, 0., -1.};
1496   Double_t xmaxK0sRCBias[3] = {0.7, 12., 1.};
1497   fhnK0sRCBias             = new THnSparseF("fhnK0sRCBias","jet pT; K0s invM; particle pT; particle #eta",3,binsK0sRCBias,xminK0sRCBias,xmaxK0sRCBias);
1498
1499   Int_t binsLaRCBias[3] = {200, 120, 200};
1500   Double_t xminLaRCBias[3] = {1.05, 0., -1.};
1501   Double_t xmaxLaRCBias[3] = {1.25, 12., 1.};
1502   fhnLaRCBias              = new THnSparseF("fhnLaRCBias","jet pT; #Lambda invM; particle pT; particle #eta",3,binsLaRCBias,xminLaRCBias,xmaxLaRCBias);
1503
1504   Int_t binsALaRCBias[3] = {200, 120, 200};
1505   Double_t xminALaRCBias[3] = {1.05, 0., -1.};
1506   Double_t xmaxALaRCBias[3] = {1.25, 12., 1.};
1507   fhnALaRCBias             = new THnSparseF("fhnALaRCBias","jet pT; #bara#Lambda invM; particle pT; particle #eta",3,binsALaRCBias,xminALaRCBias,xmaxALaRCBias);
1508
1509   Int_t binsK0sOC[3] = {200, 120, 200};
1510   Double_t xminK0sOC[3] = {0.3, 0., -1.};
1511   Double_t xmaxK0sOC[3] = {0.7, 12., 1.};
1512   fhnK0sOC                     = new THnSparseF("fhnK0sOC","jet pT; K0s invM; particle pT; particle #eta",3,binsK0sOC,xminK0sOC,xmaxK0sOC);
1513
1514   Int_t binsLaOC[3] = {200, 120, 200};
1515   Double_t xminLaOC[3] = {1.05, 0., -1.};
1516   Double_t xmaxLaOC[3] = {1.25, 12., 1.};
1517   fhnLaOC                      = new THnSparseF("fhnLaOC","jet pT; #Lambda invM; particle pT; particle #eta",3,binsLaOC,xminLaOC,xmaxLaOC);
1518
1519   Int_t binsALaOC[3] = {200, 120, 200};
1520   Double_t xminALaOC[3] = {1.05, 0., -1.};
1521   Double_t xmaxALaOC[3] = {1.25, 12., 1.};
1522
1523   fhnALaOC                      = new THnSparseF("fhnALaOC","jet pT; #bara#Lambda invM; particle pT; particle #eta",3,binsALaOC,xminALaOC,xmaxALaOC);
1524
1525   fh1AreaExcluded               = new TH1F("fh1AreaExcluded","area excluded for selected jets in event acceptance",50,0.,1.);
1526
1527   fh1MedianEta                  = new TH1F("fh1MedianEta","Median cluster axis ;#eta",200,-1.,1.);
1528   fh1JetPtMedian                = new TH1F("fh1JetPtMedian"," (selected) jet it{p}_{T} distribution for MCC method; #GeV/it{c}",19,5.,100.);
1529
1530   fh1TrackMultCone              = new TH1F("fh1TrackMultCone","track multiplicity in jet cone; number of tracks",20,0.,50.);
1531
1532   fh2TrackMultCone              = new TH2F("fh2TrackMultCone","track multiplicity in jet cone vs. jet momentum; number of tracks; jet it{p}_{T} (GeV/it{c})",50,0.,50.,19,5.,100.);
1533
1534   Int_t binsNJK0[3] = {200, 120, 200};
1535   Double_t xminNJK0[3] = {0.3, 0., -1.};
1536   Double_t xmaxNJK0[3] = {0.7, 12., 1.};
1537   fhnNJK0                       = new THnSparseF("fhnNJK0","K0s candidates in events wo selected jets;",3,binsNJK0,xminNJK0,xmaxNJK0);
1538
1539   Int_t binsNJLa[3] = {200, 120, 200};
1540   Double_t xminNJLa[3] = {1.05, 0., -1.};
1541   Double_t xmaxNJLa[3] = {1.25, 12., 1.};
1542   fhnNJLa                    = new THnSparseF("fhnNJLa","La candidates in events wo selected jets; ",3,binsNJLa,xminNJLa,xmaxNJLa);
1543
1544   Int_t binsNJALa[3] = {200, 120, 200};
1545   Double_t xminNJALa[3] = {1.05, 0., -1.};
1546   Double_t xmaxNJALa[3] = {1.25, 12., 1.};
1547   fhnNJALa                    = new THnSparseF("fhnNJALa","ALa candidates in events wo selected jets; ",3,binsNJALa,xminNJALa,xmaxNJALa);
1548
1549   fFFHistosRecCuts              = new AliFragFuncHistos("RecCuts", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1550                                                      fFFNBinsPt, fFFPtMin, fFFPtMax,
1551                                                      fFFNBinsXi, fFFXiMin, fFFXiMax,
1552                                                      fFFNBinsZ , fFFZMin , fFFZMax);
1553
1554   fV0QAK0                       = new AliFragFuncQATrackHistos("V0QAK0",fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
1555                                                             fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
1556                                                             fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
1557                                                             fQATrackHighPtThreshold);
1558
1559   fFFHistosRecCutsK0Evt         = new AliFragFuncHistos("RecCutsK0Evt", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
1560                                                      fFFNBinsPt, fFFPtMin, fFFPtMax,
1561                                                      fFFNBinsXi, fFFXiMin, fFFXiMax,
1562                                                      fFFNBinsZ , fFFZMin , fFFZMax);
1563
1564   /*
1565   fFFHistosIMK0AllEvt        = new AliFragFuncHistosInvMass("K0AllEvt", fFFIMNBinsJetPt, fFFIMJetPtMin, fFFIMJetPtMax,
1566                                                             fFFIMNBinsInvM,fFFIMInvMMin,fFFIMInvMMax,
1567                                                             fFFIMNBinsPt, fFFIMPtMin, fFFIMPtMax,
1568                                                             fFFIMNBinsXi, fFFIMXiMin, fFFIMXiMax,
1569                                                             fFFIMNBinsZ , fFFIMZMin , fFFIMZMax);
1570
1571   fFFHistosIMK0Jet           = new AliFragFuncHistosInvMass("K0Jet", fFFIMNBinsJetPt, fFFIMJetPtMin, fFFIMJetPtMax,
1572                                                             fFFIMNBinsInvM,fFFIMInvMMin,fFFIMInvMMax,
1573                                                             fFFIMNBinsPt, fFFIMPtMin, fFFIMPtMax,
1574                                                             fFFIMNBinsXi, fFFIMXiMin, fFFIMXiMax,
1575                                                             fFFIMNBinsZ , fFFIMZMin , fFFIMZMax);
1576
1577   fFFHistosIMK0Cone          = new AliFragFuncHistosInvMass("K0Cone", fFFIMNBinsJetPt, fFFIMJetPtMin, fFFIMJetPtMax,
1578                                                             fFFIMNBinsInvM,fFFIMInvMMin,fFFIMInvMMax,
1579                                                             fFFIMNBinsPt, fFFIMPtMin, fFFIMPtMax,
1580                                                             fFFIMNBinsXi, fFFIMXiMin, fFFIMXiMax,
1581                                                             fFFIMNBinsZ , fFFIMZMin , fFFIMZMax);
1582
1583   fFFHistosIMLaAllEvt        = new AliFragFuncHistosInvMass("LaAllEvt", fFFIMLaNBinsJetPt, fFFIMLaJetPtMin, fFFIMLaJetPtMax,
1584                                                             fFFIMLaNBinsInvM,fFFIMLaInvMMin,fFFIMLaInvMMax,
1585                                                             fFFIMLaNBinsPt, fFFIMLaPtMin, fFFIMLaPtMax,
1586                                                             fFFIMLaNBinsXi, fFFIMLaXiMin, fFFIMLaXiMax,
1587                                                             fFFIMLaNBinsZ , fFFIMLaZMin , fFFIMLaZMax);
1588
1589   fFFHistosIMLaJet           = new AliFragFuncHistosInvMass("LaJet", fFFIMLaNBinsJetPt, fFFIMLaJetPtMin, fFFIMLaJetPtMax,
1590                                                             fFFIMLaNBinsInvM,fFFIMLaInvMMin,fFFIMLaInvMMax,
1591                                                             fFFIMLaNBinsPt, fFFIMLaPtMin, fFFIMLaPtMax,
1592                                                             fFFIMLaNBinsXi, fFFIMLaXiMin, fFFIMLaXiMax,
1593                                                             fFFIMLaNBinsZ , fFFIMLaZMin , fFFIMLaZMax);
1594
1595
1596   fFFHistosIMLaCone          = new AliFragFuncHistosInvMass("LaCone", fFFIMLaNBinsJetPt, fFFIMLaJetPtMin, fFFIMLaJetPtMax,
1597                                                             fFFIMLaNBinsInvM,fFFIMLaInvMMin,fFFIMLaInvMMax,
1598                                                             fFFIMLaNBinsPt, fFFIMLaPtMin, fFFIMLaPtMax,
1599                                                             fFFIMLaNBinsXi, fFFIMLaXiMin, fFFIMLaXiMax,
1600                                                             fFFIMLaNBinsZ , fFFIMLaZMin , fFFIMLaZMax);
1601
1602
1603   fFFHistosIMALaAllEvt        = new AliFragFuncHistosInvMass("ALaAllEvt", fFFIMLaNBinsJetPt, fFFIMLaJetPtMin, fFFIMLaJetPtMax,
1604                                                             fFFIMLaNBinsInvM,fFFIMLaInvMMin,fFFIMLaInvMMax,
1605                                                             fFFIMLaNBinsPt, fFFIMLaPtMin, fFFIMLaPtMax,
1606                                                             fFFIMLaNBinsXi, fFFIMLaXiMin, fFFIMLaXiMax,
1607                                                             fFFIMLaNBinsZ , fFFIMLaZMin , fFFIMLaZMax);
1608
1609   fFFHistosIMALaJet           = new AliFragFuncHistosInvMass("ALaJet", fFFIMLaNBinsJetPt, fFFIMLaJetPtMin, fFFIMLaJetPtMax,
1610                                                             fFFIMLaNBinsInvM,fFFIMLaInvMMin,fFFIMLaInvMMax,
1611                                                             fFFIMLaNBinsPt, fFFIMLaPtMin, fFFIMLaPtMax,
1612                                                             fFFIMLaNBinsXi, fFFIMLaXiMin, fFFIMLaXiMax,
1613                                                             fFFIMLaNBinsZ , fFFIMLaZMin , fFFIMLaZMax);
1614
1615   fFFHistosIMALaCone          = new AliFragFuncHistosInvMass("ALaCone", fFFIMLaNBinsJetPt, fFFIMLaJetPtMin, fFFIMLaJetPtMax,
1616                                                             fFFIMLaNBinsInvM,fFFIMLaInvMMin,fFFIMLaInvMMax,
1617                                                             fFFIMLaNBinsPt, fFFIMLaPtMin, fFFIMLaPtMax,
1618                                                             fFFIMLaNBinsXi, fFFIMLaXiMin, fFFIMLaXiMax,
1619                                                             fFFIMLaNBinsZ , fFFIMLaZMin , fFFIMLaZMax);
1620   */
1621
1622   //***************
1623   // MC histograms
1624   //***************
1625
1626   //fh2MCgenK0Cone                = new TH2F("fh2MCgenK0Cone", "MC gen {K^{0}}^{s} #it{p}_{T}  in cone around rec jet axis versus jet #it{p}_{T}; jet #it{p}_{T}",19,5.,100.,200,0.,20.);
1627   //fh2MCgenLaCone                = new TH2F("fh2MCgenLaCone", "MC gen #Lambda #it{p}_{T} in cone around rec jet axis versus jet #it{p}_{T} ; jet #it{p}_{T}",19,5.,100.,200,0.,20.);
1628   //fh2MCgenALaCone               = new TH2F("fh2MCgenALaCone", "MC gen #Antilambda #it{p}_{T} in cone around rec jet axis versus jet #it{p}_{T}; jet #it{p}_{T}",19,5.,100.,200,0.,20.);
1629
1630   //fh2MCgenK0Cone->GetYaxis()->SetTitle("MC gen K^{0}}^{s} #it{p}_{T}");
1631   //fh2MCgenLaCone->GetYaxis()->SetTitle("MC gen #Lambda #it{p}_{T}");
1632   //fh2MCgenALaCone->GetYaxis()->SetTitle("MC gen #Antilambda #it{p}_{T}");
1633
1634   //fh2MCEtagenK0Cone             = new TH2F("fh2MCEtagenK0Cone","MC gen {K^{0}}^{s} #it{p}_{T} #eta distribution in jet cone;#eta",19,5.,100.,200,-1.,1.);
1635   //fh2MCEtagenLaCone             = new TH2F("fh2MCEtagenLaCone","MC gen #Lambda #it{p}_{T} #eta distribution in jet cone;#eta",19,5.,100.,200,-1.,1.);
1636   //fh2MCEtagenALaCone            = new TH2F("fh2MCEtagenALaCone","MC gen #Antilambda #it{p}_{T} #eta distribution in jet cone;#eta",19,5.,100.,200,-1.,1.);
1637   fh1IMK0ConeSmear                = new TH1F("fh1IMK0ConeSmear","Smeared jet pt study for K0s-in-cone-jets; smeared jet #it{p}_{T}", 19,5.,100.);
1638   fh1IMLaConeSmear                = new TH1F("fh1IMLaConeSmear","Smeared jet pt study for La-in-cone-jets; smeared jet #it{p}_{T}", 19,5.,100.);
1639   fh1IMALaConeSmear               = new TH1F("fh1IMALaConeSmear","Smeared jet pt study for ALa-in-cone-jets; smeared jet #it{p}_{T}", 19,5.,100.);
1640
1641   fh2CorrHijingLaProton           = new TH2F("fh2CorrHijingLaProton","#Lambda - proton pT correlation, Hijing;#it{p^{#Lambda}}_{T} (GeV/c);#it{p^{proton}}_{T} (GeV/c)",20,0.,20.,20,0.,20.);
1642   fh2CorrInjectLaProton           = new TH2F("fh2CorrInjectLaProton","#Lambda - proton pT correlation, Injected;#it{p^{#Lambda}}_{T} (GeV/c);#it{p^{proton}}_{T} (GeV/c)",20,0.,20.,20,0.,20.);
1643   fh2CorrHijingALaAProton         = new TH2F("fh2CorrHijingALaAProton","#bar{#Lambda} - proton pT correlation, Hijing;#it{p^{#Lambda}}_{T} (GeV/c);#it{p^{#bar{proton}}}_{T} (GeV/c)",20,0.,20.,20,0.,20.);
1644   fh2CorrInjectALaAProton         = new TH2F("fh2CorrInjectALaAProton","#bar{#Lambda} - proton pT correlation, Injected;#it{p^{#Lambda}}_{T} (GeV/c);#it{p^{#bar{proton}}}_{T} (GeV/c)",20,0.,20.,20,0.,20.);
1645   //12 new histograms: Cone, Incl, Lambda, Antilambda, Hijing, Injected:
1646
1647   fh2MCEtaVsPtHijingLa              = new TH2F("fh2MCEtaVsPtHijingLa","MC Hijing gen. #Lambda #eta; #it{p}_{T}",200,0.,20.,200,-1.,1.);
1648   fh2MCEtaVsPtInjectLa              = new TH2F("fh2MCEtaVsPtInjectLa","MC injected gen. #Lambda  #eta; #it{p}_{T}",200,0.,20.,200,-1.,1.);
1649   fh2MCEtaVsPtHijingALa             = new TH2F("fh2MCEtaVsPtHijingALa","MC gen. Hijing  #bar{#Lambda} #eta; #it{p}_{T}",200,0.,20.,200,-1.,1.);
1650   fh2MCEtaVsPtInjectALa             = new TH2F("fh2MCEtaVsPtInjectALa","MC gen. injected #bar{#Lambda}  #eta; #it{p}_{T}",200,0.,20.,200,-1.,1.);
1651
1652   Int_t binsrecMCHijingLaIncl[3] = {200, 120, 200};
1653   Double_t xminrecMCHijingLaIncl[3] = {1.05, 0., -1.};
1654   Double_t xmaxrecMCHijingLaIncl[3] = {1.25, 12., 1.};
1655   fhnrecMCHijingLaIncl          = new THnSparseF("fhnrecMCHijingLaIncl","La inv. mass; particle pT; particle #eta",3,binsrecMCHijingLaIncl,xminrecMCHijingLaIncl,xmaxrecMCHijingLaIncl);
1656
1657   Int_t binsrecMCHijingLaCone[4] = {19, 200, 120, 200};
1658   Double_t xminrecMCHijingLaCone[4] = {5., 1.05, 0., -1.};
1659   Double_t xmaxrecMCHijingLaCone[4] = {100., 1.25, 12., 1.};
1660   fhnrecMCHijingLaCone          = new THnSparseF("fhnrecMCHijingLaCone","La inv. mass; particle pT; particle #eta",4,binsrecMCHijingLaCone,xminrecMCHijingLaCone,xmaxrecMCHijingLaCone);
1661
1662   Int_t binsrecMCHijingALaIncl[3] = {200, 120, 200};
1663   Double_t xminrecMCHijingALaIncl[3] = {1.05, 0., -1.};
1664   Double_t xmaxrecMCHijingALaIncl[3] = {1.25, 12., 1.};
1665   fhnrecMCHijingALaIncl         = new THnSparseF("fhnrecMCHijingALaIncl","ALa inv. mass; particle pT; particle #eta",3,binsrecMCHijingALaIncl,xminrecMCHijingALaIncl,xmaxrecMCHijingALaIncl);
1666
1667   Int_t binsrecMCHijingALaCone[4] = {19, 200, 120, 200};
1668   Double_t xminrecMCHijingALaCone[4] = {5., 1.05, 0., -1.};
1669   Double_t xmaxrecMCHijingALaCone[4] = {100., 1.25, 12., 1.};
1670   fhnrecMCHijingALaCone         = new THnSparseF("fhnrecMCHijingALaCone","ALa inv. mass; particle pT; particle #eta",4,binsrecMCHijingALaCone,xminrecMCHijingALaCone,xmaxrecMCHijingALaCone);
1671
1672   Int_t binsrecMCInjectLaIncl[3] = {200, 120, 200};
1673   Double_t xminrecMCInjectLaIncl[3] = {1.05, 0., -1.};
1674   Double_t xmaxrecMCInjectLaIncl[3] = {1.25, 12., 1.};
1675   fhnrecMCInjectLaIncl          = new THnSparseF("fhnrecMCInjectLaIncl","La inv. mass; particle pT; particle #eta",3,binsrecMCInjectLaIncl,xminrecMCInjectLaIncl,xmaxrecMCInjectLaIncl);
1676
1677   Int_t binsrecMCInjectLaCone[4] = {19, 200, 120, 200};
1678   Double_t xminrecMCInjectLaCone[4] = {5., 1.05, 0., -1.};
1679   Double_t xmaxrecMCInjectLaCone[4] = {100., 1.25, 12., 1.};
1680   fhnrecMCInjectLaCone          = new THnSparseF("fhnrecMCInjectLaCone","La jet pT;inv. mass; particle pT; particle #eta",4,binsrecMCInjectLaCone,xminrecMCInjectLaCone,xmaxrecMCInjectLaCone);
1681
1682   Int_t binsrecMCInjectALaIncl[3] = {200, 120, 200};
1683   Double_t xminrecMCInjectALaIncl[3] = {1.05, 0., -1.};
1684   Double_t xmaxrecMCInjectALaIncl[3] = {1.25, 12., 1.};
1685   fhnrecMCInjectALaIncl         = new THnSparseF("fhnrecMCInjectALaIncl","ALa inv. mass; particle pT; particle #eta",3,binsrecMCInjectALaIncl,xminrecMCInjectALaIncl,xmaxrecMCInjectALaIncl);
1686
1687   Int_t binsrecMCInjectALaCone[4] = {19, 200, 120, 200};
1688   Double_t xminrecMCInjectALaCone[4] = {5., 1.05, 0., -1.};
1689   Double_t xmaxrecMCInjectALaCone[4] = {100., 1.25, 12., 1.};
1690   fhnrecMCInjectALaCone         = new THnSparseF("fhnrecMCInjectALaCone","ALa inv. mass; particle pT; particle #eta",4,binsrecMCInjectALaCone,xminrecMCInjectALaCone,xmaxrecMCInjectALaCone);
1691
1692
1693   Int_t binsMCrecK0Cone[4] = {19, 200, 120, 200};
1694   Double_t xminMCrecK0Cone[4] = {5.,0.3, 0., -1.};
1695   Double_t xmaxMCrecK0Cone[4] = {100.,0.7, 12., 1.};
1696   fhnMCrecK0Cone                = new THnSparseF("fhnMCrecK0Cone", "MC rec {K^{0}}^{s} #it{p}_{T}  in cone around jet axis matching MC gen particle; jet #it{p}_{T}; inv mass (GeV/#it{c}^{2};#it{p}_{T}",4,binsMCrecK0Cone,xminMCrecK0Cone,xmaxMCrecK0Cone);
1697
1698   Int_t binsMCrecLaCone[4] = {19, 200, 120, 200};
1699   Double_t xminMCrecLaCone[4] = {5.,0.3, 0., -1.};
1700   Double_t xmaxMCrecLaCone[4] = {100.,0.7, 12., 1.};
1701   fhnMCrecLaCone                = new THnSparseF("fhnMCrecLaCone", "MC rec {#Lambda #it{p}_{T}  in cone around jet axis matching MC gen particle; jet #it{p}_{T}; inv mass (GeV/#it{c}^{2};#it{p}_{T}",4,binsMCrecLaCone,xminMCrecLaCone,xmaxMCrecLaCone);
1702
1703   Int_t binsMCrecALaCone[4] = {19, 200, 120, 200};
1704   Double_t xminMCrecALaCone[4] = {5.,0.3, 0., -1.};
1705   Double_t xmaxMCrecALaCone[4] = {100.,0.7, 12., 1.};
1706   fhnMCrecALaCone                = new THnSparseF("fhnMCrecALaCone", "MC rec {#bar{#Lambda} #it{p}_{T}  in cone around jet axis matching MC gen particle; jet #it{p}_{T}; inv mass (GeV/#it{c}^{2};#it{p}_{T}",4,binsMCrecALaCone,xminMCrecALaCone,xmaxMCrecALaCone);
1707
1708   Int_t binsMCrecK0ConeSmear[4] = {19, 200, 120, 200};
1709   Double_t xminMCrecK0ConeSmear[4] = {5.,0.3, 0., -1.};
1710   Double_t xmaxMCrecK0ConeSmear[4] = {100.,0.7, 12., 1.};
1711   fhnMCrecK0ConeSmear                = new THnSparseF("fhnMCrecK0ConeSmear", "MC rec {K^{0}}^{s} #it{p}_{T}  in cone around jet axis matching MC gen particle; jet #it{p}_{T}; inv mass (GeV/#it{c}^{2};#it{p}_{T}",4,binsMCrecK0ConeSmear,xminMCrecK0ConeSmear,xmaxMCrecK0ConeSmear);
1712
1713   Int_t binsMCrecLaConeSmear[4] = {19, 200, 120, 200};
1714   Double_t xminMCrecLaConeSmear[4] = {5.,1.05, 0., -1.};
1715   Double_t xmaxMCrecLaConeSmear[4] = {100.,1.25, 12., 1.};
1716   fhnMCrecLaConeSmear                = new THnSparseF("fhnMCrecLaConeSmear", "MC rec {#Lambda #it{p}_{T}  in cone around jet axis matching MC gen particle; jet #it{p}_{T}; inv mass (GeV/#it{c}^{2};#it{p}_{T}",4,binsMCrecLaConeSmear,xminMCrecLaConeSmear,xmaxMCrecLaConeSmear);
1717
1718   Int_t binsMCrecALaConeSmear[4] = {19, 200, 120, 200};
1719   Double_t xminMCrecALaConeSmear[4] = {5.,1.05, 0., -1.};
1720   Double_t xmaxMCrecALaConeSmear[4] = {100.,1.25, 12., 1.};
1721   fhnMCrecALaConeSmear                = new THnSparseF("fhnMCrecALaConeSmear", "MC rec {#bar{#Lambda} #it{p}_{T}  in cone around jet axis matching MC gen particle; jet #it{p}_{T}; inv mass (GeV/#it{c}^{2};#it{p}_{T}",4,binsMCrecALaConeSmear,xminMCrecALaConeSmear,xmaxMCrecALaConeSmear);
1722
1723   Int_t binsK0sSecContinCone[3] = {19, 120, 200};
1724   Double_t xminK0sSecContinCone[3] = {5.,0., -1.};
1725   Double_t xmaxK0sSecContinCone[3] = {100.,12., 1.};
1726   fhnK0sSecContinCone                = new THnSparseF("fhnK0sSecContinCone", "Secondary contamination {K^{0}}^{s} #it{p}_{T}  in cone around jet axis; jet #it{p}_{T}; inv mass (GeV/#it{c}^{2};#it{p}_{T}",3,binsK0sSecContinCone,xminK0sSecContinCone,xmaxK0sSecContinCone);
1727
1728   Int_t binsLaSecContinCone[3] = {19, 120, 200};
1729   Double_t xminLaSecContinCone[3] = {5.,0., -1.};
1730   Double_t xmaxLaSecContinCone[3] = {100.,12., 1.};
1731   fhnLaSecContinCone                = new THnSparseF("fhnLaSecContinCone", "Secondary contamination {#Lambda #it{p}_{T}  in cone around jet axis; jet #it{p}_{T}; inv mass (GeV/#it{c}^{2};#it{p}_{T}",3,binsLaSecContinCone,xminLaSecContinCone,xmaxLaSecContinCone);
1732
1733   Int_t binsALaSecContinCone[3] = {19, 120, 200};
1734   Double_t xminALaSecContinCone[3] = {5.,0., -1.};
1735   Double_t xmaxALaSecContinCone[3] = {100.,12., 1.};
1736   fhnALaSecContinCone                = new THnSparseF("fhnALaSecContinCone", "Secondary contamination {#bar{#Lambda} #it{p}_{T}  in cone around jet axis; jet #it{p}_{T}; inv mass (GeV/#it{c}^{2};#it{p}_{T}",3,binsALaSecContinCone,xminALaSecContinCone,xmaxALaSecContinCone);
1737
1738   Int_t binsK0sIncl[3] = {200, 120, 200};
1739   Double_t xminK0sIncl[3] = {0.3, 0., -1.};
1740   Double_t xmaxK0sIncl[3] = {0.7, 12., 1.};
1741   fhnK0sIncl                    = new THnSparseF("fhnK0sIncl","K0s inv. mass; particle pT; particle #eta",3,binsK0sIncl,xminK0sIncl,xmaxK0sIncl);
1742
1743   Int_t binsK0sCone[4] = {19, 200, 120, 200};
1744   Double_t xminK0sCone[4] = {5.,0.3, 0., -1.};
1745   Double_t xmaxK0sCone[4] = {100.,0.7, 12., 1.};
1746   fhnK0sCone                    = new THnSparseF("fhnK0sCone","jet pT; K0s inv. mass; particle pT; particle #eta",4,binsK0sCone,xminK0sCone,xmaxK0sCone);
1747
1748   Int_t binsLaIncl[3] = {200, 120, 200};
1749   Double_t xminLaIncl[3] = {1.05, 0., -1.};
1750   Double_t xmaxLaIncl[3] = {1.25, 12., 1.};
1751   fhnLaIncl                    = new THnSparseF("fhnLaIncl","La inv. mass; particle pT; particle #eta",3,binsLaIncl,xminLaIncl,xmaxLaIncl);
1752
1753   Int_t binsLaCone[4] = {19, 200, 120, 200};
1754   Double_t xminLaCone[4] = {5.,1.05, 0., -1.};
1755   Double_t xmaxLaCone[4] = {100.,1.25, 12., 1.};
1756   fhnLaCone                    = new THnSparseF("fhnLaCone","jet pT; La inv. mass; particle pT; particle #eta",4,binsLaCone,xminLaCone,xmaxLaCone);
1757
1758   Int_t binsALaIncl[3] = {200, 120, 200};
1759   Double_t xminALaIncl[3] = {1.05, 0., -1.};
1760   Double_t xmaxALaIncl[3] = {1.25, 12., 1.};
1761   fhnALaIncl                    = new THnSparseF("fhnALaIncl","ALa inv. mass; particle pT; particle #eta",3,binsALaIncl,xminALaIncl,xmaxALaIncl);
1762
1763   Int_t binsALaCone[4] = {19, 200, 120, 200};
1764   Double_t xminALaCone[4] = {5.,1.05, 0., -1.};
1765   Double_t xmaxALaCone[4] = {100.,1.25, 12., 1.};
1766   fhnALaCone                    = new THnSparseF("fhnALaCone","jet pT; ALa inv. mass; particle pT; particle #eta",4,binsALaCone,xminALaCone,xmaxALaCone);
1767
1768   fh1MCMultiplicityPrimary      = new TH1F("fh1MCMultiplicityPrimary", "MC Primary Particles;NPrimary;Count", 201, -0.5, 200.5);
1769   fh1MCMultiplicityTracks       = new TH1F("h1MCMultiplicityTracks", "MC Tracks;Ntracks;Count", 201, -0.5, 200.5);
1770
1771
1772   Int_t binsFeedDownLa[3] = {19, 200, 120};
1773   Double_t xminFeedDownLa[3] = {5.,1.05, 0.};
1774   Double_t xmaxFeedDownLa[3] = {100.,1.25, 12.};
1775   fhnFeedDownLa                 = new THnSparseF("fhnFeedDownLa","#Lambda stemming from feeddown from Xi(0/-)",3,binsFeedDownLa,xminFeedDownLa,xmaxFeedDownLa);
1776
1777   Int_t binsFeedDownALa[3] = {19, 200, 120};
1778   Double_t xminFeedDownALa[3] = {5.,1.05, 0.};
1779   Double_t xmaxFeedDownALa[3] = {100.,1.25, 12.};
1780   fhnFeedDownALa                 = new THnSparseF("fhnFeedDownALa","#bar#Lambda stemming from feeddown from Xibar(0/+)",3,binsFeedDownALa,xminFeedDownALa,xmaxFeedDownALa);
1781
1782   Int_t binsFeedDownLaCone[3] = {19, 200, 120};
1783   Double_t xminFeedDownLaCone[3] = {5.,1.05, 0.};
1784   Double_t xmaxFeedDownLaCone[3] = {100.,1.25, 12.};
1785   fhnFeedDownLaCone             = new THnSparseF("fhnFeedDownLaCone","#Lambda stemming from feeddown from Xi(0/-) in jet cone",3,binsFeedDownLaCone,xminFeedDownLaCone,xmaxFeedDownLaCone);
1786
1787   Int_t binsFeedDownALaCone[3] = {19, 200, 120};
1788   Double_t xminFeedDownALaCone[3] = {5.,1.05, 0.};
1789   Double_t xmaxFeedDownALaCone[3] = {100.,1.25, 12.};
1790   fhnFeedDownALaCone             = new THnSparseF("fhnFeedDownALaCone","#bar#Lambda stemming from feeddown from Xibar(0/+) in jet cone",3,binsFeedDownALaCone,xminFeedDownALaCone,xmaxFeedDownALaCone);
1791
1792
1793   fh1MCProdRadiusK0s            = new TH1F("fh1MCProdRadiusK0s","MC gen. MC K0s prod radius",100,0.,100.);
1794   fh1MCProdRadiusLambda         = new TH1F("fh1MCProdRadiusLambda","MC gen. MC La prod radius",100,0.,100.);
1795   fh1MCProdRadiusAntiLambda     = new TH1F("fh1MCProdRadiusAntiLambda","MC gen. MC ALa prod radius",100,0.,100.);
1796
1797   // Pt and inv mass distributions
1798
1799   fh1MCPtV0s                    = new TH1F("fh1MCPtV0s", "MC gen. V^{0} in rap range;#it{p}_{T} (GeV/#it{c})",120,0,12.);// 0.1 GeV/c steps
1800   fh1MCPtK0s                    = new TH1F("fh1MCPtK0s", "MC gen. K^{0}_{s} in eta range;#it{p}_{T} (GeV/#it{c})",120,0.,12.);
1801   fh1MCPtLambda                 = new TH1F("fh1MCPtLambda", "MC gen. #Lambda in rap range;#it{p}_{T} (GeV/#it{c})",120,0.,12.);
1802   fh1MCPtAntiLambda             = new TH1F("fh1MCPtAntiLambda", "MC gen. #AntiLambda in rap range;#it{p}_{T} (GeV/#it{c})",120,0.,12.);
1803   fh1MCXiPt                     = new TH1F("fh1MCXiPt", "MC gen. #Xi^{-/o};#it{p}_{T} (GeV/#it{c})",120,0.,12.);
1804   fh1MCXibarPt                  = new TH1F("fh1MCXibarPt", "MC gen. #bar{#Xi}^{+/o};#it{p}_{T} (GeV/#it{c})",120,0.,12.);
1805   fh2MCEtaVsPtK0s               = new TH2F("fh2MCEtaVsPtK0s","MC gen. K^{0}_{s} #eta; #it{p}_{T}",120,0.,12.,200,-1.,1.);
1806   fh2MCEtaVsPtLa                = new TH2F("fh2MCEtaVsPtLa","MC gen. #Lambda #eta; #it{p}_{T}",120,0.,12.,200,-1.,1.);
1807   fh2MCEtaVsPtALa               = new TH2F("fh2MCEtaVsPtALa","MC gen. #bar{#Lambda}  #eta; #it{p}_{T}",120,0.,12.,200,-1.,1.);
1808
1809   // Rapidity
1810   //fh1MCRapK0s                   = new TH1F("fh1MCRapK0s", "MC gen. K0s;rap with cut",200,-10,10);
1811   //fh1MCRapLambda                = new TH1F("fh1MCRapLambda", "MC gen. #Lambda;rap",200,-10,10);
1812   //fh1MCRapAntiLambda            = new TH1F("fh1MCRapAntiLambda", "MC gen. #bar{#Lambda};rap",200,-10,10);
1813   fh1MCEtaAllK0s                = new TH1F("fh1MCEtaAllK0s", "MC gen. K0s;#eta",200,-1.,1.);
1814   fh1MCEtaK0s                   = new TH1F("fh1MCEtaK0s", "MC gen. K0s;#eta with cut",200,-1.,1.);
1815   fh1MCEtaLambda                = new TH1F("fh1MCEtaLambda", "MC gen. #Lambda;#eta",200,-1.,1.);
1816   fh1MCEtaAntiLambda            = new TH1F("fh1MCEtaAntiLambda", "MC gen. #bar{#Lambda};#eta",200,-1.,1.);
1817
1818   fV0QAK0->DefineHistos();
1819   fFFHistosRecCuts->DefineHistos();
1820   fFFHistosRecCutsK0Evt->DefineHistos();
1821   /* fFFHistosIMK0AllEvt->DefineHistos();
1822   fFFHistosIMK0Jet->DefineHistos();
1823   fFFHistosIMK0Cone->DefineHistos();
1824   fFFHistosIMLaAllEvt->DefineHistos();
1825   fFFHistosIMLaJet->DefineHistos();
1826   fFFHistosIMLaCone->DefineHistos();
1827   fFFHistosIMALaAllEvt->DefineHistos();
1828   fFFHistosIMALaJet->DefineHistos();
1829   fFFHistosIMALaCone->DefineHistos();
1830   */
1831
1832   const Int_t saveLevel = 5;
1833   if(saveLevel>0){
1834
1835     fCommonHistList->Add(fh1EvtAllCent);
1836     fCommonHistList->Add(fh1Evt);
1837     fCommonHistList->Add(fh1EvtSelection);
1838     fCommonHistList->Add(fh1EvtCent);
1839     fCommonHistList->Add(fh1VertexNContributors);
1840     fCommonHistList->Add(fh1VertexZ);
1841     fCommonHistList->Add(fh1Xsec);
1842     fCommonHistList->Add(fh1Trials);
1843     fCommonHistList->Add(fh1PtHard);
1844     fCommonHistList->Add(fh1PtHardTrials);
1845     fCommonHistList->Add(fh1nRecJetsCuts);
1846     fCommonHistList->Add(fh1EvtMult);
1847     fCommonHistList->Add(fh1K0Mult);
1848     fCommonHistList->Add(fh1dPhiJetK0);
1849     fCommonHistList->Add(fh1LaMult);
1850     fCommonHistList->Add(fh1dPhiJetLa);
1851     fCommonHistList->Add(fh1ALaMult);
1852     fCommonHistList->Add(fh1dPhiJetALa);
1853     fCommonHistList->Add(fh1JetEta);
1854     fCommonHistList->Add(fh1JetPhi);
1855     fCommonHistList->Add(fh2JetEtaPhi);
1856     //fCommonHistList->Add(fh1V0JetPt);
1857     fCommonHistList->Add(fh1IMK0Cone);
1858     fCommonHistList->Add(fh1IMLaCone);
1859     fCommonHistList->Add(fh1IMALaCone);
1860     fCommonHistList->Add(fh2FFJetTrackEta);
1861     // fCommonHistList->Add(fh1trackPosNCls);
1862     //fCommonHistList->Add(fh1trackNegNCls);
1863     fCommonHistList->Add(fh1trackPosEta);
1864     fCommonHistList->Add(fh1trackNegEta);
1865     fCommonHistList->Add(fh1V0Eta);
1866     // fCommonHistList->Add(fh1V0totMom);
1867     fCommonHistList->Add(fh1CosPointAngle);
1868     fCommonHistList->Add(fh1DecayLengthV0);
1869     fCommonHistList->Add(fh2ProperLifetimeK0sVsPtBeforeCut);
1870     fCommonHistList->Add(fh2ProperLifetimeK0sVsPtAfterCut);
1871     fCommonHistList->Add(fh1V0Radius);
1872     fCommonHistList->Add(fh1DcaV0Daughters);
1873     fCommonHistList->Add(fh1DcaPosToPrimVertex);
1874     fCommonHistList->Add(fh1DcaNegToPrimVertex);
1875     fCommonHistList->Add(fh2ArmenterosBeforeCuts);
1876     fCommonHistList->Add(fh2ArmenterosAfterCuts);
1877     fCommonHistList->Add(fh2BBLaPos);
1878     fCommonHistList->Add(fh2BBLaNeg);
1879     fCommonHistList->Add(fh1PosDaughterCharge);
1880     fCommonHistList->Add(fh1NegDaughterCharge);
1881     fCommonHistList->Add(fh1PtMCK0s);
1882     fCommonHistList->Add(fh1PtMCLa);
1883     fCommonHistList->Add(fh1PtMCALa);
1884     fCommonHistList->Add(fh1EtaK0s);
1885     fCommonHistList->Add(fh1EtaLa);
1886     fCommonHistList->Add(fh1EtaALa);
1887     fCommonHistList->Add(fh1RC);
1888     fCommonHistList->Add(fh1RCBiasK0);
1889     fCommonHistList->Add(fh1RCBiasLa);
1890     fCommonHistList->Add(fh1RCBiasALa);
1891     fCommonHistList->Add(fh1MCC);
1892     fCommonHistList->Add(fh1OC);
1893     fCommonHistList->Add(fh1NJ);
1894     fCommonHistList->Add(fhnInvMassEtaTrackPtK0s);
1895     fCommonHistList->Add(fhnInvMassEtaTrackPtLa);
1896     fCommonHistList->Add(fhnInvMassEtaTrackPtALa);
1897     fCommonHistList->Add(fh1TrackMultCone);
1898     fCommonHistList->Add(fh2TrackMultCone);
1899     fCommonHistList->Add(fhnNJK0);
1900     fCommonHistList->Add(fhnNJLa);
1901     fCommonHistList->Add(fhnNJALa);
1902     //fCommonHistList->Add(fh2MCgenK0Cone);
1903     //fCommonHistList->Add(fh2MCgenLaCone);
1904     //fCommonHistList->Add(fh2MCgenALaCone);
1905     //fCommonHistList->Add(fh2MCEtagenK0Cone);
1906     //fCommonHistList->Add(fh2MCEtagenLaCone);
1907     //fCommonHistList->Add(fh2MCEtagenALaCone);
1908     fCommonHistList->Add(fh2CorrHijingLaProton);
1909     fCommonHistList->Add(fh2CorrInjectLaProton);
1910     fCommonHistList->Add(fh2CorrHijingALaAProton);
1911     fCommonHistList->Add(fh2CorrInjectALaAProton);
1912     fCommonHistList->Add(fh2MCEtaVsPtHijingLa);
1913     fCommonHistList->Add(fh2MCEtaVsPtInjectLa);
1914     fCommonHistList->Add(fh2MCEtaVsPtHijingALa);
1915     fCommonHistList->Add(fh2MCEtaVsPtInjectALa);
1916     fCommonHistList->Add(fh1IMK0ConeSmear);
1917     fCommonHistList->Add(fh1IMLaConeSmear);
1918     fCommonHistList->Add(fh1IMALaConeSmear);
1919     fCommonHistList->Add(fhnrecMCHijingLaIncl);
1920     fCommonHistList->Add(fhnrecMCHijingLaCone);
1921     fCommonHistList->Add(fhnrecMCHijingALaIncl);
1922     fCommonHistList->Add(fhnrecMCHijingALaCone);
1923     fCommonHistList->Add(fhnrecMCInjectLaIncl);
1924     fCommonHistList->Add(fhnrecMCInjectLaCone);
1925     fCommonHistList->Add(fhnrecMCInjectALaIncl);
1926     fCommonHistList->Add(fhnrecMCInjectALaCone);
1927     fCommonHistList->Add(fhnMCrecK0Cone);
1928     fCommonHistList->Add(fhnMCrecLaCone);
1929     fCommonHistList->Add(fhnMCrecALaCone);
1930     fCommonHistList->Add(fhnMCrecK0ConeSmear);
1931     fCommonHistList->Add(fhnMCrecLaConeSmear);
1932     fCommonHistList->Add(fhnMCrecALaConeSmear);
1933     fCommonHistList->Add(fhnK0sSecContinCone);
1934     fCommonHistList->Add(fhnLaSecContinCone);
1935     fCommonHistList->Add(fhnALaSecContinCone);
1936     fCommonHistList->Add(fhnK0sIncl);
1937     fCommonHistList->Add(fhnK0sCone);
1938     fCommonHistList->Add(fhnLaIncl);
1939     fCommonHistList->Add(fhnLaCone);
1940     fCommonHistList->Add(fhnALaIncl);
1941     fCommonHistList->Add(fhnALaCone);
1942     fCommonHistList->Add(fhnK0sPC);
1943     fCommonHistList->Add(fhnLaPC);
1944     fCommonHistList->Add(fhnALaPC);
1945     fCommonHistList->Add(fhnK0sMCC);
1946     fCommonHistList->Add(fhnLaMCC);
1947     fCommonHistList->Add(fhnALaMCC);
1948     fCommonHistList->Add(fhnK0sRC);
1949     fCommonHistList->Add(fhnLaRC);
1950     fCommonHistList->Add(fhnALaRC);
1951     fCommonHistList->Add(fhnK0sRCBias);
1952     fCommonHistList->Add(fhnLaRCBias);
1953     fCommonHistList->Add(fhnALaRCBias);
1954     fCommonHistList->Add(fhnK0sOC);
1955     fCommonHistList->Add(fhnLaOC);
1956     fCommonHistList->Add(fhnALaOC);
1957     fCommonHistList->Add(fh1AreaExcluded);
1958     fCommonHistList->Add(fh1MedianEta);
1959     fCommonHistList->Add(fh1JetPtMedian);
1960     fCommonHistList->Add(fh1MCMultiplicityPrimary);
1961     fCommonHistList->Add(fh1MCMultiplicityTracks);
1962     fCommonHistList->Add(fhnFeedDownLa);
1963     fCommonHistList->Add(fhnFeedDownALa);
1964     fCommonHistList->Add(fhnFeedDownLaCone);
1965     fCommonHistList->Add(fhnFeedDownALaCone);
1966     fCommonHistList->Add(fh1MCProdRadiusK0s);
1967     fCommonHistList->Add(fh1MCProdRadiusLambda);
1968     fCommonHistList->Add(fh1MCProdRadiusAntiLambda);
1969     fCommonHistList->Add(fh1MCPtV0s);
1970     fCommonHistList->Add(fh1MCPtK0s);
1971     fCommonHistList->Add(fh1MCPtLambda);
1972     fCommonHistList->Add(fh1MCPtAntiLambda);
1973     fCommonHistList->Add(fh1MCXiPt);
1974     fCommonHistList->Add(fh1MCXibarPt);
1975     fCommonHistList->Add(fh2MCEtaVsPtK0s);
1976     fCommonHistList->Add(fh2MCEtaVsPtLa);
1977     fCommonHistList->Add(fh2MCEtaVsPtALa);
1978     //fCommonHistList->Add(fh1MCRapK0s);
1979     //fCommonHistList->Add(fh1MCRapLambda);
1980     //fCommonHistList->Add(fh1MCRapAntiLambda);
1981     fCommonHistList->Add(fh1MCEtaAllK0s);
1982     fCommonHistList->Add(fh1MCEtaK0s);
1983     fCommonHistList->Add(fh1MCEtaLambda);
1984     fCommonHistList->Add(fh1MCEtaAntiLambda);
1985
1986
1987
1988     fV0QAK0->AddToOutput(fCommonHistList);
1989     fFFHistosRecCuts->AddToOutput(fCommonHistList);
1990     fFFHistosRecCutsK0Evt->AddToOutput(fCommonHistList);
1991     // fFFHistosIMK0AllEvt->AddToOutput(fCommonHistList);
1992     // fFFHistosIMK0Jet->AddToOutput(fCommonHistList);
1993     // fFFHistosIMK0Cone->AddToOutput(fCommonHistList);
1994     // fFFHistosIMLaAllEvt->AddToOutput(fCommonHistList);
1995     // fFFHistosIMLaJet->AddToOutput(fCommonHistList);
1996     // fFFHistosIMLaCone->AddToOutput(fCommonHistList);
1997     // fFFHistosIMALaAllEvt->AddToOutput(fCommonHistList);
1998     // fFFHistosIMALaJet->AddToOutput(fCommonHistList);
1999     // fFFHistosIMALaCone->AddToOutput(fCommonHistList);
2000
2001
2002   }
2003
2004     // =========== Switch on Sumw2 for all histos ===========
2005   for (Int_t i=0; i<fCommonHistList->GetEntries(); ++i){
2006
2007    TH1 *h1 = dynamic_cast<TH1*>(fCommonHistList->At(i));
2008
2009    if (h1) h1->Sumw2();//The error per bin will be computed as sqrt(sum of squares of weight) for each bin
2010     else{
2011       THnSparse *hnSparse = dynamic_cast<THnSparse*>(fCommonHistList->At(i));
2012       if(hnSparse) hnSparse->Sumw2();
2013     }
2014
2015   }
2016   TH1::AddDirectory(oldStatus);
2017  PostData(1, fCommonHistList);
2018 }
2019
2020 //_______________________________________________
2021 void AliAnalysisTaskJetChem::UserExec(Option_t *)
2022 {
2023   // Main loop
2024   // Called for each event
2025
2026   if(fDebug > 1) Printf("AliAnalysisTaskJetChem::UserExec()");
2027
2028   if(fDebug > 1) Printf("Analysis event #%5d", (Int_t) fEntry);
2029
2030    // Trigger selection
2031   AliInputEventHandler* inputHandler = (AliInputEventHandler*)
2032     ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
2033
2034
2035   //for AliPIDResponse:
2036   //AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
2037   //AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
2038   fPIDResponse = inputHandler->GetPIDResponse();
2039
2040   if (!fPIDResponse){if(fDebug > 1) Printf("AliAnalysisTaskJetChem::UserExec(): fPIDResponse does not exist!"); return;}
2041
2042   //std::cout<<"inputHandler->IsEventSelected(): "<<inputHandler->IsEventSelected()<<std::endl;
2043   //std::cout<<"fEvtSelectionMask: "<<fEvtSelectionMask<<std::endl;
2044
2045   if(!(inputHandler->IsEventSelected() & fEvtSelectionMask)){
2046     //std::cout<<"########event rejected!!############"<<std::endl;
2047     fh1EvtSelection->Fill(1.);
2048     if (fDebug > 1 ) Printf(" Trigger Selection: event REJECTED ... ");
2049     PostData(1, fCommonHistList);
2050     return;
2051   }
2052
2053   fESD = dynamic_cast<AliESDEvent*>(InputEvent());//casting of pointers for inherited class, only for ESDs
2054   if(!fESD){
2055     if(fDebug>3) Printf("%s:%d ESDEvent not found in the input", (char*)__FILE__,__LINE__);
2056   }
2057
2058   fMCEvent = MCEvent();
2059   if(!fMCEvent){
2060     if(fDebug>3) Printf("%s:%d MCEvent not found in the input", (char*)__FILE__,__LINE__);
2061   }
2062
2063   // get AOD event from input/output
2064   TObject* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
2065   if( handler && handler->InheritsFrom("AliAODInputHandler") ) {
2066     fAOD  =  ((AliAODInputHandler*)handler)->GetEvent();
2067     if(fUseAODInputJets) fAODJets = fAOD;
2068     if (fDebug > 1)  Printf("%s:%d AOD event from input", (char*)__FILE__,__LINE__);
2069   }
2070   else {
2071     handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
2072     if( handler && handler->InheritsFrom("AliAODHandler") ) {
2073       fAOD = ((AliAODHandler*)handler)->GetAOD();
2074       fAODJets = fAOD;
2075       if (fDebug > 1)  Printf("%s:%d AOD event from output", (char*)__FILE__,__LINE__);
2076     }
2077   }
2078
2079   if(!fAODJets && !fUseAODInputJets){ // case we have AOD in input & output and want jets from output
2080     TObject* outHandler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
2081     if( outHandler && outHandler->InheritsFrom("AliAODHandler") ){
2082       fAODJets = ((AliAODHandler*)outHandler)->GetAOD();
2083       if (fDebug > 1)  Printf("%s:%d jets from output AOD", (char*)__FILE__,__LINE__);
2084     }
2085   }
2086
2087   if(fNonStdFile.Length()!=0){
2088     // case we have an AOD extension - fetch the jets from the extended output
2089
2090     AliAODHandler *aodH = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
2091     fAODExtension = (aodH?aodH->GetExtension(fNonStdFile.Data()):0);
2092     if(!fAODExtension){
2093       if(fDebug>1)Printf("AODExtension not found for %s",fNonStdFile.Data());
2094     }
2095   }
2096
2097   if(!fAOD){
2098     Printf("%s:%d AODEvent not found", (char*)__FILE__,__LINE__);
2099     return;
2100   }
2101   if(!fAODJets){
2102     Printf("%s:%d AODEvent with jet branch not found", (char*)__FILE__,__LINE__);
2103     return;
2104   }
2105
2106   //primary vertex position:
2107   AliAODVertex *myPrimaryVertex = NULL;
2108   myPrimaryVertex = (AliAODVertex*)fAOD->GetPrimaryVertex();
2109   if (!myPrimaryVertex) return;
2110   fh1Evt->Fill(1.);//fill in every event that was accessed with InputHandler
2111
2112   // event selection  *****************************************
2113
2114   // *** vertex cut ***
2115   AliAODVertex* primVtx = fAOD->GetPrimaryVertex();
2116   Int_t nTracksPrim = primVtx->GetNContributors();
2117   fh1VertexNContributors->Fill(nTracksPrim);
2118
2119   if (fDebug > 1) Printf("%s:%d primary vertex selection: %d", (char*)__FILE__,__LINE__,nTracksPrim);
2120   //if(!nTracksPrim){
2121   if(nTracksPrim <= 2){
2122     if (fDebug > 1) Printf("%s:%d primary vertex selection: event REJECTED...",(char*)__FILE__,__LINE__);
2123     fh1EvtSelection->Fill(3.);
2124     PostData(1, fCommonHistList);
2125     return;
2126   }
2127
2128   fh1VertexZ->Fill(primVtx->GetZ());
2129
2130   if(TMath::Abs(primVtx->GetZ())>fMaxVertexZ){
2131     if (fDebug > 1) Printf("%s:%d primary vertex z = %f: event REJECTED...",(char*)__FILE__,__LINE__,primVtx->GetZ());
2132     fh1EvtSelection->Fill(4.);
2133     PostData(1, fCommonHistList);
2134     return;
2135   }
2136
2137   // accepts only events that have same "primary" and SPD vertex, special issue of LHC11h PbPb data
2138
2139   //fAOD: pointer to global primary vertex
2140
2141   const AliAODVertex* spdVtx = fAOD->GetPrimaryVertexSPD();
2142
2143   if (TMath::Abs(spdVtx->GetZ() - primVtx->GetZ())>fDeltaVertexZ) { if (fDebug > 1) Printf("deltaZVertex: event REJECTED..."); return;}
2144
2145
2146   //check for vertex radius to be smaller than 1 cm, (that was first applied by Vit Kucera in his analysis)
2147
2148   Double_t vtxX = primVtx->GetX();
2149   Double_t vtxY = primVtx->GetY();
2150
2151   if(TMath::Sqrt(vtxX*vtxX + vtxY*vtxY)>=1){
2152     if (fDebug > 1) Printf("%s:%d primary vertex r = %f: event REJECTED...",(char*)__FILE__,__LINE__,TMath::Sqrt(vtxX*vtxX + vtxY*vtxY));
2153     return;
2154   }
2155
2156
2157   TString primVtxName(primVtx->GetName());
2158
2159   if(primVtxName.CompareTo("TPCVertex",TString::kIgnoreCase) == 1){
2160     if (fDebug > 1) Printf("%s:%d primary vertex selection: TPC vertex, event REJECTED...",(char*)__FILE__,__LINE__);
2161     fh1EvtSelection->Fill(5.);
2162     PostData(1, fCommonHistList);
2163     return;
2164   }
2165
2166   Bool_t selectedHelper = AliAnalysisHelperJetTasks::Selected();
2167   if(!selectedHelper){
2168     fh1EvtSelection->Fill(6.);
2169     PostData(1, fCommonHistList);
2170     return;
2171   }
2172
2173   // event selection  *****************************************
2174
2175   Double_t centPercent = -1;
2176   Int_t cl = 0;
2177   if(fEventClass>0){
2178
2179     if(handler && handler->InheritsFrom("AliAODInputHandler")){
2180
2181       centPercent = fAOD->GetHeader()->GetCentrality();
2182       cl = 1;
2183       //std::cout<<"centPercent: "<<centPercent<<std::endl;
2184
2185       fh1EvtAllCent->Fill(centPercent);
2186       /*
2187       if(centPercent>10) cl = 2; //standard PWG-JE binning
2188       if(centPercent>30) cl = 3;
2189       if(centPercent>50) cl = 4;
2190       */
2191
2192
2193       if(centPercent < 0) cl = -1;
2194       if(centPercent >= 0)  cl = 1;
2195       if(centPercent > 10) cl = 2; //standard PWG-JE binning
2196       if(centPercent > 30) cl = 3;
2197       if(centPercent > 50) cl = 4;
2198       if(centPercent > 80) cl = 5; //takes centralities higher than my upper edge of 80%, not to be used
2199
2200     }
2201     else {
2202
2203       cl = AliAnalysisHelperJetTasks::EventClass();
2204
2205       if(fESD) centPercent = fESD->GetCentrality()->GetCentralityPercentile("V0M"); //ESD JetServices Task has the centrality binning 0-10,10-30,30-50,50-80
2206       fh1EvtAllCent->Fill(centPercent);
2207     }
2208
2209     if(cl!=fEventClass){ // event not in selected event class, reject event#########################################
2210
2211       if (fDebug > 1) Printf("%s:%d event not in selected event class: event REJECTED ...",(char*)__FILE__,__LINE__);
2212       fh1EvtSelection->Fill(2.);
2213       PostData(1, fCommonHistList);
2214       return;
2215     }
2216   }//end if fEventClass > 0
2217
2218
2219   if (fDebug > 1) Printf("%s:%d event ACCEPTED ...",(char*)__FILE__,__LINE__);
2220
2221   //test test
2222   //Printf("Analysis event #%5d", (Int_t) fEntry);
2223
2224   fh1EvtSelection->Fill(0.);
2225   fh1EvtCent->Fill(centPercent);
2226
2227   //___ get MC information __________________________________________________________________
2228
2229
2230   Double_t ptHard = 0.; //parton energy bins -> energy of particle
2231   Double_t nTrials = 1; // trials for MC trigger weight for real data
2232
2233   if(fMCEvent){
2234      AliGenEventHeader* genHeader = fMCEvent->GenEventHeader();
2235      AliGenPythiaEventHeader*  pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);//check usage of Pythia (pp) or Hijing (PbPb)
2236      AliGenHijingEventHeader*  hijingGenHeader = 0x0;
2237
2238      if(pythiaGenHeader){
2239        if(fDebug>3) Printf("%s:%d pythiaGenHeader found", (char*)__FILE__,__LINE__);
2240        nTrials = pythiaGenHeader->Trials();
2241        ptHard  = pythiaGenHeader->GetPtHard();
2242
2243        fh1PtHard->Fill(ptHard);
2244        fh1PtHardTrials->Fill(ptHard,nTrials);
2245
2246
2247      } else { // no pythia, hijing?
2248
2249        if(fDebug>3) Printf("%s:%d no pythiaGenHeader found", (char*)__FILE__,__LINE__);
2250
2251        hijingGenHeader = dynamic_cast<AliGenHijingEventHeader*>(genHeader);
2252        if(!hijingGenHeader){
2253          if(fDebug>3) Printf("%s:%d no pythiaGenHeader or hjingGenHeader found", (char*)__FILE__,__LINE__);
2254        } else {
2255          if(fDebug>3) Printf("%s:%d hijingGenHeader found", (char*)__FILE__,__LINE__);
2256        }
2257      }
2258
2259      fh1Trials->Fill("#sum{ntrials}",fAvgTrials);
2260   }
2261
2262     //____ fetch jets _______________________________________________________________
2263
2264   Int_t nJCuts = GetListOfJets(fJetsRecCuts, kJetsRecAcceptance);//fetch list with jets that survived all jet cuts: fJetsRecCuts
2265
2266   Int_t nRecJetsCuts = 0;                                        //number of reconstructed jets after jet cuts
2267   if(nJCuts>=0) nRecJetsCuts = fJetsRecCuts->GetEntries();
2268   if(fDebug>2)Printf("%s:%d Selected Rec jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2269   if(nRecJetsCuts != nJCuts) Printf("%s:%d Mismatch selected Rec jets after cuts: %d %d",(char*)__FILE__,__LINE__,nJCuts,nRecJetsCuts);
2270   fh1nRecJetsCuts->Fill(nRecJetsCuts);
2271
2272
2273   //____ fetch background clusters ___________________________________________________
2274   if(fBranchRecBckgClusters.Length() != 0){
2275
2276     Int_t nBJ = GetListOfBckgJets(fBckgJetsRec, kJetsRec);
2277     Int_t nRecBckgJets = 0;
2278     if(nBJ>=0) nRecBckgJets = fBckgJetsRec->GetEntries();
2279     if(fDebug>2)Printf("%s:%d Selected Rec background jets: %d %d",(char*)__FILE__,__LINE__,nBJ,nRecBckgJets);
2280     if(nBJ != nRecBckgJets) Printf("%s:%d Mismatch Selected Rec background jets: %d %d",(char*)__FILE__,__LINE__,nBJ,nRecBckgJets);
2281   }
2282
2283
2284   //____ fetch reconstructed particles __________________________________________________________
2285
2286   Int_t nTCuts = GetListOfTracks(fTracksRecCuts, kTrackAODCuts);//all tracks of event
2287   if(fDebug>2)Printf("%s:%d selected reconstructed tracks after cuts: %d %d",(char*)__FILE__,__LINE__,nTCuts,fTracksRecCuts->GetEntries());
2288   if(fTracksRecCuts->GetEntries() != nTCuts)
2289     Printf("%s:%d Mismatch selected reconstructed tracks after cuts: %d %d",(char*)__FILE__,__LINE__,nTCuts,fTracksRecCuts->GetEntries());
2290   fh1EvtMult->Fill(fTracksRecCuts->GetEntries());
2291
2292   Int_t nK0s = GetListOfV0s(fListK0s,fK0Type,kK0,myPrimaryVertex,fAOD);//all V0s in event with K0s assumption
2293
2294   if(fDebug>5){std::cout<<"fK0Type: "<<fK0Type<<" kK0: "<<kK0<<" myPrimaryVertex: "<<myPrimaryVertex<<" fAOD:  "<<fAOD<<std::endl;}
2295
2296   //std::cout<< "nK0s: "<<nK0s<<std::endl;
2297
2298   if(fDebug>2)Printf("%s:%d Selected V0s after cuts: %d %d",(char*)__FILE__,__LINE__,nK0s,fListK0s->GetEntries());
2299   if(nK0s != fListK0s->GetEntries()) Printf("%s:%d Mismatch selected K0s: %d %d",(char*)__FILE__,__LINE__,nK0s,fListK0s->GetEntries());
2300   fh1K0Mult->Fill(fListK0s->GetEntries());
2301
2302
2303   Int_t nLa = GetListOfV0s(fListLa,fLaType,kLambda,myPrimaryVertex,fAOD);//all V0s in event with Lambda particle assumption
2304   if(fDebug>2)Printf("%s:%d Selected Rec tracks after cuts: %d %d",(char*)__FILE__,__LINE__,nLa,fListLa->GetEntries());
2305   if(nLa != fListLa->GetEntries()) Printf("%s:%d Mismatch selected La: %d %d",(char*)__FILE__,__LINE__,nLa,fListLa->GetEntries());
2306   fh1LaMult->Fill(fListLa->GetEntries());
2307
2308   Int_t nALa = GetListOfV0s(fListALa,fALaType,kAntiLambda,myPrimaryVertex,fAOD);//all V0s in event with Antilambda particle assumption
2309   if(fDebug>2)Printf("%s:%d Selected Rec tracks after cuts: %d %d",(char*)__FILE__,__LINE__,nALa,fListALa->GetEntries());
2310   if(nALa != fListALa->GetEntries()) Printf("%s:%d Mismatch selected ALa: %d %d",(char*)__FILE__,__LINE__,nALa,fListALa->GetEntries());
2311   fh1ALaMult->Fill(fListALa->GetEntries());
2312
2313
2314
2315   //fetch MC gen particles_______________________________________________________
2316
2317   if(fAnalysisMC){ // here
2318
2319     //fill feeddown histo for associated particles
2320
2321     // Access MC generated particles, fill TLists and histograms :
2322
2323     Int_t nMCgenK0s = GetListOfMCParticles(fListMCgenK0s,kK0,fAOD); //fill TList with MC generated primary true K0s (list to fill, particletype, mc aod event)
2324     if(nMCgenK0s != fListMCgenK0s->GetEntries()) Printf("%s:%d Mismatch selected MCgenK0s: %d %d",(char*)__FILE__,__LINE__,nMCgenK0s,fListMCgenK0s->GetEntries());
2325
2326
2327     for(Int_t it=0; it<fListMCgenK0s->GetSize(); ++it){ // loop MC generated K0s, filling histograms
2328
2329       AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenK0s->At(it));
2330       if(!mcp0) continue;
2331
2332       //MC gen K0s
2333
2334       //Double_t fRapCurrentPart   = MyRapidity(mcp0->E(),mcp0->Pz());
2335       Double_t fEtaCurrentPart   = mcp0->Eta();
2336       Double_t fPtCurrentPart    = mcp0->Pt();
2337
2338       fh1MCEtaK0s->Fill(fEtaCurrentPart);
2339       //fh1MCRapK0s->Fill(fRapCurrentPart);
2340       fh1MCPtK0s->Fill(fPtCurrentPart);
2341
2342       fh2MCEtaVsPtK0s->Fill(fPtCurrentPart,fEtaCurrentPart);                  //eta cut, physical primary selection and decay mode considered
2343
2344     }//end of the loop
2345
2346     Int_t nMCgenLa = GetListOfMCParticles(fListMCgenLa,kLambda,fAOD); //fill TList with MC generated primary true Lambdas (list to fill, particletype, mc aod event)
2347     if(nMCgenLa != fListMCgenLa->GetEntries()) Printf("%s:%d Mismatch selected MCgenLa: %d %d",(char*)__FILE__,__LINE__,nMCgenLa,fListMCgenLa->GetEntries());
2348
2349     TList *mclist = fAOD->GetList();
2350     TClonesArray *stackMC = 0x0;
2351     stackMC = (TClonesArray*)mclist->FindObject(AliAODMCParticle::StdBranchName());
2352     if (!stackMC) {
2353       Printf("ERROR: AliAnalysisTaskJetChem.cxx: loop over MC gen. particles: stackMC not available!");
2354     }
2355
2356     AliAODMCHeader *mcHdr=(AliAODMCHeader*)mclist->FindObject(AliAODMCHeader::StdBranchName());
2357     if(!mcHdr)Printf("ERROR: AliAnalysisTaskJetChem.cxx: loop over MC gen. particles: mcHdr not available!");
2358
2359     for(Int_t it=0; it<fListMCgenLa->GetSize(); ++it){ // loop MC generated La, filling histograms
2360
2361       AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenLa->At(it));
2362       if(!mcp0) continue;
2363
2364       //MC gen Lambdas
2365
2366       //Double_t fRapCurrentPart   = MyRapidity(mcp0->E(),mcp0->Pz());
2367       Double_t fEtaCurrentPart   = mcp0->Eta();
2368       Double_t fPtCurrentPart    = mcp0->Pt();
2369       TString generatorName;
2370
2371       fh1MCEtaLambda->Fill(fEtaCurrentPart);
2372       //fh1MCRapLambda->Fill(fRapCurrentPart);
2373       fh1MCPtLambda->Fill(fPtCurrentPart);
2374       fh2MCEtaVsPtLa->Fill(fPtCurrentPart,fEtaCurrentPart);                  //eta cut, physical primary selection and decay mode considered
2375
2376       Int_t mcp0label = mcp0->GetLabel();
2377       Bool_t istrackInject = IsTrackInjected(mcp0label, mcHdr, stackMC, generatorName);
2378
2379       //std::cout<<"generatorName: "<<generatorName<<std::endl;
2380
2381
2382       if(generatorName == "Hijing"){
2383         fh2MCEtaVsPtHijingLa->Fill(fPtCurrentPart,fEtaCurrentPart);
2384       }
2385
2386       if(istrackInject == kTRUE){
2387         fh2MCEtaVsPtHijingLa->Fill(fPtCurrentPart,fEtaCurrentPart);
2388       }
2389
2390     }//end of the loop
2391
2392
2393     Int_t nMCgenALa = GetListOfMCParticles(fListMCgenALa,kAntiLambda,fAOD); //fill TList with MC generated primary true Antilambdas (list to fill, particletype, mc aod event)
2394     if(nMCgenALa != fListMCgenALa->GetEntries()) Printf("%s:%d Mismatch selected MCgenALa: %d %d",(char*)__FILE__,__LINE__,nMCgenALa,fListMCgenALa->GetEntries());
2395
2396
2397     for(Int_t it=0; it<fListMCgenALa->GetSize(); ++it){ // loop MC generated ALa, filling histograms
2398
2399       AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenALa->At(it));
2400       if(!mcp0) continue;
2401
2402       //MC gen Antilambdas
2403
2404       //Double_t fRapCurrentPart   = MyRapidity(mcp0->E(),mcp0->Pz());
2405       Double_t fEtaCurrentPart   = mcp0->Eta();
2406       Double_t fPtCurrentPart    = mcp0->Pt();
2407
2408       fh1MCEtaAntiLambda->Fill(fEtaCurrentPart);
2409       //fh1MCRapAntiLambda->Fill(fRapCurrentPart);
2410       fh1MCPtAntiLambda->Fill(fPtCurrentPart);
2411       fh2MCEtaVsPtALa->Fill(fPtCurrentPart,fEtaCurrentPart);                  //eta cut, physical primary selection and decay mode considered
2412
2413     }//end of the loop
2414
2415
2416
2417   //loop over MC feeddown candidates in TList
2418
2419     //....
2420
2421
2422   } //end MCAnalysis part for gen particles
2423
2424
2425   // ___ V0 QA + K0s + La + ALa pt spectra all events _______________________________________________
2426
2427   Double_t lPrimaryVtxPosition[3];
2428   Double_t lV0Position[3];
2429   lPrimaryVtxPosition[0] = primVtx->GetX();
2430   lPrimaryVtxPosition[1] = primVtx->GetY();
2431   lPrimaryVtxPosition[2] = primVtx->GetZ();
2432   Double_t dRadiusExcludeCone = 2*GetFFRadius(); //2 times jet radius
2433   //------------------------------------------
2434  for(Int_t it=0; it<fListK0s->GetSize(); ++it){
2435
2436     AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListK0s->At(it));
2437     if(!v0) continue;
2438
2439     // VO's main characteristics to check the reconstruction cuts
2440
2441     //Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2442     Double_t invMK0s=0;
2443     Double_t trackPt=0;
2444     Double_t fV0Radius      = -999;
2445     Double_t fDcaV0Daughters = v0->DcaV0Daughters();
2446     Double_t fDcaPosToPrimVertex = v0->DcaPosToPrimVertex();//IP of positive charged daughter
2447     Double_t fDcaNegToPrimVertex = v0->DcaNegToPrimVertex();//IP of negative charged daughter
2448     Int_t negDaughterpdg = 0;
2449     Int_t posDaughterpdg = 0;
2450     Int_t motherType = 0;
2451     Int_t v0Label = -1;
2452     Double_t MCPt = 0;
2453     Bool_t fPhysicalPrimary = kFALSE;//don't use IsPhysicalPrimary() anymore for MC analysis, use instead 2D distance from primary to secondary vertex
2454     Int_t MCv0PdgCode = 0;
2455
2456     AliAODTrack *trackPos = (AliAODTrack *) (v0->GetSecondaryVtx()->GetDaughter(0));
2457     AliAODTrack *trackNeg = (AliAODTrack *) (v0->GetSecondaryVtx()->GetDaughter(1));
2458
2459     Double_t PosEta = trackPos->AliAODTrack::Eta();//daughter track charge is sometimes wrong here, account for that!!!
2460     Double_t NegEta = trackNeg->AliAODTrack::Eta();
2461
2462     //Double_t trackPosNcls = trackPos->GetTPCNcls();//Get number of clusters for positive charged tracks
2463     //Double_t trackNegNcls = trackNeg->GetTPCNcls();//Get number of clusters for negative charged tracks
2464
2465     CalculateInvMass(v0, kK0, invMK0s, trackPt);  //function to calculate invMass with TLorentzVector class
2466
2467
2468     //OUTSIDE CONES:########
2469
2470     Double_t fEta = v0->PseudoRapV0();
2471     Bool_t bIsInCone = kFALSE;//init boolean, is not in any cone (OC)
2472     Int_t nRemainingJets = nRecJetsCuts; //init value    Int_t nRemainingJets = nRecJetsCuts; //init value
2473
2474     for(Int_t ij=0; ij<nRecJetsCuts; ++ij){ // loop over all jets in event
2475
2476       AliAODJet* jet = (AliAODJet*) (fJetsRecCuts->At(ij));
2477       jettracklist->Clear();
2478       Double_t sumPt      = 0.;
2479       Bool_t isBadJet     = kFALSE;
2480
2481       if(GetFFRadius()<=0){
2482         GetJetTracksTrackrefs(jettracklist, jet, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);// list of jet tracks from trackrefs
2483       } else {
2484         GetJetTracksPointing(fTracksRecCuts, jettracklist, jet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);  // fill list of tracks in cone around jet axis with cone Radius (= 0.4 standard)
2485       }
2486
2487       //leading track pt bias on jets inside this small jet loop
2488       //APPLICATION OF REMAINING JET CUTS (leading track pt bias etc..):
2489       if(isBadJet){
2490         nRemainingJets = nRemainingJets-1;//remove one jet from nRemainingJets (was initialized with nRecJetsCuts) continue;//all bad jets are rejected
2491         continue;
2492       }
2493
2494       //if jet is selected, then check whether V0 is part of the jet cone:
2495       if(IsParticleInCone(jet, v0, dRadiusExcludeCone) == kTRUE) {bIsInCone = kTRUE;}
2496
2497       jettracklist->Clear();
2498     }
2499
2500     if((bIsInCone==kFALSE)&&(nRemainingJets > 0)){//K0s is not part of any selected jet in event, but its a jet event
2501       Double_t vK0sOC[3] = {invMK0s,trackPt,fEta};
2502       fhnK0sOC->Fill(vK0sOC);
2503     }
2504
2505     //end of outside cone K0s
2506
2507     Double_t fV0cosPointAngle = v0->CosPointingAngle(lPrimaryVtxPosition);
2508
2509     lV0Position[0]= v0->DecayVertexV0X();
2510     lV0Position[1]= v0->DecayVertexV0Y();
2511     lV0Position[2]= v0->DecayVertexV0Z();
2512
2513     Double_t fV0DecayLength = v0->DecayLengthV0(lPrimaryVtxPosition);
2514     fV0Radius  = TMath::Sqrt(lV0Position[0]*lV0Position[0]+lV0Position[1]*lV0Position[1]);
2515
2516
2517     fV0QAK0->FillTrackQA(v0->Eta(), TVector2::Phi_0_2pi(v0->Phi()), v0->Pt());
2518     //fFFHistosIMK0AllEvt->FillFF(trackPt, invMK0s, jetPt, incrementJetPt);
2519     //fh1trackPosNCls->Fill(trackPosNcls);
2520     //fh1trackNegNCls->Fill(trackNegNcls);
2521     fh1EtaK0s->Fill(fEta);
2522
2523     Double_t vK0sIncl[3] = {invMK0s,trackPt,fEta}; //fill all K0s in event into THnSparse of 3 dimensions
2524     fhnK0sIncl->Fill(vK0sIncl);
2525
2526
2527     if(fAnalysisMC){
2528       TString generatorName;
2529       Bool_t isinjected;
2530       TList *listmc = fAOD->GetList();
2531       Bool_t mclabelcheck = MCLabelCheck(v0, kK0, trackNeg, trackPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PdgCode, generatorName, isinjected);
2532       //if(fPhysicalPrimary == kFALSE)continue;
2533       //std::cout<<"mclabelcheck: "<<mclabelcheck<<std::endl;
2534       //std::cout<<"IsPhysicalPrimary: "<<fPhysicalPrimary<<std::endl;
2535
2536       if(mclabelcheck == kFALSE)continue;
2537
2538       Double_t vInvMassEtaTrackPtK0s[3] = {fEta,invMK0s,trackPt};
2539       fhnInvMassEtaTrackPtK0s->Fill(vInvMassEtaTrackPtK0s);//includes also feeddown particles, mainly phi particles whose decay products are considered here as primary
2540
2541
2542       fh1PtMCK0s->Fill(MCPt);
2543     }
2544
2545
2546     fh1V0Eta->Fill(fEta);
2547     //fh1V0totMom->Fill(fV0TotalMomentum);
2548     fh1CosPointAngle->Fill(fV0cosPointAngle);
2549     fh1DecayLengthV0->Fill(fV0DecayLength);
2550     fh1V0Radius->Fill(fV0Radius);
2551     fh1DcaV0Daughters->Fill(fDcaV0Daughters);
2552     fh1DcaPosToPrimVertex->Fill(fDcaPosToPrimVertex);
2553     fh1DcaNegToPrimVertex->Fill(fDcaNegToPrimVertex);
2554     fh1trackPosEta->Fill(PosEta);
2555     fh1trackNegEta->Fill(NegEta);
2556   }
2557
2558
2559   // __La pt spectra all events _______________________________________________
2560
2561
2562   for(Int_t it=0; it<fListLa->GetSize(); ++it){ // loop all La
2563
2564     AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListLa->At(it));
2565     if(!v0) continue;
2566
2567     // VO's main characteristics to check the reconstruction cuts
2568     //  Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2569     Double_t invMLa =0;
2570     Double_t trackPt=0;
2571     Double_t fV0Radius      = -999;
2572     Double_t fDcaV0Daughters = v0->DcaV0Daughters();
2573     Double_t fDcaPosToPrimVertex = v0->DcaPosToPrimVertex();//IP of positive charged daughter
2574     Double_t fDcaNegToPrimVertex = v0->DcaNegToPrimVertex();//IP of negative charged daughter
2575     Int_t negDaughterpdg = 0;
2576     Int_t posDaughterpdg = 0;
2577     Int_t motherType = 0;
2578     Int_t v0Label = -1;
2579     Double_t MCPt = 0;
2580     Bool_t fPhysicalPrimary = kFALSE;
2581     Int_t MCv0PdgCode = 0;
2582     AliAODTrack *trackPos = (AliAODTrack *) (v0->GetSecondaryVtx()->GetDaughter(0));
2583     AliAODTrack *trackNeg = (AliAODTrack *) (v0->GetSecondaryVtx()->GetDaughter(1));
2584
2585     //Double_t trackPosNcls = trackPos->GetTPCNcls();//Get number of clusters for positive charged tracks
2586     //Double_t trackNegNcls = trackNeg->GetTPCNcls();//Get number of clusters for negative charged tracks
2587
2588     Double_t PosEta = trackPos->AliAODTrack::Eta();//daughter track charge is sometimes wrong here, account for that!!!
2589     Double_t NegEta = trackNeg->AliAODTrack::Eta();
2590
2591     Double_t fEta = v0->PseudoRapV0();
2592     Bool_t bIsInCone = kFALSE;//init boolean, is not in any cone (OC)
2593     Int_t nRemainingJets = nRecJetsCuts; //init value
2594
2595     CalculateInvMass(v0, kLambda, invMLa, trackPt);//function to calculate invMass with TLorentzVector class
2596
2597
2598     for(Int_t ij=0; ij<nRecJetsCuts; ++ij){ // loop over all jets in event
2599
2600       AliAODJet* jet = (AliAODJet*) (fJetsRecCuts->At(ij));
2601       jettracklist->Clear();
2602       Double_t sumPt      = 0.;
2603       Bool_t isBadJet     = kFALSE;
2604
2605       if(GetFFRadius()<=0){
2606         GetJetTracksTrackrefs(jettracklist, jet, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);// list of jet tracks from trackrefs
2607       } else {
2608         GetJetTracksPointing(fTracksRecCuts, jettracklist, jet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);  // fill list of tracks in cone around jet axis with cone Radius (= 0.4 standard)
2609       }
2610
2611
2612       //leading track pt bias on jets inside this small jet loop
2613
2614       if(isBadJet){
2615         nRemainingJets = nRemainingJets-1;//remove one jet from nRemainingJets (was initialized with nRecJetsCuts) continue;//all bad jets are rejected
2616         continue;
2617       }
2618
2619
2620
2621       if(IsParticleInCone(jet, v0, dRadiusExcludeCone) == kTRUE) {bIsInCone = kTRUE;}
2622
2623       jettracklist->Clear();
2624     }  //end jet loop
2625
2626     if((bIsInCone == kFALSE)&&(nRemainingJets > 0)){//success! Lambda doesn't belong to any selected jet in event
2627       Double_t vLaOC[3] = {invMLa, trackPt,fEta};
2628       fhnLaOC->Fill(vLaOC);
2629     }
2630
2631     // Double_t jetPt = fFFIMJetPtMin; // assign pro forma jet energy
2632     // Double_t fRap = v0->Y(3122);
2633
2634     Double_t fV0DecayLength = v0->DecayLengthV0(lPrimaryVtxPosition);
2635     Double_t fV0cosPointAngle = v0->CosPointingAngle(lPrimaryVtxPosition);
2636     lV0Position[0]= v0->DecayVertexV0X();
2637     lV0Position[1]= v0->DecayVertexV0Y();
2638     lV0Position[2]= v0->DecayVertexV0Z();
2639
2640     fV0Radius  = TMath::Sqrt(lV0Position[0]*lV0Position[0]+lV0Position[1]*lV0Position[1]);
2641
2642     //fFFHistosIMLaAllEvt->FillFF(trackPt, invMLa, jetPt, incrementJetPt);
2643     //fh1trackPosNCls->Fill(trackPosNcls);
2644     //fh1trackNegNCls->Fill(trackNegNcls);
2645     fh1EtaLa->Fill(fEta);
2646
2647     Double_t vLaIncl[3] = {invMLa,trackPt,fEta};
2648     fhnLaIncl->Fill(vLaIncl);
2649
2650     if(fAnalysisMC){
2651
2652       TString generatorName;
2653       Bool_t isinjected;
2654       TList* listmc = fAOD->GetList();
2655       Bool_t mclabelcheck = MCLabelCheck(v0, kLambda, trackNeg, trackPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PdgCode, generatorName, isinjected);
2656       if(mclabelcheck == kFALSE)continue;
2657       //if(fPhysicalPrimary == kFALSE)continue;
2658
2659       if(generatorName == "Hijing"){
2660         Double_t vrecMCHijingLaIncl[3] = {invMLa,trackPt,fEta};
2661         fhnrecMCHijingLaIncl->Fill(vrecMCHijingLaIncl);
2662
2663         Double_t protonPt = trackPos->Pt();
2664         fh2CorrHijingLaProton->Fill(trackPt,protonPt);
2665       }
2666
2667       if(isinjected == kTRUE){
2668         Double_t vrecMCInjectLaIncl[3] = {invMLa,trackPt,fEta};
2669         fhnrecMCInjectLaIncl->Fill(vrecMCInjectLaIncl);
2670
2671         Double_t protonPt = trackPos->Pt();
2672         fh2CorrInjectLaProton->Fill(trackPt,protonPt);
2673       }
2674
2675       Double_t vInvMassEtaTrackPtLa[3] = {fEta,invMLa,trackPt};
2676       fhnInvMassEtaTrackPtLa->Fill(vInvMassEtaTrackPtLa);//includes also feed-down particles
2677       fh1PtMCLa->Fill(MCPt);
2678
2679
2680       fh1PtMCLa->Fill(MCPt);
2681
2682
2683     }
2684     fh1V0Eta->Fill(fEta);
2685     //fh1V0totMom->Fill(fV0TotalMomentum);
2686     fh1CosPointAngle->Fill(fV0cosPointAngle);
2687     fh1DecayLengthV0->Fill(fV0DecayLength);
2688     fh1V0Radius->Fill(fV0Radius);
2689     fh1DcaV0Daughters->Fill(fDcaV0Daughters);
2690     fh1DcaPosToPrimVertex->Fill(fDcaPosToPrimVertex);
2691     fh1DcaNegToPrimVertex->Fill(fDcaNegToPrimVertex);
2692     fh1trackPosEta->Fill(PosEta);
2693     fh1trackNegEta->Fill(NegEta);
2694   }
2695
2696   // __ALa pt spectra all events _______________________________________________
2697
2698   for(Int_t it=0; it<fListALa->GetSize(); ++it){ // loop all ALa
2699
2700     AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListALa->At(it));
2701     if(!v0) continue;
2702
2703
2704     //VO's main characteristics to check the reconstruction cuts
2705     Double_t invMALa =0;
2706     Double_t trackPt=0;
2707     Double_t fV0Radius      = -999;
2708     Double_t fDcaV0Daughters = v0->DcaV0Daughters();
2709     Double_t fDcaPosToPrimVertex = v0->DcaPosToPrimVertex();//IP of positive charged daughter
2710     Double_t fDcaNegToPrimVertex = v0->DcaNegToPrimVertex();//IP of negative charged daughter
2711     Int_t negDaughterpdg = 0;
2712     Int_t posDaughterpdg = 0;
2713     Int_t motherType = 0;
2714     Int_t v0Label = -1;
2715     Double_t MCPt = 0;
2716     Bool_t fPhysicalPrimary = kFALSE;
2717     Int_t MCv0PdgCode = 0;
2718
2719     AliAODTrack *trackPos = (AliAODTrack *) (v0->GetSecondaryVtx()->GetDaughter(0));
2720     AliAODTrack *trackNeg = (AliAODTrack *) (v0->GetSecondaryVtx()->GetDaughter(1));
2721
2722     Double_t PosEta = trackPos->AliAODTrack::Eta();//daughter track charge is sometimes wrong here, account for that!!!
2723     Double_t NegEta = trackNeg->AliAODTrack::Eta();
2724
2725     Double_t fEta = v0->PseudoRapV0();
2726     Bool_t bIsInCone = kFALSE;//init boolean for OC
2727     Int_t nRemainingJets = nRecJetsCuts; //init value
2728
2729     CalculateInvMass(v0, kAntiLambda, invMALa, trackPt);  //function to calculate invMass with TLorentzVector class
2730
2731     for(Int_t ij=0; ij<nRecJetsCuts; ++ij){ // loop over all jets in event
2732
2733       AliAODJet* jet = (AliAODJet*) (fJetsRecCuts->At(ij));
2734       jettracklist->Clear();
2735       Double_t sumPt      = 0.;
2736       Bool_t isBadJet     = kFALSE;
2737
2738
2739       if(GetFFRadius()<=0){
2740         GetJetTracksTrackrefs(jettracklist, jet, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);// list of jet tracks from trackrefs
2741       } else {
2742         GetJetTracksPointing(fTracksRecCuts, jettracklist, jet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);  // fill list of tracks in cone around jet axis with cone Radius (= 0.4 standard)
2743       }
2744
2745       //leading track pt bias on jets inside this small jet loop
2746
2747       if(isBadJet){
2748         nRemainingJets = nRemainingJets-1;//remove one jet from nRemainingJets (was initialized with nRecJetsCuts) continue;//all bad jets are rejected
2749         continue;
2750       }
2751
2752
2753       if(IsParticleInCone(jet, v0, dRadiusExcludeCone) == kTRUE){
2754         bIsInCone = kTRUE;
2755       }
2756
2757       jettracklist->Clear();
2758     }
2759
2760     if((bIsInCone == kFALSE)&&(nRemainingJets > 0)){//success!
2761       Double_t vALaOC[3] = {invMALa, trackPt,fEta};
2762       fhnALaOC->Fill(vALaOC);
2763     }
2764
2765     //Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
2766     //Double_t jetPt = fFFIMJetPtMin; // assign pro forma jet energy
2767     //      Double_t fRap = v0->Y(-3122);
2768
2769
2770     Double_t fV0cosPointAngle = v0->CosPointingAngle(lPrimaryVtxPosition);
2771     lV0Position[0]= v0->DecayVertexV0X();
2772     lV0Position[1]= v0->DecayVertexV0Y();
2773     lV0Position[2]= v0->DecayVertexV0Z();
2774     Double_t fV0DecayLength = v0->DecayLengthV0(lPrimaryVtxPosition);
2775     fV0Radius  = TMath::Sqrt(lV0Position[0]*lV0Position[0]+lV0Position[1]*lV0Position[1]);
2776
2777     //fFFHistosIMALaAllEvt->FillFF(trackPt, invMALa, jetPt, incrementJetPt);
2778     //fh1trackPosNCls->Fill(trackPosNcls);
2779     //fh1trackNegNCls->Fill(trackNegNcls);
2780     fh1EtaALa->Fill(fEta);
2781
2782     Double_t vALaIncl[3] = {invMALa,trackPt,fEta};
2783     fhnALaIncl->Fill(vALaIncl);
2784
2785     if(fAnalysisMC){
2786       TString generatorName;
2787       Bool_t isinjected;
2788       TList* listmc = fAOD->GetList();
2789       Bool_t mclabelcheck = MCLabelCheck(v0, kAntiLambda, trackNeg, trackPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PdgCode, generatorName, isinjected);
2790       if(mclabelcheck == kFALSE)continue;
2791       //if(fPhysicalPrimary == kFALSE)continue;//take also feeddown particles into account
2792
2793       if(generatorName == "Hijing"){
2794         Double_t vrecMCHijingALaIncl[3] = {invMALa,trackPt,fEta};
2795         fhnrecMCHijingALaIncl->Fill(vrecMCHijingALaIncl);
2796
2797         Double_t aprotonPt = trackNeg->Pt();
2798         fh2CorrHijingALaAProton->Fill(trackPt,aprotonPt);
2799       }
2800
2801
2802       if(isinjected == kTRUE){
2803         Double_t vrecMCInjectALaIncl[3] = {invMALa,trackPt,fEta};
2804         fhnrecMCInjectALaIncl->Fill(vrecMCInjectALaIncl);
2805
2806         Double_t aprotonPt = trackNeg->Pt();
2807         fh2CorrInjectALaAProton->Fill(trackPt,aprotonPt);
2808
2809       }
2810
2811
2812       Double_t vInvMassEtaTrackPtALa[3] = {fEta,invMALa,trackPt};
2813       fhnInvMassEtaTrackPtALa->Fill(vInvMassEtaTrackPtALa);
2814       fh1PtMCALa->Fill(MCPt);
2815
2816     }
2817     fh1V0Eta->Fill(fEta);
2818     //fh1V0totMom->Fill(fV0TotalMomentum);
2819     fh1CosPointAngle->Fill(fV0cosPointAngle);
2820     fh1DecayLengthV0->Fill(fV0DecayLength);
2821     fh1V0Radius->Fill(fV0Radius);
2822     fh1DcaV0Daughters->Fill(fDcaV0Daughters);
2823     fh1DcaPosToPrimVertex->Fill(fDcaPosToPrimVertex);
2824     fh1DcaNegToPrimVertex->Fill(fDcaNegToPrimVertex);
2825     fh1trackPosEta->Fill(PosEta);
2826     fh1trackNegEta->Fill(NegEta);
2827   }
2828
2829   //_____no jets events______________________________________________________________________________________________________________________________________
2830
2831   if(nRecJetsCuts == 0){//no jet events, before the remaining jet cuts are applied, the second part for the non-jet events comes inside the jet loop
2832
2833     fh1NJ->Fill(1.);//for normalisation by number of NJ events for events in which no rec. jets are found right from the beginning and before even the leading track bias is applied
2834
2835     if(fDebug>6) { std::cout<<"################## nRecJetsCuts == 0 ###################"<<std::endl;
2836       //std::cout<<"fListK0s->GetSize() in NJ event: "<<fListK0s->GetSize()<<std::endl;
2837     }
2838
2839     for(Int_t it=0; it<fListK0s->GetSize(); ++it){ // loop all K0s
2840
2841       AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListK0s->At(it));
2842       if(!v0) continue;
2843
2844       Double_t invMK0s =0;
2845       Double_t trackPt=0;
2846       CalculateInvMass(v0, kK0, invMK0s, trackPt);
2847       Double_t fEta = v0->Eta();
2848
2849       Double_t vNJK0[3] = {invMK0s,trackPt,fEta}; //fill all K0s in events wo selected jets
2850       fhnNJK0->Fill(vNJK0);
2851
2852     }
2853
2854     for(Int_t it=0; it<fListLa->GetSize(); ++it){ // loop all La
2855
2856       AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListLa->At(it));
2857       if(!v0) continue;
2858
2859       Double_t invMLa =0;
2860       Double_t trackPt=0;
2861       CalculateInvMass(v0, kLambda, invMLa, trackPt);
2862       Double_t fEta = v0->Eta();
2863
2864       Double_t vNJLa[3] = {invMLa,trackPt,fEta}; //fill all K0s in events wo selected jets
2865       fhnNJLa->Fill(vNJLa);
2866
2867     }
2868
2869     for(Int_t it=0; it<fListALa->GetSize(); ++it){ // loop all ALa
2870
2871       AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListALa->At(it));
2872       if(!v0) continue;
2873
2874       Double_t invMALa =0;
2875       Double_t trackPt=0;
2876       CalculateInvMass(v0, kAntiLambda, invMALa, trackPt);
2877
2878       Double_t fEta = v0->Eta();
2879
2880       Double_t vNJALa[3] = {invMALa,trackPt,fEta}; //fill all K0s in events wo selected jets
2881       fhnNJALa->Fill(vNJALa);
2882
2883
2884     }
2885
2886   }//no jet events
2887
2888   //____ fill all jet related histos  ________________________________________________________________________________________________________________________
2889   //##########################jet loop########################################################################################################################
2890
2891   Int_t nSelJets = nRecJetsCuts; //init value
2892   Bool_t IsOCEvt = kFALSE; //init for this outside cones normalisation histo (total number of OC events)
2893   Bool_t IsRCEvt = kFALSE; //init for that the random cone is placed only once per event
2894   Bool_t IsMCCEvt = kFALSE; //init for that the median cluster cone is placed only once per event
2895
2896   //fill jet histos in general
2897   for(Int_t ij=0; ij<nRecJetsCuts; ++ij){                               // ij is an index running over the list of the reconstructed jets after most of the cuts, but not yet the leading track bias, all jets in event are looped
2898
2899     AliAODJet* jet = (AliAODJet*) (fJetsRecCuts->At(ij));
2900
2901     Double_t jetPt  = jet->Pt();
2902     Double_t jetEta = jet->Eta();
2903     Double_t jetPhi = jet->Phi();
2904
2905     //if(ij==0){ // loop over leading jets for ij = 0, for ij>= 0 look into all jets
2906
2907     if(ij>=0){//all jets in event
2908
2909       jettracklist->Clear();
2910       Double_t sumPt      = 0.;
2911       Bool_t isBadJet     = kFALSE;
2912       Int_t njetTracks    = 0;
2913
2914       if(GetFFRadius()<=0){
2915         GetJetTracksTrackrefs(jettracklist, jet, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);// list of jet tracks from trackrefs
2916       } else {
2917         GetJetTracksPointing(fTracksRecCuts, jettracklist, jet, GetFFRadius(), sumPt, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJet);  // fill list of charged hybrid tracks in cone around jet axis with cone Radius (= 0.4 standard), application of leading track cut
2918       }
2919
2920       //not applied at the moment:
2921       if(GetFFMinNTracks()>0 && jettracklist->GetSize() <= GetFFMinNTracks()) isBadJet = kTRUE; // reject jets with less tracks than fFFMinNTracks
2922
2923       //APPLICATION OF REMAINING JET CUTS (leading track pt bias etc..) + NJ events
2924       if(isBadJet) {
2925
2926         nSelJets = nSelJets-1;//remove one jet from nSelJets (was initialized with nRecJetsCuts)
2927
2928         if(nSelJets == 0){//case that event doesn't contain no selected jets at all and there are no jets remaining to be looped over
2929
2930           fh1NJ->Fill(1.);//for normalisation by number of NJ events
2931
2932           for(Int_t it=0; it<fListK0s->GetSize(); ++it){ // loop all K0s
2933
2934             AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListK0s->At(it));
2935             if(!v0) continue;
2936
2937             Double_t invMK0s =0;
2938             Double_t trackPt=0;
2939             CalculateInvMass(v0, kK0, invMK0s, trackPt);
2940             Double_t fEta = v0->Eta();
2941
2942             Double_t vNJK0[3] = {invMK0s,trackPt,fEta}; //fill all K0s in events wo selected jets
2943             fhnNJK0->Fill(vNJK0);
2944
2945           }
2946
2947           for(Int_t it=0; it<fListLa->GetSize(); ++it){ // loop all La
2948
2949             AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListLa->At(it));
2950             if(!v0) continue;
2951
2952             Double_t invMLa =0;
2953             Double_t trackPt=0;
2954             CalculateInvMass(v0, kLambda, invMLa, trackPt);
2955             Double_t fEta = v0->Eta();
2956
2957             Double_t vNJLa[3] = {invMLa,trackPt,fEta}; //fill all K0s in events wo selected jets
2958             fhnNJLa->Fill(vNJLa);
2959
2960           }
2961
2962           for(Int_t it=0; it<fListALa->GetSize(); ++it){ // loop all ALa
2963
2964             AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListALa->At(it));
2965             if(!v0) continue;
2966
2967             Double_t invMALa =0;
2968             Double_t trackPt=0;
2969             CalculateInvMass(v0, kAntiLambda, invMALa, trackPt);
2970
2971             Double_t fEta = v0->Eta();
2972
2973             Double_t vNJALa[3] = {invMALa,trackPt,fEta}; //fill all K0s in events wo selected jets
2974             fhnNJALa->Fill(vNJALa);
2975
2976
2977           }
2978
2979         }
2980         continue;//rejection of current jet
2981       } // rejects jets in which no track has a track pt higher than 5 GeV/c (see AddTask macro)
2982
2983       if(IsOCEvt == kFALSE){IsOCEvt = kTRUE;fh1OC->Fill(1.);}//the first found jet triggers an OC event and is filled only once into normalisation histo
2984
2985       //Float_t fJetAreaMin = 0.6*TMath::Pi()*GetFFRadius()*GetFFRadius(); // minimum jet area cut, already applied in JetListOfJets() in FF Task
2986
2987       //if(fDebug > 2)  {if (jet->EffectiveAreaCharged() < fJetAreaMin) {std::cout<<" fCutjetArea cut removed a jet!!!!! Should not have to be done again!!"<<std::endl;}}// cut on jet area, already done by jet selection in FF task
2988
2989       Double_t dAreaExcluded = TMath::Pi()*dRadiusExcludeCone*dRadiusExcludeCone; // area of the cone
2990       dAreaExcluded -= AreaCircSegment(dRadiusExcludeCone,fCutjetEta-jet->Eta()); // positive eta overhang
2991       dAreaExcluded -= AreaCircSegment(dRadiusExcludeCone,fCutjetEta+jet->Eta()); // negative eta overhang
2992       fh1AreaExcluded->Fill(dAreaExcluded);//histo contains all areas that are jet related and have to be excluded concerning OC UE pt spectrum normalisation by area
2993
2994       fh1JetEta->Fill(jetEta);
2995       fh1JetPhi->Fill(jetPhi);
2996       fh2JetEtaPhi->Fill(jetEta,jetPhi);
2997
2998       // printf("pT = %f, eta = %f, phi = %f, leadtr pt = %f\n, ",jetPt,jetEta,jetphi,leadtrack);
2999
3000       for(Int_t it=0; it<jettracklist->GetSize(); ++it){//loop over all particles in jet
3001
3002         AliVParticle* trackVP = dynamic_cast<AliVParticle*>(jettracklist->At(it));//all tracks in jet cone
3003         if(!trackVP)continue;
3004
3005         Float_t trackPt = trackVP->Pt();//transversal momentum of jet particle
3006         Float_t trackEta = trackVP->Eta();
3007
3008         Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
3009
3010         fFFHistosRecCuts->FillFF(trackPt, jetPt, incrementJetPt);//histo with tracks/jets after cut selection, for all events
3011         if(nK0s>0) fFFHistosRecCutsK0Evt->FillFF(trackPt, jetPt, incrementJetPt);//only for K0s events
3012         fh2FFJetTrackEta->Fill(trackEta,jetPt);
3013
3014
3015       }
3016
3017       njetTracks = jettracklist->GetSize();
3018
3019       //____________________________________________________________________________________________________________________
3020       //strangeness constribution to jet cone
3021       /*
3022       if(fAnalysisMC){
3023
3024         TList *list = fAOD->GetList();
3025         AliAODMCHeader *mcHeadr=(AliAODMCHeader*)list->FindObject(AliAODMCHeader::StdBranchName());
3026         if(!mcHeadr)continue;
3027
3028         Double_t mcXv=0., mcYv=0., mcZv=0.;//MC primary vertex position
3029
3030         mcXv=mcHeadr->GetVtxX(); mcYv=mcHeadr->GetVtxY(); mcZv=mcHeadr->GetVtxZ(); // position of the MC primary vertex
3031
3032         for(Int_t it=0; it<jettracklist->GetSize(); ++it){//loop over all tracks in the jet
3033
3034           AliVParticle* trackVP = dynamic_cast<AliVParticle*>(jettracklist->At(it));//track in jet cone
3035           if(!trackVP)continue;
3036           AliAODTrack *tr = dynamic_cast<AliAODTrack*> (trackVP);                   //fetch one jet track from the TList
3037           if(!tr)continue;
3038
3039           //get MC label information
3040           TList *mclist = fAOD->GetList();
3041
3042           //fetch the MC stack
3043           TClonesArray* stackMC = (TClonesArray*)mclist->FindObject(AliAODMCParticle::StdBranchName()); //get MCAOD branch in data
3044           if (!stackMC) {Printf("ERROR: stack not available");}
3045
3046           else {
3047
3048             Int_t trackLabel = TMath::Abs(tr->GetLabel());                       //fetch jet track label in MC stack
3049
3050             AliAODMCParticle *part = dynamic_cast<AliAODMCParticle*>(stackMC->At(trackLabel));  //fetch MC gen. particle for rec. jet track
3051
3052             if(!part)continue;  //skip non-existing objects
3053
3054
3055             //Bool_t IsPhysicalPrimary = part->IsPhysicalPrimary();//not recommended to check, better use distance between primary vertex and secondary vertex
3056
3057             Float_t fDistPrimaryMax = 0.01;
3058             // Get the distance between production point of the MC mother particle and the primary vertex
3059
3060             Double_t dx = mcXv-part->Xv();//mc primary vertex - mc gen. v0 vertex
3061             Double_t dy = mcYv-part->Yv();
3062             Double_t dz = mcZv-part->Zv();
3063
3064             Float_t fDistPrimary = TMath::Sqrt(dx*dx + dy*dy + dz*dz);
3065             Bool_t fPhysicalPrimary = (fDistPrimary < fDistPrimaryMax);
3066
3067             // std::cout<<"fDistPrimary"<<fDistPrimary<<std::endl;
3068             // std::cout<<"fPhysicalPrimary"<<fPhysicalPrimary<<std::endl;
3069
3070             if(!fPhysicalPrimary)continue;//rejects Kstar and other strong decaying particles from Secondary Contamination
3071
3072             Bool_t isFromStrange = kFALSE;// flag to check whether particle has strange mother
3073
3074             Int_t iMother = part->GetMother(); //get mother MC gen. particle label
3075
3076             if(iMother >= 0){
3077               AliAODMCParticle *partM = dynamic_cast<AliAODMCParticle*>(stackMC->At(iMother)); //fetch mother of MC gen. particle
3078               if(!partM) continue;
3079
3080               Int_t codeM =  TMath::Abs(partM->GetPdgCode());                                 //mothers pdg code
3081
3082               Int_t mfl = Int_t (codeM/ TMath::Power(10, Int_t(TMath::Log10(codeM))));        //asks for first number of mothers pdg code (strange particles always start with 3..)
3083
3084               if  (mfl == 3 && codeM != 3) isFromStrange = kTRUE;
3085             }
3086
3087             if(isFromStrange == kTRUE){
3088
3089               Double_t trackPt = part->Pt();
3090               Double_t trackEta = part->Eta();
3091               //fh3StrContinCone->Fill(jetPt, trackPt, trackEta);//MC gen. particle parameters, but rec. jet pt
3092
3093               }//isFromStrange is kTRUE
3094           } //end else
3095         }//end loop over jet tracks
3096
3097       }// end fAnalysisMC
3098       */
3099
3100       fh1TrackMultCone->Fill(njetTracks);
3101       fh2TrackMultCone->Fill(njetTracks,jetPt);
3102
3103       // ---- K0s ----
3104
3105       // fQAJetHistosRecCutsLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
3106
3107       for(Int_t it=0; it<fListK0s->GetSize(); ++it){ // loop all K0s
3108
3109         AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListK0s->At(it));
3110         if(!v0) continue;//rejection of events with no V0 vertex
3111
3112         Double_t v0Mom[3];
3113         v0->PxPyPz(v0Mom);
3114         TVector3 v0MomVect(v0Mom);
3115
3116         Double_t dPhiJetK0 = (jet->MomentumVector()->Vect()).DeltaPhi(v0MomVect);
3117         //      Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
3118
3119         //      if(incrementJetPt){fh1V0JetPt->Fill(jetPt);}
3120
3121         Double_t invMK0s =0;
3122         Double_t trackPt=0;
3123         CalculateInvMass(v0, kK0, invMK0s, trackPt);  //function to calculate invMass with TLorentzVector class
3124
3125         //      fFFHistosIMK0Jet->FillFF(trackPt, invMK0s, jetPt, incrementJetPt);
3126
3127
3128         if(dPhiJetK0<fh1dPhiJetK0->GetXaxis()->GetXmin()) dPhiJetK0 += 2*TMath::Pi();
3129         fh1dPhiJetK0->Fill(dPhiJetK0);
3130
3131       }
3132
3133       // if(fListK0s->GetSize() == 0){ // no K0: increment jet pt spectrum
3134
3135       //        Bool_t incrementJetPt = kTRUE;
3136         //      fFFHistosIMK0Jet->FillFF(-1, -1, jetPt, incrementJetPt);
3137       //  }
3138
3139       //____fetch reconstructed K0s in cone around jet axis:_______________________________________________________________________________
3140
3141       jetConeK0list->Clear();
3142
3143       Double_t sumPtK0     = 0.;
3144
3145       Bool_t isBadJetK0    = kFALSE; // dummy, do not use
3146
3147       GetTracksInCone(fListK0s, jetConeK0list, jet, GetFFRadius(), sumPtK0, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetK0); //reconstructed K0s in cone around jet axis
3148
3149       if(fDebug>2)Printf("%s:%d nK0s total: %d, in jet cone: %d,FFRadius %f ",(char*)__FILE__,__LINE__,nK0s,jetConeK0list->GetEntries(),GetFFRadius());
3150
3151
3152       for(Int_t it=0; it<jetConeK0list->GetSize(); ++it){ // loop for K0s in jet cone
3153
3154         AliAODv0* v0 = dynamic_cast<AliAODv0*>(jetConeK0list->At(it));
3155         if(!v0) continue;
3156
3157         Bool_t   incrementJetPt = (it==0) ? kTRUE : kFALSE;
3158         Double_t invMK0s =0;
3159         Double_t trackPt=0;
3160         Double_t fEta=0;
3161         fEta = v0->Eta();
3162
3163         CalculateInvMass(v0, kK0, invMK0s, trackPt);  //function to calculate invMass with TLorentzVector class
3164
3165
3166         if(fAnalysisMC){
3167           Double_t jetPtSmear = -1;
3168           SmearJetPt(jetPt,cl,GetFFRadius(),GetFFMinLTrackPt(),jetPtSmear);
3169           if(incrementJetPt == kTRUE){fh1IMK0ConeSmear->Fill(jetPtSmear);}                          //fill TH1F for normalization purposes
3170         }
3171
3172         if(incrementJetPt==kTRUE){
3173           fh1IMK0Cone->Fill(jetPt);}//normalisation by number of selected jets
3174
3175         //fFFHistosIMK0Cone->FillFF(trackPt, invMK0s, jetPt, incrementJetPt);
3176
3177         Double_t vK0sCone[4] = {jetPt, invMK0s,trackPt,fEta};
3178         fhnK0sCone->Fill(vK0sCone);
3179       }
3180
3181
3182       if(jetConeK0list->GetSize() == 0){ // no K0: increment jet pt spectrum
3183
3184
3185         Bool_t incrementJetPt = kTRUE;//jets without K0s will be only filled in TH1F only once, so no increment needed
3186         //fFFHistosIMK0Cone->FillFF(-1, -1, jetPt, incrementJetPt);
3187         Double_t vK0sCone[4] = {jetPt, -1, -1, -1};
3188         fhnK0sCone->Fill(vK0sCone);
3189
3190         if(incrementJetPt==kTRUE){
3191           fh1IMK0Cone->Fill(jetPt);}//normalisation by number of selected jets
3192
3193         if(fAnalysisMC){
3194           Double_t jetPtSmear = -1;
3195           SmearJetPt(jetPt,cl,GetFFRadius(),GetFFMinLTrackPt(),jetPtSmear);
3196           if(incrementJetPt == kTRUE){fh1IMK0ConeSmear->Fill(jetPtSmear);}                          //fill TH1F for normalization purposes
3197         }
3198       }
3199
3200       //Random cones________________________________________________________________________
3201
3202
3203       if(IsRCEvt == kFALSE){//fetch random cone V0s only once per event
3204
3205
3206         IsRCEvt = kTRUE;//set boolean to kTRUE once a random cone is placed per event
3207
3208         AliAODJet* jetRC = 0;
3209         jetRC = GetRandomCone(fJetsRecCuts, fCutjetEta, 2*GetFFRadius());//fetch one random cone for each event
3210
3211         fListK0sRC->Clear();//list for K0s in random cone (RC), one RC per event
3212         fListLaRC->Clear();
3213         fListALaRC->Clear();
3214
3215         Double_t sumPtK0sRC = 0;
3216         Double_t sumPtLaRC = 0;
3217         Double_t sumPtALaRC = 0;
3218         Bool_t isBadJetK0sRC = kFALSE;
3219         Bool_t isBadJetLaRC = kFALSE;
3220         Bool_t isBadJetALaRC = kFALSE;
3221
3222
3223         if(jetRC != 0) {//if random cone was selected properly and fullfilling all the requirements
3224
3225         //fetch V0s in RC:
3226           fh1RC->Fill(1.);//for normalisation purposes
3227
3228           GetTracksInCone(fListK0s, fListK0sRC, jetRC, GetFFRadius(), sumPtK0sRC, 0, 0, isBadJetK0sRC);
3229
3230           //________________fill RC with all V0s__________________
3231           for(Int_t it=0; it<fListK0sRC->GetSize(); ++it){ // loop for K0s in random cone
3232
3233             AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListK0sRC->At(it));
3234             if(!v0) continue;
3235
3236             Double_t invMK0s =0;
3237             Double_t trackPt=0;
3238             Double_t fEta=0;
3239             fEta = v0->Eta();
3240
3241             CalculateInvMass(v0, kK0, invMK0s, trackPt);  //function to calculate invMass with TLorentzVector class
3242
3243             Double_t vK0sRC[3] = {invMK0s,trackPt,fEta};
3244             fhnK0sRC->Fill(vK0sRC);
3245           }
3246
3247
3248
3249           GetTracksInCone(fListLa, fListLaRC, jetRC, GetFFRadius(), sumPtLaRC, 0, 0, isBadJetLaRC);
3250
3251           for(Int_t it=0; it<fListLaRC->GetSize(); ++it){ // loop for Lambdas in random cone
3252
3253             AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListLaRC->At(it));
3254             if(!v0) continue;
3255
3256             Double_t invMLa =0;
3257             Double_t trackPt=0;
3258             Double_t fEta=0;
3259             fEta = v0->Eta();
3260
3261             CalculateInvMass(v0, kLambda, invMLa, trackPt);  //function to calculate invMass with TLorentzVector class
3262
3263             Double_t vLaRC[3] = {invMLa,trackPt,fEta};
3264             fhnLaRC->Fill(vLaRC);
3265           }
3266
3267
3268
3269           GetTracksInCone(fListALa, fListALaRC, jetRC, GetFFRadius(), sumPtALaRC, 0, 0, isBadJetALaRC);
3270
3271           for(Int_t it=0; it<fListALaRC->GetSize(); ++it){ // loop for Lambdas in random cone
3272
3273             AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListALaRC->At(it));
3274             if(!v0) continue;
3275
3276             Double_t invMALa =0;
3277             Double_t trackPt=0;
3278             Double_t fEta=0;
3279             fEta = v0->Eta();
3280
3281             CalculateInvMass(v0, kAntiLambda, invMALa, trackPt);  //function to calculate invMass with TLorentzVector class
3282
3283             Double_t vALaRC[3] = {invMALa,trackPt,fEta};
3284             fhnALaRC->Fill(vALaRC);
3285           }
3286
3287
3288           if(isBadJetK0sRC == kFALSE){ //in case RC contains at least one K0s with minimum pT
3289             fh1RCBiasK0->Fill(1.);//for normalisation purposes
3290
3291             //________________fill RC (with trigger particle bias)_____________
3292             for(Int_t it=0; it<fListK0sRC->GetSize(); ++it){ // loop for K0s in random cone
3293
3294               AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListK0sRC->At(it));
3295               if(!v0) continue;
3296
3297               Double_t invMK0s =0;
3298               Double_t trackPt=0;
3299               Double_t fEta=0;
3300               fEta = v0->Eta();
3301
3302               CalculateInvMass(v0, kK0, invMK0s, trackPt);  //function to calculate invMass with TLorentzVector class
3303
3304               //Double_t vK0sRC[3] = {invMK0s,trackPt,fEta};
3305               //fhnK0sRCBias->Fill(vK0sRC);
3306             }
3307           }
3308
3309
3310           if(isBadJetLaRC == kFALSE){ //in case RC contains at least one Lambda with minimum pT
3311             fh1RCBiasLa->Fill(1.);//for normalisation purposes
3312             for(Int_t it=0; it<fListLaRC->GetSize(); ++it){ // loop for Lambdas in random cone
3313
3314               AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListLaRC->At(it));
3315               if(!v0) continue;
3316
3317               Double_t invMLa =0;
3318               Double_t trackPt=0;
3319               Double_t fEta=0;
3320               fEta = v0->Eta();
3321
3322               CalculateInvMass(v0, kLambda, invMLa, trackPt);  //function to calculate invMass with TLorentzVector class
3323
3324               //Double_t vLaRC[3] = {invMLa,trackPt,fEta};
3325               //fhnLaRCBias->Fill(vLaRC);
3326             }
3327           }
3328
3329
3330
3331           if(isBadJetALaRC == kFALSE){ //in case RC contains at least one Antilambda with minimum pT
3332             fh1RCBiasALa->Fill(1.);//for normalisation purposes
3333             for(Int_t it=0; it<fListALaRC->GetSize(); ++it){ // loop for Lambdas in random cone
3334
3335               AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListALaRC->At(it));
3336               if(!v0) continue;
3337
3338               Double_t invMALa =0;
3339               Double_t trackPt=0;
3340               Double_t fEta=0;
3341               fEta = v0->Eta();
3342
3343               CalculateInvMass(v0, kAntiLambda, invMALa, trackPt);  //function to calculate invMass with TLorentzVector class
3344
3345               //Double_t vALaRC[3] = {invMALa,trackPt,fEta};
3346               //fhnALaRCBias->Fill(vALaRC);
3347             }
3348
3349           }
3350
3351         }
3352
3353         fListK0sRC->Clear();
3354         fListLaRC->Clear();
3355         fListALaRC->Clear();
3356       }
3357
3358
3359       //fetch particles in perpendicular cone to estimate UE event contribution to particle spectrum
3360       //these perpendicular cone particle spectra serve to subtract the particles in jet cones, that are stemming from the Underlying event, on a statistical basis
3361       //for normalization the common jet pT spectrum is used: fh1IMK0Cone, fh1IMLaCone and fh1IMALaCone
3362
3363       //____fetch reconstructed K0s in cone perpendicular to jet axis:_______________________________________________________________________________
3364
3365
3366       jetPerpConeK0list->Clear();
3367       Double_t sumPerpPtK0     = 0.;
3368
3369       GetTracksInPerpCone(fListK0s, jetPerpConeK0list, jet, GetFFRadius(), sumPerpPtK0); //reconstructed K0s in cone around jet axis
3370
3371       if(fDebug>2)Printf("%s:%d nK0s total: %d, in perp jet cone: %d,FFRadius %f ",(char*)__FILE__,__LINE__,nK0s,jetPerpConeK0list->GetEntries(),GetFFRadius());
3372
3373       for(Int_t it=0; it<jetPerpConeK0list->GetSize(); ++it){ // loop for K0s in perpendicular cone
3374
3375         AliAODv0* v0 = dynamic_cast<AliAODv0*>(jetPerpConeK0list->At(it));
3376         if(!v0) continue;
3377
3378         Double_t invMPerpK0s =0;
3379         Double_t trackPt=0;
3380         Double_t fEta=0;
3381
3382         fEta = v0->Eta();
3383         CalculateInvMass(v0, kK0, invMPerpK0s, trackPt);  //function to calculate invMass with TLorentzVector class
3384         Double_t vK0sPC[4] = {jetPt, invMPerpK0s,trackPt,fEta};
3385
3386         fhnK0sPC->Fill(vK0sPC);  //(x,y,z) //pay attention, this histogram contains the V0 content of both (+/- 90 degrees) perp. cones!!
3387
3388       }
3389
3390
3391       if(jetPerpConeK0list->GetSize() == 0){ // no K0s in jet cone
3392
3393         Double_t vK0sPC[4] = {jetPt, -1, -1 , -999};//default values for case: no K0s is found in PC
3394         fhnK0sPC->Fill(vK0sPC);
3395
3396       }
3397
3398
3399       if(IsMCCEvt == kFALSE){//median cluster only once for event
3400
3401         IsMCCEvt = kTRUE;
3402
3403       // if(ij==0){
3404
3405         AliAODJet* medianCluster = GetMedianCluster();
3406
3407         if(medianCluster){
3408         // ____ rec K0s in median cluster___________________________________________________________________________________________________________
3409
3410
3411           jetMedianConeK0list->Clear();
3412           jetMedianConeLalist->Clear();
3413           jetMedianConeALalist->Clear();
3414
3415           Double_t medianEta = medianCluster->Eta();
3416
3417         if(TMath::Abs(medianEta)<=fCutjetEta){
3418
3419           fh1MedianEta->Fill(medianEta);
3420           fh1JetPtMedian->Fill(jetPt);
3421           fh1MCC->Fill(1.);//for normalisation by total number of median cluster jets
3422           Double_t sumMedianPtK0     = 0.;
3423
3424           Bool_t isBadJetK0Median    = kFALSE; // dummy, do not use
3425
3426           GetTracksInCone(fListK0s, jetMedianConeK0list, medianCluster, GetFFRadius(), sumMedianPtK0, 0., 0., isBadJetK0Median); //reconstructed K0s in median cone around jet axis
3427           //GetTracksInCone(fListK0s, jetConeK0list, jet, GetFFRadius(), sumPtK0, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetK0); //original use of function
3428
3429           //cut parameters from Fragmentation Function task:
3430           //Float_t fFFMinLTrackPt;   // reject jets with leading track with pt smaller than this value, use GetFFMinLTrackPt()
3431           //Float_t fFFMaxTrackPt;    // reject jetscontaining any track with pt larger than this value, use GetFFMaxTrackPt()
3432
3433           for(Int_t it=0; it<jetMedianConeK0list->GetSize(); ++it){ // loop for K0s in median cone
3434
3435             AliAODv0* v0 = dynamic_cast<AliAODv0*>(jetMedianConeK0list->At(it));
3436             if(!v0) continue;
3437
3438             Double_t invMMedianK0s =0;
3439             Double_t trackPt=0;
3440             Double_t fEta=0;
3441
3442             fEta = v0->Eta();
3443             CalculateInvMass(v0, kK0, invMMedianK0s, trackPt);  //function to calculate invMass with TLorentzVector class
3444             Double_t vK0sMCC[3] = {invMMedianK0s,trackPt,fEta};
3445             fhnK0sMCC->Fill(vK0sMCC);
3446
3447           }
3448
3449           if(jetMedianConeK0list->GetSize() == 0){ // no K0s in median cluster cone
3450
3451             Double_t vK0sMCC[3] = {-1, -1, -999};
3452             fhnK0sMCC->Fill(vK0sMCC);
3453
3454           }
3455
3456           //__________________________________________________________________________________________________________________________________________
3457           // ____ rec Lambdas in median cluster___________________________________________________________________________________________________________
3458
3459           Double_t sumMedianPtLa     = 0.;
3460           Bool_t isBadJetLaMedian    = kFALSE; // dummy, do not use
3461
3462           GetTracksInCone(fListLa, jetMedianConeLalist, medianCluster, GetFFRadius(), sumMedianPtLa, 0, 0, isBadJetLaMedian); //reconstructed Lambdas in median cone around jet axis
3463
3464           //cut parameters from Fragmentation Function task:
3465           //Float_t fFFMinLTrackPt;   // reject jets with leading track with pt smaller than this value, use GetFFMinLTrackPt()
3466           //Float_t fFFMaxTrackPt;    // reject jets containing any track with pt larger than this value, use GetFFMaxTrackPt()
3467
3468           for(Int_t it=0; it<jetMedianConeLalist->GetSize(); ++it){ // loop for Lambdas in perpendicular cone
3469
3470             AliAODv0* v0 = dynamic_cast<AliAODv0*>(jetMedianConeLalist->At(it));
3471             if(!v0) continue;
3472
3473             Double_t invMMedianLa =0;
3474             Double_t trackPt=0;
3475             Double_t fEta=0;
3476             fEta = v0->Eta();
3477
3478             CalculateInvMass(v0, kLambda, invMMedianLa, trackPt);  //function to calculate invMass with TLorentzVector class
3479
3480             Double_t vLaMCC[3] = {invMMedianLa,trackPt,fEta};
3481             fhnLaMCC->Fill(vLaMCC);
3482           }
3483
3484           if(jetMedianConeLalist->GetSize() == 0){ // no Lambdas in median cluster cone
3485
3486             Double_t vLaMCC[4] = {jetPt, -1, -1, -999};
3487             fhnLaMCC->Fill(vLaMCC);
3488
3489           }
3490
3491
3492           // ____ rec Antilambdas in median cluster___________________________________________________________________________________________________________
3493
3494
3495           Double_t sumMedianPtALa     = 0.;
3496
3497           Bool_t isBadJetALaMedian    = kFALSE; // dummy, do not use
3498
3499           GetTracksInCone(fListALa, jetMedianConeALalist, medianCluster, GetFFRadius(), sumMedianPtALa, 0, 0, isBadJetALaMedian); //reconstructed Antilambdas in median cone around jet axis
3500
3501
3502           //cut parameters from Fragmentation Function task:
3503           //Float_t fFFMinLTrackPt;   // reject jets with leading track with pt smaller than this value, use GetFFMinLTrackPt()
3504           //Float_t fFFMaxTrackPt;    // reject jets containing any track with pt larger than this value, use GetFFMaxTrackPt()
3505
3506           for(Int_t it=0; it<jetMedianConeALalist->GetSize(); ++it){ // loop for Antilambdas in median cluster cone
3507
3508             AliAODv0* v0 = dynamic_cast<AliAODv0*>(jetMedianConeALalist->At(it));
3509             if(!v0) continue;
3510
3511             Double_t invMMedianALa =0;
3512             Double_t trackPt=0;
3513             Double_t fEta=0;
3514
3515             fEta = v0->Eta();
3516
3517             CalculateInvMass(v0, kAntiLambda, invMMedianALa, trackPt);  //function to calculate invMass with TLorentzVector class
3518             Double_t vALaMCC[3] = {invMMedianALa,trackPt,fEta};
3519             fhnALaMCC->Fill(vALaMCC);
3520
3521           }
3522
3523           if(jetMedianConeALalist->GetSize() == 0){ // no Antilambdas in median cluster cone
3524
3525             Double_t vALaMCC[4] = {jetPt, -1, -1, -999};
3526             fhnALaMCC->Fill(vALaMCC);
3527
3528           }
3529         }//median cluster eta cut
3530
3531         jetMedianConeK0list->Clear();
3532         jetMedianConeLalist->Clear();
3533         jetMedianConeALalist->Clear();
3534
3535         }//if mediancluster is existing
3536       }//end (IsMCCEvt == kFALSE)
3537       //_________________________________________________________________________________________________________________________________________
3538
3539       //____fetch reconstructed Lambdas in cone perpendicular to jet axis:__________________________________________________________________________
3540
3541       jetPerpConeLalist->Clear();
3542       Double_t sumPerpPtLa     = 0.;
3543
3544       GetTracksInPerpCone(fListLa, jetPerpConeLalist, jet, GetFFRadius(), sumPerpPtLa); //reconstructed Lambdas in cone around jet axis //pay attention, this histogram contains the V0 content of both (+/- 90 degrees) perp. cones!!
3545
3546       if(fDebug>2)Printf("%s:%d nLa total: %d, in perp jet cone: %d,FFRadius %f ",(char*)__FILE__,__LINE__,nLa,jetPerpConeLalist->GetEntries(),GetFFRadius());
3547
3548       for(Int_t it=0; it<jetPerpConeLalist->GetSize(); ++it){ // loop for Lambdas in perpendicular cone
3549
3550         AliAODv0* v0 = dynamic_cast<AliAODv0*>(jetPerpConeLalist->At(it));
3551         if(!v0) continue;
3552
3553         Double_t invMPerpLa =0;
3554         Double_t trackPt=0;
3555         Double_t fEta=0;
3556         fEta = v0->Eta();
3557
3558         CalculateInvMass(v0, kLambda, invMPerpLa, trackPt);  //function to calculate invMass with TLorentzVector class
3559         Double_t vLaPC[4] = {jetPt, invMPerpLa,trackPt,fEta};
3560         fhnLaPC->Fill(vLaPC);  //(x,y,z) //pay attention, this histogram contains the V0 content of both (+/- 90 degrees) perp. cones!!
3561
3562       }
3563
3564
3565       if(jetPerpConeLalist->GetSize() == 0){ // no Lambdas in jet
3566
3567         Double_t vLaPC[4] = {jetPt, -1, -1 , -999};//default values for case: no K0s is found in PC
3568         fhnLaPC->Fill(vLaPC);
3569
3570
3571       }
3572
3573
3574       //____fetch reconstructed Antilambdas in cone perpendicular to jet axis:___________________________________________________________________
3575
3576       jetPerpConeALalist->Clear();
3577       Double_t sumPerpPtALa     = 0.;
3578
3579       GetTracksInPerpCone(fListALa, jetPerpConeALalist, jet, GetFFRadius(), sumPerpPtALa); //reconstructed Antilambdas in cone around jet axis //pay attention, this histogram contains the V0 content of both (+/- 90 degrees) perp. cones!!
3580
3581       if(fDebug>2)Printf("%s:%d nALa total: %d, in perp jet cone: %d,FFRadius %f ",(char*)__FILE__,__LINE__,nALa,jetPerpConeALalist->GetEntries(),GetFFRadius());
3582
3583       for(Int_t it=0; it<jetPerpConeALalist->GetSize(); ++it){ // loop for ALa in perpendicular cone
3584
3585         AliAODv0* v0 = dynamic_cast<AliAODv0*>(jetPerpConeALalist->At(it));
3586         if(!v0) continue;
3587
3588         Double_t invMPerpALa =0;
3589         Double_t trackPt=0;
3590         Double_t fEta=0;
3591         fEta = v0->Eta();
3592
3593         CalculateInvMass(v0, kAntiLambda, invMPerpALa, trackPt);  //function to calculate invMass with TLorentzVector class
3594         Double_t vALaPC[4] = {jetPt, invMPerpALa,trackPt,fEta};
3595         fhnALaPC->Fill(vALaPC);
3596
3597       }
3598
3599
3600       if(jetPerpConeALalist->GetSize() == 0){ // no Antilambda
3601
3602         Double_t vALaPC[4] = {jetPt, -1, -1, -999};
3603         fhnALaPC->Fill(vALaPC);
3604
3605       }
3606
3607
3608
3609       //###########################################################################################################
3610       //MC Analysis
3611       //__________________________________________________________________________________________________________________________________________
3612
3613       if(fAnalysisMC){
3614
3615         //fill feeddown candidates from TList
3616         //std::cout<<"fListFeeddownLaCand entries: "<<fListFeeddownLaCand->GetSize()<<std::endl;
3617
3618         Double_t sumPtFDLa     = 0.;
3619         Bool_t isBadJetFDLa    = kFALSE; // dummy, do not use
3620
3621         GetTracksInCone(fListFeeddownLaCand, jetConeFDLalist, jet, GetFFRadius(), sumPtFDLa, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetFDLa);
3622
3623         Double_t sumPtFDALa     = 0.;
3624         Bool_t isBadJetFDALa    = kFALSE; // dummy, do not use
3625
3626         GetTracksInCone(fListFeeddownALaCand, jetConeFDALalist, jet, GetFFRadius(), sumPtFDALa, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetFDALa);
3627
3628       //_________________________________________________________________
3629         for(Int_t it=0; it<fListFeeddownLaCand->GetSize(); ++it){
3630
3631           AliAODv0* mcfd = dynamic_cast<AliAODv0*>(fListFeeddownLaCand->At(it));
3632           if(!mcfd) continue;
3633
3634           Double_t invMLaFDcand = 0;
3635           Double_t trackPt = 0;//pt of ass. particle, not used for the histos
3636
3637           CalculateInvMass(mcfd, kLambda, invMLaFDcand, trackPt);
3638
3639           //Get MC gen. Lambda transverse momentum
3640           TClonesArray *st = 0x0;
3641
3642           if(!fAOD)continue;
3643           TList *lt = fAOD->GetList();
3644           if(!lt)continue;
3645
3646           st = (TClonesArray*)lt->FindObject(AliAODMCParticle::StdBranchName()); //get MCAOD branch in data
3647           if (!st)continue;
3648
3649           AliAODTrack *daughtertrack = (AliAODTrack *) (mcfd->GetSecondaryVtx()->GetDaughter(0));//fetch the first of the two daughter tracks
3650           Int_t AssLabel = TMath::Abs(daughtertrack->GetLabel());
3651
3652           AliAODMCParticle *mcDaughterPart =(AliAODMCParticle*)st->UncheckedAt(AssLabel);
3653
3654           Int_t v0lab = mcDaughterPart->GetMother();
3655
3656           //  Int_t v0lab= TMath::Abs(mcfd->GetLabel());//GetLabel doesn't work for AliAODv0 class!!! Only for AliAODtrack
3657
3658           if((!v0lab) || (v0lab<0) || (v0lab > st->GetEntriesFast()))continue;//validity checks
3659
3660           AliAODMCParticle *mcp=(AliAODMCParticle*)st->UncheckedAt(v0lab);
3661
3662           Double_t genLaPt = mcp->Pt();
3663
3664           //std::cout<<"Incl FD, genLaPt:"<<genLaPt<<std::endl;
3665
3666           Double_t vFeedDownLa[3] = {5., invMLaFDcand, genLaPt};
3667           fhnFeedDownLa->Fill(vFeedDownLa);
3668
3669
3670         }//end loop over feeddown candidates for Lambda particles in jet cone
3671         //fetch MC truth in jet cones, denominator of rec. efficiency in jet cones
3672         //_________________________________________________________________
3673         for(Int_t it=0; it<jetConeFDLalist->GetSize(); ++it){
3674
3675           AliAODv0* mcfd = dynamic_cast<AliAODv0*>(jetConeFDLalist->At(it));
3676           if(!mcfd) continue;
3677
3678           //std::cout<<"Cone, recLaPt:"<<mcfd->Pt()<<std::endl;
3679
3680           Double_t invMLaFDcand = 0;
3681           Double_t trackPt = mcfd->Pt();//pt of ass. particle, not used for the histos
3682
3683           CalculateInvMass(mcfd, kLambda, invMLaFDcand, trackPt);
3684
3685           //Get MC gen. Lambda transverse momentum
3686           TClonesArray *st = 0x0;
3687
3688           TList *lt = fAOD->GetList();
3689           if(!lt)continue;
3690
3691           st = (TClonesArray*)lt->FindObject(AliAODMCParticle::StdBranchName());
3692
3693           AliAODTrack *daughtertrack = (AliAODTrack *) (mcfd->GetSecondaryVtx()->GetDaughter(0));//fetch the first of the two daughter tracks
3694           Int_t AssLabel = TMath::Abs(daughtertrack->GetLabel());
3695
3696           AliAODMCParticle *mcDaughterPart =(AliAODMCParticle*)st->UncheckedAt(AssLabel);
3697
3698           Int_t v0lab = mcDaughterPart->GetMother();
3699
3700           //std::cout<<"v0lab: "<<v0lab<<std::endl;
3701
3702           if((!v0lab) || (v0lab<0) || (v0lab > st->GetEntriesFast()))continue;//validity checks
3703
3704           AliAODMCParticle *mcp=(AliAODMCParticle*)st->UncheckedAt(v0lab);
3705
3706           Double_t genLaPt = mcp->Pt();
3707
3708
3709           //std::cout<<"Cone FD, genLaPt:"<<genLaPt<<std::endl;
3710
3711           Double_t vFeedDownLaCone[3] = {jetPt, invMLaFDcand, genLaPt};
3712           fhnFeedDownLaCone->Fill(vFeedDownLaCone);
3713
3714
3715         }//end loop over feeddown candidates for Lambda particles in jet cone
3716
3717         //_________________________________________________________________
3718         for(Int_t it=0; it<fListFeeddownALaCand->GetSize(); ++it){
3719
3720           AliAODv0* mcfd = dynamic_cast<AliAODv0*>(fListFeeddownALaCand->At(it));
3721           if(!mcfd) continue;
3722
3723           Double_t invMALaFDcand = 0;
3724           Double_t trackPt = 0;//pt of ass. particle, not used for the histos
3725
3726           CalculateInvMass(mcfd, kAntiLambda, invMALaFDcand, trackPt);
3727
3728           //Get MC gen. Antilambda transverse momentum
3729           TClonesArray *st = 0x0;
3730
3731           TList *lt = fAOD->GetList();
3732           if(!lt)continue;
3733
3734           st = (TClonesArray*)lt->FindObject(AliAODMCParticle::StdBranchName());
3735
3736           AliAODTrack *daughtertrack = (AliAODTrack *) (mcfd->GetSecondaryVtx()->GetDaughter(0));//fetch the first of the two daughter tracks
3737           Int_t AssLabel = TMath::Abs(daughtertrack->GetLabel());
3738
3739           AliAODMCParticle *mcDaughterPart =(AliAODMCParticle*)st->UncheckedAt(AssLabel);
3740
3741           Int_t v0lab = mcDaughterPart->GetMother();
3742
3743
3744           if((!v0lab) || (v0lab<0) || (v0lab > st->GetEntriesFast()))continue;//validity checks
3745
3746           AliAODMCParticle *mcp=(AliAODMCParticle*)st->UncheckedAt(v0lab);
3747
3748           Double_t genALaPt = mcp->Pt();
3749
3750           Double_t vFeedDownALa[3] = {5., invMALaFDcand, genALaPt};
3751           fhnFeedDownALa->Fill(vFeedDownALa);
3752
3753
3754         }//end loop over feeddown candidates for Antilambda particles
3755
3756         //_________________________________________________________________
3757         //feeddown for Antilambdas from Xi(bar)+ and Xi(bar)0 in jet cone:
3758
3759         for(Int_t it=0; it<jetConeFDALalist->GetSize(); ++it){
3760
3761           AliAODv0* mcfd = dynamic_cast<AliAODv0*>(jetConeFDALalist->At(it));
3762           if(!mcfd) continue;
3763
3764           Double_t invMALaFDcand = 0;
3765           Double_t trackPt = 0;//pt of ass. particle, not used for the histos
3766
3767           CalculateInvMass(mcfd, kAntiLambda, invMALaFDcand, trackPt);
3768
3769           //Get MC gen. Antilambda transverse momentum
3770           TClonesArray *st = 0x0;
3771
3772           TList *lt = fAOD->GetList();
3773           if(!lt)continue;
3774
3775           st = (TClonesArray*)lt->FindObject(AliAODMCParticle::StdBranchName());
3776
3777           AliAODTrack *daughtertrack = (AliAODTrack *) (mcfd->GetSecondaryVtx()->GetDaughter(0));//fetch the first of the two daughter tracks
3778           Int_t AssLabel = TMath::Abs(daughtertrack->GetLabel());
3779
3780           AliAODMCParticle *mcDaughterPart =(AliAODMCParticle*)st->UncheckedAt(AssLabel);
3781
3782           Int_t v0lab = mcDaughterPart->GetMother();
3783
3784           if((!v0lab) || (v0lab<0) || (v0lab > st->GetEntriesFast()))continue;//validity checks
3785
3786           AliAODMCParticle *mcp=(AliAODMCParticle*)st->UncheckedAt(v0lab);
3787
3788           Double_t genALaPt = mcp->Pt();
3789
3790           Double_t vFeedDownALaCone[3] = {jetPt, invMALaFDcand, genALaPt};
3791           fhnFeedDownALaCone->Fill(vFeedDownALaCone);
3792
3793
3794         }//end loop over feeddown candidates for Antilambda particles in jet cone
3795
3796
3797
3798         //____fetch MC generated K0s in cone around jet axis__(note: particles can stem from fragmentation but also from underlying event)________
3799
3800         Double_t sumPtMCgenK0s   = 0.;
3801         Bool_t isBadJetMCgenK0s  = kFALSE; // dummy, do not use
3802
3803
3804         fListMCgenK0sCone->Clear(); //MC generated K0s in (only geometrical) jet cone (these are MC gen K0s falling geometrically into jet cone (R = 0.4) around jet axis, that was found by anti-kt jet finder, particles can stem from fragmentation but also from underlying event!!)
3805
3806         //first: sampling MC gen K0s
3807
3808         GetTracksInCone(fListMCgenK0s, fListMCgenK0sCone, jet, GetFFRadius(), sumPtMCgenK0s, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetMCgenK0s); //MC generated K0s in cone around jet axis
3809
3810         if(fDebug>2)Printf("%s:%d nMCgenK0s in jet cone: %d,FFRadius %f ",(char*)__FILE__,__LINE__,fListMCgenK0sCone->GetEntries(),GetFFRadius());
3811
3812
3813         /*      for(Int_t it=0; it<fListMCgenK0sCone->GetSize(); ++it){ // loop MC generated K0s in cone around jet axis
3814
3815           AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenK0sCone->At(it));
3816           if(!mcp0) continue;
3817
3818           //Double_t fRapMCgenK0s   = MyRapidity(mcp0->E(),mcp0->Pz());//get rec. particle in cone information
3819           Double_t fEtaMCgenK0s   = mcp0->Eta();
3820           Double_t fPtMCgenK0s    = mcp0->Pt();
3821
3822           //fh2MCgenK0Cone->Fill(jetPt,fPtMCgenK0s);
3823           // fh2MCEtagenK0Cone->Fill(jetPt,fEtaMCgenK0s);
3824
3825           }*/
3826
3827         //check whether the reconstructed K0s in jet cone are stemming from MC gen K0s (on MCgenK0s list):__________________________________________________
3828
3829         for(Int_t ic=0; ic<jetConeK0list->GetSize(); ++ic){    //loop over all reconstructed K0s in jet cone
3830
3831         //for(Int_t ic=0; ic<fListK0s->GetSize(); ++ic){     //loop over all reconstructed K0s -> previous definition of reconstruction efficiency, not sure what is the better one to choose
3832
3833           Int_t negDaughterpdg;
3834           Int_t posDaughterpdg;
3835           Int_t motherType;
3836           Int_t v0Label;
3837           Double_t fPtMCrecK0Match;
3838           Double_t invMK0Match;
3839           Double_t MCPt;
3840           Int_t nnum =-1;
3841           Int_t pnum =-1;
3842           Bool_t fPhysicalPrimary = -1;
3843           Int_t MCv0PDGCode =0;
3844           Double_t jetPtSmear = -1;
3845
3846           AliAODv0* v0c = dynamic_cast<AliAODv0*>(jetConeK0list->At(ic));//pointer to reconstructed K0s inside jet cone (cone is placed around reconstructed jet axis)
3847
3848           //AliAODv0* v0c = dynamic_cast<AliAODv0*>(fListK0s->At(ic));//pointer to reconstructed K0s
3849           if(!v0c) continue;
3850
3851           Bool_t daughtercheck = DaughterTrackCheck(v0c, nnum, pnum);//check daughter tracks have proper sign
3852           if(daughtercheck == kFALSE)continue;
3853
3854           const AliAODTrack *trackMCNeg=(AliAODTrack *)(v0c->GetDaughter(nnum));
3855           const AliAODTrack *trackMCPos=(AliAODTrack *)(v0c->GetDaughter(pnum));
3856           Bool_t isinjected;
3857           TString generatorName;
3858           TList *listmc = fAOD->GetList();
3859
3860           Bool_t mclabelcheck = MCLabelCheck(v0c, kK0, trackMCNeg, trackMCPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PDGCode, generatorName, isinjected);
3861
3862           if(mclabelcheck == kFALSE)continue;
3863           if(fPhysicalPrimary == kFALSE)continue;  //requirements for rec. V0 associated to MC true primary particle
3864
3865           for(Int_t it=0; it<fListMCgenK0s->GetSize(); ++it){                                    // loop over MC generated K0s in event, check whether associated MC particle is part of it
3866
3867           //for(Int_t it=0; it<fListMCgenK0sCone->GetSize(); ++it){//belongs to previous definition of rec. eff. of V0s within jet cone
3868
3869             //Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
3870             //AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenK0sCone->At(it));
3871             AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenK0s->At(it));
3872             if(!mcp0) continue;
3873
3874             Bool_t particleMatching = IsParticleMatching(mcp0, v0Label);
3875
3876             if(particleMatching == kFALSE)continue;                                              //if reconstructed V0 particle doesn't match to the associated MC particle go to next stack entry
3877             CalculateInvMass(v0c, kK0, invMK0Match, fPtMCrecK0Match);
3878             Double_t fEta = v0c->Eta();
3879             Double_t fPtMCgenK0s    = mcp0->Pt();//pt has to be always MC truth value!
3880
3881             Double_t vMCrecK0Cone[4] = {jetPt, invMK0Match,fPtMCgenK0s,fEta};
3882             fhnMCrecK0Cone->Fill(vMCrecK0Cone);             //fill matching rec. K0s in 3D histogram
3883
3884             SmearJetPt(jetPt,cl,GetFFRadius(),GetFFMinLTrackPt(),jetPtSmear);       //jetPt, cent, jetRadius, ptmintrack, &jetPtSmear
3885
3886             Double_t vMCrecK0ConeSmear[4] = {jetPtSmear, invMK0Match,fPtMCgenK0s,fEta};
3887             fhnMCrecK0ConeSmear->Fill(vMCrecK0ConeSmear);
3888
3889             //fill matching rec. K0s in 3D histogram, jet pT smeared according to deltaptjet distribution width
3890
3891
3892           } // end MCgenK0s / MCgenK0sCone loop
3893
3894           //___________
3895           //check the K0s daughters contamination of the jet tracks:
3896
3897           TClonesArray *stackMC = 0x0;
3898
3899           for(Int_t it=0; it<jettracklist->GetSize(); ++it){//loop over all particles in the jet
3900
3901             AliVParticle* trackVP = dynamic_cast<AliVParticle*>(jettracklist->At(it));//all tracks in jet cone
3902             if(!trackVP)continue;
3903             AliAODTrack *tr = dynamic_cast<AliAODTrack*> (trackVP);                   //fetch one jet track from the TList
3904             if(!tr)continue;
3905
3906             //get MC label information
3907             TList *mclist = fAOD->GetList();                                           //fetch the MC stack
3908             if(!mclist)continue;
3909
3910             stackMC = (TClonesArray*)mclist->FindObject(AliAODMCParticle::StdBranchName()); //get MCAOD branch in data
3911             if (!stackMC) {Printf("ERROR: stack not available");}
3912             else {
3913
3914               Int_t particleLabel = TMath::Abs(tr->GetLabel());                       //fetch jet track label in MC stack
3915               if(!tr)continue;
3916               //v0c is pointer to K0s candidate, is fetched already above, here it is just checked again whether daughters are properly ordered by their charge
3917
3918               Bool_t daughterchecks = DaughterTrackCheck(v0c, nnum, pnum);
3919
3920               if(daughterchecks == kFALSE)continue;                                   //make sure that daughters are properly ordered
3921
3922               const AliAODTrack *trackNeg=(AliAODTrack *)(v0c->GetDaughter(nnum));    //fetch v0 daughters of reconstructed K0s
3923               const AliAODTrack *trackPos=(AliAODTrack *)(v0c->GetDaughter(pnum));
3924
3925               if(!trackNeg)continue;
3926               if(!trackPos)continue;
3927
3928               Int_t negAssLabel = TMath::Abs(trackNeg->GetLabel());                   //negative (reconstructed) charged track label in MC stack
3929               Int_t posAssLabel = TMath::Abs(trackPos->GetLabel());                   //positive (reconstructed) charged track label in MC stack
3930
3931
3932               if(particleLabel == posAssLabel){                                       //check whether jet track and each of the rec. K0s daughters have same MC stack label -> are identical
3933                 AliAODMCParticle* mctrackPos = dynamic_cast<AliAODMCParticle*>(stackMC->At(posAssLabel));
3934                 if(!mctrackPos) continue;
3935                 Double_t trackPosPt = mctrackPos->Pt();
3936                 Double_t trackPosEta = mctrackPos->Eta();
3937
3938                 Double_t vK0sSecContinCone[3] = {jetPt, trackPosPt, trackPosEta};
3939                 fhnK0sSecContinCone->Fill(vK0sSecContinCone);}           //if it's the case, fill jet pt, daughter track pt and track eta in histo
3940
3941               if(particleLabel == negAssLabel){
3942                 AliAODMCParticle* mctrackNeg = dynamic_cast<AliAODMCParticle*>(stackMC->At(negAssLabel));
3943                 if(!mctrackNeg) continue;
3944                 Double_t trackNegPt = mctrackNeg->Pt();
3945                 Double_t trackNegEta = mctrackNeg->Eta();
3946
3947                 Double_t vK0sSecContinCone[3] = {jetPt, trackNegPt, trackNegEta};
3948                 fhnK0sSecContinCone->Fill(vK0sSecContinCone);}              //if it's the case, fill jet pt, daughter track pt and track eta in histo
3949             }
3950           }
3951
3952
3953           //_______________
3954
3955
3956         } //end rec-K0-in-cone loop
3957
3958         //________________________________________________________________________________________________________________________________________________________
3959
3960         fListMCgenK0sCone->Clear();
3961
3962
3963       }//end fAnalysisMC
3964
3965       jetConeK0list->Clear();
3966       jetPerpConeK0list->Clear();
3967       jetPerpConeLalist->Clear();
3968       jetPerpConeALalist->Clear();
3969
3970
3971       //---------------La--------------------------------------------------------------------------------------------------------------------------------------------
3972
3973       // fQAJetHistosRecCutsLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
3974
3975       for(Int_t it=0; it<fListLa->GetSize(); ++it){ // loop all La
3976
3977         AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListLa->At(it));
3978         if(!v0) continue;
3979
3980         Double_t v0Mom[3];
3981         v0->PxPyPz(v0Mom);
3982         TVector3 v0MomVect(v0Mom);
3983
3984         Double_t dPhiJetLa = (jet->MomentumVector()->Vect()).DeltaPhi(v0MomVect);
3985
3986         Double_t invMLa =0;
3987         Double_t trackPt=0;
3988
3989         CalculateInvMass(v0, kLambda, invMLa, trackPt); //function to calculate invMass with TLorentzVector class
3990         //      Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
3991
3992         //if(incrementJetPt){fh1V0JetPt->Fill(jetPt);}
3993
3994         //fFFHistosIMLaJet->FillFF(trackPt, invMLa, jetPt, incrementJetPt);
3995
3996         if(dPhiJetLa<fh1dPhiJetLa->GetXaxis()->GetXmin()) dPhiJetLa += 2*TMath::Pi();
3997         fh1dPhiJetLa->Fill(dPhiJetLa);
3998       }
3999
4000       /*   if(fListLa->GetSize() == 0){ // no La: increment jet pt spectrum
4001
4002            Bool_t incrementJetPt = kTRUE;
4003            fFFHistosIMLaJet->FillFF(-1, -1, jetPt, incrementJetPt);
4004         }*/
4005
4006
4007       // ____fetch rec. Lambdas in cone around jet axis_______________________________________________________________________________________
4008
4009       jetConeLalist->Clear();
4010       Double_t sumPtLa     = 0.;
4011       Bool_t isBadJetLa    = kFALSE; // dummy, do not use
4012
4013       GetTracksInCone(fListLa, jetConeLalist, jet, GetFFRadius(), sumPtLa, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetLa);//method inherited from FF
4014
4015       if(fDebug>2)Printf("%s:%d nLa total: %d, in jet cone: %d,FFRadius %f ",(char*)__FILE__,__LINE__,nLa,jetConeLalist->GetEntries(),GetFFRadius());
4016
4017       for(Int_t it=0; it<jetConeLalist->GetSize(); ++it){ // loop La in jet cone
4018
4019         AliAODv0* v0 = dynamic_cast<AliAODv0*>(jetConeLalist->At(it));
4020         if(!v0) continue;
4021
4022         Int_t nnum;
4023         Int_t pnum;
4024
4025         Bool_t daughtercheck = DaughterTrackCheck(v0, nnum, pnum);
4026         if(daughtercheck == kFALSE)continue;
4027         Double_t invMLa =0;
4028         Double_t trackPt=0;
4029         Double_t fEta = 0;
4030
4031         fEta = v0->Eta();
4032
4033         CalculateInvMass(v0, kLambda, invMLa, trackPt); //function to calculate invMass with TLorentzVector class
4034
4035         Bool_t   incrementJetPt = (it==0) ? kTRUE : kFALSE;//needed for all histos, which serve for normalisation
4036
4037         if(fAnalysisMC){
4038
4039           Int_t negDaughterpdg;
4040           Int_t posDaughterpdg;
4041           Int_t motherType;
4042           Int_t v0Label;
4043           Double_t jetPtSmear = -1;
4044           Double_t MCPt;
4045           Bool_t fPhysicalPrimary = -1;
4046           Int_t MCv0PDGCode =0;
4047           TString generatorName;
4048
4049           SmearJetPt(jetPt,cl,GetFFRadius(),GetFFMinLTrackPt(),jetPtSmear);
4050           if(incrementJetPt == kTRUE){fh1IMLaConeSmear->Fill(jetPtSmear);
4051
4052             const AliAODTrack *trackNeg=(AliAODTrack *)(v0->GetDaughter(nnum));
4053             const AliAODTrack *trackPos=(AliAODTrack *)(v0->GetDaughter(pnum));
4054
4055             TList *listmc = fAOD->GetList();
4056             Bool_t isinjected;
4057             Bool_t mclabelcheck = MCLabelCheck(v0, kLambda, trackNeg, trackPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PDGCode, generatorName, isinjected);
4058             if(mclabelcheck == kFALSE)continue;
4059
4060             //std::cout<<"generatorName: "<<generatorName<<std::endl;
4061
4062             if(generatorName == "Hijing"){
4063             Double_t vrecMCHijingLaCone[4] = {jetPt, invMLa,trackPt,fEta};
4064             fhnrecMCHijingLaCone->Fill(vrecMCHijingLaCone);
4065             }
4066
4067             if(isinjected == kTRUE){
4068             Double_t vrecMCInjectLaCone[4] = {jetPt, invMLa,trackPt,fEta};
4069             fhnrecMCInjectLaCone->Fill(vrecMCInjectLaCone);
4070             }
4071
4072           }//fill TH1F for normalization purposes
4073         }//end MC analysis part
4074
4075         if(incrementJetPt==kTRUE){
4076           fh1IMLaCone->Fill(jetPt);}//normalisation by number of selected jets
4077
4078         //fFFHistosIMLaCone->FillFF(trackPt, invMLa, jetPt, incrementJetPt);
4079         Double_t vLaCone[4] = {jetPt, invMLa,trackPt,fEta};
4080         fhnLaCone->Fill(vLaCone);
4081       }
4082
4083       if(jetConeLalist->GetSize() == 0){ // no La: increment jet pt spectrum
4084
4085         Bool_t incrementJetPt = kTRUE;
4086         //      fFFHistosIMLaCone->FillFF(-1, -1, jetPt, incrementJetPt);
4087         Double_t vLaCone[4] = {jetPt, -1, -1, -1};
4088         fhnLaCone->Fill(vLaCone);
4089
4090         if(incrementJetPt==kTRUE){
4091           fh1IMLaCone->Fill(jetPt);}//normalisation by number of selected jets
4092
4093         if(fAnalysisMC){
4094           Double_t jetPtSmear;
4095           SmearJetPt(jetPt,cl,GetFFRadius(),GetFFMinLTrackPt(),jetPtSmear);
4096           if(incrementJetPt == kTRUE){
4097             fh1IMLaConeSmear->Fill(jetPtSmear);
4098
4099           }
4100         }
4101
4102       }
4103
4104       if(fAnalysisMC){
4105
4106         //____fetch MC generated Lambdas in cone around jet axis__(particles can stem from fragmentation but also from underlying event)_____________
4107
4108         Double_t sumPtMCgenLa      = 0.;
4109         Bool_t isBadJetMCgenLa  = kFALSE; // dummy, do not use
4110
4111         //sampling MC gen. Lambdas in cone around reconstructed jet axis
4112
4113         fListMCgenLaCone->Clear();
4114         GetTracksInCone(fListMCgenLa, fListMCgenLaCone, jet, GetFFRadius(), sumPtMCgenLa, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetMCgenLa);//fetch MC generated Lambdas in cone of resolution parameter R around jet axis
4115
4116         if(fDebug>2)Printf("%s:%d nMCgenLa in jet cone: %d,FFRadius %f ",(char*)__FILE__,__LINE__,fListMCgenLaCone->GetEntries(),GetFFRadius());
4117
4118         /*      for(Int_t it=0; it<fListMCgenLaCone->GetSize(); ++it){ // loop MC generated La in cone around jet axis
4119
4120           AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenLaCone->At(it));
4121           if(!mcp0) continue;
4122
4123           //Double_t fRapMCgenLa   = MyRapidity(mcp0->E(),mcp0->Pz());
4124           Double_t fEtaMCgenLa   = mcp0->Eta();
4125           Double_t fPtMCgenLa    = mcp0->Pt();
4126
4127           // fh2MCgenLaCone->Fill(jetPt,fPtMCgenLa);
4128           //fh2MCEtagenLaCone->Fill(jetPt,fEtaMCgenLa);
4129           }*/
4130
4131
4132         //check whether the reconstructed La are stemming from MC gen La on fListMCgenLa List:__________________________________________________
4133
4134         for(Int_t ic=0; ic<jetConeLalist->GetSize(); ++ic){//loop over all reconstructed La within jet cone, new definition
4135
4136           Int_t negDaughterpdg;
4137           Int_t posDaughterpdg;
4138           Int_t motherType;
4139           Int_t v0Label;
4140           Double_t fPtMCrecLaMatch;
4141           Double_t invMLaMatch;
4142           Double_t MCPt;
4143           Int_t nnum;
4144           Int_t pnum;
4145           Bool_t fPhysicalPrimary = -1;
4146           Int_t MCv0PDGCode =0;
4147           Double_t jetPtSmear = -1;
4148           TString generatorName;
4149
4150           AliAODv0* v0c = dynamic_cast<AliAODv0*>(jetConeLalist->At(ic));//new definition
4151
4152
4153           if(!v0c) continue;
4154
4155           Bool_t daughtercheck = DaughterTrackCheck(v0c, nnum, pnum);
4156           if(daughtercheck == kFALSE)continue;
4157
4158           const AliAODTrack *trackMCNeg=(AliAODTrack *)(v0c->GetDaughter(nnum));
4159           const AliAODTrack *trackMCPos=(AliAODTrack *)(v0c->GetDaughter(pnum));
4160
4161           TList *listmc = fAOD->GetList();
4162           Bool_t isinjected;
4163           Bool_t mclabelcheck = MCLabelCheck(v0c, kLambda, trackMCNeg, trackMCPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PDGCode, generatorName, isinjected);
4164
4165           if(mclabelcheck == kFALSE)continue;
4166           if(fPhysicalPrimary == kFALSE)continue;
4167
4168           for(Int_t it=0; it<fListMCgenLa->GetSize(); ++it){//new definition                                  // loop over MC generated K0s in cone around jet axis
4169
4170
4171             //Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4172
4173             AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenLa->At(it));//new definition
4174             //AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenLaCone->At(it));//old definition
4175
4176             if(!mcp0) continue;
4177
4178             Bool_t particleMatching = IsParticleMatching(mcp0, v0Label);
4179
4180
4181             if(particleMatching == kFALSE)continue; //particle doesn't match on any associated MC gen particle in cone around rec jet axis
4182
4183             CalculateInvMass(v0c, kLambda, invMLaMatch, fPtMCrecLaMatch);
4184
4185             Double_t fPtMCgenLa    = mcp0->Pt();
4186             Double_t fEta          = v0c->Eta();//rec. MC particle
4187             Double_t vMCrecLaCone[4] = {jetPt, invMLaMatch,fPtMCgenLa,fEta};
4188             fhnMCrecLaCone->Fill(vMCrecLaCone);
4189
4190             SmearJetPt(jetPt,cl,GetFFRadius(),GetFFMinLTrackPt(),jetPtSmear);
4191
4192             Double_t vMCrecLaConeSmear[4] = {jetPtSmear, invMLaMatch,fPtMCgenLa,fEta};
4193             fhnMCrecLaConeSmear->Fill(vMCrecLaConeSmear);  //fill matching rec. Lambdas in 3D histogram, jet pT smeared according to deltaptjet distribution width
4194
4195
4196           } // end MCgenLa loop
4197
4198             //check the Lambda daughters contamination of the jet tracks://///////////////////////////////////////////////////////////////////////////////////////////
4199
4200           TClonesArray *stackMC = 0x0;
4201
4202           for(Int_t it=0; it<jettracklist->GetSize(); ++it){//loop over all particles in the jet
4203
4204             AliVParticle* trackVP = dynamic_cast<AliVParticle*>(jettracklist->At(it));//all tracks in jet cone
4205             if(!trackVP)continue;
4206             AliAODTrack *tr = dynamic_cast<AliAODTrack*> (trackVP);                   //fetch one jet track from the TList
4207             if(!tr)continue;
4208
4209             //get MC label information
4210             TList *mclist = fAOD->GetList();                                           //fetch the MC stack
4211
4212             stackMC = (TClonesArray*)mclist->FindObject(AliAODMCParticle::StdBranchName()); //get MCAOD branch in data
4213             if (!stackMC) {Printf("ERROR: stack not available");}
4214             else {
4215
4216               Int_t particleLabel = TMath::Abs(tr->GetLabel());                       //fetch jet track label in MC stack
4217
4218               Bool_t daughterchecks = DaughterTrackCheck(v0c, nnum, pnum);
4219
4220               if(daughterchecks == kFALSE)continue;                                   //make sure that daughters are properly ordered
4221
4222               const AliAODTrack *trackNeg=(AliAODTrack *)(v0c->GetDaughter(nnum));    //fetch v0 daughters of reconstructed K0s
4223               const AliAODTrack *trackPos=(AliAODTrack *)(v0c->GetDaughter(pnum));
4224
4225               Int_t negAssLabel = TMath::Abs(trackNeg->GetLabel());                   //negative (reconstructed) charged track label in MC stack
4226               Int_t posAssLabel = TMath::Abs(trackPos->GetLabel());                   //positive (reconstructed) charged track label in MC stack
4227
4228
4229               if(particleLabel == posAssLabel){                                       //check whether jet track and each of the rec. K0s daughters have same MC stack label -> are identical
4230
4231                 AliAODMCParticle* mctrackPos = dynamic_cast<AliAODMCParticle*>(stackMC->At(posAssLabel));
4232                 if(!mctrackPos) continue;
4233
4234                 Double_t trackPosPt = trackPos->Pt();
4235                 Double_t trackPosEta = trackPos->Eta();
4236                 Double_t vLaSecContinCone[3] = {jetPt, trackPosPt, trackPosEta};
4237                 fhnLaSecContinCone->Fill(vLaSecContinCone);
4238
4239               }       //if it's the case, fill jet pt, daughter track pt and track eta in histo
4240
4241
4242               if(particleLabel == negAssLabel){
4243
4244                 AliAODMCParticle* mctrackNeg = dynamic_cast<AliAODMCParticle*>(stackMC->At(negAssLabel));
4245                 if(!mctrackNeg) continue;
4246
4247                 Double_t trackNegPt = trackNeg->Pt();
4248                 Double_t trackNegEta = trackNeg->Eta();
4249
4250                 Double_t vLaSecContinCone[3] = {jetPt, trackNegPt, trackNegEta};
4251                 fhnLaSecContinCone->Fill(vLaSecContinCone);
4252
4253
4254               }              //if it's the case, fill jet pt, daughter track pt and track eta in histo
4255             }
4256           }
4257
4258
4259         } //end rec-La-in-cone loop
4260         //________________________________________________________________________________________________________________________________________________________
4261
4262        fListMCgenLaCone->Clear();
4263
4264       }//end fAnalysisMC
4265
4266       jetConeLalist->Clear();
4267
4268
4269
4270       //---------------ALa-----------
4271
4272
4273       // fQAJetHistosRecCutsLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
4274
4275       for(Int_t it=0; it<fListALa->GetSize(); ++it){ // loop all ALa
4276
4277         AliAODv0* v0 = dynamic_cast<AliAODv0*>(fListALa->At(it));
4278         if(!v0) continue;
4279
4280         Double_t v0Mom[3];
4281         v0->PxPyPz(v0Mom);
4282         TVector3 v0MomVect(v0Mom);
4283
4284         Double_t dPhiJetALa = (jet->MomentumVector()->Vect()).DeltaPhi(v0MomVect);
4285
4286         Double_t invMALa =0;
4287         Double_t trackPt=0;
4288
4289         CalculateInvMass(v0, kAntiLambda, invMALa, trackPt); //function to calculate invMass with TLorentzVector class
4290         //Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4291
4292         //if(incrementJetPt){fh1V0JetPt->Fill(jetPt);}
4293
4294         //fFFHistosIMALaJet->FillFF(trackPt, invMALa, jetPt, incrementJetPt);
4295
4296         if(dPhiJetALa<fh1dPhiJetALa->GetXaxis()->GetXmin()) dPhiJetALa += 2*TMath::Pi();
4297         fh1dPhiJetALa->Fill(dPhiJetALa);
4298       }
4299
4300       // if(fListALa->GetSize() == 0){ // no ALa: increment jet pt spectrum
4301
4302       //        Bool_t incrementJetPt = kTRUE;
4303         //fFFHistosIMALaJet->FillFF(-1, -1, jetPt, incrementJetPt);
4304       //}
4305
4306
4307       // ____fetch rec. Antilambdas in cone around jet axis_______________________________________________________________________________________
4308
4309       jetConeALalist->Clear();
4310       Double_t sumPtALa     = 0.;
4311       Bool_t isBadJetALa    = kFALSE; // dummy, do not use
4312
4313       GetTracksInCone(fListALa, jetConeALalist, jet, GetFFRadius(), sumPtALa, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetALa);//method inherited from FF
4314
4315       if(fDebug>2)Printf("%s:%d nALa total: %d, in jet cone: %d,FFRadius %f ",(char*)__FILE__,__LINE__,nALa,jetConeALalist->GetEntries(),GetFFRadius());
4316
4317       for(Int_t it=0; it<jetConeALalist->GetSize(); ++it){ // loop ALa in jet cone
4318
4319         AliAODv0* v0 = dynamic_cast<AliAODv0*>(jetConeALalist->At(it));
4320         if(!v0) continue;
4321
4322
4323         Int_t nnum;
4324         Int_t pnum;
4325
4326         Bool_t daughtercheck = DaughterTrackCheck(v0, nnum, pnum);
4327         if(daughtercheck == kFALSE)continue;
4328
4329
4330         Double_t invMALa =0;
4331         Double_t trackPt=0;
4332         Double_t fEta = 0;
4333
4334         fEta = v0->Eta();
4335
4336         CalculateInvMass(v0, kAntiLambda, invMALa, trackPt); //function to calculate invMass with TLorentzVector class
4337
4338         Bool_t   incrementJetPt = (it==0) ? kTRUE : kFALSE;
4339
4340         if(fAnalysisMC){    //jet pt smearing study for Antilambdas
4341
4342           Int_t negDaughterpdg;
4343           Int_t posDaughterpdg;
4344           Int_t motherType;
4345           Int_t v0Label;
4346           Double_t jetPtSmear = -1;
4347           Double_t MCPt;
4348           Bool_t fPhysicalPrimary = -1;
4349           Int_t MCv0PDGCode =0;
4350           TString generatorName;
4351
4352           SmearJetPt(jetPt,cl,GetFFRadius(),GetFFMinLTrackPt(),jetPtSmear);
4353           const AliAODTrack *trackNeg=(AliAODTrack *)(v0->GetDaughter(nnum));
4354           const AliAODTrack *trackPos=(AliAODTrack *)(v0->GetDaughter(pnum));
4355
4356             TList *listmc = fAOD->GetList();
4357             Bool_t isinjected;
4358             Bool_t mclabelcheck = MCLabelCheck(v0, kAntiLambda, trackNeg, trackPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PDGCode, generatorName, isinjected);
4359             if(mclabelcheck == kFALSE)continue;
4360
4361             //std::cout<<"generatorName: "<<generatorName<<std::endl;
4362
4363             if(generatorName == "Hijing"){
4364             Double_t vrecMCHijingALaCone[4] = {jetPt, invMALa,trackPt,fEta};
4365             fhnrecMCHijingALaCone->Fill(vrecMCHijingALaCone);
4366             }
4367
4368             if(isinjected == kTRUE){
4369             Double_t vrecMCInjectALaCone[4] = {jetPt, invMALa,trackPt,fEta};
4370             fhnrecMCInjectALaCone->Fill(vrecMCInjectALaCone);
4371             }
4372
4373           if(incrementJetPt == kTRUE){fh1IMALaConeSmear->Fill(jetPtSmear);}                          //fill TH1F for normalization purposes
4374         }//end fAnalysisMC
4375
4376         if(incrementJetPt==kTRUE){
4377           fh1IMALaCone->Fill(jetPt);}//normalisation by number of selected jets
4378
4379         //fFFHistosIMALaCone->FillFF(trackPt, invMALa, jetPt, incrementJetPt);
4380         Double_t vALaCone[4] = {jetPt, invMALa,trackPt,fEta};
4381         fhnALaCone->Fill(vALaCone);
4382       }
4383
4384       if(jetConeALalist->GetSize() == 0){ // no ALa: increment jet pt spectrum
4385
4386         Bool_t incrementJetPt = kTRUE;
4387
4388         if(incrementJetPt==kTRUE){
4389           fh1IMALaCone->Fill(jetPt);}//normalisation by number of selected jets
4390
4391         //fFFHistosIMALaCone->FillFF(-1, -1, jetPt, incrementJetPt);
4392         Double_t vALaCone[4] = {jetPt, -1, -1, -1};
4393         fhnALaCone->Fill(vALaCone);
4394
4395         if(fAnalysisMC){
4396           Double_t jetPtSmear;
4397           SmearJetPt(jetPt,cl,GetFFRadius(),GetFFMinLTrackPt(),jetPtSmear);
4398           if(incrementJetPt == kTRUE)fh1IMALaConeSmear->Fill(jetPtSmear);}
4399
4400       }
4401
4402       if(fAnalysisMC){
4403
4404         //____fetch MC generated Antilambdas in cone around jet axis__(particles can stem from fragmentation but also from underlying event)_____________
4405
4406         Double_t sumPtMCgenALa      = 0.;
4407         Bool_t isBadJetMCgenALa  = kFALSE; // dummy, do not use
4408
4409         //sampling MC gen Antilambdas in cone around reconstructed jet axis
4410         fListMCgenALaCone->Clear();
4411
4412         GetTracksInCone(fListMCgenALa, fListMCgenALaCone, jet, GetFFRadius(), sumPtMCgenALa, GetFFMinLTrackPt(), GetFFMaxTrackPt(), isBadJetMCgenALa);//MC generated K0s in cone around jet axis
4413
4414         if(fDebug>2)Printf("%s:%d nMCgenALa in jet cone: %d,FFRadius %f ",(char*)__FILE__,__LINE__,fListMCgenALaCone->GetEntries(),GetFFRadius());
4415
4416         /*      for(Int_t it=0; it<fListMCgenALaCone->GetSize(); ++it){ // loop MC generated La in cone around jet axis
4417
4418           AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenALaCone->At(it));
4419           if(!mcp0) continue;
4420
4421           //Double_t fRapMCgenALa   = MyRapidity(mcp0->E(),mcp0->Pz());
4422           Double_t fEtaMCgenALa   = mcp0->Eta();
4423           Double_t fPtMCgenALa    = mcp0->Pt();
4424
4425           //fh2MCgenALaCone->Fill(jetPt,fPtMCgenALa);
4426           //fh2MCEtagenALaCone->Fill(jetPt,fEtaMCgenALa);
4427           }*/
4428
4429
4430         //check whether the reconstructed ALa are stemming from MC gen ALa on MCgenALa List:__________________________________________________
4431
4432         for(Int_t ic=0; ic<jetConeALalist->GetSize(); ++ic){//loop over all reconstructed ALa
4433
4434           Int_t negDaughterpdg;
4435           Int_t posDaughterpdg;
4436           Int_t motherType;
4437           Int_t v0Label;
4438           Double_t fPtMCrecALaMatch;
4439           Double_t invMALaMatch;
4440           Double_t MCPt;
4441           Int_t nnum;
4442           Int_t pnum;
4443           Bool_t fPhysicalPrimary = -1;
4444           Int_t MCv0PDGCode =0;
4445           Double_t jetPtSmear = -1;
4446           TString generatorName;
4447
4448           AliAODv0* v0c = dynamic_cast<AliAODv0*>(jetConeALalist->At(ic));
4449           if(!v0c) continue;
4450
4451           Bool_t daughtercheck = DaughterTrackCheck(v0c, nnum, pnum);
4452           if(daughtercheck == kFALSE)continue;
4453
4454           const AliAODTrack *trackMCNeg=(AliAODTrack *)(v0c->GetDaughter(nnum));
4455           const AliAODTrack *trackMCPos=(AliAODTrack *)(v0c->GetDaughter(pnum));
4456
4457           TList *listmc = fAOD->GetList();
4458           if(!listmc)continue;
4459           Bool_t isinjected;
4460           Bool_t mclabelcheck = MCLabelCheck(v0c, kAntiLambda, trackMCNeg, trackMCPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PDGCode, generatorName, isinjected);
4461
4462           if(mclabelcheck == kFALSE)continue;
4463           if(fPhysicalPrimary == kFALSE)continue;
4464
4465           for(Int_t it=0; it<fListMCgenALa->GetSize(); ++it){                                  // loop over MC generated Antilambdas in cone around jet axis
4466
4467             //Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
4468
4469             AliAODMCParticle* mcp0 = dynamic_cast<AliAODMCParticle*>(fListMCgenALa->At(it));
4470             if(!mcp0) continue;
4471
4472             Bool_t particleMatching = IsParticleMatching(mcp0, v0Label);
4473
4474             if(particleMatching == kFALSE)continue; //particle doesn't match on any associated MC gen particle in cone around rec jet axis
4475
4476             CalculateInvMass(v0c, kAntiLambda, invMALaMatch, fPtMCrecALaMatch);
4477
4478             Double_t fPtMCgenALa  = mcp0->Pt();
4479             Double_t fEta = v0c->Eta();
4480             Double_t vMCrecALaCone[4] = {jetPt, invMALaMatch,fPtMCgenALa,fEta};
4481             fhnMCrecALaCone->Fill(vMCrecALaCone);   //fill matching rec. Antilambda in 3D histogram
4482
4483             SmearJetPt(jetPt,cl,GetFFRadius(),GetFFMinLTrackPt(),jetPtSmear);
4484
4485             Double_t vMCrecALaConeSmear[4] = {jetPtSmear, invMALaMatch,fPtMCgenALa,fEta};
4486             fhnMCrecALaConeSmear->Fill(vMCrecALaConeSmear);   //fill matching rec. Antilambda in 3D histogram
4487
4488           } // end MCgenALa loop
4489
4490
4491            //___________
4492           //check the Antilambda daughters contamination of the jet tracks:
4493
4494           TClonesArray *stackMC = 0x0;
4495
4496           for(Int_t it=0; it<jettracklist->GetSize(); ++it){//loop over all particles in the jet
4497
4498             AliVParticle* trackVP = dynamic_cast<AliVParticle*>(jettracklist->At(it));//all tracks in jet cone
4499             if(!trackVP)continue;
4500             AliAODTrack *tr = dynamic_cast<AliAODTrack*> (trackVP);                   //fetch one jet track from the TList
4501             if(!tr)continue;
4502
4503             //get MC label information
4504             TList *mclist = fAOD->GetList();                                           //fetch the MC stack
4505             if(!mclist)continue;
4506
4507             stackMC = (TClonesArray*)mclist->FindObject(AliAODMCParticle::StdBranchName()); //get MCAOD branch in data
4508             if (!stackMC) {Printf("ERROR: stack not available");}
4509             else {
4510
4511               Int_t particleLabel = TMath::Abs(tr->GetLabel());                       //fetch jet track label in MC stack
4512
4513               Bool_t daughterchecks = DaughterTrackCheck(v0c, nnum, pnum);
4514
4515               if(daughterchecks == kFALSE)continue;                                   //make sure that daughters are properly ordered
4516
4517               const AliAODTrack *trackNeg=(AliAODTrack *)(v0c->GetDaughter(nnum));    //fetch v0 daughters of reconstructed K0s
4518               const AliAODTrack *trackPos=(AliAODTrack *)(v0c->GetDaughter(pnum));
4519               if(!trackPos)continue;
4520               if(!trackNeg)continue;
4521
4522               Int_t negAssLabel = TMath::Abs(trackNeg->GetLabel());                   //negative (reconstructed) charged track label in MC stack
4523               Int_t posAssLabel = TMath::Abs(trackPos->GetLabel());                   //positive (reconstructed) charged track label in MC stack
4524
4525               if(!negAssLabel)continue;
4526               if(!posAssLabel)continue;
4527
4528               if(particleLabel == posAssLabel){                                       //check whether jet track and each of the rec. K0s daughters have same MC stack label -> are identical
4529                 AliAODMCParticle* mctrackPos = dynamic_cast<AliAODMCParticle*>(stackMC->At(posAssLabel));
4530                 if(!mctrackPos) continue;
4531
4532                 Double_t trackPosPt = trackPos->Pt();
4533                 Double_t trackPosEta = trackPos->Eta();
4534                 if(!trackPosPt)continue;
4535                 if(!trackPosEta)continue;
4536
4537                 Double_t vLaSecContinCone[3] = {jetPt, trackPosPt, trackPosEta};
4538                 fhnLaSecContinCone->Fill(vLaSecContinCone);
4539
4540
4541
4542                 //fh3SecContinCone->Fill(jetPt, trackPosPt, trackPosEta);
4543               }              //if it's the case, fill jet pt, daughter track pt and track eta in histo
4544
4545               if(particleLabel == negAssLabel){
4546
4547                 AliAODMCParticle* mctrackNeg = dynamic_cast<AliAODMCParticle*>(stackMC->At(negAssLabel));
4548                 if(!mctrackNeg) continue;
4549
4550                 Double_t trackNegPt = trackNeg->Pt();
4551                 Double_t trackNegEta = trackNeg->Eta();
4552
4553                 if(!trackNegPt)continue;
4554                 if(!trackNegEta)continue;
4555
4556                 Double_t vLaSecContinCone[3] = {jetPt, trackNegPt, trackNegEta};
4557                 fhnLaSecContinCone->Fill(vLaSecContinCone);
4558
4559                 //fh3SecContinCone->Fill(jetPt, trackNegPt, trackNegEta);
4560               }              //if it's the case, fill jet pt, daughter track pt and track eta in histo
4561             }
4562           }
4563
4564         } //end rec-ALa-in-cone loop
4565         //________________________________________________________________________________________________________________________________________________________
4566
4567
4568         fListMCgenALaCone->Clear();
4569       }//end fAnalysisMC
4570
4571
4572       jetConeALalist->Clear();
4573       jettracklist->Clear();
4574     }//end of if 'leading' or 'all jet' requirement
4575   }//end of jet loop
4576
4577   jettracklist->Clear();
4578   jetConeK0list->Clear();
4579   jetConeLalist->Clear();
4580   jetConeALalist->Clear();
4581   jetPerpConeK0list->Clear();
4582   jetPerpConeLalist->Clear();
4583   jetPerpConeALalist->Clear();
4584   jetMedianConeK0list->Clear();
4585   jetMedianConeLalist->Clear();
4586   jetMedianConeALalist->Clear();
4587   fListK0sRC->Clear();
4588   fListLaRC->Clear();
4589   fListALaRC->Clear();
4590   fTracksRecCuts->Clear();
4591   fJetsRecCuts->Clear();
4592   fBckgJetsRec->Clear();
4593   fListK0s->Clear();
4594   fListLa->Clear();
4595   fListALa->Clear();
4596   fListFeeddownLaCand->Clear();
4597   fListFeeddownALaCand->Clear();
4598   jetConeFDLalist->Clear();
4599   jetConeFDALalist->Clear();
4600   fListMCgenK0s->Clear();
4601   fListMCgenLa->Clear();
4602   fListMCgenALa->Clear();
4603   fListMCgenK0sCone->Clear();
4604   fListMCgenLaCone->Clear();
4605   fListMCgenALaCone->Clear();
4606
4607   //Post output data.
4608   PostData(1, fCommonHistList);
4609   //end of event loop
4610
4611 }
4612
4613 // ____________________________________________________________________________________________
4614 void AliAnalysisTaskJetChem::SetProperties(TH3F* h,const char* x, const char* y, const char* z)
4615 {
4616   //Set properties of histos (x,y and z title)
4617
4618   h->SetXTitle(x);
4619   h->SetYTitle(y);
4620   h->SetZTitle(z);
4621   h->GetXaxis()->SetTitleColor(1);
4622   h->GetYaxis()->SetTitleColor(1);
4623   h->GetZaxis()->SetTitleColor(1);
4624 }
4625
4626
4627 //________________________________________________________________________________________________________________________________________
4628 Bool_t AliAnalysisTaskJetChem::AcceptBetheBloch(AliAODv0 *v0, AliPIDResponse *PIDResponse, const Int_t particletype) //dont use for MC Analysis
4629 {
4630
4631         Int_t nnum = 1;
4632         Int_t pnum = 0;
4633         //---
4634         const AliAODTrack *ntracktest=(AliAODTrack *)v0->GetDaughter(nnum);
4635         if(ntracktest->Charge() > 0){nnum = 0; pnum = 1;}
4636
4637         const AliAODTrack *trackNeg=(AliAODTrack *)(v0->GetDaughter(nnum));
4638         const AliAODTrack *trackPos=(AliAODTrack *)(v0->GetDaughter(pnum));
4639
4640         //Check if both tracks are available
4641         if (!trackPos || !trackNeg) {
4642           Printf("strange analysis::UserExec:: Error:Could not retrieve one of the daughter tracks\n");
4643           return kFALSE;
4644         }
4645
4646         //remove like sign V0s
4647         if ( trackPos->Charge() == trackNeg->Charge() ){
4648           //if(fDebug>1) Printf("%s:%d found like-sign V0", (char*)__FILE__,__LINE__);
4649           return kFALSE;
4650           }
4651         //--
4652
4653         Double_t nsig_p = 0; //number of sigmas that positive daughter track has got in TPC pid information
4654         Double_t nsig_n = 0;
4655
4656         const AliAODPid *pid_p=trackPos->GetDetPid();  // returns fDetPID, more detailed or detector specific pid information
4657         const AliAODPid *pid_n=trackNeg->GetDetPid();
4658
4659         if(!pid_p)return kFALSE;
4660         if(!pid_n)return kFALSE;
4661
4662         if (pid_p)
4663           {
4664             if(particletype == 1) //PID cut on positive charged Lambda daughters (only those with pt < 1 GeV/c)
4665               {
4666
4667                 nsig_p=PIDResponse->NumberOfSigmasTPC(trackPos,AliPID::kProton);
4668                 Double_t protonPt = trackPos->Pt();
4669                 if ((TMath::Abs(nsig_p) >= fCutBetheBloch) && (fCutBetheBloch >0) && (protonPt < 1)) return kFALSE;
4670
4671               }
4672
4673
4674           }
4675
4676         if (pid_n)
4677           {
4678             if(particletype == 2)
4679               {
4680                 nsig_n=PIDResponse->NumberOfSigmasTPC(trackNeg,AliPID::kProton);
4681                 Double_t antiprotonPt = trackNeg->Pt();
4682                 if ((TMath::Abs(nsig_n) >= fCutBetheBloch) && (fCutBetheBloch >0) && (antiprotonPt < 1)) return kFALSE;
4683               }
4684
4685           }
4686
4687         return kTRUE;
4688 }
4689
4690 //___________________________________________________________________
4691 Bool_t AliAnalysisTaskJetChem::IsK0InvMass(const Double_t mass) const
4692 {
4693   // K0 mass ? Use FF histo limits
4694
4695   if(fFFIMInvMMin <= mass && mass < fFFIMInvMMax) return kTRUE;
4696
4697   return kFALSE;
4698 }
4699 //___________________________________________________________________
4700 Bool_t AliAnalysisTaskJetChem::IsLaInvMass(const Double_t mass) const
4701 {
4702   // La mass ? Use FF histo limits
4703
4704
4705   if(fFFIMLaInvMMin <= mass && mass < fFFIMLaInvMMax) return kTRUE;
4706
4707   return kFALSE;
4708 }
4709
4710 //_____________________________________________________________________________________
4711 Int_t AliAnalysisTaskJetChem::GetListOfV0s(TList *list, const Int_t type, const Int_t particletype, AliAODVertex* primVertex, AliAODEvent* aod)
4712 {
4713   // fill list of V0s selected according to type
4714
4715   if(!list){
4716     if(fDebug>1) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
4717     return -1;
4718   }
4719
4720
4721   if(fDebug>5){std::cout<<"AliAnalysisTaskJetChem::GetListOfV0s(): type: "<<type<<" particletype: "<<particletype<<"aod: "<<aod<<std::endl;
4722     if(type==kTrackUndef){std::cout<<"AliAnalysisTaskJetChem::GetListOfV0s(): kTrackUndef!! "<<std::endl;}
4723   }
4724
4725
4726   if(type==kTrackUndef) return 0;
4727
4728   if(!primVertex) return 0;
4729
4730   Double_t lPrimaryVtxPosition[3];
4731   Double_t lV0Position[3];
4732   lPrimaryVtxPosition[0] = primVertex->GetX();
4733   lPrimaryVtxPosition[1] = primVertex->GetY();
4734   lPrimaryVtxPosition[2] = primVertex->GetZ();
4735
4736   if(fDebug>5){ std::cout<<"AliAnalysisTaskJetChem::GetListOfV0s(): aod->GetNumberOfV0s: "<<aod->GetNumberOfV0s()<<std::endl; }
4737
4738
4739   for(int i=0; i<aod->GetNumberOfV0s(); i++){ // loop over V0s
4740
4741
4742     AliAODv0* v0 = aod->GetV0(i);
4743
4744     if(!v0)
4745       {
4746         std::cout << std::endl
4747                   << "Warning in AliAnalysisTaskJetChem::GetListOfV0s:" << std::endl
4748                   << "v0 = " << v0 << std::endl;
4749         continue;
4750       }
4751
4752     Bool_t isOnFly = v0->GetOnFlyStatus();
4753
4754     if(!isOnFly &&  (type == kOnFly || type == kOnFlyPID || type == kOnFlydEdx || type == kOnFlyPrim)) continue;
4755     if( isOnFly &&  (type == kOffl  || type == kOfflPID  || type == kOffldEdx  || type == kOfflPrim))  continue;
4756
4757     Int_t motherType = -1;
4758      //Double_t v0CalcMass = 0;   //mass of MC v0
4759     Double_t MCPt = 0;         //pt of MC v0
4760
4761     Double_t pp[3]={0,0,0}; //3-momentum positive charged track
4762     Double_t pm[3]={0,0,0}; //3-momentum negative charged track
4763     Double_t v0mom[3]={0,0,0};
4764
4765     Double_t invM = 0;
4766     Double_t invMK0s=0;
4767     Double_t invMLa=0;
4768     Double_t invMALa=0;
4769     Double_t trackPt=0;
4770     Int_t nnum = -1;
4771     Int_t pnum = -1;
4772
4773
4774     Bool_t daughtercheck = DaughterTrackCheck(v0, nnum, pnum);
4775
4776     if(daughtercheck == kFALSE)continue;
4777
4778     const AliAODTrack *trackNeg=(AliAODTrack *)(v0->GetDaughter(nnum));
4779     const AliAODTrack *trackPos=(AliAODTrack *)(v0->GetDaughter(pnum));
4780
4781
4782      ///////////////////////////////////////////////////////////////////////////////////
4783
4784     //calculate InvMass for every V0 particle assumption (Kaon=1,Lambda=2,Antilambda=3)
4785     switch(particletype){
4786     case kK0:
4787       CalculateInvMass(v0, kK0, invM, trackPt); //function to calculate invMass with TLorentzVector class
4788       invMK0s=invM;
4789       break;
4790     case kLambda:
4791       CalculateInvMass(v0, kLambda, invM, trackPt);
4792       invMLa=invM;
4793       break;
4794     case kAntiLambda:
4795       CalculateInvMass(v0, kAntiLambda, invM, trackPt);
4796       invMALa=invM;
4797       break;
4798     default:
4799       std::cout<<"***NO VALID PARTICLETYPE***"<<std::endl;
4800       return 0;
4801     }
4802
4803
4804     /////////////////////////////////////////////////////////////
4805     //V0 and track Cuts:
4806
4807
4808     if(fDebug>7){if(!(IsK0InvMass(invMK0s)) && !(IsLaInvMass(invMLa)) && !(IsLaInvMass(invMALa))){std::cout<<"AliAnalysisTaskJetChem::GetListOfV0s: invM not in selected mass window "<<std::endl;}}
4809
4810     if(!(IsK0InvMass(invMK0s)) && !(IsLaInvMass(invMLa)) && !(IsLaInvMass(invMALa)))continue;
4811
4812     //  Double_t PosEta = trackPos->AliAODTrack::Eta();//daughter track charge is sometimes wrong here, account for that!!!
4813     // Double_t NegEta = trackNeg->AliAODTrack::Eta();
4814
4815    Double_t PosEta = trackPos->Eta();//daughter track charge is sometimes wrong here, account for that!!!
4816    Double_t NegEta = trackNeg->Eta();
4817
4818     Double_t PosCharge = trackPos->Charge();
4819     Double_t NegCharge = trackNeg->Charge();
4820
4821     if((trackPos->Charge() == 1) && (trackNeg->Charge() == -1)) //Fill daughters charge into histo to check if they are symmetric distributed
4822       { fh1PosDaughterCharge->Fill(PosCharge);
4823         fh1NegDaughterCharge->Fill(NegCharge);
4824       }
4825
4826     //DistOverTotMom_in_2D___________
4827
4828     Float_t fMassK0s = TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass();
4829     Float_t fMassLambda = TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass();
4830
4831
4832     AliAODVertex* primVtx = fAOD->GetPrimaryVertex(); // get the primary vertex
4833     Double_t dPrimVtxPos[3]; // primary vertex position {x,y,z}
4834     primVtx->GetXYZ(dPrimVtxPos);
4835
4836     Float_t fPtV0 = TMath::Sqrt(v0->Pt2V0()); // transverse momentum of V0
4837     Double_t dSecVtxPos[3]; // V0 vertex position {x,y,z}
4838     v0->GetSecondaryVtx(dSecVtxPos);
4839     Double_t dDecayPath[3];
4840     for (Int_t iPos = 0; iPos < 3; iPos++)
4841       dDecayPath[iPos] = dSecVtxPos[iPos]-dPrimVtxPos[iPos]; // vector of the V0 path
4842     Float_t fDecLen2D = TMath::Sqrt(dDecayPath[0]*dDecayPath[0]+dDecayPath[1]*dDecayPath[1]); //transverse path length R
4843     Float_t fROverPt = fDecLen2D/fPtV0; // R/pT
4844
4845     Float_t fMROverPtK0s = fMassK0s*fROverPt; // m*R/pT
4846     Float_t fMROverPtLambda = fMassLambda*fROverPt; // m*R/pT
4847
4848     //___________________
4849     //Double_t fRap = -999;//init values
4850     Double_t fEta = -999;
4851     Double_t fV0cosPointAngle = -999;
4852     Double_t fV0DecayLength = v0->DecayLengthV0(lPrimaryVtxPosition);
4853
4854     Double_t fV0mom[3];
4855
4856     fV0mom[0]=v0->MomV0X();
4857     fV0mom[1]=v0->MomV0Y();
4858     fV0mom[2]=v0->MomV0Z();
4859
4860     Double_t fV0TotalMomentum = TMath::Sqrt(fV0mom[0]*fV0mom[0]+fV0mom[1]*fV0mom[1]+fV0mom[2]*fV0mom[2]);
4861     //  const Double_t K0sPDGmass = 0.497614;
4862     // const Double_t LambdaPDGmass = 1.115683;
4863
4864     const Double_t K0sPDGmass = TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass();
4865     const Double_t LambdaPDGmass = TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass();
4866
4867     Double_t fDistOverTotMomK0s = 0;
4868     Double_t fDistOverTotMomLa = 0;
4869
4870     //calculate proper lifetime of particles in 3D (not recommended anymore)
4871
4872     if(particletype == kK0){
4873
4874       fDistOverTotMomK0s = fV0DecayLength * K0sPDGmass;
4875       fDistOverTotMomK0s /= (fV0TotalMomentum+1e-10);
4876     }
4877
4878     if((particletype == kLambda)||(particletype == kAntiLambda)){
4879
4880       fDistOverTotMomLa = fV0DecayLength * LambdaPDGmass;
4881       fDistOverTotMomLa /= (fV0TotalMomentum+1e-10);
4882     }
4883
4884      //TPC cluster (not used anymore) and TPCRefit cuts
4885
4886     //Double_t trackPosNcls = trackPos->GetTPCNcls();//Get number of clusters for positive charged tracks
4887     //Double_t trackNegNcls = trackNeg->GetTPCNcls();//Get number of clusters for negative charged tracks
4888
4889     if(fRequireTPCRefit==kTRUE){//if kTRUE: accept only if daughter track is refitted in TPC!!
4890       Bool_t isPosTPCRefit = (trackPos->AliAODTrack::IsOn(AliESDtrack::kTPCrefit));
4891       Bool_t isNegTPCRefit = (trackNeg->AliAODTrack::IsOn(AliESDtrack::kTPCrefit));
4892       if (!isPosTPCRefit)continue;
4893       if (!isNegTPCRefit)continue;
4894     }
4895
4896     if(fKinkDaughters==kFALSE){//if kFALSE: no acceptance of kink daughters
4897       AliAODVertex* ProdVtxDaughtersPos = (AliAODVertex*) (trackPos->AliAODTrack::GetProdVertex());
4898       Char_t isAcceptKinkDaughtersPos  = ProdVtxDaughtersPos->GetType();
4899       if(isAcceptKinkDaughtersPos==AliAODVertex::kKink)continue;
4900
4901       AliAODVertex* ProdVtxDaughtersNeg = (AliAODVertex*) (trackNeg->AliAODTrack::GetProdVertex());
4902       Char_t isAcceptKinkDaughtersNeg  = ProdVtxDaughtersNeg->GetType();
4903       if(isAcceptKinkDaughtersNeg==AliAODVertex::kKink)continue;
4904
4905     }
4906
4907     Double_t fV0Radius      = -999;
4908     Double_t fDcaV0Daughters = v0->DcaV0Daughters();
4909     Double_t fDcaPosToPrimVertex = v0->DcaPosToPrimVertex();//IP of positive charged daughter
4910     Double_t fDcaNegToPrimVertex = v0->DcaNegToPrimVertex();//IP of negative charged daughter
4911     Double_t avDecayLengthK0s = 2.6844;
4912     Double_t avDecayLengthLa = 7.89;
4913
4914     //Float_t fCTauK0s = 2.6844; // [cm] c tau of K0S
4915     //Float_t fCTauLambda = 7.89; // [cm] c tau of Lambda and Antilambda
4916
4917     fV0cosPointAngle = v0->CosPointingAngle(lPrimaryVtxPosition);
4918     lV0Position[0]= v0->DecayVertexV0X();
4919     lV0Position[1]= v0->DecayVertexV0Y();
4920     lV0Position[2]= v0->DecayVertexV0Z();
4921
4922     fV0Radius  = TMath::Sqrt(lV0Position[0]*lV0Position[0]+lV0Position[1]*lV0Position[1]);
4923
4924     if(particletype == kK0)         {//fRap = v0->RapK0Short();
4925                                      fEta = v0->PseudoRapV0();}
4926     if(particletype == kLambda)     {//fRap = v0->RapLambda();
4927                                      fEta = v0->PseudoRapV0();}
4928     if(particletype == kAntiLambda) {//fRap = v0->Y(-3122);
4929                                      fEta = v0->PseudoRapV0();}
4930
4931
4932     //cut on 3D DistOverTotMom: (not used anymore)
4933     //if((particletype == kLambda)||(particletype == kAntiLambda)){if(fDistOverTotMomLa >= (fCutV0DecayMax * avDecayLengthLa))  continue;}
4934
4935     //cut on K0s applied below after all other cuts for histo fill purposes..
4936
4937     //cut on 2D DistOverTransMom: (recommended from Iouri)
4938     if((particletype == kLambda)||(particletype == kAntiLambda)){if(fMROverPtLambda > (fCutV0DecayMax * avDecayLengthLa))continue;}//fCutV0DecayMax set to 5 in AddTask macro
4939
4940  //Armenteros Podolanski Plot for K0s:////////////////////////////
4941
4942     Double_t ArmenterosAlpha=-999;
4943     Double_t ArmenterosPt=-999;
4944     Double_t PosPl;
4945     Double_t NegPl;
4946     //Double_t PosPt;
4947     //Double_t NegPt;
4948
4949     if(particletype == kK0){
4950
4951       pp[0]=v0->MomPosX();
4952       pp[1]=v0->MomPosY();
4953       pp[2]=v0->MomPosZ();
4954
4955       pm[0]=v0->MomNegX();
4956       pm[1]=v0->MomNegY();
4957       pm[2]=v0->MomNegZ();
4958
4959
4960       v0mom[0]=v0->MomV0X();
4961       v0mom[1]=v0->MomV0Y();
4962       v0mom[2]=v0->MomV0Z();
4963
4964       TVector3 v0Pos(pp[0],pp[1],pp[2]);
4965       TVector3 v0Neg(pm[0],pm[1],pm[2]);
4966       TVector3 v0totMom(v0mom[0], v0mom[1], v0mom[2]); //vector for tot v0 momentum
4967
4968       //PosPt = v0Pos.Perp(v0totMom);             //longitudinal momentum of positive charged daughter track
4969       PosPl = v0Pos.Dot(v0totMom)/v0totMom.Mag();  //transversal momentum of positive charged daughter track
4970
4971       //NegPt = v0Neg.Perp(v0totMom);             //longitudinal momentum of negative charged daughter track
4972       NegPl = v0Neg.Dot(v0totMom)/v0totMom.Mag();  //transversal momentum of nergative charged daughter track
4973
4974       ArmenterosAlpha = 1.-2./(1+(PosPl/NegPl));
4975       ArmenterosPt= v0->PtArmV0();
4976
4977     }
4978
4979     if(particletype == kK0){//only cut on K0s histos
4980       if(IsArmenterosSelected == 1){// Armenteros Cut to reject Lambdas contamination in K0s inv. massspectrum
4981         fh2ArmenterosBeforeCuts->Fill(ArmenterosAlpha,ArmenterosPt);
4982       }
4983     }
4984
4985     //some more cuts on v0s and daughter tracks:
4986
4987
4988     if((TMath::Abs(PosEta)>fCutPostrackEta) || (TMath::Abs(NegEta)>fCutNegtrackEta))continue;   //Daughters pseudorapidity cut
4989     if (fV0cosPointAngle < fCutV0cosPointAngle) continue;                                       //cospointangle cut
4990
4991     //if(TMath::Abs(fRap) > fCutRap)continue;                                                     //V0 Rapidity Cut
4992     if(TMath::Abs(fEta) > fCutEta) continue;                                                  //V0 Eta Cut
4993     if (fDcaV0Daughters > fCutDcaV0Daughters)continue;
4994     if ((fDcaPosToPrimVertex < fCutDcaPosToPrimVertex) || (fDcaNegToPrimVertex < fCutDcaNegToPrimVertex))continue;
4995     if ((fV0Radius < fCutV0RadiusMin) || (fV0Radius > fCutV0RadiusMax))continue;
4996
4997     const AliAODPid *pid_p1=trackPos->GetDetPid();
4998     const AliAODPid *pid_n1=trackNeg->GetDetPid();
4999
5000
5001       if(particletype == kLambda){
5002         //      if(AcceptBetheBloch(v0, fPIDResponse, 1) == kFALSE){std::cout<<"******PID cut rejects Lambda!!!************"<<std::endl;}
5003         if(AcceptBetheBloch(v0, fPIDResponse, 1) == kFALSE)continue;
5004         fh2BBLaPos->Fill(pid_p1->GetTPCmomentum(),pid_p1->GetTPCsignal());//positive lambda daughter
5005         fh2BBLaNeg->Fill(pid_n1->GetTPCmomentum(),pid_n1->GetTPCsignal());//negative lambda daughter
5006
5007         //Double_t phi = v0->Phi();
5008         //Double_t massLa = v0->MassLambda();
5009
5010         //printf("La: i = %d, m = %f, pT = %f, eta = %f, phi = %f\n, ",i,massLa,trackPt,fEta,phi);
5011
5012       }
5013
5014       if(particletype == kAntiLambda){
5015
5016         if(AcceptBetheBloch(v0, fPIDResponse, 2) == kFALSE)continue;
5017         fh2BBLaPos->Fill(pid_p1->GetTPCmomentum(),pid_p1->GetTPCsignal());//positive antilambda daughter
5018         fh2BBLaNeg->Fill(pid_n1->GetTPCmomentum(),pid_n1->GetTPCsignal());//negative antilambda daughter
5019
5020       }
5021
5022
5023     //Armenteros cut on K0s:
5024     if(particletype == kK0){
5025       if(IsArmenterosSelected == 1){// Armenteros Cut to reject Lambdas contamination in K0s inv. massspectrum
5026
5027         if((ArmenterosPt<=(TMath::Abs(fCutArmenteros*ArmenterosAlpha))) && (fCutArmenteros!=-999))continue; //Cuts out Lambda contamination in K0s histos
5028         fh2ArmenterosAfterCuts->Fill(ArmenterosAlpha,ArmenterosPt);
5029       }
5030     }
5031
5032     //not used anymore in 3D, z component of total momentum has bad resolution, cut instead in 2D and use pT
5033     //Proper Lifetime Cut: DecayLength3D * PDGmass / |p_tot| < 3*2.68cm (ctau(betagamma=1))  ;  |p|/mass = beta*gamma
5034     //////////////////////////////////////////////
5035
5036
5037 //cut on 2D DistOverTransMom
5038     if(particletype == kK0){//the cut on Lambdas you can find above
5039
5040       fh2ProperLifetimeK0sVsPtBeforeCut->Fill(trackPt,fMROverPtK0s); //fill these histos after all other cuts
5041       if(fMROverPtK0s > (fCutV0DecayMax * avDecayLengthK0s))continue;
5042       fh2ProperLifetimeK0sVsPtAfterCut->Fill(trackPt,fMROverPtK0s);
5043
5044       //Double_t phi = v0->Phi();
5045       // Double_t massK0s = v0->MassK0Short();
5046       //printf("K0S: i = %d, m = %f, pT = %f, eta = %f, phi = %f\n",i,invMK0s,trackPt,fEta,phi);
5047
5048       //test std::cout<<" Index accepted K0s candidate in list of V0s in event: "<<i<<" m: "<<invMK0s<<" pT: "<<trackPt<<" eta: "<<fEta<<" phi: "<<v0->Phi()<<std::endl;
5049
5050     }
5051     //MC Associated V0 particles: (reconstructed particles associated with MC truth (MC truth: true primary MC generated particle))
5052
5053
5054     if(fAnalysisMC){// begin MC part
5055
5056       Int_t negDaughterpdg = 0;
5057       Int_t posDaughterpdg = 0;
5058       Int_t v0Label = -1;
5059       Bool_t fPhysicalPrimary = -1;   //v0 physical primary check
5060       Int_t MCv0PdgCode = 0;
5061       Bool_t mclabelcheck = kFALSE;
5062
5063       TList *listmc = aod->GetList(); //AliAODEvent* is inherited from AliVEvent*, listmc is pointer to reconstructed event in MC list, member of AliAODEvent
5064
5065       if(!listmc)continue;
5066
5067       if((particletype == kLambda) || (particletype == kAntiLambda)){// at this point the v0 candidates already survived all V0 cuts, for the MC analysis they still have to survive the association checks in the following block
5068
5069         //feeddown-correction for Lambda/Antilambda particles
5070         //feedddown comes mainly from charged and neutral Xi particles
5071         //feeddown from Sigma decays so quickly that it's not possible to distinguish from primary Lambdas with detector
5072         //feeddown for K0s from phi decays is neglectible
5073         //TH2F* fh2FeedDownMatrix = 0x0; //histo for feeddown already decleared above
5074
5075
5076         //first for all Lambda and Antilambda candidates____________________________________________________________________
5077         TString generatorName;
5078         Bool_t isinjected;
5079         if(particletype == kLambda){
5080
5081           mclabelcheck = MCLabelCheck(v0, kLambda, trackNeg, trackPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PdgCode, generatorName, isinjected);
5082
5083
5084           if((motherType == 3312)||(motherType == 3322)){//mother of v0 is neutral or negative Xi
5085
5086             fListFeeddownLaCand->Add(v0); //fill TList with ass. particles, stemming from feeddown from Xi(bar) decays
5087           }
5088         }
5089
5090         if(particletype == kAntiLambda){
5091
5092           mclabelcheck = MCLabelCheck(v0, kAntiLambda, trackNeg, trackPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PdgCode, generatorName, isinjected);
5093
5094           if((motherType == -3312)||(motherType == -3322)){
5095             fListFeeddownALaCand->Add(v0); //fill TList with ass. particles, stemming from feeddown from Xi(bar) decays
5096           }
5097         }
5098       }
5099
5100
5101       //_only true primary particles survive the following checks_______________________________________________________________________________________________
5102       TString generatorName;
5103           Bool_t isinjected;
5104       if(particletype == kK0){
5105
5106         mclabelcheck = MCLabelCheck(v0, kK0, trackNeg, trackPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PdgCode, generatorName, isinjected);
5107         if(mclabelcheck == kFALSE)continue;
5108       }
5109       if(particletype == kLambda){
5110
5111         mclabelcheck = MCLabelCheck(v0, kLambda, trackNeg, trackPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PdgCode, generatorName, isinjected);
5112         if(mclabelcheck == kFALSE)continue;
5113       }
5114       if(particletype == kAntiLambda){
5115
5116         mclabelcheck = MCLabelCheck(v0, kAntiLambda, trackNeg, trackPos, listmc, negDaughterpdg, posDaughterpdg, motherType, v0Label, MCPt, fPhysicalPrimary, MCv0PdgCode, generatorName, isinjected);
5117         if(mclabelcheck == kFALSE)continue;
5118       }
5119
5120       if(fPhysicalPrimary != 1)continue; //V0 candidate (K0s, Lambda or Antilambda) must be physical primary, this means there is no mother particle existing
5121
5122     }
5123
5124
5125     list->Add(v0);
5126
5127   }
5128
5129   Int_t nPart=list->GetSize();
5130
5131   return nPart;
5132 } // end GetListOfV0s()
5133
5134 // -------------------------------------------------------------------------------------------------------
5135
5136 void AliAnalysisTaskJetChem::CalculateInvMass(AliAODv0* v0vtx, const Int_t particletype, Double_t& invM, Double_t& trackPt){
5137
5138    //particletype:
5139    // * kaon = 1
5140    // * lambda = 2
5141    // * antilambda = 3
5142
5143      invM    = 0;
5144      trackPt = 0;
5145
5146      Double_t pp[3]={0,0,0}; //3-momentum positive charged track
5147      Double_t pm[3]={0,0,0}; //3-momentum negative charged track
5148
5149      const Double_t massPi = 0.13957018; //better use PDG code at this point
5150      const Double_t massP  = 0.93827203;
5151
5152      Double_t mass1=0;
5153      Double_t mass2=0;
5154
5155      TLorentzVector vector;  //lorentzvector V0 particle
5156      TLorentzVector fourmom1;//lorentzvector positive daughter
5157      TLorentzVector fourmom2;//lorentzvector negative daughter
5158
5159    //--------------------------------------------------------------
5160
5161    AliAODTrack *trackPos = (AliAODTrack *) (v0vtx->GetSecondaryVtx()->GetDaughter(0));//index 0 defined as positive charged track in AliESDFilter
5162
5163    if( trackPos->Charge() == 1 ){
5164
5165      pp[0]=v0vtx->MomPosX();
5166      pp[1]=v0vtx->MomPosY();
5167      pp[2]=v0vtx->MomPosZ();
5168
5169      pm[0]=v0vtx->MomNegX();
5170      pm[1]=v0vtx->MomNegY();
5171      pm[2]=v0vtx->MomNegZ();
5172    }
5173
5174    if( trackPos->Charge() == -1 ){
5175
5176      pm[0]=v0vtx->MomPosX();
5177      pm[1]=v0vtx->MomPosY();
5178      pm[2]=v0vtx->MomPosZ();
5179
5180      pp[0]=v0vtx->MomNegX();
5181      pp[1]=v0vtx->MomNegY();
5182      pp[2]=v0vtx->MomNegZ();
5183    }
5184
5185    if (particletype == kK0){ // case K0s
5186      mass1 = massPi;//positive particle
5187      mass2 = massPi;//negative particle
5188    } else if (particletype == kLambda){ // case Lambda
5189      mass1 = massP;//positive particle
5190      mass2 = massPi;//negative particle
5191    } else if (particletype == kAntiLambda){ //case AntiLambda
5192      mass1 = massPi;//positive particle
5193      mass2 = massP; //negative particle
5194    }
5195
5196    fourmom1.SetXYZM(pp[0],pp[1],pp[2],mass1);//positive track
5197    fourmom2.SetXYZM(pm[0],pm[1],pm[2],mass2);//negative track
5198    vector=fourmom1 + fourmom2;
5199
5200    invM    = vector.M();
5201    trackPt = vector.Pt();
5202
5203    /*// don't apply AliAODv0 methods to get the inv. mass for the OnFly finder, since the daughter labels are sometimes switched!!!! For Offline V0 finder no problem
5204
5205    if(particletype == kK0){
5206      std::cout << "invMK0s: " << invM <<std::endl;
5207      std::cout << "v0vtx->MassK0Short(): " << v0vtx->MassK0Short() << std::endl;
5208      std::cout << "    " <<std::endl;
5209      //invM = v0vtx->MassK0Short();
5210    }
5211
5212    if(particletype == kLambda){
5213      std::cout << "invMLambda: " << invM <<std::endl;
5214      std::cout << "v0vtx->MassMassLambda(): " << v0vtx->MassLambda() << std::endl;
5215      std::cout << "    " <<std::endl;
5216     //invM = v0vtx->MassLambda();
5217    }
5218
5219    if(particletype == kAntiLambda){
5220      std::cout << "invMAntiLambda: " << invM <<std::endl;
5221      std::cout << "v0vtx->MassAntiLambda(): " << v0vtx->MassAntiLambda() << std::endl;
5222      std::cout << "    " <<std::endl;
5223      //invM = v0vtx->MassAntiLambda();
5224    }
5225    */
5226
5227    return;
5228 }
5229
5230
5231 //_____________________________________________________________________________________
5232 Int_t AliAnalysisTaskJetChem::GetListOfMCParticles(TList *outputlist, const Int_t particletype, AliAODEvent *mcaodevent) //(list to fill here e.g. fListMCgenK0s, particle species to search for)
5233 {
5234
5235   outputlist->Clear();
5236
5237   TClonesArray *stack = 0x0;
5238   Double_t mcXv=0., mcYv=0., mcZv=0.;//MC vertex position
5239   Int_t ntrk =0;
5240
5241   // get MC generated particles
5242
5243   Int_t fPdgcodeCurrentPart = 0; //pdg code current particle
5244   //Double_t fRapCurrentPart  = 0; //get rapidity
5245   //Double_t fPtCurrentPart   = 0; //get transverse momentum
5246   Double_t fEtaCurrentPart = 0;  //get pseudorapidity
5247
5248   //variable for check: physical primary particle
5249   //Bool_t IsPhysicalPrimary = -1;
5250   //Int_t index = 0; //check number of injected particles
5251   //****************************
5252   // Start loop over MC particles
5253
5254   TList *lst = mcaodevent->GetList();
5255
5256   if(!lst){
5257     if(fDebug>1) Printf("%s:%d no input list", (char*)__FILE__,__LINE__);
5258     return -1;
5259   }
5260
5261   stack = (TClonesArray*)lst->FindObject(AliAODMCParticle::StdBranchName());
5262   if (!stack) {
5263     Printf("ERROR: stack not available");
5264     return -1;
5265   }
5266
5267   AliAODMCHeader *mcHdr=(AliAODMCHeader*)lst->FindObject(AliAODMCHeader::StdBranchName());
5268   if(!mcHdr)return -1;
5269
5270   mcXv=mcHdr->GetVtxX(); mcYv=mcHdr->GetVtxY(); mcZv=mcHdr->GetVtxZ(); // position of the MC primary vertex
5271
5272
5273   ntrk=stack->GetEntriesFast();
5274
5275   //if(TMath::Abs(mcZv)>10)return; //i also cut at the reconstructed particles - here i also want to cut for a second time on z vertex (?) -> could be possible bias because of resolution effects on edges of acceptance, also the case for pseudorapidity...
5276
5277
5278   for (Int_t iMc = 0; iMc < ntrk; iMc++) {                                             //loop over mc generated particles
5279
5280
5281     AliAODMCParticle *p0=(AliAODMCParticle*)stack->UncheckedAt(iMc);
5282     if (!p0) {
5283       //Printf("ERROR: particle with label %d not found in stack (mc loop)", iMc);
5284       continue;
5285     }
5286     fPdgcodeCurrentPart = p0->GetPdgCode();
5287
5288     // Keep only K0s, Lambda and AntiLambda, Xi and Phi:
5289     //if ( (fPdgcodeCurrentPart != 310 ) && (fPdgcodeCurrentPart != 3122 ) && (fPdgcodeCurrentPart != -3122 ) && (fPdgcodeCurrentPart != 3312 ) && (fPdgcodeCurrentPart != -3312) && (fPdgcodeCurrentPart != -333) ) continue;
5290
5291
5292
5293       //Rejection of Pythia injected particles with David Chinellatos method - not the latest method, better Method with TString from MC generator in IsInjected() function below!
5294
5295     /*     if( (p0->GetStatus()==21) ||
5296           ((p0->GetPdgCode() == 443) &&
5297            (p0->GetMother() == -1) &&
5298            (p0->GetDaughter(0) == (iMc))) ){ index++; }
5299
5300       if(p0->GetStatus()==21){std::cout<< "hello !!!!" <<std::endl;}
5301
5302       std::cout<< "MC particle status:  " << p0->GetStatus() <<std::endl;
5303     */
5304
5305
5306       //if(index>=1){std::cout<< "MC particle status:  " << p0->GetStatus() <<std::endl;}//if first injected MC particle was found, the Status is printed out for this and every following MC particle
5307
5308
5309         //injected particles could be from GenBox (single high pt tracks) or jet related tracks, both generated from PYTHIA MC generator
5310
5311       //Check: MC particle mother
5312
5313       //for feed-down checks
5314       /* //MC gen particles
5315         Int_t iMother = p0->GetMother(); //Motherparticle of V0 candidate (e.g. phi particle,..)
5316            if(iMother >= 0){
5317         AliAODMCParticle *partM = (AliAODMCParticle*)stack->UncheckedAt(iMother);
5318         Int_t codeM = -1;
5319         if(partM) codeM = TMath::Abs(partM->GetPdgCode());
5320
5321
5322          3312    Xi-                       -3312    Xibar+
5323          3322    Xi0                       -3322    Xibar0
5324
5325
5326         if((codeM == 3312)||(codeM == 3322))// feeddown for Lambda coming from Xi- and Xi0
5327
5328
5329
5330            }
5331         */
5332            /*   //Check: MC gen. particle decays via 2-pion decay? -> only to be done for the rec. particles !! (-> branching ratio ~ 70 % for K0s -> pi+ pi-)
5333
5334         Int_t daughter0Label = p0->GetDaughter(0);
5335         AliAODMCParticle *mcDaughter0 = (AliAODMCParticle *)stack->UncheckedAt(daughter0Label);
5336       if(daughter0Label >= 0)
5337         {daughter0Type = mcDaughter0->GetPdgCode();}
5338
5339       Int_t daughter1Label = p0->GetDaughter(1);
5340       AliAODMCParticle *mcDaughter1 = (AliAODMCParticle *)stack->UncheckedAt(daughter1Label);
5341
5342       if(daughter1Label >= 1)
5343         {daughter1Type = mcDaughter1->GetPdgCode();}    //requirement that daughters are pions is only done for the reconstructed V0s in GetListofV0s() below
5344     }
5345            */
5346
5347
5348       // Keep only K0s, Lambda and AntiLambda:
5349       if ( (fPdgcodeCurrentPart != 310 ) && (fPdgcodeCurrentPart != 3122 ) && (fPdgcodeCurrentPart != -3122 )) continue;
5350       // Check: Is physical primary
5351
5352       //do not use anymore: //IsPhysicalPrimary = p0->IsPhysicalPrimary();
5353       //if(!IsPhysicalPrimary)continue;
5354
5355       Float_t fDistPrimaryMax = 0.01; // [cm] max distance of production point to the primary vertex (criterion for choice of MC particles considered as primary)
5356
5357       // Get the distance between production point of the MC mother particle and the primary vertex
5358
5359       Double_t dx = mcXv-p0->Xv();//mc primary vertex - mc gen. v0 vertex
5360       Double_t dy = mcYv-p0->Yv();
5361       Double_t dz = mcZv-p0->Zv();
5362
5363       Double_t fDistPrimary = TMath::Sqrt(dx*dx + dy*dy + dz*dz);
5364       Bool_t fPhysicalPrimary = (fDistPrimary < fDistPrimaryMax);
5365
5366       if(!fPhysicalPrimary)continue;
5367
5368       //if(fPhysicalPrimary){std::cout<<"hello**********************"<<std::endl;}
5369
5370       /* std::cout<<"dx: "<<dx<<std::endl;
5371       std::cout<<"dy: "<<dy<<std::endl;
5372       std::cout<<"dz: "<<dz<<std::endl;
5373
5374       std::cout<<"start: "<<std::endl;
5375       std::cout<<"mcXv: "<<mcXv<<std::endl;
5376       std::cout<<"mcYv: "<<mcYv<<std::endl;
5377       std::cout<<"mcZv: "<<mcZv<<std::endl;
5378
5379       std::cout<<"p0->Xv(): "<<p0->Xv()<<std::endl;
5380       std::cout<<"p0->Yv(): "<<p0->Yv()<<std::endl;
5381       std::cout<<"p0->Zv(): "<<p0->Zv()<<std::endl;
5382       std::cout<<" "<<std::endl;
5383       std::cout<<"fDistPrimary"<<fDistPrimary<<std::endl;
5384       std::cout<<"fPhysicalPrimary"<<fPhysicalPrimary<<std::endl;
5385       */
5386
5387       //Is close enough to primary vertex to be considered as primary-like?
5388
5389       //fRapCurrentPart   = MyRapidity(p0->E(),p0->Pz());
5390       fEtaCurrentPart   = p0->Eta();
5391       //fPtCurrentPart    = p0->Pt();
5392
5393       if (TMath::Abs(fEtaCurrentPart) < fCutEta){
5394         // if (TMath::Abs(fRapCurrentPart) > fCutRap)continue;    //rap cut for crosschecks
5395
5396         if(particletype == kK0){                                      //MC gen. K0s
5397           if (fPdgcodeCurrentPart==310){
5398             outputlist->Add(p0);
5399           }
5400         }
5401
5402     if(particletype == kLambda){                                //MC gen. Lambdas
5403       if (fPdgcodeCurrentPart==3122)  {
5404         outputlist->Add(p0);
5405       }
5406     }
5407
5408     if(particletype == kAntiLambda){
5409       if (fPdgcodeCurrentPart==-3122) {                         //MC gen. Antilambdas
5410         outputlist->Add(p0);
5411       }
5412     }
5413   }
5414
5415   }//end  loop over MC generated particle
5416
5417   Int_t nMCPart=outputlist->GetSize();
5418
5419
5420   return nMCPart;
5421
5422 }
5423
5424 //---------------------------------------------------------------------------
5425 /*
5426 Bool_t AliAnalysisTaskJetChem::FillFeeddownMatrix(TList* fListFeeddownCand, Int_t particletype)
5427 {
5428
5429         // Define Feeddown matrix
5430         Double_t lFeedDownMatrix [100][100];
5431         // FeedDownMatrix [Lambda Bin][Xi Bin];
5432
5433         //Initialize entries of matrix:
5434         for(Int_t ilb = 0; ilb<100; ilb++){
5435           for(Int_t ixb = 0; ixb<100; ixb++){
5436             lFeedDownMatrix[ilb][ixb]=0; //first lambda bins, xi bins
5437           }
5438         }
5439 }
5440 */
5441 //----------------------------------------------------------------------------
5442
5443 Double_t AliAnalysisTaskJetChem::MyRapidity(Double_t rE, Double_t rPz) const
5444 {
5445   // Local calculation for rapidity
5446   return 0.5*TMath::Log((rE+rPz)/(rE-rPz+1.e-13));
5447 }
5448 //----------------------------------------------------------------------------
5449
5450
5451 void AliAnalysisTaskJetChem::GetTracksInCone(TList* inputlist, TList* outputlist, const AliAODJet* jet,
5452                                                                 const Double_t radius, Double_t& sumPt, const Double_t minPt, const Double_t maxPt, Bool_t& isBadPt)
5453 {
5454   // fill list of V0 tracks in cone around jet axis
5455
5456   sumPt = 0;
5457   Bool_t isBadMaxPt = kFALSE;
5458   Bool_t isBadMinPt = kTRUE;
5459
5460   Double_t jetMom[3];
5461   if(!jet)return;
5462   jet->PxPyPz(jetMom);
5463   TVector3 jet3mom(jetMom);
5464
5465   //if(jetets < jetetscutr)continue;
5466
5467   for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){//loop over all K0s found in event
5468
5469     AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack));
5470     if(!track)continue;
5471     Double_t trackMom[3];
5472     track->PxPyPz(trackMom);
5473     TVector3 track3mom(trackMom);
5474
5475     Double_t dR = jet3mom.DeltaR(track3mom);
5476
5477     if(dR<radius){//fill all the V0s inside cone into outputlist, radius is reutrn value of GetFFRadius()
5478
5479       outputlist->Add(track);
5480
5481       sumPt += track->Pt();
5482
5483       if(maxPt>0 && track->Pt()>maxPt) isBadMaxPt = kTRUE;   // reject jets containing any track with pt larger than this value, use GetFFMaxTrackPt()
5484       if(minPt>0 && track->Pt()>minPt) isBadMinPt = kFALSE;  // reject jets with leading track with pt smaller than this value, use GetFFMinLTrackPt()
5485
5486     }
5487   }
5488
5489   isBadPt = kFALSE;
5490   if(minPt>0 && isBadMinPt) isBadPt = kTRUE; //either the jet is bad because of too small leading track pt.. (probability to be purely combinatorial jet is too high to accept it)
5491   if(maxPt>0 && isBadMaxPt) isBadPt = kTRUE; //..or because of leading track with too high pt (could be fake track)
5492
5493   outputlist->Sort();
5494
5495 }
5496
5497 //____________________________________________________________________________________________________________________
5498
5499
5500 void AliAnalysisTaskJetChem::GetTracksInPerpCone(TList* inputlist, TList* outputlist, const AliAODJet* jet,
5501                                                                 const Double_t radius, Double_t& sumPerpPt)
5502 {
5503   // fill list of tracks in two cones around jet axis rotated in phi +/- 90 degrees
5504
5505   Double_t jetMom[3];             //array for entries in TVector3
5506   Double_t perpjetplusMom[3];     //array for entries in TVector3
5507   Double_t perpjetnegMom[3];
5508
5509   if(!jet)return;
5510
5511   jet->PxPyPz(jetMom);   //get 3D jet momentum
5512   Double_t jetPerpPt = jet->Pt(); //original jet pt, invariant under rotations
5513   Double_t jetPhi = jet->Phi(); //original jet phi
5514
5515   Double_t jetPerpposPhi = jetPhi + ((TMath::Pi())*0.5);//get new perp. jet axis phi clockwise
5516   Double_t jetPerpnegPhi = jetPhi - ((TMath::Pi())*0.5);//get new perp. jet axis phi counterclockwise
5517
5518   TVector3 jet3mom(jetMom); //3-Vector for original rec. jet axis
5519
5520   //Double_t phitest  = jet3mom.Phi();
5521
5522   perpjetplusMom[0]=(TMath::Cos(jetPerpposPhi)*jetPerpPt); //x coordinate (sidewards - when looking in beam direction)
5523   perpjetplusMom[1]=(TMath::Sin(jetPerpposPhi)*jetPerpPt); //y coordinate (upwards - when looking in beam direction)
5524   perpjetplusMom[2]=jetMom[2];                          //z coordinate (along beam axis), invariant under azimuthal rotation
5525
5526   perpjetnegMom[0]=(TMath::Cos(jetPerpnegPhi)*jetPerpPt); //x coordinate (sidewards - when looking in beam direction)
5527   perpjetnegMom[1]=(TMath::Sin(jetPerpnegPhi)*jetPerpPt); //y coordinate (upwards - when looking in beam direction)
5528   perpjetnegMom[2]=jetMom[2];                          //z coordinate (along beam axis), invariant under azimuthal rotation
5529
5530
5531   TVector3 perpjetplus3mom(perpjetplusMom);  //3-Vector for new perp. jet axis, clockwise rotated
5532   TVector3 perpjetneg3mom(perpjetnegMom);    //3-Vector for new perp. jet axis, counterclockwise rotated
5533
5534   //for crosscheck TVector3 rotation method
5535
5536   //Double_t jetMomplusTest[3];
5537   //Double_t jetMomminusTest[3];
5538
5539   //jet3mom.RotateZ(TMath::Pi()*0.5);//rotate original jet axis around +90 degrees in phi
5540
5541   //perpjetminus3momTest  = jet3mom.RotateZ((-1)*TMath::Pi()*0.5);
5542
5543   // jet3mom.RotateZ(TMath::Pi()*0.5);
5544   // jet3mom.RotateZ((-1)*TMath::Pi()*0.5);
5545
5546   //jetMomplusTest[0] = jet3mom.X();  //fetching perp. axis coordinates
5547   //jetMomplusTest[1] = jet3mom.Y();
5548   //jetMomplusTest[2] = jet3mom.Z();
5549
5550   //TVector3 perpjetplus3momTest(jetMomplusTest);   //new TVector3 for +90deg rotated jet axis with rotation method from ROOT
5551   //TVector3 perpjetminus3momTest(jetMomminusTest);   //new TVector3 for -90deg rotated jet axis with rotation method from ROOT
5552
5553
5554   for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){ //collect V0 content in perp cone, rotated clockwise
5555
5556     AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack)); //inputlist is fListK0s, all reconstructed K0s in event
5557     if(!track){std::cout<<"K0s track not found!!!"<<std::endl; continue;}
5558
5559     Double_t trackMom[3];//3-mom of V0 particle
5560     track->PxPyPz(trackMom);
5561     TVector3 track3mom(trackMom);
5562
5563     Double_t dR = perpjetplus3mom.DeltaR(track3mom);
5564
5565     if(dR<radius){
5566
5567       outputlist->Add(track); // output list is jetPerpConeK0list
5568
5569       sumPerpPt += track->Pt();
5570
5571
5572     }
5573   }
5574
5575
5576   for (Int_t itrack=0; itrack<inputlist->GetSize(); itrack++){//collect V0 content in perp cone, rotated counterclockwise
5577
5578     AliVParticle* track = dynamic_cast<AliVParticle*>(inputlist->At(itrack)); //inputlist is fListK0s, all reconstructed K0s in event
5579     if(!track){std::cout<<"K0s track not found!!!"<<std::endl; continue;}
5580
5581     Double_t trackMom[3];//3-mom of V0 particle
5582     track->PxPyPz(trackMom);
5583     TVector3 track3mom(trackMom);
5584
5585     Double_t dR = perpjetneg3mom.DeltaR(track3mom);
5586
5587     if(dR<radius){
5588
5589       outputlist->Add(track); // output list is jetPerpConeK0list
5590
5591       sumPerpPt += track->Pt();
5592
5593
5594     }
5595   }
5596
5597   // pay attention: this list contains the double amount of V0s, found in both cones
5598   // before using it, devide spectra by 2!!!
5599   sumPerpPt = sumPerpPt*0.5; //correct to do this?
5600
5601
5602   outputlist->Sort();
5603
5604 }
5605
5606
5607 // _______________________________________________________________________________________________________________________________________________________
5608
5609 Bool_t AliAnalysisTaskJetChem::MCLabelCheck(AliAODv0* v0, Int_t particletype,const AliAODTrack* trackNeg, const AliAODTrack* trackPos, TList *listmc, Int_t& negDaughterpdg, Int_t& posDaughterpdg, Int_t& motherType, Int_t& v0Label, Double_t& MCPt, Bool_t& fPhysicalPrimary, Int_t& MCv0PDGCode, TString& generatorName, Bool_t& isinjected){
5610
5611   if(!v0)return kFALSE;
5612
5613   TClonesArray *stackmc = 0x0;
5614   stackmc = (TClonesArray*)listmc->FindObject(AliAODMCParticle::StdBranchName()); //get MCAOD branch in data
5615   if (!stackmc)
5616     {
5617       Printf("ERROR: stack not available");
5618       return kFALSE;
5619     }
5620   else
5621     {
5622       Int_t negAssLabel = TMath::Abs(trackNeg->GetLabel());                       //negative (reconstructed) charged track label in MC stack
5623       Int_t posAssLabel = TMath::Abs(trackPos->GetLabel());                       //positive (reconstructed) charged track label in MC stack
5624
5625       //injected particle checks
5626
5627       Double_t mcXv = 0;
5628       Double_t mcYv = 0;
5629       Double_t mcZv = 0;
5630
5631       AliAODMCHeader *header=(AliAODMCHeader*)listmc->FindObject(AliAODMCHeader::StdBranchName());
5632       if(!header)return kFALSE;
5633
5634       mcXv=header->GetVtxX(); mcYv=header->GetVtxY(); mcZv=header->GetVtxZ();
5635
5636
5637
5638       //mc label checks
5639
5640       if(negAssLabel>=0 && negAssLabel < stackmc->GetEntriesFast() && posAssLabel>=0 && posAssLabel < stackmc->GetEntriesFast()){//safety check if label has valid value of stack
5641
5642         AliAODMCParticle *mcNegPart =(AliAODMCParticle*)stackmc->UncheckedAt(negAssLabel);//fetch the, with one MC truth track associated (reconstructed), negative charged track
5643         v0Label = mcNegPart->GetMother();// mother of negative charged particle is v0, get v0 label here
5644         negDaughterpdg = mcNegPart->GetPdgCode();
5645         AliAODMCParticle *mcPosPart =(AliAODMCParticle*)stackmc->UncheckedAt(posAssLabel);//fetch the, with one MC truth track associated (reconstructed), positive charged track
5646         Int_t v0PosLabel = mcPosPart->GetMother();                                        //get mother label of positive charged track label
5647         posDaughterpdg = mcPosPart->GetPdgCode();
5648
5649         if(v0Label >= 0 && v0Label < stackmc->GetEntriesFast() && v0Label == v0PosLabel){//first v0 mc label check, then: check if both daughters are stemming from same particle
5650
5651           AliAODMCParticle *mcv0 = (AliAODMCParticle *)stackmc->UncheckedAt(v0Label);  //fetch MC ass. particle to v0 (mother of the both charged daughter tracks)
5652
5653           Float_t fDistPrimaryMax = 0.01; // [cm] max distance of production point to the primary vertex (criterion for choice of MC particles considered as primary)
5654
5655           // Get the distance between production point of the MC mother particle and the primary vertex
5656
5657           Double_t dx = mcXv-mcv0->Xv();//mc primary vertex - mc particle production vertex
5658           Double_t dy = mcYv-mcv0->Yv();
5659           Double_t dz = mcZv-mcv0->Zv();
5660
5661           Float_t fDistPrimary = TMath::Sqrt(dx*dx + dy*dy + dz*dz);
5662           fPhysicalPrimary = kFALSE;//init
5663
5664           fPhysicalPrimary = (fDistPrimary < fDistPrimaryMax);
5665           MCv0PDGCode = mcv0->GetPdgCode();
5666
5667           //if(fPhysicalPrimary == kTRUE){//look only at physical primary particles
5668
5669           isinjected = IsTrackInjected(v0Label, header, stackmc, generatorName);
5670
5671             //trackinjected is kFALSE if it is either Hijing or has no generator name
5672             // std::cout<<" "<<std::endl;
5673             // std::cout<<"#### next particle: ####"<<std::endl;
5674             //std::cout<<"Is track injected: "<< trackinjected <<std::endl;
5675             // std::cout<<"pdg code: "<<MCv0PDGCode<<std::endl;
5676             // std::cout<<"v0Label: "<<v0Label<<std::endl;
5677
5678           MCPt = mcv0->Pt();//for MC data, always use MC gen. pt for any pt distributions, also for the spectra, used for normalisation
5679           //for feed-down checks later
5680
5681           Int_t motherLabel = mcv0->GetMother();  //get mother particle label of v0 particle
5682           // std::cout<<"motherLabel: "<<motherLabel<<std::endl;
5683
5684           if(motherLabel >= 0 && v0Label < stackmc->GetEntriesFast())                 //do safety check for mother label
5685             {
5686               AliAODMCParticle *mcMother = (AliAODMCParticle *)stackmc->UncheckedAt(motherLabel);  //get mother particle
5687               motherType = mcMother->GetPdgCode(); //get PDG code of mother
5688
5689               Double_t XiPt = 0.;
5690               Double_t XibarPt = 0.;
5691
5692               if(particletype == kLambda){
5693                 if((motherType == 3312)||(motherType == 3322)){ //if v0 mother is Xi0 or Xi- fill MC gen. pt in FD La histogram
5694                   XiPt = mcMother->Pt();
5695                   fh1MCXiPt->Fill(XiPt);
5696                 }
5697               }
5698               if(particletype == kAntiLambda){
5699                 if((motherType == -3312)||(motherType == -3322)){ //if v0 mother is Xibar0 or Xibar+ fill MC gen. pt in FD ALa histogram
5700                   XibarPt = mcMother->Pt();
5701                   fh1MCXibarPt->Fill(XibarPt);
5702                 }
5703                 }
5704
5705             }
5706
5707           //pdg code checks etc..
5708
5709           if(particletype == kK0){
5710
5711                if(TMath::Abs(posDaughterpdg) != 211){return kFALSE;}//one or both of the daughters are not a pion
5712                if(TMath::Abs(negDaughterpdg) != 211){return kFALSE;}
5713
5714                if(MCv0PDGCode != 310)  {return kFALSE;}
5715              }
5716
5717              if(particletype == kLambda){
5718                if(MCv0PDGCode != 3122)return kFALSE;//if particle is not Antilambda, v0 is rejected
5719                if(posDaughterpdg != 2212)return kFALSE;
5720                if(negDaughterpdg != -211)return kFALSE;    //pdg code check for Lambda daughters
5721
5722                //{if((motherType == 3312)||(motherType == 3322)){continue;}//if Xi0 and Xi- is motherparticle of Lambda, particle is rejected, pay attention, most possible Xi-, Xi0 and Omega- are not distributed physically and are much more abundant than expected by physics       //}
5723              }
5724
5725              if(particletype == kAntiLambda){
5726                if(MCv0PDGCode != -3122)return kFALSE;
5727                if(posDaughterpdg != 211)return kFALSE;
5728                if(negDaughterpdg !=-2212)return kFALSE;    //pdg code check for Antilambda daughters
5729
5730
5731                //{if((motherType == -3312)||(motherType == -3322)){continue;}//if bar{Xi0} and Xi+ is motherparticle of Antilambda, particle is rejected
5732                //}
5733              }
5734
5735              return kTRUE;                     //check was successful
5736            }//end mc v0 label check
5737       }// end of stack label check
5738     }//end of else
5739
5740
5741
5742   return kFALSE;                               //check wasn't successful
5743 }
5744 //________________________________________________________________________________________________________________________________________________________
5745
5746
5747 Bool_t AliAnalysisTaskJetChem::IsParticleMatching(const AliAODMCParticle* mcp0, const Int_t v0Label){
5748
5749   const Int_t mcp0label = mcp0->GetLabel();
5750
5751   if(v0Label == mcp0label)return kTRUE;
5752
5753   return kFALSE;
5754 }
5755
5756 //_______________________________________________________________________________________________________________________________________________________
5757
5758 Bool_t AliAnalysisTaskJetChem::DaughterTrackCheck(AliAODv0* v0, Int_t& nnum, Int_t& pnum){
5759
5760
5761   if(v0->GetNDaughters() != 2) return kFALSE;//case v0 has more or less than 2 daughters, avoids seg. break at some AOD files                                   //reason?
5762
5763
5764   // safety check of input parameters
5765   if(v0 == NULL)
5766     {
5767       if(fDebug > 1){std::cout << std::endl
5768                 << "Warning in AliAnalysisTaskJetChem::DaughterTrackCheck:" << std::endl
5769                            << "v0 = " << v0 << std::endl;}
5770
5771       return kFALSE;
5772     }
5773   else
5774     {
5775       //Daughters track check: its Luke Hanrattys method to check daughters charge
5776
5777       nnum = 1;
5778       pnum = 0;
5779
5780
5781       AliAODTrack *ntracktest =(AliAODTrack*)(v0->GetDaughter(nnum));
5782
5783       if(ntracktest == NULL)
5784         {
5785           if(fDebug > 1){std::cout << std::endl
5786                     << "Warning in AliAnalysisTaskJetChem::DaughterTrackCheck:" << std::endl
5787                          << "ntracktest = " << ntracktest << std::endl;}
5788
5789           return kFALSE;
5790         }
5791
5792       if(ntracktest->Charge() > 0)
5793         {
5794           nnum = 0;
5795           pnum = 1;
5796         }
5797
5798       const AliAODTrack *trackNeg=(AliAODTrack *)(v0->GetDaughter(nnum));
5799       const AliAODTrack *trackPos=(AliAODTrack *)(v0->GetDaughter(pnum));
5800
5801       //Check if both tracks are available
5802       if (!trackPos || !trackNeg) {
5803         if(fDebug > 1) Printf("strange analysis::UserExec:: Error:Could not retrieve one of the daughter tracks\n");
5804         return kFALSE;
5805       }
5806
5807
5808       //remove like sign V0s
5809       if ( trackPos->Charge() == trackNeg->Charge() ){
5810         //if(fDebug>1) Printf("%s:%d found like-sign V0", (char*)__FILE__,__LINE__);
5811         return kFALSE;
5812       }
5813
5814       return kTRUE;
5815     }
5816 }
5817
5818 //______________________________________________________________________
5819 TString AliAnalysisTaskJetChem::GetGenerator(Int_t label, AliAODMCHeader* header){
5820   Int_t nsumpart=0;//number of particles
5821   TList *lh=header->GetCocktailHeaders();//TList with all generator headers
5822   Int_t nh=lh->GetEntries();//number of entries in TList with all headers
5823
5824    for(Int_t i=0;i<nh;i++){
5825      AliGenEventHeader* gh=(AliGenEventHeader*)lh->At(i);
5826      TString genname=gh->GetName();//name of particle generator
5827      Int_t npart=gh->NProduced();//number of stable or undecayed particles in MC stack block (?)
5828      if(label>=nsumpart && label<(nsumpart+npart)) return genname;
5829      nsumpart+=npart;
5830    }
5831    TString empty="";
5832    return empty;
5833  }
5834
5835 //_____________________________________________________________________
5836 void AliAnalysisTaskJetChem::GetTrackPrimaryGenerator(Int_t lab, AliAODMCHeader *header,TClonesArray *arrayMC,TString &nameGen){
5837
5838   // method to check if a particle is stemming from a given generator
5839
5840   nameGen=GetGenerator(lab,header);
5841
5842   //  Int_t countControl=0;
5843
5844   while(nameGen.IsWhitespace()){
5845     AliAODMCParticle *mcpart= (AliAODMCParticle*)arrayMC->At(lab);//get MC generated particle for particle MC label
5846     if(!mcpart){
5847       printf("AliAnalysisTaskJetChem::IsTrackInjected - BREAK: No valid AliAODMCParticle at label %i\n",lab);
5848       break;
5849     }
5850     Int_t mother = mcpart->GetMother();
5851
5852     if(mother<0){
5853       printf("AliAnalysisTaskJetChem::IsTrackInjected - BREAK: Reached primary particle without valid mother\n");
5854       break;
5855     }
5856     lab=mother;
5857     nameGen=GetGenerator(mother,header);
5858
5859     // countControl++;
5860     // if(countControl>=10){ // 10 = arbitrary number; protection from infinite loops
5861     //   printf("AliVertexingHFUtils::IsTrackInjected - BREAK: Protection from infinite loop active\n");
5862     //   break;
5863     // }
5864
5865   }
5866
5867   return;
5868 }
5869
5870
5871 //---------------------------------------------------------------------------------------------------------------------
5872 Bool_t AliAnalysisTaskJetChem::IsTrackInjected(Int_t lab, AliAODMCHeader *header,TClonesArray *arrayMC, TString& nameGen){
5873   // method to check if a v0 particle comes from the signal event or from the underlying Hijing event
5874   //TString nameGen;
5875
5876   GetTrackPrimaryGenerator(lab, header, arrayMC, nameGen);
5877
5878   if(nameGen.IsWhitespace() || nameGen.Contains("ijing")) return kFALSE;//particle has either no info about generator or is Hijing particle, so it is not injected
5879
5880   //std::cout<<"generator name: "<<nameGen<<std::endl;
5881
5882   return kTRUE;
5883 }
5884
5885 //_________________________________________________________________________________________________________________________________________
5886 Double_t AliAnalysisTaskJetChem::SmearJetPt(Double_t jetPt, Int_t /*cent*/, Double_t /*jetRadius*/, Double_t /*ptmintrack*/, Double_t& jetPtSmear){
5887
5888   static TF1 fsmear("f1","[0]*exp(-1*(x-[1])*(x-[1])/(2*[2]*[2]))",-100.,100.);   //smearing according to gaussian function in between  +/- 10 GeV/c
5889
5890   //Int_t cl = 1;
5891
5892   /*  if(cent>10) cl = 2;
5893   if(cent>30) cl = 3;
5894   if(cent>50) cl = 4;
5895   */
5896
5897   fsmear.SetParameters(1,0,11.19);//for 2010 PbPb jets, R=0.4, ptmintrack = 0.15 GeV/c, cent 00-10%, delta-pt width estimated via single track embedding
5898   //fsmear->SetParameters(1,0,3.28);//for 2010 PbPb jets, R=0.4, ptmintrack = 0.15 GeV/c, cent 50-60%, delta-pt width estimated via single track embedding
5899
5900   //fsmear->SetParameters(1,0,4.472208);// for 2010 PbPb jets, R=0.2, ptmintrack = 0.15 GeV/c, cent 00-10%
5901
5902   /* //delta-pt width for anti-kt jet finder:
5903
5904   // jet cone R = 0.4
5905   if((cl == 1)&&(jetRadius == 0.4)&&(ptmintrack == 0.15)){
5906   fsmear->SetParameters(1,0,10.178069);//(max.,mean,sigma) of gaussian, needs to be adjusted for every combination of jet cone size, centrality and min. pt constituents cut
5907   }
5908   if((cl == 2)&&(jetRadius == 0.4)&&(ptmintrack == 0.15)){
5909   fsmear->SetParameters(1,0,8.536195);
5910   }
5911   if((cl == 3)&&(jetRadius == 0.4)&&(ptmintrack == 0.15)){
5912   fsmear->SetParameters(1,0,?);
5913   }
5914   if((cl == 4)&&(jetRadius == 0.4)&&(ptmintrack == 0.15)){
5915   fsmear->SetParameters(1,0,5.229839);
5916   }
5917
5918   // jet cone R = 0.3
5919   if((cl == 1)&&(jetRadius == 0.3)&&(ptmintrack == 0.15)){
5920   fsmear->SetParameters(1,0,7.145967);
5921   }
5922   if((cl == 2)&&(jetRadius == 0.3)&&(ptmintrack == 0.15)){
5923   fsmear->SetParameters(1,0,5.844796);
5924   }
5925   if((cl == 3)&&(jetRadius == 0.3)&&(ptmintrack == 0.15)){
5926   fsmear->SetParameters(1,0,?);
5927   }
5928   if((cl == 4)&&(jetRadius == 0.3)&&(ptmintrack == 0.15)){
5929   fsmear->SetParameters(1,0,3.630751);
5930   }
5931
5932   // jet cone R = 0.2
5933   if((cl == 1)&&(jetRadius == 0.2)&&(ptmintrack == 0.15)){
5934   fsmear->SetParameters(1,0,4.472208);
5935   }
5936   if((cl == 2)&&(jetRadius == 0.2)&&(ptmintrack == 0.15)){
5937   fsmear->SetParameters(1,0,3.543938);
5938   }
5939   if((cl == 3)&&(jetRadius == 0.2)&&(ptmintrack == 0.15)){
5940   fsmear->SetParameters(1,0,?);
5941   }
5942   if((cl == 4)&&(jetRadius == 0.2)&&(ptmintrack == 0.15)){
5943   fsmear->SetParameters(1,0,1.037476);
5944   }
5945
5946   */
5947
5948   Double_t r = fsmear.GetRandom();
5949   jetPtSmear = jetPt + r;
5950
5951   //  std::cout<<"jetPt: "<<jetPt<<std::endl;
5952   //  std::cout<<"jetPtSmear: "<<jetPtSmear<<std::endl;
5953   //  std::cout<<"r: "<<r<<std::endl;
5954
5955
5956   return jetPtSmear;
5957 }
5958
5959
5960 //______________________________________________________________________________________________________________________
5961 //____________________________________________________________________________________________________________________
5962
5963 Bool_t AliAnalysisTaskJetChem::IsParticleInCone(const AliVParticle* part1, const AliVParticle* part2, Double_t dRMax) const
5964 {
5965 // decides whether a particle is inside a jet cone
5966   if (!part1 || !part2)
5967     return kFALSE;
5968
5969   TVector3 vecMom2(part2->Px(),part2->Py(),part2->Pz());
5970   TVector3 vecMom1(part1->Px(),part1->Py(),part1->Pz());
5971   Double_t dR = vecMom2.DeltaR(vecMom1); // = sqrt(dEta*dEta+dPhi*dPhi)
5972   if(dR<dRMax) // momentum vectors of part1 and part2 are closer than dRMax
5973     return kTRUE;
5974   return kFALSE;
5975 }
5976 //__________________________________________________________________________________________________________________
5977
5978
5979 Bool_t AliAnalysisTaskJetChem::IsRCJCOverlap(TList* recjetlist, const AliVParticle* part, Double_t dDistance) const{
5980
5981   if(!recjetlist) return kFALSE;
5982   if(!part) return kFALSE;
5983   if(!dDistance) return kFALSE;
5984   Int_t nRecJetsCuts = fJetsRecCuts->GetEntries();
5985
5986   for(Int_t i=0; i<nRecJetsCuts; ++i){   //loop over all reconstructed jets in events
5987     AliAODJet* jet = (AliAODJet*) (recjetlist->At(i));
5988     if(!jet){if(fDebug>2)std::cout<<"AliAnalysisTaskJetChem::IsRCJCOverlap jet pointer invalid!"<<std::endl;continue;}
5989     if(IsParticleInCone(jet, part, dDistance) == kTRUE)return kTRUE;//RC and JC are overlapping
5990
5991   }//end loop testing RC-JC overlap
5992   return kFALSE;//RC and JC are not overlapping -> good!
5993 }
5994
5995 //_______________________________________________________________________________________________________________________
5996 AliAODJet* AliAnalysisTaskJetChem::GetRandomCone(TList* jetlist, Double_t dEtaConeMax, Double_t dDistance) const
5997 {
5998   TLorentzVector vecRdCone;
5999   AliAODJet* jetRC = 0;//random cone candidate
6000   Double_t dEta, dPhi; //random eta and phi value for RC
6001   Bool_t IsRCoutJC = kFALSE;//check whether RC is not overlapping with any selected jet cone in event
6002   Int_t iRCTrials = 10;//search at maximum 10 times for random cone that doesn't overlap with jet cone
6003
6004   for(Int_t i=0; i<iRCTrials; iRCTrials++){
6005
6006     dEta = dEtaConeMax*(2*fRandom->Rndm()-1.); //random eta value in range: [-dEtaConeMax,+dEtaConeMax]
6007     dPhi = TMath::TwoPi()*fRandom->Rndm(); //random phi value in range: [0,2*Pi]
6008     vecRdCone.SetPtEtaPhiM(1.,dEta,dPhi,0.);
6009     jetRC = new AliAODJet(vecRdCone);//new RC candidate
6010
6011     if (!IsRCJCOverlap(jetlist,jetRC,dDistance))
6012         {
6013           IsRCoutJC = kTRUE; //std::cout<<"RC and JC are not overlapping!!!"<<std::endl;
6014           break;
6015         }
6016       else
6017         delete jetRC; //RC is overlapping with JC, delete this RC candidate
6018
6019   }
6020   if(!IsRCoutJC) {jetRC = 0;}//in case no random cone was selected
6021
6022   return jetRC;
6023 }
6024
6025
6026 // _______________________________________________________________________________________________________________________
6027 AliAODJet* AliAnalysisTaskJetChem::GetMedianCluster()
6028 {
6029   // fill tracks from bckgCluster branch,
6030   // using cluster with median density (odd number of clusters)
6031   // or picking randomly one of the two closest to median (even number)
6032
6033   Int_t nBckgClusters = fBckgJetsRec->GetEntries(); // not 'recCuts': use all clusters in full eta range
6034
6035   if(nBckgClusters<3) return 0; // need at least 3 clusters (skipping 2 highest)
6036
6037   Double_t* bgrDensity = new Double_t[nBckgClusters];
6038   Int_t*    indices    = new Int_t[nBckgClusters];
6039
6040   for(Int_t ij=0; ij<nBckgClusters; ++ij){
6041
6042     AliAODJet* bgrCluster = (AliAODJet*)(fBckgJetsRec->At(ij));
6043     Double_t clusterPt    = bgrCluster->Pt();
6044     Double_t area         = bgrCluster->EffectiveAreaCharged();
6045
6046     Double_t density = 0;
6047     if(area>0) density = clusterPt/area;
6048
6049     bgrDensity[ij] = density;
6050     indices[ij]    = ij;
6051
6052   }
6053
6054   TMath::Sort(nBckgClusters, bgrDensity, indices);
6055
6056   // get median cluster
6057
6058   AliAODJet* medianCluster = 0;
6059
6060   if(TMath::Odd(nBckgClusters)){
6061
6062     Int_t medianIndex = indices[(Int_t) (0.5*(nBckgClusters+1))];
6063
6064     medianCluster = (AliAODJet*)(fBckgJetsRec->At(medianIndex));
6065
6066     //Double_t clusterPt = medianCluster->Pt();
6067     //Double_t area      = medianCluster->EffectiveAreaCharged();
6068   }
6069   else{
6070
6071     Int_t medianIndex1 = indices[(Int_t) (0.5*nBckgClusters)];
6072     Int_t medianIndex2 = indices[(Int_t) (0.5*nBckgClusters+1)];
6073
6074     AliAODJet* medianCluster1 = (AliAODJet*)(fBckgJetsRec->At(medianIndex1));
6075     AliAODJet* medianCluster2 = (AliAODJet*)(fBckgJetsRec->At(medianIndex2));
6076
6077     // Double_t density1 = 0;
6078     //Double_t clusterPt1 = medianCluster1->Pt();
6079     //Double_t area1      = medianCluster1->EffectiveAreaCharged();
6080     //if(area1>0) Double_t density1 = clusterPt1/area1;
6081
6082     // Double_t density2 = 0;
6083     //Double_t clusterPt2 = medianCluster2->Pt();
6084     //Double_t area2      = medianCluster2->EffectiveAreaCharged();
6085     // if(area2>0) Double_t density2 = clusterPt2/area2;
6086
6087     medianCluster = ( (gRandom->Rndm()>0.5) ? medianCluster1 : medianCluster2 );  // select one randomly to avoid adding areas
6088   }
6089
6090   delete[] bgrDensity;
6091   delete[] indices;
6092
6093   return medianCluster;
6094 }
6095
6096 //____________________________________________________________________________________________
6097
6098 Double_t AliAnalysisTaskJetChem::AreaCircSegment(Double_t dRadius, Double_t dDistance) const
6099 {
6100 // calculate area of a circular segment defined by the circle radius and the (oriented) distance between the secant line and the circle centre
6101   Double_t dEpsilon = 1e-2;
6102   Double_t dR = dRadius;
6103   Double_t dD = dDistance;
6104   if (TMath::Abs(dR)<dEpsilon)
6105     {
6106       if(fDebug>0) printf("AliAnalysisTaskJetChem::AreaCircSegment: Error: Too small radius: %f < %f\n",dR,dEpsilon);
6107       return 0.;
6108     }
6109   if (dD>=dR)
6110     return 0.;
6111   if (dD<=-dR)
6112     return TMath::Pi()*dR*dR;
6113   return dR*dR*TMath::ACos(dD/dR)-dD*TMath::Sqrt(dR*dR-dD*dD);
6114 }
6115
6116
6117