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())
 490       RelabelAODPhotonCandidates(kTRUE);    // In case of AODMC relabeling MC
 491
 492    for(Int_t firstGammaIndex=0;firstGammaIndex<fConversionGammas->GetEntriesFast();firstGammaIndex++){
 493       AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fConversionGammas->At(firstGammaIndex));
 494       if (gamma==NULL) continue;
 495       if(fMCEvent && fConversionCuts->GetSignalRejection() != 0){
 496          if(!fConversionCuts->IsParticleFromBGEvent(gamma->GetMCLabelPositive(), fMCStack, fInputEvent))
 497             continue;
 498          if(!fConversionCuts->IsParticleFromBGEvent(gamma->GetMCLabelNegative(), fMCStack, fInputEvent))
 499             continue;
 500       }
 501       if(!fConversionCuts->PhotonIsSelected(gamma,fInputEvent)){
 502          continue;
 503       }
 504
 505       if(ffillTree) ProcessQATree(gamma);
 506       if(ffillHistograms) ProcessQA(gamma);
 507    }
 508    if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class())
 509       RelabelAODPhotonCandidates(kFALSE);    // In case of AODMC relabeling MC
 510
 511    PostData(1, fOutputList);
 512 }
 513
 514
 515 ///________________________________________________________________________
 516 void AliAnalysisTaskConversionQA::ProcessQATree(AliAODConversionPhoton *gamma){
 517
 518    // Fill Histograms for QA and MC
 519    AliVEvent* event = (AliVEvent*) InputEvent();
 520
 521
 522
 523    AliPIDResponse* pidResonse = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetPIDResponse();
 524
 525    fGammaPt = gamma->GetPhotonPt();
 526
 527    fGammaTheta = gamma->Theta();
 528    fGammaChi2NDF = gamma->GetChi2perNDF();
 529
 530    fGammaPhotonProp(0)  = gamma->GetArmenterosQt();
 531    fGammaPhotonProp(1)  = gamma->GetArmenterosAlpha();
 532    fGammaPhotonProp(2)  = gamma->GetPsiPair();
 533    fGammaPhotonProp(3) = fConversionCuts->GetCosineOfPointingAngle(gamma,event);
 534         fGammaPhotonProp(4) = gamma->GetMass();
 535
 536    fGammaConvCoord(0) = gamma->GetConversionX();
 537    fGammaConvCoord(1) = gamma->GetConversionY();
 538    fGammaConvCoord(2) = gamma->GetConversionZ();
 539    fGammaConvCoord(3) = gamma->GetConversionRadius();
 540    fGammaConvCoord(4) = gamma->GetPhotonPhi();
 541
 542    AliVTrack * negTrack = fConversionCuts->GetTrack(event, gamma->GetTrackLabelNegative());
 543    AliVTrack * posTrack = fConversionCuts->GetTrack(event, gamma->GetTrackLabelPositive());
 544
 545
 546    if(!negTrack||!posTrack)return;
 547
 548    fKind = 9;
 549    if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){
 550       fKind = IsTruePhotonESD(gamma);
 551    } else if (fMCEvent && fInputEvent->IsA()==AliAODEvent::Class()){
 552       fKind = IsTruePhotonAOD(gamma);
 553    }
 554
 555    fDaughterProp(0) =  posTrack->Pt();
 556    fDaughterProp(7) =  negTrack->Pt();
 557    fDaughterProp(1) =  posTrack->Theta();
 558    fDaughterProp(8) =  negTrack->Theta();
 559 //    Double32_t signalPos[4] = {0,0,0,0};
 560 //    Char_t nclPos[3];
 561 //    Char_t nrowsPos[3];
 562 //    if (posTrack->GetTPCdEdxInfo()) {
 563 //       posTrack->GetTPCdEdxInfo()->GetTPCSignalRegionInfo(signalPos,nclPos,nrowsPos);
 564 //       fDaughterProp(2) =  signalPos[0];
 565 //       fDaughterProp(14) =  signalPos[1];
 566 //       fDaughterProp(16) =  signalPos[2];
 567 //    } else {
 568 //       fDaughterProp(2) =  posTrack->GetTPCsignal();
 569 //       fDaughterProp(14) =  0;
 570 //       fDaughterProp(16) =  0;
 571 //    }
 572 //    Double32_t signalNeg[4] = {0,0,0,0};
 573 //    Char_t nclNeg[3];
 574 //    Char_t nrowsNeg[3];
 575 //    if (negTrack->GetTPCdEdxInfo()) {
 576 //       negTrack->GetTPCdEdxInfo()->GetTPCSignalRegionInfo(signalNeg,nclNeg,nrowsNeg);
 577 //       fDaughterProp(9) =  signalNeg[0];
 578 //       fDaughterProp(15) =  signalNeg[1];
 579 //       fDaughterProp(17) =  signalNeg[2];
 580 //    } else {
 581 //       fDaughterProp(9) =  negTrack->GetTPCsignal();
 582 //       fDaughterProp(15) =  0;
 583 //       fDaughterProp(17) =  0;
 584 //    }
 585    // dEdx TPC
 586    fDaughterProp(2) =  posTrack->GetTPCsignal();
 587    fDaughterProp(3) =  pidResonse->NumberOfSigmasTPC(posTrack,AliPID::kElectron);
 588    fDaughterProp(22) =  pidResonse->NumberOfSigmasTPC(posTrack,AliPID::kPion);
 589    fDaughterProp(9) =  negTrack->GetTPCsignal();
 590    fDaughterProp(10) =  pidResonse->NumberOfSigmasTPC(negTrack,AliPID::kElectron);
 591    fDaughterProp(23) =  pidResonse->NumberOfSigmasTPC(negTrack,AliPID::kPion);
 592    Int_t nPosClusterITS = 0;
 593    Int_t nNegClusterITS = 0;
 594    for(Int_t itsLayer = 0; itsLayer<6;itsLayer++){
 595       if(TESTBIT(negTrack->GetITSClusterMap(),itsLayer)){
 596          nNegClusterITS++;
 597       }
 598       if(TESTBIT(posTrack->GetITSClusterMap(),itsLayer)){
 599          nPosClusterITS++;
 600       }
 601    }
 602
 603    // ITS signal
 604    fDaughterProp(14) =  (Float_t)nPosClusterITS;
 605    fDaughterProp(15) =  (Float_t)nNegClusterITS;
 606    if (nPosClusterITS > 0 ){
 607       fDaughterProp(16) =  posTrack->GetITSsignal();
 608       fDaughterProp(20) =  pidResonse->NumberOfSigmasITS(posTrack,AliPID::kElectron);
 609    } else {
 610       fDaughterProp(16) =  1000;
 611       fDaughterProp(20) =  20;
 612    }
 613    if (nNegClusterITS > 0 ){
 614       fDaughterProp(17) =  negTrack->GetITSsignal();
 615       fDaughterProp(21) =  pidResonse->NumberOfSigmasITS(negTrack,AliPID::kElectron);
 616    } else {
 617       fDaughterProp(17) =  1000;
 618       fDaughterProp(21) =  20;
 619    }
 620
 621    // TOF
 622    if((posTrack->GetStatus() & AliESDtrack::kTOFpid) && !(posTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
 623       Double_t t0pos = pidResonse->GetTOFResponse().GetStartTime(posTrack->P());
 624       Double_t timesPos[9];
 625       posTrack->GetIntegratedTimes(timesPos);
 626       Double_t TOFsignalPos =   posTrack->GetTOFsignal();
 627       Double_t dTpos = TOFsignalPos - t0pos - timesPos[0];
 628       fDaughterProp(4) =  dTpos;
 629       fDaughterProp(5) =  pidResonse->NumberOfSigmasTOF(posTrack, AliPID::kElectron);
 630    } else {
 631       fDaughterProp(4) =  20000;
 632       fDaughterProp(5) =  -20;
 633    }
 634    if((negTrack->GetStatus() & AliESDtrack::kTOFpid) && !(negTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
 635       Double_t t0neg = pidResonse->GetTOFResponse().GetStartTime(negTrack->P());
 636       Double_t timesNeg[9];
 637       negTrack->GetIntegratedTimes(timesNeg);
 638       Double_t TOFsignalNeg =   negTrack->GetTOFsignal();
 639       Double_t dTneg = TOFsignalNeg - t0neg - timesNeg[0];
 640       fDaughterProp(11) =  dTneg;
 641       fDaughterProp(12) =  pidResonse->NumberOfSigmasTOF(negTrack, AliPID::kElectron);
 642    } else {
 643       fDaughterProp(11) =  20000;
 644       fDaughterProp(12) =  -20;
 645    }
 646
 647    fDaughterProp(6) =  (Float_t)posTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius()));
 648    fDaughterProp(18) =  posTrack->GetNcls(1);
 649    fDaughterProp(13) =  (Float_t)negTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius()));
 650    fDaughterProp(19) =  negTrack->GetNcls(1);
 651
 652    if (fTreeQA){
 653       fTreeQA->Fill();
 654    }
 655 }
 656
 657 //_____________________________________________________________________________________________________
 658 void AliAnalysisTaskConversionQA::ProcessQA(AliAODConversionPhoton *gamma){
 659
 660    AliPIDResponse* pidResonse = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetPIDResponse();
 661
 662    // Fill Histograms for QA and MC
 663
 664    hGammaPt->Fill(gamma->GetPhotonPt());
 665    hGammaPhi->Fill(gamma->GetPhotonPhi());
 666    hGammaEta->Fill(gamma->Eta());
 667    hGammaChi2perNDF->Fill(gamma->GetChi2perNDF());
 668    hGammaPsiPair->Fill(gamma->GetPsiPair());
 669    hGammaArmenteros->Fill(gamma->GetArmenterosAlpha(),gamma->GetArmenterosQt());
 670    hGammaCosinePointingAngle->Fill(fConversionCuts->GetCosineOfPointingAngle(gamma,fInputEvent));
 671    hGammaInvMass->Fill(gamma->GetMass());
 672 //    hGammaXY->Fill(gamma->GetConversionX(),gamma->GetConversionY());
 673 //    hGammaZR->Fill(gamma->GetConversionZ(),gamma->GetConversionRadius());
 674
 675    AliVTrack * negTrack = fConversionCuts->GetTrack(fInputEvent, gamma->GetTrackLabelNegative());
 676    AliVTrack * posTrack = fConversionCuts->GetTrack(fInputEvent, gamma->GetTrackLabelPositive());
 677    if(!negTrack||!posTrack)return;
 678
 679
 680    hElecPt->Fill(negTrack->Pt(),posTrack->Pt());
 681    hElecEta->Fill(negTrack->Eta(),posTrack->Eta());
 682    hElecPhi->Fill(negTrack->Phi(),posTrack->Phi());
 683
 684    hElecNfindableClsTPC->Fill((Float_t)posTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius())));
 685    hPosiNfindableClsTPC->Fill((Float_t)negTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius())));
 686    hElecClsTPC->Fill(negTrack->GetNcls(1));
 687    hPosiClsTPC->Fill(posTrack->GetNcls(1));
 688    //TPC dEdx
 689    hElectrondEdxP->Fill(negTrack->P() ,negTrack->GetTPCsignal());
 690    hElectronNSigmadEdxP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kElectron));
 691    hElectronNSigmadEdxEta->Fill(negTrack->Eta() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kElectron));
 692    hElectronNSigmaPiondEdxP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kPion));
 693    hPositrondEdxP->Fill(posTrack->P() ,posTrack->GetTPCsignal());
 694    hPositronNSigmadEdxP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kElectron));
 695    hPositronNSigmadEdxEta->Fill(posTrack->Eta() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kElectron));
 696    hPositronNSigmaPiondEdxP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kPion));
 697
 698    //TOF signal
 699    if((negTrack->GetStatus() & AliESDtrack::kTOFpid) && !(negTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
 700       Double_t t0neg = pidResonse->GetTOFResponse().GetStartTime(negTrack->P());
 701       Double_t timesNeg[9];
 702       negTrack->GetIntegratedTimes(timesNeg);
 703       Double_t TOFsignalNeg = negTrack->GetTOFsignal();
 704       Double_t dTneg = TOFsignalNeg - t0neg - timesNeg[0];
 705       hElectronTOFP->Fill(negTrack->P() ,dTneg);
 706       hElectronNSigmaTOFP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTOF(negTrack, AliPID::kElectron));
 707    }
 708    if((posTrack->GetStatus() & AliESDtrack::kTOFpid) && !(posTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
 709       Double_t t0pos = pidResonse->GetTOFResponse().GetStartTime(posTrack->P());
 710       Double_t timesPos[9];
 711       posTrack->GetIntegratedTimes(timesPos);
 712       Double_t TOFsignalPos = posTrack->GetTOFsignal();
 713       Double_t dTpos = TOFsignalPos - t0pos - timesPos[0];
 714       hPositronTOFP->Fill(posTrack->P() ,dTpos);
 715       hPositronNSigmaTOFP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTOF(posTrack, AliPID::kElectron));
 716    }
 717
 718    Int_t nPosClusterITS = 0;
 719    Int_t nNegClusterITS = 0;
 720    for(Int_t itsLayer = 0; itsLayer<6;itsLayer++){
 721       if(TESTBIT(negTrack->GetITSClusterMap(),itsLayer)){
 722          nNegClusterITS++;
 723       }
 724       if(TESTBIT(posTrack->GetITSClusterMap(),itsLayer)){
 725          nPosClusterITS++;
 726       }
 727    }
 728    Double_t negtrackPhi = negTrack->Phi();
 729    Double_t postrackPhi = posTrack->Phi();
 730    hITSClusterPhi->Fill(negtrackPhi,nNegClusterITS);
 731    hITSClusterPhi->Fill(postrackPhi,nPosClusterITS);
 732
 733    // ITS signal
 734    if (nPosClusterITS > 0 ){
 735       hPositronITSdEdxP->Fill(posTrack->P() ,posTrack->GetITSsignal());
 736       hPositronNSigmaITSP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasITS(posTrack,AliPID::kElectron));
 737    }
 738    if (nNegClusterITS > 0 ){
 739       hElectronITSdEdxP->Fill(negTrack->P() ,negTrack->GetITSsignal());
 740       hElectronNSigmaITSP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasITS(negTrack,AliPID::kElectron));
 741    }
 742
 743
 744 //    if(gamma->P()!=0){
 745 //               hElecAsymP->Fill(gamma->P(),negTrack->P()/gamma->P());
 746 //       }
 747    // hElecNfindableClsTPC->Fill((Float_t)negTrack->GetNcls(1)/(Float_t)negTrack->GetTPCNclsF());
 748    // hPosiNfindableClsTPC->Fill((Float_t)posTrack->GetNcls(1)/(Float_t)posTrack->GetTPCNclsF());
 749 //    if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){
 750 //       ProcessTrueQAESD(gamma,(AliESDtrack*)negTrack,(AliESDtrack*)posTrack);
 751 //    } else if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class()){
 752 //         ProcessTrueQAAOD(gamma,(AliAODTrack*)negTrack,(AliAODTrack*)posTrack);
 753 //    }
 754 }
 755
 756 // //________________________________________________________________________
 757 // void AliAnalysisTaskConversionQA::ProcessTrueQAESD(AliAODConversionPhoton *TruePhotonCandidate, AliESDtrack *elec, AliESDtrack *posi)
 758 // {
 759 //
 760 //    if(IsTruePhotonESD(TruePhotonCandidate)!=0 && IsTruePhotonESD(TruePhotonCandidate)!=5  ) return;
 761 //
 762 //    TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
 763 //    TParticle *mcPhoton = TruePhotonCandidate->GetMCParticle(fMCStack);
 764    // True Photon
 765 //    hTrueResolutionR->Fill(TruePhotonCandidate->GetConversionRadius(),
 766 //                            TruePhotonCandidate->GetConversionRadius()-negDaughter->R());
 767 //    hTrueResolutionZ->Fill(TruePhotonCandidate->GetConversionZ(),
 768 //                            TruePhotonCandidate->GetConversionZ()-negDaughter->Vz());
 769 //    hTrueResolutionPhi->Fill(TruePhotonCandidate->Phi(),
 770 //                              TruePhotonCandidate->Phi()-mcPhoton->Phi());
 771 //    hTrueGammaPt->Fill(TruePhotonCandidate->Pt());
 772 //    hTrueGammaPhi->Fill(TruePhotonCandidate->Phi());
 773 //    hTrueGammaEta->Fill(TruePhotonCandidate->Eta());
 774 //    hTrueGammaMass->Fill(TruePhotonCandidate->GetMass());
 775 //    hTrueGammaChi2perNDF->Fill(TruePhotonCandidate->GetChi2perNDF());
 776 //    hTrueGammaPsiPair->Fill(TruePhotonCandidate->GetPsiPair());
 777 //    hTrueGammaQt->Fill(TruePhotonCandidate->GetArmenterosQt());
 778 //    hTrueGammaCosinePointingAngle->Fill(fConversionCuts->GetCosineOfPointingAngle(TruePhotonCandidate,fInputEvent));
 779 //    hTrueGammaXY->Fill(TruePhotonCandidate->GetConversionX(),TruePhotonCandidate->GetConversionY());
 780 //    hTrueGammaZR->Fill(TruePhotonCandidate->GetConversionZ(),TruePhotonCandidate->GetConversionRadius());
 781 //    hTrueElecPt->Fill(elec->Pt(),posi->Pt());
 782 //    hTrueElecEta->Fill(elec->Eta(),posi->Eta());
 783 //    hTrueElecPhi->Fill(elec->Phi(),posi->Phi());
 784 //    hTrueElecNfindableClsTPC
 785 //       ->Fill((Float_t)elec->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(TruePhotonCandidate->GetConversionRadius())));
 786 //    hTruePosiNfindableClsTPC
 787 //       ->Fill((Float_t)posi->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(TruePhotonCandidate->GetConversionRadius())));
 788 //    if(TruePhotonCandidate->P()!=0){
 789 //               hTrueElecAsymP->Fill(TruePhotonCandidate->P(),elec->P()/TruePhotonCandidate->P());
 790 //       }
 791
 792    // hTrueElecNfindableClsTPC->Fill((Float_t)elec->GetNcls(1)/(Float_t)elec->GetTPCNclsF());
 793    // hTruePosiNfindableClsTPC->Fill((Float_t)posi->GetNcls(1)/(Float_t)posi->GetTPCNclsF());
 794 // }
 795 //
 796 // //________________________________________________________________________
 797 // void AliAnalysisTaskConversionQA::ProcessTrueQAAOD(AliAODConversionPhoton *TruePhotonCandidate, AliAODTrack *elec, AliAODTrack *posi)
 798 // {
 799 //
 800 //    if(IsTruePhotonAOD(TruePhotonCandidate)!=0 && IsTruePhotonESD(TruePhotonCandidate)!=5 ) return;
 801 //
 802 //    TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
 803 //    AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
 804 //    AliAODMCParticle *mcPhoton = (AliAODMCParticle*) AODMCTrackArray->At(negDaughter->GetMother());
 805    // True Photon
 806 //    hTrueResolutionR->Fill(TruePhotonCandidate->GetConversionRadius(),
 807 //                            TruePhotonCandidate->GetConversionRadius()-(TMath::Sqrt(negDaughter->Xv()*negDaughter->Xv()+negDaughter->Yv()*negDaughter->Yv())));
 808 //    hTrueResolutionZ->Fill(TruePhotonCandidate->GetConversionZ(),
 809 //                            TruePhotonCandidate->GetConversionZ()-negDaughter->Zv());
 810 //    hTrueResolutionPhi->Fill(TruePhotonCandidate->Phi(),
 811 //                              TruePhotonCandidate->Phi()-mcPhoton->Phi());
 812 //    hTrueGammaPt->Fill(TruePhotonCandidate->Pt());
 813 //    hTrueGammaPhi->Fill(TruePhotonCandidate->Phi());
 814 //    hTrueGammaEta->Fill(TruePhotonCandidate->Eta());
 815 //    hTrueGammaMass->Fill(TruePhotonCandidate->GetMass());
 816 //    hTrueGammaChi2perNDF->Fill(TruePhotonCandidate->GetChi2perNDF());
 817 //    hTrueGammaPsiPair->Fill(TruePhotonCandidate->GetPsiPair());
 818 //    hTrueGammaQt->Fill(TruePhotonCandidate->GetArmenterosQt());
 819 //    hTrueGammaCosinePointingAngle->Fill(fConversionCuts->GetCosineOfPointingAngle(TruePhotonCandidate,fInputEvent));
 820 //    hTrueGammaXY->Fill(TruePhotonCandidate->GetConversionX(),TruePhotonCandidate->GetConversionY());
 821 //    hTrueGammaZR->Fill(TruePhotonCandidate->GetConversionZ(),TruePhotonCandidate->GetConversionRadius());
 822 //    hTrueElecPt->Fill(elec->Pt(),posi->Pt());
 823 //    hTrueElecEta->Fill(elec->Eta(),posi->Eta());
 824 //    hTrueElecPhi->Fill(elec->Phi(),posi->Phi());
 825 //    hTrueElecNfindableClsTPC
 826 //       ->Fill((Float_t)elec->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(TruePhotonCandidate->GetConversionRadius())));
 827 //    hTruePosiNfindableClsTPC
 828 //       ->Fill((Float_t)posi->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(TruePhotonCandidate->GetConversionRadius())));
 829    // hTrueElecNfindableClsTPC->Fill((Float_t)elec->GetNcls(1)/(Float_t)elec->GetTPCNclsF());
 830    // hTruePosiNfindableClsTPC->Fill((Float_t)posi->GetNcls(1)/(Float_t)posi->GetTPCNclsF());
 831 // }
 832
 833 //________________________________________________________________________
 834 void AliAnalysisTaskConversionQA::CountTracks(){
 835
 836    if(fInputEvent->IsA()==AliESDEvent::Class()){
 837    // Using standard function for setting Cuts
 838    Bool_t selectPrimaries=kTRUE;
 839    AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
 840    EsdTrackCuts->SetMaxDCAToVertexZ(2);
 841    EsdTrackCuts->SetEtaRange(-0.8, 0.8);
 842    EsdTrackCuts->SetPtRange(0.15);
 843       fNumberOfESDTracks = 0;
 844       for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
 845          AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
 846          if(!curTrack) continue;
 847          // if(fMCEvent && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
 848          //    if(!((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack)) continue;
 849          // }
 850          if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTracks++;
 851       }
 852       delete EsdTrackCuts;
 853       EsdTrackCuts=0x0;
 854    }
 855    else if(fInputEvent->IsA()==AliAODEvent::Class()){
 856       fNumberOfESDTracks = 0;
 857       for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
 858          AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
 859          if(!curTrack->IsPrimaryCandidate()) continue;
 860          if(abs(curTrack->Eta())>0.8) continue;
 861          if(curTrack->Pt()<0.15) continue;
 862          if(abs(curTrack->ZAtDCA())>2) continue;
 863          fNumberOfESDTracks++;
 864       }
 865    }
 866
 867    return;
 868 }
 869 //________________________________________________________________________
 870 /*
 871 Bool_t AliAnalysisTaskConversionQA::IsTruePhotonESD(AliAODConversionPhoton *TruePhotonCandidate)
 872 {
 873    TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
 874    TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
 875
 876    if(posDaughter == NULL || negDaughter == NULL) return kFALSE; // One particle does not exist
 877    Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
 878    if(posDaughter->GetMother(0) != negDaughter->GetMother(0)) return kFALSE;
 879    else if(posDaughter->GetMother(0) == -1) return kFALSE;
 880
 881    if(pdgCode[0]!=11 || pdgCode[1]!=11) return kFALSE; //One Particle is not electron
 882    if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return kFALSE; // Same Charge
 883    if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return kFALSE;// check if the daughters come from a conversion
 884
 885    TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
 886    if(Photon->GetPdgCode() != 22) return kFALSE; // Mother is no Photon
 887
 888    return kTRUE;
 889 }
 890 */
 891 UInt_t AliAnalysisTaskConversionQA::IsTruePhotonESD(AliAODConversionPhoton *TruePhotonCandidate)
 892 {
 893
 894
 895         UInt_t kind = 9;
 896         TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
 897         TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
 898         TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
 899         Int_t motherLabelPhoton;
 900         Int_t pdgCodePos = 0;
 901         Int_t pdgCodeNeg = 0;
 902         Int_t pdgCode = 0;
 903
 904
 905         if(posDaughter == NULL || negDaughter == NULL) {
 906                 kind = 9;
 907                 //              return kFALSE; // One particle does not exist
 908
 909   } else if( posDaughter->GetMother(0) != negDaughter->GetMother(0)  || (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) {
 910                 //              kind = 1;
 911           return 1;
 912                 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
 913                 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
 914                 if(pdgCodePos==11 && pdgCodeNeg==11) return 10; //Electron Combinatorial
 915                 if(pdgCodePos==11 && pdgCodeNeg==11 &&
 916                         (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) return 15; //direct Electron Combinatorial
 917
 918                 if(pdgCodePos==211 && pdgCodeNeg==211) return 11; //Pion Combinatorial
 919                 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211))       return 12; //Pion, Proton Combinatorics
 920                 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) return 13; //Pion, Electron Combinatorics
 921                 if(pdgCodePos==321 || pdgCodeNeg==321) return 14; //Kaon combinatorics
 922         }else{
 923
 924                 pdgCodePos=posDaughter->GetPdgCode();
 925                 pdgCodeNeg=negDaughter->GetPdgCode();
 926           motherLabelPhoton= Photon->GetMother(0);
 927                 if ( TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode()) pdgCode = TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode();
 928
 929                 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) return 2; // true from hadronic decays
 930                 else if ( !(pdgCodeNeg==pdgCodePos)){
 931                         if(pdgCode == 111) return 3; // pi0 Dalitz
 932                         else if (pdgCode == 221) return 4; // eta Dalitz
 933                         else if (!(negDaughter->GetUniqueID() != 5 || posDaughter->GetUniqueID() !=5)){
 934                                 if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
 935                                         return 0; // primary photons
 936                                 } else if (pdgCode == 22){
 937                                         return 5; //secondary photons
 938                                 }
 939                         }
 940                 }
 941         }
 942
 943         return kind;
 944 }
 945
 946 //________________________________________________________________________
 947 UInt_t AliAnalysisTaskConversionQA::IsTruePhotonAOD(AliAODConversionPhoton *TruePhotonCandidate)
 948 {
 949
 950         UInt_t kind = 9;
 951
 952   TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
 953         AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
 954         AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
 955         AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
 956         Int_t motherLabelPhoton = Photon->GetMother();
 957         Int_t pdgCodePos = 0;
 958         Int_t pdgCodeNeg = 0;
 959         Int_t pdgCode = 0;
 960
 961         if(posDaughter == NULL || negDaughter == NULL) {
 962                 kind = 9;
 963                 //              return kFALSE; // One particle does not exist
 964
 965    } else if( posDaughter->GetMother() != negDaughter->GetMother()  || (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1)) {
 966                 kind = 1;
 967
 968                 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
 969                 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
 970                 if(pdgCodePos==11 && pdgCodeNeg==11)    kind = 10; //Electron Combinatorial
 971                 if(pdgCodePos==11 && pdgCodeNeg==11 &&
 972                         (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1))kind = 15; //direct Electron Combinatorial
 973
 974                 if(pdgCodePos==211 && pdgCodeNeg==211) kind = 11; //Pion Combinatorial
 975                 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211))       kind = 12; //Pion, Proton Combinatorics
 976                 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) kind = 13; //Pion, Electron Combinatorics
 977                 if(pdgCodePos==321 || pdgCodeNeg==321) kind = 14; //Kaon combinatorics
 978         }else{
 979
 980                 pdgCodePos=posDaughter->GetPdgCode();
 981                 pdgCodeNeg=negDaughter->GetPdgCode();
 982
 983                 if ( Photon->GetPdgCode())
 984                         pdgCode = Photon->GetPdgCode();
 985                 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) kind = 2; // true from hadronic decays
 986                 else if ( !(pdgCodeNeg==pdgCodePos)){
 987                         if(pdgCode == 111) kind = 3; // pi0 Dalitz
 988                         else if (pdgCode == 221) kind = 4; // eta Dalitz
 989                         else if (!(negDaughter->GetMCProcessCode() != 5 || posDaughter->GetMCProcessCode() !=5)){
 990                                 if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
 991                                         kind = 0; // primary photons
 992                                 } else if (pdgCode == 22){
 993                                         kind = 5; //secondary photons
 994                                 }
 995                         }
 996                 }
 997         }
 998
 999
