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