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