PWGGA/GammaConv/AliAnalysisTaskGammaConvV1.cxx

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