]> 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
Updating configuration for ACORDE and TRD.
[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 }
ae947965 750 else if(fInputEvent->IsA()==AliAODEvent::Class()){
751 fNumberOfESDTracks = 0;
752 for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
753 AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
754 if(!curTrack->IsPrimaryCandidate()) continue;
755 if(abs(curTrack->Eta())>0.8) continue;
756 if(curTrack->Pt()<0.15) continue;
757 if(abs(curTrack->ZAtDCA())>2) continue;
758 fNumberOfESDTracks++;
759 }
760 }
761
e5b6e8a6 762 return;
763}
a280ac15 764
4803eb1f 765UInt_t AliAnalysisTaskConversionQA::IsTruePhotonESD(AliAODConversionPhoton *TruePhotonCandidate)
766{
767
768
769 UInt_t kind = 9;
770 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
771 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
772 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
773 Int_t motherLabelPhoton;
72395bd9 774 Int_t pdgCodePos = 0;
775 Int_t pdgCodeNeg = 0;
776 Int_t pdgCode = 0;
4803eb1f 777
778
779 if(posDaughter == NULL || negDaughter == NULL) {
780 kind = 9;
781 // return kFALSE; // One particle does not exist
782
783 } else if( posDaughter->GetMother(0) != negDaughter->GetMother(0) || (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) {
784 // kind = 1;
785 return 1;
786 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
787 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
788 if(pdgCodePos==11 && pdgCodeNeg==11) return 10; //Electron Combinatorial
789 if(pdgCodePos==11 && pdgCodeNeg==11 &&
790 (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)) return 15; //direct Electron Combinatorial
791
792 if(pdgCodePos==211 && pdgCodeNeg==211) return 11; //Pion Combinatorial
793 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211)) return 12; //Pion, Proton Combinatorics
794 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) return 13; //Pion, Electron Combinatorics
795 if(pdgCodePos==321 || pdgCodeNeg==321) return 14; //Kaon combinatorics
796 }else{
797
798 pdgCodePos=posDaughter->GetPdgCode();
799 pdgCodeNeg=negDaughter->GetPdgCode();
800 motherLabelPhoton= Photon->GetMother(0);
801 if ( TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode()) pdgCode = TruePhotonCandidate->GetMCParticle(fMCStack)->GetPdgCode();
802
803 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) return 2; // true from hadronic decays
804 else if ( !(pdgCodeNeg==pdgCodePos)){
805 if(pdgCode == 111) return 3; // pi0 Dalitz
806 else if (pdgCode == 221) return 4; // eta Dalitz
807 else if (!(negDaughter->GetUniqueID() != 5 || posDaughter->GetUniqueID() !=5)){
808 if(pdgCode == 22 && motherLabelPhoton < fMCStack->GetNprimary()){
809 return 0; // primary photons
810 } else if (pdgCode == 22){
811 return 5; //secondary photons
812 }
813 }
814 }
815 }
816
817 return kind;
818}
2bb2434e 819
ae947965 820//________________________________________________________________________
4803eb1f 821UInt_t AliAnalysisTaskConversionQA::IsTruePhotonAOD(AliAODConversionPhoton *TruePhotonCandidate)
ae947965 822{
ae947965 823
4803eb1f 824 UInt_t kind = 9;
2d49ea4c 825 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
4803eb1f 826 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
827 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
828 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
72395bd9 829 Int_t pdgCodePos = 0;
830 Int_t pdgCodeNeg = 0;
831 Int_t pdgCode = 0;
4803eb1f 832 if(posDaughter == NULL || negDaughter == NULL) {
833 kind = 9;
ae4f2cfb 834 } else if( posDaughter->GetMother() != negDaughter->GetMother() || (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1)) {
4803eb1f 835 kind = 1;
4803eb1f 836 pdgCodePos=TMath::Abs(posDaughter->GetPdgCode());
837 pdgCodeNeg=TMath::Abs(negDaughter->GetPdgCode());
838 if(pdgCodePos==11 && pdgCodeNeg==11) kind = 10; //Electron Combinatorial
839 if(pdgCodePos==11 && pdgCodeNeg==11 &&
840 (posDaughter->GetMother() == negDaughter->GetMother() && posDaughter->GetMother() ==-1))kind = 15; //direct Electron Combinatorial
841
842 if(pdgCodePos==211 && pdgCodeNeg==211) kind = 11; //Pion Combinatorial
843 if((pdgCodePos==211 && pdgCodeNeg==2212) ||(pdgCodePos==2212 && pdgCodeNeg==211)) kind = 12; //Pion, Proton Combinatorics
844 if((pdgCodePos==211 && pdgCodeNeg==11) ||(pdgCodePos==11 && pdgCodeNeg==211)) kind = 13; //Pion, Electron Combinatorics
845 if(pdgCodePos==321 || pdgCodeNeg==321) kind = 14; //Kaon combinatorics
846 }else{
847
848 pdgCodePos=posDaughter->GetPdgCode();
849 pdgCodeNeg=negDaughter->GetPdgCode();
850
ae4f2cfb 851 if ( Photon->GetPdgCode())
852 pdgCode = Photon->GetPdgCode();
4803eb1f 853 if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11) kind = 2; // true from hadronic decays
854 else if ( !(pdgCodeNeg==pdgCodePos)){
855 if(pdgCode == 111) kind = 3; // pi0 Dalitz
856 else if (pdgCode == 221) kind = 4; // eta Dalitz
857 else if (!(negDaughter->GetMCProcessCode() != 5 || posDaughter->GetMCProcessCode() !=5)){
2d49ea4c 858 if(pdgCode == 22 && Photon->IsPrimary()){
4803eb1f 859 kind = 0; // primary photons
860 } else if (pdgCode == 22){
861 kind = 5; //secondary photons
862 }
863 }
864 }
865 }
866
4803eb1f 867 return kind;
868
ae947965 869
ae947965 870}
871
872//________________________________________________________________________
873void AliAnalysisTaskConversionQA::RelabelAODPhotonCandidates(Bool_t mode){
874
875 // Relabeling For AOD Event
876 // ESDiD -> AODiD
877 // MCLabel -> AODMCLabel
878
879 if(mode){
880 fMCStackPos = new Int_t[fConversionGammas->GetEntries()];
881 fMCStackNeg = new Int_t[fConversionGammas->GetEntries()];
882 }
883
884 for(Int_t iGamma = 0;iGamma<fConversionGammas->GetEntries();iGamma++){
885 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fConversionGammas->At(iGamma);
886 if(!PhotonCandidate) continue;
887 if(!mode){// Back to ESD Labels
888 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
889 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
890 //PhotonCandidate->IsAODMCLabel(kFALSE);
891 continue;
892 }
893 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
894 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
895
896 Bool_t AODLabelPos = kFALSE;
897 Bool_t AODLabelNeg = kFALSE;
898
899 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
900 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
901 if(!AODLabelPos){
902 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
903 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
904 AODLabelPos = kTRUE;
905 }
906 }
907 if(!AODLabelNeg){
908 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
909 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
910 AODLabelNeg = kTRUE;
911 }
912 }
913 if(AODLabelNeg && AODLabelPos){
914 break;
915 }
916 } // Both ESD Tracks have AOD Tracks with Positive IDs
917 if(!AODLabelPos || !AODLabelNeg){
918 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
919 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
920 if(tempDaughter->GetID()<0){
921 if(!AODLabelPos){
922 if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelPositive()){
923 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
924 AODLabelPos = kTRUE;
925 }
926 }
927 if(!AODLabelNeg){
928 if( (abs(tempDaughter->GetID())-1) == PhotonCandidate->GetTrackLabelNegative()){
929 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
930 AODLabelNeg = kTRUE;
931 }
932 }
933 }
934 if(AODLabelNeg && AODLabelPos){
935 break;
936 }
937 }
938 if(!AODLabelPos || !AODLabelNeg){
939 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
940 }
941 }
942 }
943
944 if(!mode){
945 delete[] fMCStackPos;
946 delete[] fMCStackNeg;
947 }
948}
949
616d5128 950void AliAnalysisTaskConversionQA::SetLogBinningXTH2(TH2* histoRebin){
951 TAxis *axisafter = histoRebin->GetXaxis();
952 Int_t bins = axisafter->GetNbins();
953 Double_t from = axisafter->GetXmin();
954 Double_t to = axisafter->GetXmax();
955 Double_t *newbins = new Double_t[bins+1];
956 newbins[0] = from;
957 Double_t factor = TMath::Power(to/from, 1./bins);
958 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
959 axisafter->Set(bins, newbins);
960 delete [] newbins;
961
962}
963
2bb2434e 964//________________________________________________________________________
965void AliAnalysisTaskConversionQA::Terminate(Option_t *)
966{
a280ac15 967
2bb2434e 968}