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