AliPhysics  b752f14 (b752f14)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskMaterialHistos.cxx
Go to the documentation of this file.
1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Authors: Friederike Bock *
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 
23 #include "TChain.h"
24 #include "AliAnalysisManager.h"
25 #include "TParticle.h"
26 #include "TVectorF.h"
27 #include "AliPIDResponse.h"
28 #include "AliESDtrackCuts.h"
29 #include "TFile.h"
30 
31 class iostream;
32 
33 using namespace std;
34 
36 
38  fV0Reader(NULL),
39  fV0ReaderName("V0ReaderV1"),
40  fConversionGammas(NULL),
41  fGammaCandidates(NULL),
42  fConversionCutArray(NULL),
43  fEventCutArray(NULL),
44  fCutFolder(NULL),
45  fESDList(NULL),
46  fTrueList(NULL),
47  fMCList(NULL),
48  fOutputList(NULL),
49  fAllMCGammaList(NULL),
50  fAllMCConvGammaList(NULL),
51  fPrimVtxZ(0.),
52  fNContrVtx(0),
53  fNESDtracksEta09(0),
54  fNESDtracksEta0914(0),
55  fNESDtracksEta14(0),
56  fGammaMCPt(0.),
57  fGammaMCTheta(0.),
58  fGammaMCConvPt(0.),
59  fGammaMCConvTheta(0.),
60  fGammaPt(0.),
61  fGammaTheta(0.),
62  fGammaChi2NDF(0.),
63  fKind(0),
64  fIsHeavyIon(0),
65  fIsMC(0),
66  fInputEvent(NULL),
67  fMCEvent(NULL),
68  fMCStack(NULL),
69  fnCuts(0),
70  fiCut(0),
71  hNEvents(NULL),
72  hNGoodESDTracks09(NULL),
73  hNGoodESDTracks14(NULL),
74  hNGoodESDTracks09_14(NULL),
75  hESDConversionMappingRPhi(NULL),
76  hESDConversionMappingRZ(NULL),
77  hESDConversionR(NULL),
78  hESDConversionPtvsR(NULL),
79  hESDConversionAsymP(NULL),
80  hESDConversionMidPtR(NULL),
81  hESDConversionHighPtR(NULL),
82  hESDConversionEtaPR(NULL),
83  hESDConversionEtaNR(NULL),
84  hESDConversionRInBins(NULL),
85  hESDConversionPhiInBins(NULL),
86  hESDConversionEta(NULL),
87  hESDConversionMidPtEta(NULL),
88  hESDConversionHighPtEta(NULL),
89  hESDConversionPt(NULL),
90  hESDConversionPt5cm(NULL),
91  hESDConversionDCA(NULL),
92  hESDConversionMidPtDCA(NULL),
93  hESDConversionHighPtDCA(NULL),
94  hESDConversionPsiPair(NULL),
95  hESDConversionChi2(NULL),
96  hESDConversionMass(NULL),
97  hMCConversionMappingRPhi(NULL),
98  hMCConversionR(NULL),
99  hMCConversionPtvsR(NULL),
100  hMCConversionMidPtR(NULL),
101  hMCConversionHighPtR(NULL),
102  hMCConversionEtaPR(NULL),
103  hMCConversionEtaNR(NULL),
104  hMCConversionEta(NULL),
105  hMCConversionMidPtEta(NULL),
106  hMCConversionHighPtEta(NULL),
107  hMCConversionPt(NULL),
108  hMCAllGammaPt(NULL),
109  hMCTrueConversionMappingRPhi(NULL),
110  hMCTrueConversionMappingRZ(NULL),
111  hMCTrueConversionR(NULL),
112  hMCTrueConversionPtvsR(NULL),
113  hMCTrueConversionMidPtR(NULL),
114  hMCTrueConversionHighPtR(NULL),
115  hMCTrueConversionEtaPR(NULL),
116  hMCTrueConversionEtaNR(NULL),
117  hMCTrueConversionEta(NULL),
118  hMCTrueConversionMidPtEta(NULL),
119  hMCTrueConversionHighPtEta(NULL),
120  hMCTrueConversionPt(NULL),
121  hMCTrueConversionPt5cm(NULL),
122  hMCTrueConversionAsymP(NULL),
123  hMCTrueConversionDCA(NULL),
124  hMCTrueConversionMidPtDCA(NULL),
125  hMCTrueConversionHighPtDCA(NULL),
126  hMCTrueConversionPsiPair(NULL),
127  hMCTrueConversionChi2(NULL),
128  hMCTrueConversionMass(NULL),
129  hMCTruePi0DalConversionR(NULL),
130  hMCTruePi0DalConversionMidPtR(NULL),
131  hMCTruePi0DalConversionHighPtR(NULL),
132  hMCTruePi0DalConversionEta(NULL),
133  hMCTruePi0DalConversionMidPtEta(NULL),
134  hMCTruePi0DalConversionHighPtEta(NULL),
135  hMCTruePi0DalConversionPt(NULL),
136  hMCTrueEtaDalConversionR(NULL),
137  hMCTrueEtaDalConversionMidPtR(NULL),
138  hMCTrueEtaDalConversionHighPtR(NULL),
139  hMCTrueEtaDalConversionEta(NULL),
140  hMCTrueEtaDalConversionMidPtEta(NULL),
141  hMCTrueEtaDalConversionHighPtEta(NULL),
142  hMCTrueEtaDalConversionPt(NULL),
143  hMCTrueCombConversionR(NULL),
144  hMCTrueCombConversionMidPtR(NULL),
145  hMCTrueCombConversionHighPtR(NULL),
146  hMCTrueCombConversionEta(NULL),
147  hMCTrueCombConversionMidPtEta(NULL),
148  hMCTrueCombConversionHighPtEta(NULL),
149  hMCTrueCombConversionPt(NULL)
150 {
151 
152 }
153 
154 
155 //________________________________________________________________________
157 fV0Reader(NULL),
158 fV0ReaderName("V0ReaderV1"),
159 fConversionGammas(NULL),
160 fGammaCandidates(NULL),
161 fConversionCutArray(NULL),
162  fEventCutArray(NULL),
163  fCutFolder(NULL),
164  fESDList(NULL),
165  fTrueList(NULL),
166  fMCList(NULL),
167  fOutputList(NULL),
168  fAllMCGammaList(NULL),
169  fAllMCConvGammaList(NULL),
170  fPrimVtxZ(0.),
171  fNContrVtx(0),
172  fNESDtracksEta09(0),
173  fNESDtracksEta0914(0),
174  fNESDtracksEta14(0),
175  fGammaMCPt(0.),
176  fGammaMCTheta(0.),
177  fGammaMCConvPt(0.),
178  fGammaMCConvTheta(0.),
179  fGammaPt(0.),
180  fGammaTheta(0.),
181  fGammaChi2NDF(0.),
182  fKind(0),
183  fIsHeavyIon(0),
184  fIsMC(0),
185  fInputEvent(NULL),
186  fMCEvent(NULL),
187  fMCStack(NULL),
188  fnCuts(0),
189  fiCut(0),
190  hNEvents(NULL),
191  hNGoodESDTracks09(NULL),
192  hNGoodESDTracks14(NULL),
193  hNGoodESDTracks09_14(NULL),
194  hESDConversionMappingRPhi(NULL),
195  hESDConversionMappingRZ(NULL),
196  hESDConversionR(NULL),
197  hESDConversionPtvsR(NULL),
198  hESDConversionAsymP(NULL),
199  hESDConversionMidPtR(NULL),
200  hESDConversionHighPtR(NULL),
201  hESDConversionEtaPR(NULL),
202  hESDConversionEtaNR(NULL),
203  hESDConversionRInBins(NULL),
204  hESDConversionPhiInBins(NULL),
205  hESDConversionEta(NULL),
206  hESDConversionMidPtEta(NULL),
207  hESDConversionHighPtEta(NULL),
208  hESDConversionPt(NULL),
209  hESDConversionPt5cm(NULL),
210  hESDConversionDCA(NULL),
211  hESDConversionMidPtDCA(NULL),
212  hESDConversionHighPtDCA(NULL),
213  hESDConversionPsiPair(NULL),
214  hESDConversionChi2(NULL),
215  hESDConversionMass(NULL),
216  hMCConversionMappingRPhi(NULL),
217  hMCConversionR(NULL),
218  hMCConversionPtvsR(NULL),
219  hMCConversionMidPtR(NULL),
220  hMCConversionHighPtR(NULL),
221  hMCConversionEtaPR(NULL),
222  hMCConversionEtaNR(NULL),
223  hMCConversionEta(NULL),
224  hMCConversionMidPtEta(NULL),
225  hMCConversionHighPtEta(NULL),
226  hMCConversionPt(NULL),
227  hMCAllGammaPt(NULL),
228  hMCTrueConversionMappingRPhi(NULL),
229  hMCTrueConversionMappingRZ(NULL),
230  hMCTrueConversionR(NULL),
231  hMCTrueConversionPtvsR(NULL),
232  hMCTrueConversionMidPtR(NULL),
233  hMCTrueConversionHighPtR(NULL),
234  hMCTrueConversionEtaPR(NULL),
235  hMCTrueConversionEtaNR(NULL),
236  hMCTrueConversionEta(NULL),
237  hMCTrueConversionMidPtEta(NULL),
238  hMCTrueConversionHighPtEta(NULL),
239  hMCTrueConversionPt(NULL),
240  hMCTrueConversionPt5cm(NULL),
241  hMCTrueConversionAsymP(NULL),
242  hMCTrueConversionDCA(NULL),
243  hMCTrueConversionMidPtDCA(NULL),
244  hMCTrueConversionHighPtDCA(NULL),
245  hMCTrueConversionPsiPair(NULL),
246  hMCTrueConversionChi2(NULL),
247  hMCTrueConversionMass(NULL),
248  hMCTruePi0DalConversionR(NULL),
249  hMCTruePi0DalConversionMidPtR(NULL),
250  hMCTruePi0DalConversionHighPtR(NULL),
251  hMCTruePi0DalConversionEta(NULL),
252  hMCTruePi0DalConversionMidPtEta(NULL),
253  hMCTruePi0DalConversionHighPtEta(NULL),
254  hMCTruePi0DalConversionPt(NULL),
255  hMCTrueEtaDalConversionR(NULL),
256  hMCTrueEtaDalConversionMidPtR(NULL),
257  hMCTrueEtaDalConversionHighPtR(NULL),
258  hMCTrueEtaDalConversionEta(NULL),
259  hMCTrueEtaDalConversionMidPtEta(NULL),
260  hMCTrueEtaDalConversionHighPtEta(NULL),
261  hMCTrueEtaDalConversionPt(NULL),
262  hMCTrueCombConversionR(NULL),
263  hMCTrueCombConversionMidPtR(NULL),
264  hMCTrueCombConversionHighPtR(NULL),
265  hMCTrueCombConversionEta(NULL),
266  hMCTrueCombConversionMidPtEta(NULL),
267  hMCTrueCombConversionHighPtEta(NULL),
268  hMCTrueCombConversionPt(NULL)
269 {
270  // Default constructor
271 
272  DefineInput(0, TChain::Class());
273  DefineOutput(1, TList::Class());
274 }
275 
276 //________________________________________________________________________
278 {
279  // default deconstructor
280  if(fGammaCandidates){
281  delete fGammaCandidates;
282  fGammaCandidates = 0x0;
283  }
284 }
285 //________________________________________________________________________
287 {
288  // Create User Output Objects
289 
290  if(fOutputList != NULL){
291  delete fOutputList;
292  fOutputList = NULL;
293  }
294  if(fOutputList == NULL){
295  fOutputList = new TList();
296  fOutputList->SetOwner(kTRUE);
297  }
298 
299  // Array of current cut's gammas
300 
301  fGammaCandidates = new TList();
302  fCutFolder = new TList*[fnCuts];
303  fESDList = new TList*[fnCuts];
304  fMCList = new TList*[fnCuts];
305  fTrueList = new TList*[fnCuts];
306 
307 
308  hNEvents = new TH1F*[fnCuts];
309  hNGoodESDTracks09 = new TH1F*[fnCuts];
310  hNGoodESDTracks14 = new TH1F*[fnCuts];
311  hNGoodESDTracks09_14 = new TH1F*[fnCuts];
314  hESDConversionR = new TH1F*[fnCuts];
319  hESDConversionMidPtR = new TH1F*[fnCuts];
320  hESDConversionHighPtR = new TH1F*[fnCuts];
321  hESDConversionEtaPR = new TH1F*[fnCuts];
322  hESDConversionEtaNR = new TH1F*[fnCuts];
323  hESDConversionEta = new TH1F*[fnCuts];
324  hESDConversionMidPtEta = new TH1F*[fnCuts];
325  hESDConversionHighPtEta = new TH1F*[fnCuts];
326  hESDConversionPt = new TH1F*[fnCuts];
327  hESDConversionPt5cm = new TH1F*[fnCuts];
328  hESDConversionDCA = new TH1F*[fnCuts];
329  hESDConversionMidPtDCA = new TH1F*[fnCuts];
330  hESDConversionHighPtDCA = new TH1F*[fnCuts];
331  hESDConversionPsiPair = new TH1F*[fnCuts];
332  hESDConversionChi2 = new TH1F*[fnCuts];
333  hESDConversionMass = new TH1F*[fnCuts];
334 
336  hMCConversionR = new TH1F*[fnCuts];
338  hMCConversionMidPtR = new TH1F*[fnCuts];
339  hMCConversionHighPtR = new TH1F*[fnCuts];
340  hMCConversionEtaPR = new TH1F*[fnCuts];
341  hMCConversionEtaNR = new TH1F*[fnCuts];
342  hMCConversionEta = new TH1F*[fnCuts];
343  hMCConversionMidPtEta = new TH1F*[fnCuts];
344  hMCConversionHighPtEta = new TH1F*[fnCuts];
345  hMCConversionPt = new TH1F*[fnCuts];
346  hMCAllGammaPt = new TH1F*[fnCuts];
347 
350  hMCTrueConversionR = new TH1F*[fnCuts];
352  hMCTrueConversionMidPtR = new TH1F*[fnCuts];
353  hMCTrueConversionHighPtR = new TH1F*[fnCuts];
354  hMCTrueConversionEtaPR = new TH1F*[fnCuts];
355  hMCTrueConversionEtaNR = new TH1F*[fnCuts];
356  hMCTrueConversionEta = new TH1F*[fnCuts];
357  hMCTrueConversionMidPtEta = new TH1F*[fnCuts];
358  hMCTrueConversionHighPtEta = new TH1F*[fnCuts];
359  hMCTrueConversionPt = new TH1F*[fnCuts];
360  hMCTrueConversionPt5cm = new TH1F*[fnCuts];
361 
363  hMCTrueConversionDCA = new TH1F*[fnCuts];
364  hMCTrueConversionMidPtDCA = new TH1F*[fnCuts];
365  hMCTrueConversionHighPtDCA = new TH1F*[fnCuts];
366  hMCTrueConversionPsiPair = new TH1F*[fnCuts];
367  hMCTrueConversionChi2 = new TH1F*[fnCuts];
368  hMCTrueConversionMass = new TH1F*[fnCuts];
369 
370 
371  hMCTruePi0DalConversionR = new TH1F*[fnCuts];
374  hMCTruePi0DalConversionEta = new TH1F*[fnCuts];
377  hMCTruePi0DalConversionPt = new TH1F*[fnCuts];
378 
379 
380  hMCTrueEtaDalConversionEta = new TH1F*[fnCuts];
383  hMCTrueEtaDalConversionPt = new TH1F*[fnCuts];
384  hMCTrueEtaDalConversionR = new TH1F*[fnCuts];
387 
388  hMCTrueCombConversionR = new TH1F*[fnCuts];
389  hMCTrueCombConversionMidPtR = new TH1F*[fnCuts];
391  hMCTrueCombConversionEta = new TH1F*[fnCuts];
394  hMCTrueCombConversionPt = new TH1F*[fnCuts];
395 
396 
397 
398  for(Int_t iCut = 0; iCut<fnCuts;iCut++){
399 
400 
401  TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
402  TString cutstringPhoton = ((AliConversionPhotonCuts*)fConversionCutArray->At(iCut))->GetCutNumber();
403  fCutFolder[iCut] = new TList();
404  fCutFolder[iCut]->SetName(Form("Cut Number %s_%s",cutstringEvent.Data() ,cutstringPhoton.Data()));
405  fCutFolder[iCut]->SetOwner(kTRUE);
406  fOutputList->Add(fCutFolder[iCut]);
407 
408  fESDList[iCut] = new TList();
409  fESDList[iCut]->SetName(Form("%s_%s ESD histograms",cutstringEvent.Data() ,cutstringPhoton.Data()));
410  fESDList[iCut]->SetOwner(kTRUE);
411  fCutFolder[iCut]->Add(fESDList[iCut]);
412 
413  Int_t nBinsR=400;
414  Int_t nBinsX=2000;
415  Int_t nBinsY=2000;
416  Int_t nBinsZ=500;
417  Int_t nBinsPhi=750;
418  Int_t nBinsEta=2000;
419  Int_t nBinsPt=400;
420 
421 
422 
423  hNEvents[iCut] = new TH1F("NEvents","NEvents",14,-0.5,13.5);
424  hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
425  hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
426  hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Miss. MC or inc. ev.");
427  if (((AliConvEventCuts*)fEventCutArray->At(iCut))->IsSpecialTrigger() > 1 ){
428  TString TriggerNames = "Not Trigger: ";
429  TriggerNames = TriggerNames+ ( (AliConvEventCuts*)fEventCutArray->At(iCut))->GetSpecialTriggerName();
430  hNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
431  } else {
432  hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
433  }
434  hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
435  hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
436  hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
437  hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
438  hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
439  hNEvents[iCut]->GetXaxis()->SetBinLabel(10,"EMCAL problem");
440  hNEvents[iCut]->GetXaxis()->SetBinLabel(11,"rejectedForJetJetMC");
441  hNEvents[iCut]->GetXaxis()->SetBinLabel(12,"SPD hits vs tracklet");
442  hNEvents[iCut]->GetXaxis()->SetBinLabel(13,"Out-of-Bunch pileup Past-Future");
443  hNEvents[iCut]->GetXaxis()->SetBinLabel(14,"Pileup V0M-TPCout Tracks");
444  fESDList[iCut]->Add(hNEvents[iCut]);
445 
446 
447  hNGoodESDTracks09[iCut] = new TH1F("GoodESDTracks09","GoodESDTracks09",4000,0,4000);
448  fESDList[iCut]->Add(hNGoodESDTracks09[iCut]);
449 
450  hNGoodESDTracks14[iCut] = new TH1F("GoodESDTracks14","GoodESDTracks14",4000,0,4000);
451  fESDList[iCut]->Add(hNGoodESDTracks14[iCut]);
452 
453  hNGoodESDTracks09_14[iCut] = new TH1F("GoodESDTracks09_14","GoodESDTracks09_14",4000,0,4000);
454  fESDList[iCut]->Add(hNGoodESDTracks09_14[iCut]);
455 
456  hESDConversionMappingRPhi[iCut] = new TH2F("ESD_ConversionMapping_RPhi","ESD_ConversionMapping_RPhi",nBinsPhi,0.,2*TMath::Pi(),nBinsR,0.,200.);
457 
458  fESDList[iCut]->Add(hESDConversionMappingRPhi[iCut]);
459  hESDConversionMappingRZ[iCut] = new TH2F("ESD_ConversionMapping_RZ","ESD_ConversionMapping_RZ",nBinsPhi,-180.,180.,nBinsR,0.,200.);
460  fESDList[iCut]->Add(hESDConversionMappingRZ[iCut]);
461  hESDConversionR[iCut] = new TH1F("ESD_ConversionMapping_R","ESD_ConversionMapping_R",nBinsR,0.,200.);
462  fESDList[iCut]->Add(hESDConversionR[iCut]);
463 
464  hESDConversionPtvsR[iCut] = new TH2F("ESD_ConversionMapping_Pt_R","ESD_ConversionMapping_Pt_R",nBinsPt,0.,20.,nBinsR,0.,200.);
465  fESDList[iCut]->Add(hESDConversionPtvsR[iCut]);
466 
467  hESDConversionRInBins[iCut] = new TH3F("ESD_ConversionMapping_RInBins","ESD_ConversionMapping_RInBins",100,0.,20.,8,0.,4000,nBinsR,0.,200.);
468  fESDList[iCut]->Add(hESDConversionRInBins[iCut]);
469  hESDConversionPhiInBins[iCut] = new TH3F("ESD_ConversionMapping_PhiInBins","ESD_ConversionMapping_PhiInBins",100,0.,200.,8,0.,4000,nBinsPhi,0.,2*TMath::Pi());
470  fESDList[iCut]->Add(hESDConversionPhiInBins[iCut]);
471 
472  hESDConversionAsymP[iCut] = new TH2F("ESD_ConversionMapping_AsymP","ESD_ConversionMapping_AsymP",nBinsPt,0.01,20.,500,0.,1.);
473  fESDList[iCut]->Add(hESDConversionAsymP[iCut]);
474 
475  hESDConversionMidPtR[iCut] = new TH1F("ESD_ConversionMappingMidPt_R","ESD_ConversionMappingMidPt_R",nBinsR,0.,200.);
476  fESDList[iCut]->Add(hESDConversionMidPtR[iCut]);
477 
478  hESDConversionHighPtR[iCut] = new TH1F("ESD_ConversionMappingHighPt_R","ESD_ConversionMappingHighPt_R",nBinsR,0.,200.);
479  fESDList[iCut]->Add(hESDConversionHighPtR[iCut]);
480 
481  hESDConversionEtaPR[iCut] = new TH1F("ESD_ConversionMappingEtaP_R","ESD_ConversionMappingEtaP_R",nBinsR,0.,200.);
482  fESDList[iCut]->Add(hESDConversionEtaPR[iCut]);
483 
484  hESDConversionEtaNR[iCut] = new TH1F("ESD_ConversionMappingEtaN_R","ESD_ConversionMappingEtaN_R",nBinsR,0.,200.);
485  fESDList[iCut]->Add(hESDConversionEtaNR[iCut]);
486 
487  hESDConversionEta[iCut] = new TH1F("ESD_ConversionMapping_Eta","ESD_ConversionMapping_Eta",nBinsEta,-2.,2.);
488  fESDList[iCut]->Add(hESDConversionEta[iCut]);
489 
490  hESDConversionMidPtEta[iCut] = new TH1F("ESD_ConversionMappingMidPt_Eta","ESD_ConversionMappingMidPt_Eta",nBinsEta,-2.,2.);
491  fESDList[iCut]->Add(hESDConversionMidPtEta[iCut]);
492 
493  hESDConversionHighPtEta[iCut] = new TH1F("ESD_ConversionMappingHighPt_Eta","ESD_ConversionMappingHighPt_Eta",nBinsEta,-2.,2.);
494  fESDList[iCut]->Add(hESDConversionHighPtEta[iCut]);
495 
496  hESDConversionPt[iCut] = new TH1F("ESD_ConversionMapping_Pt","ESD_ConversionMapping_Pt",nBinsPt,0.,20.);
497  fESDList[iCut]->Add(hESDConversionPt[iCut]);
498 
499  hESDConversionPt5cm[iCut] = new TH1F("ESD_ConversionMapping_Pt5cm","ESD_ConversionMapping_Pt5cm",nBinsPt,0.,20.);
500  fESDList[iCut]->Add(hESDConversionPt5cm[iCut]);
501 
502  hESDConversionDCA[iCut] = new TH1F("ESD_ConversionMapping_DCA","ESD_ConversionMapping_DCA",nBinsPt,0.,5.);
503  fESDList[iCut]->Add(hESDConversionDCA[iCut]);
504 
505  hESDConversionMidPtDCA[iCut] = new TH1F("ESD_ConversionMappingMidPt_DCA","ESD_ConversionMappingMidPt_DCA",nBinsPt,0.,5.);
506  fESDList[iCut]->Add(hESDConversionMidPtDCA[iCut]);
507 
508  hESDConversionHighPtDCA[iCut] = new TH1F("ESD_ConversionMappingHighPt_DCA","ESD_ConversionMappingHighPt_DCA",nBinsPt,0.,5.);
509  fESDList[iCut]->Add(hESDConversionHighPtDCA[iCut]);
510 
511 
512  hESDConversionPsiPair[iCut] = new TH1F("ESD_ConversionMapping_PsiPair","ESD_ConversionMapping_PsiPair",nBinsPt,0.,5.);
513  fESDList[iCut]->Add(hESDConversionPsiPair[iCut]);
514 
515  hESDConversionChi2[iCut] = new TH1F("ESD_ConversionMapping_Chi2","ESD_ConversionMapping_Chi2",nBinsPt,0.,50.);
516  fESDList[iCut]->Add(hESDConversionChi2[iCut]);
517 
518  hESDConversionMass[iCut] = new TH1F("ESD_ConversionMapping_Mass","ESD_ConversionMapping_Mass",nBinsPt,0.,1.);
519  fESDList[iCut]->Add(hESDConversionMass[iCut]);
520 
521 
522 
523 
524  TAxis *AxisAfter = hESDConversionAsymP[iCut]->GetXaxis();
525  Int_t bins = AxisAfter->GetNbins();
526  Double_t from = AxisAfter->GetXmin();
527  Double_t to = AxisAfter->GetXmax();
528  Double_t *newBins = new Double_t[bins+1];
529  newBins[0] = from;
530  Double_t factor = TMath::Power(to/from, 1./bins);
531  for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];
532  AxisAfter->Set(bins, newBins);
533 
534 
535 
536  if (fIsMC>0) {
537  fMCList[iCut] = new TList();
538  fMCList[iCut]->SetName(Form("%s_%s MC histograms",cutstringEvent.Data() ,cutstringPhoton.Data()));
539  fMCList[iCut]->SetOwner(kTRUE);
540  fCutFolder[iCut]->Add(fMCList[iCut]);
541 
542  fTrueList[iCut] = new TList();
543  fTrueList[iCut]->SetName(Form("%s_%s True histograms",cutstringEvent.Data() ,cutstringPhoton.Data()));
544  fTrueList[iCut]->SetOwner(kTRUE);
545  fCutFolder[iCut]->Add(fTrueList[iCut]);
546 
547 
548 
549 
550  hMCConversionMappingRPhi[iCut] = new TH2F("MC_ConversionMapping_RPhi","MC_ConversionMapping_RPhi",nBinsPhi,0.,2*TMath::Pi(),nBinsR,0.,200.);
551  fMCList[iCut]->Add(hMCConversionMappingRPhi[iCut]);
552  hMCConversionR[iCut] = new TH1F("MC_ConversionMapping_R","MC_ConversionMapping_R",nBinsR,0.,200.);
553  fMCList[iCut]->Add(hMCConversionR[iCut]);
554  hMCConversionPtvsR[iCut] = new TH2F("MC_ConversionMapping_Pt_R","MC_ConversionMapping_Pt_R",nBinsPt,0.,20.,nBinsR,0.,200.);
555  fMCList[iCut]->Add(hMCConversionPtvsR[iCut]);
556  hMCConversionMidPtR[iCut] = new TH1F("MC_ConversionMappingMidPt_R","MC_ConversionMappingMidPt_R",nBinsR,0.,200.);
557  fMCList[iCut]->Add(hMCConversionMidPtR[iCut]);
558  hMCConversionHighPtR[iCut] = new TH1F("MC_ConversionMappingHighPt_R","MC_ConversionMappingHighPt_R",nBinsR,0.,200.);
559  fMCList[iCut]->Add(hMCConversionHighPtR[iCut]);
560  hMCConversionEtaPR[iCut] = new TH1F("MC_ConversionMappingEtaP_R","MC_ConversionMappingEtaP_R",nBinsR,0.,200.);
561  fMCList[iCut]->Add(hMCConversionEtaPR[iCut]);
562  hMCConversionEtaNR[iCut] = new TH1F("MC_ConversionMappingEtaN_R","MC_ConversionMappingEtaN_R",nBinsR,0.,200.);
563  fMCList[iCut]->Add(hMCConversionEtaNR[iCut]);
564  hMCConversionEta[iCut] = new TH1F("MC_ConversionMapping_Eta","MC_ConversionMapping_Eta",nBinsEta,-2.,2.);
565  fMCList[iCut]->Add(hMCConversionEta[iCut]);
566  hMCConversionMidPtEta[iCut] = new TH1F("MC_ConversionMappingMidPt_Eta","MC_ConversionMappingMidPt_Eta",nBinsEta,-2.,2.);
567  fMCList[iCut]->Add(hMCConversionMidPtEta[iCut]);
568  hMCConversionHighPtEta[iCut] = new TH1F("MC_ConversionMappingHighPt_Eta","MC_ConversionMappingHighPt_Eta",nBinsEta,-2.,2.);
569  fMCList[iCut]->Add(hMCConversionHighPtEta[iCut]);
570  hMCConversionPt[iCut] = new TH1F("MC_ConversionMapping_Pt","MC_ConversionMapping_Pt",nBinsPt,0.,20.);
571  fMCList[iCut]->Add(hMCConversionPt[iCut]);
572  hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",nBinsPt,0.,20.);
573  fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
574 
575 
576 
577  hMCTrueConversionMappingRPhi[iCut] = new TH2F("ESD_TrueConversionMapping_RPhi","ESD_TrueConversionMapping_RPhi",nBinsPhi,0.,2*TMath::Pi(),nBinsR,0.,200.);
578  fTrueList[iCut]->Add(hMCTrueConversionMappingRPhi[iCut]);
579 
580  hMCTrueConversionMappingRZ[iCut] = new TH2F("ESD_TrueConversionMapping_RZ","ESD_TrueConversionMapping_RZ",nBinsPhi,-180.,180.,nBinsR,0.,200.);
581  fTrueList[iCut]->Add(hMCTrueConversionMappingRZ[iCut]);
582 
583 
584  hMCTrueConversionR[iCut] = new TH1F("ESD_TrueConversionMapping_R","ESD_TrueConversionMapping_R",nBinsR,0.,200.);
585  fTrueList[iCut]->Add(hMCTrueConversionR[iCut]);
586 
587  hMCTrueConversionPtvsR[iCut] = new TH2F("ESD_TrueConversionMapping_Pt_R","ESD_TrueConversionMapping_Pt_R",nBinsPt,0.,20.,nBinsR,0.,200.);
588  fTrueList[iCut]->Add(hMCTrueConversionPtvsR[iCut]);
589 
590 
591  hMCTrueConversionMidPtR[iCut] = new TH1F("ESD_TrueConversionMappingMidPt_R","ESD_TrueConversionMappingMidPt_R",nBinsR,0.,200.);
592  fTrueList[iCut]->Add(hMCTrueConversionMidPtR[iCut]);
593 
594  hMCTrueConversionHighPtR[iCut] = new TH1F("ESD_TrueConversionMappingHighPt_R","ESD_TrueConversionMappingHighPt_R",nBinsR,0.,200.);
595  fTrueList[iCut]->Add(hMCTrueConversionHighPtR[iCut]);
596 
597  hMCTrueConversionEtaPR[iCut] = new TH1F("ESD_TrueConversionMappingEtaP_R","ESD_TrueConversionMappingEtaP_R",nBinsR,0.,200.);
598  fTrueList[iCut]->Add(hMCTrueConversionEtaPR[iCut]);
599 
600  hMCTrueConversionEtaNR[iCut] = new TH1F("ESD_TrueConversionMappingEtaN_R","ESD_TrueConversionMappingEtaN_R",nBinsR,0.,200.);
601  fTrueList[iCut]->Add(hMCTrueConversionEtaNR[iCut]);
602 
603  hMCTrueConversionEta[iCut] = new TH1F("ESD_TrueConversionMapping_Eta","ESD_TrueConversionMapping_Eta",nBinsEta,-2.,2.);
604  fTrueList[iCut]->Add(hMCTrueConversionEta[iCut]);
605  hMCTrueConversionMidPtEta[iCut] = new TH1F("ESD_TrueConversionMappingMidPt_Eta","ESD_TrueConversionMappingMidPt_Eta",nBinsEta,-2.,2.);
606  fTrueList[iCut]->Add(hMCTrueConversionMidPtEta[iCut]);
607  hMCTrueConversionHighPtEta[iCut] = new TH1F("ESD_TrueConversionMappingHighPt_Eta","ESD_TrueConversionMappingHighPt_Eta",nBinsEta,-2.,2.);
608  fTrueList[iCut]->Add(hMCTrueConversionHighPtEta[iCut]);
609 
610  hMCTrueConversionPt[iCut] = new TH1F("ESD_TrueConversionMapping_Pt","ESD_TrueConversionMapping_Pt",nBinsPt,0.,20.);
611  fTrueList[iCut]->Add(hMCTrueConversionPt[iCut]);
612 
613  hMCTrueConversionPt5cm[iCut] = new TH1F("ESD_TrueConversionMapping_Pt5cm","ESD_TrueConversionMapping_Pt5cm",nBinsPt,0.,20.);
614  fTrueList[iCut]->Add(hMCTrueConversionPt5cm[iCut]);
615 
616  hMCTrueConversionAsymP[iCut] = new TH2F("ESD_TrueConversionMapping_AsymP","ESD_TrueConversionMapping_AsymP",nBinsPt,0.01,20.,500,0.,1.);
617  fTrueList[iCut]->Add(hMCTrueConversionAsymP[iCut]);
618 
619  AxisAfter = hMCTrueConversionAsymP[iCut]->GetXaxis();
620  AxisAfter->Set(bins, newBins);
621 
622  hMCTrueConversionDCA[iCut] = new TH1F("ESD_TrueConversionMapping_DCA","ESD_TrueConversionMapping_DCA",nBinsPt,0.,5.);
623  fTrueList[iCut]->Add(hMCTrueConversionDCA[iCut]);
624 
625  hMCTrueConversionMidPtDCA[iCut] = new TH1F("ESD_TrueConversionMappingMidPt_DCA","ESD_TrueConversionMappingMidPt_DCA",nBinsPt,0.,5.);
626  fTrueList[iCut]->Add(hMCTrueConversionMidPtDCA[iCut]);
627 
628  hMCTrueConversionHighPtDCA[iCut] = new TH1F("ESD_TrueConversionMappingHighPt_DCA","ESD_TrueConversionMappingHighPt_DCA",nBinsPt,0.,5.);
629  fTrueList[iCut]->Add(hMCTrueConversionHighPtDCA[iCut]);
630 
631 
632  hMCTrueConversionPsiPair[iCut] = new TH1F("ESD_TrueConversionMapping_PsiPair","ESD_TrueConversionMapping_PsiPair",nBinsPt,0.,5.);
633  fTrueList[iCut]->Add(hMCTrueConversionPsiPair[iCut]);
634 
635  hMCTrueConversionChi2[iCut] = new TH1F("ESD_TrueConversionMapping_Chi2","ESD_TrueConversionMapping_Chi2",nBinsPt,0.,50.);
636  fTrueList[iCut]->Add(hMCTrueConversionChi2[iCut]);
637 
638  hMCTrueConversionMass[iCut] = new TH1F("ESD_TrueConversionMapping_Mass","ESD_TrueConversionMapping_Mass",nBinsPt,0.,1.);
639  fTrueList[iCut]->Add(hMCTrueConversionMass[iCut]);
640 
641 
642  hMCTruePi0DalConversionR[iCut] = new TH1F("ESD_TruePi0DalConversionMapping_R","ESD_TruePi0DalConversionMapping_R",nBinsR,0.,200.);
643  fTrueList[iCut]->Add(hMCTruePi0DalConversionR[iCut]);
644 
645  hMCTruePi0DalConversionMidPtR[iCut] = new TH1F("ESD_TruePi0DalConversionMappingMidPt_R","ESD_TruePi0DalConversionMappingMidPt_R",nBinsR,0.,200.);
646  fTrueList[iCut]->Add(hMCTruePi0DalConversionMidPtR[iCut]);
647 
648 
649  hMCTruePi0DalConversionHighPtR[iCut] = new TH1F("ESD_TruePi0DalConversionMappingHighPt_R","ESD_TruePi0DalConversionMappingHighPt_R",nBinsR,0.,200.);
650  fTrueList[iCut]->Add(hMCTruePi0DalConversionHighPtR[iCut]);
651 
652  hMCTruePi0DalConversionEta[iCut] = new TH1F("ESD_TruePi0DalConversionMapping_Eta","ESD_TruePi0DalConversionMapping_Eta",nBinsEta,-2.,2.);
653  fTrueList[iCut]->Add(hMCTruePi0DalConversionEta[iCut]);
654 
655  hMCTruePi0DalConversionMidPtEta[iCut] = new TH1F("ESD_TruePi0DalConversionMappingMidPt_Eta","ESD_TruePi0DalConversionMappingMidPt_Eta",nBinsEta,-2.,2.);
656  fTrueList[iCut]->Add(hMCTruePi0DalConversionMidPtEta[iCut]);
657 
658  hMCTruePi0DalConversionHighPtEta[iCut] = new TH1F("ESD_TruePi0DalConversionMappingHighPt_Eta","ESD_TruePi0DalConversionMappingHighPt_Eta",nBinsEta,-2.,2.);
660 
661  hMCTruePi0DalConversionPt[iCut] = new TH1F("ESD_TruePi0DalConversionMapping_Pt","ESD_TruePi0DalConversionMapping_Pt",nBinsPt,0.,20.);
662  fTrueList[iCut]->Add(hMCTruePi0DalConversionPt[iCut]);
663 
664 
665  hMCTrueEtaDalConversionR[iCut] = new TH1F("ESD_TrueEtaDalConversionMapping_R","ESD_TrueEtaDalConversionMapping_R",nBinsR,0.,200.);
666  fTrueList[iCut]->Add(hMCTrueEtaDalConversionR[iCut]);
667 
668  hMCTrueEtaDalConversionMidPtR[iCut] = new TH1F("ESD_TrueEtaDalConversionMappingMidPt_R","ESD_TrueEtaDalConversionMappingMidPt_R",nBinsR,0.,200.);
669  fTrueList[iCut]->Add(hMCTrueEtaDalConversionMidPtR[iCut]);
670 
671  hMCTrueEtaDalConversionHighPtR[iCut] = new TH1F("ESD_TrueEtaDalConversionMappingHighPt_R","ESD_TrueEtaDalConversionMappingHighPt_R",nBinsR,0.,200.);
672  fTrueList[iCut]->Add(hMCTrueEtaDalConversionHighPtR[iCut]);
673 
674  hMCTrueEtaDalConversionEta[iCut] = new TH1F("ESD_TrueEtaDalConversionMapping_Eta","ESD_TrueEtaDalConversionMapping_Eta",nBinsEta,-2.,2.);
675  fTrueList[iCut]->Add(hMCTrueEtaDalConversionEta[iCut]);
676 
677  hMCTrueEtaDalConversionMidPtEta[iCut] = new TH1F("ESD_TrueEtaDalConversionMappingMidPt_Eta","ESD_TrueEtaDalConversionMappingMidPt_Eta",nBinsEta,-2.,2.);
678  fTrueList[iCut]->Add(hMCTrueEtaDalConversionMidPtEta[iCut]);
679 
680 
681  hMCTrueEtaDalConversionHighPtEta[iCut] = new TH1F("ESD_TrueEtaDalConversionMappingHighPt_Eta","ESD_TrueEtaDalConversionMappingHighPt_Eta",nBinsEta,-2.,2.);
683 
684  hMCTrueEtaDalConversionPt[iCut] = new TH1F("ESD_TrueEtaDalConversionMapping_Pt","ESD_TrueEtaDalConversionMapping_Pt",nBinsPt,0.,20.);
685  fTrueList[iCut]->Add(hMCTrueEtaDalConversionPt[iCut]);
686 
687 
688 
689  hMCTrueCombConversionR[iCut] = new TH1F("ESD_TrueCombConversionMapping_R","ESD_TrueCombConversionMapping_R",nBinsR,0.,200.);
690  fTrueList[iCut]->Add(hMCTrueCombConversionR[iCut]);
691 
692  hMCTrueCombConversionMidPtR[iCut] = new TH1F("ESD_TrueCombConversionMappingMidPt_R","ESD_TrueCombConversionMappingMidPt_R",nBinsR,0.,200.);
693  fTrueList[iCut]->Add(hMCTrueCombConversionMidPtR[iCut]);
694 
695  hMCTrueCombConversionHighPtR[iCut] = new TH1F("ESD_TrueCombConversionMappingHighPt_R","ESD_TrueCombConversionMappingHighPt_R",nBinsR,0.,200.);
696  fTrueList[iCut]->Add(hMCTrueCombConversionHighPtR[iCut]);
697 
698  hMCTrueCombConversionEta[iCut] = new TH1F("ESD_TrueCombConversionMapping_Eta","ESD_TrueCombConversionMapping_Eta",nBinsEta,-2.,2.);
699  fTrueList[iCut]->Add(hMCTrueCombConversionEta[iCut]);
700 
701  hMCTrueCombConversionMidPtEta[iCut] = new TH1F("ESD_TrueCombConversionMappingMidPt_Eta","ESD_TrueCombConversionMappingMidPt_Eta",nBinsEta,-2.,2.);
702  fTrueList[iCut]->Add(hMCTrueCombConversionMidPtEta[iCut]);
703 
704  hMCTrueCombConversionHighPtEta[iCut] = new TH1F("ESD_TrueCombConversionMappingHighPt_Eta","ESD_TrueCombConversionMappingMidPt_Eta",nBinsEta,-2.,2.);
705  fTrueList[iCut]->Add(hMCTrueCombConversionHighPtEta[iCut]);
706 
707  hMCTrueCombConversionPt[iCut] = new TH1F("ESD_TrueCombConversionMapping_Pt","ESD_TrueCombConversionMapping_Pt",nBinsPt,0.,20.);
708  fTrueList[iCut]->Add(hMCTrueCombConversionPt[iCut]);
709 
710 
711  }
712  }
713 
714 
715  fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask(fV0ReaderName.Data());
719 
720  if(fV0Reader)
722  if(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms())
723  fOutputList->Add(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms());
724 
725  if(fV0Reader)
727  if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
728  fOutputList->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
729 
730  // if(fV0Reader && fV0Reader->GetProduceV0FindingEfficiency())
731  // if (fV0Reader->GetV0FindingEfficiencyHistograms())
732  // fOutputList->Add(fV0Reader->GetV0FindingEfficiencyHistograms());
733 
734  for(Int_t iCut = 0; iCut<fnCuts;iCut++){
735  if(!((AliConvEventCuts*)fEventCutArray->At(iCut))) continue;
736  if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms()){
737  fCutFolder[iCut]->Add(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms());
738  }
739  if(!((AliConversionPhotonCuts*)fConversionCutArray->At(iCut))) continue;
740  if(((AliConversionPhotonCuts*)fConversionCutArray->At(iCut))->GetCutHistograms()){
741  fCutFolder[iCut]->Add(((AliConversionPhotonCuts*)fConversionCutArray->At(iCut))->GetCutHistograms());
742  }
743  }
744 
745  PostData(1, fOutputList);
746 
747 }
748 
749 //________________________________________________________________________
751 
752  fInputEvent = InputEvent();
753  if (fInputEvent==NULL) return;
754 
755  if(fIsMC>0) fMCEvent = MCEvent();
756  if(fIsMC>0 && fInputEvent->IsA()==AliESDEvent::Class() && fMCEvent){
757  fMCStack = fMCEvent->Stack();
758  }
759 
760  Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
761  if(fInputEvent->IsIncompleteDAQ()==kTRUE) eventQuality = 2; // incomplete event
762  // Event Not Accepted due to MC event missing or because it is incomplere or wrong trigger for V0ReaderV1 => skip broken event/file
763  if(eventQuality == 2 || eventQuality == 3){
764  for(Int_t iCut = 0; iCut<fnCuts; iCut++){
765  hNEvents[iCut]->Fill(eventQuality);
766  }
767  return;
768  }
769 
770  fConversionGammas=fV0Reader->GetReconstructedGammas();// Gammas from default Cut
771 
772  // ------------------- BeginEvent ----------------------------
773 
774  for(Int_t iCut = 0; iCut<fnCuts; iCut++){
775  fiCut = iCut;
776  Int_t eventNotAccepted = ((AliConvEventCuts*)fEventCutArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon,kFALSE);
777  if(eventNotAccepted){
778  // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
779 
780  hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
781 
782  continue;
783  }
784 
785  if(eventQuality != 0){// Event Not Accepted
786  // cout << "event rejected due to: " <<eventQuality << endl;
787 
788  hNEvents[iCut]->Fill(eventQuality);
789 
790  continue;
791  }
792 
793  hNEvents[iCut]->Fill(eventQuality); // Should be 0 here
794 
795 
796  if(fIsMC > 0){
797  // Process MC Particle
798  if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection() != 0){
799  if(fInputEvent->IsA()==AliESDEvent::Class()){
800  ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
801  ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
802  fMCEvent);
803  }
804  }
805  }
806 
807  if(fIsMC>0){
809  }
810 
811 
812  fNESDtracksEta09 = CountTracks09(); // Estimate Event Multiplicity
813  fNESDtracksEta0914 = CountTracks0914(); // Estimate Event Multiplicity
815 
816 
817  hNGoodESDTracks09[iCut]->Fill(fNESDtracksEta09);
818  hNGoodESDTracks14[iCut]->Fill(fNESDtracksEta14);
819  hNGoodESDTracks09_14[iCut]->Fill(fNESDtracksEta0914);
820 
821 
822  if(fInputEvent){
823  if(fInputEvent->GetPrimaryVertexTracks()->GetNContributors()>0) {
824  fNContrVtx = fInputEvent->GetPrimaryVertexTracks()->GetNContributors();
825  } else {
826  fNContrVtx = 0;
827  }
828 
829  }
830  // fPrimVtxZ = fInputEvent->GetPrimaryVertex()->GetZ();
831 
832  ProcessPhotons();
833  fGammaCandidates->Clear(); // delete this cuts good gammas
834  }
835 
836  //cout<<" done with the event"<<endl;
837 
838  PostData(1, fOutputList);
839 }
840 
841 // ///________________________________________________________________________
843  // AliStack *MCStack = fMCEvent->Stack();
844  TParticle* candidate = (TParticle *)fMCStack->Particle(stackPos);
845 
846  if(((AliConversionPhotonCuts*)fConversionCutArray->At(fiCut))->PhotonIsSelectedMC(candidate,fMCStack,kFALSE)){
847  fGammaMCPt = candidate->Pt();
848  fGammaMCTheta = candidate->Theta();
849 
850  hMCAllGammaPt[fiCut]->Fill(candidate->Pt());
851 
852  }
853  Double_t minPt=0.4;
854  Double_t maxPt=1.5;
855 
856  Double_t minPtHigh=2.0;
857  Double_t maxPtHigh=4.0;
858 
859  if(((AliConversionPhotonCuts*)fConversionCutArray->At(fiCut))->PhotonIsSelectedMC(candidate,fMCStack,kTRUE)){
860  fGammaMCConvPt = candidate->Pt();
861  fGammaMCConvTheta = candidate->Theta();
862  TParticle* daughter1 = (TParticle *)fMCStack->Particle(candidate->GetFirstDaughter());
863  // TParticle* daughter2 = (TParticle *)fMCStack->Particle(candidate->GetLastDaughter());
864 
865  // hMCConversionMappingRZ[fiCut]->Fill(daughter1->Vz(),daughter1->R());
866  hMCConversionMappingRPhi[fiCut]->Fill(candidate->Phi(),daughter1->R());
867  hMCConversionEta[fiCut]->Fill(candidate->Eta());
868  hMCConversionPt[fiCut]->Fill(candidate->Pt());
869  hMCConversionR[fiCut]->Fill(daughter1->R());
870  hMCConversionPtvsR[fiCut]->Fill(candidate->Pt(),daughter1->R());
871  if (fGammaMCConvPt>minPt && fGammaMCConvPt<maxPt){
872  hMCConversionMidPtR[fiCut]->Fill(daughter1->R());
873  }else if(fGammaMCConvPt>minPtHigh && fGammaMCConvPt<maxPtHigh){
874  hMCConversionHighPtR[fiCut]->Fill(daughter1->R());
875  }
876  if (candidate->Eta()>0) {
877  hMCConversionEtaPR[fiCut]->Fill(daughter1->R());
878  }else {
879  hMCConversionEtaNR[fiCut]->Fill(daughter1->R());
880  }
881 
882 
883  } // Converted MC Gamma
884 }
885 //
886 // ///________________________________________________________________________
888  // Loop over all primary MC particle
889  // AliStack *ffMCStack = fMCEvent->Stack();
890  for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
891  TParticle* particle = (TParticle *)fMCStack->Particle(i);
892  if (!particle) continue;
893 
894 
895  if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
896  Int_t isPosFromMBHeader
897  = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
898  Int_t isNegFromMBHeader
899  = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
900  if( (isNegFromMBHeader < 1) || (isPosFromMBHeader < 1)) continue;
901  }
902 
903 
904  if (particle->GetPdgCode() == 111 && particle->GetFirstDaughter() >= fMCStack->GetNprimary()){
905  // cout << "Undecayed pi0 found with mother: " << particle->GetMother(0) << endl;
906  for (Int_t j = 0; j < 2 ; j++){
907  FillMCTree(particle->GetDaughter(j));
908  }
909  } else {
910  FillMCTree(i);
911  }
912 
913  }
914 }
915 
918 
919  // Fill Histograms for QA and MC
920  TList *GammaCandidatesStepTwo = new TList();
921 
922  //not needed here already calculated
923  //fNESDtracksEta09 = CountTracks09();
924  for(Int_t firstGammaIndex=0;firstGammaIndex<fConversionGammas->GetEntriesFast();firstGammaIndex++){
925  AliAODConversionPhoton *gamma= (AliAODConversionPhoton*)fConversionGammas->At(firstGammaIndex);
926 
927  if (gamma == NULL) continue;
928 
929  if(!((AliConversionPhotonCuts*)fConversionCutArray->At(fiCut))->PhotonIsSelected(gamma,fInputEvent))continue;
930 
931  if( ! ((AliConversionPhotonCuts*)fConversionCutArray->At(fiCut))->UseToCloseV0sCut()){
932  fGammaCandidates->Add(gamma); // if no second loop is required add to events good gammas
933  }else if(((AliConversionPhotonCuts*)fConversionCutArray->At(fiCut))->UseToCloseV0sCut()) { // shared electron is disabled, step one not needed -> step two
934  GammaCandidatesStepTwo->Add(gamma);
935  }
936  }
937 
938  if(((AliConversionPhotonCuts*)fConversionCutArray->At(fiCut))->UseToCloseV0sCut()){
939  for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
940  AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
941  if(!PhotonCandidate) continue;
942  if(!((AliConversionPhotonCuts*)fConversionCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
943  fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
944  }
945  }
946 
947 
948 
949 
950  for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
951  AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
952  if (gamma==NULL) continue;
953 
954  fGammaPt = gamma->GetPhotonPt();
955  fGammaTheta = gamma->GetPhotonTheta();
956  fGammaChi2NDF = gamma->GetChi2perNDF();
957 
958 
959  AliVTrack * negTrack = ((AliConversionPhotonCuts*)fConversionCutArray->At(fiCut))->GetTrack(fInputEvent, gamma->GetTrackLabelNegative());
960  AliVTrack * posTrack = ((AliConversionPhotonCuts*)fConversionCutArray->At(fiCut))->GetTrack(fInputEvent, gamma->GetTrackLabelPositive());
961 
962 
963  Double_t asym=0.;
964  if(gamma->GetPhotonP()!=0){
965  asym=negTrack->P()/gamma->GetPhotonP();
966  }
967  Double_t mcPhotonPt = 0.;
968  Double_t mcPhotonR = 0.;
969 
970  fKind = 9;
971 
972  if(fIsMC>0){
973  // cout << "generating MC stack"<< endl;
974  AliStack *fMCStack = fMCEvent->Stack();
975  if (!fMCStack) continue;
976 
977  const AliVVertex* primVtxMC = fMCEvent->GetPrimaryVertex();
978  Double_t mcProdVtxX = primVtxMC->GetX();
979  Double_t mcProdVtxY = primVtxMC->GetY();
980  Double_t mcProdVtxZ = primVtxMC->GetZ();
981 
982  TParticle *posDaughter = gamma->GetPositiveMCDaughter(fMCStack);
983  TParticle *negDaughter = gamma->GetNegativeMCDaughter(fMCStack);
984  // cout << "generate Daughters: "<<posDaughter << "\t" << negDaughter << endl;
985 
986  if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
987  Int_t isPosFromMBHeader
988  = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma->GetMCLabelPositive(), fMCStack, fInputEvent);
989  Int_t isNegFromMBHeader
990  = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma->GetMCLabelNegative(), fMCStack, fInputEvent);
991  if( (isNegFromMBHeader < 1) || (isPosFromMBHeader < 1)) continue;
992  }
993 
994  if(posDaughter == NULL || negDaughter == NULL){
995  fKind = 9; // garbage
996  // cout << "one of the daughters not available" << endl;
997  } else if(posDaughter->GetMother(0) != negDaughter->GetMother(0) || (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1)){
998  // Not Same Mother == Combinatorial Bck
999  fKind = 1;
1000  // cout << "not the same mother" << endl;
1001  Int_t pdgCodePos;
1002  if (posDaughter->GetPdgCode()) pdgCodePos = posDaughter->GetPdgCode(); else continue;
1003  Int_t pdgCodeNeg;
1004  if (negDaughter->GetPdgCode()) pdgCodeNeg = negDaughter->GetPdgCode(); else continue;
1005  // cout << "PDG codes daughters: " << pdgCodePos << "\t" << pdgCodeNeg << endl;
1006  if(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==11)
1007  fKind = 10; //Electron Combinatorial
1008  if(TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==11 && (posDaughter->GetMother(0) == negDaughter->GetMother(0) && posDaughter->GetMother(0) ==-1))
1009  fKind = 15; //direct Electron Combinatorial
1010 
1011  if(TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==211)
1012  fKind = 11; //Pion Combinatorial
1013  if((TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==2212) ||
1014  (TMath::Abs(pdgCodePos)==2212 && TMath::Abs(pdgCodeNeg)==211))
1015  fKind = 12; //Pion, Proton Combinatorics
1016  if((TMath::Abs(pdgCodePos)==211 && TMath::Abs(pdgCodeNeg)==11) ||
1017  (TMath::Abs(pdgCodePos)==11 && TMath::Abs(pdgCodeNeg)==211))
1018  fKind = 13; //Pion, Electron Combinatorics
1019  if (TMath::Abs(pdgCodePos)==321 || TMath::Abs(pdgCodeNeg)==321)
1020  fKind = 14; //Kaon combinatorics
1021 
1022  } else {
1023  // cout << "same mother" << endl;
1024  Int_t pdgCodePos;
1025  if (posDaughter->GetPdgCode()) pdgCodePos = posDaughter->GetPdgCode(); else continue;
1026  Int_t pdgCodeNeg;
1027  if (negDaughter->GetPdgCode()) pdgCodeNeg = negDaughter->GetPdgCode(); else continue;
1028  // cout << "PDG codes daughters: " << pdgCodePos << "\t" << pdgCodeNeg << endl;
1029  Int_t pdgCode;
1030  if (gamma->GetMCParticle(fMCStack)->GetPdgCode()) pdgCode = gamma->GetMCParticle(fMCStack)->GetPdgCode(); else continue;
1031  // cout << "PDG code: " << pdgCode << endl;
1032  if(TMath::Abs(pdgCodePos)!=11 || TMath::Abs(pdgCodeNeg)!=11)
1033  fKind = 2; // combinatorics from hadronic decays
1034  else if ( !(pdgCodeNeg==pdgCodePos)){
1035  TParticle *truePhotonCanditate = gamma->GetMCParticle(fMCStack);
1036  Int_t motherLabelPhoton = truePhotonCanditate->GetMother(0);
1037  Bool_t gammaIsPrimary = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsConversionPrimaryESD( fMCStack, posDaughter->GetMother(0), mcProdVtxX, mcProdVtxY, mcProdVtxZ);
1038  if(pdgCode == 111)
1039  fKind = 3; // pi0 Dalitz
1040  else if (pdgCode == 221)
1041  fKind = 4; // eta Dalitz
1042  else if (!(negDaughter->GetUniqueID() != 5 || posDaughter->GetUniqueID() !=5)){
1043  if(pdgCode == 22 && gammaIsPrimary){
1044  fKind = 0; // primary photons
1045  mcPhotonR= negDaughter->R();
1046  mcPhotonPt=gamma->GetMCParticle(fMCStack)->Pt();
1047  } else if (pdgCode == 22){
1048  fKind = 5; //secondary photons
1049  }
1050  } else fKind = 9; //garbage
1051  } else fKind = 9; //garbage
1052  }
1053  }
1054 
1055 
1056 
1057 
1058  Double_t minPt=0.4;
1059  Double_t maxPt=1.5;
1060  Double_t minPtHigh=2.0;
1061  Double_t maxPtHigh=4.0;
1062 
1063 
1066  hESDConversionEta[fiCut]->Fill(gamma->GetPhotonEta());
1067  hESDConversionPt[fiCut]->Fill(gamma->GetPhotonPt());
1068  if(gamma->GetConversionRadius()>5){
1069  hESDConversionPt5cm[fiCut]->Fill(gamma->GetPhotonPt());
1070  }
1071  hESDConversionR[fiCut]->Fill(gamma->GetConversionRadius());
1072  hESDConversionPtvsR[fiCut]->Fill(gamma->GetPhotonPt(),gamma->GetConversionRadius());
1073  hESDConversionAsymP[fiCut]->Fill(gamma->GetPhotonP(),asym);
1074 
1075  if(fInputEvent->IsA()==AliESDEvent::Class()){
1076  AliESDEvent *esdEvent = dynamic_cast<AliESDEvent*>(fInputEvent);
1077  if(esdEvent){
1078  AliESDv0 *v0 = esdEvent->GetV0(gamma->GetV0Index());
1079  hESDConversionDCA[fiCut]->Fill(v0->GetDcaV0Daughters());
1080  if(gamma->GetPhotonPt()>minPt && gamma->GetPhotonPt()<maxPt){
1081  hESDConversionMidPtDCA[fiCut]->Fill(v0->GetDcaV0Daughters());
1082  }else if(gamma->GetPhotonPt()>minPtHigh && gamma->GetPhotonPt()<maxPtHigh){
1083  hESDConversionHighPtDCA[fiCut]->Fill(v0->GetDcaV0Daughters());
1084  }
1085  }
1086  }
1087 
1088 
1089  hESDConversionPsiPair[fiCut]->Fill(gamma->GetPsiPair());
1090  hESDConversionChi2[fiCut]->Fill(gamma->GetChi2perNDF());
1091  hESDConversionMass[fiCut]->Fill(gamma->GetInvMassPair());
1092 
1093 
1094  if(gamma->GetPhotonPt()>minPt && gamma->GetPhotonPt()<maxPt){
1095  hESDConversionMidPtEta[fiCut]->Fill(gamma->GetPhotonEta());
1097  }else if(gamma->GetPhotonPt()>minPtHigh && gamma->GetPhotonPt()<maxPtHigh){
1098  hESDConversionHighPtEta[fiCut]->Fill(gamma->GetPhotonEta());
1100  }
1101 
1102  if(gamma->GetPhotonEta() >0){
1104  }else{
1106  }
1107 
1108 
1109  Double_t convR = gamma->GetConversionRadius();
1112 
1113  if(fIsMC>0){
1114  if(fKind==0 || fKind==5){
1117  hMCTrueConversionEta[fiCut]->Fill(gamma->GetPhotonEta());
1118  hMCTrueConversionPt[fiCut]->Fill(gamma->GetPhotonPt());
1119  if(gamma->GetConversionRadius()>5){
1120  hMCTrueConversionPt5cm[fiCut]->Fill(gamma->GetPhotonPt());
1121  }
1122  hMCTrueConversionR[fiCut]->Fill(gamma->GetConversionRadius());
1123  hMCTrueConversionPtvsR[fiCut]->Fill(mcPhotonPt,mcPhotonR);
1124  hMCTrueConversionAsymP[fiCut]->Fill(gamma->GetPhotonP(),asym);
1125  hMCTrueConversionPsiPair[fiCut]->Fill(gamma->GetPsiPair());
1126  hMCTrueConversionChi2[fiCut]->Fill(gamma->GetChi2perNDF());
1127  hMCTrueConversionMass[fiCut]->Fill(gamma->GetInvMassPair());
1128  if(fInputEvent->IsA()==AliESDEvent::Class()){
1129  AliESDEvent *esdEvent = dynamic_cast<AliESDEvent*>(fInputEvent);
1130  if(esdEvent){
1131  AliESDv0 *v0 = esdEvent->GetV0(gamma->GetV0Index());
1132  hMCTrueConversionDCA[fiCut]->Fill(v0->GetDcaV0Daughters());
1133  if(gamma->GetPhotonPt()>minPt && gamma->GetPhotonPt()<maxPt){
1134  hMCTrueConversionMidPtDCA[fiCut]->Fill(v0->GetDcaV0Daughters());
1135  }else if(gamma->GetPhotonPt()>minPtHigh && gamma->GetPhotonPt()<maxPtHigh){
1136  hMCTrueConversionHighPtDCA[fiCut]->Fill(v0->GetDcaV0Daughters());
1137  }
1138 
1139  }
1140  }
1141 
1142 
1143  if(gamma->GetPhotonPt()>minPt && gamma->GetPhotonPt()<maxPt){
1145  hMCTrueConversionMidPtEta[fiCut]->Fill(gamma->GetPhotonEta());
1146  }else if(gamma->GetPhotonPt()>minPtHigh && gamma->GetPhotonPt()<maxPtHigh){
1148  hMCTrueConversionHighPtEta[fiCut]->Fill(gamma->GetPhotonEta());
1149  }
1150 
1151  if(gamma->GetPhotonEta() >0){
1153  }else{
1155  }
1156  }
1157 
1158  if(fKind==3){
1159  hMCTruePi0DalConversionEta[fiCut]->Fill(gamma->GetPhotonEta());
1160  hMCTruePi0DalConversionPt[fiCut]->Fill(gamma->GetPhotonPt());
1162  if(gamma->GetPhotonPt()>minPt && gamma->GetPhotonPt()<maxPt){
1165  }else if(gamma->GetPhotonPt()>minPtHigh && gamma->GetPhotonPt()<maxPtHigh){
1168  }
1169  }
1170  if(fKind==4){
1171  hMCTrueEtaDalConversionEta[fiCut]->Fill(gamma->GetPhotonEta());
1172  hMCTrueEtaDalConversionPt[fiCut]->Fill(gamma->GetPhotonPt());
1174  if(gamma->GetPhotonPt()>minPt && gamma->GetPhotonPt()<maxPt){
1177  }else if (gamma->GetPhotonPt()>minPtHigh && gamma->GetPhotonPt()<maxPtHigh){
1180  }
1181  }
1182  if(fKind==1 || fKind==10 || fKind==11 || fKind==12 || fKind==13 || fKind==14 || fKind==15){
1183  hMCTrueCombConversionEta[fiCut]->Fill(gamma->GetPhotonEta());
1184  hMCTrueCombConversionPt[fiCut]->Fill(gamma->GetPhotonPt());
1186  if(gamma->GetPhotonPt()>minPt && gamma->GetPhotonPt()<maxPt){
1189  }else if(gamma->GetPhotonPt()>minPtHigh && gamma->GetPhotonPt()<maxPtHigh){
1192  }
1193  }
1194  }
1195  }
1196 
1197  delete GammaCandidatesStepTwo;
1198  GammaCandidatesStepTwo = 0x0;
1199 
1200 
1201 }
1202 
1203 //________________________________________________________________________
1205  Int_t fNumberOfESDTracks = 0;
1206  if(fInputEvent->IsA()==AliESDEvent::Class()){
1207  // Using standard function for setting Cuts
1208 
1209  AliStack *fMCStack = NULL;
1210  if (fMCEvent){
1211  fMCStack= fMCEvent->Stack();
1212  if (!fMCStack) return 0;
1213  }
1214 
1215  Bool_t selectPrimaries=kTRUE;
1216  AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
1217  EsdTrackCuts->SetMaxDCAToVertexZ(2);
1218  EsdTrackCuts->SetEtaRange(-0.9, 0.9);
1219  EsdTrackCuts->SetPtRange(0.15);
1220 
1221  for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
1222  AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
1223  if(!curTrack) continue;
1224  if(EsdTrackCuts->AcceptTrack(curTrack) ){
1225  if (fMCEvent){
1226  if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1227  Int_t isFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(TMath::Abs(curTrack->GetLabel()), fMCStack, fInputEvent);
1228  if( (isFromMBHeader < 1) ) continue;
1229  }
1230  }
1231  fNumberOfESDTracks++;
1232  }
1233  }
1234  delete EsdTrackCuts;
1235  EsdTrackCuts=0x0;
1236  }
1237  return fNumberOfESDTracks;
1238 }
1239 
1240 //________________________________________________________________________
1242  Int_t fNumberOfESDTracks = 0;
1243  if(fInputEvent->IsA()==AliESDEvent::Class()){
1244  // Using standard function for setting Cuts
1245 
1246  AliStack *fMCStack = NULL;
1247  if (fMCEvent){
1248  fMCStack= fMCEvent->Stack();
1249  if (!fMCStack) return 0;
1250  }
1251 
1252  AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
1253  EsdTrackCuts->SetMaxDCAToVertexZ(5);
1254  EsdTrackCuts->SetEtaRange(0.9, 1.4);
1255  EsdTrackCuts->SetPtRange(0.15);
1256 
1257  for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
1258  AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
1259  if(!curTrack) continue;
1260  if(EsdTrackCuts->AcceptTrack(curTrack) ){
1261  if (fMCEvent){
1262  if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1263  Int_t isFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(TMath::Abs(curTrack->GetLabel()), fMCStack, fInputEvent);
1264  if( (isFromMBHeader < 1) ) continue;
1265  }
1266  }
1267  fNumberOfESDTracks++;
1268  }
1269  }
1270  EsdTrackCuts->SetEtaRange(-1.4, -0.9);
1271  for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
1272  AliESDtrack* curTrack =(AliESDtrack*) fInputEvent->GetTrack(iTracks);
1273  if(!curTrack) continue;
1274  if(EsdTrackCuts->AcceptTrack(curTrack) ){
1275  if (fMCEvent){
1276  if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1277  Int_t isFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(TMath::Abs(curTrack->GetLabel()), fMCStack, fInputEvent);
1278  if( (isFromMBHeader < 1) ) continue;
1279  }
1280  }
1281  fNumberOfESDTracks++;
1282  }
1283  }
1284  delete EsdTrackCuts;
1285  EsdTrackCuts=0x0;
1286  }
1287 
1288  return fNumberOfESDTracks;
1289 }
1290 
1291 //________________________________________________________________________
1293 {
1294 // if (fStreamMaterial){
1295 // fStreamMaterial->GetFile()->Write();
1296 // }
1297 }
TParticle * GetMCParticle(AliStack *fMCStack)
virtual Double_t GetPhotonPhi() const
double Double_t
Definition: External.C:58
Definition: External.C:260
Definition: External.C:236
virtual Double_t GetPhotonTheta() const
virtual void UserExec(Option_t *option)
Bool_t GetProduceV0FindingEfficiency()
virtual Double_t GetPhotonP() const
int Int_t
Definition: External.C:63
AliConversionPhotonCuts * GetConversionCuts()
Definition: AliV0ReaderV1.h:80
Class handling all kinds of selection cuts for Gamma Conversion analysis.
TParticle * GetPositiveMCDaughter(AliStack *fMCStack)
virtual Double_t GetPhotonEta() const
TClonesArray * GetReconstructedGammas() const
Definition: AliV0ReaderV1.h:76
virtual Double_t GetPhotonPt() const
Class handling all kinds of selection cuts for Gamma Conversion analysis.
AliConvEventCuts * GetEventCuts()
Definition: AliV0ReaderV1.h:81
TParticle * GetNegativeMCDaughter(AliStack *fMCStack)
const char Option_t
Definition: External.C:48
bool Bool_t
Definition: External.C:53
Double_t GetConversionRadius() const
ClassImp(AliAnalysisTaskMaterialHistos) AliAnalysisTaskMaterialHistos
TList * GetV0FindingEfficiencyHistograms()