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