PWGGA/GammaConv/AliAnalysisTaskGammaConvV1.cxx

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