]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/GammaConv/AliAnalysisTaskConversionQA.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
MC changes to evsel for debugging
[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliAnalysisTaskConversionQA.cxx
CommitLineData
2bb2434e 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
e5b6e8a6 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. *
2bb2434e 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"
e5b6e8a6 29#include "AliESDtrackCuts.h"
ae947965 30#include "AliAODMCParticle.h"
31#include "AliAODMCHeader.h"
32
2bb2434e 33
34class iostream;
35
36using namespace std;
37
38ClassImp(AliAnalysisTaskConversionQA)
39
40//________________________________________________________________________
ae947965 41AliAnalysisTaskConversionQA::AliAnalysisTaskConversionQA() : AliAnalysisTaskSE(),
42 fV0Reader(NULL),
43 fConversionGammas(NULL),
44 fConversionCuts(NULL),
45 fInputEvent(NULL),
46 fNumberOfESDTracks(0),
47 fMCEvent(NULL),
48 fMCStack(NULL),
72395bd9 49 fTreeQA(NULL),
ae947965 50 fIsHeavyIon(kFALSE),
51 ffillTree(kFALSE),
52 ffillHistograms(kFALSE),
53 fOutputList(NULL),
72395bd9 54 fTreeList(NULL),
ae947965 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),
616d5128 66 hGammaArmenteros(NULL),
ae947965 67 hGammaCosinePointingAngle(NULL),
616d5128 68 hGammaInvMass(NULL),
ae947965 69 hElecPt(NULL),
70 hElecEta(NULL),
71 hElecPhi(NULL),
72 hElecNfindableClsTPC(NULL),
73 hPosiNfindableClsTPC(NULL),
616d5128 74 hElecClsTPC(NULL),
75 hPosiClsTPC(NULL),
76 hElectrondEdxP(NULL),
77 hElectronITSdEdxP(NULL),
78 hElectronTOFP(NULL),
79 hElectronNSigmadEdxP(NULL),
25c0b354 80 hElectronNSigmadEdxEta(NULL),
616d5128 81 hElectronNSigmaPiondEdxP(NULL),
82 hElectronNSigmaITSP(NULL),
83 hElectronNSigmaTOFP(NULL),
84 hPositrondEdxP(NULL),
85 hPositronITSdEdxP(NULL),
86 hPositronTOFP(NULL),
87 hPositronNSigmadEdxP(NULL),
25c0b354 88 hPositronNSigmadEdxEta(NULL),
616d5128 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),
72395bd9 113 fGammaPt(0),
114 fGammaTheta(0),
115 fGammaChi2NDF(0),
31216736 116 fGammaPhotonProp(5),
117 fGammaConvCoord(5),
616d5128 118 fDaughterProp(24),
72395bd9 119 fKind(0),
ae947965 120 fIsMC(kFALSE),
121 fnGammaCandidates(1),
122 fMCStackPos(NULL),
123 fMCStackNeg(NULL)
124{
125
126}
72395bd9 127
2bb2434e 128AliAnalysisTaskConversionQA::AliAnalysisTaskConversionQA(const char *name) : AliAnalysisTaskSE(name),
e5b6e8a6 129 fV0Reader(NULL),
2bb2434e 130 fConversionGammas(NULL),
131 fConversionCuts(NULL),
e5b6e8a6 132 fInputEvent(NULL),
133 fNumberOfESDTracks(0),
134 fMCEvent(NULL),
135 fMCStack(NULL),
72395bd9 136 fTreeQA(NULL),
2bb2434e 137 fIsHeavyIon(kFALSE),
e5b6e8a6 138 ffillTree(kFALSE),
139 ffillHistograms(kFALSE),
140 fOutputList(NULL),
72395bd9 141 fTreeList(NULL),
e5b6e8a6 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),
616d5128 153 hGammaArmenteros(NULL),
e5b6e8a6 154 hGammaCosinePointingAngle(NULL),
616d5128 155 hGammaInvMass(NULL),
e5b6e8a6 156 hElecPt(NULL),
157 hElecEta(NULL),
158 hElecPhi(NULL),
159 hElecNfindableClsTPC(NULL),
160 hPosiNfindableClsTPC(NULL),
616d5128 161 hElecClsTPC(NULL),
162 hPosiClsTPC(NULL),
163 hElectrondEdxP(NULL),
164 hElectronITSdEdxP(NULL),
165 hElectronTOFP(NULL),
166 hElectronNSigmadEdxP(NULL),
25c0b354 167 hElectronNSigmadEdxEta(NULL),
616d5128 168 hElectronNSigmaPiondEdxP(NULL),
169 hElectronNSigmaITSP(NULL),
170 hElectronNSigmaTOFP(NULL),
171 hPositrondEdxP(NULL),
172 hPositronITSdEdxP(NULL),
173 hPositronTOFP(NULL),
174 hPositronNSigmadEdxP(NULL),
25c0b354 175 hPositronNSigmadEdxEta(NULL),
616d5128 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),
72395bd9 202 fGammaPt(0),
203 fGammaTheta(0),
204 fGammaChi2NDF(0),
31216736 205 fGammaPhotonProp(5),
206 fGammaConvCoord(5),
616d5128 207 fDaughterProp(24),
72395bd9 208 fKind(0),
ae947965 209 fIsMC(kFALSE),
210 fnGammaCandidates(1),
211 fMCStackPos(NULL),
212 fMCStackNeg(NULL)
2bb2434e 213{
214 // Default constructor
215
216 DefineInput(0, TChain::Class());
217 DefineOutput(1, TList::Class());
218}
219
220//________________________________________________________________________
221AliAnalysisTaskConversionQA::~AliAnalysisTaskConversionQA()
222{
223 // default deconstructor
72395bd9 224
2bb2434e 225}
226//________________________________________________________________________
227void 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 }
a280ac15 239
e5b6e8a6 240 if(ffillHistograms){
11c1e680 241
e5b6e8a6 242 fESDList = new TList();
243 fESDList->SetOwner(kTRUE);
244 fESDList->SetName("ESD QA");
245 fOutputList->Add(fESDList);
2bb2434e 246
e5b6e8a6 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);
e492d61d 251 if(fIsHeavyIon) hNGoodESDTracks = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
e5b6e8a6 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);
11c1e680 264 hGammaEta = new TH1F("Gamma_Eta","Gamma_Eta",600,-1.5,1.5);
e5b6e8a6 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);
616d5128 270 hGammaArmenteros = new TH2F("Gamma_Armenteros","Gamma_Armenteros",200,-1,1,400,0,0.1);
271 fESDList->Add(hGammaArmenteros);
e492d61d 272 hGammaCosinePointingAngle = new TH1F("Gamma_CosinePointingAngle","Gamma_CosinePointingAngle",1000,-1.,1.);
e5b6e8a6 273 fESDList->Add(hGammaCosinePointingAngle);
616d5128 274 hGammaInvMass = new TH1F( "Gamma_InvMass","",200, 0, 0.2);
275 fESDList->Add(hGammaInvMass);
e5b6e8a6 276 hElecPt = new TH2F("Electron_Positron_Pt","Electron_Positron_Pt",250,0,25,250,0,25);
277 fESDList->Add(hElecPt);
11c1e680 278 hElecEta = new TH2F("Electron_Positron_Eta","Electron_Positron_Eta",600,-1.5,1.5,600,-1.5,1.5);
e5b6e8a6 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);
616d5128 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
e5b6e8a6 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);
616d5128 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);
25c0b354 301 hElectronNSigmadEdxEta = new TH2F("Electron_NSigmadEdx_Eta","Electron_NSigmadEdx_Eta",140, -1.4, 1.4, 200, -10, 10);
302 fESDList->Add(hElectronNSigmadEdxEta);
616d5128 303 hPositronNSigmadEdxP = new TH2F("Positron_NSigmadEdx_P","Positron_NSigmadEdx_P",100, 0.05, 20, 200, -10, 10);
304 SetLogBinningXTH2(hPositronNSigmadEdxP);
305 fESDList->Add(hPositronNSigmadEdxP);
25c0b354 306 hPositronNSigmadEdxEta = new TH2F("Positron_NSigmadEdx_Eta","Positron_NSigmadEdx_Eta",140, -1.4, 1.4, 200, -10, 10);
307 fESDList->Add(hPositronNSigmadEdxEta);
616d5128 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);
e492d61d 334 hElectronNSigmaITSP = new TH2F("Electron_NSigmaITS_P","Electron_NSigmaITS_P",100, 0.05, 20, 200, -10, 10);
616d5128 335 SetLogBinningXTH2(hElectronNSigmaITSP);
336 fESDList->Add(hElectronNSigmaITSP);
e492d61d 337 hPositronNSigmaITSP = new TH2F("Positron_NSigmaITS_P","Positron_NSigmaITS_P",100, 0.05, 20, 200, -10, 10);
616d5128 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// }
a280ac15 399 if(fConversionCuts->GetCutHistograms()){
400 fOutputList->Add(fConversionCuts->GetCutHistograms());
401 }
e5b6e8a6 402 }
a280ac15 403
e5b6e8a6 404 if(ffillTree){
72395bd9 405 fTreeList = new TList();
406 fTreeList->SetOwner(kTRUE);
407 fTreeList->SetName("TreeList");
408 fOutputList->Add(fTreeList);
409
410 fTreeQA = new TTree("PhotonQA","PhotonQA");
411
31216736 412 fTreeQA->Branch("daughterProp",&fDaughterProp);
413 fTreeQA->Branch("recCords",&fGammaConvCoord);
414 fTreeQA->Branch("photonProp",&fGammaPhotonProp);
72395bd9 415 fTreeQA->Branch("pt",&fGammaPt,"fGammaPt/F");
416 fTreeQA->Branch("theta",&fGammaTheta,"fGammaTheta/F");
417 fTreeQA->Branch("chi2ndf",&fGammaChi2NDF,"fGammaChi2NDF/F");
72395bd9 418 if (fIsMC) {
419 fTreeQA->Branch("kind",&fKind,"fKind/b");
420 }
421 fTreeList->Add(fTreeQA);
422
e5b6e8a6 423 }
a280ac15 424
11c1e680 425 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
426
e5b6e8a6 427 PostData(1, fOutputList);
2bb2434e 428}
11c1e680 429//_____________________________________________________________________________
430Bool_t AliAnalysisTaskConversionQA::Notify()
431{
ccfa8c0d 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;
11c1e680 438 }
ccfa8c0d 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
11c1e680 445 return kTRUE;
446}
2bb2434e 447//________________________________________________________________________
448void AliAnalysisTaskConversionQA::UserExec(Option_t *){
a280ac15 449
11c1e680 450
2bb2434e 451
452 Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
453 if(eventQuality != 0){// Event Not Accepted
454 return;
455 }
e5b6e8a6 456 fInputEvent = InputEvent();
ae947965 457 if(fIsMC) fMCEvent = MCEvent();
458 if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){ fMCStack = fMCEvent->Stack(); }
e5b6e8a6 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
2bb2434e 463
464 fConversionGammas=fV0Reader->GetReconstructedGammas();
465
e5b6e8a6 466 if(fMCEvent){
467 if(fConversionCuts->GetSignalRejection() != 0){
ae947965 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 }
e5b6e8a6 478 }
479 }
480
e5b6e8a6 481 if(ffillHistograms){
ae947965 482 CountTracks();
a280ac15 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());
e5b6e8a6 487 }
2bb2434e 488
2d49ea4c 489 if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
ae947965 490 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
2d49ea4c 491 fV0Reader->RelabelAODs(kTRUE);
492 }
493
494
2bb2434e 495 for(Int_t firstGammaIndex=0;firstGammaIndex<fConversionGammas->GetEntriesFast();firstGammaIndex++){
496 AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fConversionGammas->At(firstGammaIndex));
0a2b2b4b 497 if (gamma==NULL) continue;
e5b6e8a6 498 if(fMCEvent && fConversionCuts->GetSignalRejection() != 0){
ae947965 499 if(!fConversionCuts->IsParticleFromBGEvent(gamma->GetMCLabelPositive(), fMCStack, fInputEvent))
e5b6e8a6 500 continue;
ae947965 501 if(!fConversionCuts->IsParticleFromBGEvent(gamma->GetMCLabelNegative(), fMCStack, fInputEvent))
e5b6e8a6 502 continue;
503 }
a280ac15 504 if(!fConversionCuts->PhotonIsSelected(gamma,fInputEvent)){
505 continue;
e5b6e8a6 506 }
507
a280ac15 508 if(ffillTree) ProcessQATree(gamma);
509 if(ffillHistograms) ProcessQA(gamma);
510 }
a8b0377e 511
512 if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
513 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
514 fV0Reader->RelabelAODs(kFALSE);
515 }
ae947965 516
a280ac15 517 PostData(1, fOutputList);
518}
519
520
521///________________________________________________________________________
522void AliAnalysisTaskConversionQA::ProcessQATree(AliAODConversionPhoton *gamma){
523
524 // Fill Histograms for QA and MC
ae947965 525 AliVEvent* event = (AliVEvent*) InputEvent();
4803eb1f 526
527
528
a280ac15 529 AliPIDResponse* pidResonse = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetPIDResponse();
530
72395bd9 531 fGammaPt = gamma->GetPhotonPt();
532
533 fGammaTheta = gamma->Theta();
534 fGammaChi2NDF = gamma->GetChi2perNDF();
535
31216736 536 fGammaPhotonProp(0) = gamma->GetArmenterosQt();
537 fGammaPhotonProp(1) = gamma->GetArmenterosAlpha();
538 fGammaPhotonProp(2) = gamma->GetPsiPair();
539 fGammaPhotonProp(3) = fConversionCuts->GetCosineOfPointingAngle(gamma,event);
540 fGammaPhotonProp(4) = gamma->GetMass();
72395bd9 541
31216736 542 fGammaConvCoord(0) = gamma->GetConversionX();
543 fGammaConvCoord(1) = gamma->GetConversionY();
544 fGammaConvCoord(2) = gamma->GetConversionZ();
545 fGammaConvCoord(3) = gamma->GetConversionRadius();
546 fGammaConvCoord(4) = gamma->GetPhotonPhi();
72395bd9 547
ae947965 548 AliVTrack * negTrack = fConversionCuts->GetTrack(event, gamma->GetTrackLabelNegative());
549 AliVTrack * posTrack = fConversionCuts->GetTrack(event, gamma->GetTrackLabelPositive());
a280ac15 550
4803eb1f 551
a280ac15 552 if(!negTrack||!posTrack)return;
553
72395bd9 554 fKind = 9;
4803eb1f 555 if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){
72395bd9 556 fKind = IsTruePhotonESD(gamma);
ae947965 557 } else if (fMCEvent && fInputEvent->IsA()==AliAODEvent::Class()){
2d49ea4c 558// cout << "entering IsTruePhotonAOD" << endl;
72395bd9 559 fKind = IsTruePhotonAOD(gamma);
a280ac15 560 }
561
31216736 562 fDaughterProp(0) = posTrack->Pt();
563 fDaughterProp(7) = negTrack->Pt();
564 fDaughterProp(1) = posTrack->Theta();
565 fDaughterProp(8) = negTrack->Theta();
976b1f89 566 // dEdx TPC
567 fDaughterProp(2) = posTrack->GetTPCsignal();
568 fDaughterProp(3) = pidResonse->NumberOfSigmasTPC(posTrack,AliPID::kElectron);
616d5128 569 fDaughterProp(22) = pidResonse->NumberOfSigmasTPC(posTrack,AliPID::kPion);
976b1f89 570 fDaughterProp(9) = negTrack->GetTPCsignal();
571 fDaughterProp(10) = pidResonse->NumberOfSigmasTPC(negTrack,AliPID::kElectron);
616d5128 572 fDaughterProp(23) = pidResonse->NumberOfSigmasTPC(negTrack,AliPID::kPion);
976b1f89 573 Int_t nPosClusterITS = 0;
574 Int_t nNegClusterITS = 0;
575 for(Int_t itsLayer = 0; itsLayer<6;itsLayer++){
576 if(TESTBIT(negTrack->GetITSClusterMap(),itsLayer)){
577 nNegClusterITS++;
578 }
579 if(TESTBIT(posTrack->GetITSClusterMap(),itsLayer)){
580 nPosClusterITS++;
581 }
582 }
583
584 // ITS signal
585 fDaughterProp(14) = (Float_t)nPosClusterITS;
586 fDaughterProp(15) = (Float_t)nNegClusterITS;
587 if (nPosClusterITS > 0 ){
588 fDaughterProp(16) = posTrack->GetITSsignal();
589 fDaughterProp(20) = pidResonse->NumberOfSigmasITS(posTrack,AliPID::kElectron);
a280ac15 590 } else {
976b1f89 591 fDaughterProp(16) = 1000;
592 fDaughterProp(20) = 20;
a280ac15 593 }
976b1f89 594 if (nNegClusterITS > 0 ){
595 fDaughterProp(17) = negTrack->GetITSsignal();
596 fDaughterProp(21) = pidResonse->NumberOfSigmasITS(negTrack,AliPID::kElectron);
a280ac15 597 } else {
976b1f89 598 fDaughterProp(17) = 1000;
599 fDaughterProp(21) = 20;
a280ac15 600 }
976b1f89 601
602 // TOF
a280ac15 603 if((posTrack->GetStatus() & AliESDtrack::kTOFpid) && !(posTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
604 Double_t t0pos = pidResonse->GetTOFResponse().GetStartTime(posTrack->P());
25c0b354 605 Double_t timesPos[9];
a280ac15 606 posTrack->GetIntegratedTimes(timesPos);
607 Double_t TOFsignalPos = posTrack->GetTOFsignal();
608 Double_t dTpos = TOFsignalPos - t0pos - timesPos[0];
31216736 609 fDaughterProp(4) = dTpos;
610 fDaughterProp(5) = pidResonse->NumberOfSigmasTOF(posTrack, AliPID::kElectron);
a280ac15 611 } else {
31216736 612 fDaughterProp(4) = 20000;
613 fDaughterProp(5) = -20;
a280ac15 614 }
615 if((negTrack->GetStatus() & AliESDtrack::kTOFpid) && !(negTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
616 Double_t t0neg = pidResonse->GetTOFResponse().GetStartTime(negTrack->P());
25c0b354 617 Double_t timesNeg[9];
a280ac15 618 negTrack->GetIntegratedTimes(timesNeg);
619 Double_t TOFsignalNeg = negTrack->GetTOFsignal();
620 Double_t dTneg = TOFsignalNeg - t0neg - timesNeg[0];
31216736 621 fDaughterProp(11) = dTneg;
622 fDaughterProp(12) = pidResonse->NumberOfSigmasTOF(negTrack, AliPID::kElectron);
a280ac15 623 } else {
31216736 624 fDaughterProp(11) = 20000;
625 fDaughterProp(12) = -20;
a280ac15 626 }
627
31216736 628 fDaughterProp(6) = (Float_t)posTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius()));
629 fDaughterProp(18) = posTrack->GetNcls(1);
630 fDaughterProp(13) = (Float_t)negTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius()));
631 fDaughterProp(19) = negTrack->GetNcls(1);
ae947965 632
72395bd9 633 if (fTreeQA){
634 fTreeQA->Fill();
2bb2434e 635 }
636}
a280ac15 637
e5b6e8a6 638//_____________________________________________________________________________________________________
a280ac15 639void AliAnalysisTaskConversionQA::ProcessQA(AliAODConversionPhoton *gamma){
e5b6e8a6 640
616d5128 641 AliPIDResponse* pidResonse = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetPIDResponse();
642
e5b6e8a6 643 // Fill Histograms for QA and MC
616d5128 644
a280ac15 645 hGammaPt->Fill(gamma->GetPhotonPt());
646 hGammaPhi->Fill(gamma->GetPhotonPhi());
647 hGammaEta->Fill(gamma->Eta());
648 hGammaChi2perNDF->Fill(gamma->GetChi2perNDF());
649 hGammaPsiPair->Fill(gamma->GetPsiPair());
616d5128 650 hGammaArmenteros->Fill(gamma->GetArmenterosAlpha(),gamma->GetArmenterosQt());
a280ac15 651 hGammaCosinePointingAngle->Fill(fConversionCuts->GetCosineOfPointingAngle(gamma,fInputEvent));
616d5128 652 hGammaInvMass->Fill(gamma->GetMass());
653// hGammaXY->Fill(gamma->GetConversionX(),gamma->GetConversionY());
654// hGammaZR->Fill(gamma->GetConversionZ(),gamma->GetConversionRadius());
a280ac15 655
ae947965 656 AliVTrack * negTrack = fConversionCuts->GetTrack(fInputEvent, gamma->GetTrackLabelNegative());
657 AliVTrack * posTrack = fConversionCuts->GetTrack(fInputEvent, gamma->GetTrackLabelPositive());
a280ac15 658 if(!negTrack||!posTrack)return;
659
e5b6e8a6 660
a280ac15 661 hElecPt->Fill(negTrack->Pt(),posTrack->Pt());
662 hElecEta->Fill(negTrack->Eta(),posTrack->Eta());
663 hElecPhi->Fill(negTrack->Phi(),posTrack->Phi());
e5b6e8a6 664
a280ac15 665 hElecNfindableClsTPC->Fill((Float_t)posTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius())));
666 hPosiNfindableClsTPC->Fill((Float_t)negTrack->GetTPCClusterInfo(2,0,fConversionCuts->GetFirstTPCRow(gamma->GetConversionRadius())));
616d5128 667 hElecClsTPC->Fill(negTrack->GetNcls(1));
668 hPosiClsTPC->Fill(posTrack->GetNcls(1));
669 //TPC dEdx
670 hElectrondEdxP->Fill(negTrack->P() ,negTrack->GetTPCsignal());
671 hElectronNSigmadEdxP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kElectron));
25c0b354 672 hElectronNSigmadEdxEta->Fill(negTrack->Eta() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kElectron));
616d5128 673 hElectronNSigmaPiondEdxP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTPC(negTrack, AliPID::kPion));
674 hPositrondEdxP->Fill(posTrack->P() ,posTrack->GetTPCsignal());
675 hPositronNSigmadEdxP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kElectron));
25c0b354 676 hPositronNSigmadEdxEta->Fill(posTrack->Eta() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kElectron));
616d5128 677 hPositronNSigmaPiondEdxP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTPC(posTrack, AliPID::kPion));
678
679 //TOF signal
680 if((negTrack->GetStatus() & AliESDtrack::kTOFpid) && !(negTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
681 Double_t t0neg = pidResonse->GetTOFResponse().GetStartTime(negTrack->P());
25c0b354 682 Double_t timesNeg[9];
616d5128 683 negTrack->GetIntegratedTimes(timesNeg);
684 Double_t TOFsignalNeg = negTrack->GetTOFsignal();
685 Double_t dTneg = TOFsignalNeg - t0neg - timesNeg[0];
686 hElectronTOFP->Fill(negTrack->P() ,dTneg);
687 hElectronNSigmaTOFP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasTOF(negTrack, AliPID::kElectron));
688 }
689 if((posTrack->GetStatus() & AliESDtrack::kTOFpid) && !(posTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
690 Double_t t0pos = pidResonse->GetTOFResponse().GetStartTime(posTrack->P());
25c0b354 691 Double_t timesPos[9];
616d5128 692 posTrack->GetIntegratedTimes(timesPos);
693 Double_t TOFsignalPos = posTrack->GetTOFsignal();
694 Double_t dTpos = TOFsignalPos - t0pos - timesPos[0];
695 hPositronTOFP->Fill(posTrack->P() ,dTpos);
696 hPositronNSigmaTOFP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasTOF(posTrack, AliPID::kElectron));
697 }
698
699 Int_t nPosClusterITS = 0;
700 Int_t nNegClusterITS = 0;
701 for(Int_t itsLayer = 0; itsLayer<6;itsLayer++){
702 if(TESTBIT(negTrack->GetITSClusterMap(),itsLayer)){
703 nNegClusterITS++;
704 }
705 if(TESTBIT(posTrack->GetITSClusterMap(),itsLayer)){
706 nPosClusterITS++;
707 }
708 }
709 Double_t negtrackPhi = negTrack->Phi();
710 Double_t postrackPhi = posTrack->Phi();
711 hITSClusterPhi->Fill(negtrackPhi,nNegClusterITS);
712 hITSClusterPhi->Fill(postrackPhi,nPosClusterITS);
713
714 // ITS signal
715 if (nPosClusterITS > 0 ){
716 hPositronITSdEdxP->Fill(posTrack->P() ,posTrack->GetITSsignal());
717 hPositronNSigmaITSP->Fill(posTrack->P() ,pidResonse->NumberOfSigmasITS(posTrack,AliPID::kElectron));
718 }
719 if (nNegClusterITS > 0 ){
720 hElectronITSdEdxP->Fill(negTrack->P() ,negTrack->GetITSsignal());
721 hElectronNSigmaITSP->Fill(negTrack->P() ,pidResonse->NumberOfSigmasITS(negTrack,AliPID::kElectron));
722 }
723
724
e5b6e8a6 725}
a280ac15 726
ae947965 727
e5b6e8a6 728//________________________________________________________________________
ae947965 729void AliAnalysisTaskConversionQA::CountTracks(){
e5b6e8a6 730
ae947965 731 if(fInputEvent->IsA()==AliESDEvent::Class()){
e5b6e8a6 732 // Using standard function for setting Cuts
733 Bool_t selectPrimaries=kTRUE;
0a2b2b4b 734 AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
e5b6e8a6 735 EsdTrackCuts->SetMaxDCAToVertexZ(2);
736 EsdTrackCuts->SetEtaRange(-0.8, 0.8);
737 EsdTrackCuts->SetPtRange(0.15);
ae947965 738 fNumberOfESDTracks = 0;
739 for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
740 AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
741 if(!curTrack) continue;
742 // if(fMCEvent && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
743 // if(!((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(abs(curTrack->GetLabel()), fMCStack)) continue;
744 // }
745 if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTracks++;
746 }
747 delete EsdTrackCuts;
748 EsdTrackCuts=0x0;
e5b6e8a6 749 }
97146ba4 750 else if(fInputEvent->IsA()==AliAODEvent::Class()){
ae947965 751 fNumberOfESDTracks = 0;
752 for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
753 AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
97146ba4 754 if(curTrack->GetID()<0) continue; // Avoid double counting of tracks
755 if(!curTrack->IsHybridGlobalConstrainedGlobal()) continue;
ae947965 756 if(abs(curTrack->Eta())>0.8) continue;
757 if(curTrack->Pt()<0.15) continue;
ae947965 758 fNumberOfESDTracks++;
759 }
760 }
e5b6e8a6 761 return;
762}
a280ac15 763
4803eb1f 764UInt_t AliAnalysisTaskConversionQA::IsTruePhotonESD(AliAODConversionPhoton *TruePhotonCandidate)
765{
766
767
768 UInt_t kind = 9;
769 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
770 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
4803eb1f 771 Int_t motherLabelPhoton;
72395bd9 772 Int_t pdgCodePos = 0;
773 Int_t pdgCodeNeg = 0;
774 Int_t pdgCode = 0;
4803eb1f 775
776
777 if(posDaughter == NULL || negDaughter == NULL) {
778 kind = 9;
779 // return kFALSE; // One particle does not exist
780
85b56575 781 } else if( posDaughter->GetMother(0) != negDaughter->GetMother(0) || (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) {
782 kind = 1;
783 // return 1;
4803eb1f 784 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
785 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
786 if(pdgCodePos==11 && pdgCodeNeg==11) return 10; //Electron Combinatorial
787 if(pdgCodePos==11 && pdgCodeNeg==11 &&
788 (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) return 15; //direct Electron Combinatorial
789
790 if(pdgCodePos==211 && pdgCodeNeg==211) return 11; //Pion Combinatorial
791 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211)) return 12; //Pion, Proton Combinatorics
792 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) return 13; //Pion, Electron Combinatorics
793 if(pdgCodePos==321 || pdgCodeNeg==321) return 14; //Kaon combinatorics
794 }else{
85b56575 795 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
4803eb1f 796 pdgCodePos=posDaughter->GetPdgCode();
797 pdgCodeNeg=negDaughter->GetPdgCode();
85b56575 798 motherLabelPhoton= Photon->GetMother(0);
4803eb1f 799 if ( TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode()) pdgCode = TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode();
800
801 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) return 2; // true from hadronic decays
802 else if ( !(pdgCodeNeg==pdgCodePos)){
803 if(pdgCode == 111) return 3; // pi0 Dalitz
804 else if (pdgCode == 221) return 4; // eta Dalitz
805 else if (!(negDaughter->GetUniqueID() != 5 || posDaughter->GetUniqueID() !=5)){
806 if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
807 return 0; // primary photons
808 } else if (pdgCode == 22){
809 return 5; //secondary photons
810 }
811 }
812 }
813 }
814
815 return kind;
816}
2bb2434e 817
ae947965 818//________________________________________________________________________
4803eb1f 819UInt_t AliAnalysisTaskConversionQA::IsTruePhotonAOD(AliAODConversionPhoton *TruePhotonCandidate)
ae947965 820{
ae947965 821
4803eb1f 822 UInt_t kind = 9;
2d49ea4c 823 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
85b56575 824 if (AODMCTrackArray!=NULL && TruePhotonCandidate!=NULL){
825 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
826 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
827 Int_t pdgCodePos = 0;
828 Int_t pdgCodeNeg = 0;
829 Int_t pdgCode = 0;
830 if(posDaughter == NULL || negDaughter == NULL) {
831 kind = 9;
832 } else if( posDaughter->GetMother() != negDaughter->GetMother() || (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1)) {
833 kind = 1;
834 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
835 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
836 if(pdgCodePos==11 && pdgCodeNeg==11) kind = 10; //Electron Combinatorial
837 if(pdgCodePos==11 && pdgCodeNeg==11 &&
838 (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1))kind = 15; //direct Electron Combinatorial
839
840 if(pdgCodePos==211 && pdgCodeNeg==211) kind = 11; //Pion Combinatorial
841 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211)) kind = 12; //Pion, Proton Combinatorics
842 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) kind = 13; //Pion, Electron Combinatorics
843 if(pdgCodePos==321 || pdgCodeNeg==321) kind = 14; //Kaon combinatorics
844 }else{
845 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
846 pdgCodePos=posDaughter->GetPdgCode();
847 pdgCodeNeg=negDaughter->GetPdgCode();
848
849 if ( Photon->GetPdgCode())
850 pdgCode = Photon->GetPdgCode();
851 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) kind = 2; // true from hadronic decays
852 else if ( !(pdgCodeNeg==pdgCodePos)){
853 if(pdgCode == 111) kind = 3; // pi0 Dalitz
854 else if (pdgCode == 221) kind = 4; // eta Dalitz
855 else if (!(negDaughter->GetMCProcessCode() != 5 || posDaughter->GetMCProcessCode() !=5)){
856 if(pdgCode == 22 && Photon->IsPrimary()){
857 kind = 0; // primary photons
858 } else if (pdgCode == 22){
859 kind = 5; //secondary photons
860 }
4803eb1f 861 }
862 }
863 }
4803eb1f 864
85b56575 865 return kind;
866 }
4803eb1f 867 return kind;
ae947965 868}
869
870//________________________________________________________________________
871void AliAnalysisTaskConversionQA::RelabelAODPhotonCandidates(Bool_t mode){
872
873 // Relabeling For AOD Event
874 // ESDiD -> AODiD
875 // MCLabel -> AODMCLabel
876
877 if(mode){
878 fMCStackPos = new Int_t[fConversionGammas->GetEntries()];
879 fMCStackNeg = new Int_t[fConversionGammas->GetEntries()];
880 }
881
882 for(Int_t iGamma = 0;iGamma<fConversionGammas->GetEntries();iGamma++){
883 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fConversionGammas->At(iGamma);
884 if(!PhotonCandidate) continue;
885 if(!mode){// Back to ESD Labels
886 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
887 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
888 //PhotonCandidate->IsAODMCLabel(kFALSE);
889 continue;
890 }
891 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
892 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
893
894 Bool_t AODLabelPos = kFALSE;
895 Bool_t AODLabelNeg = kFALSE;
896
897 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
898 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
899 if(!AODLabelPos){
900 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
901 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
902 AODLabelPos = kTRUE;
903 }
904 }
905 if(!AODLabelNeg){
906 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
907 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
908 AODLabelNeg = kTRUE;
909 }
910 }
911 if(AODLabelNeg && AODLabelPos){
912 break;
913 }
914 } // Both ESD Tracks have AOD Tracks with Positive IDs
915 if(!AODLabelPos || !AODLabelNeg){
916 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
917 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
918 if(tempDaughter->GetID()<0){
919 if(!AODLabelPos){
920 if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelPositive()){
921 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
922 AODLabelPos = kTRUE;
923 }
924 }
925 if(!AODLabelNeg){
926 if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelNegative()){
927 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
928 AODLabelNeg = kTRUE;
929 }
930 }
931 }
932 if(AODLabelNeg && AODLabelPos){
933 break;
934 }
935 }
936 if(!AODLabelPos || !AODLabelNeg){
937 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
938 }
939 }
940 }
941
942 if(!mode){
943 delete[] fMCStackPos;
944 delete[] fMCStackNeg;
945 }
946}
947
616d5128 948void AliAnalysisTaskConversionQA::SetLogBinningXTH2(TH2* histoRebin){
949 TAxis *axisafter = histoRebin->GetXaxis();
950 Int_t bins = axisafter->GetNbins();
951 Double_t from = axisafter->GetXmin();
952 Double_t to = axisafter->GetXmax();
953 Double_t *newbins = new Double_t[bins+1];
954 newbins[0] = from;
955 Double_t factor = TMath::Power(to/from, 1./bins);
956 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
957 axisafter->Set(bins, newbins);
958 delete [] newbins;
959
960}
961
2bb2434e 962//________________________________________________________________________
963void AliAnalysisTaskConversionQA::Terminate(Option_t *)
964{
a280ac15 965
2bb2434e 966}