PWGGA/GammaConv/AliAnalysisTaskGammaConvDalitzV1.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: Pedro Gonz??lez, Pedro Ladr??n de Guevara, Ernesto L??pez Torres, *
   5  *         Eulogio Serradilla, Ana Marin, Friederike Bock                 *
   6  * Version 2                                                              *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16
  17 // Analysis task for pi0->e+e-gamma (Dalitz decay)
  18 // Analysis task for chic->JPsi+gamma
  19
  20 #include <vector>
  21
  22 #include "TParticle.h"
  23 #include "TPDGCode.h"
  24 #include "TMCProcess.h"
  25 #include "TDatabasePDG.h"
  26 #include "TList.h"
  27 #include "TChain.h"
  28 #include "TDirectory.h"
  29 #include "TTree.h"
  30 #include "TH1.h"
  31 #include "TH1F.h"
  32 #include "THnSparse.h"
  33 #include "TH2F.h"
  34 #include "AliStack.h"
  35 #include "AliAnalysisManager.h"
  36 #include "AliESDInputHandler.h"
  37 #include "AliESDtrack.h"
  38 #include "AliMCEvent.h"
  39 #include "AliStack.h"
  40 #include "AliMCEventHandler.h"
  41 #include "AliPID.h"
  42 #include "AliLog.h"
  43 #include "AliESDtrackCuts.h"
  44 #include "AliESDpidCuts.h"
  45 #include "AliMCEvent.h"
  46 #include "AliESDv0.h"
  47 #include "AliESDEvent.h"
  48 #include "AliESDpid.h"
  49 #include "AliKFParticle.h"
  50 #include "AliMCEventHandler.h"
  51 #include "AliKFVertex.h"
  52 #include "AliTriggerAnalysis.h"
  53 #include "AliCentrality.h"
  54 #include "AliMultiplicity.h"
  55 #include "AliAnalysisTaskGammaConvDalitzV1.h"
  56
  57
  58 ClassImp( AliAnalysisTaskGammaConvDalitzV1 )
  59
  60 //-----------------------------------------------------------------------------------------------
  61 AliAnalysisTaskGammaConvDalitzV1::AliAnalysisTaskGammaConvDalitzV1():
  62 fV0Reader(NULL),
  63    fElecSelector(NULL),
  64    fBGHandler(NULL),
  65    fESDEvent(NULL),
  66    fMCEvent(NULL),
  67    fMCStack(NULL),
  68    fCutFolder(NULL),
  69    fESDList(NULL),
  70    fBackList(NULL),
  71    fMotherList(NULL),
  72    fTrueList(NULL),
  73    fMCList(NULL),
  74    fQAFolder(NULL),
  75    fOutputContainer(0),
  76    fReaderGammas(NULL),
  77    fSelectorElectronIndex(0),
  78    fSelectorPositronIndex(0),
  79    fGoodGammas(NULL),
  80    fGoodVirtualGammas(NULL),
  81    fGoodElectrons(NULL),
  82    fGoodPositrons(NULL),
  83    fCutGammaArray(NULL),
  84    fCutElectronArray(NULL),
  85    fCutMesonArray(NULL),
  86    fGammasPool(NULL),
  87    fConversionCuts(NULL),
  88    hESDConvGammaPt(NULL),
  89    hESDConvGammaEta(NULL),
  90    hESDConvGammaZR(NULL),
  91    hESDDalitzElectronPt(NULL),
  92    hESDDalitzPositronPt(NULL),
  93    hESDDalitzElectronPhi(NULL),
  94    hESDDalitzPositronPhi(NULL),
  95    hESDDalitzElectronAfterPt(NULL),
  96    hESDDalitzPositronAfterPt(NULL),
  97    hESDDalitzElectronAfterEta(NULL),
  98    hESDDalitzPositronAfterEta(NULL),
  99    hESDDalitzElectronAfterPhi(NULL),
 100    hESDDalitzPositronAfterPhi(NULL),
 101    hESDDalitzElectronAfterNClsITS(NULL),
 102    hESDDalitzPositronAfterNClsITS(NULL),
 103    hESDDalitzElectronAfterNFindClsTPC(NULL),
 104    hESDDalitzPositronAfterNFindClsTPC(NULL),
 105    hESDDalitzElectronAfterNClsTPC(NULL),
 106    hESDDalitzPositronAfterNClsTPC(NULL),
 107    hESDDalitzElectronAfterNCrossedRowsTPC(NULL),
 108    hESDDalitzPositronAfterNCrossedRowsTPC(NULL),
 109    hESDDalitzPosEleAfterDCAxy(NULL),
 110    hESDDalitzPosEleAfterDCAz(NULL),
 111    hESDDalitzElectronAfterTPCdEdxVsP(NULL),
 112    hESDDalitzPositronAfterTPCdEdxVsP(NULL),
 113    hESDDalitzElectronAfterTPCdEdxSignalVsP(NULL),
 114    hESDDalitzPositronAfterTPCdEdxSignalVsP(NULL),
 115    hESDDalitzElectronAfterTPCdEdxVsEta(NULL),
 116    hESDDalitzPositronAfterTPCdEdxVsEta(NULL),
 117    hESDDalitzElectronAfterTPCdEdxVsPhi(NULL),
 118    hESDDalitzPositronAfterTPCdEdxVsPhi(NULL),
 119    hESDMotherPhi(NULL),
 120    hESDEposEnegPsiPairDPhi(NULL),
 121    hESDEposEnegInvMassPt(NULL),
 122    hESDEposEnegLikeSignBackInvMassPt(NULL),
 123    hESDMotherInvMassPt(NULL),
 124    hESDPi0MotherInvMassPt(NULL),
 125    hESDPi0MotherDiffInvMassPt(NULL),
 126    hESDPi0MotherDiffLimInvMassPt(NULL),
 127    sESDMotherInvMassPtZM(NULL),
 128    hESDMotherBackInvMassPt(NULL),
 129    sESDMotherBackInvMassPtZM(NULL),
 130    hMCAllGammaPt(NULL),
 131    hMCConvGammaPt(NULL),
 132    hMCConvGammaRSPt(NULL),
 133    hMCAllPositronsPt(NULL),
 134    hMCAllElectronsPt(NULL),
 135    hMCConvGammaEta(NULL),
 136    hMCAllPositronsEta(NULL),
 137    hMCAllElectronsEta(NULL),
 138    hMCPi0DalitzGammaPt(NULL),
 139    hMCPi0DalitzElectronPt(NULL),
 140    hMCPi0DalitzPositronPt(NULL),
 141    hMCPi0Pt(NULL),
 142    hMCPi0GGPt(NULL),
 143    hMCEtaPt(NULL),
 144    hMCEtaGGPt(NULL),
 145    hMCPi0InAccPt(NULL),
 146    hMCEtaInAccPt(NULL),
 147    hMCChiCPt(NULL),
 148    hMCChiCInAccPt(NULL),
 149    hMCPi0EposEnegInvMassPt(NULL),
 150    hMCEtaEposEnegInvMassPt(NULL),
 151    hESDEposEnegTruePi0DalitzInvMassPt(NULL),
 152    hESDEposEnegTruePrimPi0DalitzInvMass(NULL),
 153    hESDEposEnegTruePi0DalitzPsiPairDPhi(NULL),
 154    hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
 155    hESDEposEnegTruePrimEtaDalitzInvMass(NULL),
 156    hESDEposEnegTrueEtaDalitzPsiPairDPhi(NULL),
 157    hESDEposEnegTruePhotonInvMassPt(NULL),
 158    hESDEposEnegTrueInvMassPt(NULL),
 159    hESDEposEnegTruePhotonPsiPairDPhi(NULL),
 160    hESDEposEnegTrueJPsiInvMassPt(NULL),
 161    hESDTrueMotherChiCInvMassPt(NULL),
 162    hESDTrueMotherChiCDiffInvMassPt(NULL),
 163    hESDTrueMotherInvMassPt(NULL),
 164    hESDTrueMotherDalitzInvMassPt(NULL),
 165    hESDTrueMotherPi0GGInvMassPt(NULL),
 166    hESDTruePrimaryMotherPi0GGInvMassPt(NULL),
 167    hESDTrueSecondaryMotherPi0GGInvMassPt(NULL),
 168    hESDTruePrimaryMotherInvMassMCPt(NULL),
 169    hESDTruePrimaryMotherInvMassPt(NULL),
 170    hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
 171    hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
 172    hESDTrueSecondaryMotherInvMassPt(NULL),
 173    hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
 174    hESDTrueBckGGInvMassPt(NULL),
 175    hESDTrueBckContInvMassPt(NULL),
 176    hESDTrueMotherGGInvMassPt(NULL),
 177    hESDTrueConvGammaPt(NULL),
 178    hESDTruePositronPt(NULL),
 179    hESDTrueElectronPt(NULL),
 180    hESDTrueSecConvGammaPt(NULL),
 181    hESDTrueSecPositronPt(NULL),
 182    hESDTrueSecElectronPt(NULL),
 183    hESDTruePi0DalitzConvGammaPt(NULL),
 184    hESDTruePi0DalitzPositronPt(NULL),
 185    hESDTruePi0DalitzElectronPt(NULL),
 186    hESDTruePi0DalitzSecConvGammaPt(NULL),
 187    hESDTruePi0DalitzSecPositronPt(NULL),
 188    hESDTruePi0DalitzSecElectronPt(NULL),
 189    hNEvents(NULL),
 190    hNGoodESDTracks(NULL),
 191    hEtaShift(NULL),
 192    fRandom(0),
 193    fUnsmearedPx(NULL),
 194    fUnsmearedPy(NULL),
 195    fUnsmearedPz(NULL),
 196    fUnsmearedE(NULL),
 197    fnCuts(0),
 198    fiCut(0),
 199    fNumberOfESDTracks(0),
 200    fMoveParticleAccordingToVertex(kFALSE),
 201    fIsHeavyIon(kFALSE),
 202    fDoMesonAnalysis(kTRUE),
 203    fDoChicAnalysis(kFALSE),
 204    fDoMesonQA(kFALSE),
 205    fSetProductionVertextoVGamma(kTRUE),
 206    fIsFromMBHeader(kTRUE),
 207    fIsMC(kFALSE)
 208 {
 209
 210 }
 211
 212 //-----------------------------------------------------------------------------------------------
 213 AliAnalysisTaskGammaConvDalitzV1::AliAnalysisTaskGammaConvDalitzV1( const char* name ):
 214    AliAnalysisTaskSE(name),
 215    fV0Reader(NULL),
 216    fElecSelector(NULL),
 217    fBGHandler(NULL),
 218    fESDEvent(NULL),
 219    fMCEvent(NULL),
 220    fMCStack(NULL),
 221    fCutFolder(NULL),
 222    fESDList(NULL),
 223    fBackList(NULL),
 224    fMotherList(NULL),
 225    fTrueList(NULL),
 226    fMCList(NULL),
 227    fQAFolder(NULL),
 228    fOutputContainer(0),
 229    fReaderGammas(NULL),
 230    fSelectorElectronIndex(0),
 231    fSelectorPositronIndex(0),
 232    fGoodGammas(NULL),
 233    fGoodVirtualGammas(NULL),
 234    fGoodElectrons(NULL),
 235    fGoodPositrons(NULL),
 236    fCutGammaArray(NULL),
 237    fCutElectronArray(NULL),
 238    fCutMesonArray(NULL),
 239    fGammasPool(NULL),
 240    fConversionCuts(NULL),
 241    hESDConvGammaPt(NULL),
 242    hESDConvGammaEta(NULL),
 243    hESDConvGammaZR(NULL),
 244    hESDDalitzElectronPt(NULL),
 245    hESDDalitzPositronPt(NULL),
 246    hESDDalitzElectronPhi(NULL),
 247    hESDDalitzPositronPhi(NULL),
 248    hESDDalitzElectronAfterPt(NULL),
 249    hESDDalitzPositronAfterPt(NULL),
 250    hESDDalitzElectronAfterEta(NULL),
 251    hESDDalitzPositronAfterEta(NULL),
 252    hESDDalitzElectronAfterPhi(NULL),
 253    hESDDalitzPositronAfterPhi(NULL),
 254    hESDDalitzElectronAfterNClsITS(NULL),
 255    hESDDalitzPositronAfterNClsITS(NULL),
 256    hESDDalitzElectronAfterNFindClsTPC(NULL),
 257    hESDDalitzPositronAfterNFindClsTPC(NULL),
 258    hESDDalitzElectronAfterNClsTPC(NULL),
 259    hESDDalitzPositronAfterNClsTPC(NULL),
 260    hESDDalitzElectronAfterNCrossedRowsTPC(NULL),
 261    hESDDalitzPositronAfterNCrossedRowsTPC(NULL),
 262    hESDDalitzPosEleAfterDCAxy(NULL),
 263    hESDDalitzPosEleAfterDCAz(NULL),
 264    hESDDalitzElectronAfterTPCdEdxVsP(NULL),
 265    hESDDalitzPositronAfterTPCdEdxVsP(NULL),
 266    hESDDalitzElectronAfterTPCdEdxSignalVsP(NULL),
 267    hESDDalitzPositronAfterTPCdEdxSignalVsP(NULL),
 268    hESDDalitzElectronAfterTPCdEdxVsEta(NULL),
 269    hESDDalitzPositronAfterTPCdEdxVsEta(NULL),
 270    hESDDalitzElectronAfterTPCdEdxVsPhi(NULL),
 271    hESDDalitzPositronAfterTPCdEdxVsPhi(NULL),
 272    hESDMotherPhi(NULL),
 273    hESDEposEnegPsiPairDPhi(NULL),
 274    hESDEposEnegInvMassPt(NULL),
 275    hESDEposEnegLikeSignBackInvMassPt(NULL),
 276    hESDMotherInvMassPt(NULL),
 277    hESDPi0MotherInvMassPt(NULL),
 278    hESDPi0MotherDiffInvMassPt(NULL),
 279    hESDPi0MotherDiffLimInvMassPt(NULL),
 280    sESDMotherInvMassPtZM(NULL),
 281    hESDMotherBackInvMassPt(NULL),
 282    sESDMotherBackInvMassPtZM(NULL),
 283    hMCAllGammaPt(NULL),
 284    hMCConvGammaPt(NULL),
 285    hMCConvGammaRSPt(NULL),
 286    hMCAllPositronsPt(NULL),
 287    hMCAllElectronsPt(NULL),
 288    hMCConvGammaEta(NULL),
 289    hMCAllPositronsEta(NULL),
 290    hMCAllElectronsEta(NULL),
 291    hMCPi0DalitzGammaPt(NULL),
 292    hMCPi0DalitzElectronPt(NULL),
 293    hMCPi0DalitzPositronPt(NULL),
 294    hMCPi0Pt(NULL),
 295    hMCPi0GGPt(NULL),
 296    hMCEtaPt(NULL),
 297    hMCEtaGGPt(NULL),
 298    hMCPi0InAccPt(NULL),
 299    hMCEtaInAccPt(NULL),
 300    hMCChiCPt(NULL),
 301    hMCChiCInAccPt(NULL),
 302    hMCPi0EposEnegInvMassPt(NULL),
 303    hMCEtaEposEnegInvMassPt(NULL),
 304    hESDEposEnegTruePi0DalitzInvMassPt(NULL),
 305    hESDEposEnegTruePrimPi0DalitzInvMass(NULL),
 306    hESDEposEnegTruePi0DalitzPsiPairDPhi(NULL),
 307    hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
 308    hESDEposEnegTruePrimEtaDalitzInvMass(NULL),
 309    hESDEposEnegTrueEtaDalitzPsiPairDPhi(NULL),
 310    hESDEposEnegTruePhotonInvMassPt(NULL),
 311    hESDEposEnegTrueInvMassPt(NULL),
 312    hESDEposEnegTruePhotonPsiPairDPhi(NULL),
 313    hESDEposEnegTrueJPsiInvMassPt(NULL),
 314    hESDTrueMotherChiCInvMassPt(NULL),
 315    hESDTrueMotherChiCDiffInvMassPt(NULL),
 316    hESDTrueMotherInvMassPt(NULL),
 317    hESDTrueMotherDalitzInvMassPt(NULL),
 318    hESDTrueMotherPi0GGInvMassPt(NULL),
 319    hESDTruePrimaryMotherPi0GGInvMassPt(NULL),
 320    hESDTrueSecondaryMotherPi0GGInvMassPt(NULL),
 321    hESDTruePrimaryMotherInvMassMCPt(NULL),
 322    hESDTruePrimaryMotherInvMassPt(NULL),
 323    hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
 324    hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
 325    hESDTrueSecondaryMotherInvMassPt(NULL),
 326    hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
 327    hESDTrueBckGGInvMassPt(NULL),
 328    hESDTrueBckContInvMassPt(NULL),
 329    hESDTrueMotherGGInvMassPt(NULL),
 330    hESDTrueConvGammaPt(NULL),
 331    hESDTruePositronPt(NULL),
 332    hESDTrueElectronPt(NULL),
 333    hESDTrueSecConvGammaPt(NULL),
 334    hESDTrueSecPositronPt(NULL),
 335    hESDTrueSecElectronPt(NULL),
 336    hESDTruePi0DalitzConvGammaPt(NULL),
 337    hESDTruePi0DalitzPositronPt(NULL),
 338    hESDTruePi0DalitzElectronPt(NULL),
 339    hESDTruePi0DalitzSecConvGammaPt(NULL),
 340    hESDTruePi0DalitzSecPositronPt(NULL),
 341    hESDTruePi0DalitzSecElectronPt(NULL),
 342    hNEvents(NULL),
 343    hNGoodESDTracks(NULL),
 344    hEtaShift(NULL),
 345    fRandom(0),
 346    fUnsmearedPx(NULL),
 347    fUnsmearedPy(NULL),
 348    fUnsmearedPz(NULL),
 349    fUnsmearedE(NULL),
 350    fnCuts(0),
 351    fiCut(0),
 352    fNumberOfESDTracks(0),
 353    fMoveParticleAccordingToVertex(kFALSE),
 354    fIsHeavyIon(kFALSE),
 355    fDoMesonAnalysis(kTRUE),
 356    fDoChicAnalysis(kFALSE),
 357    fDoMesonQA(kFALSE),
 358    fSetProductionVertextoVGamma(kTRUE),
 359    fIsFromMBHeader(kTRUE),
 360    fIsMC(kFALSE)
 361 {
 362    DefineOutput(1, TList::Class());
 363 }
 364
 365 //-----------------------------------------------------------------------------------------------
 366 AliAnalysisTaskGammaConvDalitzV1::~AliAnalysisTaskGammaConvDalitzV1()
 367 {
 368    //
 369    // virtual destructor
 370    //
 371
 372    cout<<"Destructor"<<endl;
 373
 374    if(fGoodGammas){
 375       delete fGoodGammas;
 376       fGoodGammas = 0x0;
 377    }
 378    if(fGoodVirtualGammas){
 379       delete fGoodVirtualGammas;
 380       fGoodGammas = 0x0;
 381    }
 382    if(fGoodElectrons){
 383       delete fGoodGammas;
 384       fGoodGammas = 0x0;
 385    }
 386    if(fGoodPositrons){
 387       delete fGoodGammas;
 388       fGoodGammas = 0x0;
 389    }
 390    if(fBGHandler){
 391       delete[] fBGHandler;
 392       fBGHandler = 0x0;
 393    }
 394    if( fGammasPool ){
 395       delete[] fGammasPool;
 396       fGammasPool = 0x0;
 397    }
 398 }
 399 //___________________________________________________________
 400 void AliAnalysisTaskGammaConvDalitzV1::InitBack(){
 401
 402    const Int_t nDim = 4;
 403    Int_t nBins[nDim] = {800,250,7,4};
 404    Double_t xMin[nDim] = {0,0, 0,0};
 405    Double_t xMax[nDim] = {0.8,25,7,4};
 406
 407    sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
 408    sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
 409
 410    fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
 411    //fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
 412    for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 413       //if (((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->DoBGCalculation()){
 414
 415
 416          TString cutstringElectron     =   ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
 417          TString cutstringMeson        =   ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
 418          TString cutstringGamma        =   ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
 419
 420
 421
 422          Int_t collisionSystem = atoi((TString)(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber())(0,1));
 423          Int_t centMin = atoi((TString)(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber())(1,1));
 424          Int_t centMax = atoi((TString)(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber())(2,1));
 425
 426          if(collisionSystem == 1 || collisionSystem == 2 ||
 427             collisionSystem == 5 || collisionSystem == 8 ||
 428             collisionSystem == 9){
 429             centMin = centMin*10;
 430             centMax = centMax*10;
 431          }
 432          else if(collisionSystem == 3 || collisionSystem == 6){
 433             centMin = centMin*5;
 434             centMax = centMax*5;
 435          }
 436          else if(collisionSystem == 4 || collisionSystem == 7){
 437             centMin = ((centMin*5)+45);
 438             centMax = ((centMax*5)+45);
 439          }
 440
 441
 442          fBackList[iCut] = new TList();
 443          fBackList[iCut]->SetName(Form("%s_%s_%s Back histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
 444          fBackList[iCut]->SetOwner(kTRUE);
 445          fCutFolder[iCut]->Add(fBackList[iCut]);
 446
 447          sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
 448          fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
 449
 450          fMotherList[iCut] = new TList();
 451          fMotherList[iCut]->SetName(Form("%s_%s_%s Mother histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
 452          fMotherList[iCut]->SetOwner(kTRUE);
 453          fCutFolder[iCut]->Add(fMotherList[iCut]);
 454
 455          sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
 456          fMotherList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
 457
 458
 459          fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
 460                                                                   collisionSystem,centMin,centMax,
 461                                                                   ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->NumberOfRotationEvents(),
 462                                                                   ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->UseTrackMultiplicity());
 463
 464         if( ( (AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetBKGMethod() == 3 ){
 465          fGammasPool[iCut] = new TList();
 466         }
 467
 468       //}
 469    }
 470 }
 471
 472 //______________________________________________________________________
 473 void AliAnalysisTaskGammaConvDalitzV1::UserCreateOutputObjects()
 474 {
 475    //
 476    // Create ouput objects
 477    //
 478
 479    // Create the output container
 480    if(fOutputContainer != NULL){
 481       delete fOutputContainer;
 482       fOutputContainer = NULL;
 483    }
 484    if(fOutputContainer == NULL){
 485       fOutputContainer = new TList();
 486       fOutputContainer->SetOwner(kTRUE);
 487    }
 488
 489    fGoodGammas = new TList();
 490    //fGoodGammas->SetOwner(kTRUE);
 491
 492
 493    fGoodVirtualGammas = new TList();
 494    //fGoodVirtualGammas->SetOwner(kTRUE);
 495
 496
 497
 498    fGammasPool                     = new TList*[fnCuts];
 499    fCutFolder                      = new TList*[fnCuts];
 500    fESDList                        = new TList*[fnCuts];
 501    fBackList                       = new TList*[fnCuts];
 502    fMotherList                     = new TList*[fnCuts];
 503    //fQAFolder                       = new TList*[fnCuts];
 504    hNEvents                        = new TH1I*[fnCuts];
 505    hNGoodESDTracks                 = new TH1I*[fnCuts];
 506    hEtaShift                       = new TProfile*[fnCuts];
 507    hESDConvGammaPt                 = new TH1F*[fnCuts];
 508    hESDConvGammaEta                = new TH1F*[fnCuts];
 509
 510    hESDDalitzElectronPt            = new TH1F*[fnCuts];
 511    hESDDalitzPositronPt            = new TH1F*[fnCuts];
 512    hESDDalitzElectronPhi           = new TH1F*[fnCuts];
 513    hESDDalitzPositronPhi           = new TH1F*[fnCuts];
 514
 515    if( fDoMesonQA ) {
 516
 517    fQAFolder  = new TList*[fnCuts];
 518
 519    hESDDalitzElectronAfterPt       = new TH1F*[fnCuts];
 520    hESDDalitzPositronAfterPt       = new TH1F*[fnCuts];
 521    hESDDalitzElectronAfterEta      = new TH1F*[fnCuts];
 522    hESDDalitzPositronAfterEta      = new TH1F*[fnCuts];
 523    hESDDalitzElectronAfterPhi      = new TH1F*[fnCuts];
 524    hESDDalitzPositronAfterPhi      = new TH1F*[fnCuts];
 525    hESDDalitzElectronAfterNClsITS  = new TH1F*[fnCuts];
 526    hESDDalitzPositronAfterNClsITS  = new TH1F*[fnCuts];
 527    hESDDalitzElectronAfterNFindClsTPC = new TH2F*[fnCuts];
 528    hESDDalitzPositronAfterNFindClsTPC = new TH2F*[fnCuts];
 529    hESDDalitzElectronAfterNClsTPC     = new TH2F*[fnCuts];
 530    hESDDalitzPositronAfterNClsTPC     = new TH2F*[fnCuts];
 531    hESDDalitzElectronAfterNCrossedRowsTPC = new TH2F*[fnCuts];
 532    hESDDalitzPositronAfterNCrossedRowsTPC = new TH2F*[fnCuts];
 533    hESDDalitzPosEleAfterDCAxy      = new TH2F*[fnCuts];
 534    hESDDalitzPosEleAfterDCAz       = new TH2F*[fnCuts];
 535    hESDDalitzElectronAfterTPCdEdxVsP    = new TH2F*[fnCuts];
 536    hESDDalitzPositronAfterTPCdEdxVsP = new TH2F*[fnCuts];
 537    hESDDalitzElectronAfterTPCdEdxSignalVsP = new TH2F*[fnCuts];
 538    hESDDalitzPositronAfterTPCdEdxSignalVsP = new TH2F*[fnCuts];
 539    hESDDalitzElectronAfterTPCdEdxVsEta = new TH2F*[fnCuts];
 540    hESDDalitzPositronAfterTPCdEdxVsEta = new TH2F*[fnCuts];
 541    hESDDalitzElectronAfterTPCdEdxVsPhi = new TH2F*[fnCuts];
 542    hESDDalitzPositronAfterTPCdEdxVsPhi = new TH2F*[fnCuts];
 543    hESDMotherPhi                   = new TH1F*[fnCuts];
 544    hESDEposEnegPsiPairDPhi         = new TH2F*[fnCuts];
 545    hESDEposEnegInvMassPt           = new TH2F*[fnCuts];
 546    hESDEposEnegLikeSignBackInvMassPt = new TH2F*[fnCuts];
 547    hESDConvGammaZR                 = new TH2F*[fnCuts];
 548
 549    }
 550
 551
 552
 553    hESDMotherInvMassPt             = new TH2F*[fnCuts];
 554
 555    if(fDoChicAnalysis) {
 556    hESDPi0MotherInvMassPt          = new TH2F*[fnCuts];
 557    hESDPi0MotherDiffInvMassPt      = new TH2F*[fnCuts];
 558    hESDPi0MotherDiffLimInvMassPt   = new TH2F*[fnCuts];
 559    }
 560
 561
 562    hESDMotherBackInvMassPt         = new TH2F*[fnCuts];
 563
 564
 565    for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 566
 567
 568       TString cutstringElectron =((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
 569       TString cutstringMeson= ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
 570       TString cutstringGamma = ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
 571
 572       fCutFolder[iCut] = new TList();
 573       fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
 574       fCutFolder[iCut]->SetOwner(kTRUE);
 575       fOutputContainer->Add(fCutFolder[iCut]);
 576
 577       fESDList[iCut] = new TList();
 578       fESDList[iCut]->SetName(Form("%s_%s_%s ESD histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
 579       fESDList[iCut]->SetOwner(kTRUE);
 580
 581
 582       hNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
 583       hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
 584       hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
 585       hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
 586       hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
 587       hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
 588       hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
 589       hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
 590       hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
 591       hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
 592       fESDList[iCut]->Add(hNEvents[iCut]);
 593
 594
 595
 596       if(fIsHeavyIon) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",3000,0,3000);
 597       else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
 598       fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
 599
 600       hEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
 601       fESDList[iCut]->Add(hEtaShift[iCut]);
 602
 603       hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
 604       fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
 605
 606       hESDConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",600,-1.5,1.5);
 607       fESDList[iCut]->Add(hESDConvGammaEta[iCut]);
 608
 609       hESDDalitzElectronPt[iCut] = new TH1F("ESD_DalitzElectron_Pt","ESD_DalitzElectron_Pt",1000,0,25);
 610       fESDList[iCut]->Add(hESDDalitzElectronPt[iCut]);
 611
 612       hESDDalitzPositronPt[iCut] = new TH1F("ESD_DalitzPositron_Pt","ESD_DalitzPositron_Pt",1000,0,25);
 613       fESDList[iCut]->Add(hESDDalitzPositronPt[iCut]);
 614
 615
 616       hESDDalitzElectronPhi[iCut] = new TH1F("ESD_DalitzElectron_Phi","ESD_DalitzElectron_Phi",360,0,2*TMath::Pi());
 617       fESDList[iCut]->Add(hESDDalitzElectronPhi[iCut]);
 618
 619       hESDDalitzPositronPhi[iCut] = new TH1F("ESD_DalitzPositron_Phi","ESD_DalitzPositron_Phi",360,0,2*TMath::Pi());
 620       fESDList[iCut]->Add(hESDDalitzPositronPhi[iCut]);
 621
 622
 623
 624       if ( fDoMesonQA ) {
 625
 626       fQAFolder[iCut] = new TList();
 627       fQAFolder[iCut]->SetName(Form("%s_%s_%s QA histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
 628       fQAFolder[iCut]->SetOwner(kTRUE);
 629
 630
 631
 632       //const Int_t kDCABins=62;
 633       //Double_t binsDCADummy[63]={-3.0,-2.7,-2.4,-2.1,-1.8,-1.5,-1.2,-0.9,-0.6,-0.3,-0.25,-0.2,-0.19,-0.18,-0.17,-0.16,-0.15,-0.14,-0.13,-0.12,-0.11,-0.10,-0.09,-0.08,-0.07,-0.06,-0.05,-0.04,-0.03,-0.02,-0.01,0.0,0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.1,0.11,0.12,0.13,0.14,0.15,0.16,0.17,0.18,0.19,0.2,0.25,0.3,0.6,0.9,1.2,1.5,1.8,2.1,2.4,2.7,3.0};
 634
 635       const Int_t kPtBins=110;
 636       Double_t binsPtDummy[kPtBins+1];
 637       const Int_t kPBins = 109;
 638       Double_t binsPDummy[kPBins+1];
 639       binsPtDummy[0]=0.0;
 640       binsPDummy[0]=0.05;
 641
 642         for(Int_t i=1;i<kPtBins+1;i++)
 643         {
 644                 if(binsPtDummy[i-1]+0.05<1.01)
 645                         binsPtDummy[i]=binsPtDummy[i-1]+0.05;
 646                 else
 647                         binsPtDummy[i]=binsPtDummy[i-1]+0.1;
 648
 649         }
 650         for(Int_t i=1; i<kPBins+1;i++){
 651
 652                   if( binsPDummy[i-1]+0.05<1.01)
 653                         binsPDummy[i] = binsPDummy[i-1]+0.05;
 654                   else
 655                         binsPDummy[i] = binsPDummy[i-1]+0.1;
 656
 657         }
 658
 659
 660
 661       hESDConvGammaZR[iCut]= new TH2F("ESD_ConvGamma_ConversionPoint_ZR","ESD_ConvGamma_ConversionPoint_ZR",1200,-150,150,480,0,120);
 662       fQAFolder[iCut]->Add(hESDConvGammaZR[iCut]);
 663
 664       hESDDalitzElectronAfterPt[iCut] = new TH1F("ESD_DalitzElectron_After_Pt","ESD_DalitzElectron_After_Pt",1000,0,25);
 665       fQAFolder[iCut]->Add(hESDDalitzElectronAfterPt[iCut]);
 666
 667       hESDDalitzPositronAfterPt[iCut] = new TH1F("ESD_DalitzPositron_After_Pt","ESD_DalitzPositron_After_Pt",1000,0,25);
 668       fQAFolder[iCut]->Add(hESDDalitzPositronAfterPt[iCut]);
 669
 670       hESDDalitzElectronAfterEta[iCut] = new TH1F("ESD_DalitzElectron_After_Eta","ESD_DalitzElectron_After_Eta",600,-1.5,1.5);
 671       fQAFolder[iCut]->Add(hESDDalitzElectronAfterEta[iCut]);
 672
 673       hESDDalitzPositronAfterEta[iCut] = new TH1F("ESD_DalitzPositron_After_Eta","ESD_DalitzElectron_After_Eta",600,-1.5,1.5);
 674       fQAFolder[iCut]->Add(hESDDalitzPositronAfterEta[iCut]);
 675
 676
 677       hESDDalitzElectronAfterPhi[iCut] = new TH1F("ESD_DalitzElectron_After_Phi","ESD_DalitzElectron_After_Phi",360,0,2*TMath::Pi());
 678       fQAFolder[iCut]->Add(hESDDalitzElectronAfterPhi[iCut]);
 679
 680       hESDDalitzPositronAfterPhi[iCut] = new TH1F("ESD_DalitzPositron_After_Phi","ESD_DalitzPositron_After_Phi",360,0,2*TMath::Pi());
 681       fQAFolder[iCut]->Add(hESDDalitzPositronAfterPhi[iCut]);
 682
 683       hESDDalitzElectronAfterNClsITS[iCut]  = new TH1F("ESD_DalitzElectron_After_NClsITS","ESD_DalitzElectron_After_NClsITS",7,0.,7.);
 684       fQAFolder[iCut]->Add(hESDDalitzElectronAfterNClsITS[iCut]);
 685
 686       hESDDalitzPositronAfterNClsITS[iCut]  = new TH1F("ESD_DalitzPositron_After_NClsITS","ESD_DalitzPositron_After_NClsITS",7,0.,7.);
 687       fQAFolder[iCut]->Add(hESDDalitzPositronAfterNClsITS[iCut]);
 688
 689
 690       hESDDalitzElectronAfterNFindClsTPC[iCut]  = new TH2F("ESD_DalitzElectron_After_NFindClsTPC","ESD_DalitzElectron_After_NFindClsTPC",60,0,1.5,kPtBins,binsPtDummy);
 691       fQAFolder[iCut]->Add(hESDDalitzElectronAfterNFindClsTPC[iCut]);
 692
 693       hESDDalitzPositronAfterNFindClsTPC[iCut]  = new TH2F("ESD_DalitzPositron_After_NFindClsTPC","ESD_DalitzPositron_After_NFindClsTPC",60,0,1.5,kPtBins,binsPtDummy);
 694       fQAFolder[iCut]->Add(hESDDalitzPositronAfterNFindClsTPC[iCut]);
 695
 696
 697       hESDDalitzElectronAfterNClsTPC[iCut]  = new TH2F("ESD_DalitzElectron_After_NClsTPC","ESD_DalitzElectron_After_NClsTPC",200,0,200,kPtBins,binsPtDummy);
 698       fQAFolder[iCut]->Add(hESDDalitzElectronAfterNClsTPC[iCut]);
 699
 700       hESDDalitzPositronAfterNClsTPC[iCut]  = new TH2F("ESD_DalitzPositron_After_NClsTPC","ESD_DalitzPositron_After_NClsTPC",200,0,200,kPtBins,binsPtDummy);
 701       fQAFolder[iCut]->Add(hESDDalitzPositronAfterNClsTPC[iCut]);
 702
 703       hESDDalitzPositronAfterNCrossedRowsTPC[iCut] =  new TH2F("ESD_DalitzPositron_After_NCrossedRowsTPC","ESD_DalitzPositron_After_NCrossedRowsTPC",165,-0.5,164.5,kPtBins,binsPtDummy);
 704       fQAFolder[iCut]->Add(hESDDalitzPositronAfterNCrossedRowsTPC[iCut]);
 705
 706       hESDDalitzElectronAfterNCrossedRowsTPC[iCut] =  new TH2F("ESD_DalitzElectron_After_NCrossedRowsTPC","ESD_DalitzElectron_After_NCrossedRowsTPC",165,-0.5,164.5,kPtBins,binsPtDummy);
 707       fQAFolder[iCut]->Add(hESDDalitzElectronAfterNCrossedRowsTPC[iCut]);
 708
 709       hESDDalitzPosEleAfterDCAxy[iCut] = new TH2F("ESD_DalitzPosEle_After_DCAxy","ESD_DalitzPosEle_After_DCAxy",124,-0.62,0.62,kPtBins,binsPtDummy);
 710       fQAFolder[iCut]->Add(hESDDalitzPosEleAfterDCAxy[iCut]);
 711
 712       hESDDalitzPosEleAfterDCAz[iCut]  = new TH2F("ESD_DalitzPosEle_After_DCAz","ESD_DalitzPosEle_After_DCAz",200,-1.0,1.0,kPtBins,binsPtDummy);
 713       fQAFolder[iCut]->Add(hESDDalitzPosEleAfterDCAz[iCut]);
 714
 715       hESDDalitzElectronAfterTPCdEdxVsP[iCut] = new TH2F("ESD_DalitzElectron_After_TPCdEdxVsP","ESD_DalitzElectron_After_TPCdEdxVsP_After_TPCdEdx",kPBins,binsPDummy,200,-10,10);
 716       fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxVsP[iCut]);
 717
 718       hESDDalitzPositronAfterTPCdEdxVsP[iCut] = new TH2F("ESD_DalitzPositron_After_TPCdEdxVsP","ESD_DalitzPositron_After_TPCdEdxVsP",kPBins,binsPDummy,200,-10,10);
 719       fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxVsP[iCut]);
 720
 721       hESDDalitzElectronAfterTPCdEdxSignalVsP[iCut] =new TH2F("ESD_DalitzElectron_After_TPCdEdxSignalVsP","ESD_DalitzElectron_After_TPCdEdxSignalVsP" ,kPBins,binsPDummy,200,0.0,200);
 722       fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxSignalVsP[iCut]);
 723
 724       hESDDalitzPositronAfterTPCdEdxSignalVsP[iCut] =new TH2F("ESD_DalitzPositron_After_TPCdEdxSignalVsP","ESD_DalitzPositron_After_TPCdEdxSignalVsP" ,kPBins,binsPDummy,200,0.0,200);
 725       fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxSignalVsP[iCut]);
 726
 727       hESDDalitzElectronAfterTPCdEdxVsEta[iCut] = new TH2F("ESD_DalitzElectron_After_TPCdEdxVsEta","ESD_DalitzElectron_After_TPCdEdxVsEta",140,-1.4,1.4,200,-10,10);
 728       fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxVsEta[iCut]);
 729
 730       hESDDalitzPositronAfterTPCdEdxVsEta[iCut] = new  TH2F("ESD_DalitzPositron_After_TPCdEdxVsEta","ESD_DalitzPositron_After_TPCdEdxVsEta",140,-1.4,1.4,200,-10,10);
 731       fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxVsEta[iCut]);
 732
 733       hESDDalitzElectronAfterTPCdEdxVsPhi[iCut] = new TH2F("ESD_DalitzElectron_After_TPCdEdxVsPhi","ESD_DalitzElectron_After_TPCdEdxVsPhi",180,0,2*TMath::Pi(),200,-10,10);
 734       fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxVsPhi[iCut]);
 735
 736       hESDDalitzPositronAfterTPCdEdxVsPhi[iCut] = new TH2F("ESD_DalitzPositron_After_TPCdEdxVsPhi","ESD_DalitzPositron_After_TPCdEdxVsPhi",180,0,2*TMath::Pi(),200,-10,10);
 737       fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxVsPhi[iCut]);
 738
 739       hESDMotherPhi[iCut] = new TH1F("ESD_DalitzMother_Phi","ESD_DalitzMother_Phi",360,0,2*TMath::Pi());
 740       fQAFolder[iCut]->Add(hESDMotherPhi[iCut]);
 741
 742       hESDEposEnegPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_PsiPair_DPhi","ESD_EposEneg_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
 743       fQAFolder[iCut]->Add(hESDEposEnegPsiPairDPhi[iCut]);
 744
 745       hESDEposEnegInvMassPt[iCut] = new TH2F("ESD_EposEneg_InvMassPt","ESD_EposEneg_InvMassPt",5000,0.,5.,100,0.,10.);
 746       fQAFolder[iCut]->Add(hESDEposEnegInvMassPt[iCut]);
 747
 748       hESDEposEnegLikeSignBackInvMassPt[iCut]  = new TH2F("ESD_EposEneg_LikeSignBack_InvMassPt","ESD_EposEneg_LikeSignBack_InvMassPt",5000,0.,5.,100,0.,10.);
 749       fQAFolder[iCut]->Add(hESDEposEnegLikeSignBackInvMassPt[iCut]);
 750
 751
 752       TAxis *AxisAfter = hESDDalitzElectronAfterTPCdEdxVsP[iCut]->GetXaxis();
 753       Int_t bins = AxisAfter->GetNbins();
 754       Double_t from = AxisAfter->GetXmin();
 755       Double_t to = AxisAfter->GetXmax();
 756       Double_t *newBins = new Double_t[bins+1];
 757       newBins[0] = from;
 758       Double_t factor = TMath::Power(to/from, 1./bins);
 759       for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];
 760
 761       AxisAfter->Set(bins, newBins);
 762       AxisAfter = hESDDalitzElectronAfterTPCdEdxSignalVsP[iCut]->GetXaxis();
 763       AxisAfter->Set(bins, newBins);
 764
 765       AxisAfter = hESDDalitzPositronAfterTPCdEdxVsP[iCut]->GetXaxis();
 766       AxisAfter->Set(bins, newBins);
 767
 768       AxisAfter = hESDDalitzPositronAfterTPCdEdxSignalVsP[iCut]->GetXaxis();
 769       AxisAfter->Set(bins,newBins);
 770
 771
 772
 773       delete [] newBins;
 774
 775       fCutFolder[iCut]->Add(fQAFolder[iCut]);
 776
 777
 778
 779       }
 780
 781
 782
 783
 784
 785       hESDMotherInvMassPt[iCut] = new TH2F("ESD_DalitzMother_InvMass_Pt","ESD_DalitzMother_InvMass_Pt",800,0,0.8,250,0,25);
 786       fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
 787
 788
 789       if( fDoChicAnalysis) {
 790
 791       hESDPi0MotherInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_InvMass_Pt","ESD_Pi0Mother_InvMass_Pt",4000,0,4,250,0,25);
 792       fESDList[iCut]->Add(hESDPi0MotherInvMassPt[iCut]);
 793
 794       hESDPi0MotherDiffInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffInvMass_Pt","ESD_Pi0Mother_DiffInvMass_Pt",2000,0,2,250,0,25);
 795       fESDList[iCut]->Add(hESDPi0MotherDiffInvMassPt[iCut]);
 796
 797       hESDPi0MotherDiffLimInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffLimInvMass_Pt","ESD_Pi0Mother_DiffLimInvMass_Pt",2000,0,2,250,0,25);
 798       fESDList[iCut]->Add(hESDPi0MotherDiffLimInvMassPt[iCut]);
 799
 800       }
 801
 802
 803       hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_DalitzBackground_InvMass_Pt","ESD_DalitzBackground_InvMass_Pt",800,0,0.8,250,0,25);
 804       fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
 805
 806
 807
 808       fCutFolder[iCut]->Add(fESDList[iCut]);
 809
 810
 811
 812    }
 813
 814
 815    InitBack(); // Init Background Handler
 816
 817
 818    //if(MCEvent()){
 819     if( fIsMC ){
 820       // MC Histogramms
 821       fMCList = new TList*[fnCuts];
 822       // True Histogramms
 823       fTrueList = new TList*[fnCuts];
 824       hESDTrueConvGammaPt = new TH1F*[fnCuts];
 825       hESDTruePositronPt  = new TH1F*[fnCuts];
 826       hESDTrueElectronPt  = new TH1F*[fnCuts];
 827       hESDTrueSecConvGammaPt = new TH1F*[fnCuts];
 828       hESDTrueSecPositronPt  = new TH1F*[fnCuts];
 829       hESDTrueSecElectronPt  = new TH1F*[fnCuts];
 830       hESDTruePi0DalitzConvGammaPt = new TH1F*[fnCuts];
 831       hESDTruePi0DalitzPositronPt  = new TH1F*[fnCuts];
 832       hESDTruePi0DalitzElectronPt  = new TH1F*[fnCuts];
 833       hESDTruePi0DalitzSecConvGammaPt = new TH1F*[fnCuts];
 834       hESDTruePi0DalitzSecPositronPt  = new TH1F*[fnCuts];
 835       hESDTruePi0DalitzSecElectronPt  = new TH1F*[fnCuts];
 836       //if(fDoMesonAnalysis){
 837       hMCAllGammaPt  = new TH1F*[fnCuts];
 838       hMCConvGammaPt = new TH1F*[fnCuts];
 839       hMCConvGammaRSPt = new TH1F*[fnCuts];
 840       hMCAllPositronsPt = new TH1F*[fnCuts];
 841       hMCAllElectronsPt = new TH1F*[fnCuts];
 842
 843       if( fDoMesonQA ) {
 844
 845         hMCConvGammaEta    = new TH1F*[fnCuts];
 846         hMCAllPositronsEta = new TH1F*[fnCuts];
 847         hMCAllElectronsEta = new TH1F*[fnCuts];
 848
 849       }
 850       hMCPi0DalitzGammaPt    = new TH1F*[fnCuts];
 851       hMCPi0DalitzElectronPt = new TH1F*[fnCuts];
 852       hMCPi0DalitzPositronPt = new TH1F*[fnCuts];
 853
 854       hMCPi0Pt = new TH1F*[fnCuts];
 855       hMCPi0GGPt =  new TH1F*[fnCuts];
 856       hMCEtaPt = new TH1F*[fnCuts];
 857       hMCEtaGGPt = new TH1F*[fnCuts];
 858       hMCPi0InAccPt = new TH1F*[fnCuts];
 859       hMCEtaInAccPt = new TH1F*[fnCuts];
 860                         hMCChiCPt = new TH1F*[fnCuts];
 861                         hMCChiCInAccPt = new TH1F*[fnCuts];
 862
 863
 864       if ( fDoMesonQA ) {
 865
 866         hMCPi0EposEnegInvMassPt                      = new TH2F*[fnCuts];
 867         hMCEtaEposEnegInvMassPt                      = new TH2F*[fnCuts];
 868
 869         hESDEposEnegTruePi0DalitzInvMassPt           = new TH2F*[fnCuts];
 870         hESDEposEnegTruePrimPi0DalitzInvMass         = new TH1F*[fnCuts];
 871         hESDEposEnegTruePi0DalitzPsiPairDPhi         = new TH2F*[fnCuts];
 872         hESDEposEnegTrueEtaDalitzInvMassPt           = new TH2F*[fnCuts];
 873         hESDEposEnegTruePrimEtaDalitzInvMass         = new TH1F*[fnCuts];
 874         hESDEposEnegTrueEtaDalitzPsiPairDPhi         = new TH2F*[fnCuts];
 875         hESDEposEnegTruePhotonInvMassPt              = new TH2F*[fnCuts];
 876         hESDEposEnegTrueInvMassPt                    = new TH2F*[fnCuts];
 877         hESDEposEnegTruePhotonPsiPairDPhi            = new TH2F*[fnCuts];
 878         hESDEposEnegTrueJPsiInvMassPt                = new TH2F*[fnCuts];
 879       }
 880
 881
 882       if( fDoChicAnalysis ){
 883       hESDTrueMotherChiCInvMassPt = new TH2F*[fnCuts];
 884       hESDTrueMotherChiCDiffInvMassPt = new TH2F*[fnCuts];
 885       }
 886
 887
 888       hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
 889       hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
 890       hESDTrueMotherPi0GGInvMassPt = new TH2F*[fnCuts];
 891       hESDTruePrimaryMotherPi0GGInvMassPt = new TH2F*[fnCuts];
 892       hESDTrueSecondaryMotherPi0GGInvMassPt = new TH2F*[fnCuts];
 893       hESDTruePrimaryPi0DalitzESDPtMCPt = new TH2F*[fnCuts];
 894       hESDTruePrimaryMotherInvMassMCPt = new TH2F*[fnCuts];
 895       hESDTruePrimaryMotherInvMassPt   = new TH2F*[fnCuts];
 896       hESDTruePrimaryMotherW0WeightingInvMassPt = new TH2F*[fnCuts];
 897       hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
 898       hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
 899       hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
 900       hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
 901       hESDTrueMotherGGInvMassPt = new TH2F*[fnCuts];
 902       //}
 903
 904       for(Int_t iCut = 0; iCut<fnCuts;iCut++){
 905          TString cutstringElectron =((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
 906          TString cutstringMeson= ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
 907          TString cutstringGamma = ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
 908
 909          fMCList[iCut] = new TList();
 910          fMCList[iCut]->SetName(Form("%s_%s_%s MC histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
 911          fMCList[iCut]->SetOwner(kTRUE);
 912          fCutFolder[iCut]->Add(fMCList[iCut]);
 913
 914
 915         hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
 916         fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
 917
 918         hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
 919         fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
 920
 921
 922         hMCConvGammaRSPt[iCut] = new TH1F("MC_ConvGamma_RS_Pt","MC_ConvGamma_RS_Pt",250,0,25);
 923         fMCList[iCut]->Add(hMCConvGammaRSPt[iCut]);
 924
 925
 926         hMCAllPositronsPt[iCut] = new TH1F("MC_AllPositrons_Pt","MC_AllPositrons_Pt",1000,0,25);
 927         fMCList[iCut]->Add(hMCAllPositronsPt[iCut]);
 928
 929                                  hMCAllElectronsPt[iCut] = new TH1F("MC_AllElectrons_Pt","MC_AllElectrons_Pt",1000,0,25);
 930                                  fMCList[iCut]->Add(hMCAllElectronsPt[iCut]);
 931
 932                                  hMCPi0DalitzGammaPt[iCut] = new TH1F("MC_Pi0DalitzGamma_Pt","MC_Pi0DalitzGamma_Pt",250,0,25);
 933                                  hMCPi0DalitzGammaPt[iCut]->Sumw2();
 934                                  fMCList[iCut]->Add(hMCPi0DalitzGammaPt[iCut]);
 935
 936                                  if ( fDoMesonQA ){
 937
 938                                   hMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",600,-1.5,1.5);
 939                                   fMCList[iCut]->Add(hMCConvGammaEta[iCut]);
 940
 941                                   hMCAllPositronsEta[iCut] = new TH1F("MC_AllPositrons_Eta","MC_AllPositrons_Eta",600,-1.5,1.5);
 942                                   fMCList[iCut]->Add(hMCAllPositronsEta[iCut]);
 943
 944                                   hMCAllElectronsEta[iCut] = new TH1F("MC_AllElectrons_Eta","MC_AllElectrons_Eta",600,-1.5,1.5);
 945                                   fMCList[iCut]->Add(hMCAllElectronsEta[iCut]);
 946
 947
 948                                  }
 949
 950
 951                                  hMCPi0DalitzPositronPt[iCut] = new TH1F("MC_Pi0DalitzPositron_Pt","MC_Pi0DalitzPositron_Pt",1000,0,25);
 952                                  hMCPi0DalitzPositronPt[iCut]->Sumw2();
 953                                  fMCList[iCut]->Add(hMCPi0DalitzPositronPt[iCut]);
 954
 955                                  hMCPi0DalitzElectronPt[iCut] = new TH1F("MC_Pi0DalitzElectron_Pt","MC_Pi0DalitzElectron_Pt",1000,0,25);
 956                                  hMCPi0DalitzElectronPt[iCut]->Sumw2();
 957                                  fMCList[iCut]->Add(hMCPi0DalitzElectronPt[iCut]);
 958
 959
 960                                  hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
 961                                  hMCPi0Pt[iCut]->Sumw2();
 962                                  fMCList[iCut]->Add(hMCPi0Pt[iCut]);
 963
 964                                  hMCPi0GGPt[iCut] = new TH1F("MC_Pi0_GG_Pt","MC_Pi0_GG_Pt",250,0,25);
 965                                  hMCPi0GGPt[iCut]->Sumw2();
 966                                  fMCList[iCut]->Add(hMCPi0GGPt[iCut]);
 967
 968                                  hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
 969                                  hMCEtaPt[iCut]->Sumw2();
 970                                  fMCList[iCut]->Add(hMCEtaPt[iCut]);
 971
 972                                  hMCEtaGGPt[iCut] = new TH1F("MC_Eta_GG_Pt","MC_Eta_GG_Pt",250,0,25);
 973                                  hMCEtaGGPt[iCut]->Sumw2();
 974                                  fMCList[iCut]->Add(hMCEtaGGPt[iCut]);
 975
 976                                  hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0DalitzInAcc_Pt","MC_Pi0DalitzInAcc_Pt",250,0,25);
 977                                  hMCPi0InAccPt[iCut]->Sumw2();
 978                                  fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
 979
 980                                  hMCEtaInAccPt[iCut] = new TH1F("MC_EtaDalitzInAcc_Pt","MC_EtaDalitzInAcc_Pt",250,0,25);
 981                                  hMCEtaInAccPt[iCut]->Sumw2();
 982                                  fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
 983
 984
 985
 986                                  hMCChiCPt[iCut] = new TH1F("MC_ChiC_Pt","MC_ChiC_Pt",250,0,25);
 987                                  fMCList[iCut]->Add(hMCChiCPt[iCut]);
 988
 989                                  hMCChiCInAccPt[iCut] = new TH1F("MC_ChiCInAcc_Pt","MC_ChiCInAcc_Pt",250,0,25);
 990                                  fMCList[iCut]->Add(hMCChiCInAccPt[iCut]);
 991
 992                                   if ( fDoMesonQA ) {
 993
 994                                   hMCPi0EposEnegInvMassPt[iCut] = new TH2F("MC_Pi0EposEneg_InvMassPt","MC_Pi0EposEneg_InvMassPt",500,0.,0.5,100,0.,10.);
 995                                   fMCList[iCut]->Add(hMCPi0EposEnegInvMassPt[iCut]);
 996
 997                                   hMCEtaEposEnegInvMassPt[iCut] = new TH2F("MC_EtaEposEneg_InvMassPt","MC_EtaEposEneg_InvMassPt",800,0.,0.8,100,0.,10.);
 998                                   fMCList[iCut]->Add(hMCEtaEposEnegInvMassPt[iCut]);
 999
1000                                   }
1001
1002
1003
1004          fTrueList[iCut] = new TList();
1005          fTrueList[iCut]->SetName(Form("%s_%s_%s True histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
1006          fTrueList[iCut]->SetOwner(kTRUE);
1007          fCutFolder[iCut]->Add(fTrueList[iCut]);
1008
1009          if ( fDoMesonQA ) {
1010
1011
1012          hESDEposEnegTruePi0DalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_InvMassPt","ESD_EposEneg_TruePi0Dalitz_InvMassPt",500,0.,0.5,100,0.,10.);
1013          fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzInvMassPt[iCut]);
1014
1015          hESDEposEnegTruePrimPi0DalitzInvMass[iCut] = new TH1F("ESD_EposEneg_TruePrimPi0Dalitz_InvMass","ESD_EposEneg_TruePrimPi0Dalitz_InvMass",500,0.,0.5);
1016          fTrueList[iCut]->Add(hESDEposEnegTruePrimPi0DalitzInvMass[iCut]);
1017
1018          hESDEposEnegTruePi0DalitzPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_PsiPair_DPhi","ESD_EposEneg_TruePi0Dalitz_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
1019          fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzPsiPairDPhi[iCut]);
1020
1021
1022          hESDEposEnegTrueEtaDalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueEtaDalitz_InvMassPt","ESD_EposEneg_TrueEtaDalitz_InvMassPt",700,0.,0.7,100,0.,10.);
1023          fTrueList[iCut]->Add(hESDEposEnegTrueEtaDalitzInvMassPt[iCut]);
1024
1025          hESDEposEnegTruePrimEtaDalitzInvMass[iCut] = new TH1F("ESD_EposEneg_TruePrimEtaDalitz_InvMass","ESD_EposEneg_TruePrimEtaDalitz_InvMass",700,0.,0.7);
1026          fTrueList[iCut]->Add(hESDEposEnegTruePrimEtaDalitzInvMass[iCut]);
1027
1028          hESDEposEnegTrueEtaDalitzPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TrueEtaDalitz_PsiPair_DPhi","ESD_EposEneg_TrueEtaDalitz_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
1029          fTrueList[iCut]->Add(hESDEposEnegTrueEtaDalitzPsiPairDPhi[iCut]);
1030
1031          hESDEposEnegTruePhotonInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePhoton_InvMassPt","ESD_EposEneg_TruePhoton_InvMassPt",500,0.,0.5,100,0.,10.);
1032          fTrueList[iCut]->Add(hESDEposEnegTruePhotonInvMassPt[iCut]);
1033
1034          hESDEposEnegTrueInvMassPt[iCut] = new TH2F("ESD_EposEneg_True_InvMassPt","ESD_EposEneg_True_InvMassPt",5000,0.,5.,100,0.,10.);
1035          fTrueList[iCut]->Add(hESDEposEnegTrueInvMassPt[iCut]);
1036
1037          hESDEposEnegTruePhotonPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TruePhoton_PsiPair_DPhi","ESD_EposEneg_TruePhoton_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
1038          fTrueList[iCut]->Add(hESDEposEnegTruePhotonPsiPairDPhi[iCut]);
1039
1040          hESDEposEnegTrueJPsiInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueJPsi_InvMassPt","ESD_EposEneg_TrueJPsi_InvMassPt",5000,0.,5.,100,0.,10.);
1041          fTrueList[iCut]->Add(hESDEposEnegTrueJPsiInvMassPt[iCut]);
1042
1043
1044
1045          }
1046
1047
1048          hESDTruePositronPt[iCut] = new TH1F("ESD_TruePositron_Pt","ESD_TruePositron_Pt",1000,0,25);
1049          fTrueList[iCut]->Add(hESDTruePositronPt[iCut]);
1050
1051          hESDTrueElectronPt[iCut] = new TH1F("ESD_TrueElectron_Pt","ESD_TrueElectron_Pt",1000,0,25);
1052          fTrueList[iCut]->Add(hESDTrueElectronPt[iCut]);
1053
1054          hESDTrueSecPositronPt[iCut] = new TH1F("ESD_TrueSecPositron_Pt","ESD_TrueSecPositron_Pt",1000,0,25);
1055          fTrueList[iCut]->Add(hESDTrueSecPositronPt[iCut]);
1056
1057          hESDTrueSecElectronPt[iCut] = new TH1F("ESD_TrueSecElectron_Pt","ESD_TrueSecElectron_Pt",1000,0,25);
1058          fTrueList[iCut]->Add(hESDTrueSecElectronPt[iCut]);
1059
1060          hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
1061          fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
1062
1063          hESDTrueSecConvGammaPt[iCut] = new TH1F("ESD_TrueSecConvGamma_Pt","ESD_TrueSecConvGamma_Pt",250,0,25);
1064          fTrueList[iCut]->Add(hESDTrueSecConvGammaPt[iCut]);
1065
1066          hESDTruePi0DalitzConvGammaPt[iCut] = new TH1F("ESD_TruePi0DalitzConvGamma_Pt","ESD_TruePi0DalitzConvGamma_Pt",250,0,25);
1067          fTrueList[iCut]->Add(hESDTruePi0DalitzConvGammaPt[iCut]);
1068
1069          hESDTruePi0DalitzElectronPt[iCut] = new TH1F("ESD_TruePi0DalitzElectron_Pt","ESD_TruePi0DalitzElectron_Pt",1000,0,25);
1070          fTrueList[iCut]->Add(hESDTruePi0DalitzElectronPt[iCut]);
1071
1072          hESDTruePi0DalitzPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzPositron_Pt","ESD_TruePi0DalitzPositron_Pt",1000,0,25);
1073          fTrueList[iCut]->Add(hESDTruePi0DalitzPositronPt[iCut]);
1074
1075          hESDTruePi0DalitzSecConvGammaPt[iCut] = new TH1F("ESD_TruePi0DalitzSecConvGamma_Pt","ESD_TruePi0DalitzSecConvGamma_Pt",250,0,25);
1076          fTrueList[iCut]->Add(hESDTruePi0DalitzSecConvGammaPt[iCut]);
1077
1078          hESDTruePi0DalitzSecElectronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecElectron_Pt","ESD_TruePi0DalitzSecElectron_Pt",1000,0,25);
1079          fTrueList[iCut]->Add(hESDTruePi0DalitzSecElectronPt[iCut]);
1080
1081          hESDTruePi0DalitzSecPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecPositron_Pt","ESD_TruePi0DalitzSecPositron_Pt",1000,0,25);
1082          fTrueList[iCut]->Add(hESDTruePi0DalitzSecPositronPt[iCut]);
1083
1084          if( fDoChicAnalysis) {
1085
1086          hESDTrueMotherChiCInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiC_InvMass_Pt","ESD_TrueMotherChiC_InvMass_Pt",4000,0,4,250,0,25);
1087          fTrueList[iCut]->Add(hESDTrueMotherChiCInvMassPt[iCut]);
1088
1089          hESDTrueMotherChiCDiffInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiCDiff_InvMass_Pt","ESD_TrueMotherChiCDiff_InvMass_Pt",2000,0,2,250,0,25);
1090          fTrueList[iCut]->Add(hESDTrueMotherChiCDiffInvMassPt[iCut]);
1091
1092          }
1093
1094          hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
1095          hESDTrueMotherInvMassPt[iCut]->Sumw2();
1096          fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
1097
1098          hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueMother_Dalitz_InvMass_Pt","ESD_TrueMother_Dalitz_InvMass_Pt",800,0,0.8,250,0,25);
1099          hESDTrueMotherDalitzInvMassPt[iCut]->Sumw2();
1100          fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
1101
1102
1103
1104
1105
1106          hESDTrueMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueMotherPi0GG_InvMass_Pt","ESD_TrueMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
1107          hESDTrueMotherPi0GGInvMassPt[iCut]->Sumw2();
1108          fTrueList[iCut]->Add(hESDTrueMotherPi0GGInvMassPt[iCut]);
1109
1110          hESDTruePrimaryMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMotherPi0GG_InvMass_Pt","ESD_TruePrimaryMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
1111          hESDTruePrimaryMotherPi0GGInvMassPt[iCut]->Sumw2();
1112          fTrueList[iCut]->Add(hESDTruePrimaryMotherPi0GGInvMassPt[iCut]);
1113
1114          hESDTrueSecondaryMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryMotherPi0GG_InvMass_Pt","ESD_TrueSecondaryMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
1115          hESDTrueSecondaryMotherPi0GGInvMassPt[iCut]->Sumw2();
1116          fTrueList[iCut]->Add(hESDTrueSecondaryMotherPi0GGInvMassPt[iCut]);
1117
1118          hESDTruePrimaryPi0DalitzESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt","ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt",250,0,25,250,0,25);
1119          hESDTruePrimaryPi0DalitzESDPtMCPt[iCut]->Sumw2();
1120          fTrueList[iCut]->Add(hESDTruePrimaryPi0DalitzESDPtMCPt[iCut]);
1121          hESDTruePrimaryMotherInvMassMCPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_MCPt","ESD_TrueDalitzPrimaryMother_InvMass_MCPt",800,0,0.8,250,0,25);
1122          hESDTruePrimaryMotherInvMassMCPt[iCut]->Sumw2();
1123          fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassMCPt[iCut]);
1124          hESDTruePrimaryMotherInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_Pt","ESD_TruePrimaryMother_InvMass_Pt",800,0,0.8,250,0,25);
1125          hESDTruePrimaryMotherInvMassPt[iCut]->Sumw2();
1126          fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassPt[iCut]);
1127          hESDTruePrimaryMotherW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMotherW0Weighting_InvMass_Pt","ESD_TruePrimaryMotherW0Weighting_InvMass_Pt",800,0,0.8,250,0,25);
1128          hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]->Sumw2();
1129          fTrueList[iCut]->Add(hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]);
1130
1131          hESDTrueSecondaryMotherInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMother_InvMass_Pt","ESD_TrueDalitzSecondaryMother_InvMass_Pt",800,0,0.8,250,0,25);
1132          hESDTrueSecondaryMotherInvMassPt[iCut]->Sumw2();
1133          fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
1134          //                             hESDTrueSecondaryMotherFromK0sInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt",1000,0,1,250,0,25);
1135          //                             fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
1136          hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckGG_InvMass_Pt","ESD_TrueDalitzBckGG_InvMass_Pt",800,0,0.8,250,0,25);
1137          fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
1138          hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckCont_InvMass_Pt","ESD_TrueDalitzBckCont_InvMass_Pt",800,0,0.8,250,0,25);
1139          fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
1140          //                             hESDTrueMotherGGInvMassPt[iCut] = new TH2F("ESD_TrueGammaGamma_InvMass_Pt","ESD_TrueGammaGamma_InvMass_Pt",1000,0,1,250,0,25);
1141          //                             fTrueList[iCut]->Add(hESDTrueMotherGGInvMassPt[iCut]);
1142
1143       }
1144    }
1145
1146    fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1147    if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1148
1149    if(fV0Reader)
1150       if((AliConversionCuts*)fV0Reader->GetConversionCuts())
1151          if(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1152             fOutputContainer->Add(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1153
1154
1155
1156    fElecSelector=(AliDalitzElectronSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("ElectronSelector");
1157    if(!fElecSelector){printf("Error: No ElectronSelector");return;} // GetV0Reader
1158
1159     if( fElecSelector ){
1160
1161       if ( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() ){
1162          fOutputContainer->Add( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() );
1163       }
1164    }
1165
1166    for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1167
1168       if( fCutElectronArray ){
1169          if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() ) {
1170             fCutFolder[iCut]->Add( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() );
1171          }
1172       }
1173
1174       if( fCutMesonArray  ) {
1175          if( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms() ) {
1176             fCutFolder[iCut]->Add( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms());
1177          }
1178       }
1179
1180       if( fCutGammaArray ) {
1181          if( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() ) {
1182             fCutFolder[iCut]->Add( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutHistograms()  );
1183          }
1184       }
1185    }
1186
1187    PostData(1, fOutputContainer);
1188
1189 }
1190
1191 //______________________________________________________________________
1192 void AliAnalysisTaskGammaConvDalitzV1::UserExec(Option_t *)
1193 {
1194
1195    //
1196    // Execute analysis for current event
1197    //
1198
1199    fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1200    if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1201
1202
1203    Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
1204
1205    if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1206         for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1207            hNEvents[iCut]->Fill(eventQuality);
1208         }
1209       return;
1210    }
1211
1212
1213    fElecSelector=(AliDalitzElectronSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("ElectronSelector");
1214    if(!fElecSelector){printf("Error: No ElectronSelector");return;} // GetV0Reader
1215
1216
1217    if(fIsMC)          fMCEvent        =  MCEvent();
1218    fESDEvent        = (AliESDEvent*)InputEvent();
1219    fReaderGammas    = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
1220    fSelectorElectronIndex = fElecSelector->GetReconstructedElectronsIndex(); // Electrons from default Cut
1221    fSelectorPositronIndex = fElecSelector->GetReconstructedPositronsIndex(); // Positrons from default Cut
1222
1223    //CountESDTracks(); // Estimate Event Multiplicity
1224    fNumberOfESDTracks = fV0Reader->GetNumberOfPrimaryTracks();
1225    //AddTaskContainers(); //Add conatiner
1226
1227    for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1228       fiCut = iCut;
1229
1230       Int_t eventNotAccepted =
1231          ((AliConversionCuts*)fCutGammaArray->At(iCut))
1232          ->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
1233
1234       if(eventNotAccepted){
1235          //                     cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1236          hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1237          continue;
1238       }
1239
1240       if(eventQuality != 0){// Event Not Accepted
1241          //                     cout << "event rejected due to: " <<eventQuality << endl;
1242          hNEvents[iCut]->Fill(eventQuality);
1243          continue;
1244       }
1245
1246       hNEvents[iCut]->Fill(eventQuality);
1247
1248       hNGoodESDTracks[iCut]->Fill(fNumberOfESDTracks);
1249
1250       if(fMCEvent){ // Process MC Particle
1251
1252
1253
1254         fMCStack = fMCEvent->Stack();
1255
1256           if(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetSignalRejection() != 0){
1257              ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetSignalRejection(),
1258                                                                                      ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetAcceptedHeader(),
1259                                                                                        fMCEvent);
1260           }
1261
1262          ProcessMCParticles();
1263       }
1264
1265       ProcessPhotonCandidates(); // Process this cuts gammas
1266       ProcessElectronCandidates(); // Process this cuts gammas
1267
1268       if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1269
1270             fUnsmearedPx = new Double_t[fGoodGammas->GetEntries()]; // Store unsmeared Momenta
1271             fUnsmearedPy = new Double_t[fGoodGammas->GetEntries()];
1272             fUnsmearedPz = new Double_t[fGoodGammas->GetEntries()];
1273             fUnsmearedE =  new Double_t[fGoodGammas->GetEntries()];
1274
1275             for(Int_t gamma=0;gamma<fGoodGammas->GetEntries();gamma++){ // Smear the AODPhotons in MC
1276
1277                fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Px();
1278                fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Py();
1279                fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Pz();
1280                fUnsmearedE[gamma] =  ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->E();
1281                ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(gamma)));
1282
1283             }
1284         }
1285
1286
1287       CalculatePi0DalitzCandidates();
1288       CalculateBackground();
1289       UpdateEventByEventData();
1290
1291
1292       if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1293
1294            for(Int_t gamma=0;gamma<fGoodGammas->GetEntries();gamma++){ // Smear the AODPhotons in MC
1295                ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1296                ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1297                ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1298                ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetE(fUnsmearedE[gamma]);
1299             }
1300             delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1301             delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1302             delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1303             delete[] fUnsmearedE;  fUnsmearedE  = 0x0;
1304
1305        }
1306
1307
1308       fGoodGammas->Clear(); // delete this cuts good gammas
1309       fGoodVirtualGammas->Clear(); // delete this cuts good gammas
1310    }
1311
1312    fSelectorElectronIndex.clear();
1313    fSelectorPositronIndex.clear();
1314
1315    PostData( 1, fOutputContainer );
1316 }
1317
1318 Bool_t AliAnalysisTaskGammaConvDalitzV1::Notify()
1319 {
1320    for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1321
1322
1323       if( !((AliConversionCuts*)fCutGammaArray->At(iCut))->GetDoEtaShift() ){
1324
1325          /*if (((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() != 0.){
1326             printf("Error: Gamma Conversion Dalitz Task %s :: Eta Shift not requested but set to %f, reset to 00. \n\n",
1327                    (((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift());
1328             ((AliConversionCuts*)fCutGammaArray->At(iCut))->SetEtaShift(0.);
1329             ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift(0.);
1330
1331
1332          }*/
1333          hEtaShift[iCut]->Fill(0.,0.);
1334          continue; // No Eta Shift requested, continue
1335       }
1336
1337
1338       if( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1339          ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
1340          ((AliConversionCuts*)fCutGammaArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1341          ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() );
1342          hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift()));
1343          continue;
1344       }
1345       else{
1346          printf(" Gamma Conversion Dalitz Task %s :: Eta Shift Manually Set to %f \n\n",
1347          (((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift());
1348          ((AliConversionCuts*)fCutGammaArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1349          ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() );
1350           hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift()));
1351       }
1352    }
1353
1354    return kTRUE;
1355 }
1356
1357
1358 void AliAnalysisTaskGammaConvDalitzV1::Terminate(const Option_t *)
1359 {
1360
1361 ///Grid
1362
1363 }
1364 //________________________________________________________________________
1365 void AliAnalysisTaskGammaConvDalitzV1::ProcessPhotonCandidates()
1366 {
1367    Int_t nV0 = 0;
1368    TList *GoodGammasStepOne = new TList();
1369    TList *GoodGammasStepTwo = new TList();
1370    // Loop over Photon Candidates allocated by ReaderV1
1371
1372    for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1373       AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1374       if(!PhotonCandidate) continue;
1375
1376       fIsFromMBHeader = kTRUE;
1377
1378       if( fMCEvent && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0 ){
1379
1380          Int_t isPosFromMBHeader
1381             = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1382          if(isPosFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
1383
1384          Int_t isNegFromMBHeader
1385             = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1386          if(isNegFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
1387
1388          if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1389
1390       }
1391
1392       if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fESDEvent)) continue;
1393
1394       if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut() &&
1395          !((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // if no post reader loop is required add to events good gammas
1396
1397          fGoodGammas->Add(PhotonCandidate);
1398
1399          if(fIsFromMBHeader){
1400               hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1401               hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1402               if( fDoMesonQA ) hESDConvGammaZR[fiCut]->Fill(PhotonCandidate->GetConversionZ(),PhotonCandidate->GetConversionRadius());
1403          }
1404
1405          if(fMCEvent){
1406             ProcessTruePhotonCandidates(PhotonCandidate);
1407          }
1408       }
1409       else if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1410          ((AliConversionCuts*)fCutGammaArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1411          nV0++;
1412          GoodGammasStepOne->Add(PhotonCandidate);
1413       }
1414       else if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut() &&
1415                ((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1416          GoodGammasStepTwo->Add(PhotonCandidate);
1417       }
1418    }
1419
1420
1421    if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut()){
1422       for(Int_t i = 0;i<GoodGammasStepOne->GetEntries();i++){
1423          AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GoodGammasStepOne->At(i);
1424          if(!PhotonCandidate) continue;
1425
1426
1427          fIsFromMBHeader = kTRUE;
1428          if(fMCEvent && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0){
1429             Int_t isPosFromMBHeader
1430                = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack,fInputEvent);
1431             Int_t isNegFromMBHeader
1432                = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1433             if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1434          }
1435
1436
1437          if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GoodGammasStepOne->GetEntries())) continue;
1438          if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1439             fGoodGammas->Add(PhotonCandidate);
1440
1441              if(fIsFromMBHeader){
1442                 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1443                 hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1444                 if( fDoMesonQA )hESDConvGammaZR[fiCut]->Fill(PhotonCandidate->GetConversionZ(),PhotonCandidate->GetConversionRadius());
1445              }
1446
1447             if(fMCEvent){
1448                ProcessTruePhotonCandidates(PhotonCandidate);
1449             }
1450          }
1451          else GoodGammasStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1452       }
1453    }
1454    if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){
1455       for(Int_t i = 0;i<GoodGammasStepTwo->GetEntries();i++){
1456          AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GoodGammasStepTwo->At(i);
1457          if(!PhotonCandidate) continue;
1458
1459          if(fMCEvent && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0){
1460             Int_t isPosFromMBHeader
1461                = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack,fInputEvent);
1462             Int_t isNegFromMBHeader
1463                = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1464             if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1465          }
1466
1467          if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GoodGammasStepTwo,i)) continue;
1468          fGoodGammas->Add(PhotonCandidate); // Add gamma to current cut TList
1469
1470           if(fIsFromMBHeader){
1471               hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt()); // Differences to old V0Reader in p_t due to conversion KF->TLorentzVector
1472               hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1473               if(fDoMesonQA)hESDConvGammaZR[fiCut]->Fill(PhotonCandidate->GetConversionZ(),PhotonCandidate->GetConversionRadius());
1474           }
1475
1476          if(fMCEvent){
1477             ProcessTruePhotonCandidates(PhotonCandidate);
1478          }
1479       }
1480    }
1481
1482    delete GoodGammasStepOne;
1483    GoodGammasStepOne = 0x0;
1484    delete GoodGammasStepTwo;
1485    GoodGammasStepTwo = 0x0;
1486 }
1487
1488 //________________________________________________________________________
1489 void AliAnalysisTaskGammaConvDalitzV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1490 {
1491    // Process True Photons
1492    AliStack *MCStack = fMCEvent->Stack();
1493    TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(MCStack);
1494    TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(MCStack);
1495
1496    if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1497    if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){  // Not Same Mother == Combinatorial Bck
1498       return;
1499    }
1500
1501    else if (posDaughter->GetMother(0) == -1){
1502       return;
1503    }
1504
1505    if(TMath::Abs(posDaughter->GetPdgCode())!=11 || TMath::Abs(negDaughter->GetPdgCode())!=11) return; //One Particle is not electron
1506    if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1507    if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1508
1509    TParticle *Photon = TruePhotonCandidate->GetMCParticle(MCStack);
1510    if(Photon->GetPdgCode() != 22) return; // Mother is no Photon
1511
1512    // True Photon
1513
1514   Int_t labelGamma = TruePhotonCandidate->GetMCParticleLabel(MCStack);
1515
1516   if( labelGamma < MCStack->GetNprimary() ){
1517     if( fIsFromMBHeader ){
1518       hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1519     }
1520   }
1521   else {
1522     if( fIsFromMBHeader){
1523       hESDTrueSecConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1524     }
1525   }
1526
1527   if( IsPi0DalitzDaughter(labelGamma) == kTRUE ) {
1528         if( labelGamma < MCStack->GetNprimary() ) {
1529           if( fIsFromMBHeader ){
1530             hESDTruePi0DalitzConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1531           }
1532         }
1533         else {
1534           if( fIsFromMBHeader ) {
1535             hESDTruePi0DalitzSecConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1536           }
1537         }
1538   }
1539
1540
1541 }
1542
1543 //________________________________________________________________________
1544 void AliAnalysisTaskGammaConvDalitzV1::ProcessElectronCandidates(){
1545
1546    Double_t magField = fInputEvent->GetMagneticField();
1547
1548
1549    if( magField  < 0.0 ){
1550       magField =  1.0;
1551    }
1552    else {
1553       magField =  -1.0;
1554    }
1555
1556
1557    vector<Int_t> lGoodElectronIndexPrev(0);
1558    vector<Int_t> lGoodPositronIndexPrev(0);
1559
1560
1561
1562
1563    for(UInt_t i = 0; i < fSelectorElectronIndex.size(); i++){
1564
1565     AliESDtrack* electronCandidate = fESDEvent->GetTrack(fSelectorElectronIndex[i]);
1566
1567     if( fMCEvent ) {
1568
1569           Int_t labelelectron = TMath::Abs( electronCandidate->GetLabel() );
1570           Int_t isMCFromMBHeader = -1;
1571           if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0) {
1572             isMCFromMBHeader
1573             = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(labelelectron,fMCStack,fInputEvent);
1574             if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
1575           }
1576     }
1577
1578     if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(electronCandidate) ) continue;
1579
1580     lGoodElectronIndexPrev.push_back(   fSelectorElectronIndex[i] );
1581     hESDDalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
1582     hESDDalitzElectronPhi[fiCut]->Fill(electronCandidate->Phi());
1583
1584
1585     if( fMCEvent ) {
1586
1587           Int_t labelelectron = TMath::Abs( electronCandidate->GetLabel() );
1588             if( labelelectron < fMCStack->GetNtrack() ){
1589               TParticle* electron = fMCStack->Particle(labelelectron);
1590                 if( electron->GetPdgCode() ==  11 ){
1591                     if( labelelectron < fMCStack->GetNprimary() ){
1592                       hESDTrueElectronPt[fiCut]->Fill(electronCandidate->Pt());    //primary electron
1593                     }
1594                     else{
1595                       hESDTrueSecElectronPt[fiCut]->Fill(electronCandidate->Pt()); //secondary electron
1596                     }
1597                     if( IsPi0DalitzDaughter(labelelectron) == kTRUE ) {
1598                         if( labelelectron < fMCStack->GetNprimary() ) {
1599                           hESDTruePi0DalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
1600                         }
1601                         else{
1602                           hESDTruePi0DalitzSecElectronPt[fiCut]->Fill(electronCandidate->Pt());
1603                         }
1604                     }
1605                 }
1606             }
1607         }
1608
1609
1610    }
1611
1612    for(UInt_t i = 0; i < fSelectorPositronIndex.size(); i++){
1613
1614       AliESDtrack* positronCandidate = fESDEvent->GetTrack( fSelectorPositronIndex[i] );
1615
1616       if( fMCEvent ) {
1617
1618          Int_t labelpositron = TMath::Abs( positronCandidate->GetLabel() );
1619          Int_t isMCFromMBHeader = -1;
1620
1621           if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0) {
1622             isMCFromMBHeader
1623             = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(labelpositron,fMCStack,fInputEvent);
1624           if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
1625
1626           }
1627       }
1628
1629
1630
1631       if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(positronCandidate) ) continue;
1632
1633       lGoodPositronIndexPrev.push_back( fSelectorPositronIndex[i] );
1634       hESDDalitzPositronPt[fiCut]->Fill( positronCandidate->Pt() );
1635       hESDDalitzPositronPhi[fiCut]->Fill( positronCandidate->Phi() );
1636
1637
1638        if( fMCEvent ) {
1639
1640           Int_t labelpositron = TMath::Abs( positronCandidate->GetLabel() );
1641
1642           if( labelpositron < fMCStack->GetNtrack() ) {
1643             TParticle* positron = fMCStack->Particle(labelpositron);
1644             if( positron->GetPdgCode() ==  -11 ){
1645               if( labelpositron < fMCStack->GetNprimary() ){
1646                 hESDTruePositronPt[fiCut]->Fill(positronCandidate->Pt());
1647               }
1648               else{
1649                 hESDTrueSecPositronPt[fiCut]->Fill(positronCandidate->Pt());
1650               }
1651               if( IsPi0DalitzDaughter(labelpositron) == kTRUE ) {
1652                 if( labelpositron < fMCStack->GetNprimary() ){
1653                   hESDTruePi0DalitzPositronPt[fiCut]->Fill(positronCandidate->Pt());
1654                 }
1655                 else{
1656                   hESDTruePi0DalitzSecPositronPt[fiCut]->Fill(positronCandidate->Pt());
1657                 }
1658               }
1659             }
1660           }
1661         }
1662        }
1663
1664
1665    vector<Bool_t> lElectronPsiIndex(lGoodElectronIndexPrev.size(), kTRUE);
1666    vector<Bool_t> lPositronPsiIndex(lGoodPositronIndexPrev.size(), kTRUE);
1667
1668
1669    if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->DoPsiPairCut() == kTRUE ){
1670
1671       for( UInt_t i = 0; i < lGoodElectronIndexPrev.size(); i++ ) {
1672
1673          AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndexPrev[i]);
1674
1675          for(UInt_t j = 0; j <  lGoodPositronIndexPrev.size(); j++){
1676             AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndexPrev[j]);
1677             Double_t psiPair = GetPsiPair(positronCandidate,electronCandidate);
1678             Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->GetConstrainedParam()->Phi()-positronCandidate->GetConstrainedParam()->Phi());
1679
1680             if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->IsFromGammaConversion(psiPair,deltaPhi ) ){
1681                lElectronPsiIndex[i] = kFALSE;
1682                lPositronPsiIndex[j] = kFALSE;
1683             }
1684          }
1685       }
1686    }
1687
1688
1689    vector<Int_t> lGoodElectronIndex(0);
1690    vector<Int_t> lGoodPositronIndex(0);
1691
1692
1693    for( UInt_t i = 0; i < lGoodElectronIndexPrev.size(); i++ ) {
1694
1695         if(  lElectronPsiIndex[i] == kTRUE )
1696         lGoodElectronIndex.push_back(   lGoodElectronIndexPrev[i]  );
1697    }
1698
1699    for( UInt_t i = 0; i < lGoodPositronIndexPrev.size(); i++ ) {
1700
1701          if(  lPositronPsiIndex[i] == kTRUE )
1702          lGoodPositronIndex.push_back(   lGoodPositronIndexPrev[i]  );
1703    }
1704
1705
1706
1707
1708
1709    for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
1710
1711       //if( lElectronPsiIndex[i] == kFALSE ) continue;
1712
1713
1714       AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndex[i]);
1715
1716       AliKFParticle electronCandidateKF( *electronCandidate->GetConstrainedParam(), ::kElectron );
1717
1718       for(UInt_t j = 0; j < lGoodPositronIndex.size(); j++){
1719
1720          //if( lPositronPsiIndex[j] == kFALSE ) continue;
1721
1722          AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndex[j]);
1723          AliKFParticle positronCandidateKF( *positronCandidate->GetConstrainedParam(), ::kPositron );
1724                                  Bool_t isPhoton    = kFALSE;
1725                                  Bool_t isPi0Dalitz = kFALSE;
1726                                  Bool_t isEtaDalitz = kFALSE;
1727                                  Bool_t isJPsi      = kFALSE;
1728                                  Bool_t isTrueEposENeg = kFALSE;
1729
1730          Double_t psiPair = GetPsiPair(positronCandidate,electronCandidate);
1731          Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->GetConstrainedParam()->Phi()-positronCandidate->GetConstrainedParam()->Phi());
1732
1733
1734          AliKFConversionPhoton* virtualPhoton = NULL;
1735          virtualPhoton = new AliKFConversionPhoton(electronCandidateKF,positronCandidateKF);
1736
1737          if( fSetProductionVertextoVGamma == kTRUE ){
1738
1739               AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1740               primaryVertexImproved+=*virtualPhoton;
1741               virtualPhoton->SetProductionVertex(primaryVertexImproved);
1742
1743          }
1744
1745          virtualPhoton->SetTrackLabels( lGoodPositronIndex[j], lGoodElectronIndex[i]);
1746
1747          Bool_t isMotherPrimary = kFALSE;
1748
1749
1750          if( fMCEvent ) {
1751
1752           Int_t labeln=TMath::Abs(electronCandidate->GetLabel());
1753           Int_t labelp=TMath::Abs(positronCandidate->GetLabel());
1754           TParticle *fNegativeMCParticle = fMCStack->Particle(labeln);
1755           TParticle *fPositiveMCParticle = fMCStack->Particle(labelp);
1756
1757
1758             if( fPositiveMCParticle && fNegativeMCParticle) {
1759                virtualPhoton->SetMCLabelPositive(labelp);
1760                virtualPhoton->SetMCLabelNegative(labeln);
1761
1762                if( fPositiveMCParticle->GetPdgCode() == ::kPositron && fNegativeMCParticle->GetPdgCode() == ::kElectron ) isTrueEposENeg = kTRUE;
1763
1764                if( fPositiveMCParticle->GetMother(0) > -1 && fPositiveMCParticle->GetMother(0) < fMCStack->GetNprimary() )
1765                isMotherPrimary = kTRUE;
1766
1767             }
1768
1769
1770
1771          }
1772
1773           AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton); //To Apply PsiPairCut
1774
1775           if ( fDoMesonQA ) {
1776
1777               if( fMCEvent ) {
1778
1779               TParticle *mcVgamma=virtualPhoton->GetMCParticle(fMCStack);
1780
1781               if(mcVgamma){
1782               // Check if it is a true photon
1783               if(mcVgamma->GetPdgCode() == 22){
1784                 isPhoton = kTRUE;
1785               }else if(mcVgamma->GetPdgCode() == 443){
1786                 isJPsi = kTRUE;
1787               }
1788               else if( IsDalitz( mcVgamma ) ){
1789                 if     ( mcVgamma->GetPdgCode() == 111 ) isPi0Dalitz = kTRUE;
1790                 else if( mcVgamma->GetPdgCode() == 221 ) isEtaDalitz = kTRUE;
1791               }
1792               }
1793
1794               if(isPhoton){
1795                     hESDEposEnegTruePhotonInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1796
1797                     hESDEposEnegTruePhotonPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1798               }
1799               else if(isJPsi){
1800                     hESDEposEnegTrueJPsiInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1801               }
1802               else if(isPi0Dalitz){
1803                     hESDEposEnegTruePi0DalitzInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1804                     hESDEposEnegTruePi0DalitzPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1805                     if( isMotherPrimary ) hESDEposEnegTruePrimPi0DalitzInvMass[fiCut]->Fill( vphoton->GetMass() );
1806               }
1807               else if(isEtaDalitz){
1808                     hESDEposEnegTrueEtaDalitzInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1809                     hESDEposEnegTrueEtaDalitzPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1810                     if( isMotherPrimary ) hESDEposEnegTruePrimEtaDalitzInvMass[fiCut]->Fill( vphoton->GetMass() );
1811               }
1812
1813               if( isTrueEposENeg ) hESDEposEnegTrueInvMassPt[fiCut]->Fill(vphoton->GetMass(), vphoton->Pt());
1814
1815             }
1816           }
1817
1818
1819
1820          if ( fDoMesonQA ) {
1821
1822          hESDEposEnegPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1823          hESDEposEnegInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1824
1825          }
1826
1827          if( ! fDoChicAnalysis ) {
1828
1829                   if (  ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE )  {
1830
1831                      Double_t MassCutMax = 1000.0;
1832                      if(  ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutLowPt() >= ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutHighPt() ){
1833                        MassCutMax = ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutLowPt();
1834                      }
1835                      else {
1836                        MassCutMax = ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutHighPt();
1837                      }
1838
1839                      Bool_t DoMassMinCut = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->DoMassMinCut();
1840                      Double_t MassMinCut = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetMassMinCut();
1841
1842                      if( vphoton->GetMass() > MassCutMax || (  DoMassMinCut && vphoton->GetMass() < MassMinCut )  ) {
1843
1844
1845                        delete vphoton;
1846                        vphoton = 0x0;
1847                        delete virtualPhoton;
1848                        virtualPhoton = 0x0;
1849                        continue;
1850
1851                      }
1852
1853                   }
1854          }
1855
1856
1857          fGoodVirtualGammas->Add(  vphoton );
1858          delete virtualPhoton;
1859          virtualPhoton=NULL;
1860
1861       }
1862    }
1863
1864
1865    //Computing mixing event
1866
1867    if(  fDoMesonQA ) {
1868
1869       for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
1870
1871          //if( lElectronPsiIndex[i] == kFALSE ) continue;
1872
1873           AliESDtrack *electronCandidate1 = fESDEvent->GetTrack(lGoodElectronIndex[i]);
1874
1875           AliKFParticle electronCandidate1KF( *electronCandidate1->GetConstrainedParam(), ::kElectron );
1876
1877
1878           for(UInt_t j = i+1; j < lGoodElectronIndex.size(); j++){
1879
1880                //if( lElectronPsiIndex[j] == kFALSE ) continue;
1881
1882
1883                 AliESDtrack *electronCandidate2 = fESDEvent->GetTrack(lGoodElectronIndex[j]);
1884
1885                 AliKFParticle electronCandidate2KF( *electronCandidate2->GetConstrainedParam(), ::kElectron );
1886
1887                 AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(electronCandidate1KF,electronCandidate2KF);
1888
1889                 //AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1890                 //primaryVertexImproved+=*virtualPhoton;
1891                 //virtualPhoton->SetProductionVertex(primaryVertexImproved);
1892
1893
1894                 AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton);
1895                 hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1896                 delete vphoton;
1897                 delete virtualPhoton;
1898                 vphoton = 0x0;
1899                 virtualPhoton = 0x0;
1900
1901           }
1902    }
1903
1904
1905       for(UInt_t i = 0; i < lGoodPositronIndex.size(); i++){
1906
1907
1908
1909          //if( lPositronPsiIndex[i] == kFALSE ) continue;
1910
1911           AliESDtrack *positronCandidate1 = fESDEvent->GetTrack(lGoodPositronIndex[i]);
1912
1913           AliKFParticle positronCandidate1KF( *positronCandidate1->GetConstrainedParam(), ::kPositron );
1914
1915
1916           for(UInt_t j = i+1; j < lGoodPositronIndex.size(); j++){
1917
1918               // if( lPositronPsiIndex[j] == kFALSE ) continue;
1919
1920                 AliESDtrack *positronCandidate2 = fESDEvent->GetTrack(lGoodPositronIndex[j]);
1921
1922                 AliKFParticle positronCandidate2KF( *positronCandidate2->GetConstrainedParam(), ::kPositron );
1923
1924                 AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(positronCandidate1KF,positronCandidate2KF);
1925                 //AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1926                 //primaryVertexImproved+=*virtualPhoton;
1927                 //virtualPhoton->SetProductionVertex(primaryVertexImproved);
1928
1929                 AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton);
1930                 hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1931
1932
1933                 delete vphoton;
1934                 delete virtualPhoton;
1935                 vphoton = 0x0;
1936                 virtualPhoton = 0x0;
1937
1938           }
1939       }
1940
1941    }
1942 }
1943
1944 //________________________________________________________________________
1945 void AliAnalysisTaskGammaConvDalitzV1::CalculatePi0DalitzCandidates(){
1946
1947    // Conversion Gammas
1948
1949
1950
1951
1952    if( fGoodGammas->GetEntries() > 0 && fGoodVirtualGammas->GetEntries() > 0 ){
1953
1954       vector<Bool_t> lGoodVirtualGamma(fGoodVirtualGammas->GetEntries(), kFALSE);
1955
1956       for(Int_t GammaIndex=0; GammaIndex<fGoodGammas->GetEntries(); GammaIndex++){
1957
1958          AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(GammaIndex));
1959          if (gamma==NULL) continue;
1960          for(Int_t virtualGammaIndex=0;virtualGammaIndex<fGoodVirtualGammas->GetEntries();virtualGammaIndex++){
1961
1962             AliAODConversionPhoton *Vgamma=dynamic_cast<AliAODConversionPhoton*>(fGoodVirtualGammas->At(virtualGammaIndex));
1963             if (Vgamma==NULL) continue;
1964             //Check for same Electron ID
1965             if(gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelPositive() ||
1966                gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelNegative() ||
1967                gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelPositive() ||
1968                gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelNegative() ) continue;
1969
1970             AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma,Vgamma);
1971             pi0cand->SetLabels(GammaIndex,virtualGammaIndex);
1972
1973
1974             if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift())) ){
1975
1976               //cout<< "Meson Accepted "<<endl;
1977
1978                Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
1979                Int_t mbin = 0;
1980                if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ){
1981                   mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1982                } else {
1983                   mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
1984                }
1985
1986
1987
1988               if(  ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
1989
1990
1991                  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( pi0cand->Pt() , Vgamma->GetMass() ) == kTRUE ){
1992
1993                  hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1994
1995                  Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1996                  sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1997
1998
1999                     if ( fDoMesonQA ) {
2000
2001                        hESDMotherPhi[fiCut]->Fill(pi0cand->Phi());
2002
2003                         if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
2004
2005                           FillElectronQAHistos(Vgamma);
2006
2007                           lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
2008                       }
2009                    }
2010                 }
2011               }
2012               else {
2013                  hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2014                  Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
2015                  sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2016
2017
2018                    if ( fDoMesonQA ) {
2019
2020                     hESDMotherPhi[fiCut]->Fill(pi0cand->Phi());
2021
2022                     if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
2023
2024                       FillElectronQAHistos(Vgamma);
2025
2026                       lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
2027
2028                     }
2029                  }
2030               }
2031
2032                if( fDoChicAnalysis) {
2033
2034                hESDPi0MotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2035
2036                Double_t diffMass = pi0cand->M() - Vgamma->GetMass();
2037
2038                hESDPi0MotherDiffInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
2039
2040                 if( Vgamma->GetMass() > 2.5 && Vgamma->GetMass() < 3.4){
2041                 hESDPi0MotherDiffLimInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
2042                 }
2043                }
2044
2045               if(fMCEvent){
2046                   ProcessTrueMesonCandidates(pi0cand,gamma,Vgamma);
2047               }
2048             }
2049             delete pi0cand;
2050             pi0cand=0x0;
2051          }
2052       }
2053    }
2054 }
2055
2056 //________________________________________________________________________
2057 void AliAnalysisTaskGammaConvDalitzV1::CalculateBackground(){
2058
2059    Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
2060    Int_t mbin = 0;
2061
2062    Int_t method = 0;
2063
2064    method = ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetBKGMethod();
2065
2066
2067    if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity()){
2068       mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
2069    } else {
2070       mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
2071    }
2072
2073    if( method == 1 || method == 2 ) {
2074
2075       AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2076
2077       if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ) {
2078
2079          for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2080
2081             AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2082
2083             if(fMoveParticleAccordingToVertex == kTRUE && method == 1){
2084                bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2085             }
2086
2087             for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
2088                AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
2089
2090                for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2091                   AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2092
2093                   if(fMoveParticleAccordingToVertex == kTRUE && method == 1 ){
2094                      MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2095                   }
2096
2097                   AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2098
2099
2100                   if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE, ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()))){
2101                       if(  ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2102
2103                         if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.GetMass() ) == kTRUE ){
2104
2105                          // cout<<" Mass dalitz: "<<currentEventGoodV0.GetMass()<<endl;
2106                           hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2107                           Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2108                           sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2109                          }
2110                       }
2111                       else {
2112                         hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2113                         Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2114                         sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2115                       }
2116                   }
2117                   delete backgroundCandidate;
2118                   backgroundCandidate = 0x0;
2119                }
2120             }
2121          }
2122       }
2123       else{
2124          for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2125             AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2126             if(previousEventV0s){
2127                if(fMoveParticleAccordingToVertex == kTRUE && method == 1){
2128                   bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2129                }
2130                for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
2131
2132                   AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
2133
2134                   for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2135
2136                      AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2137
2138                      if(fMoveParticleAccordingToVertex == kTRUE && method ==1){
2139                         MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2140                      }
2141
2142                      AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2143
2144                      if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()))){
2145
2146                        if(  ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2147
2148                           if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.GetMass() ) == kTRUE ){
2149
2150
2151                           hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2152                           Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2153                           sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2154                         }
2155                        }
2156                        else {
2157                           hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2158                           Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2159                           sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2160                        }
2161                      }
2162                      delete backgroundCandidate;
2163                      backgroundCandidate = 0x0;
2164                   }
2165                }
2166             }
2167          }
2168       }
2169    }
2170
2171    else if( method == 3 ){
2172
2173       for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
2174
2175          AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
2176
2177          for(Int_t iPrevious=0;iPrevious<fGammasPool[fiCut]->GetEntries();iPrevious++){
2178
2179             AliAODConversionPhoton previousGoodV0 = *(AliAODConversionPhoton*)((fGammasPool[fiCut]->At(iPrevious) ));
2180
2181
2182             AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2183
2184
2185             if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE, ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()))){
2186
2187                if(  ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2188
2189                     if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.GetMass() ) == kTRUE ){
2190
2191
2192                   hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2193                   Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2194                   sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2195
2196                   }
2197                }
2198                else{
2199
2200                  hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2201                  Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2202                  sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2203
2204                }
2205             }
2206             delete backgroundCandidate;
2207             backgroundCandidate = 0x0;
2208          }
2209       }
2210    }
2211
2212 }
2213 //________________________________________________________________________
2214 void AliAnalysisTaskGammaConvDalitzV1::UpdateEventByEventData(){
2215    //see header file for documentation
2216
2217    Int_t method = 0;
2218
2219    method = ( (AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetBKGMethod();
2220
2221
2222
2223
2224    if( method == 1 ) {
2225
2226       if(fGoodGammas->GetEntries() > 0 ){
2227
2228          if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ){
2229             fBGHandler[fiCut]->AddEvent(fGoodGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fNumberOfESDTracks);
2230          }
2231
2232          else{ // means we use #V0s for multiplicity
2233             fBGHandler[fiCut]->AddEvent(fGoodGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fGoodGammas->GetEntries());
2234          }
2235       }
2236    }
2237
2238    else if ( method == 2 ){
2239
2240       if(fGoodVirtualGammas->GetEntries() > 0 ){
2241          if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity()){
2242             fBGHandler[fiCut]->AddEvent(fGoodVirtualGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fNumberOfESDTracks);
2243          }
2244          else{ // means we use #V0s for multiplicity
2245             fBGHandler[fiCut]->AddEvent(fGoodVirtualGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fGoodVirtualGammas->GetEntries());
2246          }
2247       }
2248    }
2249    else if ( method  == 3 ) {
2250
2251
2252
2253       for(Int_t index = 0; index < fGoodGammas->GetEntries(); index++){
2254
2255
2256          if ( fGammasPool[fiCut]->GetEntries() > ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->NumberOfRotationEvents() ){
2257             fGammasPool[fiCut]->RemoveLast();
2258          }
2259          fGammasPool[fiCut]->AddFirst( new AliAODConversionPhoton(*(AliAODConversionPhoton*)(fGoodGammas->At(index)) ) );
2260
2261       }
2262    }
2263 }
2264 //______________________________________________________________________
2265 void AliAnalysisTaskGammaConvDalitzV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate, AliAODConversionPhoton *TrueVirtualGammaCandidate)
2266 {
2267
2268    // Process True Mesons
2269
2270    AliStack *MCStack = fMCEvent->Stack();
2271
2272    if(  TrueGammaCandidate->GetV0Index()<fESDEvent->GetNumberOfV0s()    ){
2273
2274
2275      //cout<<"Entro True Meson"<<endl;
2276
2277
2278       Bool_t isTruePi0 = kFALSE;
2279       Bool_t isTrueEta = kFALSE;
2280       Bool_t massCutAccept = kFALSE;
2281       //Bool_t isTrueChiC = kFALSE;
2282       Int_t gammaMCLabel = TrueGammaCandidate->GetMCParticleLabel(MCStack);
2283       Int_t gammaMotherLabel = -1;
2284
2285
2286       if(  ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2287
2288             if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( Pi0Candidate->Pt() , TrueVirtualGammaCandidate->GetMass() ) == kTRUE ){
2289
2290                massCutAccept = kTRUE;
2291             }
2292       }
2293       else {
2294               massCutAccept  = kTRUE;
2295       }
2296
2297
2298
2299
2300
2301       if(gammaMCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2302
2303
2304          // Daughters Gamma 0
2305          TParticle * negativeMC = (TParticle*)TrueGammaCandidate->GetNegativeMCDaughter(MCStack);
2306          TParticle * positiveMC = (TParticle*)TrueGammaCandidate->GetPositiveMCDaughter(MCStack);
2307          TParticle * gammaMC = (TParticle*)MCStack->Particle(gammaMCLabel);
2308
2309
2310          if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){  // Electrons ...
2311
2312             if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2313
2314                if(gammaMC->GetPdgCode() == 22){ // ... with Gamma Mother
2315                   gammaMotherLabel=gammaMC->GetFirstMother();
2316                }
2317             }
2318          }
2319       }
2320
2321
2322       Int_t virtualGammaMCLabel = TrueVirtualGammaCandidate->GetMCParticleLabel(MCStack);
2323       Int_t virtualGammaMotherLabel = -1;
2324       Int_t virtualGamma = 1;
2325       Int_t virtualGammaGrandMotherLabel =-1;
2326
2327
2328       if(virtualGammaMCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2329          // Daughters Gamma 1
2330          TParticle * negativeMC = (TParticle*)TrueVirtualGammaCandidate->GetNegativeMCDaughter(MCStack);
2331          TParticle * positiveMC = (TParticle*)TrueVirtualGammaCandidate->GetPositiveMCDaughter(MCStack);
2332          TParticle * virtualGammaMotherMC = (TParticle*)MCStack->Particle(virtualGammaMCLabel);
2333
2334          if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){  // Electrons ...
2335
2336             if( virtualGammaMotherMC->GetPdgCode() != 22 ){
2337                virtualGammaMotherLabel=virtualGammaMCLabel;
2338             if(virtualGammaMotherMC->GetPdgCode() == 443){
2339                virtualGammaGrandMotherLabel=virtualGammaMotherMC->GetFirstMother();
2340             }
2341            }
2342
2343             else if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2344                virtualGammaMotherLabel=virtualGammaMotherMC->GetFirstMother();
2345                virtualGamma = 0; //no virtual gamma
2346             }
2347          }
2348       }
2349
2350
2351       if(gammaMotherLabel >= 0 && ( gammaMotherLabel == virtualGammaMotherLabel) ){
2352
2353          if(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetPdgCode() == 111){
2354             isTruePi0=kTRUE;
2355          }
2356
2357          if(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetPdgCode() == 221){
2358             isTrueEta=kTRUE;
2359          }
2360
2361
2362         }
2363
2364        if( fDoChicAnalysis) {
2365         if(gammaMotherLabel>=0 && ( gammaMotherLabel == virtualGammaGrandMotherLabel) ){
2366           if(((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 445 ||
2367             ((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 10443 ||
2368             ((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 20443 ){
2369               //isTrueChiC=kTRUE;
2370               hESDTrueMotherChiCInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2371               hESDTrueMotherChiCDiffInvMassPt[fiCut]->Fill(Pi0Candidate->M()-TrueVirtualGammaCandidate->GetMass(),Pi0Candidate->Pt());
2372              }
2373           }
2374        }
2375
2376       if( ( isTruePi0 || isTrueEta) && massCutAccept ){ // True Pion or Eta
2377
2378          if ( virtualGamma == 1 ) { //True Dalitz
2379
2380             Float_t weighted= 1;
2381
2382             if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2383                 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
2384                     if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
2385                         weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
2386                     }
2387                 }
2388             }
2389
2390             hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2391             hESDTrueMotherDalitzInvMassPt[fiCut]->Fill( TrueVirtualGammaCandidate->GetMass(),Pi0Candidate->Pt(),weighted);
2392
2393             if(gammaMotherLabel < MCStack->GetNprimary()){ // Only primary pi0 for efficiency calculation
2394
2395
2396                hESDTruePrimaryMotherInvMassPt[fiCut]->Fill( Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2397                hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill( Pi0Candidate->M(), Pi0Candidate->Pt() );
2398
2399                hESDTruePrimaryMotherInvMassMCPt[fiCut]->Fill(Pi0Candidate->M(),((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->Pt(),weighted);
2400                if(isTruePi0){ // Only primaries for unfolding
2401                   hESDTruePrimaryPi0DalitzESDPtMCPt[fiCut]->Fill(Pi0Candidate->Pt(),((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->Pt(),weighted);
2402                }
2403             }
2404             else { // Secondary Meson
2405               Float_t weightedSec= 1;
2406
2407               if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2408                   Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gammaMotherLabel))->GetMother(0);
2409                   if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(gammaMotherLabel)->GetPdgCode()==310){
2410                     weightedSec= ((AliConversionCuts*)fCutGammaArray->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
2411                   }
2412               }
2413
2414               hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2415             }
2416          }
2417
2418
2419          else if ( virtualGamma == 0 ){
2420
2421               Float_t weighted= 1;
2422
2423              if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2424               if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
2425                 if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
2426                     weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
2427                 }
2428               }
2429             }
2430
2431             hESDTrueMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted); // Pi0 from GG
2432
2433             if( gammaMotherLabel < MCStack->GetNprimary() ){
2434                 hESDTruePrimaryMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2435             }
2436             else {
2437
2438             Float_t weightedSec= 1;
2439
2440             if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2441                 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gammaMotherLabel))->GetMother(0);
2442                    if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(gammaMotherLabel)->GetPdgCode()==310){
2443                             weightedSec= ((AliConversionCuts*)fCutGammaArray->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
2444                    }
2445             }
2446                     hESDTrueSecondaryMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2447             }
2448          }
2449       }
2450
2451       if(!isTruePi0 && !isTrueEta && massCutAccept ){ // Background
2452          if(gammaMotherLabel>-1 && virtualGammaMotherLabel>-1 && virtualGamma == 0){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2453             hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2454          } else { // No photon or without mother
2455             hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2456          }
2457       }
2458    }
2459 }
2460
2461
2462 //________________________________________________________________________
2463 void AliAnalysisTaskGammaConvDalitzV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
2464    //see header file for documentation
2465
2466    Double_t dx = vertex->fX - fESDEvent->GetPrimaryVertex()->GetX();
2467    Double_t dy = vertex->fY - fESDEvent->GetPrimaryVertex()->GetY();
2468    Double_t dz = vertex->fZ - fESDEvent->GetPrimaryVertex()->GetZ();
2469
2470    Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
2471    particle->SetConversionPoint(movedPlace);
2472 }
2473
2474
2475 //________________________________________________________________________
2476 void AliAnalysisTaskGammaConvDalitzV1::CountESDTracks(){
2477
2478    // Using standard function for setting Cuts
2479    Bool_t selectPrimaries=kTRUE;
2480    AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
2481    EsdTrackCuts->SetMaxDCAToVertexZ(2);
2482    EsdTrackCuts->SetEtaRange(-0.8, 0.8);
2483    EsdTrackCuts->SetPtRange(0.15);
2484
2485    fNumberOfESDTracks = 0;
2486    for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
2487       AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
2488       if(!curTrack) continue;
2489       if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTracks++;
2490    }
2491    delete EsdTrackCuts;
2492    EsdTrackCuts=0x0;
2493
2494    return;
2495 }
2496
2497 //_____________________________________________________________________________
2498 void AliAnalysisTaskGammaConvDalitzV1::ProcessMCParticles()
2499 {
2500
2501    // Loop over all primary MC particle
2502
2503    for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2504
2505
2506       TParticle* particle = (TParticle *)fMCStack->Particle(i);
2507       if (!particle) continue;
2508
2509
2510       Bool_t mcIsFromMB = kTRUE;
2511       Int_t isMCFromMBHeader = -1;
2512
2513       if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0) {
2514          isMCFromMBHeader
2515             = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i,fMCStack,fInputEvent);
2516          if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
2517          if(isMCFromMBHeader != 2) mcIsFromMB = kFALSE;
2518       }
2519
2520       if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
2521           hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2522       }
2523
2524       if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
2525          hMCConvGammaPt[fiCut]->Fill(particle->Pt());
2526          if(fDoMesonQA) hMCConvGammaEta[fiCut]->Fill( particle->Eta());
2527
2528          if(mcIsFromMB){
2529             hMCConvGammaRSPt[fiCut]->Fill(particle->Pt());
2530          }
2531       } // Converted MC Gamma
2532
2533       if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(i,fMCStack)){
2534                         if( particle->GetPdgCode() == -11) {
2535                           hMCAllPositronsPt[fiCut]->Fill(particle->Pt()); // All positrons
2536                           if(fDoMesonQA) hMCAllPositronsEta[fiCut]->Fill( particle->Eta() );
2537                         }
2538                         if( particle->GetPdgCode() ==  11){
2539                           hMCAllElectronsPt[fiCut]->Fill(particle->Pt()); // All electrons
2540                           if (fDoMesonQA)  hMCAllElectronsEta[fiCut]->Fill(particle->Eta()); // All electrons
2541                         }
2542
2543       }
2544
2545       if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMC( particle,fMCStack,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift() ) ){
2546
2547                 Float_t weighted= 1;
2548
2549                     if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2550                         if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2551                           if (particle->Pt()>0.005){
2552                             weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
2553                           }
2554                         }
2555                     }
2556
2557                         if(particle->GetPdgCode() == 111)hMCPi0GGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Pi0 GG decay
2558                         if(particle->GetPdgCode() == 221)hMCEtaGGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Eta GG decay
2559       }
2560
2561
2562       Int_t labelgamma    = -1;
2563       Int_t labelelectron = -1;
2564       Int_t labelpositron = -1;
2565
2566
2567       if( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMCDalitz(particle,fMCStack,labelelectron,labelpositron,labelgamma,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift())  )
2568       {
2569
2570
2571                     Float_t weighted= 1;
2572                    if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2573                         if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack,fInputEvent)){
2574                           if (particle->Pt()>0.005){
2575                             weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
2576                           }
2577                         }
2578                    }
2579                         if(particle->GetPdgCode() == 111)hMCPi0Pt[fiCut]->Fill(particle->Pt(), weighted); // All MC Pi0
2580                         if(particle->GetPdgCode() == 221)hMCEtaPt[fiCut]->Fill(particle->Pt(), weighted); // All MC Eta
2581
2582                         // Check the acceptance for gamma and electrons
2583
2584
2585                                 TParticle *gamma    = fMCStack->Particle(labelgamma);
2586                                 TParticle *electron = fMCStack->Particle(labelelectron);
2587                                 TParticle *positron = fMCStack->Particle(labelpositron);
2588
2589
2590                                 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(gamma,fMCStack,kFALSE) &&
2591                                    ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelelectron,fMCStack) &&
2592                                    ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelpositron,fMCStack) ) {
2593
2594                                      Double_t massDalitz = -1;
2595
2596                                       if( fDoMesonQA){
2597
2598                                         TLorentzVector TLVEpos,TLVEneg,TLVDalitz;
2599                                         Double_t electronMass = TDatabasePDG::Instance()->GetParticle(  ::kElectron   )->Mass();
2600
2601                                         TLVEpos.SetXYZM(positron->Px(),positron->Py(),positron->Pz(),electronMass);
2602                                         TLVEneg.SetXYZM(electron->Px(),electron->Py(),electron->Pz(),electronMass);
2603                                         TLVDalitz =  TLVEpos + TLVEneg ;
2604                                         massDalitz = TLVDalitz.M();
2605                                       }
2606
2607
2608
2609
2610                                         if(particle->GetPdgCode() == 111){
2611
2612                                                 hMCPi0InAccPt[fiCut]->Fill(particle->Pt() , weighted); // MC Pi0Dalitz with gamma and e+e- in acc
2613                                                 hMCPi0DalitzGammaPt[fiCut]->Fill( gamma->Pt() );
2614                                                 hMCPi0DalitzPositronPt[fiCut]->Fill( positron->Pt()  );
2615                                                 hMCPi0DalitzElectronPt[fiCut]->Fill( electron->Pt()  );
2616
2617                                                 if ( fDoMesonQA )hMCPi0EposEnegInvMassPt[fiCut]->Fill(massDalitz,particle->Pt());
2618
2619
2620                                         }
2621                                         if(particle->GetPdgCode() == 221){
2622                                               hMCEtaInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC EtaDalitz with gamma and e+e- in acc
2623                                               if( fDoMesonQA ) hMCEtaEposEnegInvMassPt[fiCut]->Fill( massDalitz, particle->Pt());
2624                                         }
2625                                 }
2626
2627
2628         }
2629                 Int_t labelgammaChiC=-1;
2630                 Int_t labelpositronChiC=-1;
2631                 Int_t labelelectronChiC=-1;
2632
2633                 if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMCChiC(particle,fMCStack,labelelectronChiC,labelpositronChiC,labelgammaChiC,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift())){
2634
2635                         hMCChiCPt[fiCut]->Fill(particle->Pt()); // All MC ChiC
2636                         TParticle * gammaChiC  =fMCStack->Particle(labelgammaChiC);
2637
2638                         if( ((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC( gammaChiC,fMCStack,kFALSE) &&
2639                             ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelelectronChiC,fMCStack) &&
2640                             ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelpositronChiC,fMCStack) ){
2641                                 hMCChiCInAccPt[fiCut]->Fill(particle->Pt()); // All MC ChiC
2642                         }
2643                 }
2644         }
2645 }
2646 //_____________________________________________________________________________
2647 Bool_t AliAnalysisTaskGammaConvDalitzV1::IsDalitz(TParticle *fMCMother) const
2648 {
2649
2650         if( fMCMother->GetNDaughters() != 3 ) return kFALSE;
2651         if( fMCMother->GetPdgCode() != 111 && fMCMother->GetPdgCode() != 221 ) return kFALSE;
2652
2653
2654         TParticle *positron = 0x0;
2655         TParticle *electron = 0x0;
2656         TParticle *gamma    = 0x0;
2657
2658         for(Int_t index= fMCMother->GetFirstDaughter();index<= fMCMother->GetLastDaughter();index++){
2659
2660                 TParticle* temp = (TParticle*)fMCStack->Particle( index );
2661
2662                 switch( temp->GetPdgCode() ) {
2663                 case ::kPositron:
2664                         positron =  temp;
2665                         break;
2666                 case ::kElectron:
2667                         electron =  temp;
2668                         break;
2669                 case ::kGamma:
2670                         gamma    =  temp;
2671                         break;
2672                 }
2673         }
2674
2675         if( positron && electron && gamma) return kTRUE;
2676
2677         return kFALSE;
2678 }
2679 //_____________________________________________________________________________________
2680 Bool_t AliAnalysisTaskGammaConvDalitzV1::IsPi0DalitzDaughter( Int_t label ) const
2681 {
2682 //
2683 // Returns true if the particle comes from Pi0 -> e+ e- gamma
2684 //
2685
2686         Int_t motherLabel = fMCStack->Particle( label )->GetMother(0);
2687
2688         if( motherLabel < 0 || motherLabel >= fMCStack->GetNtrack() ) return kFALSE;
2689
2690         TParticle* mother = fMCStack->Particle( motherLabel );
2691
2692         if( mother->GetPdgCode() != 111 ) return kFALSE;
2693
2694         if( IsDalitz( mother ) ) return kTRUE;
2695
2696
2697         return kFALSE;
2698
2699
2700 }
2701
2702 void AliAnalysisTaskGammaConvDalitzV1::FillElectronQAHistos(AliAODConversionPhoton *Vgamma) const
2703 {
2704
2705
2706               AliESDtrack *positronVgamma = 0;
2707               AliESDtrack *electronVgamma = 0;
2708
2709               Double_t clsToFPos = -1.0;
2710               Double_t clsToFNeg = -1.0;
2711
2712
2713               Double_t NumClsITSPos = -1.0;
2714               Double_t NumClsITSNeg = -1.0;
2715               Double_t NumClsTPCPos = -1.0;
2716               Double_t NumClsTPCNeg = -1.0;
2717               Double_t nCrossedRowsTPCPos = -1.0;
2718               Double_t nCrossedRowsTPCNeg = -1.0;
2719
2720
2721
2722               Float_t dcaToVertexXYPos = -1.0;
2723               Float_t dcaToVertexZPos  = -1.0;
2724               Float_t dcaToVertexXYNeg = -1.0;
2725               Float_t dcaToVertexZNeg  = -1.0;
2726
2727               Double_t nSigmaPosTPC = -999.;
2728               Double_t nSigmaNegTPC = -999.;
2729
2730               positronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
2731               electronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
2732               clsToFPos = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(positronVgamma);
2733               clsToFNeg = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(electronVgamma);
2734
2735               nSigmaPosTPC = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(positronVgamma, AliPID::kElectron) ;
2736               nSigmaNegTPC = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(electronVgamma, AliPID::kElectron) ;
2737
2738
2739
2740               NumClsITSPos =  positronVgamma->GetNcls(0); //Get number of ITS clusters
2741               NumClsITSNeg =  electronVgamma->GetNcls(0);
2742               NumClsTPCPos =  positronVgamma->GetNcls(1);  //Get number of TPC clusters
2743               NumClsTPCNeg =  electronVgamma->GetNcls(1);
2744
2745               nCrossedRowsTPCPos = positronVgamma->GetTPCCrossedRows();
2746               nCrossedRowsTPCNeg = electronVgamma->GetTPCCrossedRows();
2747
2748
2749
2750               Float_t bPos[2];
2751               Float_t bCovPos[3];
2752               positronVgamma->GetImpactParameters(bPos,bCovPos);
2753
2754               if (bCovPos[0]<=0 || bCovPos[2]<=0) {
2755                   AliDebug(1, "Estimated b resolution lower or equal zero!");
2756                   bCovPos[0]=0; bCovPos[2]=0;
2757                }
2758
2759                Float_t bNeg[2];
2760                Float_t bCovNeg[3];
2761                positronVgamma->GetImpactParameters(bNeg,bCovNeg);
2762
2763                if (bCovNeg[0]<=0 || bCovNeg[2]<=0) {
2764                   AliDebug(1, "Estimated b resolution lower or equal zero!");
2765                   bCovNeg[0]=0; bCovNeg[2]=0;
2766                 }
2767
2768                dcaToVertexXYPos = bPos[0];
2769                dcaToVertexZPos  = bPos[1];
2770                dcaToVertexXYNeg = bNeg[0];
2771                dcaToVertexZNeg  = bNeg[1];
2772
2773                hESDDalitzElectronAfterPt[fiCut]->Fill(  electronVgamma->Pt()  );
2774                hESDDalitzPositronAfterPt[fiCut]->Fill(  positronVgamma->Pt()  );
2775
2776                hESDDalitzElectronAfterEta[fiCut]->Fill( electronVgamma->Eta() );
2777                hESDDalitzPositronAfterEta[fiCut]->Fill( positronVgamma->Eta() );
2778
2779                hESDDalitzElectronAfterPhi[fiCut]->Fill( electronVgamma->Phi() );
2780                hESDDalitzPositronAfterPhi[fiCut]->Fill( positronVgamma->Phi() );
2781
2782                hESDDalitzElectronAfterNFindClsTPC[fiCut]->Fill(clsToFNeg,electronVgamma->Pt());
2783                hESDDalitzPositronAfterNFindClsTPC[fiCut]->Fill(clsToFPos,positronVgamma->Pt());
2784
2785                hESDDalitzElectronAfterNClsTPC[fiCut]->Fill(  NumClsTPCNeg,electronVgamma->Pt());
2786                hESDDalitzPositronAfterNClsTPC[fiCut]->Fill(  NumClsTPCPos,positronVgamma->Pt());
2787
2788                hESDDalitzElectronAfterNCrossedRowsTPC[fiCut]->Fill( nCrossedRowsTPCNeg, electronVgamma->Pt() );
2789                hESDDalitzPositronAfterNCrossedRowsTPC[fiCut]->Fill( nCrossedRowsTPCPos, positronVgamma->Pt() );
2790
2791                hESDDalitzElectronAfterNClsITS[fiCut]->Fill( NumClsITSNeg);
2792                hESDDalitzPositronAfterNClsITS[fiCut]->Fill( NumClsITSPos);
2793
2794                hESDDalitzPosEleAfterDCAxy[fiCut]->Fill(  dcaToVertexXYNeg, electronVgamma->Pt() );
2795                hESDDalitzPosEleAfterDCAz[fiCut]->Fill(   dcaToVertexZNeg,  electronVgamma->Pt() );
2796                hESDDalitzPosEleAfterDCAxy[fiCut]->Fill(  dcaToVertexXYPos, positronVgamma->Pt() );
2797                hESDDalitzPosEleAfterDCAz[fiCut]->Fill(   dcaToVertexZPos,  positronVgamma->Pt() );
2798
2799                hESDDalitzElectronAfterTPCdEdxVsP[fiCut]->Fill( electronVgamma->P(),nSigmaNegTPC);
2800                hESDDalitzPositronAfterTPCdEdxVsP[fiCut]->Fill( positronVgamma->P(), nSigmaPosTPC);
2801
2802                hESDDalitzElectronAfterTPCdEdxVsEta[fiCut]->Fill( electronVgamma->Eta(),nSigmaNegTPC);
2803                hESDDalitzPositronAfterTPCdEdxVsEta[fiCut]->Fill( positronVgamma->Eta(),nSigmaPosTPC);
2804
2805                hESDDalitzElectronAfterTPCdEdxVsPhi[fiCut]->Fill( electronVgamma->Phi(),nSigmaNegTPC);
2806                hESDDalitzPositronAfterTPCdEdxVsPhi[fiCut]->Fill( positronVgamma->Phi(),nSigmaPosTPC);
2807
2808
2809                hESDDalitzElectronAfterTPCdEdxSignalVsP[fiCut]->Fill( electronVgamma->P(), TMath::Abs(electronVgamma->GetTPCsignal()));
2810                hESDDalitzPositronAfterTPCdEdxSignalVsP[fiCut]->Fill( positronVgamma->P(), TMath::Abs(positronVgamma->GetTPCsignal()));
2811
2812
2813
2814 }
2815
2816
2817 //_____________________________________________________________________________
2818 Double_t AliAnalysisTaskGammaConvDalitzV1::GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg ) const
2819 {
2820    //
2821    // This angle is a measure for the contribution of the opening in polar
2822    // direction ?0 to the opening angle ? Pair
2823    //
2824    // Ref. Measurement of photons via conversion pairs with the PHENIX experiment at RHIC
2825    //      Mas   ter Thesis. Thorsten Dahms. 2005
2826    // https://twiki.cern.ch/twiki/pub/ALICE/GammaPhysicsPublications/tdahms_thesis.pdf
2827    //
2828    Double_t momPos[3];
2829    Double_t momNeg[3];
2830    if( trackPos->GetConstrainedPxPyPz(momPos) == 0 ) trackPos->GetPxPyPz( momPos );
2831    if( trackNeg->GetConstrainedPxPyPz(momNeg) == 0 ) trackNeg->GetPxPyPz( momNeg );
2832
2833    TVector3 posDaughter;
2834    TVector3 negDaughter;
2835
2836    posDaughter.SetXYZ( momPos[0], momPos[1], momPos[2] );
2837    negDaughter.SetXYZ( momNeg[0], momNeg[1], momNeg[2] );
2838
2839    Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();
2840    Double_t openingAngle =  posDaughter.Angle( negDaughter );  //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );
2841
2842    if( openingAngle < 1e-20 ) return 0.;
2843
2844    Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );
2845
2846    return psiAngle;
2847 }