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