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         TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
 773         Int_t motherLabelPhoton;
 774         Int_t pdgCodePos = 0;
 775         Int_t pdgCodeNeg = 0;
 776         Int_t pdgCode = 0;
 777
 778
 779         if(posDaughter == NULL || negDaughter == NULL) {
 780                 kind = 9;
 781                 //              return kFALSE; // One particle does not exist
 782
 783   } else if( posDaughter->GetMother(0) != negDaughter->GetMother(0)  || (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) {
 784                 //              kind = 1;
 785           return 1;
 786                 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
 787                 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
 788                 if(pdgCodePos==11 && pdgCodeNeg==11) return 10; //Electron Combinatorial
 789                 if(pdgCodePos==11 && pdgCodeNeg==11 &&
 790                         (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) return 15; //direct Electron Combinatorial
 791
 792                 if(pdgCodePos==211 && pdgCodeNeg==211) return 11; //Pion Combinatorial
 793                 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211))       return 12; //Pion, Proton Combinatorics
 794                 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) return 13; //Pion, Electron Combinatorics
 795                 if(pdgCodePos==321 || pdgCodeNeg==321) return 14; //Kaon combinatorics
 796         }else{
 797
 798                 pdgCodePos=posDaughter->GetPdgCode();
 799                 pdgCodeNeg=negDaughter->GetPdgCode();
 800           motherLabelPhoton= Photon->GetMother(0);
 801                 if ( TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode()) pdgCode = TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode();
 802
 803                 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) return 2; // true from hadronic decays
 804                 else if ( !(pdgCodeNeg==pdgCodePos)){
 805                         if(pdgCode == 111) return 3; // pi0 Dalitz
 806                         else if (pdgCode == 221) return 4; // eta Dalitz
 807                         else if (!(negDaughter->GetUniqueID() != 5 || posDaughter->GetUniqueID() !=5)){
 808                                 if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
 809                                         return 0; // primary photons
 810                                 } else if (pdgCode == 22){
 811                                         return 5; //secondary photons
 812                                 }
 813                         }
 814                 }
 815         }
 816
 817         return kind;
 818 }
 819
 820 //________________________________________________________________________
 821 UInt_t AliAnalysisTaskConversionQA::IsTruePhotonAOD(AliAODConversionPhoton *TruePhotonCandidate)
 822 {
 823
 824         UInt_t kind = 9;
 825         TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
 826         AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
 827         AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
 828         AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
 829         Int_t pdgCodePos = 0;
 830         Int_t pdgCodeNeg = 0;
 831         Int_t pdgCode = 0;
 832         if(posDaughter == NULL || negDaughter == NULL) {
 833                 kind = 9;
 834    } else if( posDaughter->GetMother() != negDaughter->GetMother()  || (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1)) {
 835                 kind = 1;
 836                 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
 837                 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
 838                 if(pdgCodePos==11 && pdgCodeNeg==11)    kind = 10; //Electron Combinatorial
 839                 if(pdgCodePos==11 && pdgCodeNeg==11 &&
 840                         (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1))kind = 15; //direct Electron Combinatorial
 841
 842                 if(pdgCodePos==211 && pdgCodeNeg==211) kind = 11; //Pion Combinatorial
 843                 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211))       kind = 12; //Pion, Proton Combinatorics
 844                 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) kind = 13; //Pion, Electron Combinatorics
 845                 if(pdgCodePos==321 || pdgCodeNeg==321) kind = 14; //Kaon combinatorics
 846         }else{
 847
 848                 pdgCodePos=posDaughter->GetPdgCode();
 849                 pdgCodeNeg=negDaughter->GetPdgCode();
 850
 851                 if ( Photon->GetPdgCode())
 852                         pdgCode = Photon->GetPdgCode();
 853                 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) kind = 2; // true from hadronic decays
 854                 else if ( !(pdgCodeNeg==pdgCodePos)){
 855                         if(pdgCode == 111) kind = 3; // pi0 Dalitz
 856                         else if (pdgCode == 221) kind = 4; // eta Dalitz
 857                         else if (!(negDaughter->GetMCProcessCode() != 5 || posDaughter->GetMCProcessCode() !=5)){
 858                                 if(pdgCode == 22 && Photon->IsPrimary()){
 859                                         kind = 0; // primary photons
 860                                 } else if (pdgCode == 22){
 861                                         kind = 5; //secondary photons
 862                                 }
 863                         }
 864                 }
 865         }
 866
 867         return kind;
 868
 869
 870 }
 871
 872 //________________________________________________________________________
 873 void AliAnalysisTaskConversionQA::RelabelAODPhotonCandidates(Bool_t mode){
 874
 875    // Relabeling For AOD Event
 876    // ESDiD -> AODiD
 877    // MCLabel -> AODMCLabel
 878
 879    if(mode){
 880       fMCStackPos = new Int_t[fConversionGammas->GetEntries()];
 881       fMCStackNeg = new Int_t[fConversionGammas->GetEntries()];
 882    }
 883
 884    for(Int_t iGamma = 0;iGamma<fConversionGammas->GetEntries();iGamma++){
 885       AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fConversionGammas->At(iGamma);
 886       if(!PhotonCandidate) continue;
 887       if(!mode){// Back to ESD Labels
 888          PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
 889          PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
 890          //PhotonCandidate->IsAODMCLabel(kFALSE);
 891          continue;
 892       }
 893       fMCStackPos[iGamma] =  PhotonCandidate->GetMCLabelPositive();
 894       fMCStackNeg[iGamma] =  PhotonCandidate->GetMCLabelNegative();
 895
 896       Bool_t AODLabelPos = kFALSE;
 897       Bool_t AODLabelNeg = kFALSE;
 898
 899       for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
 900          AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
 901          if(!AODLabelPos){
 902             if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
 903                PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
 904                AODLabelPos = kTRUE;
 905             }
 906          }
 907          if(!AODLabelNeg){
 908             if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
 909                PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
 910                AODLabelNeg = kTRUE;
 911             }
 912          }
 913          if(AODLabelNeg && AODLabelPos){
 914             break;
 915          }
 916       } // Both ESD Tracks have AOD Tracks with Positive IDs
 917       if(!AODLabelPos || !AODLabelNeg){
 918          for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
 919             AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
 920             if(tempDaughter->GetID()<0){
 921                if(!AODLabelPos){
 922                   if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelPositive()){
 923                      PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
 924                      AODLabelPos = kTRUE;
 925                   }
 926                }
 927                if(!AODLabelNeg){
 928                   if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelNegative()){
 929                      PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
 930                      AODLabelNeg = kTRUE;
 931                   }
 932                }
 933             }
 934             if(AODLabelNeg && AODLabelPos){
 935                break;
 936             }
 937          }
 938          if(!AODLabelPos || !AODLabelNeg){
 939             cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
 940          }
 941       }
 942    }
 943
 944    if(!mode){
 945       delete[] fMCStackPos;
 946       delete[] fMCStackNeg;
 947    }
 948 }
 949
 950 void AliAnalysisTaskConversionQA::SetLogBinningXTH2(TH2* histoRebin){
 951    TAxis *axisafter = histoRebin->GetXaxis();
 952    Int_t bins = axisafter->GetNbins();
 953    Double_t from = axisafter->GetXmin();
 954    Double_t to = axisafter->GetXmax();
 955    Double_t *newbins = new Double_t[bins+1];
 956    newbins[0] = from;
 957    Double_t factor = TMath::Power(to/from, 1./bins);
 958    for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
 959    axisafter->Set(bins, newbins);
 960    delete [] newbins;
 961
 962 }
 963
 964 //________________________________________________________________________
 965 void AliAnalysisTaskConversionQA::Terminate(Option_t *)
 966 {
 967
 968 }