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