PWGGA/GammaConv/AliAnalysisTaskGammaConvCalo.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                                                                                                *
   4  * Author: Baldo Sahlmueller, Friederike Bock                                             *
   5  * Version 1.0                                                                                                                    *
   6  *                                                                                                                                                *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is                  *
  14  * provided "as is" without express or implied warranty.                          *
  15  **************************************************************************/
  16
  17 //////////////////////////////////////////////////////////////////
  18 //----------------------------------------------------------------
  19 // Class used to do analysis on conversion photons + calo photons
  20 //----------------------------------------------------------------
  21 //////////////////////////////////////////////////////////////////
  22 #include "TChain.h"
  23 #include "TTree.h"
  24 #include "TBranch.h"
  25 #include "TFile.h"
  26 #include "TH1F.h"
  27 #include "TH2F.h"
  28 #include "TH3F.h"
  29 #include "THnSparse.h"
  30 #include "TCanvas.h"
  31 #include "TNtuple.h"
  32 #include "AliAnalysisTask.h"
  33 #include "AliAnalysisManager.h"
  34 #include "AliESDEvent.h"
  35 #include "AliESDInputHandler.h"
  36 #include "AliMCEventHandler.h"
  37 #include "AliMCEvent.h"
  38 #include "AliMCParticle.h"
  39 #include "AliCentrality.h"
  40 #include "AliESDVZERO.h"
  41 #include "AliESDpid.h"
  42 #include "AliAnalysisTaskGammaConvCalo.h"
  43 #include "AliVParticle.h"
  44 #include "AliESDtrack.h"
  45 #include "AliESDtrackCuts.h"
  46 #include "AliKFVertex.h"
  47 #include "AliV0ReaderV1.h"
  48 #include "AliGenCocktailEventHeader.h"
  49 #include "AliConversionAODBGHandlerRP.h"
  50 #include "AliAODMCParticle.h"
  51 #include "AliAODMCHeader.h"
  52 #include "AliEventplane.h"
  53 #include "AliAnalysisTaskEMCALClusterizeFast.h"
  54 #include "AliAODEvent.h"
  55 #include "AliAODInputHandler.h"
  56 #include "AliESDEvent.h"
  57 #include "AliESDInputHandler.h"
  58 #include "AliInputEventHandler.h"
  59
  60 ClassImp(AliAnalysisTaskGammaConvCalo)
  61
  62 //________________________________________________________________________
  63 AliAnalysisTaskGammaConvCalo::AliAnalysisTaskGammaConvCalo(): AliAnalysisTaskSE(),
  64         fV0Reader(NULL),
  65         fBGHandler(NULL),
  66         fBGHandlerRP(NULL),
  67         fBGClusHandler(NULL),
  68         fBGClusHandlerRP(NULL),
  69         fInputEvent(NULL),
  70         fMCEvent(NULL),
  71         fMCStack(NULL),
  72         fCutFolder(NULL),
  73         fESDList(NULL),
  74         fBackList(NULL),
  75         fMotherList(NULL),
  76         fPhotonDCAList(NULL),
  77         fTrueList(NULL),
  78         fMCList(NULL),
  79         fHeaderNameList(NULL),
  80         fClusterOutputList(NULL),
  81         fOutputContainer(NULL),
  82         fReaderGammas(NULL),
  83         fGammaCandidates(NULL),
  84         fClusterCandidates(NULL),
  85         fEventCutArray(NULL),
  86         fEventCuts(NULL),
  87         fCutArray(NULL),
  88         fConversionCuts(NULL),
  89         fClusterCutArray(NULL),
  90         fCaloPhotonCuts(NULL),
  91         fMesonCutArray(NULL),
  92         fMesonCuts(NULL),
  93         fHistoConvGammaPt(NULL),
  94         fHistoConvGammaR(NULL),
  95         fHistoConvGammaEta(NULL),
  96         fTreeConvGammaPtDcazCat(NULL),
  97         fPtGamma(0),
  98         fDCAzPhoton(0),
  99         fRConvPhoton(0),
 100         fEtaPhoton(0),
 101         fCharCatPhoton(0),
 102         fCharPhotonMCInfo(0),
 103         fHistoMotherInvMassPt(NULL),
 104         fHistoMotherMatchedInvMassPt(NULL),
 105         fSparseMotherInvMassPtZM(NULL),
 106         fHistoMotherBackInvMassPt(NULL),
 107         fSparseMotherBackInvMassPtZM(NULL),
 108         fHistoMotherInvMassEalpha(NULL),
 109         fHistoMotherPi0PtY(NULL),
 110         fHistoMotherEtaPtY(NULL),
 111         fHistoMotherPi0PtAlpha(NULL),
 112         fHistoMotherEtaPtAlpha(NULL),
 113         fHistoMotherPi0PtOpenAngle(NULL),
 114         fHistoMotherEtaPtOpenAngle(NULL),
 115     fHistoMotherPi0ConvPhotonEtaPhi(NULL),
 116     fHistoMotherEtaConvPhotonEtaPhi(NULL),
 117         fHistoMotherInvMassECalib(NULL),
 118         fHistoMotherInvMassECalibalpha(NULL),
 119         fHistoPhotonPairPtconv(NULL),
 120         fHistoPhotonPairMixedEventPtconv(NULL),
 121         fHistoClusGammaPt(NULL),
 122         fHistoClusOverlapHeadersGammaPt(NULL),
 123         fHistoMCHeaders(NULL),
 124         fHistoMCAllGammaPt(NULL),
 125         fHistoMCAllGammaEMCALAccPt(NULL),
 126         fHistoMCDecayGammaPi0Pt(NULL),
 127         fHistoMCDecayGammaRhoPt(NULL),
 128         fHistoMCDecayGammaEtaPt(NULL),
 129         fHistoMCDecayGammaOmegaPt(NULL),
 130         fHistoMCDecayGammaEtapPt(NULL),
 131         fHistoMCDecayGammaPhiPt(NULL),
 132         fHistoMCDecayGammaSigmaPt(NULL),
 133         fHistoMCConvGammaPt(NULL),
 134         fHistoMCConvGammaR(NULL),
 135         fHistoMCConvGammaEta(NULL),
 136         fHistoMCPi0Pt(NULL),
 137         fHistoMCPi0WOWeightPt(NULL),
 138         fHistoMCEtaPt(NULL),
 139         fHistoMCEtaWOWeightPt(NULL),
 140         fHistoMCPi0InAccPt(NULL),
 141         fHistoMCEtaInAccPt(NULL),
 142         fHistoMCPi0PtY(NULL),
 143         fHistoMCEtaPtY(NULL),
 144         fHistoMCPi0PtAlpha(NULL),
 145         fHistoMCEtaPtAlpha(NULL),
 146         fHistoMCK0sPt(NULL),
 147         fHistoMCK0sWOWeightPt(NULL),
 148         fHistoMCK0sPtY(NULL),
 149         fHistoMCSecPi0PtvsSource(NULL),
 150         fHistoMCSecPi0Source(NULL),
 151         fHistoMCSecEtaPt(NULL),
 152         fHistoMCSecEtaSource(NULL),
 153         fHistoTruePi0InvMassPt(NULL),
 154         fHistoTrueEtaInvMassPt(NULL),
 155         fHistoTruePi0CaloPhotonInvMassPt(NULL),
 156         fHistoTrueEtaCaloPhotonInvMassPt(NULL),
 157         fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
 158         fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
 159         fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
 160         fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
 161         fHistoTruePi0CaloElectronInvMassPt(NULL),
 162         fHistoTrueEtaCaloElectronInvMassPt(NULL),
 163         fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
 164         fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
 165         fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
 166         fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
 167         fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
 168         fHistoTruePrimaryPi0InvMassPt(NULL),
 169         fHistoTruePrimaryEtaInvMassPt(NULL),
 170         fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
 171         fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
 172         fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
 173         fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
 174         fHistoTruePrimaryPi0MCPtResolPt(NULL),
 175         fHistoTruePrimaryEtaMCPtResolPt(NULL),
 176     fHistoTrueMotherPi0ConvPhotonEtaPhi(NULL),
 177     fHistoTrueMotherEtaConvPhotonEtaPhi(NULL),
 178         fHistoTrueSecondaryPi0InvMassPt(NULL),
 179         fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
 180         fHistoTrueK0sWithPi0DaughterMCPt(NULL),
 181         fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
 182         fHistoTrueEtaWithPi0DaughterMCPt(NULL),
 183         fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
 184         fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
 185         fHistoTrueBckGGInvMassPt(NULL),
 186         fHistoTrueBckContInvMassPt(NULL),
 187         fHistoTruePi0PtY(NULL),
 188         fHistoTrueEtaPtY(NULL),
 189         fHistoTruePi0PtAlpha(NULL),
 190         fHistoTrueEtaPtAlpha(NULL),
 191         fHistoTruePi0PtOpenAngle(NULL),
 192         fHistoTrueEtaPtOpenAngle(NULL),
 193         fHistoTrueConvGammaPt(NULL),
 194         fHistoTrueConvPi0GammaPt(NULL),
 195         fHistoTrueConvGammaEta(NULL),
 196         fHistoCombinatorialPt(NULL),
 197         fHistoTruePrimaryConvGammaPt(NULL),
 198         fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
 199         fHistoTrueSecondaryConvGammaPt(NULL),
 200         fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
 201         fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
 202         fHistoTrueClusGammaPt(NULL),
 203         fHistoTrueClusUnConvGammaPt(NULL),
 204         fHistoTrueClusUnConvGammaMCPt(NULL),
 205         fHistoTrueClusElectronPt(NULL),
 206         fHistoTrueClusConvGammaPt(NULL),
 207         fHistoTrueClusConvGammaMCPt(NULL),
 208         fHistoTrueClusConvGammaFullyPt(NULL),
 209         fHistoTrueClusMergedGammaPt(NULL),
 210         fHistoTrueClusMergedPartConvGammaPt(NULL),
 211         fHistoTrueClusDalitzPt(NULL),
 212         fHistoTrueClusDalitzMergedPt(NULL),
 213         fHistoTrueClusPhotonFromElecMotherPt(NULL),
 214         fHistoTrueClusShowerPt(NULL),
 215         fHistoTrueClusSubLeadingPt(NULL),
 216         fHistoTrueClusNParticles(NULL),
 217         fHistoTrueClusEMNonLeadingPt(NULL),
 218         fHistoTrueNLabelsInClus(NULL),
 219         fHistoTruePrimaryClusGammaPt(NULL),
 220         fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
 221         fHistoTruePrimaryPi0PhotonPairPtconv(NULL),
 222         fHistoTruePrimaryPi0DCPtconv(NULL),
 223         fHistoTruePrimaryPi0MissingPtconv(NULL),
 224         fHistoTruePrimaryEtaPhotonPairPtconv(NULL),
 225         fHistoTruePrimaryEtaDCPtconv(NULL),
 226         fHistoTruePrimaryEtaMissingPtconv(NULL),
 227         fHistoTrueSecondaryPi0PhotonPairPtconv(NULL),
 228         fHistoTrueSecondaryPi0DCPtconv(NULL),
 229         fHistoTrueSecondaryPi0MissingPtconv(NULL),
 230         fStringRecTruePi0s(NULL),
 231         fStringRecTrueEtas(NULL),
 232         fHistoNEvents(NULL),
 233         fHistoNGoodESDTracks(NULL),
 234         fHistoNGammaCandidates(NULL),
 235         fHistoNGoodESDTracksVsNGammaCanditates(NULL),
 236         fHistoNV0Tracks(NULL),
 237         fProfileEtaShift(NULL),
 238         fEventPlaneAngle(-100),
 239         fRandom(0),
 240         fNGammaCandidates(0),
 241         fUnsmearedPx(NULL),
 242         fUnsmearedPy(NULL),
 243         fUnsmearedPz(NULL),
 244         fUnsmearedE(NULL),
 245         fMCStackPos(NULL),
 246         fMCStackNeg(NULL),
 247         fESDArrayPos(NULL),
 248         fESDArrayNeg(NULL),
 249         fnCuts(0),
 250         fiCut(0),
 251         fMoveParticleAccordingToVertex(kTRUE),
 252         fIsHeavyIon(0),
 253         fDoMesonAnalysis(kTRUE),
 254         fDoMesonQA(0),
 255         fDoPhotonQA(0),
 256         fDoClusterQA(0),
 257         fIsFromMBHeader(kTRUE),
 258         fIsOverlappingWithOtherHeader(kFALSE),
 259     fIsMC(kFALSE),
 260     fDoTHnSparse(kTRUE)
 261 {
 262
 263 }
 264
 265 //________________________________________________________________________
 266 AliAnalysisTaskGammaConvCalo::AliAnalysisTaskGammaConvCalo(const char *name):
 267         AliAnalysisTaskSE(name),
 268         fV0Reader(NULL),
 269         fBGHandler(NULL),
 270         fBGHandlerRP(NULL),
 271         fBGClusHandler(NULL),
 272         fBGClusHandlerRP(NULL),
 273         fInputEvent(NULL),
 274         fMCEvent(NULL),
 275         fMCStack(NULL),
 276         fCutFolder(NULL),
 277         fESDList(NULL),
 278         fBackList(NULL),
 279         fMotherList(NULL),
 280         fPhotonDCAList(NULL),
 281         fTrueList(NULL),
 282         fMCList(NULL),
 283         fHeaderNameList(NULL),
 284         fClusterOutputList(NULL),
 285         fOutputContainer(0),
 286         fReaderGammas(NULL),
 287         fGammaCandidates(NULL),
 288         fClusterCandidates(NULL),
 289         fEventCutArray(NULL),
 290         fEventCuts(NULL),
 291         fCutArray(NULL),
 292         fConversionCuts(NULL),
 293         fClusterCutArray(NULL),
 294         fCaloPhotonCuts(NULL),
 295         fMesonCutArray(NULL),
 296         fMesonCuts(NULL),
 297         fHistoConvGammaPt(NULL),
 298         fHistoConvGammaR(NULL),
 299         fHistoConvGammaEta(NULL),
 300         fTreeConvGammaPtDcazCat(NULL),
 301         fPtGamma(0),
 302         fDCAzPhoton(0),
 303         fRConvPhoton(0),
 304         fEtaPhoton(0),
 305         fCharCatPhoton(0),
 306         fCharPhotonMCInfo(0),
 307         fHistoMotherInvMassPt(NULL),
 308         fHistoMotherMatchedInvMassPt(NULL),
 309         fSparseMotherInvMassPtZM(NULL),
 310         fHistoMotherBackInvMassPt(NULL),
 311         fSparseMotherBackInvMassPtZM(NULL),
 312         fHistoMotherInvMassEalpha(NULL),
 313         fHistoMotherPi0PtY(NULL),
 314         fHistoMotherEtaPtY(NULL),
 315         fHistoMotherPi0PtAlpha(NULL),
 316         fHistoMotherEtaPtAlpha(NULL),
 317         fHistoMotherPi0PtOpenAngle(NULL),
 318         fHistoMotherEtaPtOpenAngle(NULL),
 319     fHistoMotherPi0ConvPhotonEtaPhi(NULL),
 320     fHistoMotherEtaConvPhotonEtaPhi(NULL),
 321         fHistoMotherInvMassECalib(NULL),
 322         fHistoMotherInvMassECalibalpha(NULL),
 323         fHistoPhotonPairPtconv(NULL),
 324         fHistoPhotonPairMixedEventPtconv(NULL),
 325         fHistoClusGammaPt(NULL),
 326         fHistoClusOverlapHeadersGammaPt(NULL),
 327         fHistoMCHeaders(NULL),
 328         fHistoMCAllGammaPt(NULL),
 329         fHistoMCAllGammaEMCALAccPt(NULL),
 330         fHistoMCDecayGammaPi0Pt(NULL),
 331         fHistoMCDecayGammaRhoPt(NULL),
 332         fHistoMCDecayGammaEtaPt(NULL),
 333         fHistoMCDecayGammaOmegaPt(NULL),
 334         fHistoMCDecayGammaEtapPt(NULL),
 335         fHistoMCDecayGammaPhiPt(NULL),
 336         fHistoMCDecayGammaSigmaPt(NULL),
 337         fHistoMCConvGammaPt(NULL),
 338         fHistoMCConvGammaR(NULL),
 339         fHistoMCConvGammaEta(NULL),
 340         fHistoMCPi0Pt(NULL),
 341         fHistoMCPi0WOWeightPt(NULL),
 342         fHistoMCEtaPt(NULL),
 343         fHistoMCEtaWOWeightPt(NULL),
 344         fHistoMCPi0InAccPt(NULL),
 345         fHistoMCEtaInAccPt(NULL),
 346         fHistoMCPi0PtY(NULL),
 347         fHistoMCEtaPtY(NULL),
 348         fHistoMCPi0PtAlpha(NULL),
 349         fHistoMCEtaPtAlpha(NULL),
 350         fHistoMCK0sPt(NULL),
 351         fHistoMCK0sWOWeightPt(NULL),
 352         fHistoMCK0sPtY(NULL),
 353         fHistoMCSecPi0PtvsSource(NULL),
 354         fHistoMCSecPi0Source(NULL),
 355         fHistoMCSecEtaPt(NULL),
 356         fHistoMCSecEtaSource(NULL),
 357         fHistoTruePi0InvMassPt(NULL),
 358         fHistoTrueEtaInvMassPt(NULL),
 359         fHistoTruePi0CaloPhotonInvMassPt(NULL),
 360         fHistoTrueEtaCaloPhotonInvMassPt(NULL),
 361         fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
 362         fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
 363         fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
 364         fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
 365         fHistoTruePi0CaloElectronInvMassPt(NULL),
 366         fHistoTrueEtaCaloElectronInvMassPt(NULL),
 367         fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
 368         fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
 369         fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
 370         fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
 371         fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
 372         fHistoTruePrimaryPi0InvMassPt(NULL),
 373         fHistoTruePrimaryEtaInvMassPt(NULL),
 374         fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
 375         fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
 376         fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
 377         fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
 378         fHistoTruePrimaryPi0MCPtResolPt(NULL),
 379         fHistoTruePrimaryEtaMCPtResolPt(NULL),
 380     fHistoTrueMotherPi0ConvPhotonEtaPhi(NULL),
 381     fHistoTrueMotherEtaConvPhotonEtaPhi(NULL),
 382         fHistoTrueSecondaryPi0InvMassPt(NULL),
 383         fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
 384         fHistoTrueK0sWithPi0DaughterMCPt(NULL),
 385         fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
 386         fHistoTrueEtaWithPi0DaughterMCPt(NULL),
 387         fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
 388         fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
 389         fHistoTrueBckGGInvMassPt(NULL),
 390         fHistoTrueBckContInvMassPt(NULL),
 391         fHistoTruePi0PtY(NULL),
 392         fHistoTrueEtaPtY(NULL),
 393         fHistoTruePi0PtAlpha(NULL),
 394         fHistoTrueEtaPtAlpha(NULL),
 395         fHistoTruePi0PtOpenAngle(NULL),
 396         fHistoTrueEtaPtOpenAngle(NULL),
 397         fHistoTrueConvGammaPt(NULL),
 398         fHistoTrueConvPi0GammaPt(NULL),
 399         fHistoTrueConvGammaEta(NULL),
 400         fHistoCombinatorialPt(NULL),
 401         fHistoTruePrimaryConvGammaPt(NULL),
 402         fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
 403         fHistoTrueSecondaryConvGammaPt(NULL),
 404         fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
 405         fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
 406         fHistoTrueClusGammaPt(NULL),
 407         fHistoTrueClusUnConvGammaPt(NULL),
 408         fHistoTrueClusUnConvGammaMCPt(NULL),
 409         fHistoTrueClusElectronPt(NULL),
 410         fHistoTrueClusConvGammaPt(NULL),
 411         fHistoTrueClusConvGammaMCPt(NULL),
 412         fHistoTrueClusConvGammaFullyPt(NULL),
 413         fHistoTrueClusMergedGammaPt(NULL),
 414         fHistoTrueClusMergedPartConvGammaPt(NULL),
 415         fHistoTrueClusDalitzPt(NULL),
 416         fHistoTrueClusDalitzMergedPt(NULL),
 417         fHistoTrueClusPhotonFromElecMotherPt(NULL),
 418         fHistoTrueClusShowerPt(NULL),
 419         fHistoTrueClusSubLeadingPt(NULL),
 420         fHistoTrueClusNParticles(NULL),
 421         fHistoTrueClusEMNonLeadingPt(NULL),
 422         fHistoTrueNLabelsInClus(NULL),
 423         fHistoTruePrimaryClusGammaPt(NULL),
 424         fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
 425         fHistoTruePrimaryPi0PhotonPairPtconv(NULL),
 426         fHistoTruePrimaryPi0DCPtconv(NULL),
 427         fHistoTruePrimaryPi0MissingPtconv(NULL),
 428         fHistoTruePrimaryEtaPhotonPairPtconv(NULL),
 429         fHistoTruePrimaryEtaDCPtconv(NULL),
 430         fHistoTruePrimaryEtaMissingPtconv(NULL),
 431         fHistoTrueSecondaryPi0PhotonPairPtconv(NULL),
 432         fHistoTrueSecondaryPi0DCPtconv(NULL),
 433         fHistoTrueSecondaryPi0MissingPtconv(NULL),
 434         fStringRecTruePi0s(NULL),
 435         fStringRecTrueEtas(NULL),
 436         fHistoNEvents(NULL),
 437         fHistoNGoodESDTracks(NULL),
 438         fHistoNGammaCandidates(NULL),
 439         fHistoNGoodESDTracksVsNGammaCanditates(NULL),
 440         fHistoNV0Tracks(NULL),
 441         fProfileEtaShift(NULL),
 442         fEventPlaneAngle(-100),
 443         fRandom(0),
 444         fNGammaCandidates(0),
 445         fUnsmearedPx(NULL),
 446         fUnsmearedPy(NULL),
 447         fUnsmearedPz(NULL),
 448         fUnsmearedE(NULL),
 449         fMCStackPos(NULL),
 450         fMCStackNeg(NULL),
 451         fESDArrayPos(NULL),
 452         fESDArrayNeg(NULL),
 453         fnCuts(0),
 454         fiCut(0),
 455         fMoveParticleAccordingToVertex(kTRUE),
 456         fIsHeavyIon(0),
 457         fDoMesonAnalysis(kTRUE),
 458         fDoMesonQA(0),
 459         fDoPhotonQA(0),
 460         fDoClusterQA(0),
 461         fIsFromMBHeader(kTRUE),
 462         fIsOverlappingWithOtherHeader(kFALSE),
 463     fIsMC(kFALSE),
 464     fDoTHnSparse(kTRUE)
 465 {
 466   // Define output slots here
 467   DefineOutput(1, TList::Class());
 468 }
 469
 470 AliAnalysisTaskGammaConvCalo::~AliAnalysisTaskGammaConvCalo()
 471 {
 472         if(fGammaCandidates){
 473                 delete fGammaCandidates;
 474                 fGammaCandidates = 0x0;
 475         }
 476         if(fClusterCandidates){
 477                 delete fClusterCandidates;
 478                 fClusterCandidates = 0x0;
 479         }
 480         if(fBGHandler){
 481                 delete[] fBGHandler;
 482                 fBGHandler = 0x0;
 483         }
 484         if(fBGHandlerRP){
 485                 delete[] fBGHandlerRP;
 486                 fBGHandlerRP = 0x0;
 487         }
 488         if(fBGClusHandler){
 489                 delete[] fBGClusHandler;
 490                 fBGClusHandler = 0x0;
 491         }
 492         if(fBGClusHandlerRP){
 493                 delete[] fBGClusHandlerRP;
 494                 fBGClusHandlerRP = 0x0;
 495         }
 496 }
 497 //___________________________________________________________
 498 void AliAnalysisTaskGammaConvCalo::InitBack(){
 499
 500         const Int_t nDim = 4;
 501         Int_t nBins[nDim] = {800,250,7,4};
 502         Double_t xMin[nDim] = {0,0, 0,0};
 503         Double_t xMax[nDim] = {0.8,25,7,4};
 504
 505     if(fDoTHnSparse){
 506         fSparseMotherInvMassPtZM = new THnSparseF*[fnCuts];
 507         fSparseMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
 508     }
 509
 510         fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
 511         fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
 512
 513         fBGClusHandler = new AliGammaConversionAODBGHandler*[fnCuts];
 514         fBGClusHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
 515
 516         for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 517                 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
 518                         TString cutstringEvent  = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
 519                         TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
 520                         TString cutstringCalo   = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
 521                         TString cutstringMeson  = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
 522
 523                         Int_t collisionSystem = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(0,1));
 524                         Int_t centMin = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(1,1));
 525                         Int_t centMax = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(2,1));
 526
 527                         if(collisionSystem == 1 || collisionSystem == 2 ||
 528                                 collisionSystem == 5 || collisionSystem == 8 ||
 529                                 collisionSystem == 9){
 530                                 centMin = centMin*10;
 531                                 centMax = centMax*10;
 532                                 if(centMax ==0 && centMax!=centMin) centMax=100;
 533                         } else if(collisionSystem == 3 || collisionSystem == 6){
 534                                 centMin = centMin*5;
 535                                 centMax = centMax*5;
 536                         } else if(collisionSystem == 4 || collisionSystem == 7){
 537                                 centMin = ((centMin*5)+45);
 538                                 centMax = ((centMax*5)+45);
 539                         }
 540
 541             if(fDoTHnSparse){
 542                 fBackList[iCut] = new TList();
 543                 fBackList[iCut]->SetName(Form("%s_%s_%s_%s Back histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(), cutstringMeson.Data()));
 544                 fBackList[iCut]->SetOwner(kTRUE);
 545                 fCutFolder[iCut]->Add(fBackList[iCut]);
 546
 547                 fSparseMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
 548                 fBackList[iCut]->Add(fSparseMotherBackInvMassPtZM[iCut]);
 549
 550                 fMotherList[iCut] = new TList();
 551                 fMotherList[iCut]->SetName(Form("%s_%s_%s_%s Mother histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
 552                 fMotherList[iCut]->SetOwner(kTRUE);
 553                 fCutFolder[iCut]->Add(fMotherList[iCut]);
 554
 555                 fSparseMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
 556                 fMotherList[iCut]->Add(fSparseMotherInvMassPtZM[iCut]);
 557             }
 558
 559                         if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
 560                                 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
 561                                                                                                                                         collisionSystem,centMin,centMax,
 562                                                                                                                                         ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
 563                                                                                                                                         ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity(),
 564                                                                                                                                         2,8,7);
 565                                 fBGClusHandler[iCut] = new AliGammaConversionAODBGHandler(
 566                                                                                                                                         collisionSystem,centMin,centMax,
 567                                                                                                                                         ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
 568                                                                                                                                         ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity(),
 569                                                                                                                                         2,8,7);
 570                                 fBGHandlerRP[iCut] = NULL;
 571                         } else{
 572                                 fBGHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
 573                                                                                                                                         ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsHeavyIon(),
 574                                                                                                                                         ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
 575                                                                                                                                         ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
 576                                 fBGClusHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
 577                                                                                                                                         ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsHeavyIon(),
 578                                                                                                                                         ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
 579                                                                                                                                         ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
 580                                 fBGHandler[iCut] = NULL;
 581                         }
 582                 }
 583         }
 584 }
 585 //________________________________________________________________________
 586 void AliAnalysisTaskGammaConvCalo::UserCreateOutputObjects(){
 587
 588         // Create histograms
 589         if(fOutputContainer != NULL){
 590                 delete fOutputContainer;
 591                 fOutputContainer = NULL;
 592         }
 593         if(fOutputContainer == NULL){
 594                 fOutputContainer = new TList();
 595                 fOutputContainer->SetOwner(kTRUE);
 596         }
 597
 598         // Array of current cut's gammas
 599         fGammaCandidates = new TList();
 600         fClusterCandidates = new TList();
 601
 602         fCutFolder = new TList*[fnCuts];
 603         fESDList = new TList*[fnCuts];
 604
 605     if(fDoTHnSparse){
 606         fBackList = new TList*[fnCuts];
 607         fMotherList = new TList*[fnCuts];
 608     }
 609
 610         fHistoNEvents = new TH1I*[fnCuts];
 611         fHistoNGoodESDTracks = new TH1I*[fnCuts];
 612         fHistoNGammaCandidates = new TH1I*[fnCuts];
 613         fHistoNGoodESDTracksVsNGammaCanditates = new TH2F*[fnCuts];
 614         fHistoNV0Tracks = new TH1I*[fnCuts];
 615         fProfileEtaShift = new TProfile*[fnCuts];
 616         fHistoConvGammaPt = new TH1F*[fnCuts];
 617
 618         if (fDoPhotonQA == 2){
 619                 fPhotonDCAList = new TList*[fnCuts];
 620                 fTreeConvGammaPtDcazCat = new TTree*[fnCuts];
 621         }
 622         if (fDoPhotonQA > 0){
 623                 fHistoConvGammaR = new TH1F*[fnCuts];
 624                 fHistoConvGammaEta = new TH1F*[fnCuts];
 625         }
 626
 627         if(fDoMesonAnalysis){
 628                 fHistoMotherInvMassPt = new TH2F*[fnCuts];
 629                 fHistoMotherMatchedInvMassPt = new TH2F*[fnCuts];
 630                 fHistoMotherBackInvMassPt = new TH2F*[fnCuts];
 631                 fHistoMotherInvMassEalpha = new TH2F*[fnCuts];
 632                 fHistoPhotonPairPtconv = new TH2F*[fnCuts];
 633                 fHistoPhotonPairMixedEventPtconv = new TH2F*[fnCuts];
 634                 if (fDoMesonQA > 0){
 635                         fHistoMotherPi0PtY =  new TH2F*[fnCuts];
 636                         fHistoMotherEtaPtY =  new TH2F*[fnCuts];
 637                         fHistoMotherPi0PtAlpha =  new TH2F*[fnCuts];
 638                         fHistoMotherEtaPtAlpha =  new TH2F*[fnCuts];
 639                         fHistoMotherPi0PtOpenAngle =  new TH2F*[fnCuts];
 640                         fHistoMotherEtaPtOpenAngle =  new TH2F*[fnCuts];
 641             fHistoMotherPi0ConvPhotonEtaPhi = new TH2F*[fnCuts];
 642             fHistoMotherEtaConvPhotonEtaPhi = new TH2F*[fnCuts];
 643                 }
 644                 if(fDoMesonQA == 1){
 645                         fHistoMotherInvMassECalib = new TH2F*[fnCuts];
 646                         fHistoMotherInvMassECalibalpha = new TH2F*[fnCuts];
 647                 }
 648         }
 649
 650         fClusterOutputList = new TList*[fnCuts];
 651         fHistoClusGammaPt = new TH1F*[fnCuts];
 652         fHistoClusOverlapHeadersGammaPt = new TH1F*[fnCuts];
 653
 654         for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 655                 TString cutstringEvent  = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
 656                 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
 657                 TString cutstringCalo   = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
 658                 TString cutstringMeson  = "NoMesonCut";
 659                 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
 660
 661                 fCutFolder[iCut] = new TList();
 662                 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s_%s",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
 663                 fCutFolder[iCut]->SetOwner(kTRUE);
 664                 fOutputContainer->Add(fCutFolder[iCut]);
 665                 fESDList[iCut] = new TList();
 666                 fESDList[iCut]->SetName(Form("%s_%s_%s_%s ESD histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
 667                 fESDList[iCut]->SetOwner(kTRUE);
 668                 fCutFolder[iCut]->Add(fESDList[iCut]);
 669
 670                 fHistoNEvents[iCut] = new TH1I("NEvents","NEvents",10,-0.5,9.5);
 671                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
 672                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
 673                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
 674                 if (((AliConvEventCuts*)fEventCutArray->At(iCut))->IsSpecialTrigger() > 1 ){
 675                         TString TriggerNames = "Not Trigger: ";
 676                         TriggerNames = TriggerNames+ ( (AliConvEventCuts*)fEventCutArray->At(iCut))->GetSpecialTriggerName();
 677                         fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
 678                 } else {
 679                         fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
 680                 }
 681                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
 682                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
 683                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
 684                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
 685                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
 686                 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(10,"EMCAL problem");
 687                 fESDList[iCut]->Add(fHistoNEvents[iCut]);
 688
 689                 if(fIsHeavyIon == 1) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
 690                 else if(fIsHeavyIon == 2) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",400,0,400);
 691                 else fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
 692                 fHistoNGoodESDTracks[iCut]->SetXTitle("# TPC tracks");
 693                 fESDList[iCut]->Add(fHistoNGoodESDTracks[iCut]);
 694
 695                 if(fIsHeavyIon == 1) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
 696                 else if(fIsHeavyIon == 2) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
 697                 else fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
 698                 fHistoNGammaCandidates[iCut]->SetXTitle("# accepted $#gamma_{conv}");
 699                 fESDList[iCut]->Add(fHistoNGammaCandidates[iCut]);
 700
 701                 if(fIsHeavyIon == 1) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",4000,0,4000,100,0,100);
 702                 else if(fIsHeavyIon == 2) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",400,0,400,50,0,50);
 703                 else fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",200,0,200,50,0,50);
 704                 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->SetXTitle("# TPC tracks");
 705                 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->SetYTitle("# accepted $#gamma_{conv}");
 706                 fESDList[iCut]->Add(fHistoNGoodESDTracksVsNGammaCanditates[iCut]);
 707
 708
 709                 if(fIsHeavyIon == 1) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
 710                 else if(fIsHeavyIon == 2) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
 711                 else fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
 712                 fHistoNV0Tracks[iCut]->SetXTitle("VZERO amp [arb. units]");
 713                 fESDList[iCut]->Add(fHistoNV0Tracks[iCut]);
 714                 fProfileEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
 715                 fESDList[iCut]->Add(fProfileEtaShift[iCut]);
 716                 fHistoConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
 717                 fHistoConvGammaPt[iCut]->SetXTitle("p_{T,conv} (GeV/c)");
 718                 fESDList[iCut]->Add(fHistoConvGammaPt[iCut]);
 719
 720                 if (fDoPhotonQA == 2){
 721                         fPhotonDCAList[iCut] = new TList();
 722                         fPhotonDCAList[iCut]->SetName(Form("%s_%s_%s_%s Photon DCA tree",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
 723                         fPhotonDCAList[iCut]->SetOwner(kTRUE);
 724                         fCutFolder[iCut]->Add(fPhotonDCAList[iCut]);
 725
 726                         fTreeConvGammaPtDcazCat[iCut] = new TTree("ESD_ConvGamma_Pt_Dcaz_R_Eta","ESD_ConvGamma_Pt_Dcaz_R_Eta_Cat");
 727                         fTreeConvGammaPtDcazCat[iCut]->Branch("Pt",&fPtGamma,"fPtGamma/F");
 728                         fTreeConvGammaPtDcazCat[iCut]->Branch("DcaZPhoton",&fDCAzPhoton,"fDCAzPhoton/F");
 729                         fTreeConvGammaPtDcazCat[iCut]->Branch("cat",&fCharCatPhoton,"fCharCatPhoton/b");
 730                         if(fIsMC){
 731                                 fTreeConvGammaPtDcazCat[iCut]->Branch("photonMCInfo",&fCharPhotonMCInfo,"fCharPhotonMCInfo/b");
 732                         }
 733                         fPhotonDCAList[iCut]->Add(fTreeConvGammaPtDcazCat[iCut]);
 734                 }
 735
 736                 if (fDoPhotonQA > 0){
 737                         fHistoConvGammaR[iCut] = new TH1F("ESD_ConvGamma_R","ESD_ConvGamma_R",800,0,200);
 738                         fHistoConvGammaR[iCut]->SetXTitle("R_{conv} (cm)");
 739                         fESDList[iCut]->Add(fHistoConvGammaR[iCut]);
 740                         fHistoConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",2000,-2,2);
 741                         fHistoConvGammaEta[iCut]->SetXTitle("#eta_{conv}");
 742                         fESDList[iCut]->Add(fHistoConvGammaEta[iCut]);
 743                 }
 744
 745                 fClusterOutputList[iCut] = new TList();
 746                 fClusterOutputList[iCut]->SetName(Form("%s_%s_%s_%s Cluster Output",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
 747                 fClusterOutputList[iCut]->SetOwner(1);
 748                 fCutFolder[iCut]->Add(fClusterOutputList[iCut]);
 749
 750                 fHistoClusGammaPt[iCut] = new TH1F("ClusGamma_Pt","ClusGamma_Pt",250,0,25);
 751                 fHistoClusGammaPt[iCut]->SetXTitle("p_{T,clus} (GeV/c)");
 752                 fClusterOutputList[iCut]->Add(fHistoClusGammaPt[iCut]);
 753                 fHistoClusOverlapHeadersGammaPt[iCut] = new TH1F("ClusGammaOverlapHeaders_Pt","ClusGammaOverlapHeaders_Pt",250,0,25);
 754                 fHistoClusOverlapHeadersGammaPt[iCut]->SetXTitle("p_{T,clus} (GeV/c), selected header w/ overlap");
 755                 fClusterOutputList[iCut]->Add(fHistoClusOverlapHeadersGammaPt[iCut]);
 756
 757                 if(fDoMesonAnalysis){
 758                         fHistoMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
 759                         fHistoMotherInvMassPt[iCut]->SetXTitle("M_{inv} (GeV/c^{2})");
 760                         fHistoMotherInvMassPt[iCut]->SetYTitle("p_{T,pair} (GeV/c)");
 761                         fESDList[iCut]->Add(fHistoMotherInvMassPt[iCut]);
 762
 763                         fHistoMotherMatchedInvMassPt[iCut] = new TH2F("ESD_MotherMatched_InvMass_Pt","ESD_MotherMatched_InvMass_Pt",800,0,0.8,250,0,25);
 764                         fHistoMotherMatchedInvMassPt[iCut]->SetXTitle("M_{inv} (GeV/c^{2}) matched conv e^{+/-} to cluster");
 765                         fHistoMotherMatchedInvMassPt[iCut]->SetYTitle("p_{T,pair} (GeV/c)");
 766                         fESDList[iCut]->Add(fHistoMotherMatchedInvMassPt[iCut]);
 767
 768                         fHistoMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
 769                         fHistoMotherBackInvMassPt[iCut]->SetXTitle("M_{inv, mxed} (GeV/c^{2})");
 770                         fHistoMotherBackInvMassPt[iCut]->SetYTitle("p_{T,BG pair} (GeV/c)");
 771                         fESDList[iCut]->Add(fHistoMotherBackInvMassPt[iCut]);
 772
 773                         fHistoMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
 774                         fHistoMotherInvMassEalpha[iCut]->SetXTitle("M_{inv} (GeV/c^{2})");
 775                         fHistoMotherInvMassEalpha[iCut]->SetYTitle("p_{T,pair} (GeV/c)");
 776                         fESDList[iCut]->Add(fHistoMotherInvMassEalpha[iCut]);
 777
 778                         fHistoPhotonPairPtconv[iCut] = new TH2F("ESD_Mother_InvMass_PtConv","",800,0,0.8,250,0,25);
 779                         fHistoPhotonPairPtconv[iCut]->SetXTitle("M_{inv} (GeV/c^{2})");
 780                         fHistoPhotonPairPtconv[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
 781                         fESDList[iCut]->Add(fHistoPhotonPairPtconv[iCut]);
 782
 783                         fHistoPhotonPairMixedEventPtconv[iCut] = new TH2F("ESD_Background_InvMass_PtConv","",800,0,0.8,250,0,25);
 784                         fHistoPhotonPairMixedEventPtconv[iCut]->SetXTitle("M_{inv,mixed} (GeV/c^{2})");
 785                         fHistoPhotonPairMixedEventPtconv[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
 786                         fESDList[iCut]->Add(fHistoPhotonPairMixedEventPtconv[iCut]);
 787
 788                         if(fDoMesonQA == 1){
 789                 fHistoMotherInvMassECalib[iCut] = new TH2F("ESD_Mother_InvMass_E_Calib","ESD_Mother_InvMass_E_Calib",800,0,0.8,250,0,25);
 790                                 fHistoMotherInvMassECalib[iCut]->SetXTitle("M_{inv} (GeV/c^{2})");
 791                                 fHistoMotherInvMassECalib[iCut]->SetYTitle("p_{T,cluster} (GeV/c)");
 792                                 fESDList[iCut]->Add(fHistoMotherInvMassECalib[iCut]);
 793
 794                                 fHistoMotherInvMassECalibalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_Calib_alpha","ESD_Mother_InvMass_vs_E_Calib_alpha",800,0,0.8,250,0,25);
 795                                 fHistoMotherInvMassECalibalpha[iCut]->SetXTitle("M_{inv} (GeV/c^{2})");
 796                                 fHistoMotherInvMassECalibalpha[iCut]->SetYTitle("p_{T,cluster} (GeV/c)");
 797                                 fESDList[iCut]->Add(fHistoMotherInvMassECalibalpha[iCut]);
 798                         }
 799
 800                         if (fDoMesonQA > 0 ){
 801                                 fHistoMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
 802                                 fHistoMotherPi0PtY[iCut]->SetXTitle("p_{T, #pi^{0} cand} (GeV/c)");
 803                                 fHistoMotherPi0PtY[iCut]->SetYTitle("y_{#pi^{0} cand}");
 804                                 SetLogBinningXTH2(fHistoMotherPi0PtY[iCut]);
 805                                 fESDList[iCut]->Add(fHistoMotherPi0PtY[iCut]);
 806                                 fHistoMotherEtaPtY[iCut] = new TH2F("ESD_MotaherEta_Pt_Y","ESD_MotherEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
 807                                 fHistoMotherEtaPtY[iCut]->SetXTitle("p_{T, #eta cand} (GeV/c)");
 808                                 fHistoMotherEtaPtY[iCut]->SetYTitle("y_{ #eta cand}");
 809                                 SetLogBinningXTH2(fHistoMotherEtaPtY[iCut]);
 810                                 fESDList[iCut]->Add(fHistoMotherEtaPtY[iCut]);
 811                                 fHistoMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",150,0.03,15.,100,0,1);
 812                                 fHistoMotherPi0PtAlpha[iCut]->SetXTitle("p_{T, #pi^{0} cand} (GeV/c)");
 813                                 fHistoMotherPi0PtAlpha[iCut]->SetYTitle("#alpha_{#pi^{0} cand}");
 814                                 SetLogBinningXTH2(fHistoMotherPi0PtAlpha[iCut]);
 815                                 fESDList[iCut]->Add(fHistoMotherPi0PtAlpha[iCut]);
 816                                 fHistoMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",150,0.03,15.,100,0,1);
 817                                 fHistoMotherEtaPtAlpha[iCut]->SetXTitle("p_{T, #eta cand} (GeV/c)");
 818                                 fHistoMotherEtaPtAlpha[iCut]->SetYTitle("#alpha_{#eta cand}");
 819                                 SetLogBinningXTH2(fHistoMotherEtaPtAlpha[iCut]);
 820                                 fESDList[iCut]->Add(fHistoMotherEtaPtAlpha[iCut]);
 821                                 fHistoMotherPi0PtOpenAngle[iCut] = new TH2F("ESD_MotherPi0_Pt_OpenAngle","ESD_MotherPi0_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
 822                                 fHistoMotherPi0PtOpenAngle[iCut]->SetXTitle("p_{T, #pi^{0} cand} (GeV/c)");
 823                                 fHistoMotherPi0PtOpenAngle[iCut]->SetYTitle("#theta_{#pi^{0} cand}");
 824                                 SetLogBinningXTH2(fHistoMotherPi0PtOpenAngle[iCut]);
 825                                 fESDList[iCut]->Add(fHistoMotherPi0PtOpenAngle[iCut]);
 826                                 fHistoMotherEtaPtOpenAngle[iCut] = new TH2F("ESD_MotherEta_Pt_OpenAngle","ESD_MotherEta_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
 827                                 fHistoMotherEtaPtOpenAngle[iCut]->SetXTitle("p_{T, #eta cand} (GeV/c)");
 828                                 fHistoMotherEtaPtOpenAngle[iCut]->SetYTitle("#theta_{#eta cand}");
 829                                 SetLogBinningXTH2(fHistoMotherEtaPtOpenAngle[iCut]);
 830                                 fESDList[iCut]->Add(fHistoMotherEtaPtOpenAngle[iCut]);
 831                 fHistoMotherPi0ConvPhotonEtaPhi[iCut] = new TH2F("ESD_MotherPi0ConvPhoton_Eta_Phi","ConvPhoton under #pi^{0} peak",600,0,2*TMath::Pi(),200,-1,1);
 832                                 fHistoMotherPi0ConvPhotonEtaPhi[iCut]->SetXTitle("#phi_{#gamma_{conv}} (rad)");
 833                                 fHistoMotherPi0ConvPhotonEtaPhi[iCut]->SetYTitle("#eta_{#gamma_{conv}}");
 834                                 fESDList[iCut]->Add(fHistoMotherPi0ConvPhotonEtaPhi[iCut]);
 835                 fHistoMotherEtaConvPhotonEtaPhi[iCut] = new TH2F("ESD_MotherEtaConvPhoton_Eta_Phi","ConvPhoton under #eta peak",600,0,2*TMath::Pi(),200,-1,1);
 836                                 fHistoMotherEtaConvPhotonEtaPhi[iCut]->SetXTitle("#phi_{#gamma_{conv}} (rad)");
 837                                 fHistoMotherEtaConvPhotonEtaPhi[iCut]->SetYTitle("#eta_{#gamma_{conv}}");
 838                                 fESDList[iCut]->Add(fHistoMotherEtaConvPhotonEtaPhi[iCut]);
 839                         }
 840                 }
 841         }
 842         if(fDoMesonAnalysis){
 843                 InitBack(); // Init Background Handler
 844         }
 845
 846         if(fIsMC){
 847                 // MC Histogramms
 848                 fMCList         = new TList*[fnCuts];
 849                 // True Histogramms
 850                 fTrueList       = new TList*[fnCuts];
 851                 // Selected Header List
 852                 fHeaderNameList                                         = new TList*[fnCuts];
 853                 fHistoMCHeaders                                         = new TH1I*[fnCuts];
 854                 fHistoMCAllGammaPt                                      = new TH1F*[fnCuts];
 855                 fHistoMCAllGammaEMCALAccPt                      = new TH1F*[fnCuts];
 856                 fHistoMCDecayGammaPi0Pt                         = new TH1F*[fnCuts];
 857                 fHistoMCDecayGammaRhoPt                         = new TH1F*[fnCuts];
 858                 fHistoMCDecayGammaEtaPt                         = new TH1F*[fnCuts];
 859                 fHistoMCDecayGammaOmegaPt                       = new TH1F*[fnCuts];
 860                 fHistoMCDecayGammaEtapPt                        = new TH1F*[fnCuts];
 861                 fHistoMCDecayGammaPhiPt                         = new TH1F*[fnCuts];
 862                 fHistoMCDecayGammaSigmaPt                       = new TH1F*[fnCuts];
 863                 fHistoMCConvGammaPt                             = new TH1F*[fnCuts];
 864                 fHistoTrueConvGammaPt                           = new TH1F*[fnCuts];
 865                 fHistoTrueConvPi0GammaPt                        = new TH1F*[fnCuts];
 866
 867                 fHistoCombinatorialPt                                                   = new TH2F*[fnCuts];
 868                 fHistoTruePrimaryConvGammaPt                                    = new TH1F*[fnCuts];
 869                 fHistoTruePrimaryConvGammaESDPtMCPt                     = new TH2F*[fnCuts];
 870                 fHistoTrueSecondaryConvGammaPt                                  = new TH1F*[fnCuts];
 871                 fHistoTrueSecondaryConvGammaFromXFromK0sPt              = new TH1F*[fnCuts];
 872                 fHistoTrueSecondaryConvGammaFromXFromLambdaPt   = new TH1F*[fnCuts];
 873
 874                 fHistoTrueClusGammaPt                           = new TH1F*[fnCuts];
 875                 fHistoTruePrimaryClusGammaPt            = new TH1F*[fnCuts];
 876                 fHistoTruePrimaryClusGammaESDPtMCPt = new TH2F*[fnCuts];
 877
 878                 if (fDoPhotonQA > 0){
 879                         fHistoMCConvGammaR                                      = new TH1F*[fnCuts];
 880                         fHistoMCConvGammaEta                            = new TH1F*[fnCuts];
 881                         fHistoTrueConvGammaEta                          = new TH1F*[fnCuts];
 882                 }
 883                 if (fDoClusterQA > 0){
 884                         fHistoTrueClusUnConvGammaPt             = new TH1F*[fnCuts];
 885                         fHistoTrueClusUnConvGammaMCPt           = new TH1F*[fnCuts];
 886                         fHistoTrueClusElectronPt                        = new TH1F*[fnCuts];
 887                         fHistoTrueClusConvGammaPt                       = new TH1F*[fnCuts];
 888                         fHistoTrueClusConvGammaMCPt                     = new TH1F*[fnCuts];
 889                         fHistoTrueClusConvGammaFullyPt          = new TH1F*[fnCuts];
 890                         fHistoTrueClusMergedGammaPt             = new TH1F*[fnCuts];
 891                         fHistoTrueClusMergedPartConvGammaPt = new TH1F*[fnCuts];
 892                         fHistoTrueClusDalitzPt                          = new TH1F*[fnCuts];
 893                         fHistoTrueClusDalitzMergedPt            = new TH1F*[fnCuts];
 894                         fHistoTrueClusPhotonFromElecMotherPt= new TH1F*[fnCuts];
 895                         fHistoTrueClusShowerPt                          = new TH1F*[fnCuts];
 896                         fHistoTrueClusSubLeadingPt                      = new TH1F*[fnCuts];
 897                         fHistoTrueClusNParticles                        = new TH1I*[fnCuts];
 898                         fHistoTrueClusEMNonLeadingPt            = new TH1F*[fnCuts];
 899                         fHistoTrueNLabelsInClus                         = new TH1F*[fnCuts];
 900                 }
 901
 902                 if(fDoMesonAnalysis){
 903                         fHistoMCPi0Pt                                   = new TH1F*[fnCuts];
 904                         fHistoMCPi0WOWeightPt                   = new TH1F*[fnCuts];
 905                         fHistoMCEtaPt                                   = new TH1F*[fnCuts];
 906                         fHistoMCEtaWOWeightPt                   = new TH1F*[fnCuts];
 907                         fHistoMCPi0InAccPt                              = new TH1F*[fnCuts];
 908                         fHistoMCEtaInAccPt                              = new TH1F*[fnCuts];
 909
 910                         fHistoTruePi0InvMassPt                                          = new TH2F*[fnCuts];
 911                         fHistoTrueEtaInvMassPt                                          = new TH2F*[fnCuts];
 912                         fHistoTruePrimaryPi0InvMassPt                           = new TH2F*[fnCuts];
 913                         fHistoTruePrimaryEtaInvMassPt                           = new TH2F*[fnCuts];
 914                         fHistoTruePrimaryPi0W0WeightingInvMassPt        = new TH2F*[fnCuts];
 915                         fHistoTruePrimaryEtaW0WeightingInvMassPt        = new TH2F*[fnCuts];
 916                         fProfileTruePrimaryPi0WeightsInvMassPt          = new TProfile2D*[fnCuts];
 917                         fProfileTruePrimaryEtaWeightsInvMassPt          = new TProfile2D*[fnCuts];
 918                         fHistoTrueSecondaryPi0InvMassPt                         = new TH2F*[fnCuts];
 919                         fHistoTrueSecondaryPi0FromK0sInvMassPt          = new TH2F*[fnCuts];
 920                         fHistoTrueSecondaryPi0FromEtaInvMassPt          = new TH2F*[fnCuts];
 921                         fHistoTrueSecondaryPi0FromLambdaInvMassPt       = new TH2F*[fnCuts];
 922                         fHistoTruePrimaryPi0PhotonPairPtconv            = new TH2F*[fnCuts];
 923                         fHistoTrueSecondaryPi0PhotonPairPtconv          = new TH2F*[fnCuts];
 924                         fHistoTruePrimaryEtaPhotonPairPtconv            = new TH2F*[fnCuts];
 925                         fHistoTruePrimaryPi0DCPtconv                            = new TH1F*[fnCuts];
 926                         fHistoTrueSecondaryPi0DCPtconv                          = new TH1F*[fnCuts];
 927                         fHistoTruePrimaryEtaDCPtconv                            = new TH1F*[fnCuts];
 928                         fHistoTruePrimaryPi0MissingPtconv                       = new TH1F*[fnCuts];
 929                         fHistoTrueSecondaryPi0MissingPtconv             = new TH1F*[fnCuts];
 930                         fHistoTruePrimaryEtaMissingPtconv                       = new TH1F*[fnCuts];
 931                         fStringRecTruePi0s                                                      = new TString[fnCuts];
 932                         fStringRecTrueEtas                                                      = new TString[fnCuts];
 933
 934                         if (fDoMesonQA > 0){
 935                                 fHistoMCPi0PtY                                                          = new TH2F*[fnCuts];
 936                                 fHistoMCEtaPtY                                                          = new TH2F*[fnCuts];
 937                                 fHistoMCPi0PtAlpha                                                      = new TH2F*[fnCuts];
 938                                 fHistoMCEtaPtAlpha                                                      = new TH2F*[fnCuts];
 939                                 fHistoMCK0sPt                                                           = new TH1F*[fnCuts];
 940                                 fHistoMCK0sWOWeightPt                                           = new TH1F*[fnCuts];
 941                                 fHistoMCK0sPtY                                                          = new TH2F*[fnCuts];
 942                                 fHistoMCSecPi0PtvsSource                                        = new TH2F*[fnCuts];
 943                                 fHistoMCSecPi0Source                                            = new TH1F*[fnCuts];
 944                                 fHistoMCSecEtaPt                                                        = new TH1F*[fnCuts];
 945                                 fHistoMCSecEtaSource                                            = new TH1F*[fnCuts];
 946                                 fHistoTruePi0CaloPhotonInvMassPt                        = new TH2F*[fnCuts];
 947                                 fHistoTrueEtaCaloPhotonInvMassPt                        = new TH2F*[fnCuts];
 948                                 fHistoTruePi0CaloConvertedPhotonInvMassPt       = new TH2F*[fnCuts];
 949                                 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt = new TH2F*[fnCuts];
 950                                 fHistoTrueEtaCaloConvertedPhotonInvMassPt       = new TH2F*[fnCuts];
 951                                 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt = new TH2F*[fnCuts];
 952                                 fHistoTruePi0CaloElectronInvMassPt              = new TH2F*[fnCuts];
 953                                 fHistoTrueEtaCaloElectronInvMassPt              = new TH2F*[fnCuts];
 954                                 fHistoTruePi0CaloMergedClusterInvMassPt         = new TH2F*[fnCuts];
 955                                 fHistoTrueEtaCaloMergedClusterInvMassPt         = new TH2F*[fnCuts];
 956                                 fHistoTruePi0CaloMergedClusterPartConvInvMassPt         = new TH2F*[fnCuts];
 957                                 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt         = new TH2F*[fnCuts];
 958                                 fHistoTrueMotherCaloEMNonLeadingInvMassPt       = new TH2F*[fnCuts];
 959                                 fHistoTruePrimaryPi0MCPtResolPt                         = new TH2F*[fnCuts];
 960                                 fHistoTruePrimaryEtaMCPtResolPt                         = new TH2F*[fnCuts];
 961                                 fHistoTrueK0sWithPi0DaughterMCPt                        = new TH1F*[fnCuts];
 962                                 fHistoTrueEtaWithPi0DaughterMCPt                        = new TH1F*[fnCuts];
 963                                 fHistoTrueLambdaWithPi0DaughterMCPt             = new TH1F*[fnCuts];
 964                                 fHistoTrueBckGGInvMassPt                                        = new TH2F*[fnCuts];
 965                                 fHistoTrueBckContInvMassPt                                      = new TH2F*[fnCuts];
 966                                 fHistoTruePi0PtY                                                        = new TH2F*[fnCuts];
 967                                 fHistoTrueEtaPtY                                                        = new TH2F*[fnCuts];
 968                                 fHistoTruePi0PtAlpha                                            = new TH2F*[fnCuts];
 969                                 fHistoTrueEtaPtAlpha                                            = new TH2F*[fnCuts];
 970                                 fHistoTruePi0PtOpenAngle                                        = new TH2F*[fnCuts];
 971                                 fHistoTrueEtaPtOpenAngle                                        = new TH2F*[fnCuts];
 972                 fHistoTrueMotherPi0ConvPhotonEtaPhi         = new TH2F*[fnCuts];
 973                 fHistoTrueMotherEtaConvPhotonEtaPhi                     = new TH2F*[fnCuts];
 974                         }
 975                 }
 976
 977                 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 978                         TString cutstringEvent  = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
 979                         TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
 980                         TString cutstringCalo   = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
 981                         TString cutstringMeson  = "NoMesonCut";
 982                         if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
 983
 984                         fMCList[iCut] = new TList();
 985                         fMCList[iCut]->SetName(Form("%s_%s_%s_%s MC histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
 986                         fMCList[iCut]->SetOwner(kTRUE);
 987                         fCutFolder[iCut]->Add(fMCList[iCut]);
 988                         fHistoMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
 989                         fMCList[iCut]->Add(fHistoMCHeaders[iCut]);
 990                         fHistoMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
 991                         fMCList[iCut]->Add(fHistoMCAllGammaPt[iCut]);
 992                         fHistoMCAllGammaEMCALAccPt[iCut] = new TH1F("MC_AllGammaEMCALAcc_Pt","MC_AllGammaEMCALAcc_Pt",250,0,25);
 993                         fMCList[iCut]->Add(fHistoMCAllGammaEMCALAccPt[iCut]);
 994                         fHistoMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
 995                         fMCList[iCut]->Add(fHistoMCDecayGammaPi0Pt[iCut]);
 996                         fHistoMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
 997                         fMCList[iCut]->Add(fHistoMCDecayGammaRhoPt[iCut]);
 998                         fHistoMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
 999                         fMCList[iCut]->Add(fHistoMCDecayGammaEtaPt[iCut]);
1000                         fHistoMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
1001                         fMCList[iCut]->Add(fHistoMCDecayGammaOmegaPt[iCut]);
1002                         fHistoMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
1003                         fMCList[iCut]->Add(fHistoMCDecayGammaEtapPt[iCut]);
1004                         fHistoMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
1005                         fMCList[iCut]->Add(fHistoMCDecayGammaPhiPt[iCut]);
1006                         fHistoMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
1007                         fMCList[iCut]->Add(fHistoMCDecayGammaSigmaPt[iCut]);
1008                         fHistoMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
1009                         fMCList[iCut]->Add(fHistoMCConvGammaPt[iCut]);
1010
1011                         if (fDoPhotonQA > 0){
1012                                 fHistoMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
1013                                 fMCList[iCut]->Add(fHistoMCConvGammaR[iCut]);
1014                                 fHistoMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",2000,-2,2);
1015                                 fMCList[iCut]->Add(fHistoMCConvGammaEta[iCut]);
1016                         }
1017
1018                         if(fDoMesonAnalysis){
1019                                 fHistoMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
1020                                 fHistoMCPi0Pt[iCut]->Sumw2();
1021                                 fMCList[iCut]->Add(fHistoMCPi0Pt[iCut]);
1022                                 fHistoMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
1023                                 fHistoMCPi0WOWeightPt[iCut]->Sumw2();
1024                                 fMCList[iCut]->Add(fHistoMCPi0WOWeightPt[iCut]);
1025
1026                                 fHistoMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
1027                                 fHistoMCEtaPt[iCut]->Sumw2();
1028                                 fMCList[iCut]->Add(fHistoMCEtaPt[iCut]);
1029                                 fHistoMCEtaWOWeightPt[iCut] = new TH1F("MC_Eta_WOWeights_Pt","MC_Eta_WOWeights_Pt",250,0,25);
1030                                 fHistoMCEtaWOWeightPt[iCut]->Sumw2();
1031                                 fMCList[iCut]->Add(fHistoMCEtaWOWeightPt[iCut]);
1032                                 fHistoMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
1033                                 fHistoMCPi0InAccPt[iCut]->Sumw2();
1034                                 fMCList[iCut]->Add(fHistoMCPi0InAccPt[iCut]);
1035                                 fHistoMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
1036                                 fHistoMCEtaInAccPt[iCut]->Sumw2();
1037                                 fMCList[iCut]->Add(fHistoMCEtaInAccPt[iCut]);
1038                                 if (fDoMesonQA > 0){
1039                                         fHistoMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1040                                         fHistoMCPi0PtY[iCut]->Sumw2();
1041                                         SetLogBinningXTH2(fHistoMCPi0PtY[iCut]);
1042                                         fMCList[iCut]->Add(fHistoMCPi0PtY[iCut]);
1043                                         fHistoMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1044                                         fHistoMCEtaPtY[iCut]->Sumw2();
1045                                         SetLogBinningXTH2(fHistoMCEtaPtY[iCut]);
1046                                         fMCList[iCut]->Add(fHistoMCEtaPtY[iCut]);
1047                                         fHistoMCPi0PtAlpha[iCut] = new TH2F("MC_Pi0_Pt_Alpha","MC_Pi0_Pt_Alpha",150,0.03,15.,100,0,1);
1048                                         SetLogBinningXTH2(fHistoMCPi0PtAlpha[iCut]);
1049                                         fMCList[iCut]->Add(fHistoMCPi0PtAlpha[iCut]);
1050                                         fHistoMCEtaPtAlpha[iCut] = new TH2F("MC_Eta_Pt_Alpha","MC_Eta_Pt_Alpha",150,0.03,15.,100,0,1);
1051                                         SetLogBinningXTH2(fHistoMCEtaPtAlpha[iCut]);
1052                                         fMCList[iCut]->Add(fHistoMCEtaPtAlpha[iCut]);
1053
1054                                         fHistoMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",150,0,15);
1055                                         fHistoMCK0sPt[iCut]->Sumw2();
1056                                         fMCList[iCut]->Add(fHistoMCK0sPt[iCut]);
1057                                         fHistoMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",150,0,15);
1058                                         fHistoMCK0sWOWeightPt[iCut]->Sumw2();
1059                                         fMCList[iCut]->Add(fHistoMCK0sWOWeightPt[iCut]);
1060                                         fHistoMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1061                                         fHistoMCK0sPtY[iCut]->Sumw2();
1062                                         SetLogBinningXTH2(fHistoMCK0sPtY[iCut]);
1063                                         fMCList[iCut]->Add(fHistoMCK0sPtY[iCut]);
1064
1065                                         fHistoMCSecPi0Source[iCut] = new TH1F("MC_SecPi0_Source","MC_SecPi0_Source",5000,0.,5000);
1066                                         fMCList[iCut]->Add(fHistoMCSecPi0Source[iCut]);
1067                                         fHistoMCSecEtaSource[iCut] = new TH1F("MC_SecEta_Source","MC_SecEta_Source",5000,0,5000);
1068                                         fMCList[iCut]->Add(fHistoMCSecEtaSource[iCut]);
1069                                         fHistoMCSecPi0PtvsSource[iCut] = new TH2F("MC_SecPi0_Pt_Source","MC_SecPi0_Pt_Source",250,0.0,25.,16,-0.5,15.5);
1070                                         fHistoMCSecPi0PtvsSource[iCut]->Sumw2();
1071                                         fMCList[iCut]->Add(fHistoMCSecPi0PtvsSource[iCut]);
1072                                         fHistoMCSecEtaPt[iCut] = new TH1F("MC_SecEta_Pt","MC_SecEta_Pt",250,0,25);
1073                                         fHistoMCSecEtaPt[iCut]->Sumw2();
1074                                         fMCList[iCut]->Add(fHistoMCSecEtaPt[iCut]);
1075                                 }
1076
1077                         }
1078                         fTrueList[iCut] = new TList();
1079                         fTrueList[iCut]->SetName(Form("%s_%s_%s_%s True histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
1080                         fTrueList[iCut]->SetOwner(kTRUE);
1081                         fCutFolder[iCut]->Add(fTrueList[iCut]);
1082
1083                         fHistoTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
1084                         fTrueList[iCut]->Add(fHistoTrueConvGammaPt[iCut]);
1085
1086             fHistoTrueConvPi0GammaPt[iCut] = new TH1F("ESD_TrueConvPi0Gamma_Pt","ESD_TrueConvPi0Gamma_Pt",250,0,25);
1087                         fTrueList[iCut]->Add(fHistoTrueConvPi0GammaPt[iCut]);
1088
1089                         fHistoCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
1090                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
1091                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
1092                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
1093                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
1094                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
1095                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
1096                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
1097                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
1098                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
1099                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
1100                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
1101                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
1102                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
1103                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
1104                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
1105                         fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
1106                         fTrueList[iCut]->Add(fHistoCombinatorialPt[iCut]);
1107                         fHistoTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
1108                         fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaPt[iCut]);
1109                         fHistoTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
1110                         fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaPt[iCut]);
1111
1112                         fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
1113                         fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
1114                         fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
1115                         fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
1116
1117                         fHistoTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
1118                         fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaESDPtMCPt[iCut]);
1119
1120                         fHistoTrueClusGammaPt[iCut] = new TH1F("TrueClusGamma_Pt","ESD_TrueClusGamma_Pt",250,0,25);
1121                         fClusterOutputList[iCut]->Add(fHistoTrueClusGammaPt[iCut]);
1122                         fHistoTruePrimaryClusGammaPt[iCut] = new TH1F("TruePrimaryClusGamma_Pt","ESD_TruePrimaryClusGamma_Pt",250,0,25);
1123                         fClusterOutputList[iCut]->Add(fHistoTruePrimaryClusGammaPt[iCut]);
1124                         fHistoTruePrimaryClusGammaESDPtMCPt[iCut] = new TH2F("TruePrimaryClusGamma_Pt_MCPt","ESD_TruePrimaryClusGamma_MCPt",250,0,25,250,0,25);
1125                         fClusterOutputList[iCut]->Add(fHistoTruePrimaryClusGammaESDPtMCPt[iCut]);
1126
1127                         if (fDoPhotonQA > 0){
1128                                 fHistoTrueConvGammaEta[iCut] = new TH1F("ESD_TrueConvGamma_Eta","ESD_TrueConvGamma_Eta",2000,-2,2);
1129                                 fTrueList[iCut]->Add(fHistoTrueConvGammaEta[iCut]);
1130                         }
1131                         if (fDoClusterQA > 0){
1132                                 fHistoTrueClusUnConvGammaPt[iCut] = new TH1F("TrueClusUnConvGamma_Pt","TrueClusUnConvGamma_Pt",250,0,25);
1133                                 fClusterOutputList[iCut]->Add(fHistoTrueClusUnConvGammaPt[iCut]);
1134                                 fHistoTrueClusUnConvGammaMCPt[iCut] = new TH1F("TrueClusUnConvGamma_MCPt","TrueClusUnConvGamma_MCPt",250,0,25);
1135                                 fClusterOutputList[iCut]->Add(fHistoTrueClusUnConvGammaMCPt[iCut]);
1136                                 fHistoTrueClusElectronPt[iCut] = new TH1F("TrueClusElectron_Pt","TrueElectronGamma_Pt",250,0,25);
1137                                 fClusterOutputList[iCut]->Add(fHistoTrueClusElectronPt[iCut]);
1138                                 fHistoTrueClusConvGammaPt[iCut] = new TH1F("TrueClusConvGamma_Pt","TrueClusConvGamma_Pt",250,0,25);
1139                                 fClusterOutputList[iCut]->Add(fHistoTrueClusConvGammaPt[iCut]);
1140                                 fHistoTrueClusConvGammaMCPt[iCut] = new TH1F("TrueClusConvGamma_MCPt","TrueClusConvGamma_MCPt",250,0,25);
1141                                 fClusterOutputList[iCut]->Add(fHistoTrueClusConvGammaMCPt[iCut]);
1142                                 fHistoTrueClusConvGammaFullyPt[iCut] = new TH1F("TrueClusConvGammaFullyContained_Pt","TrueClusConvGammaFullyContained_Pt",250,0,25);
1143                                 fClusterOutputList[iCut]->Add(fHistoTrueClusConvGammaFullyPt[iCut]);
1144                                 fHistoTrueClusMergedGammaPt[iCut] = new TH1F("TrueClusMergedGamma_Pt","TrueClusMergedGamma_Pt",250,0,25);
1145                                 fClusterOutputList[iCut]->Add(fHistoTrueClusMergedGammaPt[iCut]);
1146                                 fHistoTrueClusMergedPartConvGammaPt[iCut] = new TH1F("TrueClusMergedPartConvGamma_Pt","TrueClusMergedPartConvGamma_Pt",250,0,25);
1147                                 fClusterOutputList[iCut]->Add(fHistoTrueClusMergedPartConvGammaPt[iCut]);
1148                                 fHistoTrueClusDalitzPt[iCut] = new TH1F("TrueClusDalitz_Pt","TrueClusDalitz_Pt",250,0,25);
1149                                 fClusterOutputList[iCut]->Add(fHistoTrueClusDalitzPt[iCut]);
1150                                 fHistoTrueClusDalitzMergedPt[iCut] = new TH1F("TrueClusDalitzMerged_Pt","TrueClusDalitzMerged_Pt",250,0,25);
1151                                 fClusterOutputList[iCut]->Add(fHistoTrueClusDalitzMergedPt[iCut]);
1152                                 fHistoTrueClusPhotonFromElecMotherPt[iCut] = new TH1F("TrueClusPhotonFromElecMother_Pt","TrueClusPhotonFromElecMother_Pt",250,0,25);
1153                                 fClusterOutputList[iCut]->Add(fHistoTrueClusPhotonFromElecMotherPt[iCut]);
1154                                 fHistoTrueClusShowerPt[iCut] = new TH1F("TrueClusShower_Pt","TrueClusShower_Pt",250,0,25);
1155                                 fClusterOutputList[iCut]->Add(fHistoTrueClusShowerPt[iCut]);
1156                                 fHistoTrueClusSubLeadingPt[iCut] = new TH1F("TrueClusSubleading_Pt","TrueClusSubleading_Pt",250,0,25);
1157                                 fClusterOutputList[iCut]->Add(fHistoTrueClusSubLeadingPt[iCut]);
1158                                 fHistoTrueClusNParticles[iCut] = new TH1I("TrueClusNParticles","TrueClusNParticles",20,0,20);
1159                                 fClusterOutputList[iCut]->Add(fHistoTrueClusNParticles[iCut]);
1160                                 fHistoTrueClusEMNonLeadingPt[iCut] = new TH1F("TrueClusEMNonLeading_Pt","TrueClusEMNonLeading_Pt",250,0,25);
1161                                 fClusterOutputList[iCut]->Add(fHistoTrueClusEMNonLeadingPt[iCut]);
1162                                 fHistoTrueNLabelsInClus[iCut] = new TH1F("TrueNLabelsInClus","TrueNLabelsInClus",100,-0.5,99.5);
1163                                 fClusterOutputList[iCut]->Add(fHistoTrueNLabelsInClus[iCut]);
1164                         }
1165
1166                         if(fDoMesonAnalysis){
1167                                 fHistoTruePi0InvMassPt[iCut] = new TH2F("ESD_TruePi0_InvMass_Pt","ESD_TruePi0_InvMass_Pt",800,0,0.8,250,0,25);
1168                                 fHistoTruePi0InvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2})");
1169                                 fHistoTruePi0InvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1170                                 fTrueList[iCut]->Add(fHistoTruePi0InvMassPt[iCut]);
1171                                 fHistoTrueEtaInvMassPt[iCut] = new TH2F("ESD_TrueEta_InvMass_Pt","ESD_TrueEta_InvMass_Pt",800,0,0.8,250,0,25);
1172                                 fHistoTruePi0InvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2})");
1173                                 fHistoTruePi0InvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1174                                 fTrueList[iCut]->Add(fHistoTrueEtaInvMassPt[iCut]);
1175
1176                                 fHistoTruePrimaryPi0InvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0_InvMass_Pt", "ESD_TruePrimaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1177                                 fHistoTruePrimaryPi0InvMassPt[iCut]->SetXTitle("M_{inv,prim #pi^{0}} (GeV/c^{2})");
1178                                 fHistoTruePrimaryPi0InvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1179                                 fHistoTruePrimaryPi0InvMassPt[iCut]->Sumw2();
1180                                 fTrueList[iCut]->Add(fHistoTruePrimaryPi0InvMassPt[iCut]);
1181
1182                                 fHistoTruePrimaryEtaInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEta_InvMass_Pt", "ESD_TruePrimaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
1183                                 fHistoTruePrimaryEtaInvMassPt[iCut]->SetXTitle("M_{inv,prim #eta} (GeV/c^{2})");
1184                                 fHistoTruePrimaryEtaInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1185                                 fHistoTruePrimaryEtaInvMassPt[iCut]->Sumw2();
1186                                 fTrueList[iCut]->Add(fHistoTruePrimaryEtaInvMassPt[iCut]);
1187
1188                                 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0W0Weights_InvMass_Pt", "ESD_TruePrimaryPi0W0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1189                                 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]->SetXTitle("M_{inv,prim #pi^{0}} (GeV/c^{2})");
1190                                 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1191                                 fTrueList[iCut]->Add(fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]);
1192
1193                                 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEtaW0Weights_InvMass_Pt", "ESD_TruePrimaryEtaW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1194                                 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]->SetXTitle("M_{inv,prim #eta} (GeV/c^{2})");
1195                                 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1196                                 fTrueList[iCut]->Add(fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]);
1197
1198                                 fProfileTruePrimaryPi0WeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryPi0Weights_InvMass_Pt", "ESD_TruePrimaryPi0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1199                                 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->SetXTitle("M_{inv,prim #pi^{0}} (GeV/c^{2})");
1200                                 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1201                                 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->Sumw2();
1202                                 fTrueList[iCut]->Add(fProfileTruePrimaryPi0WeightsInvMassPt[iCut]);
1203                                 fProfileTruePrimaryEtaWeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryEtaWeights_InvMass_Pt", "ESD_TruePrimaryEtaWeights_InvMass_Pt", 800,0,0.8,250,0,25);
1204                                 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->SetXTitle("M_{inv,prim #eta} (GeV/c^{2})");
1205                                 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1206                                 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->Sumw2();
1207                                 fTrueList[iCut]->Add(fProfileTruePrimaryEtaWeightsInvMassPt[iCut]);
1208
1209                                 fHistoTrueSecondaryPi0InvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0_InvMass_Pt", "ESD_TrueSecondaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1210                                 fHistoTrueSecondaryPi0InvMassPt[iCut]->SetXTitle("M_{inv,sec #pi^{0}} (GeV/c^{2})");
1211                                 fHistoTrueSecondaryPi0InvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1212                                 fHistoTrueSecondaryPi0InvMassPt[iCut]->Sumw2();
1213                                 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0InvMassPt[iCut]);
1214
1215                                 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromK0s_InvMass_Pt","ESD_TrueSecondaryPi0FromK0s_InvMass_Pt",800,0,0.8,250,0,25);
1216                                 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0} from K^{0}_{S}} (GeV/c^{2})");
1217                                 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1218                                 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->Sumw2();
1219                                 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]);
1220                                 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromEta_InvMass_Pt","ESD_TrueSecondaryPi0FromEta_InvMass_Pt",800,0,0.8,250,0,25);
1221                                 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0} from #eta} (GeV/c^{2})");
1222                                 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]->SetYTitle("#pi^{0}  p_{T} (GeV/c)");
1223                                 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]);
1224                                 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromLambda_InvMass_Pt","ESD_TrueSecondaryPi0FromLambda_InvMass_Pt",800,0,0.8,250,0,25);
1225                                 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0} from #Lambda} (GeV/c^{2})");
1226                                 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]->SetYTitle("#pi^{0}  p_{T} (GeV/c)");
1227                                 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]);
1228
1229                                 fHistoTruePrimaryPi0PhotonPairPtconv[iCut] = new TH2F("ESD_TruePrimaryPi0_InvMass_PtConv","",800,0,0.8,250,0,25);
1230                                 fHistoTruePrimaryPi0PhotonPairPtconv[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2})");
1231                                 fHistoTruePrimaryPi0PhotonPairPtconv[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
1232                                 fHistoTruePrimaryPi0PhotonPairPtconv[iCut]->Sumw2();
1233                                 fTrueList[iCut]->Add(fHistoTruePrimaryPi0PhotonPairPtconv[iCut]);
1234
1235                                 fHistoTrueSecondaryPi0PhotonPairPtconv[iCut] = new TH2F("ESD_TrueSecondaryPi0_InvMass_PtConv","",800,0,0.8,250,0,25);
1236                                 fHistoTrueSecondaryPi0PhotonPairPtconv[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2})");
1237                                 fHistoTrueSecondaryPi0PhotonPairPtconv[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
1238                                 fHistoTrueSecondaryPi0PhotonPairPtconv[iCut]->Sumw2();
1239                                 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0PhotonPairPtconv[iCut]);
1240
1241                                 fHistoTruePrimaryEtaPhotonPairPtconv[iCut] = new TH2F("ESD_TruePrimaryEta_InvMass_PtConv","",800,0,0.8,250,0,25);
1242                                 fHistoTruePrimaryEtaPhotonPairPtconv[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2})");
1243                                 fHistoTruePrimaryEtaPhotonPairPtconv[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
1244                                 fHistoTruePrimaryEtaPhotonPairPtconv[iCut]->Sumw2();
1245                                 fTrueList[iCut]->Add(fHistoTruePrimaryEtaPhotonPairPtconv[iCut]);
1246
1247                                 fHistoTruePrimaryPi0DCPtconv[iCut] = new TH1F("ESD_TruePrimaryPi0DC_PtConv","",250,0,25);
1248                                 fHistoTruePrimaryPi0DCPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1249                                 fHistoTruePrimaryPi0DCPtconv[iCut]->Sumw2();
1250                                 fTrueList[iCut]->Add(fHistoTruePrimaryPi0DCPtconv[iCut]);
1251
1252                                 fHistoTrueSecondaryPi0DCPtconv[iCut] = new TH1F("ESD_TrueSecondaryPi0DC_PtConv","",250,0,25);
1253                                 fHistoTrueSecondaryPi0DCPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1254                                 fHistoTrueSecondaryPi0DCPtconv[iCut]->Sumw2();
1255                                 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0DCPtconv[iCut]);
1256
1257                                 fHistoTruePrimaryEtaDCPtconv[iCut] = new TH1F("ESD_TruePrimaryEtaDC_PtConv","",250,0,25);
1258                                 fHistoTruePrimaryEtaDCPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1259                                 fHistoTruePrimaryEtaDCPtconv[iCut]->Sumw2();
1260                                 fTrueList[iCut]->Add(fHistoTruePrimaryEtaDCPtconv[iCut]);
1261
1262                                 fHistoTruePrimaryPi0MissingPtconv[iCut] = new TH1F("ESD_TruePrimaryPi0Missing_PtConv","",250,0,25);
1263                                 fHistoTruePrimaryPi0MissingPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1264                                 fHistoTruePrimaryPi0MissingPtconv[iCut]->Sumw2();
1265                                 fTrueList[iCut]->Add(fHistoTruePrimaryPi0MissingPtconv[iCut]);
1266
1267                                 fHistoTrueSecondaryPi0MissingPtconv[iCut] = new TH1F("ESD_TrueSecondaryPi0Missing_PtConv","",250,0,25);
1268                                 fHistoTrueSecondaryPi0MissingPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1269                                 fHistoTrueSecondaryPi0MissingPtconv[iCut]->Sumw2();
1270                                 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0MissingPtconv[iCut]);
1271
1272                                 fHistoTruePrimaryEtaMissingPtconv[iCut] = new TH1F("ESD_TruePrimaryEtaMissing_PtConv","",250,0,25);
1273                                 fHistoTruePrimaryEtaMissingPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1274                                 fHistoTruePrimaryEtaMissingPtconv[iCut]->Sumw2();
1275                                 fTrueList[iCut]->Add(fHistoTruePrimaryEtaMissingPtconv[iCut]);
1276
1277                                 if (fDoMesonQA > 0){
1278                                         fHistoTruePi0CaloPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloPhoton_InvMass_Pt","ESD_TruePi0CaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1279                                         fHistoTruePi0CaloPhotonInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma #gamma");
1280                                         fHistoTruePi0CaloPhotonInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1281                                         fTrueList[iCut]->Add(fHistoTruePi0CaloPhotonInvMassPt[iCut]);
1282
1283                                         fHistoTrueEtaCaloPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloPhoton_InvMass_Pt","ESD_TrueEtaCaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1284                                         fHistoTrueEtaCaloPhotonInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma #gamma");
1285                                         fHistoTrueEtaCaloPhotonInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1286                                         fTrueList[iCut]->Add(fHistoTrueEtaCaloPhotonInvMassPt[iCut]);
1287
1288                                         fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhoton_InvMass_Pt","ESD_TruePi0CaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1289                                         fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma #gamma_{conv}");
1290                                         fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1291                                         fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]);
1292
1293                                         fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt","ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1294                                         fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma #gamma_{conv,matched}");
1295                                         fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1296                                         fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut]);
1297
1298                                         fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt","ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1299                                         fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma #gamma_{conv}");
1300                                         fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1301                                         fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]);
1302
1303                                         fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt","ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1304                                         fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma #gamma_{conv,matched}");
1305                                         fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1306                                         fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut]);
1307
1308                                         fHistoTruePi0CaloElectronInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloElectron_InvMass_Pt","ESD_TruePi0CaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1309                                         fHistoTruePi0CaloElectronInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma e^{#pm}");
1310                                         fHistoTruePi0CaloElectronInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1311                                         fTrueList[iCut]->Add(fHistoTruePi0CaloElectronInvMassPt[iCut]);
1312                                         fHistoTrueEtaCaloElectronInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloElectron_InvMass_Pt","ESD_TrueEtaCaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1313                                         fHistoTrueEtaCaloElectronInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma e^{#pm}");
1314                                         fHistoTrueEtaCaloElectronInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1315                                         fTrueList[iCut]->Add(fHistoTrueEtaCaloElectronInvMassPt[iCut]);
1316
1317                                         fHistoTruePi0CaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedCluster_InvMass_Pt","ESD_TruePi0CaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1318                                         fHistoTruePi0CaloMergedClusterInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma merged cluster");
1319                                         fHistoTruePi0CaloMergedClusterInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1320                                         fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterInvMassPt[iCut]);
1321                                         fHistoTrueEtaCaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedCluster_InvMass_Pt","ESD_TrueEtaCaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1322                                         fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma merged cluster");
1323                                         fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1324                                         fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]);
1325
1326                                         fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut] = new TH2F("ESD_TrueMotherCaloEMNonLeading_InvMass_Pt","ESD_TrueMotherCaloEMNonLeading_InvMass_Pt",800,0,0.8,250,0,25);
1327                                         fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut]->SetXTitle("M_{inv} (GeV/c^{2}) #gamma cluster no leading EM");
1328                                         fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut]->SetYTitle("#pair p_{T} (GeV/c)");
1329                                         fTrueList[iCut]->Add(fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut]);
1330                                         fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt","ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1331                                         fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma merged cluster, part conv");
1332                                         fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1333                                         fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]);
1334                                         fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt","ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1335                                         fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma merged cluster, part conv");
1336                                         fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1337                                         fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]);
1338
1339                                         fHistoTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1340                                         fHistoTruePrimaryPi0MCPtResolPt[iCut]->SetXTitle("#pi^{0} p_{T,MC} (GeV/c)");
1341                                         fHistoTruePrimaryPi0MCPtResolPt[iCut]->SetYTitle("#pi^{0} (p_{T,rec}-p_{T,MC})/p_{T,MC} ()");
1342                                         fHistoTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
1343                                         SetLogBinningXTH2(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1344                                         fTrueList[iCut]->Add(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1345
1346                                         fHistoTruePrimaryEtaMCPtResolPt[iCut]  = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1347                                         fHistoTruePrimaryEtaMCPtResolPt[iCut]->SetXTitle("#eta p_{T,MC} (GeV/c)");
1348                                         fHistoTruePrimaryEtaMCPtResolPt[iCut]->SetYTitle("#eta (p_{T,rec}-p_{T,MC})/p_{T,MC} ()");
1349                                         fHistoTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
1350                                         SetLogBinningXTH2(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1351                                         fTrueList[iCut]->Add(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1352
1353                                         fHistoTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
1354                                         fHistoTrueBckGGInvMassPt[iCut]->SetXTitle("M_{inv} (GeV/c^{2}) #gamma #gamma no signal");
1355                                         fHistoTrueBckGGInvMassPt[iCut]->SetYTitle("#pair p_{T} (GeV/c)");
1356                                         fTrueList[iCut]->Add(fHistoTrueBckGGInvMassPt[iCut]);
1357                                         fHistoTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
1358                                         fHistoTrueBckContInvMassPt[iCut]->SetXTitle("M_{inv} (GeV/c^{2}) contamination");
1359                                         fHistoTrueBckContInvMassPt[iCut]->SetYTitle("#pair p_{T} (GeV/c)");
1360                                         fTrueList[iCut]->Add(fHistoTrueBckContInvMassPt[iCut]);
1361                                         fHistoTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
1362                                         fHistoTrueK0sWithPi0DaughterMCPt[iCut]->SetXTitle("K^{0}_{s} p_{MC,T} (GeV/c) for K^{0}_{s} where #pi^{0} rec ");
1363                                         fTrueList[iCut]->Add(fHistoTrueK0sWithPi0DaughterMCPt[iCut]);
1364                                         fHistoTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
1365                                         fHistoTrueEtaWithPi0DaughterMCPt[iCut]->SetXTitle("#eta p_{MC,T} (GeV/c) for #eta where #pi^{0} rec ");
1366                                         fTrueList[iCut]->Add(fHistoTrueEtaWithPi0DaughterMCPt[iCut]);
1367                                         fHistoTrueLambdaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueLambdaWithPi0Daughter_MCPt","ESD_TrueLambdaWithPi0Daughter_MCPt",250,0,25);
1368                                         fHistoTrueLambdaWithPi0DaughterMCPt[iCut]->SetXTitle("#Lambda p_{MC,T} (GeV/c) for #Lambda where #pi^{0} rec ");
1369                                         fTrueList[iCut]->Add(fHistoTrueLambdaWithPi0DaughterMCPt[iCut]);
1370
1371                                         fHistoTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1372                                         fHistoTruePi0PtY[iCut]->SetYTitle("Y_{#pi^{0}}");
1373                                         fHistoTruePi0PtY[iCut]->SetXTitle("#pi^{0} p_{T} (GeV/c)");
1374                                         SetLogBinningXTH2(fHistoTruePi0PtY[iCut]);
1375                                         fTrueList[iCut]->Add(fHistoTruePi0PtY[iCut]);
1376                                         fHistoTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1377                                         fHistoTrueEtaPtY[iCut]->SetYTitle("Y_{#eta}");
1378                                         fHistoTrueEtaPtY[iCut]->SetXTitle("#eta p_{T} (GeV/c)");
1379                                         SetLogBinningXTH2(fHistoTrueEtaPtY[iCut]);
1380                                         fTrueList[iCut]->Add(fHistoTrueEtaPtY[iCut]);
1381                                         fHistoTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",150,0.03,15.,100,0,1);
1382                                         fHistoTruePi0PtAlpha[iCut]->SetYTitle("#alpha_{#pi^{0}}");
1383                                         fHistoTruePi0PtAlpha[iCut]->SetXTitle("#pi^{0} p_{T} (GeV/c)");
1384                                         SetLogBinningXTH2(fHistoTruePi0PtAlpha[iCut]);
1385                                         fTrueList[iCut]->Add(fHistoTruePi0PtAlpha[iCut]);
1386                                         fHistoTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",150,0.03,15.,100,0,1);
1387                                         fHistoTrueEtaPtAlpha[iCut]->SetYTitle("#alpha_{#eta}");
1388                                         fHistoTrueEtaPtAlpha[iCut]->SetXTitle("#eta p_{T} (GeV/c)");
1389                                         SetLogBinningXTH2(fHistoTrueEtaPtAlpha[iCut]);
1390                                         fTrueList[iCut]->Add(fHistoTrueEtaPtAlpha[iCut]);
1391
1392                                         fHistoTruePi0PtOpenAngle[iCut] = new TH2F("ESD_TruePi0_Pt_OpenAngle","ESD_TruePi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1393                                         fHistoTruePi0PtOpenAngle[iCut]->SetYTitle("#theta_{#pi^{0}}");
1394                                         fHistoTruePi0PtOpenAngle[iCut]->SetXTitle("#pi^{0} p_{T} (GeV/c)");
1395                                         SetLogBinningXTH2(fHistoTruePi0PtOpenAngle[iCut]);
1396                                         fTrueList[iCut]->Add(fHistoTruePi0PtOpenAngle[iCut]);
1397                                         fHistoTrueEtaPtOpenAngle[iCut] = new TH2F("ESD_TrueEta_Pt_OpenAngle","ESD_TrueEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1398                                         fHistoTrueEtaPtOpenAngle[iCut]->SetYTitle("#theta_{#eta}");
1399                                         fHistoTrueEtaPtOpenAngle[iCut]->SetXTitle("#eta p_{T} (GeV/c)");
1400                                         SetLogBinningXTH2(fHistoTrueEtaPtOpenAngle[iCut]);
1401                                         fTrueList[iCut]->Add(fHistoTrueEtaPtOpenAngle[iCut]);
1402
1403                                         fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut] = new TH2F("ESD_TrueMotherPi0ConvPhoton_Eta_Phi","conv photons for true #pi^{0}",600,0,2*TMath::Pi(),200,-1,1);
1404                                         fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut]->SetXTitle("#phi_{#gamma_{conv}} (rad)");
1405                                         fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut]->SetYTitle("#eta_{#gamma_{conv}}");
1406                                         fTrueList[iCut]->Add(fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut]);
1407                                         fHistoTrueMotherEtaConvPhotonEtaPhi[iCut] = new TH2F("ESD_TrueMotherEtaConvPhoton_Eta_Phi","conv photons for true #eta",600,0,2*TMath::Pi(),200,-1,1);
1408                                         fHistoTrueMotherEtaConvPhotonEtaPhi[iCut]->SetXTitle("#phi_{#gamma_{conv}} (rad)");
1409                                         fHistoTrueMotherEtaConvPhotonEtaPhi[iCut]->SetYTitle("#eta_{#gamma_{conv}}");
1410                                         fTrueList[iCut]->Add(fHistoTrueMotherEtaConvPhotonEtaPhi[iCut]);
1411
1412                                 }
1413                         }
1414                 }
1415         }
1416
1417         fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1418         if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1419
1420         if(fV0Reader)
1421                 if((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())
1422                         if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1423                                 fOutputContainer->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1424         if(fV0Reader)
1425                 if((AliConvEventCuts*)fV0Reader->GetEventCuts())
1426                         if(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms())
1427                                 fOutputContainer->Add(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms());
1428
1429
1430         for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1431                 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))) continue;
1432                 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms()){
1433                         fCutFolder[iCut]->Add(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms());
1434                 }
1435                 if(!((AliConversionPhotonCuts*)fCutArray->At(iCut))) continue;
1436                 if(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms()){
1437                         fCutFolder[iCut]->Add(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms());
1438                 }
1439                 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))) continue;
1440                 if(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms()){
1441                         fCutFolder[iCut]->Add(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms());
1442                 }
1443                 if(fDoMesonAnalysis){
1444                         if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
1445                         if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
1446                                 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
1447                         }
1448                 }
1449         }
1450         PostData(1, fOutputContainer);
1451 }
1452 //_____________________________________________________________________________
1453 Bool_t AliAnalysisTaskGammaConvCalo::Notify()
1454 {
1455         for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1456                 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))->GetDoEtaShift()){
1457                         fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1458                         continue; // No Eta Shift requested, continue
1459                 }
1460                 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1461                         ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
1462                         fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1463                         ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1464                         continue;
1465                 }
1466                 else{
1467                         printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
1468                                         (((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber()).Data(),((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift());
1469                         fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1470                         ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1471                 }
1472         }
1473
1474         return kTRUE;
1475 }
1476 //_____________________________________________________________________________
1477 void AliAnalysisTaskGammaConvCalo::UserExec(Option_t *)
1478 {
1479         //
1480         // Called for each event
1481         //
1482         Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
1483         if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1484                 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1485                 fHistoNEvents[iCut]->Fill(eventQuality);
1486                 }
1487                 return;
1488         }
1489
1490         if(fIsMC) fMCEvent = MCEvent();
1491         if(fMCEvent == NULL) fIsMC = kFALSE;
1492
1493         fInputEvent = InputEvent();
1494
1495         if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
1496                 fMCStack = fMCEvent->Stack();
1497                 if(fMCStack == NULL) fIsMC = kFALSE;
1498         }
1499
1500         if(fInputEvent->IsA()==AliAODEvent::Class()){
1501                 fInputEvent->InitMagneticField();
1502         }
1503
1504         fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
1505
1506         // ------------------- BeginEvent ----------------------------
1507
1508         AliEventplane *EventPlane = fInputEvent->GetEventplane();
1509         if(fIsHeavyIon ==1)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
1510         else fEventPlaneAngle=0.0;
1511
1512         if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1513                 RelabelAODPhotonCandidates(kTRUE);    // In case of AODMC relabeling MC
1514                 fV0Reader->RelabelAODs(kTRUE);
1515         }
1516
1517
1518         for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1519
1520                 fiCut = iCut;
1521
1522                 Bool_t isRunningEMCALrelAna = kFALSE;
1523                 if (((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->GetClusterType() == 1) isRunningEMCALrelAna = kTRUE;
1524
1525                 Int_t eventNotAccepted = ((AliConvEventCuts*)fEventCutArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon,isRunningEMCALrelAna);
1526
1527                 if(eventNotAccepted){
1528                 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1529                         fHistoNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1530                         continue;
1531                 }
1532
1533                 if(eventQuality != 0){// Event Not Accepted
1534                         //cout << "event rejected due to: " <<eventQuality << endl;
1535                         fHistoNEvents[iCut]->Fill(eventQuality);
1536                         continue;
1537                 }
1538
1539                 fHistoNEvents[iCut]->Fill(eventQuality); // Should be 0 here
1540                 fHistoNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
1541                 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->IsHeavyIon() == 2)    fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
1542                         else fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1543
1544                 if(fIsMC){
1545                         // Process MC Particle
1546                         fStringRecTruePi0s[iCut] = "";
1547                         fStringRecTrueEtas[iCut] = "";
1548                         if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection() != 0){
1549                                 if(fInputEvent->IsA()==AliESDEvent::Class()){
1550                                 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1551                                                                                                                                                                         ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1552                                                                                                                                                                         fMCEvent);
1553                                 }
1554                                 else if(fInputEvent->IsA()==AliAODEvent::Class()){
1555                                 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1556                                                                                                                                                                         ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1557                                                                                                                                                                         fInputEvent);
1558                                 }
1559
1560                                 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader()){
1561                                         for(Int_t i = 0;i<(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
1562                                                 TString nameBin= fHistoMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
1563                                                 if (nameBin.CompareTo("")== 0){
1564                                                         TString nameHeader = ((TObjString*)((TList*)((AliConvEventCuts*)fEventCutArray->At(iCut))
1565                                                                                                                                 ->GetAcceptedHeader())->At(i))->GetString();
1566                                                         fHistoMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
1567                                                 }
1568                                         }
1569                                 }
1570                         }
1571                 }
1572                 if(fIsMC){
1573                         if(fInputEvent->IsA()==AliESDEvent::Class())
1574                                 ProcessMCParticles();
1575                         if(fInputEvent->IsA()==AliAODEvent::Class())
1576                                 ProcessAODMCParticles();
1577                 }
1578
1579                 // it is in the loop to have the same conversion cut string (used also for MC stuff that should be same for V0 and Cluster)
1580                 ProcessClusters();                                      // process calo clusters
1581                 ProcessPhotonCandidates();                              // Process this cuts gammas
1582
1583                 fHistoNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
1584                 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks(),fGammaCandidates->GetEntries());
1585                 if(fDoMesonAnalysis){ // Meson Analysis
1586                 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1587                         fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
1588                         fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
1589                         fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
1590                         fUnsmearedE =  new Double_t[fGammaCandidates->GetEntries()];
1591
1592                         for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1593                         fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
1594                         fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
1595                         fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
1596                         fUnsmearedE[gamma] =  ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
1597                         ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
1598                         }
1599                 }
1600
1601                 CalculatePi0Candidates(); // Combine Gammas from conversion and from calo
1602
1603                 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1604                         if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1605                                 CalculateBackground(); // Combinatorial Background
1606                                 UpdateEventByEventData(); // Store Event for mixed Events
1607                         }
1608                         else{
1609                                 CalculateBackgroundRP(); // Combinatorial Background
1610                                 fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
1611                                 fBGClusHandlerRP[iCut]->AddEvent(fClusterCandidates,fInputEvent); // Store Event for mixed Events
1612                         }
1613                 }
1614
1615                 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class()){
1616                         ProcessConversionPhotonsForMissingTagsAOD(); //Count missing tags
1617                 } else if (fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
1618                         ProcessConversionPhotonsForMissingTags(); //Count missing tags
1619                 }
1620
1621                 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1622                         for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1623                         ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1624                         ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1625                         ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1626                         ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
1627                         }
1628                         delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1629                         delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1630                         delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1631                         delete[] fUnsmearedE;  fUnsmearedE  = 0x0;
1632                 }
1633                 }
1634
1635                 fGammaCandidates->Clear(); // delete this cuts good gammas
1636                 fClusterCandidates->Clear(); // delete cluster candidates
1637         }
1638
1639         if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1640                 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
1641                 fV0Reader->RelabelAODs(kFALSE);
1642         }
1643
1644         PostData(1, fOutputContainer);
1645 }
1646
1647 //________________________________________________________________________
1648 void AliAnalysisTaskGammaConvCalo::ProcessClusters()
1649 {
1650
1651         Int_t nclus = 0;
1652         nclus = fInputEvent->GetNumberOfCaloClusters();
1653
1654 //      cout << nclus << endl;
1655
1656         if(nclus == 0)  return;
1657
1658         // vertex
1659         Double_t vertex[3] = {0};
1660         InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1661
1662         // Loop over EMCal clusters
1663         for(Long_t i = 0; i < nclus; i++){
1664
1665                 AliVCluster* clus = NULL;
1666                 clus = fInputEvent->GetCaloCluster(i);
1667                 if (!clus) continue;
1668                 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelected(clus,fInputEvent,fIsMC)) continue;
1669                 // TLorentzvector with cluster
1670                 TLorentzVector clusterVector;
1671                 clus->GetMomentum(clusterVector,vertex);
1672
1673                 TLorentzVector* tmpvec = new TLorentzVector();
1674                 tmpvec->SetPxPyPzE(clusterVector.Px(),clusterVector.Py(),clusterVector.Pz(),clusterVector.E());
1675
1676                 // convert to AODConversionPhoton
1677                 AliAODConversionPhoton *PhotonCandidate=new AliAODConversionPhoton(tmpvec);
1678                 if(!PhotonCandidate) continue;
1679
1680                 // Flag Photon as CaloPhoton
1681                 PhotonCandidate->SetIsCaloPhoton();
1682                 PhotonCandidate->SetCaloClusterRef(i);
1683                 // get MC label
1684                 if(fIsMC){
1685                         Int_t* mclabelsCluster = clus->GetLabels();
1686                         PhotonCandidate->SetNCaloPhotonMCLabels(clus->GetNLabels());
1687 //                      cout << clus->GetNLabels() << endl;
1688                         if (clus->GetNLabels()>0){
1689                                 for (Int_t k =0; k< (Int_t)clus->GetNLabels(); k++){
1690                                         if (k< 20)PhotonCandidate->SetCaloPhotonMCLabel(k,mclabelsCluster[k]);
1691 //                                      Int_t pdgCode = fMCStack->Particle(mclabelsCluster[k])->GetPdgCode();
1692 //                                      cout << "label " << k << "\t" << mclabelsCluster[k] << " pdg code: " << pdgCode << endl;
1693                                 }
1694                         }
1695                 }
1696
1697                 fIsFromMBHeader = kTRUE;
1698                 fIsOverlappingWithOtherHeader = kFALSE;
1699                 // test whether largest contribution to cluster orginates in added signals
1700                 if (fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetCaloPhotonMCLabel(0), fMCStack, fInputEvent) == 0) fIsFromMBHeader = kFALSE;
1701                 if (fIsMC ){
1702                         if (clus->GetNLabels()>1){
1703                                 Int_t* mclabelsCluster = clus->GetLabels();
1704                                 for (Int_t l = 1; l < (Int_t)clus->GetNLabels(); l++ ){
1705                                         if (((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(mclabelsCluster[l], fMCStack, fInputEvent) == 0) fIsOverlappingWithOtherHeader = kTRUE;
1706                                 }
1707                         }
1708                 }
1709
1710                 if (fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
1711                         fHistoClusGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1712                         fClusterCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1713                 }
1714                 if (fIsFromMBHeader && fIsOverlappingWithOtherHeader) fHistoClusOverlapHeadersGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1715
1716                 if(fIsMC){
1717                         if(fInputEvent->IsA()==AliESDEvent::Class()){
1718                                 ProcessTrueClusterCandidates(PhotonCandidate);
1719                         } else {
1720                                 ProcessTrueClusterCandidatesAOD(PhotonCandidate);
1721                         }
1722                 }
1723
1724                 delete tmpvec;
1725         }
1726
1727 }
1728
1729 //________________________________________________________________________
1730 void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1731 {
1732
1733         TParticle *Photon = NULL;
1734         if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1735         fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1736
1737         if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0)Photon = fMCStack->Particle(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1738                 else return;
1739
1740         if(Photon == NULL){
1741         //    cout << "no photon" << endl;
1742                 return;
1743         }
1744
1745         TruePhotonCandidate->SetCaloPhotonMCFlags(fMCStack);
1746
1747         // True Photon
1748         if(fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
1749                 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1750                         else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1751                 if (fDoClusterQA > 0){
1752                         if (TruePhotonCandidate->IsLargestComponentPhoton()){
1753                                 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1754                                 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1755                         }
1756                         if (TruePhotonCandidate->IsLargestComponentElectron())
1757                                 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1758                         if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1759                                 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1760                                 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(Photon->GetMother(0)))->Pt());
1761                         }
1762                         if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1763                                 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1764                         if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1765                                 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1766                         if (TruePhotonCandidate->IsMergedPartConv())
1767                                 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1768                         if (TruePhotonCandidate->IsDalitz())
1769                                 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1770                         if (TruePhotonCandidate->IsDalitzMerged())
1771                                 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1772                         if (TruePhotonCandidate->IsPhotonWithElecMother())
1773                                 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1774                         if (TruePhotonCandidate->IsShower())
1775                                 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1776                         if (TruePhotonCandidate->IsSubLeadingEM())
1777                                 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1778                         fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1779                 }
1780         }
1781
1782         if(Photon->GetMother(0) <= fMCStack->GetNprimary()){
1783                 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1784                 if(fIsFromMBHeader){
1785                         fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1786                         fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1787                 }
1788         }
1789         return;
1790 }
1791
1792
1793 //________________________________________________________________________
1794 void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1795 {
1796         AliAODMCParticle *Photon = NULL;
1797         TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1798         if (AODMCTrackArray){
1799                 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1800                 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0) Photon = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1801                         else return;
1802         } else {
1803                 AliInfo("AODMCTrackArray could not be loaded");
1804                 return;
1805         }
1806
1807         if(Photon == NULL){
1808         //      cout << "no photon" << endl;
1809                 return;
1810         }
1811         TruePhotonCandidate->SetCaloPhotonMCFlagsAOD(fInputEvent);
1812         fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1813         // True Photon
1814         if(fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
1815                 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1816                         else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1817                 if (fDoClusterQA > 0){
1818                         if (TruePhotonCandidate->IsLargestComponentPhoton()) {
1819                                 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1820                                 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1821                         }
1822                         if (TruePhotonCandidate->IsLargestComponentElectron())
1823                                 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1824                         if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()) {
1825                                 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1826                                 AliAODMCParticle *Mother = (AliAODMCParticle*) AODMCTrackArray->At(Photon->GetMother());
1827                                 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(Mother->Pt());
1828                         }
1829                         if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1830                                 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1831                         if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1832                                 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1833                         if (TruePhotonCandidate->IsMergedPartConv())
1834                                 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1835                         if (TruePhotonCandidate->IsDalitz())
1836                                 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1837                         if (TruePhotonCandidate->IsDalitzMerged())
1838                                 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1839                         if (TruePhotonCandidate->IsPhotonWithElecMother())
1840                                 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1841                         if (TruePhotonCandidate->IsShower())
1842                                 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1843                         if (TruePhotonCandidate->IsSubLeadingEM())
1844                                 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1845                         fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1846                 }
1847         }
1848
1849         // True Photon
1850         if(fIsFromMBHeader){
1851                 fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1852 //              if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1853         }
1854
1855         if(Photon->IsPrimary()){
1856                 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1857                 if(fIsFromMBHeader){
1858                         fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1859                         fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1860                 }
1861         }
1862 }
1863
1864 //________________________________________________________________________
1865 void AliAnalysisTaskGammaConvCalo::ProcessPhotonCandidates()
1866 {
1867         Int_t nV0 = 0;
1868         TList *GammaCandidatesStepOne = new TList();
1869         TList *GammaCandidatesStepTwo = new TList();
1870         // Loop over Photon Candidates allocated by ReaderV1
1871         for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1872                 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1873                 if(!PhotonCandidate) continue;
1874                 fIsFromMBHeader = kTRUE;
1875                 if(fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1876                         Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1877                         if(isPosFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1878                         Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1879                         if(isNegFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1880                         if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1881                 }
1882
1883                 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
1884                 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(PhotonCandidate->GetPhotonPhi(),fEventPlaneAngle)) continue;
1885                 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1886                 !((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1887                         fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1888
1889                         if(fIsFromMBHeader){
1890                                 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1891                                 if (fDoPhotonQA > 0){
1892                                 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1893                                 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1894                                 }
1895                         }
1896                         if(fIsMC){
1897                                 if(fInputEvent->IsA()==AliESDEvent::Class())
1898                                 ProcessTruePhotonCandidates(PhotonCandidate);
1899                                 if(fInputEvent->IsA()==AliAODEvent::Class())
1900                                 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1901                         }
1902                         if (fIsFromMBHeader && fDoPhotonQA == 2){
1903                                 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1904                                         fPtGamma = PhotonCandidate->Pt();
1905                                         fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1906                                         fRConvPhoton = PhotonCandidate->GetConversionRadius();
1907                                         fEtaPhoton = PhotonCandidate->GetPhotonEta();
1908                                         fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1909                                         fTreeConvGammaPtDcazCat[fiCut]->Fill();
1910                                 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1911                                         fPtGamma = PhotonCandidate->Pt();
1912                                         fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1913                                         fRConvPhoton = PhotonCandidate->GetConversionRadius();
1914                                         fEtaPhoton = PhotonCandidate->GetPhotonEta();
1915                                         fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1916                                         fTreeConvGammaPtDcazCat[fiCut]->Fill();
1917                                 }
1918                         }
1919                 } else if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1920                         ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1921                         nV0++;
1922                         GammaCandidatesStepOne->Add(PhotonCandidate);
1923                 } else if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1924                                 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1925                         GammaCandidatesStepTwo->Add(PhotonCandidate);
1926                 }
1927         }
1928         if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
1929                 for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1930                         AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1931                         if(!PhotonCandidate) continue;
1932                         fIsFromMBHeader = kTRUE;
1933                         if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1934                                 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1935                                 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1936                                 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1937                         }
1938                         if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1939                         if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1940                                 fGammaCandidates->Add(PhotonCandidate);
1941                                 if(fIsFromMBHeader){
1942                                         fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1943                                         if (fDoPhotonQA > 0){
1944                                                 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1945                                                 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1946                                         }
1947                                 }
1948                         }
1949                         if(fIsMC){
1950                                 if(fInputEvent->IsA()==AliESDEvent::Class())
1951                                         ProcessTruePhotonCandidates(PhotonCandidate);
1952                                 if(fInputEvent->IsA()==AliAODEvent::Class())
1953                                         ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1954                         } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1955
1956                         if (fIsFromMBHeader && fDoPhotonQA == 2){
1957                                 if (fIsHeavyIon ==1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1958                                         fPtGamma = PhotonCandidate->Pt();
1959                                         fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1960                                         fRConvPhoton = PhotonCandidate->GetConversionRadius();
1961                                         fEtaPhoton = PhotonCandidate->GetPhotonEta();
1962                                         fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1963                                         fTreeConvGammaPtDcazCat[fiCut]->Fill();
1964                                 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1965                                         fPtGamma = PhotonCandidate->Pt();
1966                                         fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1967                                         fRConvPhoton = PhotonCandidate->GetConversionRadius();
1968                                         fEtaPhoton = PhotonCandidate->GetPhotonEta();
1969                                         fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1970                                         fTreeConvGammaPtDcazCat[fiCut]->Fill();
1971                                 }
1972                         }
1973                 }
1974         }
1975         if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1976                 for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1977                         AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1978                         if(!PhotonCandidate) continue;
1979                         fIsFromMBHeader = kTRUE;
1980                         if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1981                                 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1982                                 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1983                                 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1984                         }
1985                         if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
1986                         fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1987                         if(fIsFromMBHeader){
1988                                 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1989                                 if (fDoPhotonQA > 0){
1990                                         fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1991                                         fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1992                                 }
1993                         }
1994                         if(fIsMC){
1995                                 if(fInputEvent->IsA()==AliESDEvent::Class())
1996                                         ProcessTruePhotonCandidates(PhotonCandidate);
1997                                 if(fInputEvent->IsA()==AliAODEvent::Class())
1998                                         ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1999                         }
2000                         if (fIsFromMBHeader){
2001                                 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
2002                                         fPtGamma = PhotonCandidate->Pt();
2003                                         fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
2004                                         fRConvPhoton = PhotonCandidate->GetConversionRadius();
2005                                         fEtaPhoton = PhotonCandidate->GetPhotonEta();
2006                                         fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
2007                                         fTreeConvGammaPtDcazCat[fiCut]->Fill();
2008                                 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
2009                                         fPtGamma = PhotonCandidate->Pt();
2010                                         fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
2011                                         fRConvPhoton = PhotonCandidate->GetConversionRadius();
2012                                         fEtaPhoton = PhotonCandidate->GetPhotonEta();
2013                                         fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
2014                                         fTreeConvGammaPtDcazCat[fiCut]->Fill();
2015                                 }
2016                         }
2017                 }
2018         }
2019
2020         delete GammaCandidatesStepOne;
2021         GammaCandidatesStepOne = 0x0;
2022         delete GammaCandidatesStepTwo;
2023         GammaCandidatesStepTwo = 0x0;
2024
2025 }
2026
2027 //________________________________________________________________________
2028 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
2029 {
2030
2031         Double_t magField = fInputEvent->GetMagneticField();
2032         if( magField  < 0.0 ){
2033                 magField =  1.0;
2034         }
2035         else {
2036                 magField =  -1.0;
2037         }
2038
2039         TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2040         if (AODMCTrackArray == NULL) return;
2041         AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
2042         AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
2043         fCharPhotonMCInfo = 0;
2044
2045         if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
2046         Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
2047
2048         if(posDaughter->GetMother() != negDaughter->GetMother()){
2049                 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2050                 fCharPhotonMCInfo = 1;
2051                 return;
2052         }
2053         else if(posDaughter->GetMother() == -1){
2054                 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2055                 fCharPhotonMCInfo = 1;
2056                 return;
2057         }
2058
2059         if(pdgCode[0]!=11 || pdgCode[1]!=11){
2060                 fCharPhotonMCInfo = 1;
2061                 return; //One Particle is not a electron
2062         }
2063
2064         if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
2065                 fCharPhotonMCInfo = 1;
2066                 return; // Same Charge
2067         }
2068
2069         AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
2070         if(Photon->GetPdgCode() != 22){
2071                 fCharPhotonMCInfo = 1;
2072                 return; // Mother is no Photon
2073         }
2074
2075         if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
2076                 fCharPhotonMCInfo = 1;
2077                 return;// check if the daughters come from a conversion
2078         }
2079         // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
2080
2081
2082
2083         // True Photon
2084         if(fIsFromMBHeader){
2085                 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2086                 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
2087         }
2088         if(Photon->IsPrimary()){
2089                 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
2090                 if(fIsFromMBHeader){
2091                         fCharPhotonMCInfo = 6;
2092                         fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2093                         fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
2094                 }
2095                 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
2096         } else {
2097                 if(fIsFromMBHeader){
2098                         fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2099                         fCharPhotonMCInfo = 2;
2100                         if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
2101                                 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
2102                                 fCharPhotonMCInfo = 5;
2103                                 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2104                         }
2105                         if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
2106                                 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
2107                                 fCharPhotonMCInfo = 4;
2108                                 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2109                         }
2110                         if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
2111                                 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
2112                                 fCharPhotonMCInfo = 3;
2113                         }
2114                 }
2115         }
2116         TruePhotonCandidate->SetIsTrueConvertedPhoton();
2117 }
2118
2119 //________________________________________________________________________
2120 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
2121 {
2122
2123         Double_t magField = fInputEvent->GetMagneticField();
2124         if( magField  < 0.0 ){
2125                 magField =  1.0;
2126         }
2127         else {
2128                 magField =  -1.0;
2129         }
2130
2131         // Process True Photons
2132         TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
2133         TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
2134         fCharPhotonMCInfo = 0;
2135
2136         if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
2137         Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
2138         fCharPhotonMCInfo = 1;
2139         if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
2140                 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2141                 return;
2142         }
2143         else if(posDaughter->GetMother(0) == -1){
2144                 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2145                 return;
2146         }
2147
2148         if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
2149
2150         if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
2151
2152         TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
2153
2154         if(Photon->GetPdgCode() != 22){
2155                 return; // Mother is no Photon
2156         }
2157
2158         if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
2159
2160         // True Photon
2161         if(fIsFromMBHeader){
2162                 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2163                 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
2164         }
2165         if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
2166                 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
2167                 if(fIsFromMBHeader){
2168                         fCharPhotonMCInfo = 6;
2169                         fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2170                         fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
2171                 }
2172                 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
2173         } else {
2174                 if(fIsFromMBHeader){
2175                         fCharPhotonMCInfo = 2;
2176                         fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2177                         if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2178                                 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
2179                                 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2180                                 fCharPhotonMCInfo = 5;
2181                         }
2182                         if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2183                                 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
2184                                 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2185                                 fCharPhotonMCInfo = 4;
2186                         }
2187                         if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2188                                 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
2189                                 fCharPhotonMCInfo = 3;
2190                         }
2191                 }
2192         }
2193         TruePhotonCandidate->SetIsTrueConvertedPhoton();
2194         return;
2195 }
2196 //________________________________________________________________________
2197 void AliAnalysisTaskGammaConvCalo::ProcessAODMCParticles()
2198 {
2199
2200         TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2201         if (AODMCTrackArray == NULL) return;
2202
2203         // Loop over all primary MC particle
2204         for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
2205
2206                 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
2207                 if (!particle) continue;
2208                 if (!particle->IsPrimary()) continue;
2209
2210                 Int_t isMCFromMBHeader = -1;
2211                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2212                         isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2213                         if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2214                 }
2215
2216                 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2217                 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
2218                         fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2219                         if (abs(particle->Eta()) < 0.66 ){
2220                                 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2221                         }
2222                         if(particle->GetMother() >-1){ // Meson Decay Gamma
2223                                 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
2224                                 case 111: // Pi0
2225                                         fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2226                                         break;
2227                                 case 113: // Rho0
2228                                         fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2229                                         break;
2230                                 case 221: // Eta
2231                                         fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2232                                         break;
2233                                 case 223: // Omega
2234                                         fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2235                                         break;
2236                                 case 331: // Eta'
2237                                         fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2238                                         break;
2239                                 case 333: // Phi
2240                                         fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2241                                         break;
2242                                 case 3212: // Sigma
2243                                         fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2244                                         break;
2245                                 }
2246                         }
2247                 }
2248                 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
2249                         Double_t rConv = 0;
2250                         for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
2251                                 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
2252                                 if(!tmpDaughter) continue;
2253                                 if(abs(tmpDaughter->GetPdgCode()) == 11){
2254                                         rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
2255                                 }
2256                         }
2257                         fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2258                         if (fDoPhotonQA > 0){
2259                                 fHistoMCConvGammaR[fiCut]->Fill(rConv);
2260                                 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2261                         }
2262                 }
2263                 // Converted MC Gamma
2264                 if(fDoMesonAnalysis){
2265                         if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2266                                 Double_t mesonY = 10.;
2267                                 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2268                                         mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2269                                 } else {
2270                                         mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2271                                 }
2272                                 Float_t weightedK0s= 1;
2273                                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2274                                         if (particle->Pt()>0.005){
2275                                                 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2276                                                 //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
2277                                         }
2278                                 }
2279                                 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2280                                 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2281                                 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2282                         }
2283                         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2284                                 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2285                                 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
2286                                 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
2287                                 Float_t weighted= 1;
2288                                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2289                                         if (particle->Pt()>0.005){
2290                                                 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2291                                                 //                   if(particle->GetPdgCode() == 221){
2292                                                 //                      cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
2293                                                 //                   }
2294                                         }
2295                                 }
2296                                 Double_t mesonY = 10.;
2297                                 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2298                                         mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2299                                 } else{
2300                                         mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2301                                 }
2302
2303                                 Double_t alpha = -1;
2304                                 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2305                                         alpha = TMath::Abs((daughter0->E() - daughter1->E()))/(daughter0->E() + daughter1->E());
2306                                 }
2307
2308
2309                                 if(particle->GetPdgCode() == 111){
2310                                         fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2311                                         fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2312                                         if (fDoMesonQA > 0){
2313                                                 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2314                                                 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2315                                         }
2316                                 } else if(particle->GetPdgCode() == 221){
2317                                         fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2318                                         fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2319                                         if (fDoMesonQA > 0){
2320                                                 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2321                                                 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2322                                         }
2323                                 }
2324
2325                                 // Check the acceptance for both gammas
2326                                 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
2327                                 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE)  &&
2328                                 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2329                                 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2330
2331                                         if(particle->GetPdgCode() == 111){
2332                                                 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2333                                         } else if(particle->GetPdgCode() == 221){
2334                                                 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2335                                         }
2336                                 }
2337                         }
2338                 }
2339         }
2340
2341 }
2342 //________________________________________________________________________
2343 void AliAnalysisTaskGammaConvCalo::ProcessMCParticles()
2344 {
2345         // Loop over all primary MC particle
2346         for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2347                 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2348                 if (!particle) continue;
2349
2350                 Int_t isMCFromMBHeader = -1;
2351                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2352                         isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2353                         if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2354                 }
2355
2356                 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2357                 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
2358                         fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2359                         if (abs(particle->Eta()) < 0.66 ){
2360                                 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2361                         }
2362
2363                         if(particle->GetMother(0) >-1){ // Meson Decay Gamma
2364                                 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
2365                                 case 111: // Pi0
2366                                         fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2367                                         break;
2368                                 case 113: // Rho0
2369                                         fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2370                                         break;
2371                                 case 221: // Eta
2372                                         fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2373                                         break;
2374                                 case 223: // Omega
2375                                         fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2376                                         break;
2377                                 case 331: // Eta'
2378                                         fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2379                                         break;
2380                                 case 333: // Phi
2381                                         fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2382                                         break;
2383                                 case 3212: // Sigma
2384                                         fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2385                                         break;
2386                                 }
2387                         }
2388                 }
2389                 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
2390                         fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2391                         if (fDoPhotonQA > 0){
2392                                 fHistoMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
2393                                 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2394                         }
2395                 } // Converted MC Gamma
2396                 if(fDoMesonAnalysis){
2397                         if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2398                                 Double_t mesonY = 10.;
2399                                 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2400                                         mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2401                                 } else{
2402                                         mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2403                                 }
2404                                 Float_t weightedK0s= 1;
2405                                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2406                                         if (particle->Pt()>0.005){
2407                                                 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2408                                                 //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
2409                                         }
2410                                 }
2411                                 if (fMCStack->IsPhysicalPrimary(i)){
2412                                         fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2413                                         fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2414                                         fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2415                                 }
2416                         }
2417                         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2418                                 ->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2419                                 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
2420                                 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
2421
2422                                 Float_t weighted= 1;
2423                                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2424                                         if (particle->Pt()>0.005){
2425                                                 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2426                                                 //                   if(particle->GetPdgCode() == 221){
2427                                                 //                      cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
2428                                                 //                   }
2429                                         }
2430                                 }
2431                                 Double_t mesonY = 10.;
2432                                 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2433                                         mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2434                                 } else{
2435                                         mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2436                                 }
2437
2438                                 Double_t alpha = -1;
2439                                 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2440                                         alpha = TMath::Abs((daughter0->Energy() - daughter1->Energy()))/(daughter0->Energy() + daughter1->Energy());
2441                                 }
2442
2443                                 if(particle->GetPdgCode() == 111){
2444                                         fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2445                                         fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2446                                         if (fDoMesonQA > 0){
2447                                                 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2448                                                 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2449                                         }
2450                                 } else if(particle->GetPdgCode() == 221){
2451                                         fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2452                                         fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2453                                         if (fDoMesonQA > 0){
2454                                                 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2455                                                 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2456                                         }
2457                                 }
2458
2459                                 // Check the acceptance for both gammas
2460                                 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
2461                                 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE)  &&
2462                                 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2463                                 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2464
2465                                         if(particle->GetPdgCode() == 111){
2466                                                 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2467                                         } else if(particle->GetPdgCode() == 221){
2468                                                 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2469                                         }
2470                                 }
2471                         }
2472                 }
2473         }
2474
2475         if (fDoMesonQA){
2476                 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
2477                         TParticle* particle = (TParticle *)fMCStack->Particle(i);
2478                         if (!particle) continue;
2479
2480                         Int_t isMCFromMBHeader = -1;
2481                         if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2482                                 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2483                                 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2484                         }
2485
2486                         if(fDoMesonAnalysis){
2487                                 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2488                                         Float_t weighted= 1;
2489                                         if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2490                                                 if (particle->Pt()>0.005){
2491                                                         weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2492               //                   if(particle->GetPdgCode() == 221){
2493               //                      cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
2494               //                   }
2495                                                 }
2496                                         }
2497
2498                                         if(particle->GetPdgCode() == 111){
2499                                                 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2500                                                 Int_t source = GetSourceClassification(111,pdgCode);
2501                                                 fHistoMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
2502                                                 fHistoMCSecPi0Source[fiCut]->Fill(pdgCode);
2503                                         } else if(particle->GetPdgCode() == 221){
2504                                                 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2505                                                 fHistoMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2506                                                 fHistoMCSecEtaSource[fiCut]->Fill(pdgCode);
2507                                         }
2508                                 }
2509                         }
2510                 }
2511         }
2512 }
2513
2514 //________________________________________________________________________
2515 void AliAnalysisTaskGammaConvCalo::CalculatePi0Candidates(){
2516
2517         // Conversion Gammas
2518         if(fGammaCandidates->GetEntries()>0){
2519
2520                 // vertex
2521                 Double_t vertex[3] = {0};
2522                 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
2523
2524                 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2525                         AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2526                         if (gamma0==NULL) continue;
2527
2528                         for(Int_t secondGammaIndex=0;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
2529                                 Bool_t matched = kFALSE;
2530                                 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2531                                 if (gamma1==NULL) continue;
2532
2533                                 if (gamma1->GetIsCaloPhoton()){
2534                                         AliVCluster* cluster = fInputEvent->GetCaloCluster(gamma1->GetCaloClusterRef());
2535                                         matched = ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->MatchConvPhotonToCluster(gamma0,cluster, fInputEvent );
2536                                 }
2537
2538                                 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
2539                                 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
2540
2541
2542
2543                                 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2544                                         if (matched){
2545                                                 fHistoMotherMatchedInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2546                                         } else {
2547                                                 fHistoMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2548                                         }
2549                                         // fill new histograms
2550                                         if (!matched){
2551                                                 fHistoPhotonPairPtconv[fiCut]->Fill(pi0cand->M(),gamma0->Pt());
2552                                                 if(pi0cand->GetAlpha()<0.1)
2553                                                         fHistoMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
2554
2555                                                 if (fDoMesonQA > 0){
2556                                                         if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
2557                                                                 fHistoMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2558                                                                 fHistoMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2559                                 fHistoMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2560                                 fHistoMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
2561                                                         }
2562                                                         if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
2563                                                                 fHistoMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2564                                                                 fHistoMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2565                                                                 fHistoMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2566                                 fHistoMotherEtaConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
2567                                                         }
2568                                                 }
2569                         if(fDoTHnSparse && ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
2570                                                         Int_t zbin = 0;
2571                                                         Int_t mbin = 0;
2572
2573                                                         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
2574                                                                 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2575                                                                 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2576                                                                         mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2577                                                                 } else {
2578                                                                         mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2579                                                                 }
2580                                                         } else{
2581                                                                 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2582                                                                 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2583                                                                         mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2584                                                                 } else {
2585                                                                         mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2586                                                                 }
2587                                                         }
2588                                                         Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
2589                                                         fSparseMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2590                                                 }
2591                                         }
2592
2593                                         if(fIsMC){
2594                                                 if(fInputEvent->IsA()==AliESDEvent::Class())
2595                                                         ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1, matched);
2596                                                 if(fInputEvent->IsA()==AliAODEvent::Class())
2597                                                         ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1, matched);
2598                                         }
2599                                         if (!matched){
2600                                                 if (fDoMesonQA == 1){
2601                                                         fHistoMotherInvMassECalib[fiCut]->Fill(pi0cand->M(),gamma1->E());
2602                                                         if(pi0cand->GetAlpha()<0.1)
2603                                                         fHistoMotherInvMassECalibalpha[fiCut]->Fill(pi0cand->M(),gamma1->E());
2604                                                 }
2605                                         }
2606                                 }
2607                                 delete pi0cand;
2608                                 pi0cand=0x0;
2609                         }
2610                 }
2611         }
2612 }
2613 //______________________________________________________________________
2614 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2615 {
2616         // Process True Mesons
2617         if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2618                 Bool_t isTruePi0 = kFALSE;
2619                 Bool_t isTrueEta = kFALSE;
2620                 Int_t gamma0MCLabel = -1;
2621                 Int_t gamma0MotherLabel = -1;
2622                 if (TrueGammaCandidate0->IsTrueConvertedPhoton()){
2623                         gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(fMCStack);
2624                         TParticle * gammaMC0 = (TParticle*)fMCStack->Particle(gamma0MCLabel);
2625                         gamma0MotherLabel=gammaMC0->GetFirstMother();
2626
2627                 }
2628                 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
2629
2630                 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0);     // get most probable MC label
2631                 Int_t gamma1MotherLabel = -1;
2632                 // check if
2633
2634                 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2635                         // Daughters Gamma 1
2636                         TParticle * gammaMC1 = (TParticle*)fMCStack->Particle(gamma1MCLabel);
2637                         if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){              // largest component is electro magnetic
2638                                 // get mother of interest (pi0 or eta)
2639                                 if (TrueGammaCandidate1->IsLargestComponentPhoton()){                                                                                                           // for photons its the direct mother
2640                                         gamma1MotherLabel=gammaMC1->GetMother(0);
2641                                 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){                                                                                          // for electrons its either the direct mother or for conversions the grandmother
2642                                         if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=fMCStack->Particle(gammaMC1->GetMother(0))->GetMother(0);
2643                                         else gamma1MotherLabel=gammaMC1->GetMother(0);
2644                                 }
2645                         } else {
2646                                 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2647                         }
2648                 }
2649
2650                 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2651                         if(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
2652                                 isTruePi0=kTRUE;
2653                         }
2654                         if(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
2655                                 isTrueEta=kTRUE;
2656                         }
2657                 }
2658
2659                 if(isTruePi0 || isTrueEta){// True Pion or Eta
2660                         if (!matched){
2661                                 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2662                                 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2663                         }
2664                         if (fDoMesonQA > 0){
2665                                 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2666                                         if(isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2667                                         if(isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2668                                 }
2669                                 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched){
2670                                         if(isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2671                                         if(isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2672                                 }
2673                                 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() ){
2674                                         if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2675                                         if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2676                                         if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0){
2677                                                 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2678                                         }
2679                                         if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta){
2680                                                 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2681                                         }
2682                                 }
2683                                 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2684                                         if (isTruePi0 )fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2685                                         if (isTrueEta )fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2686                                 }
2687                                 if (TrueGammaCandidate1->IsMergedPartConv() && !matched){
2688                                         if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2689                                         if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2690                                 }
2691                         }
2692                         if (!matched){
2693                                 if (fDoMesonQA > 0){
2694                                         if (isTruePi0){
2695                                                 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2696                                                         fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2697                                                         fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2698                                                         fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2699                                                         fHistoTrueMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2700                                                 }
2701                                         } else if (isTrueEta){
2702                                                 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2703                                                         fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2704                                                         fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2705                                                         fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2706                                                         fHistoTrueMotherEtaConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2707                                                 }
2708                                         }
2709                                 }
2710
2711                                 if(gamma0MotherLabel >= fMCStack->GetNprimary()){ // Secondary Meson
2712                                         Int_t secMotherLabel = ((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetMother(0);
2713                                         Float_t weightedSec= 1;
2714                                         if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && fMCStack->Particle(secMotherLabel)->GetPdgCode()==310){
2715                                                 weightedSec= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),secMotherLabel, fMCStack, fInputEvent)/2.; //invariant mass is additive thus the weight for the daughters has to be devide by two for the K0s at a certain pt
2716                                                 //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
2717                                         }
2718                                         if (isTruePi0){
2719                                                 fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2720                                                 fHistoTrueSecondaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weightedSec);
2721                                                 if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2722                                                         fHistoTrueSecondaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weightedSec);
2723                                                 }
2724                                         }
2725                                         if (secMotherLabel >-1){
2726                                                 if(fMCStack->Particle(secMotherLabel)->GetPdgCode()==310 && isTruePi0 ){
2727                                                         fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2728                                                         if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(fMCStack->Particle(secMotherLabel)->Pt());
2729                                                 }
2730                                                 if(fMCStack->Particle(secMotherLabel)->GetPdgCode()==221 && isTruePi0){
2731                                                         fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2732                                                         if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(fMCStack->Particle(secMotherLabel)->Pt());
2733                                                 }
2734                                                 if(fMCStack->Particle(secMotherLabel)->GetPdgCode()==3122 && isTruePi0){
2735                                                         fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2736                                                         if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(fMCStack->Particle(secMotherLabel)->Pt());
2737                                                 }
2738                                         }
2739                                 } else { // Only primary pi0 for efficiency calculation
2740                                         Float_t weighted= 1;
2741                                         if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
2742                                                 if (((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
2743                                                         weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
2744                                                         //                      cout << "rec \t " <<gamma1MotherLabel << "\t" <<  weighted << endl;
2745                                                 }
2746                                         }
2747                                         if (isTruePi0){
2748                                                 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2749                                                 fHistoTruePrimaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2750                                                 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2751                                                 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2752                                                 if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2753                                                         fHistoTruePrimaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2754                                                 }
2755
2756                                         } else if (isTrueEta) {
2757                                                 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2758                                                 fHistoTruePrimaryEtaPhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2759                                                 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2760                                                 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2761                                                 if(CheckIfContainedInString(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
2762                                                         fHistoTruePrimaryEtaDCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2763                                                 }
2764                                         }
2765
2766                                         if (fDoMesonQA > 0){
2767                                                 if(isTruePi0){ // Only primary pi0 for resolution
2768                                                         fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2769                                                 }
2770                                                 if (isTrueEta){ // Only primary eta for resolution
2771                                                         fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2772                                                 }
2773                                         }
2774                                 }
2775                         }
2776                 } else if(!isTruePi0 && !isTrueEta){ // Background
2777                         if (fDoMesonQA > 0){
2778                                 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2779                                         fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2780                                 } else { // No photon or without mother
2781                                         fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2782                                 }
2783                         }
2784                 }
2785                 if (isTrueEta && !matched){
2786                         fStringRecTrueEtas[fiCut].Append(Form("%i,",gamma0MotherLabel));
2787                 }
2788                 if (isTruePi0 && !matched){
2789                         fStringRecTruePi0s[fiCut].Append(Form("%i,",gamma0MotherLabel));
2790                 }
2791
2792         }
2793 }
2794 //______________________________________________________________________
2795 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2796 {
2797
2798         // Process True Mesons
2799         TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2800         if (AODMCTrackArray == NULL) return;
2801         Bool_t isTruePi0 = kFALSE;
2802         Bool_t isTrueEta = kFALSE;
2803
2804         AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
2805         AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
2806
2807         Int_t gamma0MCLabel = -1;
2808         Int_t gamma0MotherLabel = -1;
2809         if(!positiveMC||!negativeMC)
2810                 return;
2811
2812         if (TrueGammaCandidate0->IsTrueConvertedPhoton()){
2813                 gamma0MCLabel = positiveMC->GetMother();
2814                 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2815                 gamma0MotherLabel=gammaMC0->GetMother();
2816         }
2817
2818         if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
2819         Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0);     // get most probable MC label
2820         Int_t gamma1MotherLabel = -1;
2821                 // check if
2822
2823         if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2824                 // Daughters Gamma 1
2825                 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2826                 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){              // largest component is electro magnetic
2827                         // get mother of interest (pi0 or eta)
2828                         if (TrueGammaCandidate1->IsLargestComponentPhoton()){                                                                                                           // for photons its the direct mother
2829                                 gamma1MotherLabel=gammaMC1->GetMother();
2830                         } else if (TrueGammaCandidate1->IsLargestComponentElectron()){                                                                                          // for electrons its either the direct mother or for conversions the grandmother
2831                                 if (TrueGammaCandidate1->IsConversion()){
2832                                         AliAODMCParticle * gammaGrandMotherMC1 =  static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC1->GetMother()));
2833                                         gamma1MotherLabel=gammaGrandMotherMC1->GetMother();
2834                                 } else gamma1MotherLabel=gammaMC1->GetMother();
2835                         }
2836                 } else {
2837                         if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2838                 }
2839         }
2840
2841         if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2842                 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2843                         isTruePi0=kTRUE;
2844                 }
2845                 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2846                         isTrueEta=kTRUE;
2847                 }
2848         }
2849
2850         if(isTruePi0 || isTrueEta){// True Pion or Eta
2851                 if (!matched){
2852                         if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2853                         if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2854                 }
2855                 if (fDoMesonQA > 0){
2856                         if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2857                                 if (isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2858                                 if (isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2859                         }
2860                         if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched) {
2861                                 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2862                                 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2863                         }
2864                         if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()){
2865                                 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2866                                 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2867                                 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0)
2868                                         fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2869                                 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta)
2870                                         fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2871                         }
2872                         if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2873                                 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2874                                 if (isTrueEta) fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2875                         }
2876                         if (TrueGammaCandidate1->IsMergedPartConv() && !matched) {
2877                                 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2878                                 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2879                         }
2880                 }
2881
2882                 if ( !matched){
2883                         if (fDoMesonQA > 0){
2884                                 if (isTruePi0){
2885                                         if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2886                                                 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2887                                                 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2888                                                 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2889                                                 fHistoTrueMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2890                                         }
2891                                 } else if (isTrueEta){
2892                                         if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2893                                                 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2894                                                 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2895                                                 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2896                                                 fHistoTrueMotherEtaConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2897                                         }
2898                                 }
2899                         }
2900                         if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2901                                 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2902                                 Float_t weightedSec= 1;
2903                                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2904                                         weightedSec= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),secMotherLabel, 0x0, fInputEvent)/2.; //invariant mass is additive thus the weight for the daughters has to be devide by two for the K0s at a certain pt
2905                                         //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
2906                                 }
2907                                 if (isTruePi0){
2908                                         fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2909                                         fHistoTrueSecondaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weightedSec);
2910                                         if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2911                                                 fHistoTrueSecondaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weightedSec);
2912                                         }
2913                                 }
2914                                 if (secMotherLabel >-1){
2915                                         if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310 && isTruePi0){
2916                                                 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2917                                                 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2918                                         }
2919                                         if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221 && isTruePi0){
2920                                                 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2921                                                 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2922                                         }
2923                                         if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122 && isTruePi0){
2924                                                 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2925                                                 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2926                                         }
2927                                 }
2928                         } else{ // Only primary pi0 for efficiency calculation
2929                                 Float_t weighted= 1;
2930                                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2931                                         if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2932                                         weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2933                                         //                      cout << "rec \t " <<gamma1MotherLabel << "\t" <<  weighted << endl;
2934                                         }
2935                                 }
2936                                 if (isTruePi0){
2937                                         fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2938                                         fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2939                                         fHistoTruePrimaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2940                                         fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2941                                         if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2942                                                 fHistoTruePrimaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2943                                         }
2944                                 } else if (isTrueEta){
2945                                         fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2946                                         fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2947                                         fHistoTruePrimaryEtaPhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2948                                         fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2949                                         if(CheckIfContainedInString(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
2950                                                 fHistoTruePrimaryEtaDCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2951                                         }
2952                                 }
2953                                 if (fDoMesonQA > 0){
2954                                         if(isTruePi0){ // Only primary pi0 for resolution
2955                                                 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2956                                                                                                                                 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2957
2958                                         }
2959                                         if (isTrueEta){ // Only primary eta for resolution
2960                                                 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2961                                                                                                                                 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2962                                         }
2963                                 }
2964                         }
2965                 }
2966         } else if(!isTruePi0 && !isTrueEta) { // Background
2967                 if (fDoMesonQA > 0){
2968                         if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2969                                 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2970                         } else { // No photon or without mother
2971                                 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2972                         }
2973                 }
2974         }
2975
2976         if (isTrueEta && !matched){
2977                 fStringRecTrueEtas[fiCut].Append(Form("%i,",gamma0MotherLabel));
2978         }
2979         if (isTruePi0 && !matched){
2980                 fStringRecTruePi0s[fiCut].Append(Form("%i,",gamma0MotherLabel));
2981         }
2982
2983
2984
2985 }
2986
2987 //________________________________________________________________________
2988 void AliAnalysisTaskGammaConvCalo::CalculateBackground(){
2989
2990     Int_t zbin = fBGClusHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2991     Int_t mbin = 0;
2992
2993     if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2994         mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2995     } else {
2996         mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2997     }
2998
2999
3000         AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
3001         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3002                 for(Int_t nEventsInBG=0;nEventsInBG<fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
3003                         AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
3004                         if(fMoveParticleAccordingToVertex == kTRUE || ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
3005                                 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
3006                         }
3007
3008                         for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3009                                 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3010                                 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
3011                                         AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
3012                                         if(fMoveParticleAccordingToVertex == kTRUE){
3013                                                 if (bgEventVertex){
3014                                                         MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
3015                                                 }
3016                                         }
3017                                         if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
3018                                                 if (bgEventVertex){
3019                                                         RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
3020                                                 }
3021                                         }
3022
3023                                         AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
3024                                         backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3025                                         if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3026                                                 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
3027                                                 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
3028                                                 fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate->M(),currentEventGoodV0.Pt());
3029                         if(fDoTHnSparse){
3030                             Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
3031                             fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
3032                         }
3033                                         }
3034                                         delete backgroundCandidate;
3035                                         backgroundCandidate = 0x0;
3036                                 }
3037                         }
3038                 }
3039         } else {
3040                 for(Int_t nEventsInBG=0;nEventsInBG <fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
3041                         AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
3042                         if(previousEventV0s){
3043                                 if(fMoveParticleAccordingToVertex == kTRUE || ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0 ){
3044                                         bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
3045                                 }
3046                                 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3047                                         AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3048                                         for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
3049
3050                                                 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
3051
3052                                                 if(fMoveParticleAccordingToVertex == kTRUE){
3053                                                         if (bgEventVertex){
3054                                                                 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
3055                                                         }
3056                                                 }
3057                                                 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
3058                                                         if (bgEventVertex){
3059                                                                 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
3060                                                         }
3061                                                 }
3062
3063                                                 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
3064                                                 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3065                                                 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
3066                                                         fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
3067                                                         fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate->M(),currentEventGoodV0.Pt());
3068                             if(fDoTHnSparse){
3069                                 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
3070                                 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
3071                             }
3072                                                 }
3073                                                 delete backgroundCandidate;
3074                                                 backgroundCandidate = 0x0;
3075                                         }
3076                                 }
3077                         }
3078                 }
3079         }
3080 }
3081
3082 //________________________________________________________________________
3083 void AliAnalysisTaskGammaConvCalo::CalculateBackgroundRP(){
3084
3085     Int_t zbin = 0;
3086     Int_t mbin = 0;
3087
3088     if(fDoTHnSparse){
3089         zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
3090         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3091             mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
3092         } else {
3093             mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
3094         }
3095     }
3096
3097         //Rotation Method
3098         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
3099                 // Correct for the number of rotations
3100                 // BG is for rotation the same, except for factor NRotations
3101                 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
3102
3103                 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3104
3105                         AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3106                         if (gamma0==NULL) continue;
3107                         for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
3108                                 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
3109                                 if (gamma1 == NULL) continue;
3110                                 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
3111                                 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
3112
3113                                         RotateParticle(gamma1);
3114                                         AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3115                                         backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3116                                         if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3117                                                 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3118                                                 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3119                                                 fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate.M(),gamma0->Pt());
3120                         if(fDoTHnSparse){
3121                             Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3122                             fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3123                         }
3124                                         }
3125                                 }
3126                         }
3127                 }
3128         } else {
3129                 // Do Event Mixing
3130                 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
3131
3132                         AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
3133
3134                         if(previousEventGammas){
3135                                 // test weighted background
3136                                 Double_t weight=1.0;
3137                                 // Correct for the number of eventmixing:
3138                                 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1))  using sum formula sum(i)=N*(N-1)/2  -> N*(N-1)/2
3139                                 // real combinations (since you cannot combine a photon with its own)
3140                                 // but BG leads to N_{a}*N_{b} combinations
3141                                 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
3142
3143                                 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3144                                         AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3145                                         for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
3146
3147                                                 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
3148
3149                                                 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3150                                                 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3151                                                 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3152                                                 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3153                                                         fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3154                                                         fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate.M(),gamma0->Pt());
3155                             if(fDoTHnSparse){
3156                                 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3157                                 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3158                             }
3159                                                 }
3160                                         }
3161                                 }
3162                         }
3163                 }
3164         }
3165 }
3166 //________________________________________________________________________
3167 void AliAnalysisTaskGammaConvCalo::RotateParticle(AliAODConversionPhoton *gamma){
3168         Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
3169         Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
3170         Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
3171         gamma->RotateZ(rotationValue);
3172 }
3173
3174 //________________________________________________________________________
3175 void AliAnalysisTaskGammaConvCalo::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
3176
3177         previousEventEP=previousEventEP+TMath::Pi();
3178         thisEventEP=thisEventEP+TMath::Pi();
3179         Double_t rotationValue= thisEventEP-previousEventEP;
3180         gamma->RotateZ(rotationValue);
3181 }
3182
3183 //________________________________________________________________________
3184 void AliAnalysisTaskGammaConvCalo::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
3185         //see header file for documentation
3186
3187         Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
3188         Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
3189         Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
3190
3191         Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
3192         particle->SetConversionPoint(movedPlace);
3193 }
3194 //________________________________________________________________________
3195 void AliAnalysisTaskGammaConvCalo::UpdateEventByEventData(){
3196         //see header file for documentation
3197         if(fGammaCandidates->GetEntries() >0 ){
3198                 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3199                         fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3200                         fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3201                 } else { // means we use #V0s for multiplicity
3202                         fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3203                         fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3204                 }
3205         }
3206 }
3207
3208
3209 //________________________________________________________________________
3210 void AliAnalysisTaskGammaConvCalo::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
3211 {
3212         // Combinatorial Bck = 0 ee, 1 ep,i 2 ek, 3 ep, 4 emu, 5 pipi, 6 pik, 7 pip, 8 pimu, 9 kk, 10 kp, 11 kmu, 12 pp, 13 pmu, 14 mumu, 15 Rest
3213         if(pdgCode[0]==11   && pdgCode[1]==11){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
3214         else if( (pdgCode[0]==11   && pdgCode[1]==211) || (pdgCode[0]==211  && pdgCode[1]==11) )
3215         {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
3216         else if( (pdgCode[0]==11   && pdgCode[1]==321) || (pdgCode[0]==321  && pdgCode[1]==11) )
3217         {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
3218         else if( (pdgCode[0]==11   && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
3219         {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
3220         else if( (pdgCode[0]==11   && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==11) )
3221         {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
3222         else if(  pdgCode[0]==211  && pdgCode[1]==211 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
3223         else if( (pdgCode[0]==211  && pdgCode[1]==321) || (pdgCode[0]==321  && pdgCode[1]==211) )
3224         {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
3225         else if( (pdgCode[0]==211  && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
3226         {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
3227         else if( (pdgCode[0]==211  && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==211) )
3228         {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
3229         else if(  pdgCode[0]==321  && pdgCode[1]==321 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
3230         else if( (pdgCode[0]==321  && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
3231         {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
3232         else if( (pdgCode[0]==321  && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==321) )
3233         {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
3234         else if(  pdgCode[0]==2212   && pdgCode[1]==2212  ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
3235         else if( (pdgCode[0]==2212  && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==2212) )
3236         {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
3237         else if(  pdgCode[0]==13   && pdgCode[1]==13  ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
3238         else {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
3239 }
3240 //________________________________________________________________________
3241 void AliAnalysisTaskGammaConvCalo::RelabelAODPhotonCandidates(Bool_t mode){
3242
3243         // Relabeling For AOD Event
3244         // ESDiD -> AODiD
3245         // MCLabel -> AODMCLabel
3246
3247         if(mode){
3248                 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
3249                 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
3250                 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
3251                 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
3252         }
3253
3254         for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
3255                 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
3256                 if(!PhotonCandidate) continue;
3257                 if(!mode){// Back to ESD Labels
3258                 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
3259                 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
3260                 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
3261                 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
3262                 continue;
3263                 }
3264                 fMCStackPos[iGamma] =  PhotonCandidate->GetMCLabelPositive();
3265                 fMCStackNeg[iGamma] =  PhotonCandidate->GetMCLabelNegative();
3266                 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
3267                 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
3268
3269                 Bool_t AODLabelPos = kFALSE;
3270                 Bool_t AODLabelNeg = kFALSE;
3271
3272                 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
3273                 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
3274                 if(!AODLabelPos){
3275                         if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
3276                         PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
3277                         PhotonCandidate->SetLabelPositive(i);
3278                         AODLabelPos = kTRUE;
3279                         }
3280                 }
3281                 if(!AODLabelNeg){
3282                         if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
3283                         PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
3284                         PhotonCandidate->SetLabelNegative(i);
3285                         AODLabelNeg = kTRUE;
3286                         }
3287                 }
3288                 if(AODLabelNeg && AODLabelPos){
3289                         break;
3290                 }
3291                 }
3292                 if(!AODLabelPos || !AODLabelNeg){
3293                 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
3294                 }
3295         }
3296
3297
3298         if(!mode){
3299                 delete[] fMCStackPos;
3300                 delete[] fMCStackNeg;
3301                 delete[] fESDArrayPos;
3302                 delete[] fESDArrayNeg;
3303         }
3304 }
3305
3306 void AliAnalysisTaskGammaConvCalo::SetLogBinningXTH2(TH2* histoRebin){
3307         TAxis *axisafter = histoRebin->GetXaxis();
3308         Int_t bins = axisafter->GetNbins();
3309         Double_t from = axisafter->GetXmin();
3310         Double_t to = axisafter->GetXmax();
3311         Double_t *newbins = new Double_t[bins+1];
3312         newbins[0] = from;
3313         Double_t factor = TMath::Power(to/from, 1./bins);
3314         for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
3315         axisafter->Set(bins, newbins);
3316         delete [] newbins;
3317 }
3318
3319 //________________________________________________________________________
3320 void AliAnalysisTaskGammaConvCalo::Terminate(const Option_t *)
3321 {
3322
3323   //fOutputContainer->Print(); // Will crash on GRID
3324 }
3325
3326 //________________________________________________________________________
3327 Int_t AliAnalysisTaskGammaConvCalo::GetSourceClassification(Int_t daughter, Int_t pdgCode){
3328
3329         if (daughter == 111) {
3330                 if (abs(pdgCode) == 310) return 1; // k0s
3331                 else if (abs(pdgCode) == 3122) return 2; // Lambda
3332                 else if (abs(pdgCode) == 130) return 3; // K0L
3333                 else if (abs(pdgCode) == 2212) return 4; // proton
3334                 else if (abs(pdgCode) == 2112) return 5; // neutron
3335                 else if (abs(pdgCode) == 211) return 6; // pion
3336                 else if (abs(pdgCode) == 321) return 7; // kaon
3337                 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
3338                 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112  ) return 9; // Sigma
3339                 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114  ) return 10; // Delta
3340                 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323   ) return 11; // K*
3341                 else return 15;
3342         }
3343         return 15;
3344
3345 }
3346
3347 //_________________________________________________________________________________
3348 Bool_t AliAnalysisTaskGammaConvCalo::CheckIfContainedInString(TString input, Int_t tobechecked){
3349         TObjArray *arr = input.Tokenize(",");
3350         for (Int_t i = 0; i < arr->GetEntriesFast();i++){
3351                 TString tempStr = ((TObjString*)arr->At(i))->GetString();
3352                 if (tempStr.Atoi() == tobechecked) return kTRUE;
3353         }
3354         return kFALSE;
3355 }
3356
3357 //_________________________________________________________________________________
3358 Bool_t AliAnalysisTaskGammaConvCalo::CheckIfContainedInStringAndAppend(TString &input, Int_t tobechecked){
3359         TObjArray *arr = input.Tokenize(",");
3360         Bool_t isContained = kFALSE;
3361         for (Int_t i = 0; i < arr->GetEntriesFast();i++){
3362                 TString tempStr = ((TObjString*)arr->At(i))->GetString();
3363                 if (tempStr.Atoi() == tobechecked) isContained= kTRUE;
3364         }
3365         if (!isContained)input.Append(Form("%i,",tobechecked));
3366         return isContained;
3367 }
3368
3369 //_________________________________________________________________________________
3370 void AliAnalysisTaskGammaConvCalo::ProcessConversionPhotonsForMissingTags (){
3371
3372         if (!fMCStack) return;
3373
3374         for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3375                 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3376                 if (gamma0->IsTrueConvertedPhoton()){
3377                         Int_t gamma0MotherLabel = -1;
3378                         Int_t gamma0MCLabel = gamma0->GetMCParticleLabel(fMCStack);
3379                         if(gamma0MCLabel != -1){
3380                                 TParticle * gammaMC0 = (TParticle*)fMCStack->Particle(gamma0MCLabel);
3381                                 gamma0MotherLabel=gammaMC0->GetFirstMother();
3382                                 if (gamma0MotherLabel>-1){
3383                                         if(((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetPdgCode() == 111){
3384                                                 if (!CheckIfContainedInStringAndAppend(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
3385                                                         if (gamma0MotherLabel >= fMCStack->GetNprimary()){
3386                                                                 Int_t secMotherLabel = ((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetMother(0);
3387                                                                 Float_t weightedSec= 1;
3388                                                                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && fMCStack->Particle(secMotherLabel)->GetPdgCode()==310){
3389                                                                         weightedSec= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),secMotherLabel, fMCStack, fInputEvent)/2.; //invariant mass is additive thus the weight for the daughters has to be devide by two for the K0s at a certain pt
3390                                                                 }
3391                                                                 fHistoTrueSecondaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weightedSec);
3392                                                         } else {
3393                                                                 Float_t weighted= 1;
3394                                                                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma0MotherLabel, fMCStack, fInputEvent)){
3395                                                                         if (((TParticle*)fMCStack->Particle(gamma0MotherLabel))->Pt()>0.005){
3396                                                                                 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma0MotherLabel, fMCStack, fInputEvent);
3397                                                                         }
3398                                                                 }
3399                                                                 fHistoTruePrimaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
3400                                                         }
3401                                                 }
3402                                         } else if(((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetPdgCode() == 221){
3403                                                 if (!CheckIfContainedInStringAndAppend(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
3404                                                         Float_t weighted= 1;
3405                                                         if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma0MotherLabel, fMCStack, fInputEvent)){
3406                                                                 if (((TParticle*)fMCStack->Particle(gamma0MotherLabel))->Pt()>0.005){
3407                                                                         weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma0MotherLabel, fMCStack, fInputEvent);
3408                                                                 }
3409                                                         }
3410                                                         fHistoTruePrimaryEtaMissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
3411                                                 }
3412                                         }
3413                                 }
3414                         }
3415                 }
3416         }
3417         return;
3418 }
3419
3420 //_________________________________________________________________________________
3421 void AliAnalysisTaskGammaConvCalo::ProcessConversionPhotonsForMissingTagsAOD (){
3422
3423         TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
3424
3425         for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3426                 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3427
3428                 if (gamma0->IsTrueConvertedPhoton()){
3429                         AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0->GetMCLabelPositive()));
3430                         AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0->GetMCLabelNegative()));
3431
3432                         Int_t gamma0MCLabel = -1;
3433                         Int_t gamma0MotherLabel = -1;
3434                         if(!positiveMC||!negativeMC)
3435                                 return;
3436
3437                         if (gamma0->IsTrueConvertedPhoton()){
3438                                 gamma0MCLabel = positiveMC->GetMother();
3439                                 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
3440                                 gamma0MotherLabel=gammaMC0->GetMother();
3441
3442                                 if (gamma0MotherLabel>-1){
3443                                         if(((AliAODMCParticle*)AODMCTrackArray->At(gamma0MotherLabel))->GetPdgCode() == 111){
3444                                                 if (!CheckIfContainedInStringAndAppend(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
3445                                                         if (!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){
3446                                                                 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->GetMother();
3447                                                                 Float_t weightedSec= 1;
3448                                                                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
3449                                                                         weightedSec= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),secMotherLabel, 0x0, fInputEvent)/2.; //invariant mass is additive thus the weight for the daughters has to be devide by two for the K0s at a certain pt
3450                                                                 }
3451                                                                 fHistoTrueSecondaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weightedSec);
3452                                                         } else {
3453                                                                 Float_t weighted= 1;
3454                                                                 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma0MotherLabel, 0x0, fInputEvent)){
3455                                                                         if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->Pt()>0.005){
3456                                                                                 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma0MotherLabel, 0x0, fInputEvent);
3457                                                                         }
3458                                                                 }
3459                                                                 fHistoTruePrimaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
3460                                                         }
3461                                                 }
3462                                         } else if(((AliAODMCParticle*)AODMCTrackArray->At(gamma0MotherLabel))->GetPdgCode() == 221){
3463                                                 if (!CheckIfContainedInStringAndAppend(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
3464                                                         Float_t weighted= 1;
3465                                                         if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma0MotherLabel, 0x0, fInputEvent)){
3466                                                                 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->Pt()>0.005){
3467                                                                         weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma0MotherLabel, 0x0, fInputEvent);
3468                                                                 }
3469                                                         }
3470                                                         fHistoTruePrimaryEtaMissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
3471                                                 }
3472                                         }
3473                                 }
3474                         }
3475                 }
3476         }
3477         return;
3478 }