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