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