PWGGA/GammaConv/AliAnalysisTaskConversionQA.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Authors: Svein Lindal, Daniel Lohner                                   *
   5  * Version 1.0                                                            *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 ////////////////////////////////////////////////
  17 //---------------------------------------------
  18 // QA Task for V0 Reader V1
  19 //---------------------------------------------
  20 ////////////////////////////////////////////////
  21
  22 #include "AliAnalysisTaskConversionQA.h"
  23 #include "TChain.h"
  24 #include "AliAnalysisManager.h"
  25 #include "TParticle.h"
  26 #include "TVectorF.h"
  27 #include "AliPIDResponse.h"
  28 #include "TFile.h"
  29 #include "AliESDtrackCuts.h"
  30 #include "AliAODMCParticle.h"
  31 #include "AliAODMCHeader.h"
  32
  33
  34 class iostream;
  35
  36 using namespace std;
  37
  38 ClassImp(AliAnalysisTaskConversionQA)
  39
  40 //________________________________________________________________________
  41 AliAnalysisTaskConversionQA::AliAnalysisTaskConversionQA() : AliAnalysisTaskSE(),
  42    fV0Reader(NULL),
  43    fConversionGammas(NULL),
  44    fConversionCuts(NULL),
  45    fInputEvent(NULL),
  46    fNumberOfESDTracks(0),
  47    fMCEvent(NULL),
  48    fMCStack(NULL),
  49    fTreeQA(NULL),
  50    fIsHeavyIon(kFALSE),
  51    ffillTree(kFALSE),
  52    ffillHistograms(kFALSE),
  53    fOutputList(NULL),
  54    fTreeList(NULL),
  55    fESDList(NULL),
  56    hVertexZ(NULL),
  57    hNGoodESDTracks(NULL),
  58    hNV0Tracks(NULL),
  59    hNContributorsVertex(NULL),
  60    hITSClusterPhi(NULL),
  61    hGammaPt(NULL),
  62    hGammaPhi(NULL),
  63    hGammaEta(NULL),
  64    hGammaChi2perNDF(NULL),
  65    hGammaPsiPair(NULL),
  66    hGammaArmenteros(NULL),
  67    hGammaCosinePointingAngle(NULL),
  68    hGammaInvMass(NULL),
  69    hElecPt(NULL),
  70    hElecEta(NULL),
  71    hElecPhi(NULL),
  72    hElecNfindableClsTPC(NULL),
  73    hPosiNfindableClsTPC(NULL),
  74    hElecClsTPC(NULL),
  75    hPosiClsTPC(NULL),
  76    hElectrondEdxP(NULL),
  77    hElectronITSdEdxP(NULL),
  78    hElectronTOFP(NULL),
  79    hElectronNSigmadEdxP(NULL),
  80    hElectronNSigmadEdxEta(NULL),
  81    hElectronNSigmaPiondEdxP(NULL),
  82    hElectronNSigmaITSP(NULL),
  83    hElectronNSigmaTOFP(NULL),
  84    hPositrondEdxP(NULL),
  85    hPositronITSdEdxP(NULL),
  86    hPositronTOFP(NULL),
  87    hPositronNSigmadEdxP(NULL),
  88    hPositronNSigmadEdxEta(NULL),
  89    hPositronNSigmaPiondEdxP(NULL),
  90    hPositronNSigmaITSP(NULL),
  91    hPositronNSigmaTOFP(NULL),
  92 //    hElecAsymP(NULL),
  93 //    fTrueList(NULL),
  94 //    hTrueResolutionR(NULL),
  95 //    hTrueResolutionZ(NULL),
  96 //    hTrueResolutionPhi(NULL),
  97 //    hTrueGammaPt(NULL),
  98 //    hTrueGammaPhi(NULL),
  99 //    hTrueGammaEta(NULL),
 100 //    hTrueGammaMass(NULL),
 101 //    hTrueGammaChi2perNDF(NULL),
 102 //    hTrueGammaPsiPair(NULL),
 103 //    hTrueGammaQt(NULL),
 104 //    hTrueGammaCosinePointingAngle(NULL),
 105 //    hTrueGammaXY(NULL),
 106 //    hTrueGammaZR(NULL),
 107 //    hTrueElecPt(NULL),
 108 //    hTrueElecEta(NULL),
 109 //    hTrueElecPhi(NULL),
 110 //    hTrueElecNfindableClsTPC(NULL),
 111 //    hTruePosiNfindableClsTPC(NULL),
 112 //    hTrueElecAsymP(NULL),
 113    fGammaPt(0),
 114    fGammaTheta(0),
 115    fGammaChi2NDF(0),
 116    fGammaPhotonProp(5),
 117    fGammaConvCoord(5),
 118    fDaughterProp(24),
 119    fKind(0),
 120    fIsMC(kFALSE),
 121    fnGammaCandidates(1),
 122    fMCStackPos(NULL),
 123    fMCStackNeg(NULL)
 124 {
 125
 126 }
 127
 128 AliAnalysisTaskConversionQA::AliAnalysisTaskConversionQA(const char *name) : AliAnalysisTaskSE(name),
 129    fV0Reader(NULL),
 130    fConversionGammas(NULL),
 131    fConversionCuts(NULL),
 132    fInputEvent(NULL),
 133    fNumberOfESDTracks(0),
 134    fMCEvent(NULL),
 135    fMCStack(NULL),
 136    fTreeQA(NULL),
 137    fIsHeavyIon(kFALSE),
 138    ffillTree(kFALSE),
 139    ffillHistograms(kFALSE),
 140    fOutputList(NULL),
 141    fTreeList(NULL),
 142    fESDList(NULL),
 143    hVertexZ(NULL),
 144    hNGoodESDTracks(NULL),
 145    hNV0Tracks(NULL),
 146    hNContributorsVertex(NULL),
 147    hITSClusterPhi(NULL),
 148    hGammaPt(NULL),
 149    hGammaPhi(NULL),
 150    hGammaEta(NULL),
 151    hGammaChi2perNDF(NULL),
 152    hGammaPsiPair(NULL),
 153    hGammaArmenteros(NULL),
 154    hGammaCosinePointingAngle(NULL),
 155    hGammaInvMass(NULL),
 156    hElecPt(NULL),
 157    hElecEta(NULL),
 158    hElecPhi(NULL),
 159    hElecNfindableClsTPC(NULL),
 160    hPosiNfindableClsTPC(NULL),
 161    hElecClsTPC(NULL),
 162    hPosiClsTPC(NULL),
 163    hElectrondEdxP(NULL),
 164    hElectronITSdEdxP(NULL),
 165    hElectronTOFP(NULL),
 166    hElectronNSigmadEdxP(NULL),
 167    hElectronNSigmadEdxEta(NULL),
 168    hElectronNSigmaPiondEdxP(NULL),
 169    hElectronNSigmaITSP(NULL),
 170    hElectronNSigmaTOFP(NULL),
 171    hPositrondEdxP(NULL),
 172    hPositronITSdEdxP(NULL),
 173    hPositronTOFP(NULL),
 174    hPositronNSigmadEdxP(NULL),
 175    hPositronNSigmadEdxEta(NULL),
 176    hPositronNSigmaPiondEdxP(NULL),
 177    hPositronNSigmaITSP(NULL),
 178    hPositronNSigmaTOFP(NULL),
 179 //    hGammaXY(NULL),
 180 //    hGammaZR(NULL),
 181 //    hElecAsymP(NULL),
 182 //    fTrueList(NULL),
 183 //    hTrueResolutionR(NULL),
 184 //    hTrueResolutionZ(NULL),
 185 //    hTrueResolutionPhi(NULL),
 186 //    hTrueGammaPt(NULL),
 187 //    hTrueGammaPhi(NULL),
 188 //    hTrueGammaEta(NULL),
 189 //    hTrueGammaMass(NULL),
 190 //    hTrueGammaChi2perNDF(NULL),
 191 //    hTrueGammaPsiPair(NULL),
 192 //    hTrueGammaQt(NULL),
 193 //    hTrueGammaCosinePointingAngle(NULL),
 194 //    hTrueGammaXY(NULL),
 195 //    hTrueGammaZR(NULL),
 196 //    hTrueElecPt(NULL),
 197 //    hTrueElecEta(NULL),
 198 //    hTrueElecPhi(NULL),
 199 //    hTrueElecNfindableClsTPC(NULL),
 200 //    hTruePosiNfindableClsTPC(NULL),
 201 //    hTrueElecAsymP(NULL),
 202    fGammaPt(0),
 203    fGammaTheta(0),
 204    fGammaChi2NDF(0),
 205    fGammaPhotonProp(5),
 206    fGammaConvCoord(5),
 207    fDaughterProp(24),
 208    fKind(0),
 209    fIsMC(kFALSE),
 210    fnGammaCandidates(1),
 211    fMCStackPos(NULL),
 212    fMCStackNeg(NULL)
 213 {
 214    // Default constructor
 215
 216    DefineInput(0, TChain::Class());
 217    DefineOutput(1, TList::Class());
 218 }
 219
 220 //________________________________________________________________________
 221 AliAnalysisTaskConversionQA::~AliAnalysisTaskConversionQA()
 222 {
 223    // default deconstructor
 224
 225 }
 226 //________________________________________________________________________
 227 void AliAnalysisTaskConversionQA::UserCreateOutputObjects()
 228 {
 229    // Create User Output Objects
 230
 231    if(fOutputList != NULL){
 232       delete fOutputList;
 233       fOutputList = NULL;
 234    }
 235    if(fOutputList == NULL){
 236       fOutputList = new TList();
 237       fOutputList->SetOwner(kTRUE);
 238    }
 239
 240    if(ffillHistograms){
 241
 242       fESDList = new TList();
 243       fESDList->SetOwner(kTRUE);
 244       fESDList->SetName("ESD QA");
 245       fOutputList->Add(fESDList);
 246
 247       hVertexZ = new TH1F("Vertex_Z","Vertex_Z",300,-15,15);
 248       fESDList->Add(hVertexZ);
 249       hNContributorsVertex = new TH1I("ContrVertex_Z","ContrVertex_Z",3000,0,3000);
 250       fESDList->Add(hNContributorsVertex);
 251       if(fIsHeavyIon) hNGoodESDTracks = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
 252       else hNGoodESDTracks = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
 253       fESDList->Add(hNGoodESDTracks);
 254       if(fIsHeavyIon) hNV0Tracks = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
 255       else hNV0Tracks = new TH1I("V0 Multiplicity","V0 Multiplicity",2000,0,2000);
 256       fESDList->Add(hNV0Tracks);
 257
 258       hITSClusterPhi = new TH2F("ITSClusterPhi","hITSClusterPhi",72,0,2*TMath::Pi(),7,0,7);
 259       fESDList->Add(hITSClusterPhi);
 260       hGammaPt = new TH1F("Gamma_Pt","Gamma_Pt",250,0,25);
 261       fESDList->Add(hGammaPt);
 262       hGammaPhi = new TH1F("Gamma_Phi","Gamma_Phi",360,0,2*TMath::Pi());
 263       fESDList->Add(hGammaPhi);
 264       hGammaEta = new TH1F("Gamma_Eta","Gamma_Eta",600,-1.5,1.5);
 265       fESDList->Add(hGammaEta);
 266       hGammaChi2perNDF = new TH1F("Gamma_Chi2perNDF","Gamma_Chi2perNDF",500,0,100);
 267       fESDList->Add(hGammaChi2perNDF);
 268       hGammaPsiPair = new TH1F("Gamma_PsiPair","Gamma_PsiPair",500,0,2);
 269       fESDList->Add(hGammaPsiPair);
 270       hGammaArmenteros = new TH2F("Gamma_Armenteros","Gamma_Armenteros",200,-1,1,400,0,0.1);
 271       fESDList->Add(hGammaArmenteros);
 272       hGammaCosinePointingAngle = new TH1F("Gamma_CosinePointingAngle","Gamma_CosinePointingAngle",1000,-1.,1.);
 273       fESDList->Add(hGammaCosinePointingAngle);
 274       hGammaInvMass = new TH1F( "Gamma_InvMass","",200, 0, 0.2);
 275       fESDList->Add(hGammaInvMass);
 276       hElecPt = new TH2F("Electron_Positron_Pt","Electron_Positron_Pt",250,0,25,250,0,25);
 277       fESDList->Add(hElecPt);
 278       hElecEta = new TH2F("Electron_Positron_Eta","Electron_Positron_Eta",600,-1.5,1.5,600,-1.5,1.5);
 279       fESDList->Add(hElecEta);
 280       hElecPhi = new TH2F("Electron_Positron_Phi","Electron_Positron_Phi",360,0,2*TMath::Pi(),360,0,2*TMath::Pi());
 281       fESDList->Add(hElecPhi);
 282       hElecClsTPC = new TH1F("Electron_ClusterTPC","Electron_ClusterTPC",200,0,200);
 283       fESDList->Add(hElecClsTPC);
 284       hPosiClsTPC = new TH1F("Positron_ClusterTPC","Positron_ClusterTPC",200,0,200);
 285       fESDList->Add(hPosiClsTPC);
 286
 287       hElecNfindableClsTPC = new TH1F("Electron_findableClusterTPC","Electron_findableClusterTPC",100,0,1);
 288       fESDList->Add(hElecNfindableClsTPC);
 289       hPosiNfindableClsTPC = new TH1F("Positron_findableClusterTPC","Positron_findableClusterTPC",100,0,1);
 290       fESDList->Add(hPosiNfindableClsTPC);
 291
 292       hElectrondEdxP =  new TH2F("Electron_dEdx_P","Electron_dEdx_P",100, 0.05, 20, 200, 0, 200);
 293       SetLogBinningXTH2(hElectrondEdxP);
 294       fESDList->Add(hElectrondEdxP);
 295       hPositrondEdxP =  new TH2F("Positron_dEdx_P","Positron_dEdx_P",100, 0.05, 20, 200, 0, 200);
 296       SetLogBinningXTH2(hPositrondEdxP);
 297       fESDList->Add(hPositrondEdxP);
 298       hElectronNSigmadEdxP =  new TH2F("Electron_NSigmadEdx_P","Electron_NSigmadEdx_P",100, 0.05, 20, 200, -10, 10);
 299       SetLogBinningXTH2(hElectronNSigmadEdxP);
 300       fESDList->Add(hElectronNSigmadEdxP);
 301           hElectronNSigmadEdxEta =  new TH2F("Electron_NSigmadEdx_Eta","Electron_NSigmadEdx_Eta",140, -1.4, 1.4, 200, -10, 10);
 302           fESDList->Add(hElectronNSigmadEdxEta);
 303       hPositronNSigmadEdxP =  new TH2F("Positron_NSigmadEdx_P","Positron_NSigmadEdx_P",100, 0.05, 20, 200, -10, 10);
 304       SetLogBinningXTH2(hPositronNSigmadEdxP);
 305       fESDList->Add(hPositronNSigmadEdxP);
 306           hPositronNSigmadEdxEta =  new TH2F("Positron_NSigmadEdx_Eta","Positron_NSigmadEdx_Eta",140, -1.4, 1.4, 200, -10, 10);
 307           fESDList->Add(hPositronNSigmadEdxEta);
 308       hElectronNSigmaPiondEdxP =  new TH2F("Electron_NSigmaPiondEdx_P","Electron_NSigmaPiondEdx_P",100, 0.05, 20, 200, -10, 10);
 309       SetLogBinningXTH2(hElectronNSigmaPiondEdxP);
 310       fESDList->Add(hElectronNSigmaPiondEdxP);
 311       hPositronNSigmaPiondEdxP =  new TH2F("Positron_NSigmaPiondEdx_P","Positron_NSigmaPiondEdx_P",100, 0.05, 20, 200, -10, 10);
 312       SetLogBinningXTH2(hPositronNSigmaPiondEdxP);
 313       fESDList->Add(hPositronNSigmaPiondEdxP);
 314
 315       hElectronTOFP =  new TH2F("Electron_TOF_P","Electron_TOF_P",100, 0.05, 20, 600, -1000, 29000);
 316       SetLogBinningXTH2(hElectronTOFP);
 317       fESDList->Add(hElectronTOFP);
 318       hPositronTOFP =  new TH2F("Positron_TOF_P","Positron_TOF_P",100, 0.05, 20, 600, -1000, 29000);
 319       SetLogBinningXTH2(hPositronTOFP);
 320       fESDList->Add(hPositronTOFP);
 321       hElectronNSigmaTOFP =  new TH2F("Electron_NSigmaTOF_P","Electron_NSigmaTOF_P",100, 0.05, 20, 200, -10, 10);
 322       SetLogBinningXTH2(hElectronNSigmaTOFP);
 323       fESDList->Add(hElectronNSigmaTOFP);
 324       hPositronNSigmaTOFP =  new TH2F("Positron_NSigmaTOF_P","Positron_NSigmaTOF_P",100, 0.05, 20, 200, -10, 10);
 325       SetLogBinningXTH2(hPositronNSigmaTOFP);
 326       fESDList->Add(hPositronNSigmaTOFP);
 327
 328       hElectronITSdEdxP  =  new TH2F("Electron_ITSdEdx_P","Electron_ITSdEdx_P",100, 0.05, 20, 200, 0, 200);
 329       SetLogBinningXTH2(hElectronITSdEdxP);
 330       fESDList->Add(hElectronITSdEdxP);
 331       hPositronITSdEdxP =  new TH2F("Positron_ITSdEdx_P","Positron_ITSdEdx_P",100, 0.05, 20, 200, 0, 200);
 332       SetLogBinningXTH2(hPositronITSdEdxP);
 333       fESDList->Add(hPositronITSdEdxP);
 334       hElectronNSigmaITSP =  new TH2F("Electron_NSigmaITS_P","Electron_NSigmaITS_P",100, 0.05, 20, 200, -10, 10);
 335       SetLogBinningXTH2(hElectronNSigmaITSP);
 336       fESDList->Add(hElectronNSigmaITSP);
 337       hPositronNSigmaITSP =  new TH2F("Positron_NSigmaITS_P","Positron_NSigmaITS_P",100, 0.05, 20, 200, -10, 10);
 338       SetLogBinningXTH2(hPositronNSigmaITSP);
 339       fESDList->Add(hPositronNSigmaITSP);
 340
 341
 342
 343 //       hGammaXY = new TH2F("Gamma_ConversionPoint_XY","Gamma_ConversionPoint_XY",960,-120,120,960,-120,120);
 344 //       fESDList->Add(hGammaXY);
 345 //       hGammaZR= new TH2F("Gamma_ConversionPoint_ZR","Gamma_ConversionPoint_ZR",1200,-150,150,480,0,120);
 346 //       fESDList->Add(hGammaZR);
 347
 348
 349 //       hElecAsymP = new TH2F("Electron_Asym_vs_P", "Electron_Asym_vs_P",200,0.,20.,200,0.,1.);
 350 //       fESDList->Add(hElecAsymP);
 351
 352 //       if(fIsMC){
 353 //          fTrueList = new TList();
 354 //          fTrueList->SetOwner(kTRUE);
 355 //          fTrueList->SetName("True QA");
 356 //          fOutputList->Add(fTrueList);
 357 //
 358 //          hTrueResolutionR = new TH2F("True_ConversionPointResolution_R","True_ConversionPointResolution_R",240,0,120,200,-20,20);
 359 //          fTrueList->Add(hTrueResolutionR);
 360 //          hTrueResolutionZ = new TH2F("True_ConversionPointResolution_Z","True_ConversionPointResolution_Z",480,-120,120,200,-20,20);
 361 //          fTrueList->Add(hTrueResolutionZ);
 362 //          hTrueResolutionPhi = new TH2F("True_ConversionPointResolution_Phi","True_ConversionPointResolution_Phi",360,0,2*TMath::Pi(),200,-TMath::Pi()/30., TMath::Pi()/30.);
 363 //          fTrueList->Add(hTrueResolutionPhi);
 364 //
 365 //          hTrueGammaPt = new TH1F("True_Gamma_Pt","True_Gamma_Pt",250,0,25);
 366 //          fTrueList->Add(hTrueGammaPt);
 367 //          hTrueGammaPhi = new TH1F("True_Gamma_Phi","True_Gamma_Phi",360,0,2*TMath::Pi());
 368 //          fTrueList->Add(hTrueGammaPhi);
 369 //          hTrueGammaEta = new TH1F("True_Gamma_Eta","True_Gamma_Eta",600,-1.5,1.5);
 370 //          fTrueList->Add(hTrueGammaEta);
 371 //          hTrueGammaMass = new TH1F("True_Gamma_Mass","True_Gamma_Mass",1000,0,0.3);
 372 //          fTrueList->Add(hTrueGammaMass);
 373 //          hTrueGammaChi2perNDF = new TH1F("True_Gamma_Chi2perNDF","True_Gamma_Chi2perNDF",500,0,100);
 374 //          fTrueList->Add(hTrueGammaChi2perNDF);
 375 //          hTrueGammaPsiPair = new TH1F("True_Gamma_PsiPair","True_Gamma_PsiPair",500,0,2);
 376 //          fTrueList->Add(hTrueGammaPsiPair);
 377 //          hTrueGammaQt = new TH1F("True_Gamma_Qt","True_Gamma_Qt",400,0,0.1);
 378 //          fTrueList->Add(hTrueGammaQt);
 379 //          hTrueGammaCosinePointingAngle = new TH1F("True_Gamma_CosinePointingAngle","True_Gamma_CosinePointingAngle",900,0.7,1.);
 380 //          fTrueList->Add(hTrueGammaCosinePointingAngle);
 381 //          hTrueGammaXY = new TH2F("True_Gamma_ConversionPoint_XY","True_Gamma_ConversionPoint_XY",960,-120,120,960,-120,120);
 382 //          fTrueList->Add(hTrueGammaXY);
 383 //          hTrueGammaZR= new TH2F("TrueGamma_ConversionPoint_ZR","TrueGamma_ConversionPoint_ZR",1200,-150,150,480,0,120);
 384 //          fTrueList->Add(hTrueGammaZR);
 385 //
 386 //          hTrueElecPt = new TH2F("True_Electron_Positron_Pt","True_Electron_Positron_Pt",250,0,25,250,0,25);
 387 //          fTrueList->Add(hTrueElecPt);
 388 //          hTrueElecEta = new TH2F("True_Electron_Positron_Eta","True_Electron_Positron_Eta",600,-1.5,1.5,600,-1.5,1.5);
 389 //          fTrueList->Add(hTrueElecEta);
 390 //          hTrueElecPhi = new TH2F("True_Electron_Positron_Phi","True_Electron_Positron_Phi",360,0,2*TMath::Pi(),360,0,2*TMath::Pi());
 391 //          fTrueList->Add(hTrueElecPhi);
 392 //          hTrueElecNfindableClsTPC = new TH1F("True_Electron_findableClusterTPC","True_Electron_findableClusterTPC",100,0,1);
 393 //          fTrueList->Add(hTrueElecNfindableClsTPC);
 394 //          hTruePosiNfindableClsTPC = new TH1F("True_Positron_findableClusterTPC","True_Positron_findableClusterTPC",100,0,1);
 395 //          fTrueList->Add(hTruePosiNfindableClsTPC);
 396 //                               hTrueElecAsymP = new TH2F("True_Electron_Asym_vs_P", "True_Electron_Asym_vs_P",200,0.,20.,200,0.,1.);
 397 //                               fTrueList->Add(hTrueElecAsymP);
 398 //       }
 399       if(fConversionCuts->GetCutHistograms()){
 400          fOutputList->Add(fConversionCuts->GetCutHistograms());
 401       }
 402    }
 403
 404    if(ffillTree){
 405       fTreeList = new TList();
 406       fTreeList->SetOwner(kTRUE);
 407       fTreeList->SetName("TreeList");
 408       fOutputList->Add(fTreeList);
 409
 410       fTreeQA = new TTree("PhotonQA","PhotonQA");
 411
 412       fTreeQA->Branch("daughterProp",&fDaughterProp);
 413       fTreeQA->Branch("recCords",&fGammaConvCoord);
 414       fTreeQA->Branch("photonProp",&fGammaPhotonProp);
 415       fTreeQA->Branch("pt",&fGammaPt,"fGammaPt/F");
 416       fTreeQA->Branch("theta",&fGammaTheta,"fGammaTheta/F");
 417       fTreeQA->Branch("chi2ndf",&fGammaChi2NDF,"fGammaChi2NDF/F");
 418       if (fIsMC) {
 419          fTreeQA->Branch("kind",&fKind,"fKind/b");
 420       }
 421       fTreeList->Add(fTreeQA);
 422
 423    }
 424
 425    fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
 426
 427    PostData(1, fOutputList);
 428 }
 429 //_____________________________________________________________________________
 430 Bool_t AliAnalysisTaskConversionQA::Notify()
 431 {
 432    if(!fConversionCuts->GetDoEtaShift()) return kTRUE;; // No Eta Shift requested, continue
 433
 434    if(fConversionCuts->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
 435       fConversionCuts->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
 436       fConversionCuts->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
 437       return kTRUE;
 438    }
 439    else{
 440       printf(" Gamma Conversion QA Task %s :: Eta Shift Manually Set to %f \n\n",
 441              (fConversionCuts->GetCutNumber()).Data(),fConversionCuts->GetEtaShift());
 442       fConversionCuts->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
 443    }
 444
 445    return kTRUE;
 446 }
 447 //________________________________________________________________________
 448 void AliAnalysisTaskConversionQA::UserExec(Option_t *){
 449
 450
 451
 452    Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
 453    if(eventQuality != 0){// Event Not Accepted
 454       return;
 455    }
 456    fInputEvent = InputEvent();
 457    if(fIsMC) fMCEvent = MCEvent();
 458    if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){ fMCStack = fMCEvent->Stack(); }
 459
 460    Int_t eventNotAccepted =
 461       fConversionCuts->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
 462    if(eventNotAccepted) return; // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
 463
 464    fConversionGammas=fV0Reader->GetReconstructedGammas();
 465
 466    if(fMCEvent){
 467       if(fConversionCuts->GetSignalRejection() != 0){
 468          if(fInputEvent->IsA()==AliESDEvent::Class()){
 469                fConversionCuts->GetNotRejectedParticles(fConversionCuts->GetSignalRejection(),
 470                                                         fConversionCuts->GetAcceptedHeader(),
 471                                                         fMCEvent);
 472          }
 473          else if(fInputEvent->IsA()==AliAODEvent::Class()){
 474             fConversionCuts->GetNotRejectedParticles(fConversionCuts->GetSignalRejection(),
 475                                                       fConversionCuts->GetAcceptedHeader(),
 476                                                       fInputEvent);
 477          }
 478       }
 479    }
 480
 481    if(ffillHistograms){
 482       CountTracks();
 483       hVertexZ->Fill(fInputEvent->GetPrimaryVertex()->GetZ());
 484       hNContributorsVertex->Fill(fConversionCuts->GetNumberOfContributorsVtx(fInputEvent));
 485       hNGoodESDTracks->Fill(fNumberOfESDTracks);
 486       hNV0Tracks->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
 487    }
 488
 489    if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
 490       RelabelAODPhotonCandidates(kTRUE);    // In case of AODMC relabeling MC
 491       fV0Reader->RelabelAODs(kTRUE);
 492    }
 493
 494
 495    for(Int_t firstGammaIndex=0;firstGammaIndex<fConversionGammas->GetEntriesFast();firstGammaIndex++){
 496       AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fConversionGammas->At(firstGammaIndex));
 497       if (gamma==NULL) continue;
 498       if(fMCEvent && fConversionCuts->GetSignalRejection() != 0){
 499          if(!fConversionCuts->IsParticleFromBGEvent(gamma->GetMCLabelPositive(), fMCStack, fInputEvent))
 500             continue;
 501          if(!fConversionCuts->IsParticleFromBGEvent(gamma->GetMCLabelNegative(), fMCStack, fInputEvent))
 502             continue;
 503       }
 504       if(!fConversionCuts->PhotonIsSelected(gamma,fInputEvent)){
 505          continue;
 506       }
 507
 508       if(ffillTree) ProcessQATree(gamma);
 509       if(ffillHistograms) ProcessQA(gamma);
 510    }
 511
 512    if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
 513       RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
 514       fV0Reader->RelabelAODs(kFALSE);
 515    }
 516
 517    PostData(1, fOutputList);
 518 }
 519
 520
 521 ///________________________________________________________________________
 522 void AliAnalysisTaskConversionQA::ProcessQATree(AliAODConversionPhoton *gamma){
 523
 524    // Fill Histograms for QA and MC
 525    AliVEvent* event = (AliVEvent*) InputEvent();
 526
 527
 528
 529    AliPIDResponse* pidResonse = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetPIDResponse();
 530
 531    fGammaPt = gamma->GetPhotonPt();
 532
 533    fGammaTheta = gamma->Theta();
 534    fGammaChi2NDF = gamma->GetChi2perNDF();
 535
 536    fGammaPhotonProp(0)  = gamma->GetArmenterosQt();
 537    fGammaPhotonProp(1)  = gamma->GetArmenterosAlpha();
 538    fGammaPhotonProp(2)  = gamma->GetPsiPair();
 539    fGammaPhotonProp(3) = fConversionCuts->GetCosineOfPointingAngle(gamma,event);
 540         fGammaPhotonProp(4) = gamma->GetMass();
 541
 542    fGammaConvCoord(0) = gamma->GetConversionX();
 543    fGammaConvCoord(1) = gamma->GetConversionY();
 544    fGammaConvCoord(2) = gamma->GetConversionZ();
 545    fGammaConvCoord(3) = gamma->GetConversionRadius();
 546    fGammaConvCoord(4) = gamma->GetPhotonPhi();
 547
 548    AliVTrack * negTrack = fConversionCuts->GetTrack(event, gamma->GetTrackLabelNegative());
 549    AliVTrack * posTrack = fConversionCuts->GetTrack(event, gamma->GetTrackLabelPositive());
 550
 551
 552    if(!negTrack||!posTrack)return;
 553
 554    fKind = 9;
 555    if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){
 556       fKind = IsTruePhotonESD(gamma);
 557    } else if (fMCEvent && fInputEvent->IsA()==AliAODEvent::Class()){
 558 //        cout << "entering IsTruePhotonAOD" << endl;
 559       fKind = IsTruePhotonAOD(gamma);
 560    }
 561
 562    fDaughterProp(0) =  posTrack->Pt();
 563    fDaughterProp(7) =  negTrack->Pt();
 564    fDaughterProp(1) =  posTrack->Theta();
 565    fDaughterProp(8) =  negTrack->Theta();
 566    // dEdx TPC
 567    fDaughterProp(2) =  posTrack->GetTPCsignal();
 568    fDaughterProp(3) =  pidResonse->NumberOfSigmasTPC(posTrack,AliPID::kElectron);
 569    fDaughterProp(22) =  pidResonse->NumberOfSigmasTPC(posTrack,AliPID::kPion);
 570    fDaughterProp(9) =  negTrack->GetTPCsignal();
 571    fDaughterProp(10) =  pidResonse->NumberOfSigmasTPC(negTrack,AliPID::kElectron);
 572    fDaughterProp(23) =  pidResonse->NumberOfSigmasTPC(negTrack,AliPID::kPion);
 573    Int_t nPosClusterITS = 0;
 574    Int_t nNegClusterITS = 0;
 575    for(Int_t itsLayer = 0; itsLayer<6;itsLayer++){
 576       if(TESTBIT(negTrack->GetITSClusterMap(),itsLayer)){
 577          nNegClusterITS++;
 578       }
 579       if(TESTBIT(posTrack->GetITSClusterMap(),itsLayer)){
 580          nPosClusterITS++;
 581       }
 582    }
 583
 584    // ITS signal
 585    fDaughterProp(14) =  (Float_t)nPosClusterITS;
 586    fDaughterProp(15) =  (Float_t)nNegClusterITS;
 587    if (nPosClusterITS > 0 ){
 588       fDaughterProp(16) =  posTrack->GetITSsignal();
 589       fDaughterProp(20) =  pidResonse->NumberOfSigmasITS(posTrack,AliPID::kElectron);
 590    } else {
 591       fDaughterProp(16) =  1000;
 592       fDaughterProp(20) =  20;
 593    }
 594    if (nNegClusterITS > 0 ){
 595       fDaughterProp(17) =  negTrack->GetITSsignal();
 596       fDaughterProp(21) =  pidResonse->NumberOfSigmasITS(negTrack,AliPID::kElectron);
 597    } else {
 598       fDaughterProp(17) =  1000;
 599       fDaughterProp(21) =  20;
 600    }
 601
 602    // TOF
 603    if((posTrack->GetStatus() & AliESDtrack::kTOFpid) && !(posTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
 604       Double_t t0pos = pidResonse->GetTOFResponse().GetStartTime(posTrack->P());
 605       Double_t timesPos[9];
 606       posTrack->GetIntegratedTimes(timesPos);
 607       Double_t TOFsignalPos =   posTrack->GetTOFsignal();
 608       Double_t dTpos = TOFsignalPos - t0pos - timesPos[0];
 609       fDaughterProp(4) =  dTpos;
 610       fDaughterProp(5) =  pidResonse->NumberOfSigmasTOF(posTrack, AliPID::kElectron);
 611    } else {
 612       fDaughterProp(4) =  20000;
 613       fDaughterProp(5) =  -20;
 614    }
 615    if((negTrack->GetStatus() & AliESDtrack::kTOFpid) && !(negTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
 616       Double_t t0neg = pidResonse->GetTOFResponse().GetStartTime(negTrack->P());
 617       Double_t timesNeg[9];
 618       negTrack->GetIntegratedTimes(timesNeg);
 619       Double_t TOFsignalNeg =   negTrack->GetTOFsignal();
 620       Double_t dTneg = TOFsignalNeg - t0neg - timesNeg[0];
 621       fDaughterProp(11) =  dTneg;
 622       fDaughterProp(12) =  pidResonse->NumberOfSigmasTOF(negTrack, AliPID::kElectron);
 623    } else {
 624       fDaughterProp(11) =  20000;
 625       fDaughterProp(12) =  -20;
 626    }
 627
 628    fDaughterProp(6) =  (Float_t)posTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius()));
 629    fDaughterProp(18) =  posTrack->GetNcls(1);
 630    fDaughterProp(13) =  (Float_t)negTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius()));
 631    fDaughterProp(19) =  negTrack->GetNcls(1);
 632
 633    if (fTreeQA){
 634       fTreeQA->Fill();
 635    }
 636 }
 637
 638 //_____________________________________________________________________________________________________
 639 void AliAnalysisTaskConversionQA::ProcessQA(AliAODConversionPhoton *gamma){
 640
 641    AliPIDResponse* pidResonse = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetPIDResponse();
 642
 643    // Fill Histograms for QA and MC
 644
 645    hGammaPt->Fill(gamma->GetPhotonPt());
 646    hGammaPhi->Fill(gamma->GetPhotonPhi());
 647    hGammaEta->Fill(gamma->Eta());
 648    hGammaChi2perNDF->Fill(gamma->GetChi2perNDF());
 649    hGammaPsiPair->Fill(gamma->GetPsiPair());
 650    hGammaArmenteros->Fill(gamma->GetArmenterosAlpha(),gamma->GetArmenterosQt());
 651    hGammaCosinePointingAngle->Fill(fConversionCuts->GetCosineOfPointingAngle(gamma,fInputEvent));
 652    hGammaInvMass->Fill(gamma->GetMass());
 653 //    hGammaXY->Fill(gamma->GetConversionX(),gamma->GetConversionY());
 654 //    hGammaZR->Fill(gamma->GetConversionZ(),gamma->GetConversionRadius());
 655
 656    AliVTrack * negTrack = fConversionCuts->GetTrack(fInputEvent, gamma->GetTrackLabelNegative());
 657    AliVTrack * posTrack = fConversionCuts->GetTrack(fInputEvent, gamma->GetTrackLabelPositive());
 658    if(!negTrack||!posTrack)return;
 659
 660
 661    hElecPt->Fill(negTrack->Pt(),posTrack->Pt());
 662    hElecEta->Fill(negTrack->Eta(),posTrack->Eta());
 663    hElecPhi->Fill(negTrack->Phi(),posTrack->Phi());
 664
 665    hElecNfindableClsTPC->Fill((Float_t)posTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius())));
 666    hPosiNfindableClsTPC->Fill((Float_t)negTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius())));
 667    hElecClsTPC->Fill(negTrack->GetNcls(1));
 668    hPosiClsTPC->Fill(posTrack->GetNcls(1));
 669    //TPC dEdx
 670    hElectrondEdxP->Fill(negTrack->P() ,negTrack->GetTPCsignal());
 671    hElectronNSigmadEdxP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kElectron));
 672    hElectronNSigmadEdxEta->Fill(negTrack->Eta() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kElectron));
 673    hElectronNSigmaPiondEdxP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kPion));
 674    hPositrondEdxP->Fill(posTrack->P() ,posTrack->GetTPCsignal());
 675    hPositronNSigmadEdxP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kElectron));
 676    hPositronNSigmadEdxEta->Fill(posTrack->Eta() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kElectron));
 677    hPositronNSigmaPiondEdxP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kPion));
 678
 679    //TOF signal
 680    if((negTrack->GetStatus() & AliESDtrack::kTOFpid) && !(negTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
 681       Double_t t0neg = pidResonse->GetTOFResponse().GetStartTime(negTrack->P());
 682       Double_t timesNeg[9];
 683       negTrack->GetIntegratedTimes(timesNeg);
 684       Double_t TOFsignalNeg = negTrack->GetTOFsignal();
 685       Double_t dTneg = TOFsignalNeg - t0neg - timesNeg[0];
 686       hElectronTOFP->Fill(negTrack->P() ,dTneg);
 687       hElectronNSigmaTOFP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTOF(negTrack, AliPID::kElectron));
 688    }
 689    if((posTrack->GetStatus() & AliESDtrack::kTOFpid) && !(posTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
 690       Double_t t0pos = pidResonse->GetTOFResponse().GetStartTime(posTrack->P());
 691       Double_t timesPos[9];
 692       posTrack->GetIntegratedTimes(timesPos);
 693       Double_t TOFsignalPos = posTrack->GetTOFsignal();
 694       Double_t dTpos = TOFsignalPos - t0pos - timesPos[0];
 695       hPositronTOFP->Fill(posTrack->P() ,dTpos);
 696       hPositronNSigmaTOFP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTOF(posTrack, AliPID::kElectron));
 697    }
 698
 699    Int_t nPosClusterITS = 0;
 700    Int_t nNegClusterITS = 0;
 701    for(Int_t itsLayer = 0; itsLayer<6;itsLayer++){
 702       if(TESTBIT(negTrack->GetITSClusterMap(),itsLayer)){
 703          nNegClusterITS++;
 704       }
 705       if(TESTBIT(posTrack->GetITSClusterMap(),itsLayer)){
 706          nPosClusterITS++;
 707       }
 708    }
 709    Double_t negtrackPhi = negTrack->Phi();
 710    Double_t postrackPhi = posTrack->Phi();
 711    hITSClusterPhi->Fill(negtrackPhi,nNegClusterITS);
 712    hITSClusterPhi->Fill(postrackPhi,nPosClusterITS);
 713
 714    // ITS signal
 715    if (nPosClusterITS > 0 ){
 716       hPositronITSdEdxP->Fill(posTrack->P() ,posTrack->GetITSsignal());
 717       hPositronNSigmaITSP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasITS(posTrack,AliPID::kElectron));
 718    }
 719    if (nNegClusterITS > 0 ){
 720       hElectronITSdEdxP->Fill(negTrack->P() ,negTrack->GetITSsignal());
 721       hElectronNSigmaITSP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasITS(negTrack,AliPID::kElectron));
 722    }
 723
 724
 725 }
 726
 727
 728 //________________________________________________________________________
 729 void AliAnalysisTaskConversionQA::CountTracks(){
 730
 731    if(fInputEvent->IsA()==AliESDEvent::Class()){
 732    // Using standard function for setting Cuts
 733    Bool_t selectPrimaries=kTRUE;
 734    AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
 735    EsdTrackCuts->SetMaxDCAToVertexZ(2);
 736    EsdTrackCuts->SetEtaRange(-0.8, 0.8);
 737    EsdTrackCuts->SetPtRange(0.15);
 738       fNumberOfESDTracks = 0;
 739       for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
 740          AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
 741          if(!curTrack) continue;
 742          // if(fMCEvent && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
 743          //    if(!((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack)) continue;
 744          // }
 745          if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTracks++;
 746       }
 747       delete EsdTrackCuts;
 748       EsdTrackCuts=0x0;
 749    }
 750    else if(fInputEvent->IsA()==AliAODEvent::Class()){
 751       fNumberOfESDTracks = 0;
 752       for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
 753          AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
 754          if(!curTrack->IsPrimaryCandidate()) continue;
 755          if(abs(curTrack->Eta())>0.8) continue;
 756          if(curTrack->Pt()<0.15) continue;
 757          if(abs(curTrack->ZAtDCA())>2) continue;
 758          fNumberOfESDTracks++;
 759       }
 760    }
 761
 762    return;
 763 }
 764
 765 UInt_t AliAnalysisTaskConversionQA::IsTruePhotonESD(AliAODConversionPhoton *TruePhotonCandidate)
 766 {
 767
 768
 769         UInt_t kind = 9;
 770         TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
 771         TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
 772         Int_t motherLabelPhoton;
 773         Int_t pdgCodePos = 0;
 774         Int_t pdgCodeNeg = 0;
 775         Int_t pdgCode = 0;
 776
 777
 778         if(posDaughter == NULL || negDaughter == NULL) {
 779                 kind = 9;
 780                 //              return kFALSE; // One particle does not exist
 781
 782         } else if( posDaughter->GetMother(0) != negDaughter->GetMother(0)  || (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) {
 783                 kind = 1;
 784                 //              return 1;
 785                 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
 786                 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
 787                 if(pdgCodePos==11 && pdgCodeNeg==11) return 10; //Electron Combinatorial
 788                 if(pdgCodePos==11 && pdgCodeNeg==11 &&
 789                         (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) return 15; //direct Electron Combinatorial
 790
 791                 if(pdgCodePos==211 && pdgCodeNeg==211) return 11; //Pion Combinatorial
 792                 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211))       return 12; //Pion, Proton Combinatorics
 793                 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) return 13; //Pion, Electron Combinatorics
 794                 if(pdgCodePos==321 || pdgCodeNeg==321) return 14; //Kaon combinatorics
 795         }else{
 796                 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
 797                 pdgCodePos=posDaughter->GetPdgCode();
 798                 pdgCodeNeg=negDaughter->GetPdgCode();
 799                 motherLabelPhoton= Photon->GetMother(0);
 800                 if ( TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode()) pdgCode = TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode();
 801
 802                 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) return 2; // true from hadronic decays
 803                 else if ( !(pdgCodeNeg==pdgCodePos)){
 804                         if(pdgCode == 111) return 3; // pi0 Dalitz
 805                         else if (pdgCode == 221) return 4; // eta Dalitz
 806                         else if (!(negDaughter->GetUniqueID() != 5 || posDaughter->GetUniqueID() !=5)){
 807                                 if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
 808                                         return 0; // primary photons
 809                                 } else if (pdgCode == 22){
 810                                         return 5; //secondary photons
 811                                 }
 812                         }
 813                 }
 814         }
 815
 816         return kind;
 817 }
 818
 819 //________________________________________________________________________
 820 UInt_t AliAnalysisTaskConversionQA::IsTruePhotonAOD(AliAODConversionPhoton *TruePhotonCandidate)
 821 {
 822
 823         UInt_t kind = 9;
 824         TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
 825         if (AODMCTrackArray!=NULL && TruePhotonCandidate!=NULL){
 826                 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
 827                 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
 828                 Int_t pdgCodePos = 0;
 829                 Int_t pdgCodeNeg = 0;
 830                 Int_t pdgCode = 0;
 831                 if(posDaughter == NULL || negDaughter == NULL) {
 832                         kind = 9;
 833                 } else if( posDaughter->GetMother() != negDaughter->GetMother()  || (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1)) {
 834                         kind = 1;
 835                         pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
 836                         pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
 837                         if(pdgCodePos==11 && pdgCodeNeg==11)    kind = 10; //Electron Combinatorial
 838                         if(pdgCodePos==11 && pdgCodeNeg==11 &&
 839                                 (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1))kind = 15; //direct Electron Combinatorial
 840
 841                         if(pdgCodePos==211 && pdgCodeNeg==211) kind = 11; //Pion Combinatorial
 842                         if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211))       kind = 12; //Pion, Proton Combinatorics
 843                         if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) kind = 13; //Pion, Electron Combinatorics
 844                         if(pdgCodePos==321 || pdgCodeNeg==321) kind = 14; //Kaon combinatorics
 845                 }else{
 846                         AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
 847                         pdgCodePos=posDaughter->GetPdgCode();
 848                         pdgCodeNeg=negDaughter->GetPdgCode();
 849
 850                         if ( Photon->GetPdgCode())
 851                                 pdgCode = Photon->GetPdgCode();
 852                         if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) kind = 2; // true from hadronic decays
 853                         else if ( !(pdgCodeNeg==pdgCodePos)){
 854                                 if(pdgCode == 111) kind = 3; // pi0 Dalitz
 855                                 else if (pdgCode == 221) kind = 4; // eta Dalitz
 856                                 else if (!(negDaughter->GetMCProcessCode() != 5 || posDaughter->GetMCProcessCode() !=5)){
 857                                         if(pdgCode == 22 && Photon->IsPrimary()){
 858                                                 kind = 0; // primary photons
 859                                         } else if (pdgCode == 22){
 860                                                 kind = 5; //secondary photons
 861                                         }
 862                                 }
 863                         }
 864                 }
 865
 866                 return kind;
 867         }
 868         return kind;
 869 }
 870
 871 //________________________________________________________________________
 872 void AliAnalysisTaskConversionQA::RelabelAODPhotonCandidates(Bool_t mode){
 873
 874    // Relabeling For AOD Event
 875    // ESDiD -> AODiD
 876    // MCLabel -> AODMCLabel
 877
 878    if(mode){
 879       fMCStackPos = new Int_t[fConversionGammas->GetEntries()];
 880       fMCStackNeg = new Int_t[fConversionGammas->GetEntries()];
 881    }
 882
 883    for(Int_t iGamma = 0;iGamma<fConversionGammas->GetEntries();iGamma++){
 884       AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fConversionGammas->At(iGamma);
 885       if(!PhotonCandidate) continue;
 886       if(!mode){// Back to ESD Labels
 887          PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
 888          PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
 889          //PhotonCandidate->IsAODMCLabel(kFALSE);
 890          continue;
 891       }
 892       fMCStackPos[iGamma] =  PhotonCandidate->GetMCLabelPositive();
 893       fMCStackNeg[iGamma] =  PhotonCandidate->GetMCLabelNegative();
 894
 895       Bool_t AODLabelPos = kFALSE;
 896       Bool_t AODLabelNeg = kFALSE;
 897
 898       for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
 899          AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
 900          if(!AODLabelPos){
 901             if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
 902                PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
 903                AODLabelPos = kTRUE;
 904             }
 905          }
 906          if(!AODLabelNeg){
 907             if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
 908                PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
 909                AODLabelNeg = kTRUE;
 910             }
 911          }
 912          if(AODLabelNeg && AODLabelPos){
 913             break;
 914          }
 915       } // Both ESD Tracks have AOD Tracks with Positive IDs
 916       if(!AODLabelPos || !AODLabelNeg){
 917          for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
 918             AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
 919             if(tempDaughter->GetID()<0){
 920                if(!AODLabelPos){
 921                   if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelPositive()){
 922                      PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
 923                      AODLabelPos = kTRUE;
 924                   }
 925                }
 926                if(!AODLabelNeg){
 927                   if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelNegative()){
 928                      PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
 929                      AODLabelNeg = kTRUE;
 930                   }
 931                }
 932             }
 933             if(AODLabelNeg && AODLabelPos){
 934                break;
 935             }
 936          }
 937          if(!AODLabelPos || !AODLabelNeg){
 938             cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
 939          }
 940       }
 941    }
 942
 943    if(!mode){
 944       delete[] fMCStackPos;
 945       delete[] fMCStackNeg;
 946    }
 947 }
 948
 949 void AliAnalysisTaskConversionQA::SetLogBinningXTH2(TH2* histoRebin){
 950    TAxis *axisafter = histoRebin->GetXaxis();
 951    Int_t bins = axisafter->GetNbins();
 952    Double_t from = axisafter->GetXmin();
 953    Double_t to = axisafter->GetXmax();
 954    Double_t *newbins = new Double_t[bins+1];
 955    newbins[0] = from;
 956    Double_t factor = TMath::Power(to/from, 1./bins);
 957    for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
 958    axisafter->Set(bins, newbins);
 959    delete [] newbins;
 960
 961 }
 962
 963 //________________________________________________________________________
 964 void AliAnalysisTaskConversionQA::Terminate(Option_t *)
 965 {
 966
 967 }