PWGGA/GammaConv/AliAnalysisTaskGammaConvV1.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: Martin Wilde, Daniel Lohner, Friederike Bock                   *
   5  * Version 1.0                                                            *
   6  *                                                                        *
   7  * based on: on older version (see aliroot up to v5-04-42-AN)             *
   8  *           AliAnalysisTaskGammaConversion.cxx                           *
   9  *           Authors: Kathrin Koch, Kenneth Aamodt, Ana Marin             *
  10  *                                                                        *
  11  * Permission to use, copy, modify and distribute this software and its   *
  12  * documentation strictly for non-commercial purposes is hereby granted   *
  13  * without fee, provided that the above copyright notice appears in all   *
  14  * copies and that both the copyright notice and this permission notice   *
  15  * appear in the supporting documentation. The authors make no claims     *
  16  * about the suitability of this software for any purpose. It is          *
  17  * provided "as is" without express or implied warranty.                  *
  18  **************************************************************************/
  19
  20 ////////////////////////////////////////////////
  21 //---------------------------------------------
  22
  23 // Class used to do analysis on conversion pairs
  24 //---------------------------------------------
  25 ///////////////////////////////////////////////
  26 #include "TChain.h"
  27 #include "TTree.h"
  28 #include "TBranch.h"
  29 #include "TFile.h"
  30 #include "TH1F.h"
  31 #include "TH2F.h"
  32 #include "TH3F.h"
  33 #include "THnSparse.h"
  34 #include "TCanvas.h"
  35 #include "TNtuple.h"
  36 #include "AliAnalysisTask.h"
  37 #include "AliAnalysisManager.h"
  38 #include "AliESDEvent.h"
  39 #include "AliESDInputHandler.h"
  40 #include "AliMCEventHandler.h"
  41 #include "AliMCEvent.h"
  42 #include "AliMCParticle.h"
  43 #include "AliCentrality.h"
  44 #include "AliESDVZERO.h"
  45 #include "AliESDpid.h"
  46 #include "AliAnalysisTaskGammaConvV1.h"
  47 #include "AliVParticle.h"
  48 #include "AliESDtrack.h"
  49 #include "AliESDtrackCuts.h"
  50 #include "AliKFVertex.h"
  51 #include "AliV0ReaderV1.h"
  52 #include "AliGenCocktailEventHeader.h"
  53 #include "AliConversionAODBGHandlerRP.h"
  54 #include "AliAODMCParticle.h"
  55 #include "AliAODMCHeader.h"
  56 #include "AliEventplane.h"
  57
  58 ClassImp(AliAnalysisTaskGammaConvV1)
  59
  60 //________________________________________________________________________
  61 AliAnalysisTaskGammaConvV1::AliAnalysisTaskGammaConvV1(): AliAnalysisTaskSE(),
  62    fV0Reader(NULL),
  63    fBGHandler(NULL),
  64    fBGHandlerRP(NULL),
  65    fInputEvent(NULL),
  66    fMCEvent(NULL),
  67    fMCStack(NULL),
  68    fCutFolder(NULL),
  69    fESDList(NULL),
  70    fBackList(NULL),
  71    fMotherList(NULL),
  72    fPhotonDCAList(NULL),
  73    fMesonDCAList(NULL),
  74    fTrueList(NULL),
  75    fMCList(NULL),
  76    fHeaderNameList(NULL),
  77    fOutputContainer(0),
  78    fReaderGammas(NULL),
  79    fGammaCandidates(NULL),
  80    fCutArray(NULL),
  81    fConversionCuts(NULL),
  82    fMesonCutArray(NULL),
  83    fMesonCuts(NULL),
  84    hESDConvGammaPt(NULL),
  85    hESDConvGammaR(NULL),
  86    hESDConvGammaEta(NULL),
  87    tESDConvGammaPtDcazCat(NULL),
  88    fPtGamma(0),
  89    fDCAzPhoton(0),
  90    fRConvPhoton(0),
  91    fEtaPhoton(0),
  92    iCatPhoton(0),
  93    iPhotonMCInfo(0),
  94    hESDMotherInvMassPt(NULL),
  95    sESDMotherInvMassPtZM(NULL),
  96    hESDMotherBackInvMassPt(NULL),
  97    sESDMotherBackInvMassPtZM(NULL),
  98    hESDMotherInvMassEalpha(NULL),
  99    hESDMotherPi0PtY(NULL),
 100    hESDMotherEtaPtY(NULL),
 101    hESDMotherPi0PtAlpha(NULL),
 102    hESDMotherEtaPtAlpha(NULL),
 103    hESDMotherPi0YEtaLowPtGamma(NULL),
 104    hESDMotherPi0YEtaHighPtGamma(NULL),
 105    hESDMotherEtaYEtaLowPtGamma(NULL),
 106    hESDMotherEtaYEtaHighPtGamma(NULL),
 107    hMCHeaders(NULL),
 108    hMCAllGammaPt(NULL),
 109    hMCDecayGammaPi0Pt(NULL),
 110    hMCDecayGammaRhoPt(NULL),
 111    hMCDecayGammaEtaPt(NULL),
 112    hMCDecayGammaOmegaPt(NULL),
 113    hMCDecayGammaEtapPt(NULL),
 114    hMCDecayGammaPhiPt(NULL),
 115    hMCDecayGammaSigmaPt(NULL),
 116    hMCConvGammaPt(NULL),
 117    hMCConvGammaR(NULL),
 118    hMCConvGammaEta(NULL),
 119    hMCPi0Pt(NULL),
 120    hMCPi0WOWeightPt(NULL),
 121    hMCEtaPt(NULL),
 122    hMCPi0InAccPt(NULL),
 123    hMCEtaInAccPt(NULL),
 124    hMCPi0PtY(NULL),
 125    hMCEtaPtY(NULL),
 126    hMCK0sPt(NULL),
 127    hMCK0sWOWeightPt(NULL),
 128    hMCK0sPtY(NULL),
 129    hESDTrueMotherInvMassPt(NULL),
 130    hESDTruePrimaryMotherInvMassPt(NULL),
 131    hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
 132    pESDTruePrimaryMotherWeightsInvMassPt(NULL),
 133    hESDTruePrimaryPi0MCPtResolPt(NULL),
 134    hESDTruePrimaryEtaMCPtResolPt(NULL),
 135    hESDTrueSecondaryMotherInvMassPt(NULL),
 136    hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
 137    hESDTrueK0sWithPi0DaughterMCPt(NULL),
 138    hESDTrueSecondaryMotherFromEtaInvMassPt(NULL),
 139    hESDTrueEtaWithPi0DaughterMCPt(NULL),
 140    hESDTrueBckGGInvMassPt(NULL),
 141    hESDTrueBckContInvMassPt(NULL),
 142    hESDTruePi0PtY(NULL),
 143    hESDTrueEtaPtY(NULL),
 144    hESDTruePi0PtAlpha(NULL),
 145    hESDTrueEtaPtAlpha(NULL),
 146    hESDTruePi0YEtaLowPtGamma(NULL),
 147    hESDTruePi0YEtaHighPtGamma(NULL),
 148    hESDTrueEtaYEtaLowPtGamma(NULL),
 149    hESDTrueEtaYEtaHighPtGamma(NULL),
 150    hESDTrueMotherDalitzInvMassPt(NULL),
 151    hESDTrueConvGammaPt(NULL),
 152    hESDCombinatorialPt(NULL),
 153    hESDTruePrimaryConvGammaPt(NULL),
 154    hESDTruePrimaryConvGammaESDPtMCPt(NULL),
 155    hESDTrueSecondaryConvGammaPt(NULL),
 156    hESDTrueSecondaryConvGammaFromXFromK0sPt(NULL),
 157    hESDTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
 158    hESDTrueDalitzPsiPairDeltaPhi(NULL),
 159    hESDTrueGammaPsiPairDeltaPhi(NULL),
 160    hNEvents(NULL),
 161    hNGoodESDTracks(NULL),
 162    hNGammaCandidates(NULL),
 163    hNV0Tracks(NULL),
 164    hEtaShift(NULL),
 165    tESDMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
 166    fInvMass(0),
 167    fPt(0),
 168    fDCAzGammaMin(0),
 169    fDCAzGammaMax(0),
 170    iFlag(0),
 171    iMesonMCInfo(0),
 172    fEventPlaneAngle(-100),
 173    fRandom(0),
 174    fnGammaCandidates(0),
 175    fUnsmearedPx(NULL),
 176    fUnsmearedPy(NULL),
 177    fUnsmearedPz(NULL),
 178    fUnsmearedE(NULL),
 179    fMCStackPos(NULL),
 180    fMCStackNeg(NULL),
 181    fESDArrayPos(NULL),
 182    fESDArrayNeg(NULL),
 183    fnCuts(0),
 184    fiCut(0),
 185    fMoveParticleAccordingToVertex(kTRUE),
 186    fIsHeavyIon(kFALSE),
 187    fDoMesonAnalysis(kTRUE),
 188    fDoMesonQA(0),
 189    fDoPhotonQA(0),
 190    fIsFromMBHeader(kTRUE),
 191    fIsMC(kFALSE)
 192 {
 193
 194 }
 195
 196 //________________________________________________________________________
 197 AliAnalysisTaskGammaConvV1::AliAnalysisTaskGammaConvV1(const char *name):
 198    AliAnalysisTaskSE(name),
 199    fV0Reader(NULL),
 200    fBGHandler(NULL),
 201    fBGHandlerRP(NULL),
 202    fInputEvent(NULL),
 203    fMCEvent(NULL),
 204    fMCStack(NULL),
 205    fCutFolder(NULL),
 206    fESDList(NULL),
 207    fBackList(NULL),
 208    fMotherList(NULL),
 209    fPhotonDCAList(NULL),
 210    fMesonDCAList(NULL),
 211    fTrueList(NULL),
 212    fMCList(NULL),
 213    fHeaderNameList(NULL),
 214    fOutputContainer(0),
 215    fReaderGammas(NULL),
 216    fGammaCandidates(NULL),
 217    fCutArray(NULL),
 218    fConversionCuts(NULL),
 219    fMesonCutArray(NULL),
 220    fMesonCuts(NULL),
 221    hESDConvGammaPt(NULL),
 222    hESDConvGammaR(NULL),
 223    hESDConvGammaEta(NULL),
 224    tESDConvGammaPtDcazCat(NULL),
 225    fPtGamma(0),
 226    fDCAzPhoton(0),
 227    fRConvPhoton(0),
 228    fEtaPhoton(0),
 229    iCatPhoton(0),
 230    iPhotonMCInfo(0),
 231    hESDMotherInvMassPt(NULL),
 232    sESDMotherInvMassPtZM(NULL),
 233    hESDMotherBackInvMassPt(NULL),
 234    sESDMotherBackInvMassPtZM(NULL),
 235    hESDMotherInvMassEalpha(NULL),
 236    hESDMotherPi0PtY(NULL),
 237    hESDMotherEtaPtY(NULL),
 238    hESDMotherPi0PtAlpha(NULL),
 239    hESDMotherEtaPtAlpha(NULL),
 240    hESDMotherPi0YEtaLowPtGamma(NULL),
 241    hESDMotherPi0YEtaHighPtGamma(NULL),
 242    hESDMotherEtaYEtaLowPtGamma(NULL),
 243    hESDMotherEtaYEtaHighPtGamma(NULL),
 244    hMCHeaders(NULL),
 245    hMCAllGammaPt(NULL),
 246    hMCDecayGammaPi0Pt(NULL),
 247    hMCDecayGammaRhoPt(NULL),
 248    hMCDecayGammaEtaPt(NULL),
 249    hMCDecayGammaOmegaPt(NULL),
 250    hMCDecayGammaEtapPt(NULL),
 251    hMCDecayGammaPhiPt(NULL),
 252    hMCDecayGammaSigmaPt(NULL),
 253    hMCConvGammaPt(NULL),
 254    hMCConvGammaR(NULL),
 255    hMCConvGammaEta(NULL),
 256    hMCPi0Pt(NULL),
 257    hMCPi0WOWeightPt(NULL),
 258    hMCEtaPt(NULL),
 259    hMCPi0InAccPt(NULL),
 260    hMCEtaInAccPt(NULL),
 261    hMCPi0PtY(NULL),
 262    hMCEtaPtY(NULL),
 263    hMCK0sPt(NULL),
 264    hMCK0sWOWeightPt(NULL),
 265    hMCK0sPtY(NULL),
 266    hESDTrueMotherInvMassPt(NULL),
 267    hESDTruePrimaryMotherInvMassPt(NULL),
 268    hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
 269    pESDTruePrimaryMotherWeightsInvMassPt(NULL),
 270    hESDTruePrimaryPi0MCPtResolPt(NULL),
 271    hESDTruePrimaryEtaMCPtResolPt(NULL),
 272    hESDTrueSecondaryMotherInvMassPt(NULL),
 273    hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
 274    hESDTrueK0sWithPi0DaughterMCPt(NULL),
 275    hESDTrueSecondaryMotherFromEtaInvMassPt(NULL),
 276    hESDTrueEtaWithPi0DaughterMCPt(NULL),
 277    hESDTrueBckGGInvMassPt(NULL),
 278    hESDTrueBckContInvMassPt(NULL),
 279    hESDTruePi0PtY(NULL),
 280    hESDTrueEtaPtY(NULL),
 281    hESDTruePi0PtAlpha(NULL),
 282    hESDTrueEtaPtAlpha(NULL),
 283    hESDTruePi0YEtaLowPtGamma(NULL),
 284    hESDTruePi0YEtaHighPtGamma(NULL),
 285    hESDTrueEtaYEtaLowPtGamma(NULL),
 286    hESDTrueEtaYEtaHighPtGamma(NULL),
 287    hESDTrueMotherDalitzInvMassPt(NULL),
 288    hESDTrueConvGammaPt(NULL),
 289    hESDCombinatorialPt(NULL),
 290    hESDTruePrimaryConvGammaPt(NULL),
 291    hESDTruePrimaryConvGammaESDPtMCPt(NULL),
 292    hESDTrueSecondaryConvGammaPt(NULL),
 293    hESDTrueSecondaryConvGammaFromXFromK0sPt(NULL),
 294    hESDTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
 295    hESDTrueDalitzPsiPairDeltaPhi(NULL),
 296    hESDTrueGammaPsiPairDeltaPhi(NULL),
 297    hNEvents(NULL),
 298    hNGoodESDTracks(NULL),
 299    hNGammaCandidates(NULL),
 300    hNV0Tracks(NULL),
 301    hEtaShift(NULL),
 302    tESDMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
 303    fInvMass(0),
 304    fPt(0),
 305    fDCAzGammaMin(0),
 306    fDCAzGammaMax(0),
 307    iFlag(0),
 308    iMesonMCInfo(0),
 309    fEventPlaneAngle(-100),
 310    fRandom(0),
 311    fnGammaCandidates(0),
 312    fUnsmearedPx(NULL),
 313    fUnsmearedPy(NULL),
 314    fUnsmearedPz(NULL),
 315    fUnsmearedE(NULL),
 316    fMCStackPos(NULL),
 317    fMCStackNeg(NULL),
 318    fESDArrayPos(NULL),
 319    fESDArrayNeg(NULL),
 320    fnCuts(0),
 321    fiCut(0),
 322    fMoveParticleAccordingToVertex(kTRUE),
 323    fIsHeavyIon(kFALSE),
 324    fDoMesonAnalysis(kTRUE),
 325    fDoMesonQA(0),
 326    fDoPhotonQA(0),
 327    fIsFromMBHeader(kTRUE),
 328    fIsMC(kFALSE)
 329 {
 330    // Define output slots here
 331    DefineOutput(1, TList::Class());
 332 }
 333
 334 AliAnalysisTaskGammaConvV1::~AliAnalysisTaskGammaConvV1()
 335 {
 336    if(fGammaCandidates){
 337       delete fGammaCandidates;
 338       fGammaCandidates = 0x0;
 339    }
 340    if(fBGHandler){
 341       delete[] fBGHandler;
 342       fBGHandler = 0x0;
 343    }
 344    if(fBGHandlerRP){
 345       delete[] fBGHandlerRP;
 346       fBGHandlerRP = 0x0;
 347    }
 348 }
 349 //___________________________________________________________
 350 void AliAnalysisTaskGammaConvV1::InitBack(){
 351
 352    const Int_t nDim = 4;
 353    Int_t nBins[nDim] = {800,250,7,4};
 354    Double_t xMin[nDim] = {0,0, 0,0};
 355    Double_t xMax[nDim] = {0.8,25,7,4};
 356
 357    sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
 358    sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
 359
 360    fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
 361    fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
 362    for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 363       if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
 364          TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
 365          TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
 366
 367          Int_t collisionSystem = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(0,1));
 368          Int_t centMin = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(1,1));
 369          Int_t centMax = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(2,1));
 370
 371          if(collisionSystem == 1 || collisionSystem == 2 ||
 372             collisionSystem == 5 || collisionSystem == 8 ||
 373             collisionSystem == 9){
 374             centMin = centMin*10;
 375             centMax = centMax*10;
 376             if(centMax ==0 && centMax!=centMin) centMax=100;
 377          }
 378          else if(collisionSystem == 3 || collisionSystem == 6){
 379             centMin = centMin*5;
 380             centMax = centMax*5;
 381          }
 382          else if(collisionSystem == 4 || collisionSystem == 7){
 383             centMin = ((centMin*5)+45);
 384             centMax = ((centMax*5)+45);
 385          }
 386
 387          fBackList[iCut] = new TList();
 388          fBackList[iCut]->SetName(Form("%s_%s Back histograms",cutstring.Data(),cutstringMeson.Data()));
 389          fBackList[iCut]->SetOwner(kTRUE);
 390          fCutFolder[iCut]->Add(fBackList[iCut]);
 391
 392          sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
 393          fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
 394
 395          fMotherList[iCut] = new TList();
 396          fMotherList[iCut]->SetName(Form("%s_%s Mother histograms",cutstring.Data(),cutstringMeson.Data()));
 397          fMotherList[iCut]->SetOwner(kTRUE);
 398          fCutFolder[iCut]->Add(fMotherList[iCut]);
 399
 400          sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
 401          fMotherList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
 402
 403          if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
 404             fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
 405                                                                   collisionSystem,centMin,centMax,
 406                                                                   ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
 407                                                                   ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity());
 408             fBGHandlerRP[iCut] = NULL;
 409          }
 410          else{
 411             fBGHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
 412                                                                  ((AliConversionCuts*)fCutArray->At(fiCut))->IsHeavyIon(),
 413                                                                  ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
 414                                                                  ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
 415             fBGHandler[iCut] = NULL;
 416          }
 417       }
 418    }
 419 }
 420 //________________________________________________________________________
 421 void AliAnalysisTaskGammaConvV1::UserCreateOutputObjects()
 422 {
 423
 424    // Create histograms
 425    if(fOutputContainer != NULL){
 426       delete fOutputContainer;
 427       fOutputContainer = NULL;
 428    }
 429    if(fOutputContainer == NULL){
 430       fOutputContainer = new TList();
 431       fOutputContainer->SetOwner(kTRUE);
 432    }
 433
 434    // Array of current cut's gammas
 435    fGammaCandidates = new TList();
 436
 437    fCutFolder = new TList*[fnCuts];
 438    fESDList = new TList*[fnCuts];
 439    fBackList = new TList*[fnCuts];
 440    fMotherList = new TList*[fnCuts];
 441    hNEvents = new TH1I*[fnCuts];
 442    hNGoodESDTracks = new TH1I*[fnCuts];
 443    hNGammaCandidates = new TH1I*[fnCuts];
 444    hNV0Tracks = new TH1I*[fnCuts];
 445    hEtaShift = new TProfile*[fnCuts];
 446    hESDConvGammaPt = new TH1F*[fnCuts];
 447
 448    if (fDoPhotonQA == 2){
 449       fPhotonDCAList = new TList*[fnCuts];
 450       tESDConvGammaPtDcazCat = new TTree*[fnCuts];
 451    }
 452    if (fDoPhotonQA > 0){
 453       hESDConvGammaR = new TH1F*[fnCuts];
 454       hESDConvGammaEta = new TH1F*[fnCuts];
 455    }
 456
 457    if(fDoMesonAnalysis){
 458       hESDMotherInvMassPt = new TH2F*[fnCuts];
 459       hESDMotherBackInvMassPt = new TH2F*[fnCuts];
 460       hESDMotherInvMassEalpha = new TH2F*[fnCuts];
 461       if (fDoMesonQA == 2){
 462          fMesonDCAList = new TList*[fnCuts];
 463          tESDMesonsInvMassPtDcazMinDcazMaxFlag = new TTree*[fnCuts];
 464       }
 465       if (fDoMesonQA > 0){
 466          hESDMotherPi0PtY =  new TH2F*[fnCuts];
 467          hESDMotherEtaPtY =  new TH2F*[fnCuts];
 468          hESDMotherPi0PtAlpha =  new TH2F*[fnCuts];
 469          hESDMotherEtaPtAlpha =  new TH2F*[fnCuts];
 470          hESDMotherPi0YEtaLowPtGamma =  new TH2F*[fnCuts];
 471          hESDMotherPi0YEtaHighPtGamma =  new TH2F*[fnCuts];
 472          hESDMotherEtaYEtaLowPtGamma =  new TH2F*[fnCuts];
 473          hESDMotherEtaYEtaHighPtGamma =  new TH2F*[fnCuts];
 474       }
 475    }
 476
 477    for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 478
 479       TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
 480       TString cutstringMeson = "NoMesonCut";
 481       if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
 482
 483       fCutFolder[iCut] = new TList();
 484       fCutFolder[iCut]->SetName(Form("Cut Number %s_%s",cutstring.Data(),cutstringMeson.Data()));
 485       fCutFolder[iCut]->SetOwner(kTRUE);
 486       fOutputContainer->Add(fCutFolder[iCut]);
 487       fESDList[iCut] = new TList();
 488       fESDList[iCut]->SetName(Form("%s_%s ESD histograms",cutstring.Data(),cutstringMeson.Data()));
 489       fESDList[iCut]->SetOwner(kTRUE);
 490       fCutFolder[iCut]->Add(fESDList[iCut]);
 491
 492       hNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
 493       hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
 494       hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
 495       hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
 496       if (((AliConversionCuts*)fCutArray->At(iCut))->IsSpecialTrigger() == 4 ){
 497          TString TriggerNames = "Not Trigger: ";
 498          TriggerNames = TriggerNames+ ( (AliConversionCuts*)fCutArray->At(iCut))->GetSpecialTriggerName();
 499          hNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
 500       } else {
 501          hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
 502       }
 503       hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
 504       hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
 505       hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
 506       hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
 507       hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
 508       fESDList[iCut]->Add(hNEvents[iCut]);
 509       if(fIsHeavyIon) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
 510       else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
 511       fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
 512       if(fIsHeavyIon) hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
 513       else hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
 514       fESDList[iCut]->Add(hNGammaCandidates[iCut]);
 515       if(fIsHeavyIon) hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
 516       else hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2000,0,2000);
 517       fESDList[iCut]->Add(hNV0Tracks[iCut]);
 518       hEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
 519       fESDList[iCut]->Add(hEtaShift[iCut]);
 520       hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
 521       fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
 522
 523       if (fDoPhotonQA == 2){
 524          fPhotonDCAList[iCut] = new TList();
 525          fPhotonDCAList[iCut]->SetName(Form("%s_%s Photon DCA tree",cutstring.Data(),cutstringMeson.Data()));
 526          fPhotonDCAList[iCut]->SetOwner(kTRUE);
 527          fCutFolder[iCut]->Add(fPhotonDCAList[iCut]);
 528
 529         tESDConvGammaPtDcazCat[iCut] = new TTree("ESD_ConvGamma_Pt_Dcaz_R_Eta","ESD_ConvGamma_Pt_Dcaz_R_Eta_Cat");
 530          tESDConvGammaPtDcazCat[iCut]->Branch("Pt",&fPtGamma,"fPtGamma/F");
 531          tESDConvGammaPtDcazCat[iCut]->Branch("DcaZPhoton",&fDCAzPhoton,"fDCAzPhoton/F");
 532 //          tESDConvGammaPtDcazCat[iCut]->Branch("R",&fRConvPhoton,"fRConvPhoton/F");
 533 //          tESDConvGammaPtDcazCat[iCut]->Branch("Eta",&fEtaPhoton,"fEtaPhoton/F");
 534
 535          tESDConvGammaPtDcazCat[iCut]->Branch("cat",&iCatPhoton,"iCatPhoton/b");
 536          if(fIsMC){
 537             tESDConvGammaPtDcazCat[iCut]->Branch("photonMCInfo",&iPhotonMCInfo,"iPhotonMCInfo/b");
 538          }
 539          fPhotonDCAList[iCut]->Add(tESDConvGammaPtDcazCat[iCut]);
 540       }
 541
 542       if (fDoPhotonQA > 0){
 543          hESDConvGammaR[iCut] = new TH1F("ESD_ConvGamma_R","ESD_ConvGamma_R",800,0,200);
 544          fESDList[iCut]->Add(hESDConvGammaR[iCut]);
 545          hESDConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",100,-4,4);
 546          fESDList[iCut]->Add(hESDConvGammaEta[iCut]);
 547       }
 548
 549       if(fDoMesonAnalysis){
 550          hESDMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
 551          fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
 552          hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
 553          fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
 554          hESDMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
 555          fESDList[iCut]->Add(hESDMotherInvMassEalpha[iCut]);
 556          if (fDoMesonQA == 2){
 557             fMesonDCAList[iCut] = new TList();
 558             fMesonDCAList[iCut]->SetName(Form("%s_%s Meson DCA tree",cutstring.Data(),cutstringMeson.Data()));
 559             fMesonDCAList[iCut]->SetOwner(kTRUE);
 560             fCutFolder[iCut]->Add(fMesonDCAList[iCut]);
 561
 562             tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut] = new TTree("ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag","ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag");
 563             tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("InvMass",&fInvMass,"fInvMass/F");
 564             tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("Pt",&fPt,"fPt/F");
 565             tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMin",&fDCAzGammaMin,"fDCAzGammaMin/F");
 566             tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMax",&fDCAzGammaMax,"fDCAzGammaMax/F");
 567             tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("kind",&iFlag,"iFlag/b");
 568             if(fIsMC){
 569                tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("mesonMCInfo",&iMesonMCInfo,"iMesonMCInfo/b");
 570             }
 571             fMesonDCAList[iCut]->Add(tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]);
 572
 573          }
 574          if (fDoMesonQA > 0 ){
 575             hESDMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",250,0,25,150,-1.5,1.5);
 576             fESDList[iCut]->Add(hESDMotherPi0PtY[iCut]);
 577             hESDMotherEtaPtY[iCut] = new TH2F("ESD_MotherEta_Pt_Y","ESD_MotherEta_Pt_Y",250,0,25,150,-1.5,1.5);
 578             fESDList[iCut]->Add(hESDMotherEtaPtY[iCut]);
 579             hESDMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",250,0,25,100,0,1);
 580             fESDList[iCut]->Add(hESDMotherPi0PtAlpha[iCut]);
 581             hESDMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",250,0,25,100,0,1);
 582             fESDList[iCut]->Add(hESDMotherEtaPtAlpha[iCut]);
 583             hESDMotherPi0YEtaLowPtGamma[iCut] = new TH2F("ESD_MotherPi0_Y_EtaLowPtGamma","ESD_MotherPi0_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
 584             fESDList[iCut]->Add(hESDMotherPi0YEtaLowPtGamma[iCut]);
 585             hESDMotherPi0YEtaHighPtGamma[iCut] = new TH2F("ESD_MotherPi0_Y_EtaHighPtGamma","ESD_MotherPi0_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
 586             fESDList[iCut]->Add(hESDMotherPi0YEtaHighPtGamma[iCut]);
 587             hESDMotherEtaYEtaLowPtGamma[iCut] = new TH2F("ESD_MotherEta_Y_EtaLowPtGamma","ESD_MotherEta_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
 588             fESDList[iCut]->Add(hESDMotherEtaYEtaLowPtGamma[iCut]);
 589             hESDMotherEtaYEtaHighPtGamma[iCut] = new TH2F("ESD_MotherEta_Y_EtaHighPtGamma","ESD_MotherEta_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
 590             fESDList[iCut]->Add(hESDMotherEtaYEtaHighPtGamma[iCut]);
 591          }
 592
 593
 594       }
 595
 596
 597    }
 598    if(fDoMesonAnalysis){
 599       InitBack(); // Init Background Handler
 600    }
 601
 602    if(fIsMC){
 603       // MC Histogramms
 604       fMCList = new TList*[fnCuts];
 605       // True Histogramms
 606       fTrueList = new TList*[fnCuts];
 607       // Selected Header List
 608       fHeaderNameList = new TList*[fnCuts];
 609       hMCHeaders = new TH1I*[fnCuts];
 610       hMCAllGammaPt = new TH1F*[fnCuts];
 611       hMCDecayGammaPi0Pt = new TH1F*[fnCuts];
 612       hMCDecayGammaRhoPt = new TH1F*[fnCuts];
 613       hMCDecayGammaEtaPt = new TH1F*[fnCuts];
 614       hMCDecayGammaOmegaPt = new TH1F*[fnCuts];
 615       hMCDecayGammaEtapPt = new TH1F*[fnCuts];
 616       hMCDecayGammaPhiPt = new TH1F*[fnCuts];
 617       hMCDecayGammaSigmaPt = new TH1F*[fnCuts];
 618       hMCConvGammaPt = new TH1F*[fnCuts];
 619       hESDTrueConvGammaPt = new TH1F*[fnCuts];
 620
 621       hESDCombinatorialPt = new TH2F*[fnCuts];
 622       hESDTruePrimaryConvGammaPt = new TH1F*[fnCuts];
 623       hESDTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
 624       hESDTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
 625       hESDTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
 626       hESDTrueSecondaryConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
 627
 628       hESDTrueDalitzPsiPairDeltaPhi= new TH2F*[fnCuts];
 629       hESDTrueGammaPsiPairDeltaPhi= new TH2F*[fnCuts];
 630
 631       if (fDoPhotonQA > 0){
 632          hMCConvGammaR = new TH1F*[fnCuts];
 633          hMCConvGammaEta = new TH1F*[fnCuts];
 634       }
 635
 636       if(fDoMesonAnalysis){
 637          hMCPi0Pt = new TH1F*[fnCuts];
 638          hMCPi0WOWeightPt = new TH1F*[fnCuts];
 639          hMCEtaPt = new TH1F*[fnCuts];
 640          hMCPi0InAccPt = new TH1F*[fnCuts];
 641          hMCEtaInAccPt = new TH1F*[fnCuts];
 642
 643          hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
 644          hESDTruePrimaryMotherInvMassPt = new TH2F*[fnCuts];
 645          hESDTruePrimaryMotherW0WeightingInvMassPt = new TH2F*[fnCuts];
 646          pESDTruePrimaryMotherWeightsInvMassPt = new TProfile2D*[fnCuts];
 647          hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
 648          hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
 649          hESDTrueSecondaryMotherFromEtaInvMassPt = new TH2F*[fnCuts];
 650          hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
 651          if (fDoMesonQA > 0){
 652             hMCPi0PtY = new TH2F*[fnCuts];
 653             hMCEtaPtY = new TH2F*[fnCuts];
 654             hMCK0sPt = new TH1F*[fnCuts];
 655             hMCK0sWOWeightPt = new TH1F*[fnCuts];
 656             hMCK0sPtY = new TH2F*[fnCuts];
 657             hESDTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
 658             hESDTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
 659             hESDTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
 660             hESDTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
 661             hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
 662             hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
 663             hESDTruePi0PtY = new TH2F*[fnCuts];
 664             hESDTrueEtaPtY = new TH2F*[fnCuts];
 665             hESDTruePi0PtAlpha = new TH2F*[fnCuts];
 666             hESDTrueEtaPtAlpha = new TH2F*[fnCuts];
 667             hESDTruePi0YEtaLowPtGamma = new TH2F*[fnCuts];
 668             hESDTruePi0YEtaHighPtGamma = new TH2F*[fnCuts];
 669             hESDTrueEtaYEtaLowPtGamma = new TH2F*[fnCuts];
 670             hESDTrueEtaYEtaHighPtGamma = new TH2F*[fnCuts];
 671          }
 672       }
 673
 674       for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 675          TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
 676          TString cutstringMeson = "NoMesonCut";
 677          if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
 678
 679          fMCList[iCut] = new TList();
 680          fMCList[iCut]->SetName(Form("%s_%s MC histograms",cutstring.Data(),cutstringMeson.Data()));
 681          fMCList[iCut]->SetOwner(kTRUE);
 682          fCutFolder[iCut]->Add(fMCList[iCut]);
 683          hMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
 684          fMCList[iCut]->Add(hMCHeaders[iCut]);
 685          hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
 686          fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
 687          hMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
 688          fMCList[iCut]->Add(hMCDecayGammaPi0Pt[iCut]);
 689          hMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
 690          fMCList[iCut]->Add(hMCDecayGammaRhoPt[iCut]);
 691          hMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
 692          fMCList[iCut]->Add(hMCDecayGammaEtaPt[iCut]);
 693          hMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
 694          fMCList[iCut]->Add(hMCDecayGammaOmegaPt[iCut]);
 695          hMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
 696          fMCList[iCut]->Add(hMCDecayGammaEtapPt[iCut]);
 697          hMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
 698          fMCList[iCut]->Add(hMCDecayGammaPhiPt[iCut]);
 699          hMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
 700          fMCList[iCut]->Add(hMCDecayGammaSigmaPt[iCut]);
 701          hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
 702          fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
 703
 704          if (fDoPhotonQA > 0){
 705             hMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
 706             fMCList[iCut]->Add(hMCConvGammaR[iCut]);
 707             hMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",100,-4,4);
 708             fMCList[iCut]->Add(hMCConvGammaEta[iCut]);
 709          }
 710
 711          if(fDoMesonAnalysis){
 712             hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
 713             hMCPi0Pt[iCut]->Sumw2();
 714             fMCList[iCut]->Add(hMCPi0Pt[iCut]);
 715             hMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
 716             hMCPi0WOWeightPt[iCut]->Sumw2();
 717             fMCList[iCut]->Add(hMCPi0WOWeightPt[iCut]);
 718
 719             hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
 720             hMCEtaPt[iCut]->Sumw2();
 721             fMCList[iCut]->Add(hMCEtaPt[iCut]);
 722             hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
 723             hMCPi0InAccPt[iCut]->Sumw2();
 724             fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
 725             hMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
 726             hMCEtaInAccPt[iCut]->Sumw2();
 727             fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
 728             if (fDoMesonQA > 0){
 729                hMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",250,0,25,150,-1.5,1.5);
 730                hMCPi0PtY[iCut]->Sumw2();
 731                fMCList[iCut]->Add(hMCPi0PtY[iCut]);
 732                hMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",250,0,25,150,-1.5,1.5);
 733                hMCEtaPtY[iCut]->Sumw2();
 734                fMCList[iCut]->Add(hMCEtaPtY[iCut]);
 735                hMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",250,0,25);
 736                hMCK0sPt[iCut]->Sumw2();
 737                fMCList[iCut]->Add(hMCK0sPt[iCut]);
 738                hMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",250,0,25);
 739                hMCK0sWOWeightPt[iCut]->Sumw2();
 740                fMCList[iCut]->Add(hMCK0sWOWeightPt[iCut]);
 741                hMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",250,0,25,150,-1.5,1.5);
 742                hMCK0sPtY[iCut]->Sumw2();
 743                fMCList[iCut]->Add(hMCK0sPtY[iCut]);
 744
 745             }
 746
 747          }
 748          fTrueList[iCut] = new TList();
 749          fTrueList[iCut]->SetName(Form("%s_%s True histograms",cutstring.Data(),cutstringMeson.Data()));
 750          fTrueList[iCut]->SetOwner(kTRUE);
 751          fCutFolder[iCut]->Add(fTrueList[iCut]);
 752
 753          hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
 754          fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
 755
 756          hESDCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
 757          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
 758          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
 759          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
 760          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
 761          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
 762          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
 763          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
 764          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
 765          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
 766          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
 767          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
 768          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
 769          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
 770          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
 771          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
 772          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
 773          fTrueList[iCut]->Add(hESDCombinatorialPt[iCut]);
 774          hESDTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
 775          fTrueList[iCut]->Add(hESDTruePrimaryConvGammaPt[iCut]);
 776          hESDTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
 777          fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaPt[iCut]);
 778
 779          hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]
 780             = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
 781          fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
 782          hESDTrueSecondaryConvGammaFromXFromLambdaPt[iCut]
 783             = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
 784          fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
 785
 786          hESDTrueDalitzPsiPairDeltaPhi[iCut]
 787             = new TH2F("ESD_TrueDalitzPsiPairDeltaPhi_Pt", "ESD_TrueDalitzPsiPairDeltaPhi_Pt",400,-2,2,400,-2,2);
 788          fTrueList[iCut]->Add(hESDTrueDalitzPsiPairDeltaPhi[iCut]);
 789
 790          hESDTrueGammaPsiPairDeltaPhi[iCut]
 791             = new TH2F("ESD_TrueGammaPsiPairDeltaPhi_Pt", "ESD_TrueGammaPsiPairDeltaPhi_Pt",200,-2,2,400,-2,2);
 792          fTrueList[iCut]->Add(hESDTrueGammaPsiPairDeltaPhi[iCut]);
 793
 794
 795          hESDTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
 796          fTrueList[iCut]->Add(hESDTruePrimaryConvGammaESDPtMCPt[iCut]);
 797
 798          if(fDoMesonAnalysis){
 799             hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
 800             fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
 801             hESDTruePrimaryMotherInvMassPt[iCut]
 802                = new TH2F("ESD_TruePrimaryMother_InvMass_Pt", "ESD_TruePrimaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
 803             hESDTruePrimaryMotherInvMassPt[iCut]->Sumw2();
 804             fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassPt[iCut]);
 805             hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]
 806                = new TH2F("ESD_TruePrimaryMotherW0Weights_InvMass_Pt", "ESD_TruePrimaryMotherW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
 807             hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]->Sumw2();
 808             fTrueList[iCut]->Add(hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]);
 809             pESDTruePrimaryMotherWeightsInvMassPt[iCut]
 810                = new TProfile2D("ESD_TruePrimaryMotherWeights_InvMass_Pt", "ESD_TruePrimaryMotherWeights_InvMass_Pt", 800,0,0.8,250,0,25);
 811             pESDTruePrimaryMotherWeightsInvMassPt[iCut]->Sumw2();
 812             fTrueList[iCut]->Add(pESDTruePrimaryMotherWeightsInvMassPt[iCut]);
 813             hESDTrueSecondaryMotherInvMassPt[iCut]
 814                = new TH2F("ESD_TrueSecondaryMother_InvMass_Pt", "ESD_TrueSecondaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
 815             hESDTrueSecondaryMotherInvMassPt[iCut]->Sumw2();
 816             fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
 817             hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]
 818                = new TH2F("ESD_TrueSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueSecondaryMotherFromK0s_InvMass_Pt",800,0,0.8,250,0,25);
 819             hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]->Sumw2();
 820             fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
 821             hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]
 822                = new TH2F("ESD_TrueSecondaryMotherFromEta_InvMass_Pt","ESD_TrueSecondaryMotherFromEta_InvMass_Pt",800,0,0.8,250,0,25);
 823             fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]);
 824             hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueDalitz_InvMass_Pt","ESD_TrueDalitz_InvMass_Pt",800,0,0.8,250,0,25);
 825             fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
 826             if (fDoMesonQA > 0){
 827                hESDTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0,25,1000,-1.,1.);
 828                hESDTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
 829                fTrueList[iCut]->Add(hESDTruePrimaryPi0MCPtResolPt[iCut]);
 830                hESDTruePrimaryEtaMCPtResolPt[iCut]  = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0,25,1000,-1.,1.);
 831                hESDTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
 832                fTrueList[iCut]->Add(hESDTruePrimaryEtaMCPtResolPt[iCut]);
 833                hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
 834                fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
 835                hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
 836                fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
 837                hESDTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
 838                fTrueList[iCut]->Add(hESDTrueK0sWithPi0DaughterMCPt[iCut]);
 839                hESDTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
 840                fTrueList[iCut]->Add(hESDTrueEtaWithPi0DaughterMCPt[iCut]);
 841                hESDTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",250,0,25,150,-1.5,1.5);
 842                fTrueList[iCut]->Add(hESDTruePi0PtY[iCut]);
 843                hESDTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",250,0,25,150,-1.5,1.5);
 844                fTrueList[iCut]->Add(hESDTrueEtaPtY[iCut]);
 845                hESDTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",250,0,25,100,0,1);
 846                fTrueList[iCut]->Add(hESDTruePi0PtAlpha[iCut]);
 847                hESDTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",250,0,25,100,0,1);
 848                fTrueList[iCut]->Add(hESDTrueEtaPtAlpha[iCut]);
 849
 850                hESDTruePi0YEtaLowPtGamma[iCut] = new TH2F("ESD_TruePi0_Y_EtaLowPtGamma","ESD_TruePi0_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
 851                fTrueList[iCut]->Add(hESDTruePi0YEtaLowPtGamma[iCut]);
 852                hESDTruePi0YEtaHighPtGamma[iCut] = new TH2F("ESD_TruePi0_Y_EtaHighPtGamma","ESD_TruePi0_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
 853                fTrueList[iCut]->Add(hESDTruePi0YEtaHighPtGamma[iCut]);
 854                hESDTrueEtaYEtaLowPtGamma[iCut] = new TH2F("ESD_TrueEta_Y_EtaLowPtGamma","ESD_TrueEta_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
 855                fTrueList[iCut]->Add(hESDTrueEtaYEtaLowPtGamma[iCut]);
 856                hESDTrueEtaYEtaHighPtGamma[iCut] = new TH2F("ESD_TrueEta_Y_EtaHighPtGamma","ESD_TrueEta_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
 857                fTrueList[iCut]->Add(hESDTrueEtaYEtaHighPtGamma[iCut]);
 858             }
 859          }
 860       }
 861    }
 862
 863    fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
 864    if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
 865
 866    if(fV0Reader)
 867       if((AliConversionCuts*)fV0Reader->GetConversionCuts())
 868          if(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
 869             fOutputContainer->Add(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
 870
 871    for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 872       if(!((AliConversionCuts*)fCutArray->At(iCut))) continue;
 873       if(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms()){
 874          fCutFolder[iCut]->Add(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms());
 875       }
 876       if(fDoMesonAnalysis){
 877          if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
 878          if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
 879             fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
 880          }
 881       }
 882    }
 883    PostData(1, fOutputContainer);
 884 }
 885 //_____________________________________________________________________________
 886 Bool_t AliAnalysisTaskGammaConvV1::Notify()
 887 {
 888    for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 889       if(!((AliConversionCuts*)fCutArray->At(iCut))->GetDoEtaShift()){
 890          hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
 891          continue; // No Eta Shift requested, continue
 892       }
 893       if(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
 894          ((AliConversionCuts*)fCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
 895           hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
 896          ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
 897          continue;
 898       }
 899       else{
 900          printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
 901                 (((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift());
 902           hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
 903          ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
 904       }
 905    }
 906
 907    return kTRUE;
 908 }
 909 //_____________________________________________________________________________
 910 void AliAnalysisTaskGammaConvV1::UserExec(Option_t *)
 911 {
 912    //
 913    // Called for each event
 914    //
 915    Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
 916    if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
 917       for(Int_t iCut = 0; iCut<fnCuts; iCut++){
 918          hNEvents[iCut]->Fill(eventQuality);
 919       }
 920       return;
 921    }
 922
 923    if(fIsMC) fMCEvent = MCEvent();
 924    if(fMCEvent == NULL) fIsMC = kFALSE;
 925
 926    fInputEvent = InputEvent();
 927
 928    if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
 929       fMCStack = fMCEvent->Stack();
 930       if(fMCStack == NULL) fIsMC = kFALSE;
 931    }
 932
 933    fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
 934
 935    // ------------------- BeginEvent ----------------------------
 936
 937    AliEventplane *EventPlane = fInputEvent->GetEventplane();
 938    if(fIsHeavyIon)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
 939    else fEventPlaneAngle=0.0;
 940
 941    if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
 942       RelabelAODPhotonCandidates(kTRUE);    // In case of AODMC relabeling MC
 943       fV0Reader->RelabelAODs(kTRUE);
 944    }
 945    for(Int_t iCut = 0; iCut<fnCuts; iCut++){
 946       fiCut = iCut;
 947       Int_t eventNotAccepted =
 948          ((AliConversionCuts*)fCutArray->At(iCut))
 949          ->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
 950       if(eventNotAccepted){
 951          // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
 952          hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
 953          continue;
 954       }
 955
 956       if(eventQuality != 0){// Event Not Accepted
 957          // cout << "event rejected due to: " <<eventQuality << endl;
 958          hNEvents[iCut]->Fill(eventQuality);
 959          continue;
 960       }
 961
 962       hNEvents[iCut]->Fill(eventQuality); // Should be 0 here
 963       hNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
 964       if(((AliConversionCuts*)fCutArray->At(iCut))->IsHeavyIon() == 2)  hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
 965       else hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
 966
 967       if(fIsMC){
 968          // Process MC Particle
 969          if(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection() != 0){
 970             if(fInputEvent->IsA()==AliESDEvent::Class()){
 971                ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
 972                                                                                   ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
 973                                                                                   fMCEvent);
 974             }
 975             else if(fInputEvent->IsA()==AliAODEvent::Class()){
 976                ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
 977                                                                                   ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
 978                                                                                   fInputEvent);
 979             }
 980
 981             if(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader()){
 982                for(Int_t i = 0;i<(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
 983                   TString nameBin= hMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
 984                   if (nameBin.CompareTo("")== 0){
 985                      TString nameHeader = ((TObjString*)((TList*)((AliConversionCuts*)fCutArray->At(iCut))
 986                                                          ->GetAcceptedHeader())->At(i))->GetString();
 987                      hMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
 988                   }
 989                }
 990             }
 991          }
 992       }
 993       if(fIsMC){
 994          if(fInputEvent->IsA()==AliESDEvent::Class())
 995             ProcessMCParticles();
 996          if(fInputEvent->IsA()==AliAODEvent::Class())
 997             ProcessAODMCParticles();
 998       }
 999
