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