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