1000       ProcessPhotonCandidates(); // Process this cuts gammas
1001
1002       hNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
1003       if(fDoMesonAnalysis){ // Meson Analysis
1004          if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1005             fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
1006             fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
1007             fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
1008             fUnsmearedE =  new Double_t[fGammaCandidates->GetEntries()];
1009
1010             for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1011                fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
1012                fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
1013                fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
1014                fUnsmearedE[gamma] =  ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
1015                ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
1016             }
1017          }
1018
1019          CalculatePi0Candidates(); // Combine Gammas
1020          if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1021             if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1022                CalculateBackground(); // Combinatorial Background
1023                UpdateEventByEventData(); // Store Event for mixed Events
1024             }
1025             else{
1026                CalculateBackgroundRP(); // Combinatorial Background
1027                fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
1028             }
1029          }
1030          if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1031             for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1032                ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1033                ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1034                ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1035                ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
1036             }
1037             delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1038             delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1039             delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1040             delete[] fUnsmearedE;  fUnsmearedE  = 0x0;
1041          }
1042       }
1043       fGammaCandidates->Clear(); // delete this cuts good gammas
1044    }
1045
1046    if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1047       RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
1048       fV0Reader->RelabelAODs(kFALSE);
1049    }
1050
1051    PostData(1, fOutputContainer);
1052 }
1053 //________________________________________________________________________
1054 void AliAnalysisTaskGammaConvV1::ProcessPhotonCandidates()
1055 {
1056    Int_t nV0 = 0;
1057    TList *GammaCandidatesStepOne = new TList();
1058    TList *GammaCandidatesStepTwo = new TList();
1059    // Loop over Photon Candidates allocated by ReaderV1
1060    for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1061       AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1062       if(!PhotonCandidate) continue;
1063       fIsFromMBHeader = kTRUE;
1064       if(fIsMC && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1065          Int_t isPosFromMBHeader
1066             = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1067          if(isPosFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1068          Int_t isNegFromMBHeader
1069             = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1070          if(isNegFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1071
1072          if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1073       }
1074
1075       if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
1076       if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(PhotonCandidate->GetPhotonPhi(),fEventPlaneAngle)) continue;
1077       if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1078          !((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1079          fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1080
1081          if(fIsFromMBHeader){
1082             hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1083             if (fDoPhotonQA > 0){
1084                hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1085                hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1086             }
1087          }
1088          if(fIsMC){
1089             if(fInputEvent->IsA()==AliESDEvent::Class())
1090                ProcessTruePhotonCandidates(PhotonCandidate);
1091             if(fInputEvent->IsA()==AliAODEvent::Class())
1092                ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1093          }
1094          if (fIsFromMBHeader && fDoPhotonQA == 2){
1095             if (fIsHeavyIon && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1096                fPtGamma = PhotonCandidate->Pt();
1097                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1098                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1099                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1100                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1101                tESDConvGammaPtDcazCat[fiCut]->Fill();
1102             } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1103                fPtGamma = PhotonCandidate->Pt();
1104                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1105                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1106                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1107                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1108                tESDConvGammaPtDcazCat[fiCut]->Fill();
1109             }
1110          }
1111       } else if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1112          ((AliConversionCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1113          nV0++;
1114          GammaCandidatesStepOne->Add(PhotonCandidate);
1115       } else if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1116               ((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1117          GammaCandidatesStepTwo->Add(PhotonCandidate);
1118       }
1119    }
1120    if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
1121       for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1122          AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1123          if(!PhotonCandidate) continue;
1124          fIsFromMBHeader = kTRUE;
1125          if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1126             Int_t isPosFromMBHeader
1127                = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1128             Int_t isNegFromMBHeader
1129                = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1130             if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1131          }
1132          if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1133          if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1134             fGammaCandidates->Add(PhotonCandidate);
1135             if(fIsFromMBHeader){
1136                hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1137                if (fDoPhotonQA > 0){
1138                   hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1139                   hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1140                }
1141             }
1142          }
1143          if(fIsMC){
1144             if(fInputEvent->IsA()==AliESDEvent::Class())
1145                ProcessTruePhotonCandidates(PhotonCandidate);
1146             if(fInputEvent->IsA()==AliAODEvent::Class())
1147                ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1148          } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1149
1150            if (fIsFromMBHeader && fDoPhotonQA == 2){
1151             if (fIsHeavyIon && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1152                fPtGamma = PhotonCandidate->Pt();
1153                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1154                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1155                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1156                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1157                tESDConvGammaPtDcazCat[fiCut]->Fill();
1158             } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1159                fPtGamma = PhotonCandidate->Pt();
1160                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1161                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1162                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1163                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1164                tESDConvGammaPtDcazCat[fiCut]->Fill();
1165             }
1166          }
1167       }
1168    }
1169    if(((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1170       for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1171          AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1172          if(!PhotonCandidate) continue;
1173          fIsFromMBHeader = kTRUE;
1174          if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1175             Int_t isPosFromMBHeader
1176                = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1177             Int_t isNegFromMBHeader
1178                = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1179             if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1180          }
1181          if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
1182          fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1183          if(fIsFromMBHeader){
1184             hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1185             if (fDoPhotonQA > 0){
1186                hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1187                hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1188             }
1189          }
1190          if(fIsMC){
1191             if(fInputEvent->IsA()==AliESDEvent::Class())
1192                ProcessTruePhotonCandidates(PhotonCandidate);
1193             if(fInputEvent->IsA()==AliAODEvent::Class())
1194                ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1195          }
1196          if (fIsFromMBHeader){
1197            if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1198                fPtGamma = PhotonCandidate->Pt();
1199                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1200                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1201                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1202                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1203                tESDConvGammaPtDcazCat[fiCut]->Fill();
1204             } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1205                fPtGamma = PhotonCandidate->Pt();
1206                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1207                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1208                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1209                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1210                tESDConvGammaPtDcazCat[fiCut]->Fill();
1211             }
1212          }
1213       }
1214    }
1215
1216    delete GammaCandidatesStepOne;
1217    GammaCandidatesStepOne = 0x0;
1218    delete GammaCandidatesStepTwo;
1219    GammaCandidatesStepTwo = 0x0;
1220
1221 }
1222 //________________________________________________________________________
1223 void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1224 {
1225
1226    Double_t magField = fInputEvent->GetMagneticField();
1227    if( magField  < 0.0 ){
1228       magField =  1.0;
1229    }
1230    else {
1231       magField =  -1.0;
1232    }
1233
1234    TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1235    AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1236    AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
1237    iPhotonMCInfo = 0;
1238
1239    if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1240    Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1241
1242    if(posDaughter->GetMother() != negDaughter->GetMother()){
1243       FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1244       iPhotonMCInfo = 1;
1245       return;
1246    }
1247    else if(posDaughter->GetMother() == -1){
1248       FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1249       iPhotonMCInfo = 1;
1250       return;
1251    }
1252
1253    if(pdgCode[0]!=11 || pdgCode[1]!=11){
1254       iPhotonMCInfo = 1;
1255       return; //One Particle is not a electron
1256    }
1257    if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
1258       iPhotonMCInfo = 1;
1259       return; // Same Charge
1260    }
1261
1262    AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
1263    AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1264    AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1265    Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1266
1267    if(Photon->GetPdgCode() != 22){
1268       hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1269       iPhotonMCInfo = 1;
1270       return; // Mother is no Photon
1271    }
1272
1273    if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
1274       iPhotonMCInfo = 1;
1275       return;// check if the daughters come from a conversion
1276    }
1277    // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1278
1279
1280
1281    // True Photon
1282    if(fIsFromMBHeader)hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1283    hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1284    if(Photon->IsPrimary()){
1285       // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1286       if(fIsFromMBHeader){
1287          iPhotonMCInfo = 6;
1288          hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1289          hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1290       }
1291       // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1292    }
1293    else{
1294       if(fIsFromMBHeader){
1295          hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1296          iPhotonMCInfo = 2;
1297          if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1298             ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1299             iPhotonMCInfo = 5;
1300             hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1301          }
1302          if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1303             ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1304             iPhotonMCInfo = 4;
1305             hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1306          }
1307          if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1308             ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1309             iPhotonMCInfo = 3;
1310          }
1311       }
1312    }
1313
1314 }
1315 //________________________________________________________________________
1316 void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1317 {
1318
1319   Double_t magField = fInputEvent->GetMagneticField();
1320    if( magField  < 0.0 ){
1321       magField =  1.0;
1322    }
1323    else {
1324       magField =  -1.0;
1325    }
1326
1327    // Process True Photons
1328    TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1329    TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
1330
1331    iPhotonMCInfo = 0;
1332
1333    if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1334    Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1335    iPhotonMCInfo = 1;
1336    if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
1337       FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1338       return;
1339    }
1340    else if(posDaughter->GetMother(0) == -1){
1341       FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1342       return;
1343    }
1344
1345    if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1346
1347    if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1348
1349    TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
1350    AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1351    AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1352    Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1353
1354    if(Photon->GetPdgCode() != 22){
1355       hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1356       return; // Mother is no Photon
1357    }
1358
1359    if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1360
1361
1362
1363    // True Photon
1364    if(fIsFromMBHeader){
1365       hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1366    }
1367    hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1368    if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
1369       // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1370       if(fIsFromMBHeader){
1371          iPhotonMCInfo = 6;
1372          hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1373          hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1374
1375       }
1376       // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1377    }
1378    else{
1379       if(fIsFromMBHeader){
1380          iPhotonMCInfo = 2;
1381          hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1382          if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1383             fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
1384             hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1385             iPhotonMCInfo = 5;
1386          }
1387          if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1388             fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
1389             hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1390             iPhotonMCInfo = 4;
1391          }
1392          if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1393             fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
1394             iPhotonMCInfo = 3;
1395          }
1396       }
1397    }
1398 }
1399 //________________________________________________________________________
1400 void AliAnalysisTaskGammaConvV1::ProcessAODMCParticles()
1401 {
1402
1403    TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1404
1405    // Loop over all primary MC particle
1406    for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
1407
1408       AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
1409       if (!particle) continue;
1410       if (!particle->IsPrimary()) continue;
1411
1412       Int_t isMCFromMBHeader = -1;
1413       if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1414          isMCFromMBHeader
1415             = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1416          if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1417       }
1418
1419       if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
1420       if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
1421          hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1422          if(particle->GetMother() >-1){ // Meson Decay Gamma
1423             switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
1424             case 111: // Pi0
1425                hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1426                break;
1427             case 113: // Rho0
1428                hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1429                break;
1430             case 221: // Eta
1431                hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1432                break;
1433             case 223: // Omega
1434                hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1435                break;
1436             case 331: // Eta'
1437                hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1438                break;
1439             case 333: // Phi
1440                hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1441                break;
1442             case 3212: // Sigma
1443                hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1444                break;
1445             }
1446          }
1447       }
1448       if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
1449          Double_t rConv = 0;
1450          for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
1451             AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
1452             if(!tmpDaughter) continue;
1453             if(abs(tmpDaughter->GetPdgCode()) == 11){
1454                rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
1455             }
1456          }
1457          hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1458          if (fDoPhotonQA > 0){
1459             hMCConvGammaR[fiCut]->Fill(rConv);
1460             hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1461          }
1462       }
1463       // Converted MC Gamma
1464       if(fDoMesonAnalysis){
1465          if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1466             Double_t mesonY = 10.;
1467             if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1468                mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1469             } else{
1470                mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1471                   -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1472             }
1473             Float_t weightedK0s= 1;
1474             if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1475                if (particle->Pt()>0.005){
1476                   weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1477                   //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
1478                }
1479             }
1480             hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1481             hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1482             hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1483          }
1484          if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1485             ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1486             AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
1487             AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
1488             Float_t weighted= 1;
1489             if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1490                if (particle->Pt()>0.005){
1491                   weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1492                   //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
1493                }
1494             }
1495             Double_t mesonY = 10.;
1496             if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1497                mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1498             } else{
1499                mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1500                   -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1501             }
1502
1503             if(particle->GetPdgCode() == 111){
1504                hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1505                hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1506                if (fDoMesonQA > 0) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1507             } else if(particle->GetPdgCode() == 221){
1508                hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1509                if (fDoMesonQA > 0) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1510             }
1511
1512             // Check the acceptance for both gammas
1513             if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
1514                ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE)  &&
1515                ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
1516                ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
1517
1518                if(particle->GetPdgCode() == 111){
1519                   hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1520                } else if(particle->GetPdgCode() == 221){
1521                   hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1522                }
1523             }
1524          }
1525       }
1526    }
1527 }
1528 //________________________________________________________________________
1529 void AliAnalysisTaskGammaConvV1::ProcessMCParticles()
1530 {
1531    // Loop over all primary MC particle
1532    for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
1533       TParticle* particle = (TParticle *)fMCStack->Particle(i);
1534       if (!particle) continue;
1535
1536       Int_t isMCFromMBHeader = -1;
1537       if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1538          isMCFromMBHeader
1539             = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1540          if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1541       }
1542
1543       if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
1544       if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
1545          hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1546          if(particle->GetMother(0) >-1){ // Meson Decay Gamma
1547             switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
1548             case 111: // Pi0
1549                hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1550                break;
1551             case 113: // Rho0
1552                hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1553                break;
1554             case 221: // Eta
1555                hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1556                break;
1557             case 223: // Omega
1558                hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1559                break;
1560             case 331: // Eta'
1561                hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1562                break;
1563             case 333: // Phi
1564                hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1565                break;
1566             case 3212: // Sigma
1567                hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1568                break;
1569             }
1570          }
1571       }
1572       if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
1573          hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1574          if (fDoPhotonQA > 0){
1575             hMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
1576             hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1577          }
1578       } // Converted MC Gamma
1579       if(fDoMesonAnalysis){
1580          if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1581             Double_t mesonY = 10.;
1582             if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1583                mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1584             } else{
1585                mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1586                   -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1587             }
1588             Float_t weightedK0s= 1;
1589             if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1590                if (particle->Pt()>0.005){
1591                   weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1592                   //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
1593                }
1594             }
1595             hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1596             hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1597             hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1598          }
1599          if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1600             ->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1601             TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
1602             TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
1603
1604             Float_t weighted= 1;
1605             if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1606                if (particle->Pt()>0.005){
1607                   weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1608                   //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
1609                }
1610             }
1611             Double_t mesonY = 10.;
1612             if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1613                mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1614             } else{
1615                mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1616                   -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1617             }
1618
1619             if(particle->GetPdgCode() == 111){
1620                hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1621                hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1622                if (fDoMesonQA > 0) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1623             } else if(particle->GetPdgCode() == 221){
1624                hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1625                if (fDoMesonQA > 0) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1626             }
1627
1628             // Check the acceptance for both gammas
1629             if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
1630                ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE)  &&
1631                ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
1632                ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
1633
1634                if(particle->GetPdgCode() == 111){
1635                   hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1636                } else if(particle->GetPdgCode() == 221){
1637                   hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1638                }
1639             }
1640          }
1641       }
1642    }
1643 }
1644 //________________________________________________________________________
1645 void AliAnalysisTaskGammaConvV1::CalculatePi0Candidates(){
1646
1647    // Conversion Gammas
1648    if(fGammaCandidates->GetEntries()>1){
1649       for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
1650          AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
1651          if (gamma0==NULL) continue;
1652          for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
1653             AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
1654             //Check for same Electron ID
1655             if (gamma1==NULL) continue;
1656             if(gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelPositive() ||
1657                gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelNegative() ||
1658                gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelPositive() ||
1659                gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelNegative() ) continue;
1660
1661             AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
1662             pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
1663
1664             pi0cand->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
1665             if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1666                 ->MesonIsSelected(pi0cand,kTRUE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
1667                hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1668                if(pi0cand->GetAlpha()<0.1)
1669                   hESDMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
1670
1671                if (fDoMesonQA > 0){
1672                   if ( pi0cand->M() < 0.17){
1673                      hESDMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1674                      hESDMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1675                      if (gamma0->Pt() < gamma1->Pt()){
1676                        hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1677                        hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1678                      } else {
1679                        hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1680                        hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1681                      }
1682                   }
1683                   if ( pi0cand->M() > 0.17 && pi0cand->M() < 0.7){
1684                      hESDMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1685                      hESDMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1686                      if (gamma0->Pt() < gamma1->Pt()){
1687                        hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1688                        hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1689                      } else {
1690                        hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1691                        hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1692                      }
1693                   }
1694                }
1695                if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
1696                   Int_t zbin = 0;
1697                   Int_t mbin = 0;
1698
1699                   if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
1700                      zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1701                      if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1702                         mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1703                      } else {
1704                         mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1705                      }
1706                   }
1707                   else{
1708                      zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1709                      if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1710                         mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1711                      } else {
1712                         mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1713                      }
1714                   }
1715                   Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1716                   sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1717                }
1718
1719
1720                if(fIsMC){
1721                   if(fInputEvent->IsA()==AliESDEvent::Class())
1722                      ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1);
1723                   if(fInputEvent->IsA()==AliAODEvent::Class())
1724                      ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1);
1725                }
1726                if (fDoMesonQA == 2){
1727                   fInvMass = pi0cand->M();
1728                   fPt  = pi0cand->Pt();
1729                   if (abs(gamma0->GetDCAzToPrimVtx()) < abs(gamma1->GetDCAzToPrimVtx())){
1730                      fDCAzGammaMin = gamma0->GetDCAzToPrimVtx();
1731                      fDCAzGammaMax = gamma1->GetDCAzToPrimVtx();
1732                   } else {
1733                      fDCAzGammaMin = gamma1->GetDCAzToPrimVtx();
1734                      fDCAzGammaMax = gamma0->GetDCAzToPrimVtx();
1735                   }
1736                   iFlag = pi0cand->GetMesonQuality();
1737 //                   cout << "gamma 0: " << gamma0->GetV0Index()<< "\t" << gamma0->GetPx() << "\t" << gamma0->GetPy() << "\t" <<  gamma0->GetPz() << "\t" << endl;
1738 //                   cout << "gamma 1: " << gamma1->GetV0Index()<< "\t"<< gamma1->GetPx() << "\t" << gamma1->GetPy() << "\t" <<  gamma1->GetPz() << "\t" << endl;
1739 //                    cout << "pi0: "<<fInvMass << "\t" << fPt <<"\t" << fDCAzGammaMin << "\t" << fDCAzGammaMax << "\t" << (Int_t)iFlag << "\t" << (Int_t)iMesonMCInfo <<endl;
1740                   if (fIsHeavyIon == 1 && fPt > 0.399 && fPt < 20. ) {
1741                      if (fInvMass > 0.08 && fInvMass < 0.2) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1742                      if ((fInvMass > 0.45 && fInvMass < 0.6) &&  (fPt > 0.999 && fPt < 20.) )tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1743                   } else if (fPt > 0.299 && fPt < 20. )  {
1744                      if ( (fInvMass > 0.08 && fInvMass < 0.2) || (fInvMass > 0.45 && fInvMass < 0.6)) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1745                   }
1746                }
1747             }
1748             delete pi0cand;
1749             pi0cand=0x0;
1750          }
1751       }
1752    }
1753 }
1754 //______________________________________________________________________
1755 void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1756 {
1757    // Process True Mesons
1758    AliStack *MCStack = fMCEvent->Stack();
1759    iMesonMCInfo = 0;
1760    if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
1761       Bool_t isTruePi0 = kFALSE;
1762       Bool_t isTrueEta = kFALSE;
1763       Bool_t isTruePi0Dalitz = kFALSE;
1764       Bool_t isTrueEtaDalitz = kFALSE;
1765       Bool_t gamma0DalitzCand = kFALSE;
1766       Bool_t gamma1DalitzCand = kFALSE;
1767       Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
1768       Int_t gamma0MotherLabel = -1;
1769       if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1770          // Daughters Gamma 0
1771          TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
1772          TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
1773          TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
1774          if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){  // Electrons ...
1775             if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1776                if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1777                   gamma0MotherLabel=gammaMC0->GetFirstMother();
1778                }
1779             }
1780             if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate
1781                gamma0DalitzCand = kTRUE;
1782                gamma0MotherLabel=-111;
1783             }
1784             if(gammaMC0->GetPdgCode() ==221){ // Dalitz candidate
1785                gamma0DalitzCand = kTRUE;
1786                gamma0MotherLabel=-221;
1787             }
1788          }
1789       }
1790       if(TrueGammaCandidate1->GetV0Index()<fInputEvent->GetNumberOfV0s()){
1791          Int_t gamma1MCLabel = TrueGammaCandidate1->GetMCParticleLabel(MCStack);
1792          Int_t gamma1MotherLabel = -1;
1793          if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1794             // Daughters Gamma 1
1795             TParticle * negativeMC = (TParticle*)TrueGammaCandidate1->GetNegativeMCDaughter(MCStack);
1796             TParticle * positiveMC = (TParticle*)TrueGammaCandidate1->GetPositiveMCDaughter(MCStack);
1797             TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
1798             if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){  // Electrons ...
1799                if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1800                   if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
1801                      gamma1MotherLabel=gammaMC1->GetFirstMother();
1802                   }
1803                }
1804                if(gammaMC1->GetPdgCode() ==111 ){ // Dalitz candidate
1805                  gamma1DalitzCand = kTRUE;
1806                  gamma1MotherLabel=-111;
1807                }
1808                if(gammaMC1->GetPdgCode() ==221){ // Dalitz candidate
1809                  gamma1DalitzCand = kTRUE;
1810                  gamma1MotherLabel=-221;
1811                }
1812             }
1813          }
1814          if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1815             if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
1816                isTruePi0=kTRUE;
1817             }
1818             if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
1819                isTrueEta=kTRUE;
1820             }
1821          }
1822
1823          //Identify Dalitz candidate
1824          if (gamma1DalitzCand || gamma0DalitzCand){
1825             if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){
1826                if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE;
1827                if (gamma0MotherLabel == -221) isTrueEtaDalitz = kTRUE;
1828             }
1829             if (gamma1DalitzCand && gamma1MCLabel >=0 && gamma1MCLabel==gamma0MotherLabel){
1830                if (gamma1MotherLabel == -111) isTruePi0Dalitz = kTRUE;
1831                if (gamma1MotherLabel == -221) isTrueEtaDalitz = kTRUE;
1832             }
1833          }
1834
1835
1836          if(isTruePi0 || isTrueEta){// True Pion or Eta
1837             hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1838             if (fDoMesonQA > 0){
1839                if (isTruePi0){
1840                   hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1841                   hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
1842                   if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
1843                      hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1844                      hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1845                   } else {
1846                      hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1847                      hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1848                   }
1849
1850                } else if (isTrueEta){
1851                   hESDTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1852                   hESDTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
1853                   if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
1854                      hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1855                      hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1856                   } else {
1857                      hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1858                      hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1859                   }
1860                }
1861             }
1862             if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
1863                Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetMother(0);
1864                Float_t weightedSec= 1;
1865                if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1866                   weightedSec= ((AliConversionCuts*)fCutArray->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
1867                   //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
1868                }
1869                hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1870                iMesonMCInfo = 2;
1871                if (secMotherLabel >-1){
1872                   if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1873                      iMesonMCInfo = 4;
1874                      hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1875                      if (fDoMesonQA > 0)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
1876                                        ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1877                   }
1878                   if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221){
1879                      iMesonMCInfo = 3;
1880                      hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1881                      if (fDoMesonQA > 0)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
1882                                        ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1883                   }
1884                }
1885             }else{ // Only primary pi0 for efficiency calculation
1886                iMesonMCInfo = 6;
1887                Float_t weighted= 1;
1888                if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
1889                   if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
1890                      weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
1891 //                      cout << "rec \t " <<gamma1MotherLabel << "\t" <<  weighted << endl;
1892                   }
1893                }
1894                hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1895                hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1896                pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1897
1898
1899                if (fDoMesonQA > 0){
1900                   if(isTruePi0){ // Only primary pi0 for resolution
1901                      hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1902                   }
1903                   if (isTrueEta){ // Only primary eta for resolution
1904                      hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1905                   }
1906                }
1907             }
1908          } else if(!isTruePi0 && !isTrueEta){ // Background
1909             if (fDoMesonQA > 0){
1910                if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
1911                   hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1912                   iMesonMCInfo = 1;
1913                } else { // No photon or without mother
1914                   hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1915                }
1916             }
1917             if( isTruePi0Dalitz || isTrueEtaDalitz ){
1918                // Dalitz
1919                iMesonMCInfo = 5;
1920                hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1921             } else if (gamma0DalitzCand || gamma1DalitzCand){
1922                if (fDoMesonQA > 0)hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1923             }
1924          }
1925       }
1926    }
1927 }
1928 //______________________________________________________________________
1929 void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1930 {
1931
1932    // Process True Mesons
1933    TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1934    Bool_t isTruePi0 = kFALSE;
1935    Bool_t isTrueEta = kFALSE;
1936    Bool_t isTruePi0Dalitz = kFALSE;
1937    Bool_t isTrueEtaDalitz = kFALSE;
1938    Bool_t gamma0DalitzCand = kFALSE;
1939    Bool_t gamma1DalitzCand = kFALSE;
1940
1941    AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
1942    AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
1943
1944    iMesonMCInfo = 0;
1945    Int_t gamma0MCLabel = -1;
1946    Int_t gamma0MotherLabel = -1;
1947    if(!positiveMC||!negativeMC)
1948       return;
1949
1950    if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
1951       gamma0MCLabel = positiveMC->GetMother();
1952    }
1953
1954    if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1955       // Daughters Gamma 0
1956       AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
1957       if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){  // Electrons ...
1958          if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
1959             if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1960                gamma0MotherLabel=gammaMC0->GetMother();
1961             }
1962          }
1963          if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate
1964             gamma0DalitzCand = kTRUE;
1965             gamma0MotherLabel=-111;
1966          }
1967          if(gammaMC0->GetPdgCode() ==221){ // Dalitz candidate
1968             gamma0DalitzCand = kTRUE;
1969             gamma0MotherLabel=-221;
1970          }
1971       }
1972    }
1973    positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelPositive()));
1974    negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelNegative()));
1975
1976    Int_t gamma1MCLabel = -1;
1977    Int_t gamma1MotherLabel = -1;
1978    if(!positiveMC||!negativeMC)
1979       return;
1980
1981    if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
1982       gamma1MCLabel = positiveMC->GetMother();
1983    }
1984    if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1985       // Daughters Gamma 1
1986       AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
1987       if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){  // Electrons ...
1988          if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
1989             if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
1990                gamma1MotherLabel=gammaMC1->GetMother();
1991             }
1992          }
1993          if(gammaMC1->GetPdgCode() ==111 ){ // Dalitz candidate
1994                  gamma1DalitzCand = kTRUE;
1995                  gamma1MotherLabel=-111;
1996          }
1997          if(gammaMC1->GetPdgCode() ==221){ // Dalitz candidate
1998             gamma1DalitzCand = kTRUE;
1999             gamma1MotherLabel=-221;
2000          }
2001       }
2002    }
2003    if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2004       if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2005          isTruePi0=kTRUE;
2006       }
2007       if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2008          isTrueEta=kTRUE;
2009       }
2010    }
2011
2012    //Identify Dalitz candidate
2013    if (gamma1DalitzCand || gamma0DalitzCand){
2014       if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){
2015          if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE;
2016          if (gamma0MotherLabel == -221) isTrueEtaDalitz = kTRUE;
2017       }
2018       if (gamma1DalitzCand && gamma1MCLabel >=0 && gamma1MCLabel==gamma0MotherLabel){
2019          if (gamma1MotherLabel == -111) isTruePi0Dalitz = kTRUE;
2020          if (gamma1MotherLabel == -221) isTrueEtaDalitz = kTRUE;
2021       }
2022    }
2023
2024    if(isTruePi0 || isTrueEta){// True Pion or Eta
2025       hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2026       if (fDoMesonQA > 0){
2027          if (isTruePi0){
2028             hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
2029             hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2030             if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
2031                hESDTruePi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2032                hESDTruePi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2033             } else {
2034                hESDTruePi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2035                hESDTruePi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2036             }
2037          } else if (isTrueEta){
2038             hESDTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
2039             hESDTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2040             if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
2041                hESDTrueEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2042                hESDTrueEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2043             } else {
2044                hESDTrueEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2045                hESDTrueEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2046             }
2047
2048          }
2049       }
2050       if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2051          Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2052          Float_t weightedSec= 1;
2053          if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2054             weightedSec= ((AliConversionCuts*)fCutArray->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
2055             //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
2056          }
2057          hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2058          iMesonMCInfo = 2;
2059          if (secMotherLabel >-1){
2060             if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2061                iMesonMCInfo = 4;
2062                hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2063                if (fDoMesonQA > 0)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
2064                                  ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2065             }
2066             if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221){
2067                iMesonMCInfo = 3;
2068                hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2069                if (fDoMesonQA > 0)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
2070                                  ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2071             }
2072          }
2073       }else{ // Only primary pi0 for efficiency calculation
2074          Float_t weighted= 1;
2075          iMesonMCInfo = 6;
2076          if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2077             if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2078                weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2079                //                      cout << "rec \t " <<gamma1MotherLabel << "\t" <<  weighted << endl;
2080             }
2081          }
2082          hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2083          hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2084          pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2085
2086          if (fDoMesonQA > 0){
2087             if(isTruePi0){ // Only primary pi0 for resolution
2088                hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2089                                                           (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2090
2091             }
2092             if (isTrueEta){ // Only primary eta for resolution
2093                hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2094                                                           (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2095             }
2096          }
2097       }
2098    } else if(!isTruePi0 && !isTrueEta) { // Background
2099       if (fDoMesonQA > 0){
2100          if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2101             hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2102             iMesonMCInfo = 1;
2103          } else { // No photon or without mother
2104             hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2105          }
2106       }
2107       if( isTruePi0Dalitz || isTrueEtaDalitz ){
2108          // Dalitz
2109          iMesonMCInfo = 5;
2110          hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2111       } else if (gamma0DalitzCand || gamma1DalitzCand){
2112          if (fDoMesonQA > 0)hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2113       }
2114    }
2115 }
2116 //________________________________________________________________________
2117 void AliAnalysisTaskGammaConvV1::CalculateBackground(){
2118
2119    Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2120    Int_t mbin = 0;
2121
2122    if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2123       mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2124    } else {
2125       mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2126    }
2127
2128    if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2129
2130       for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2131          AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2132          for(Int_t iCurrent2=iCurrent+1;iCurrent2<fGammaCandidates->GetEntries();iCurrent2++){
2133             for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2134                AliAODConversionPhoton currentEventGoodV02 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent2));
2135
2136                if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGProbability()){
2137                   AliAODConversionMother *backgroundCandidateProb = new AliAODConversionMother(&currentEventGoodV0,&currentEventGoodV02);
2138                   Double_t massBGprob = backgroundCandidateProb->M();
2139                   if(massBGprob>0.1 && massBGprob<0.14){
2140                      if(fRandom.Rndm()>fBGHandler[fiCut]->GetBGProb(zbin,mbin)){
2141                         delete backgroundCandidateProb;
2142                         continue;
2143                      }
2144                   }
2145                   delete backgroundCandidateProb;
2146                   backgroundCandidateProb = 0x0;
2147                }
2148
2149                RotateParticle(&currentEventGoodV02);
2150                AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&currentEventGoodV02);
2151                backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2152                if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2153                    ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2154                   hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2155                   Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2156                   sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2157                }
2158                delete backgroundCandidate;
2159                backgroundCandidate = 0x0;
2160             }
2161          }
2162       }
2163    }else{
2164       AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2165
2166       if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2167          for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2168             AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2169             if(fMoveParticleAccordingToVertex == kTRUE){
2170                bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2171             }
2172
2173             for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2174                AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2175                for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2176                   AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2177                   if(fMoveParticleAccordingToVertex == kTRUE){
2178                      MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2179                   }
2180                   if(fIsHeavyIon){
2181                      RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2182                   }
2183
2184                   AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2185                   backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2186                   if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2187                       ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2188                      hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2189                      Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2190                      sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2191                   }
2192                   delete backgroundCandidate;
2193                   backgroundCandidate = 0x0;
2194                }
2195             }
2196          }
2197       }
2198       else{
2199          for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2200             AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2201             if(previousEventV0s){
2202                if(fMoveParticleAccordingToVertex == kTRUE){
2203                   bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2204                }
2205                for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2206                   AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2207                   for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2208
2209                      AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2210
2211                      if(fMoveParticleAccordingToVertex == kTRUE){
2212                         MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2213                      }
2214                      if(fIsHeavyIon){
2215                         RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2216                      }
2217
2218
2219                      AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2220                      backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2221                      if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2222                          ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2223                         hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2224                         Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2225                         sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2226                      }
2227                      delete backgroundCandidate;
2228                      backgroundCandidate = 0x0;
2229                   }
2230                }
2231             }
2232          }
2233       }
2234    }
2235 }
2236 //________________________________________________________________________
2237 void AliAnalysisTaskGammaConvV1::CalculateBackgroundRP(){
2238
2239    Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2240    Int_t mbin = 0;
2241    if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2242       mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2243    } else {
2244       mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2245    }
2246
2247
2248    //Rotation Method
2249    if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2250       // Correct for the number of rotations
2251       // BG is for rotation the same, except for factor NRotations
2252       Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
2253
2254       for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2255
2256          AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2257          if (gamma0==NULL) continue;
2258          for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
2259             AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
2260             if (gamma1 == NULL) continue;
2261             if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
2262             for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2263
2264                RotateParticle(gamma1);
2265
2266                AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2267                backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2268                if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2269                   ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
2270                   hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2271                   Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2272                   sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2273                }
2274             }
2275          }
2276       }
2277    }
2278    else{
2279       // Do Event Mixing
2280       for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
2281
2282          AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
2283
2284          if(previousEventGammas){
2285             // test weighted background
2286             Double_t weight=1.0;
2287             // Correct for the number of eventmixing:
2288             // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1))  using sum formula sum(i)=N*(N-1)/2  -> N*(N-1)/2
2289             // real combinations (since you cannot combine a photon with its own)
2290             // but BG leads to N_{a}*N_{b} combinations
2291             weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
2292
2293             for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2294
2295                AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2296
2297                for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
2298
2299                   AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
2300
2301                   AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2302                   backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2303                   if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2304                      ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
2305                      hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2306                      Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2307                      sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2308                   }
2309                }
2310             }
2311          }
2312       }
2313    }
2314 }
2315 //________________________________________________________________________
2316 void AliAnalysisTaskGammaConvV1::RotateParticle(AliAODConversionPhoton *gamma){
2317    Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
2318    Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
2319    Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
2320    gamma->RotateZ(rotationValue);
2321 }
2322
2323 //________________________________________________________________________
2324 void AliAnalysisTaskGammaConvV1::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
2325
2326    previousEventEP=previousEventEP+TMath::Pi();
2327    thisEventEP=thisEventEP+TMath::Pi();
2328    Double_t rotationValue= thisEventEP-previousEventEP;
2329    gamma->RotateZ(rotationValue);
2330 }
2331
2332 //________________________________________________________________________
2333 void AliAnalysisTaskGammaConvV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
2334    //see header file for documentation
2335
2336    Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
2337    Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
2338    Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
2339
2340    Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
2341    particle->SetConversionPoint(movedPlace);
2342 }
2343 //________________________________________________________________________
2344 void AliAnalysisTaskGammaConvV1::UpdateEventByEventData(){
2345    //see header file for documentation
2346    if(fGammaCandidates->GetEntries() >0 ){
2347       if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2348          fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
2349       }
2350       else{ // means we use #V0s for multiplicity
2351          fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
2352       }
2353    }
2354 }
2355
2356
2357 //________________________________________________________________________
2358 void AliAnalysisTaskGammaConvV1::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
2359 {
2360    // 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
2361    if(pdgCode[0]==11   && pdgCode[1]==11){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
2362    else if( (pdgCode[0]==11   && pdgCode[1]==211) || (pdgCode[0]==211  && pdgCode[1]==11) )
2363       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
2364    else if( (pdgCode[0]==11   && pdgCode[1]==321) || (pdgCode[0]==321  && pdgCode[1]==11) )
2365       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
2366    else if( (pdgCode[0]==11   && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
2367       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
2368    else if( (pdgCode[0]==11   && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==11) )
2369       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
2370    else if(  pdgCode[0]==211  && pdgCode[1]==211 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
2371    else if( (pdgCode[0]==211  && pdgCode[1]==321) || (pdgCode[0]==321  && pdgCode[1]==211) )
2372       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
2373    else if( (pdgCode[0]==211  && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
2374       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
2375    else if( (pdgCode[0]==211  && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==211) )
2376       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
2377    else if(  pdgCode[0]==321  && pdgCode[1]==321 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
2378    else if( (pdgCode[0]==321  && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
2379       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
2380    else if( (pdgCode[0]==321  && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==321) )
2381       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
2382    else if(  pdgCode[0]==2212   && pdgCode[1]==2212  ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
2383    else if( (pdgCode[0]==2212  && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==2212) )
2384       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
2385    else if(  pdgCode[0]==13   && pdgCode[1]==13  ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
2386    else {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
2387 }
2388 //________________________________________________________________________
2389 void AliAnalysisTaskGammaConvV1::RelabelAODPhotonCandidates(Bool_t mode){
2390
2391    // Relabeling For AOD Event
2392    // ESDiD -> AODiD
2393    // MCLabel -> AODMCLabel
2394
2395    if(mode){
2396       fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
2397       fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
2398       fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
2399       fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
2400    }
2401
2402    for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
2403       AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
2404       if(!PhotonCandidate) continue;
2405       if(!mode){// Back to ESD Labels
2406          PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
2407          PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
2408          PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
2409          PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
2410          continue;
2411       }
2412       fMCStackPos[iGamma] =  PhotonCandidate->GetMCLabelPositive();
2413       fMCStackNeg[iGamma] =  PhotonCandidate->GetMCLabelNegative();
2414       fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
2415       fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
2416
2417       Bool_t AODLabelPos = kFALSE;
2418       Bool_t AODLabelNeg = kFALSE;
2419
2420       for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
2421          AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
2422          if(!AODLabelPos){
2423             if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
2424                PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
2425                PhotonCandidate->SetLabelPositive(i);
2426                AODLabelPos = kTRUE;
2427             }
2428          }
2429          if(!AODLabelNeg){
2430             if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
2431                PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
2432                PhotonCandidate->SetLabelNegative(i);
2433                AODLabelNeg = kTRUE;
2434             }
2435          }
2436          if(AODLabelNeg && AODLabelPos){
2437             break;
2438          }
2439       }
2440       if(!AODLabelPos || !AODLabelNeg){
2441          cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
2442       }
2443    }
2444
2445
2446    if(!mode){
2447       delete[] fMCStackPos;
2448       delete[] fMCStackNeg;
2449       delete[] fESDArrayPos;
2450       delete[] fESDArrayNeg;
2451    }
2452 }
2453 //________________________________________________________________________
2454 void AliAnalysisTaskGammaConvV1::Terminate(const Option_t *)
2455 {
2456
2457    //fOutputContainer->Print(); // Will crash on GRID
2458 }