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