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