1000         return kind;
1001
1002
1003 }
1004
1005 //________________________________________________________________________
1006 void AliAnalysisTaskConversionQA::RelabelAODPhotonCandidates(Bool_t mode){
1007
1008    // Relabeling For AOD Event
1009    // ESDiD -> AODiD
1010    // MCLabel -> AODMCLabel
1011
1012    if(mode){
1013       fMCStackPos = new Int_t[fConversionGammas->GetEntries()];
1014       fMCStackNeg = new Int_t[fConversionGammas->GetEntries()];
1015    }
1016
1017    for(Int_t iGamma = 0;iGamma<fConversionGammas->GetEntries();iGamma++){
1018       AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fConversionGammas->At(iGamma);
1019       if(!PhotonCandidate) continue;
1020       if(!mode){// Back to ESD Labels
1021          PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
1022          PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
1023          //PhotonCandidate->IsAODMCLabel(kFALSE);
1024          continue;
1025       }
1026       fMCStackPos[iGamma] =  PhotonCandidate->GetMCLabelPositive();
1027       fMCStackNeg[iGamma] =  PhotonCandidate->GetMCLabelNegative();
1028
1029       Bool_t AODLabelPos = kFALSE;
1030       Bool_t AODLabelNeg = kFALSE;
1031
1032       for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
1033          AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
1034          if(!AODLabelPos){
1035             if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
1036                PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
1037                AODLabelPos = kTRUE;
1038             }
1039          }
1040          if(!AODLabelNeg){
1041             if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
1042                PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
1043                AODLabelNeg = kTRUE;
1044             }
1045          }
1046          if(AODLabelNeg && AODLabelPos){
1047             break;
1048          }
1049       } // Both ESD Tracks have AOD Tracks with Positive IDs
1050       if(!AODLabelPos || !AODLabelNeg){
1051          for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
1052             AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
1053             if(tempDaughter->GetID()<0){
1054                if(!AODLabelPos){
1055                   if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelPositive()){
1056                      PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
1057                      AODLabelPos = kTRUE;
1058                   }
1059                }
1060                if(!AODLabelNeg){
1061                   if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelNegative()){
1062                      PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
1063                      AODLabelNeg = kTRUE;
1064                   }
1065                }
1066             }
1067             if(AODLabelNeg && AODLabelPos){
1068                break;
1069             }
1070          }
1071          if(!AODLabelPos || !AODLabelNeg){
1072             cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
1073          }
1074       }
1075    }
1076
1077    if(!mode){
1078       delete[] fMCStackPos;
1079       delete[] fMCStackNeg;
1080    }
1081 }
1082
1083 void AliAnalysisTaskConversionQA::SetLogBinningXTH2(TH2* histoRebin){
1084    TAxis *axisafter = histoRebin->GetXaxis();
1085    Int_t bins = axisafter->GetNbins();
1086    Double_t from = axisafter->GetXmin();
1087    Double_t to = axisafter->GetXmax();
1088    Double_t *newbins = new Double_t[bins+1];
1089    newbins[0] = from;
1090    Double_t factor = TMath::Power(to/from, 1./bins);
1091    for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
1092    axisafter->Set(bins, newbins);
1093    delete [] newbins;
1094
1095 }
1096
1097 //________________________________________________________________________
1098 void AliAnalysisTaskConversionQA::Terminate(Option_t *)
1099 {
1100
1101 }