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",2000,-2,2);
 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.03,25.,150,-1.5,1.5);
 576             SetLogBinningXTH2(hESDMotherPi0PtY[iCut]);
 577             fESDList[iCut]->Add(hESDMotherPi0PtY[iCut]);
 578             hESDMotherEtaPtY[iCut] = new TH2F("ESD_MotherEta_Pt_Y","ESD_MotherEta_Pt_Y",250,0.03,25.,150,-1.5,1.5);
 579             SetLogBinningXTH2(hESDMotherEtaPtY[iCut]);
 580             fESDList[iCut]->Add(hESDMotherEtaPtY[iCut]);
 581             hESDMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",250,0.03,25.,100,0,1);
 582             SetLogBinningXTH2(hESDMotherPi0PtAlpha[iCut]);
 583             fESDList[iCut]->Add(hESDMotherPi0PtAlpha[iCut]);
 584             hESDMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",250,0.03,25.,100,0,1);
 585             SetLogBinningXTH2(hESDMotherEtaPtAlpha[iCut]);
 586             fESDList[iCut]->Add(hESDMotherEtaPtAlpha[iCut]);
 587             hESDMotherPi0YEtaLowPtGamma[iCut] = new TH2F("ESD_MotherPi0_Y_EtaLowPtGamma","ESD_MotherPi0_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
 588             fESDList[iCut]->Add(hESDMotherPi0YEtaLowPtGamma[iCut]);
 589             hESDMotherPi0YEtaHighPtGamma[iCut] = new TH2F("ESD_MotherPi0_Y_EtaHighPtGamma","ESD_MotherPi0_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
 590             fESDList[iCut]->Add(hESDMotherPi0YEtaHighPtGamma[iCut]);
 591             hESDMotherEtaYEtaLowPtGamma[iCut] = new TH2F("ESD_MotherEta_Y_EtaLowPtGamma","ESD_MotherEta_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
 592             fESDList[iCut]->Add(hESDMotherEtaYEtaLowPtGamma[iCut]);
 593             hESDMotherEtaYEtaHighPtGamma[iCut] = new TH2F("ESD_MotherEta_Y_EtaHighPtGamma","ESD_MotherEta_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
 594             fESDList[iCut]->Add(hESDMotherEtaYEtaHighPtGamma[iCut]);
 595          }
 596
 597
 598       }
 599
 600
 601    }
 602    if(fDoMesonAnalysis){
 603       InitBack(); // Init Background Handler
 604    }
 605
 606    if(fIsMC){
 607       // MC Histogramms
 608       fMCList = new TList*[fnCuts];
 609       // True Histogramms
 610       fTrueList = new TList*[fnCuts];
 611       // Selected Header List
 612       fHeaderNameList = new TList*[fnCuts];
 613       hMCHeaders = new TH1I*[fnCuts];
 614       hMCAllGammaPt = new TH1F*[fnCuts];
 615       hMCDecayGammaPi0Pt = new TH1F*[fnCuts];
 616       hMCDecayGammaRhoPt = new TH1F*[fnCuts];
 617       hMCDecayGammaEtaPt = new TH1F*[fnCuts];
 618       hMCDecayGammaOmegaPt = new TH1F*[fnCuts];
 619       hMCDecayGammaEtapPt = new TH1F*[fnCuts];
 620       hMCDecayGammaPhiPt = new TH1F*[fnCuts];
 621       hMCDecayGammaSigmaPt = new TH1F*[fnCuts];
 622       hMCConvGammaPt = new TH1F*[fnCuts];
 623       hESDTrueConvGammaPt = new TH1F*[fnCuts];
 624
 625       hESDCombinatorialPt = new TH2F*[fnCuts];
 626       hESDTruePrimaryConvGammaPt = new TH1F*[fnCuts];
 627       hESDTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
 628       hESDTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
 629       hESDTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
 630       hESDTrueSecondaryConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
 631
 632       hESDTrueDalitzPsiPairDeltaPhi= new TH2F*[fnCuts];
 633       hESDTrueGammaPsiPairDeltaPhi= new TH2F*[fnCuts];
 634
 635       if (fDoPhotonQA > 0){
 636          hMCConvGammaR = new TH1F*[fnCuts];
 637          hMCConvGammaEta = new TH1F*[fnCuts];
 638       }
 639
 640       if(fDoMesonAnalysis){
 641          hMCPi0Pt = new TH1F*[fnCuts];
 642          hMCPi0WOWeightPt = new TH1F*[fnCuts];
 643          hMCEtaPt = new TH1F*[fnCuts];
 644          hMCPi0InAccPt = new TH1F*[fnCuts];
 645          hMCEtaInAccPt = new TH1F*[fnCuts];
 646
 647          hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
 648          hESDTruePrimaryMotherInvMassPt = new TH2F*[fnCuts];
 649          hESDTruePrimaryMotherW0WeightingInvMassPt = new TH2F*[fnCuts];
 650          pESDTruePrimaryMotherWeightsInvMassPt = new TProfile2D*[fnCuts];
 651          hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
 652          hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
 653          hESDTrueSecondaryMotherFromEtaInvMassPt = new TH2F*[fnCuts];
 654          hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
 655          if (fDoMesonQA > 0){
 656             hMCPi0PtY = new TH2F*[fnCuts];
 657             hMCEtaPtY = new TH2F*[fnCuts];
 658             hMCK0sPt = new TH1F*[fnCuts];
 659             hMCK0sWOWeightPt = new TH1F*[fnCuts];
 660             hMCK0sPtY = new TH2F*[fnCuts];
 661             hESDTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
 662             hESDTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
 663             hESDTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
 664             hESDTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
 665             hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
 666             hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
 667             hESDTruePi0PtY = new TH2F*[fnCuts];
 668             hESDTrueEtaPtY = new TH2F*[fnCuts];
 669             hESDTruePi0PtAlpha = new TH2F*[fnCuts];
 670             hESDTrueEtaPtAlpha = new TH2F*[fnCuts];
 671             hESDTruePi0YEtaLowPtGamma = new TH2F*[fnCuts];
 672             hESDTruePi0YEtaHighPtGamma = new TH2F*[fnCuts];
 673             hESDTrueEtaYEtaLowPtGamma = new TH2F*[fnCuts];
 674             hESDTrueEtaYEtaHighPtGamma = new TH2F*[fnCuts];
 675          }
 676       }
 677
 678       for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 679          TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
 680          TString cutstringMeson = "NoMesonCut";
 681          if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
 682
 683          fMCList[iCut] = new TList();
 684          fMCList[iCut]->SetName(Form("%s_%s MC histograms",cutstring.Data(),cutstringMeson.Data()));
 685          fMCList[iCut]->SetOwner(kTRUE);
 686          fCutFolder[iCut]->Add(fMCList[iCut]);
 687          hMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
 688          fMCList[iCut]->Add(hMCHeaders[iCut]);
 689          hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
 690          fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
 691          hMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
 692          fMCList[iCut]->Add(hMCDecayGammaPi0Pt[iCut]);
 693          hMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
 694          fMCList[iCut]->Add(hMCDecayGammaRhoPt[iCut]);
 695          hMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
 696          fMCList[iCut]->Add(hMCDecayGammaEtaPt[iCut]);
 697          hMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
 698          fMCList[iCut]->Add(hMCDecayGammaOmegaPt[iCut]);
 699          hMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
 700          fMCList[iCut]->Add(hMCDecayGammaEtapPt[iCut]);
 701          hMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
 702          fMCList[iCut]->Add(hMCDecayGammaPhiPt[iCut]);
 703          hMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
 704          fMCList[iCut]->Add(hMCDecayGammaSigmaPt[iCut]);
 705          hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
 706          fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
 707
 708          if (fDoPhotonQA > 0){
 709             hMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
 710             fMCList[iCut]->Add(hMCConvGammaR[iCut]);
 711             hMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",100,-4,4);
 712             fMCList[iCut]->Add(hMCConvGammaEta[iCut]);
 713          }
 714
 715          if(fDoMesonAnalysis){
 716             hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
 717             hMCPi0Pt[iCut]->Sumw2();
 718             fMCList[iCut]->Add(hMCPi0Pt[iCut]);
 719             hMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
 720             hMCPi0WOWeightPt[iCut]->Sumw2();
 721             fMCList[iCut]->Add(hMCPi0WOWeightPt[iCut]);
 722
 723             hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
 724             hMCEtaPt[iCut]->Sumw2();
 725             fMCList[iCut]->Add(hMCEtaPt[iCut]);
 726             hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
 727             hMCPi0InAccPt[iCut]->Sumw2();
 728             fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
 729             hMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
 730             hMCEtaInAccPt[iCut]->Sumw2();
 731             fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
 732             if (fDoMesonQA > 0){
 733                hMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",250,0.03,25.,150,-1.5,1.5);
 734                hMCPi0PtY[iCut]->Sumw2();
 735                SetLogBinningXTH2(hMCPi0PtY[iCut]);
 736                fMCList[iCut]->Add(hMCPi0PtY[iCut]);
 737                hMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",250,0.03,25.,150,-1.5,1.5);
 738                hMCEtaPtY[iCut]->Sumw2();
 739                SetLogBinningXTH2(hMCEtaPtY[iCut]);
 740                fMCList[iCut]->Add(hMCEtaPtY[iCut]);
 741                hMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",250,0,25);
 742                hMCK0sPt[iCut]->Sumw2();
 743                fMCList[iCut]->Add(hMCK0sPt[iCut]);
 744                hMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",250,0,25);
 745                hMCK0sWOWeightPt[iCut]->Sumw2();
 746                fMCList[iCut]->Add(hMCK0sWOWeightPt[iCut]);
 747                hMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",250,0.03,25.,150,-1.5,1.5);
 748                hMCK0sPtY[iCut]->Sumw2();
 749                SetLogBinningXTH2(hMCK0sPtY[iCut]);
 750                fMCList[iCut]->Add(hMCK0sPtY[iCut]);
 751
 752             }
 753
 754          }
 755          fTrueList[iCut] = new TList();
 756          fTrueList[iCut]->SetName(Form("%s_%s True histograms",cutstring.Data(),cutstringMeson.Data()));
 757          fTrueList[iCut]->SetOwner(kTRUE);
 758          fCutFolder[iCut]->Add(fTrueList[iCut]);
 759
 760          hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
 761          fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
 762
 763          hESDCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
 764          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
 765          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
 766          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
 767          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
 768          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
 769          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
 770          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
 771          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
 772          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
 773          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
 774          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
 775          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
 776          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
 777          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
 778          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
 779          hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
 780          fTrueList[iCut]->Add(hESDCombinatorialPt[iCut]);
 781          hESDTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
 782          fTrueList[iCut]->Add(hESDTruePrimaryConvGammaPt[iCut]);
 783          hESDTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
 784          fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaPt[iCut]);
 785
 786          hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]
 787             = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
 788          fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
 789          hESDTrueSecondaryConvGammaFromXFromLambdaPt[iCut]
 790             = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
 791          fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
 792
 793          hESDTrueDalitzPsiPairDeltaPhi[iCut]
 794             = new TH2F("ESD_TrueDalitzPsiPairDeltaPhi_Pt", "ESD_TrueDalitzPsiPairDeltaPhi_Pt",400,-2,2,400,-2,2);
 795          fTrueList[iCut]->Add(hESDTrueDalitzPsiPairDeltaPhi[iCut]);
 796
 797          hESDTrueGammaPsiPairDeltaPhi[iCut]
 798             = new TH2F("ESD_TrueGammaPsiPairDeltaPhi_Pt", "ESD_TrueGammaPsiPairDeltaPhi_Pt",200,-2,2,400,-2,2);
 799          fTrueList[iCut]->Add(hESDTrueGammaPsiPairDeltaPhi[iCut]);
 800
 801
 802          hESDTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
 803          fTrueList[iCut]->Add(hESDTruePrimaryConvGammaESDPtMCPt[iCut]);
 804
 805          if(fDoMesonAnalysis){
 806             hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
 807             fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
 808             hESDTruePrimaryMotherInvMassPt[iCut]
 809                = new TH2F("ESD_TruePrimaryMother_InvMass_Pt", "ESD_TruePrimaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
 810             hESDTruePrimaryMotherInvMassPt[iCut]->Sumw2();
 811             fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassPt[iCut]);
 812             hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]
 813                = new TH2F("ESD_TruePrimaryMotherW0Weights_InvMass_Pt", "ESD_TruePrimaryMotherW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
 814             hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]->Sumw2();
 815             fTrueList[iCut]->Add(hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]);
 816             pESDTruePrimaryMotherWeightsInvMassPt[iCut]
 817                = new TProfile2D("ESD_TruePrimaryMotherWeights_InvMass_Pt", "ESD_TruePrimaryMotherWeights_InvMass_Pt", 800,0,0.8,250,0,25);
 818             pESDTruePrimaryMotherWeightsInvMassPt[iCut]->Sumw2();
 819             fTrueList[iCut]->Add(pESDTruePrimaryMotherWeightsInvMassPt[iCut]);
 820             hESDTrueSecondaryMotherInvMassPt[iCut]
 821                = new TH2F("ESD_TrueSecondaryMother_InvMass_Pt", "ESD_TrueSecondaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
 822             hESDTrueSecondaryMotherInvMassPt[iCut]->Sumw2();
 823             fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
 824             hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]
 825                = new TH2F("ESD_TrueSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueSecondaryMotherFromK0s_InvMass_Pt",800,0,0.8,250,0,25);
 826             hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]->Sumw2();
 827             fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
 828             hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]
 829                = new TH2F("ESD_TrueSecondaryMotherFromEta_InvMass_Pt","ESD_TrueSecondaryMotherFromEta_InvMass_Pt",800,0,0.8,250,0,25);
 830             fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]);
 831             hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueDalitz_InvMass_Pt","ESD_TrueDalitz_InvMass_Pt",800,0,0.8,250,0,25);
 832             fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
 833             if (fDoMesonQA > 0){
 834                hESDTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
 835                hESDTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
 836                SetLogBinningXTH2(hESDTruePrimaryPi0MCPtResolPt[iCut]);
 837                fTrueList[iCut]->Add(hESDTruePrimaryPi0MCPtResolPt[iCut]);
 838                hESDTruePrimaryEtaMCPtResolPt[iCut]  = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
 839                hESDTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
 840                SetLogBinningXTH2(hESDTruePrimaryEtaMCPtResolPt[iCut]);
 841                fTrueList[iCut]->Add(hESDTruePrimaryEtaMCPtResolPt[iCut]);
 842                hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
 843                fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
 844                hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
 845                fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
 846                hESDTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
 847                fTrueList[iCut]->Add(hESDTrueK0sWithPi0DaughterMCPt[iCut]);
 848                hESDTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
 849                fTrueList[iCut]->Add(hESDTrueEtaWithPi0DaughterMCPt[iCut]);
 850                hESDTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",250,0.03,25.,150,-1.5,1.5);
 851                SetLogBinningXTH2(hESDTruePi0PtY[iCut]);
 852                fTrueList[iCut]->Add(hESDTruePi0PtY[iCut]);
 853                hESDTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",250,0.03,25.,150,-1.5,1.5);
 854                SetLogBinningXTH2(hESDTrueEtaPtY[iCut]);
 855                fTrueList[iCut]->Add(hESDTrueEtaPtY[iCut]);
 856                hESDTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",250,0.03,25.,100,0,1);
 857                SetLogBinningXTH2(hESDTruePi0PtAlpha[iCut]);
 858                fTrueList[iCut]->Add(hESDTruePi0PtAlpha[iCut]);
 859                hESDTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",250,0.03,25.,100,0,1);
 860                SetLogBinningXTH2(hESDTrueEtaPtAlpha[iCut]);
 861                fTrueList[iCut]->Add(hESDTrueEtaPtAlpha[iCut]);
 862
 863                hESDTruePi0YEtaLowPtGamma[iCut] = new TH2F("ESD_TruePi0_Y_EtaLowPtGamma","ESD_TruePi0_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
 864                fTrueList[iCut]->Add(hESDTruePi0YEtaLowPtGamma[iCut]);
 865                hESDTruePi0YEtaHighPtGamma[iCut] = new TH2F("ESD_TruePi0_Y_EtaHighPtGamma","ESD_TruePi0_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
 866                fTrueList[iCut]->Add(hESDTruePi0YEtaHighPtGamma[iCut]);
 867                hESDTrueEtaYEtaLowPtGamma[iCut] = new TH2F("ESD_TrueEta_Y_EtaLowPtGamma","ESD_TrueEta_Y_EtaLowPtGamma",150,-1.5,1.5,200,-2,2);
 868                fTrueList[iCut]->Add(hESDTrueEtaYEtaLowPtGamma[iCut]);
 869                hESDTrueEtaYEtaHighPtGamma[iCut] = new TH2F("ESD_TrueEta_Y_EtaHighPtGamma","ESD_TrueEta_Y_EtaHighPtGamma",150,-1.5,1.5,200,-2,2);
 870                fTrueList[iCut]->Add(hESDTrueEtaYEtaHighPtGamma[iCut]);
 871             }
 872          }
 873       }
 874    }
 875
 876    fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
 877    if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
 878
 879    if(fV0Reader)
 880       if((AliConversionCuts*)fV0Reader->GetConversionCuts())
 881          if(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
 882             fOutputContainer->Add(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
 883
 884    for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 885       if(!((AliConversionCuts*)fCutArray->At(iCut))) continue;
 886       if(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms()){
 887          fCutFolder[iCut]->Add(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms());
 888       }
 889       if(fDoMesonAnalysis){
 890          if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
 891          if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
 892             fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
 893          }
 894       }
 895    }
 896    PostData(1, fOutputContainer);
 897 }
 898 //_____________________________________________________________________________
 899 Bool_t AliAnalysisTaskGammaConvV1::Notify()
 900 {
 901    for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 902       if(!((AliConversionCuts*)fCutArray->At(iCut))->GetDoEtaShift()){
 903          hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
 904          continue; // No Eta Shift requested, continue
 905       }
 906       if(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
 907          ((AliConversionCuts*)fCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
 908           hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
 909          ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
 910          continue;
 911       }
 912       else{
 913          printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
 914                 (((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift());
 915           hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
 916          ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
 917       }
 918    }
 919
 920    return kTRUE;
 921 }
 922 //_____________________________________________________________________________
 923 void AliAnalysisTaskGammaConvV1::UserExec(Option_t *)
 924 {
 925    //
 926    // Called for each event
 927    //
 928    Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
 929    if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
 930       for(Int_t iCut = 0; iCut<fnCuts; iCut++){
 931          hNEvents[iCut]->Fill(eventQuality);
 932       }
 933       return;
 934    }
 935
 936    if(fIsMC) fMCEvent = MCEvent();
 937    if(fMCEvent == NULL) fIsMC = kFALSE;
 938
 939    fInputEvent = InputEvent();
 940
 941    if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
 942       fMCStack = fMCEvent->Stack();
 943       if(fMCStack == NULL) fIsMC = kFALSE;
 944    }
 945
 946    fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
 947
 948    // ------------------- BeginEvent ----------------------------
 949
 950    AliEventplane *EventPlane = fInputEvent->GetEventplane();
 951    if(fIsHeavyIon)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
 952    else fEventPlaneAngle=0.0;
 953
 954    if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
 955       RelabelAODPhotonCandidates(kTRUE);    // In case of AODMC relabeling MC
 956       fV0Reader->RelabelAODs(kTRUE);
 957    }
 958    for(Int_t iCut = 0; iCut<fnCuts; iCut++){
 959       fiCut = iCut;
 960       Int_t eventNotAccepted =
 961          ((AliConversionCuts*)fCutArray->At(iCut))
 962          ->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
 963       if(eventNotAccepted){
 964          // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
 965          hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
 966          continue;
 967       }
 968
 969       if(eventQuality != 0){// Event Not Accepted
 970          // cout << "event rejected due to: " <<eventQuality << endl;
 971          hNEvents[iCut]->Fill(eventQuality);
 972          continue;
 973       }
 974
 975       hNEvents[iCut]->Fill(eventQuality); // Should be 0 here
 976       hNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
 977       if(((AliConversionCuts*)fCutArray->At(iCut))->IsHeavyIon() == 2)  hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
 978       else hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
 979
 980       if(fIsMC){
 981          // Process MC Particle
 982          if(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection() != 0){
 983             if(fInputEvent->IsA()==AliESDEvent::Class()){
 984                ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
 985                                                                                   ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
 986                                                                                   fMCEvent);
 987             }
 988             else if(fInputEvent->IsA()==AliAODEvent::Class()){
 989                ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
 990                                                                                   ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
 991                                                                                   fInputEvent);
 992             }
 993
 994             if(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader()){
 995                for(Int_t i = 0;i<(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
 996                   TString nameBin= hMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
 997                   if (nameBin.CompareTo("")== 0){
 998                      TString nameHeader = ((TObjString*)((TList*)((AliConversionCuts*)fCutArray->At(iCut))
 999                                                          ->GetAcceptedHeader())->At(i))->GetString();
1000                      hMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
1001                   }
1002                }
1003             }
1004          }
1005       }
1006       if(fIsMC){
1007          if(fInputEvent->IsA()==AliESDEvent::Class())
1008             ProcessMCParticles();
1009          if(fInputEvent->IsA()==AliAODEvent::Class())
1010             ProcessAODMCParticles();
1011       }
1012
1013       ProcessPhotonCandidates(); // Process this cuts gammas
1014
1015       hNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
1016       if(fDoMesonAnalysis){ // Meson Analysis
1017          if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1018             fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
1019             fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
1020             fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
1021             fUnsmearedE =  new Double_t[fGammaCandidates->GetEntries()];
1022
1023             for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1024                fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
1025                fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
1026                fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
1027                fUnsmearedE[gamma] =  ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
1028                ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
1029             }
1030          }
1031
1032          CalculatePi0Candidates(); // Combine Gammas
1033          if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1034             if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1035                CalculateBackground(); // Combinatorial Background
1036                UpdateEventByEventData(); // Store Event for mixed Events
1037             }
1038             else{
1039                CalculateBackgroundRP(); // Combinatorial Background
1040                fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
1041             }
1042          }
1043          if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1044             for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1045                ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1046                ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1047                ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1048                ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
1049             }
1050             delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1051             delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1052             delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1053             delete[] fUnsmearedE;  fUnsmearedE  = 0x0;
1054          }
1055       }
1056       fGammaCandidates->Clear(); // delete this cuts good gammas
1057    }
1058
1059    if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1060       RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
1061       fV0Reader->RelabelAODs(kFALSE);
1062    }
1063
1064    PostData(1, fOutputContainer);
1065 }
1066 //________________________________________________________________________
1067 void AliAnalysisTaskGammaConvV1::ProcessPhotonCandidates()
1068 {
1069    Int_t nV0 = 0;
1070    TList *GammaCandidatesStepOne = new TList();
1071    TList *GammaCandidatesStepTwo = new TList();
1072    // Loop over Photon Candidates allocated by ReaderV1
1073    for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1074       AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1075       if(!PhotonCandidate) continue;
1076       fIsFromMBHeader = kTRUE;
1077       if(fIsMC && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1078          Int_t isPosFromMBHeader
1079             = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1080          if(isPosFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1081          Int_t isNegFromMBHeader
1082             = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1083          if(isNegFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1084
1085          if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1086       }
1087
1088       if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
1089       if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(PhotonCandidate->GetPhotonPhi(),fEventPlaneAngle)) continue;
1090       if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1091          !((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1092          fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1093
1094          if(fIsFromMBHeader){
1095             hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1096             if (fDoPhotonQA > 0){
1097                hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1098                hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1099             }
1100          }
1101          if(fIsMC){
1102             if(fInputEvent->IsA()==AliESDEvent::Class())
1103                ProcessTruePhotonCandidates(PhotonCandidate);
1104             if(fInputEvent->IsA()==AliAODEvent::Class())
1105                ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1106          }
1107          if (fIsFromMBHeader && fDoPhotonQA == 2){
1108             if (fIsHeavyIon && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1109                fPtGamma = PhotonCandidate->Pt();
1110                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1111                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1112                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1113                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1114                tESDConvGammaPtDcazCat[fiCut]->Fill();
1115             } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1116                fPtGamma = PhotonCandidate->Pt();
1117                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1118                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1119                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1120                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1121                tESDConvGammaPtDcazCat[fiCut]->Fill();
1122             }
1123          }
1124       } else if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1125          ((AliConversionCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1126          nV0++;
1127          GammaCandidatesStepOne->Add(PhotonCandidate);
1128       } else if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1129               ((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1130          GammaCandidatesStepTwo->Add(PhotonCandidate);
1131       }
1132    }
1133    if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
1134       for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1135          AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1136          if(!PhotonCandidate) continue;
1137          fIsFromMBHeader = kTRUE;
1138          if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1139             Int_t isPosFromMBHeader
1140                = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1141             Int_t isNegFromMBHeader
1142                = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1143             if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1144          }
1145          if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1146          if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1147             fGammaCandidates->Add(PhotonCandidate);
1148             if(fIsFromMBHeader){
1149                hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1150                if (fDoPhotonQA > 0){
1151                   hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1152                   hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1153                }
1154             }
1155          }
1156          if(fIsMC){
1157             if(fInputEvent->IsA()==AliESDEvent::Class())
1158                ProcessTruePhotonCandidates(PhotonCandidate);
1159             if(fInputEvent->IsA()==AliAODEvent::Class())
1160                ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1161          } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1162
1163            if (fIsFromMBHeader && fDoPhotonQA == 2){
1164             if (fIsHeavyIon && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1165                fPtGamma = PhotonCandidate->Pt();
1166                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1167                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1168                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1169                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1170                tESDConvGammaPtDcazCat[fiCut]->Fill();
1171             } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1172                fPtGamma = PhotonCandidate->Pt();
1173                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1174                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1175                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1176                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1177                tESDConvGammaPtDcazCat[fiCut]->Fill();
1178             }
1179          }
1180       }
1181    }
1182    if(((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1183       for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1184          AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1185          if(!PhotonCandidate) continue;
1186          fIsFromMBHeader = kTRUE;
1187          if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1188             Int_t isPosFromMBHeader
1189                = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1190             Int_t isNegFromMBHeader
1191                = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1192             if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1193          }
1194          if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
1195          fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1196          if(fIsFromMBHeader){
1197             hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1198             if (fDoPhotonQA > 0){
1199                hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1200                hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1201             }
1202          }
1203          if(fIsMC){
1204             if(fInputEvent->IsA()==AliESDEvent::Class())
1205                ProcessTruePhotonCandidates(PhotonCandidate);
1206             if(fInputEvent->IsA()==AliAODEvent::Class())
1207                ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1208          }
1209          if (fIsFromMBHeader){
1210            if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1211                fPtGamma = PhotonCandidate->Pt();
1212                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1213                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1214                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1215                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1216                tESDConvGammaPtDcazCat[fiCut]->Fill();
1217             } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1218                fPtGamma = PhotonCandidate->Pt();
1219                fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1220                fRConvPhoton = PhotonCandidate->GetConversionRadius();
1221                fEtaPhoton = PhotonCandidate->GetPhotonEta();
1222                iCatPhoton = PhotonCandidate->GetPhotonQuality();
1223                tESDConvGammaPtDcazCat[fiCut]->Fill();
1224             }
1225          }
1226       }
1227    }
1228
1229    delete GammaCandidatesStepOne;
1230    GammaCandidatesStepOne = 0x0;
1231    delete GammaCandidatesStepTwo;
1232    GammaCandidatesStepTwo = 0x0;
1233
1234 }
1235 //________________________________________________________________________
1236 void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1237 {
1238
1239    Double_t magField = fInputEvent->GetMagneticField();
1240    if( magField  < 0.0 ){
1241       magField =  1.0;
1242    }
1243    else {
1244       magField =  -1.0;
1245    }
1246
1247    TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1248    AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1249    AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
1250    iPhotonMCInfo = 0;
1251
1252    if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1253    Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1254
1255    if(posDaughter->GetMother() != negDaughter->GetMother()){
1256       FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1257       iPhotonMCInfo = 1;
1258       return;
1259    }
1260    else if(posDaughter->GetMother() == -1){
1261       FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1262       iPhotonMCInfo = 1;
1263       return;
1264    }
1265
1266    if(pdgCode[0]!=11 || pdgCode[1]!=11){
1267       iPhotonMCInfo = 1;
1268       return; //One Particle is not a electron
1269    }
1270    if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
1271       iPhotonMCInfo = 1;
1272       return; // Same Charge
1273    }
1274
1275    AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
1276    AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1277    AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1278    Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1279
1280    if(Photon->GetPdgCode() != 22){
1281       hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1282       iPhotonMCInfo = 1;
1283       return; // Mother is no Photon
1284    }
1285
1286    if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
1287       iPhotonMCInfo = 1;
1288       return;// check if the daughters come from a conversion
1289    }
1290    // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1291
1292
1293
1294    // True Photon
1295    if(fIsFromMBHeader)hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1296    hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1297    if(Photon->IsPrimary()){
1298       // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1299       if(fIsFromMBHeader){
1300          iPhotonMCInfo = 6;
1301          hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1302          hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1303       }
1304       // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1305    }
1306    else{
1307       if(fIsFromMBHeader){
1308          hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1309          iPhotonMCInfo = 2;
1310          if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1311             ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1312             iPhotonMCInfo = 5;
1313             hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1314          }
1315          if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1316             ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1317             iPhotonMCInfo = 4;
1318             hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1319          }
1320          if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1321             ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1322             iPhotonMCInfo = 3;
1323          }
1324       }
1325    }
1326
1327 }
1328 //________________________________________________________________________
1329 void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1330 {
1331
1332   Double_t magField = fInputEvent->GetMagneticField();
1333    if( magField  < 0.0 ){
1334       magField =  1.0;
1335    }
1336    else {
1337       magField =  -1.0;
1338    }
1339
1340    // Process True Photons
1341    TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1342    TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
1343
1344    iPhotonMCInfo = 0;
1345
1346    if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1347    Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1348    iPhotonMCInfo = 1;
1349    if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
1350       FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1351       return;
1352    }
1353    else if(posDaughter->GetMother(0) == -1){
1354       FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1355       return;
1356    }
1357
1358    if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1359
1360    if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1361
1362    TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
1363    AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1364    AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1365    Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1366
1367    if(Photon->GetPdgCode() != 22){
1368       hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1369       return; // Mother is no Photon
1370    }
1371
1372    if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1373
1374
1375
1376    // True Photon
1377    if(fIsFromMBHeader){
1378       hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1379    }
1380    hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1381    if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
1382       // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1383       if(fIsFromMBHeader){
1384          iPhotonMCInfo = 6;
1385          hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1386          hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1387
1388       }
1389       // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1390    }
1391    else{
1392       if(fIsFromMBHeader){
1393          iPhotonMCInfo = 2;
1394          hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1395          if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1396             fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
1397             hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1398             iPhotonMCInfo = 5;
1399          }
1400          if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1401             fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
1402             hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1403             iPhotonMCInfo = 4;
1404          }
1405          if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1406             fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
1407             iPhotonMCInfo = 3;
1408          }
1409       }
1410    }
1411 }
1412 //________________________________________________________________________
1413 void AliAnalysisTaskGammaConvV1::ProcessAODMCParticles()
1414 {
1415
1416    TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1417
1418    // Loop over all primary MC particle
1419    for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
1420
1421       AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
1422       if (!particle) continue;
1423       if (!particle->IsPrimary()) continue;
1424
1425       Int_t isMCFromMBHeader = -1;
1426       if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1427          isMCFromMBHeader
1428             = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1429          if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1430       }
1431
1432       if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
1433       if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
1434          hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1435          if(particle->GetMother() >-1){ // Meson Decay Gamma
1436             switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
1437             case 111: // Pi0
1438                hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1439                break;
1440             case 113: // Rho0
1441                hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1442                break;
1443             case 221: // Eta
1444                hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1445                break;
1446             case 223: // Omega
1447                hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1448                break;
1449             case 331: // Eta'
1450                hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1451                break;
1452             case 333: // Phi
1453                hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1454                break;
1455             case 3212: // Sigma
1456                hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1457                break;
1458             }
1459          }
1460       }
1461       if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
1462          Double_t rConv = 0;
1463          for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
1464             AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
1465             if(!tmpDaughter) continue;
1466             if(abs(tmpDaughter->GetPdgCode()) == 11){
1467                rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
1468             }
1469          }
1470          hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1471          if (fDoPhotonQA > 0){
1472             hMCConvGammaR[fiCut]->Fill(rConv);
1473             hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1474          }
1475       }
1476       // Converted MC Gamma
1477       if(fDoMesonAnalysis){
1478          if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1479             Double_t mesonY = 10.;
1480             if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1481                mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1482             } else{
1483                mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1484                   -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1485             }
1486             Float_t weightedK0s= 1;
1487             if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1488                if (particle->Pt()>0.005){
1489                   weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1490                   //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
1491                }
1492             }
1493             hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1494             hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1495             hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1496          }
1497          if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1498             ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1499             AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
1500             AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
1501             Float_t weighted= 1;
1502             if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1503                if (particle->Pt()>0.005){
1504                   weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1505                   //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
1506                }
1507             }
1508             Double_t mesonY = 10.;
1509             if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1510                mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1511             } else{
1512                mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1513                   -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1514             }
1515
1516             if(particle->GetPdgCode() == 111){
1517                hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1518                hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1519                if (fDoMesonQA > 0) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1520             } else if(particle->GetPdgCode() == 221){
1521                hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1522                if (fDoMesonQA > 0) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1523             }
1524
1525             // Check the acceptance for both gammas
1526             if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
1527                ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE)  &&
1528                ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
1529                ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
1530
1531                if(particle->GetPdgCode() == 111){
1532                   hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1533                } else if(particle->GetPdgCode() == 221){
1534                   hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1535                }
1536             }
1537          }
1538       }
1539    }
1540 }
1541 //________________________________________________________________________
1542 void AliAnalysisTaskGammaConvV1::ProcessMCParticles()
1543 {
1544    // Loop over all primary MC particle
1545    for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
1546       TParticle* particle = (TParticle *)fMCStack->Particle(i);
1547       if (!particle) continue;
1548
1549       Int_t isMCFromMBHeader = -1;
1550       if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1551          isMCFromMBHeader
1552             = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1553          if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1554       }
1555
1556       if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
1557       if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
1558          hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1559          if(particle->GetMother(0) >-1){ // Meson Decay Gamma
1560             switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
1561             case 111: // Pi0
1562                hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1563                break;
1564             case 113: // Rho0
1565                hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1566                break;
1567             case 221: // Eta
1568                hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1569                break;
1570             case 223: // Omega
1571                hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1572                break;
1573             case 331: // Eta'
1574                hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1575                break;
1576             case 333: // Phi
1577                hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1578                break;
1579             case 3212: // Sigma
1580                hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1581                break;
1582             }
1583          }
1584       }
1585       if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
1586          hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1587          if (fDoPhotonQA > 0){
1588             hMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
1589             hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1590          }
1591       } // Converted MC Gamma
1592       if(fDoMesonAnalysis){
1593          if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1594             Double_t mesonY = 10.;
1595             if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1596                mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1597             } else{
1598                mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1599                   -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1600             }
1601             Float_t weightedK0s= 1;
1602             if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1603                if (particle->Pt()>0.005){
1604                   weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1605                   //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
1606                }
1607             }
1608             hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1609             hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1610             hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1611          }
1612          if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1613             ->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1614             TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
1615             TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
1616
1617             Float_t weighted= 1;
1618             if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1619                if (particle->Pt()>0.005){
1620                   weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1621                   //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
1622                }
1623             }
1624             Double_t mesonY = 10.;
1625             if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1626                mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1627             } else{
1628                mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1629                   -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1630             }
1631
1632             if(particle->GetPdgCode() == 111){
1633                hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1634                hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1635                if (fDoMesonQA > 0) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1636             } else if(particle->GetPdgCode() == 221){
1637                hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1638                if (fDoMesonQA > 0) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1639             }
1640
1641             // Check the acceptance for both gammas
1642             if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
1643                ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE)  &&
1644                ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
1645                ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
1646
1647                if(particle->GetPdgCode() == 111){
1648                   hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1649                } else if(particle->GetPdgCode() == 221){
1650                   hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1651                }
1652             }
1653          }
1654       }
1655    }
1656 }
1657 //________________________________________________________________________
1658 void AliAnalysisTaskGammaConvV1::CalculatePi0Candidates(){
1659
1660    // Conversion Gammas
1661    if(fGammaCandidates->GetEntries()>1){
1662       for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
1663          AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
1664          if (gamma0==NULL) continue;
1665          for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
1666             AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
1667             //Check for same Electron ID
1668             if (gamma1==NULL) continue;
1669             if(gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelPositive() ||
1670                gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelNegative() ||
1671                gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelPositive() ||
1672                gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelNegative() ) continue;
1673
1674             AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
1675             pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
1676
1677             pi0cand->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
1678             if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1679                 ->MesonIsSelected(pi0cand,kTRUE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
1680                hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1681                if(pi0cand->GetAlpha()<0.1)
1682                   hESDMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
1683
1684                if (fDoMesonQA > 0){
1685                   if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
1686                      hESDMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1687                      hESDMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1688                      if (gamma0->Pt() < gamma1->Pt()){
1689                        hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1690                        hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1691                      } else {
1692                        hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1693                        hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1694                      }
1695                   }
1696                   if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
1697                      hESDMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1698                      hESDMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1699                      if (gamma0->Pt() < gamma1->Pt()){
1700                        hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1701                        hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1702                      } else {
1703                        hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma1->Eta());
1704                        hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),gamma0->Eta());
1705                      }
1706                   }
1707                }
1708                if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
1709                   Int_t zbin = 0;
1710                   Int_t mbin = 0;
1711
1712                   if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
1713                      zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1714                      if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1715                         mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1716                      } else {
1717                         mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1718                      }
1719                   }
1720                   else{
1721                      zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1722                      if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1723                         mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1724                      } else {
1725                         mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1726                      }
1727                   }
1728                   Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1729                   sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1730                }
1731
1732
1733                if(fIsMC){
1734                   if(fInputEvent->IsA()==AliESDEvent::Class())
1735                      ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1);
1736                   if(fInputEvent->IsA()==AliAODEvent::Class())
1737                      ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1);
1738                }
1739                if (fDoMesonQA == 2){
1740                   fInvMass = pi0cand->M();
1741                   fPt  = pi0cand->Pt();
1742                   if (abs(gamma0->GetDCAzToPrimVtx()) < abs(gamma1->GetDCAzToPrimVtx())){
1743                      fDCAzGammaMin = gamma0->GetDCAzToPrimVtx();
1744                      fDCAzGammaMax = gamma1->GetDCAzToPrimVtx();
1745                   } else {
1746                      fDCAzGammaMin = gamma1->GetDCAzToPrimVtx();
1747                      fDCAzGammaMax = gamma0->GetDCAzToPrimVtx();
1748                   }
1749                   iFlag = pi0cand->GetMesonQuality();
1750 //                   cout << "gamma 0: " << gamma0->GetV0Index()<< "\t" << gamma0->GetPx() << "\t" << gamma0->GetPy() << "\t" <<  gamma0->GetPz() << "\t" << endl;
1751 //                   cout << "gamma 1: " << gamma1->GetV0Index()<< "\t"<< gamma1->GetPx() << "\t" << gamma1->GetPy() << "\t" <<  gamma1->GetPz() << "\t" << endl;
1752 //                    cout << "pi0: "<<fInvMass << "\t" << fPt <<"\t" << fDCAzGammaMin << "\t" << fDCAzGammaMax << "\t" << (Int_t)iFlag << "\t" << (Int_t)iMesonMCInfo <<endl;
1753                   if (fIsHeavyIon == 1 && fPt > 0.399 && fPt < 20. ) {
1754                      if (fInvMass > 0.08 && fInvMass < 0.2) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1755                      if ((fInvMass > 0.45 && fInvMass < 0.6) &&  (fPt > 0.999 && fPt < 20.) )tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1756                   } else if (fPt > 0.299 && fPt < 20. )  {
1757                      if ( (fInvMass > 0.08 && fInvMass < 0.2) || (fInvMass > 0.45 && fInvMass < 0.6)) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1758                   }
1759                }
1760             }
1761             delete pi0cand;
1762             pi0cand=0x0;
1763          }
1764       }
1765    }
1766 }
1767 //______________________________________________________________________
1768 void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1769 {
1770    // Process True Mesons
1771    AliStack *MCStack = fMCEvent->Stack();
1772    iMesonMCInfo = 0;
1773    if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
1774       Bool_t isTruePi0 = kFALSE;
1775       Bool_t isTrueEta = kFALSE;
1776       Bool_t isTruePi0Dalitz = kFALSE;
1777       Bool_t isTrueEtaDalitz = kFALSE;
1778       Bool_t gamma0DalitzCand = kFALSE;
1779       Bool_t gamma1DalitzCand = kFALSE;
1780       Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
1781       Int_t gamma0MotherLabel = -1;
1782       if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1783          // Daughters Gamma 0
1784          TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
1785          TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
1786          TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
1787          if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){  // Electrons ...
1788             if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1789                if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1790                   gamma0MotherLabel=gammaMC0->GetFirstMother();
1791                }
1792             }
1793             if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate
1794                gamma0DalitzCand = kTRUE;
1795                gamma0MotherLabel=-111;
1796             }
1797             if(gammaMC0->GetPdgCode() ==221){ // Dalitz candidate
1798                gamma0DalitzCand = kTRUE;
1799                gamma0MotherLabel=-221;
1800             }
1801          }
1802       }
1803       if(TrueGammaCandidate1->GetV0Index()<fInputEvent->GetNumberOfV0s()){
1804          Int_t gamma1MCLabel = TrueGammaCandidate1->GetMCParticleLabel(MCStack);
1805          Int_t gamma1MotherLabel = -1;
1806          if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1807             // Daughters Gamma 1
1808             TParticle * negativeMC = (TParticle*)TrueGammaCandidate1->GetNegativeMCDaughter(MCStack);
1809             TParticle * positiveMC = (TParticle*)TrueGammaCandidate1->GetPositiveMCDaughter(MCStack);
1810             TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
1811             if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){  // Electrons ...
1812                if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1813                   if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
1814                      gamma1MotherLabel=gammaMC1->GetFirstMother();
1815                   }
1816                }
1817                if(gammaMC1->GetPdgCode() ==111 ){ // Dalitz candidate
1818                  gamma1DalitzCand = kTRUE;
1819                  gamma1MotherLabel=-111;
1820                }
1821                if(gammaMC1->GetPdgCode() ==221){ // Dalitz candidate
1822                  gamma1DalitzCand = kTRUE;
1823                  gamma1MotherLabel=-221;
1824                }
1825             }
1826          }
1827          if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1828             if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
1829                isTruePi0=kTRUE;
1830             }
1831             if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
1832                isTrueEta=kTRUE;
1833             }
1834          }
1835
1836          //Identify Dalitz candidate
1837          if (gamma1DalitzCand || gamma0DalitzCand){
1838             if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){
1839                if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE;
1840                if (gamma0MotherLabel == -221) isTrueEtaDalitz = kTRUE;
1841             }
1842             if (gamma1DalitzCand && gamma1MCLabel >=0 && gamma1MCLabel==gamma0MotherLabel){
1843                if (gamma1MotherLabel == -111) isTruePi0Dalitz = kTRUE;
1844                if (gamma1MotherLabel == -221) isTrueEtaDalitz = kTRUE;
1845             }
1846          }
1847
1848
1849          if(isTruePi0 || isTrueEta){// True Pion or Eta
1850             hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1851             if (fDoMesonQA > 0){
1852                if (isTruePi0){
1853                   if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
1854                      hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1855                      hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
1856                      if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
1857                         hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1858                         hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1859                      } else {
1860                         hESDMotherPi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1861                         hESDMotherPi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1862                      }
1863                   }
1864                } else if (isTrueEta){
1865                   if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
1866                      hESDTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1867                      hESDTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
1868                      if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
1869                         hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1870                         hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1871                      } else {
1872                         hESDMotherEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
1873                         hESDMotherEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
1874                      }
1875                   }
1876                }
1877             }
1878             if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
1879                Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetMother(0);
1880                Float_t weightedSec= 1;
1881                if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1882                   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
1883                   //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
1884                }
1885                hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1886                iMesonMCInfo = 2;
1887                if (secMotherLabel >-1){
1888                   if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1889                      iMesonMCInfo = 4;
1890                      hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1891                      if (fDoMesonQA > 0)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
1892                                        ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1893                   }
1894                   if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221){
1895                      iMesonMCInfo = 3;
1896                      hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1897                      if (fDoMesonQA > 0)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
1898                                        ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1899                   }
1900                }
1901             }else{ // Only primary pi0 for efficiency calculation
1902                iMesonMCInfo = 6;
1903                Float_t weighted= 1;
1904                if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
1905                   if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
1906                      weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
1907 //                      cout << "rec \t " <<gamma1MotherLabel << "\t" <<  weighted << endl;
1908                   }
1909                }
1910                hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1911                hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1912                pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1913
1914
1915                if (fDoMesonQA > 0){
1916                   if(isTruePi0){ // Only primary pi0 for resolution
1917                      hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1918                   }
1919                   if (isTrueEta){ // Only primary eta for resolution
1920                      hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1921                   }
1922                }
1923             }
1924          } else if(!isTruePi0 && !isTrueEta){ // Background
1925             if (fDoMesonQA > 0){
1926                if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
1927                   hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1928                   iMesonMCInfo = 1;
1929                } else { // No photon or without mother
1930                   hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1931                }
1932             }
1933             if( isTruePi0Dalitz || isTrueEtaDalitz ){
1934                // Dalitz
1935                iMesonMCInfo = 5;
1936                hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1937             } else if (gamma0DalitzCand || gamma1DalitzCand){
1938                if (fDoMesonQA > 0)hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1939             }
1940          }
1941       }
1942    }
1943 }
1944 //______________________________________________________________________
1945 void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1946 {
1947
1948    // Process True Mesons
1949    TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1950    Bool_t isTruePi0 = kFALSE;
1951    Bool_t isTrueEta = kFALSE;
1952    Bool_t isTruePi0Dalitz = kFALSE;
1953    Bool_t isTrueEtaDalitz = kFALSE;
1954    Bool_t gamma0DalitzCand = kFALSE;
1955    Bool_t gamma1DalitzCand = kFALSE;
1956
1957    AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
1958    AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
1959
1960    iMesonMCInfo = 0;
1961    Int_t gamma0MCLabel = -1;
1962    Int_t gamma0MotherLabel = -1;
1963    if(!positiveMC||!negativeMC)
1964       return;
1965
1966    if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
1967       gamma0MCLabel = positiveMC->GetMother();
1968    }
1969
1970    if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1971       // Daughters Gamma 0
1972       AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
1973       if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){  // Electrons ...
1974          if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
1975             if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1976                gamma0MotherLabel=gammaMC0->GetMother();
1977             }
1978          }
1979          if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate
1980             gamma0DalitzCand = kTRUE;
1981             gamma0MotherLabel=-111;
1982          }
1983          if(gammaMC0->GetPdgCode() ==221){ // Dalitz candidate
1984             gamma0DalitzCand = kTRUE;
1985             gamma0MotherLabel=-221;
1986          }
1987       }
1988    }
1989    positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelPositive()));
1990    negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelNegative()));
1991
1992    Int_t gamma1MCLabel = -1;
1993    Int_t gamma1MotherLabel = -1;
1994    if(!positiveMC||!negativeMC)
1995       return;
1996
1997    if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
1998       gamma1MCLabel = positiveMC->GetMother();
1999    }
2000    if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2001       // Daughters Gamma 1
2002       AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2003       if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){  // Electrons ...
2004          if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
2005             if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
2006                gamma1MotherLabel=gammaMC1->GetMother();
2007             }
2008          }
2009          if(gammaMC1->GetPdgCode() ==111 ){ // Dalitz candidate
2010                  gamma1DalitzCand = kTRUE;
2011                  gamma1MotherLabel=-111;
2012          }
2013          if(gammaMC1->GetPdgCode() ==221){ // Dalitz candidate
2014             gamma1DalitzCand = kTRUE;
2015             gamma1MotherLabel=-221;
2016          }
2017       }
2018    }
2019    if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2020       if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2021          isTruePi0=kTRUE;
2022       }
2023       if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2024          isTrueEta=kTRUE;
2025       }
2026    }
2027
2028    //Identify Dalitz candidate
2029    if (gamma1DalitzCand || gamma0DalitzCand){
2030       if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){
2031          if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE;
2032          if (gamma0MotherLabel == -221) isTrueEtaDalitz = kTRUE;
2033       }
2034       if (gamma1DalitzCand && gamma1MCLabel >=0 && gamma1MCLabel==gamma0MotherLabel){
2035          if (gamma1MotherLabel == -111) isTruePi0Dalitz = kTRUE;
2036          if (gamma1MotherLabel == -221) isTrueEtaDalitz = kTRUE;
2037       }
2038    }
2039
2040    if(isTruePi0 || isTrueEta){// True Pion or Eta
2041       hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2042       if (fDoMesonQA > 0){
2043          if (isTruePi0){
2044             if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2045                hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
2046                hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2047                if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
2048                   hESDTruePi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2049                   hESDTruePi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2050                } else {
2051                   hESDTruePi0YEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2052                   hESDTruePi0YEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2053                }
2054             }
2055          } else if (isTrueEta){
2056             if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2057                hESDTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
2058                hESDTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2059                if (TrueGammaCandidate0->Pt() < TrueGammaCandidate1->Pt()){
2060                   hESDTrueEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2061                   hESDTrueEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2062                } else {
2063                   hESDTrueEtaYEtaLowPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate1->Eta());
2064                   hESDTrueEtaYEtaHighPtGamma[fiCut]->Fill(Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift(),TrueGammaCandidate0->Eta());
2065                }
2066             }
2067          }
2068       }
2069       if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2070          Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2071          Float_t weightedSec= 1;
2072          if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2073             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
2074             //cout << "MC input \t"<<i << "\t" <<  particle->Pt()<<"\t"<<weighted << endl;
2075          }
2076          hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2077          iMesonMCInfo = 2;
2078          if (secMotherLabel >-1){
2079             if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2080                iMesonMCInfo = 4;
2081                hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2082                if (fDoMesonQA > 0)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
2083                                  ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2084             }
2085             if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221){
2086                iMesonMCInfo = 3;
2087                hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2088                if (fDoMesonQA > 0)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
2089                                  ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2090             }
2091          }
2092       }else{ // Only primary pi0 for efficiency calculation
2093          Float_t weighted= 1;
2094          iMesonMCInfo = 6;
2095          if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2096             if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2097                weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2098                //                      cout << "rec \t " <<gamma1MotherLabel << "\t" <<  weighted << endl;
2099             }
2100          }
2101          hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2102          hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2103          pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2104
2105          if (fDoMesonQA > 0){
2106             if(isTruePi0){ // Only primary pi0 for resolution
2107                hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2108                                                           (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2109
2110             }
2111             if (isTrueEta){ // Only primary eta for resolution
2112                hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2113                                                           (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2114             }
2115          }
2116       }
2117    } else if(!isTruePi0 && !isTrueEta) { // Background
2118       if (fDoMesonQA > 0){
2119          if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2120             hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2121             iMesonMCInfo = 1;
2122          } else { // No photon or without mother
2123             hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2124          }
2125       }
2126       if( isTruePi0Dalitz || isTrueEtaDalitz ){
2127          // Dalitz
2128          iMesonMCInfo = 5;
2129          hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2130       } else if (gamma0DalitzCand || gamma1DalitzCand){
2131          if (fDoMesonQA > 0)hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2132       }
2133    }
2134 }
2135 //________________________________________________________________________
2136 void AliAnalysisTaskGammaConvV1::CalculateBackground(){
2137
2138    Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2139    Int_t mbin = 0;
2140
2141    if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2142       mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2143    } else {
2144       mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2145    }
2146
2147    if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2148
2149       for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2150          AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2151          for(Int_t iCurrent2=iCurrent+1;iCurrent2<fGammaCandidates->GetEntries();iCurrent2++){
2152             for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2153                AliAODConversionPhoton currentEventGoodV02 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent2));
2154
2155                if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGProbability()){
2156                   AliAODConversionMother *backgroundCandidateProb = new AliAODConversionMother(&currentEventGoodV0,&currentEventGoodV02);
2157                   Double_t massBGprob = backgroundCandidateProb->M();
2158                   if(massBGprob>0.1 && massBGprob<0.14){
2159                      if(fRandom.Rndm()>fBGHandler[fiCut]->GetBGProb(zbin,mbin)){
2160                         delete backgroundCandidateProb;
2161                         continue;
2162                      }
2163                   }
2164                   delete backgroundCandidateProb;
2165                   backgroundCandidateProb = 0x0;
2166                }
2167
2168                RotateParticle(&currentEventGoodV02);
2169                AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&currentEventGoodV02);
2170                backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2171                if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2172                    ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2173                   hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2174                   Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2175                   sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2176                }
2177                delete backgroundCandidate;
2178                backgroundCandidate = 0x0;
2179             }
2180          }
2181       }
2182    }else{
2183       AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2184
2185       if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2186          for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2187             AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2188             if(fMoveParticleAccordingToVertex == kTRUE){
2189                bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2190             }
2191
2192             for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2193                AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2194                for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2195                   AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2196                   if(fMoveParticleAccordingToVertex == kTRUE){
2197                      MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2198                   }
2199                   if(fIsHeavyIon){
2200                      RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2201                   }
2202
2203                   AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2204                   backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2205                   if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2206                       ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2207                      hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2208                      Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2209                      sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2210                   }
2211                   delete backgroundCandidate;
2212                   backgroundCandidate = 0x0;
2213                }
2214             }
2215          }
2216       }
2217       else{
2218          for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2219             AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2220             if(previousEventV0s){
2221                if(fMoveParticleAccordingToVertex == kTRUE){
2222                   bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2223                }
2224                for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2225                   AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2226                   for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2227
2228                      AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2229
2230                      if(fMoveParticleAccordingToVertex == kTRUE){
2231                         MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2232                      }
2233                      if(fIsHeavyIon){
2234                         RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2235                      }
2236
2237
2238                      AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2239                      backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2240                      if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2241                          ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2242                         hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2243                         Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2244                         sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2245                      }
2246                      delete backgroundCandidate;
2247                      backgroundCandidate = 0x0;
2248                   }
2249                }
2250             }
2251          }
2252       }
2253    }
2254 }
2255 //________________________________________________________________________
2256 void AliAnalysisTaskGammaConvV1::CalculateBackgroundRP(){
2257
2258    Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2259    Int_t mbin = 0;
2260    if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2261       mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2262    } else {
2263       mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2264    }
2265
2266
2267    //Rotation Method
2268    if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2269       // Correct for the number of rotations
2270       // BG is for rotation the same, except for factor NRotations
2271       Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
2272
2273       for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2274
2275          AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2276          if (gamma0==NULL) continue;
2277          for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
2278             AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
2279             if (gamma1 == NULL) continue;
2280             if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
2281             for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2282
2283                RotateParticle(gamma1);
2284
2285                AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2286                backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2287                if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2288                   ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
2289                   hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2290                   Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2291                   sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2292                }
2293             }
2294          }
2295       }
2296    }
2297    else{
2298       // Do Event Mixing
2299       for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
2300
2301          AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
2302
2303          if(previousEventGammas){
2304             // test weighted background
2305             Double_t weight=1.0;
2306             // Correct for the number of eventmixing:
2307             // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1))  using sum formula sum(i)=N*(N-1)/2  -> N*(N-1)/2
2308             // real combinations (since you cannot combine a photon with its own)
2309             // but BG leads to N_{a}*N_{b} combinations
2310             weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
2311
2312             for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2313
2314                AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2315
2316                for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
2317
2318                   AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
2319
2320                   AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2321                   backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2322                   if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2323                      ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
2324                      hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2325                      Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2326                      sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2327                   }
2328                }
2329             }
2330          }
2331       }
2332    }
2333 }
2334 //________________________________________________________________________
2335 void AliAnalysisTaskGammaConvV1::RotateParticle(AliAODConversionPhoton *gamma){
2336    Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
2337    Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
2338    Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
2339    gamma->RotateZ(rotationValue);
2340 }
2341
2342 //________________________________________________________________________
2343 void AliAnalysisTaskGammaConvV1::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
2344
2345    previousEventEP=previousEventEP+TMath::Pi();
2346    thisEventEP=thisEventEP+TMath::Pi();
2347    Double_t rotationValue= thisEventEP-previousEventEP;
2348    gamma->RotateZ(rotationValue);
2349 }
2350
2351 //________________________________________________________________________
2352 void AliAnalysisTaskGammaConvV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
2353    //see header file for documentation
2354
2355    Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
2356    Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
2357    Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
2358
2359    Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
2360    particle->SetConversionPoint(movedPlace);
2361 }
2362 //________________________________________________________________________
2363 void AliAnalysisTaskGammaConvV1::UpdateEventByEventData(){
2364    //see header file for documentation
2365    if(fGammaCandidates->GetEntries() >0 ){
2366       if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2367          fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
2368       }
2369       else{ // means we use #V0s for multiplicity
2370          fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
2371       }
2372    }
2373 }
2374
2375
2376 //________________________________________________________________________
2377 void AliAnalysisTaskGammaConvV1::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
2378 {
2379    // 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
2380    if(pdgCode[0]==11   && pdgCode[1]==11){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
2381    else if( (pdgCode[0]==11   && pdgCode[1]==211) || (pdgCode[0]==211  && pdgCode[1]==11) )
2382       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
2383    else if( (pdgCode[0]==11   && pdgCode[1]==321) || (pdgCode[0]==321  && pdgCode[1]==11) )
2384       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
2385    else if( (pdgCode[0]==11   && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
2386       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
2387    else if( (pdgCode[0]==11   && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==11) )
2388       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
2389    else if(  pdgCode[0]==211  && pdgCode[1]==211 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
2390    else if( (pdgCode[0]==211  && pdgCode[1]==321) || (pdgCode[0]==321  && pdgCode[1]==211) )
2391       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
2392    else if( (pdgCode[0]==211  && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
2393       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
2394    else if( (pdgCode[0]==211  && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==211) )
2395       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
2396    else if(  pdgCode[0]==321  && pdgCode[1]==321 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
2397    else if( (pdgCode[0]==321  && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
2398       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
2399    else if( (pdgCode[0]==321  && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==321) )
2400       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
2401    else if(  pdgCode[0]==2212   && pdgCode[1]==2212  ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
2402    else if( (pdgCode[0]==2212  && pdgCode[1]==13) || (pdgCode[0]==13   && pdgCode[1]==2212) )
2403       {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
2404    else if(  pdgCode[0]==13   && pdgCode[1]==13  ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
2405    else {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
2406 }
2407 //________________________________________________________________________
2408 void AliAnalysisTaskGammaConvV1::RelabelAODPhotonCandidates(Bool_t mode){
2409
2410    // Relabeling For AOD Event
2411    // ESDiD -> AODiD
2412    // MCLabel -> AODMCLabel
2413
2414    if(mode){
2415       fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
2416       fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
2417       fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
2418       fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
2419    }
2420
2421    for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
2422       AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
2423       if(!PhotonCandidate) continue;
2424       if(!mode){// Back to ESD Labels
2425          PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
2426          PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
2427          PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
2428          PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
2429          continue;
2430       }
2431       fMCStackPos[iGamma] =  PhotonCandidate->GetMCLabelPositive();
2432       fMCStackNeg[iGamma] =  PhotonCandidate->GetMCLabelNegative();
2433       fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
2434       fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
2435
2436       Bool_t AODLabelPos = kFALSE;
2437       Bool_t AODLabelNeg = kFALSE;
2438
2439       for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
2440          AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
2441          if(!AODLabelPos){
2442             if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
2443                PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
2444                PhotonCandidate->SetLabelPositive(i);
2445                AODLabelPos = kTRUE;
2446             }
2447          }
2448          if(!AODLabelNeg){
2449             if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
2450                PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
2451                PhotonCandidate->SetLabelNegative(i);
2452                AODLabelNeg = kTRUE;
2453             }
2454          }
2455          if(AODLabelNeg && AODLabelPos){
2456             break;
2457          }
2458       }
2459       if(!AODLabelPos || !AODLabelNeg){
2460          cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
2461       }
2462    }
2463
2464
2465    if(!mode){
2466       delete[] fMCStackPos;
2467       delete[] fMCStackNeg;
2468       delete[] fESDArrayPos;
2469       delete[] fESDArrayNeg;
2470    }
2471 }
2472
2473 void AliAnalysisTaskGammaConvV1::SetLogBinningXTH2(TH2* histoRebin){
2474    TAxis *axisafter = histoRebin->GetXaxis();
2475    Int_t bins = axisafter->GetNbins();
2476    Double_t from = axisafter->GetXmin();
2477    Double_t to = axisafter->GetXmax();
2478    Double_t *newbins = new Double_t[bins+1];
2479    newbins[0] = from;
2480    Double_t factor = TMath::Power(to/from, 1./bins);
2481    for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
2482    axisafter->Set(bins, newbins);
2483    delete [] newbins;
2484
2485 }
2486
2487 //________________________________________________________________________
2488 void AliAnalysisTaskGammaConvV1::Terminate(const Option_t *)
2489 {
2490
2491    //fOutputContainer->Print(); // Will crash on GRID
2492 }