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