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