AliPhysics  2b88e80 (2b88e80)
AliAnalysisTaskGammaConvDalitzV1.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: Pedro Gonzalez, Pedro Ladron de Guevara, Ernesto Lopez Torres, *
5  * Eulogio Serradilla, Ana Marin, Friederike Bock *
6  * Version 2 *
7  * *
8  * Permission to use, copy, modify and distribute this software and its *
9  * documentation strictly for non-commercial purposes is hereby granted *
10  * without fee, provided that the above copyright notice appears in all *
11  * copies and that both the copyright notice and this permission notice *
12  * appear in the supporting documentation. The authors make no claims *
13  * about the suitability of this software for any purpose. It is *
14  * provided "as is" without express or implied warranty. *
15  **************************************************************************/
16 
17 // Analysis task for pi0->e+e-gamma (Dalitz decay)
18 // Analysis task for chic->JPsi+gamma
19 
20 #include <vector>
21 
22 #include "TParticle.h"
23 #include "TPDGCode.h"
24 #include "TMCProcess.h"
25 #include "TDatabasePDG.h"
26 #include "TList.h"
27 #include "TChain.h"
28 #include "TDirectory.h"
29 #include "TTree.h"
30 #include "TH1.h"
31 #include "TH1F.h"
32 #include "THnSparse.h"
33 #include "TH2F.h"
34 #include "AliAnalysisManager.h"
35 #include "AliESDInputHandler.h"
36 #include "AliESDtrack.h"
37 #include "AliMCEvent.h"
38 #include "AliMCEventHandler.h"
39 #include "AliPID.h"
40 #include "AliLog.h"
41 #include "AliESDtrackCuts.h"
42 #include "AliESDpidCuts.h"
43 #include "AliMCEvent.h"
44 #include "AliESDv0.h"
45 #include "AliESDEvent.h"
46 #include "AliESDpid.h"
47 #include "AliKFParticle.h"
48 #include "AliMCEventHandler.h"
49 #include "AliKFVertex.h"
50 #include "AliTriggerAnalysis.h"
51 #include "AliCentrality.h"
52 #include "AliMultiplicity.h"
53 #include "AliAnalysisTaskGammaConvDalitzV1.h"
54 #include "AliEventplane.h"
55 #include <vector>
56 
57 
58 ClassImp( AliAnalysisTaskGammaConvDalitzV1 )
59 
60 //-----------------------------------------------------------------------------------------------
61 AliAnalysisTaskGammaConvDalitzV1::AliAnalysisTaskGammaConvDalitzV1():
62  fV0Reader(NULL),
63  fV0ReaderName("V0ReaderV1"),
64  fElecSelector(NULL),
65  fBGHandler(NULL),
66  fESDEvent(NULL),
67  fMCEvent(NULL),
68  fCutFolder(NULL),
69  fESDList(NULL),
70  fBackList(NULL),
71  fMotherList(NULL),
72  fTrueList(NULL),
73  fMCList(NULL),
74  fQAFolder(NULL),
75  fOutputContainer(0),
76  fReaderGammas(NULL),
77  fSelectorElectronIndex(0),
78  fSelectorPositronIndex(0),
79  fGoodGammas(NULL),
80  fGoodVirtualGammas(NULL),
81  fGoodElectrons(NULL),
82  fGoodPositrons(NULL),
83  fCutEventArray(NULL),
84  fCutGammaArray(NULL),
85  fCutElectronArray(NULL),
86  fCutMesonArray(NULL),
87  fEventCuts(NULL),
88  fConversionCuts(NULL),
89  hESDConvGammaPt(NULL),
90  hESDConvGammaEta(NULL),
91  //hESDConvGammaZR(NULL),
92  sESDConvGammaZR(NULL),
93  sESDConvGammaXY(NULL),
94  hESDDalitzElectronPt(NULL),
95  hESDDalitzPositronPt(NULL),
96  hESDDalitzElectronPhi(NULL),
97  hESDDalitzPositronPhi(NULL),
98  hESDDalitzElectronAfterPt(NULL),
99  hESDDalitzPositronAfterPt(NULL),
100  hESDDalitzElectronAfterEta(NULL),
101  hESDDalitzElectronAfterEtaPCut(NULL),
102  hESDDalitzPositronAfterEta(NULL),
103  hESDDalitzPositronAfterEtaPCut(NULL),
104  hESDDalitzElectronAfterPhi(NULL),
105  hESDDalitzPositronAfterPhi(NULL),
106  hESDDalitzElectronAfterNClsITS(NULL),
107  hESDDalitzElectronAfterNClsITSPCut(NULL),
108  hESDDalitzPositronAfterNClsITS(NULL),
109  hESDDalitzPositronAfterNClsITSPCut(NULL),
110  hESDDalitzElectronAfterNFindClsTPC(NULL),
111  hESDDalitzElectronAfterNFindClsTPCPCut(NULL),
112  hESDDalitzPositronAfterNFindClsTPC(NULL),
113  hESDDalitzPositronAfterNFindClsTPCPCut(NULL),
114  hESDDalitzElectronAfterNClsTPC(NULL),
115  hESDDalitzElectronAfterNClsTPCPCut(NULL),
116  hESDDalitzPositronAfterNClsTPC(NULL),
117  hESDDalitzPositronAfterNClsTPCPCut(NULL),
118  hESDDalitzElectronAfterNCrossedRowsTPC(NULL),
119  hESDDalitzElectronAfterNCrossedRowsTPCPCut(NULL),
120  hESDDalitzPositronAfterNCrossedRowsTPC(NULL),
121  hESDDalitzPositronAfterNCrossedRowsTPCPCut(NULL),
122  hESDDalitzPosEleAfterDCAxy(NULL),
123  hESDDalitzPosEleAfterDCAz(NULL),
124  hESDDalitzElectronAfterTPCdEdxVsP(NULL),
125  hESDDalitzPositronAfterTPCdEdxVsP(NULL),
126  hESDDalitzElectronAfterTPCdEdxSignalVsP(NULL),
127  hESDDalitzPositronAfterTPCdEdxSignalVsP(NULL),
128  hESDDalitzElectronAfterTPCdEdxVsEta(NULL),
129  hESDDalitzPositronAfterTPCdEdxVsEta(NULL),
130  hESDDalitzElectronAfterTPCdEdxVsPhi(NULL),
131  hESDDalitzPositronAfterTPCdEdxVsPhi(NULL),
132  hESDEposEnegPsiPairDPhi(NULL),
133  hESDEposEnegPsiPairEta(NULL),
134  hESDEposEnegDPhiEta(NULL),
135  hESDEposEnegInvMassPt(NULL),
136  hESDTruePi0EposEnegInvMassPi0Pt(NULL),
137  hESDEposEnegLikeSignBackInvMassPt(NULL),
138  hESDMotherInvMassPt(NULL),
139  hESDPi0MotherInvMassPt(NULL),
140  hESDPi0MotherDiffInvMassPt(NULL),
141  hESDPi0MotherDiffLimInvMassPt(NULL),
142  hESDEposEnegInvMassPi0MotherPt(NULL),
143  hESDMotherInvMassOpeningAngleGammaElectron(NULL),
144  sESDMotherInvMassPtZM(NULL),
145  hESDMotherBackInvMassPt(NULL),
146  sESDMotherBackInvMassPtZM(NULL),
147  hESDMotherPi0PtY(NULL),
148  hESDMotherPi0PtAlpha(NULL),
149  hESDMotherPi0PtOpenAngle(NULL),
150  sESDMotherDalitzPlot(NULL),
151  hMCAllGammaPt(NULL),
152  hMCAllGammaPi0Pt(NULL),
153  hMCConvGammaPt(NULL),
154  hMCConvGammaPtR(NULL),
155  hMCConvGammaRSPt(NULL),
156  hMCConvGammaPi0Pt(NULL),
157  hMCAllPositronsPt(NULL),
158  hMCDecayPositronPi0Pt(NULL),
159  hMCAllElectronsPt(NULL),
160  hMCDecayElectronPi0Pt(NULL),
161  hMCConvGammaEta(NULL),
162  hMCConvGammaR(NULL),
163  hMCAllPositronsEta(NULL),
164  hMCAllElectronsEta(NULL),
165  hMCPi0DalitzGammaPt(NULL),
166  hMCPi0DalitzElectronPt(NULL),
167  hMCPi0DalitzPositronPt(NULL),
168  hMCPi0Pt(NULL),
169  hMCPi0WOWeightPt(NULL),
170  hMCPi0GGPt(NULL),
171  hMCEtaPt(NULL),
172  hMCEtaGGPt(NULL),
173  hMCPi0InAccPt(NULL),
174  hMCPi0WOWeightInAccPt(NULL),
175  hMCPi0InAccOpeningAngleGammaElectron(NULL),
176  sMCPi0DalitzPlot(NULL),
177  hMCEtaInAccPt(NULL),
178  hMCChiCPt(NULL),
179  hMCChiCInAccPt(NULL),
180  hMCPi0EposEnegInvMassPt(NULL),
181  hMCEtaEposEnegInvMassPt(NULL),
182  hESDEposEnegTruePi0DalitzInvMassPt(NULL),
183  hESDEposEnegTruePrimPi0DalitzInvMass(NULL),
184  hESDEposEnegTruePi0DalitzPsiPairDPhi(NULL),
185  hESDEposEnegTruePi0DalitzPsiPairMC(NULL),
186  hESDEposEnegTruePi0DalitzPsiPairEta(NULL),
187  hESDEposEnegTruePi0DalitzDPhiEta(NULL),
188  hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
189  hESDEposEnegTruePrimEtaDalitzInvMass(NULL),
190  hESDEposEnegTrueEtaDalitzPsiPairDPhi(NULL),
191  hESDEposEnegTruePhotonInvMassPt(NULL),
192  hESDEposEnegTrueInvMassPt(NULL),
193  hESDEposEnegTrueMotherInvMassPt(NULL),
194  hESDEposEnegTruePhotonPsiPairDPhi(NULL),
195  hESDEposEnegTruePhotonPsiPairDPhiPtCut(NULL),
196  hESDEposEnegTrueJPsiInvMassPt(NULL),
197  hESDTrueMotherChiCInvMassPt(NULL),
198  hESDTrueMotherChiCDiffInvMassPt(NULL),
199  hESDTrueMotherInvMassPt(NULL),
200  hESDTrueMotherW0WeightsInvMassPt(NULL),
201  hESDTrueMotherDalitzInvMassPt(NULL),
202  hESDTrueMotherPi0GGInvMassPt(NULL),
203  hESDTrueMotherPi0GGW0WeightsInvMassPt(NULL),
204  hESDTruePi0PtY(NULL),
205  hESDTruePi0PtAlpha(NULL),
206  hESDTruePi0PtOpenAngle(NULL),
207  sESDTruePi0DalitzPlot(NULL),
208  hESDTruePrimaryMotherPi0GGInvMassPt(NULL),
209  hESDTrueSecondaryMotherPi0GGInvMassPt(NULL),
210  hESDTruePrimaryMotherInvMassMCPt(NULL),
211  hESDTruePrimaryMotherInvMassPt(NULL),
212  hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
213  hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
214  hESDTrueSecondaryMotherInvMassPt(NULL),
215  hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
216  hESDTrueBckGGInvMassPt(NULL),
217  hESDTrueBckContInvMassPt(NULL),
218  hESDTrueMotherGGInvMassPt(NULL),
219  hESDTrueConvGammaPt(NULL),
220  hESDTrueConvGammaPtMC(NULL),
221  hESDTrueConvGammaR(NULL),
222  hESDTrueConvGammaRMC(NULL),
223  hESDTruePositronPt(NULL),
224  hESDTrueElectronPt(NULL),
225  hESDTrueSecConvGammaPt(NULL),
226  hESDTrueSecPositronPt(NULL),
227  hESDTrueSecElectronPt(NULL),
228  hESDTruePi0DalitzConvGammaPt(NULL),
229  hESDTruePi0DalitzConvGammaR(NULL),
230  hESDTruePi0DalitzPositronPt(NULL),
231  hESDTruePi0DalitzPositronPtMB(NULL),
232  hESDTruePi0DalitzElectronPt(NULL),
233  hESDTruePi0DalitzElectronPtMB(NULL),
234  hESDTruePi0DalitzSecConvGammaPt(NULL),
235  hESDTruePi0DalitzSecPositronPt(NULL),
236  hESDTruePi0DalitzSecElectronPt(NULL),
237  hNEvents(NULL),
238  hNGoodESDTracks(NULL),
239  hNGoodESDTracksVsNGoodGammas(NULL),
240  hNGoodESDTracksVsNGoodVGammas(NULL),
241  fHistoSPDClusterTrackletBackground(NULL),
242  hNV0Tracks(NULL),
243  hEtaShift(NULL),
244  fHistoDoubleCountTruePi0InvMassPt(NULL),
245  fHistoDoubleCountTrueEtaInvMassPt(NULL),
246  fHistoDoubleCountTrueConvGammaRPt(NULL),
247  fVectorDoubleCountTruePi0s(0),
248  fVectorDoubleCountTrueEtas(0),
249  fVectorDoubleCountTrueConvGammas(0),
250  fRandom(0),
251  fEventPlaneAngle(-100),
252  fUnsmearedPx(NULL),
253  fUnsmearedPy(NULL),
254  fUnsmearedPz(NULL),
255  fUnsmearedE(NULL),
256  fUnsmearedVPx(NULL),
257  fUnsmearedVPy(NULL),
258  fUnsmearedVPz(NULL),
259  fUnsmearedVE(NULL),
260  fnCuts(0),
261  fiCut(0),
262  fNumberOfESDTracks(0),
263  fNumberOfESDTrackskBoth(0),
264  fNVirtualGammas(0),
265  fMoveParticleAccordingToVertex(kFALSE),
266  fIsHeavyIon(0),
267  fDoMesonAnalysis(kTRUE),
268  fDoChicAnalysis(kFALSE),
269  fDoMesonQA(0),
270  fSetProductionVertextoVGamma(kTRUE),
271  fIsFromMBHeader(kTRUE),
272  fIsMC(kFALSE),
273  fDoTHnSparse(kTRUE),
274  fDoHistoDalitzMassLog(kFALSE),
275  fDoMaterialBudgetWeightingOfGammasForTrueMesons(kFALSE)
276 {
277 
278 }
279 
280 //-----------------------------------------------------------------------------------------------
281 AliAnalysisTaskGammaConvDalitzV1::AliAnalysisTaskGammaConvDalitzV1( const char* name ):
282  AliAnalysisTaskSE(name),
283  fV0Reader(NULL),
284  fV0ReaderName("V0ReaderV1"),
285  fElecSelector(NULL),
286  fBGHandler(NULL),
287  fESDEvent(NULL),
288  fMCEvent(NULL),
289  fCutFolder(NULL),
290  fESDList(NULL),
291  fBackList(NULL),
292  fMotherList(NULL),
293  fTrueList(NULL),
294  fMCList(NULL),
295  fQAFolder(NULL),
296  fOutputContainer(0),
297  fReaderGammas(NULL),
298  fSelectorElectronIndex(0),
299  fSelectorPositronIndex(0),
300  fGoodGammas(NULL),
301  fGoodVirtualGammas(NULL),
302  fGoodElectrons(NULL),
303  fGoodPositrons(NULL),
304  fCutEventArray(NULL),
305  fCutGammaArray(NULL),
306  fCutElectronArray(NULL),
307  fCutMesonArray(NULL),
308  fEventCuts(NULL),
309  fConversionCuts(NULL),
310  hESDConvGammaPt(NULL),
311  hESDConvGammaEta(NULL),
312  //hESDConvGammaZR(NULL),
313  sESDConvGammaZR(NULL),
314  sESDConvGammaXY(NULL),
315  hESDDalitzElectronPt(NULL),
316  hESDDalitzPositronPt(NULL),
317  hESDDalitzElectronPhi(NULL),
318  hESDDalitzPositronPhi(NULL),
319  hESDDalitzElectronAfterPt(NULL),
320  hESDDalitzPositronAfterPt(NULL),
321  hESDDalitzElectronAfterEta(NULL),
322  hESDDalitzElectronAfterEtaPCut(NULL),
323  hESDDalitzPositronAfterEta(NULL),
324  hESDDalitzPositronAfterEtaPCut(NULL),
325  hESDDalitzElectronAfterPhi(NULL),
326  hESDDalitzPositronAfterPhi(NULL),
327  hESDDalitzElectronAfterNClsITS(NULL),
328  hESDDalitzElectronAfterNClsITSPCut(NULL),
329  hESDDalitzPositronAfterNClsITS(NULL),
330  hESDDalitzPositronAfterNClsITSPCut(NULL),
331  hESDDalitzElectronAfterNFindClsTPC(NULL),
332  hESDDalitzElectronAfterNFindClsTPCPCut(NULL),
333  hESDDalitzPositronAfterNFindClsTPC(NULL),
334  hESDDalitzPositronAfterNFindClsTPCPCut(NULL),
335  hESDDalitzElectronAfterNClsTPC(NULL),
336  hESDDalitzElectronAfterNClsTPCPCut(NULL),
337  hESDDalitzPositronAfterNClsTPC(NULL),
338  hESDDalitzPositronAfterNClsTPCPCut(NULL),
339  hESDDalitzElectronAfterNCrossedRowsTPC(NULL),
340  hESDDalitzElectronAfterNCrossedRowsTPCPCut(NULL),
341  hESDDalitzPositronAfterNCrossedRowsTPC(NULL),
342  hESDDalitzPositronAfterNCrossedRowsTPCPCut(NULL),
343  hESDDalitzPosEleAfterDCAxy(NULL),
344  hESDDalitzPosEleAfterDCAz(NULL),
345  hESDDalitzElectronAfterTPCdEdxVsP(NULL),
346  hESDDalitzPositronAfterTPCdEdxVsP(NULL),
347  hESDDalitzElectronAfterTPCdEdxSignalVsP(NULL),
348  hESDDalitzPositronAfterTPCdEdxSignalVsP(NULL),
349  hESDDalitzElectronAfterTPCdEdxVsEta(NULL),
350  hESDDalitzPositronAfterTPCdEdxVsEta(NULL),
351  hESDDalitzElectronAfterTPCdEdxVsPhi(NULL),
352  hESDDalitzPositronAfterTPCdEdxVsPhi(NULL),
353  hESDEposEnegPsiPairDPhi(NULL),
354  hESDEposEnegPsiPairEta(NULL),
355  hESDEposEnegDPhiEta(NULL),
356  hESDEposEnegInvMassPt(NULL),
357  hESDTruePi0EposEnegInvMassPi0Pt(NULL),
358  hESDEposEnegLikeSignBackInvMassPt(NULL),
359  hESDMotherInvMassPt(NULL),
360  hESDPi0MotherInvMassPt(NULL),
361  hESDPi0MotherDiffInvMassPt(NULL),
362  hESDPi0MotherDiffLimInvMassPt(NULL),
363  hESDEposEnegInvMassPi0MotherPt(NULL),
364  hESDMotherInvMassOpeningAngleGammaElectron(NULL),
365  sESDMotherInvMassPtZM(NULL),
366  hESDMotherBackInvMassPt(NULL),
367  sESDMotherBackInvMassPtZM(NULL),
368  hESDMotherPi0PtY(NULL),
369  hESDMotherPi0PtAlpha(NULL),
370  hESDMotherPi0PtOpenAngle(NULL),
371  sESDMotherDalitzPlot(NULL),
372  hMCAllGammaPt(NULL),
373  hMCAllGammaPi0Pt(NULL),
374  hMCConvGammaPt(NULL),
375  hMCConvGammaPtR(NULL),
376  hMCConvGammaRSPt(NULL),
377  hMCConvGammaPi0Pt(NULL),
378  hMCAllPositronsPt(NULL),
379  hMCDecayPositronPi0Pt(NULL),
380  hMCAllElectronsPt(NULL),
381  hMCDecayElectronPi0Pt(NULL),
382  hMCConvGammaEta(NULL),
383  hMCConvGammaR(NULL),
384  hMCAllPositronsEta(NULL),
385  hMCAllElectronsEta(NULL),
386  hMCPi0DalitzGammaPt(NULL),
387  hMCPi0DalitzElectronPt(NULL),
388  hMCPi0DalitzPositronPt(NULL),
389  hMCPi0Pt(NULL),
390  hMCPi0WOWeightPt(NULL),
391  hMCPi0GGPt(NULL),
392  hMCEtaPt(NULL),
393  hMCEtaGGPt(NULL),
394  hMCPi0InAccPt(NULL),
395  hMCPi0WOWeightInAccPt(NULL),
396  hMCPi0InAccOpeningAngleGammaElectron(NULL),
397  sMCPi0DalitzPlot(NULL),
398  hMCEtaInAccPt(NULL),
399  hMCChiCPt(NULL),
400  hMCChiCInAccPt(NULL),
401  hMCPi0EposEnegInvMassPt(NULL),
402  hMCEtaEposEnegInvMassPt(NULL),
403  hESDEposEnegTruePi0DalitzInvMassPt(NULL),
404  hESDEposEnegTruePrimPi0DalitzInvMass(NULL),
405  hESDEposEnegTruePi0DalitzPsiPairDPhi(NULL),
406  hESDEposEnegTruePi0DalitzPsiPairMC(NULL),
407  hESDEposEnegTruePi0DalitzPsiPairEta(NULL),
408  hESDEposEnegTruePi0DalitzDPhiEta(NULL),
409  hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
410  hESDEposEnegTruePrimEtaDalitzInvMass(NULL),
411  hESDEposEnegTrueEtaDalitzPsiPairDPhi(NULL),
412  hESDEposEnegTruePhotonInvMassPt(NULL),
413  hESDEposEnegTrueInvMassPt(NULL),
414  hESDEposEnegTrueMotherInvMassPt(NULL),
415  hESDEposEnegTruePhotonPsiPairDPhi(NULL),
416  hESDEposEnegTruePhotonPsiPairDPhiPtCut(NULL),
417  hESDEposEnegTrueJPsiInvMassPt(NULL),
418  hESDTrueMotherChiCInvMassPt(NULL),
419  hESDTrueMotherChiCDiffInvMassPt(NULL),
420  hESDTrueMotherInvMassPt(NULL),
421  hESDTrueMotherW0WeightsInvMassPt(NULL),
422  hESDTrueMotherDalitzInvMassPt(NULL),
423  hESDTrueMotherPi0GGInvMassPt(NULL),
424  hESDTrueMotherPi0GGW0WeightsInvMassPt(NULL),
425  hESDTruePi0PtY(NULL),
426  hESDTruePi0PtAlpha(NULL),
427  hESDTruePi0PtOpenAngle(NULL),
428  sESDTruePi0DalitzPlot(NULL),
429  hESDTruePrimaryMotherPi0GGInvMassPt(NULL),
430  hESDTrueSecondaryMotherPi0GGInvMassPt(NULL),
431  hESDTruePrimaryMotherInvMassMCPt(NULL),
432  hESDTruePrimaryMotherInvMassPt(NULL),
433  hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
434  hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
435  hESDTrueSecondaryMotherInvMassPt(NULL),
436  hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
437  hESDTrueBckGGInvMassPt(NULL),
438  hESDTrueBckContInvMassPt(NULL),
439  hESDTrueMotherGGInvMassPt(NULL),
440  hESDTrueConvGammaPt(NULL),
441  hESDTrueConvGammaPtMC(NULL),
442  hESDTrueConvGammaR(NULL),
443  hESDTrueConvGammaRMC(NULL),
444  hESDTruePositronPt(NULL),
445  hESDTrueElectronPt(NULL),
446  hESDTrueSecConvGammaPt(NULL),
447  hESDTrueSecPositronPt(NULL),
448  hESDTrueSecElectronPt(NULL),
449  hESDTruePi0DalitzConvGammaPt(NULL),
450  hESDTruePi0DalitzConvGammaR(NULL),
451  hESDTruePi0DalitzPositronPt(NULL),
452  hESDTruePi0DalitzPositronPtMB(NULL),
453  hESDTruePi0DalitzElectronPt(NULL),
454  hESDTruePi0DalitzElectronPtMB(NULL),
455  hESDTruePi0DalitzSecConvGammaPt(NULL),
456  hESDTruePi0DalitzSecPositronPt(NULL),
457  hESDTruePi0DalitzSecElectronPt(NULL),
458  hNEvents(NULL),
459  hNGoodESDTracks(NULL),
460  hNGoodESDTracksVsNGoodGammas(NULL),
461  hNGoodESDTracksVsNGoodVGammas(NULL),
462  fHistoSPDClusterTrackletBackground(NULL),
463  hNV0Tracks(NULL),
464  hEtaShift(NULL),
465  fHistoDoubleCountTruePi0InvMassPt(NULL),
466  fHistoDoubleCountTrueEtaInvMassPt(NULL),
467  fHistoDoubleCountTrueConvGammaRPt(NULL),
468  fVectorDoubleCountTruePi0s(0),
469  fVectorDoubleCountTrueEtas(0),
470  fVectorDoubleCountTrueConvGammas(0),
471  fRandom(0),
472  fEventPlaneAngle(-100),
473  fUnsmearedPx(NULL),
474  fUnsmearedPy(NULL),
475  fUnsmearedPz(NULL),
476  fUnsmearedE(NULL),
477  fUnsmearedVPx(NULL),
478  fUnsmearedVPy(NULL),
479  fUnsmearedVPz(NULL),
480  fUnsmearedVE(NULL),
481  fnCuts(0),
482  fiCut(0),
483  fNumberOfESDTracks(0),
484  fNumberOfESDTrackskBoth(0),
485  fNVirtualGammas(0),
486  fMoveParticleAccordingToVertex(kFALSE),
487  fIsHeavyIon(0),
488  fDoMesonAnalysis(kTRUE),
489  fDoChicAnalysis(kFALSE),
490  fDoMesonQA(0),
491  fSetProductionVertextoVGamma(kTRUE),
492  fIsFromMBHeader(kTRUE),
493  fIsMC(kFALSE),
494  fDoTHnSparse(kTRUE),
495  fDoHistoDalitzMassLog(kFALSE),
496  fDoMaterialBudgetWeightingOfGammasForTrueMesons(kFALSE)
497 {
498  DefineOutput(1, TList::Class());
499 }
500 
501 //-----------------------------------------------------------------------------------------------
502 AliAnalysisTaskGammaConvDalitzV1::~AliAnalysisTaskGammaConvDalitzV1()
503 {
504  //
505  // virtual destructor
506  //
507 
508  cout<<"Destructor"<<endl;
509 
510  if(fGoodGammas){
511  delete fGoodGammas;
512  fGoodGammas = 0x0;
513  }
514  if(fGoodVirtualGammas){
515  delete fGoodVirtualGammas;
516  fGoodVirtualGammas = 0x0;
517  }
518  if(fGoodElectrons){
519  delete fGoodElectrons;
520  fGoodElectrons = 0x0;
521  }
522  if(fGoodPositrons){
523  delete fGoodPositrons;
524  fGoodPositrons = 0x0;
525  }
526  if(fBGHandler){
527  delete[] fBGHandler;
528  fBGHandler = 0x0;
529  }
530 
531 }
532 
533 //___________________________________________________________
534 void AliAnalysisTaskGammaConvDalitzV1::InitBack(){
535 
536  const Int_t nDim = 4;
537  Int_t nBins[nDim] = {800,250,7,4};
538  Double_t xMin[nDim] = {0,0, 0,0};
539  Double_t xMax[nDim] = {0.8,25,7,4};
540 
541  if( fDoTHnSparse ) {
542  sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
543  sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
544  }
545 
546  fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
547 
548  for(Int_t iCut = 0; iCut<fnCuts;iCut++){
549 
550  TString cutstringEvent = ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber();
551  TString cutstringElectron = ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
552  TString cutstringMeson = ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
553  TString cutstringGamma = ((AliConversionPhotonCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
554 
555  Int_t collisionSystem = atoi((TString)(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber())(0,1));
556  Int_t centMin = atoi((TString)(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber())(1,1));
557  Int_t centMax = atoi((TString)(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber())(2,1));
558 
559  if(collisionSystem == 1 || collisionSystem == 2 ||
560  collisionSystem == 5 || collisionSystem == 8 ||
561  collisionSystem == 9){
562  centMin = centMin*10;
563  centMax = centMax*10;
564  if(centMax ==0 && centMax!=centMin) centMax=100;
565  }
566  else if(collisionSystem == 3 || collisionSystem == 6){
567  centMin = centMin*5;
568  centMax = centMax*5;
569  }
570  else if(collisionSystem == 4 || collisionSystem == 7){
571  centMin = ((centMin*5)+45);
572  centMax = ((centMax*5)+45);
573  }
574 
575  if( fDoTHnSparse ) {
576  fBackList[iCut] = new TList();
577  fBackList[iCut]->SetName(Form("%s_%s_%s_%s Back histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
578  fBackList[iCut]->SetOwner(kTRUE);
579  fCutFolder[iCut]->Add(fBackList[iCut]);
580 
581  sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
582  fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
583 
584  fMotherList[iCut] = new TList();
585  fMotherList[iCut]->SetName(Form("%s_%s_%s_%s Mother histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
586  fMotherList[iCut]->SetOwner(kTRUE);
587  fCutFolder[iCut]->Add(fMotherList[iCut]);
588 
589  sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
590  fMotherList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
591  }
592 
593  if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->BackgroundHandlerType() == 0){
594 
595 
596  fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
597  collisionSystem,centMin,centMax,
598  ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetNumberOfBGEvents(),
599  ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseTrackMultiplicity(),
600  1,8,5);
601  }
602 
603 
604 
605  }
606 }
607 
608 //______________________________________________________________________
609 void AliAnalysisTaskGammaConvDalitzV1::UserCreateOutputObjects()
610 {
611  //
612  // Create ouput objects
613  //
614 
615  // Create the output container
616  if(fOutputContainer != NULL){
617  delete fOutputContainer;
618  fOutputContainer = NULL;
619  }
620  if(fOutputContainer == NULL){
621  fOutputContainer = new TList();
622  fOutputContainer->SetOwner(kTRUE);
623  }
624 
625  fGoodGammas = new TList();
626 
627  fGoodVirtualGammas = new TList();
628  fGoodVirtualGammas->SetOwner(kTRUE);
629 
630 
631  fCutFolder = new TList*[fnCuts];
632  fESDList = new TList*[fnCuts];
633 
634  if( fDoTHnSparse ){
635  fBackList = new TList*[fnCuts];
636  fMotherList = new TList*[fnCuts];
637  }
638  hNEvents = new TH1I*[fnCuts];
639  hNGoodESDTracks = new TH1I*[fnCuts];
640  hNV0Tracks = new TH1I*[fnCuts];
641  hEtaShift = new TProfile*[fnCuts];
642  hESDConvGammaPt = new TH1F*[fnCuts];
643  hESDConvGammaEta = new TH1F*[fnCuts];
644 
645  hESDDalitzElectronPt = new TH1F*[fnCuts];
646  hESDDalitzPositronPt = new TH1F*[fnCuts];
647  hESDDalitzElectronPhi = new TH1F*[fnCuts];
648  hESDDalitzPositronPhi = new TH1F*[fnCuts];
649 
650  const Int_t nBinsMassPair = 800;
651  Double_t xMinMassPair = 0.0;
652  Double_t xMaxMassPair = 0.8;
653 
654  if( fDoMesonQA > 0) {
655  fQAFolder = new TList*[fnCuts];
656  hNGoodESDTracksVsNGoodGammas = new TH2F*[fnCuts];
657  hNGoodESDTracksVsNGoodVGammas = new TH2F*[fnCuts];
658  fHistoSPDClusterTrackletBackground = new TH2F*[fnCuts];
659  hESDDalitzElectronAfterPt = new TH1F*[fnCuts];
660  hESDDalitzPositronAfterPt = new TH1F*[fnCuts];
661  hESDDalitzElectronAfterEta = new TH1F*[fnCuts];
662  hESDDalitzElectronAfterEtaPCut = new TH1F*[fnCuts];
663  hESDDalitzPositronAfterEta = new TH1F*[fnCuts];
664  hESDDalitzPositronAfterEtaPCut = new TH1F*[fnCuts];
665  hESDDalitzElectronAfterPhi = new TH1F*[fnCuts];
666  hESDDalitzPositronAfterPhi = new TH1F*[fnCuts];
667  hESDDalitzElectronAfterNClsITS = new TH1F*[fnCuts];
668  hESDDalitzElectronAfterNClsITSPCut = new TH1F*[fnCuts];
669  hESDDalitzPositronAfterNClsITS = new TH1F*[fnCuts];
670  hESDDalitzPositronAfterNClsITSPCut = new TH1F*[fnCuts];
671  hESDDalitzElectronAfterNFindClsTPC = new TH2F*[fnCuts];
672  hESDDalitzElectronAfterNFindClsTPCPCut = new TH1F*[fnCuts];
673  hESDDalitzPositronAfterNFindClsTPC = new TH2F*[fnCuts];
674  hESDDalitzPositronAfterNFindClsTPCPCut = new TH1F*[fnCuts];
675  hESDDalitzElectronAfterNClsTPC = new TH2F*[fnCuts];
676  hESDDalitzElectronAfterNClsTPCPCut = new TH1F*[fnCuts];
677  hESDDalitzPositronAfterNClsTPC = new TH2F*[fnCuts];
678  hESDDalitzPositronAfterNClsTPCPCut = new TH1F*[fnCuts];
679  hESDDalitzElectronAfterNCrossedRowsTPC = new TH2F*[fnCuts];
680  hESDDalitzElectronAfterNCrossedRowsTPCPCut = new TH1F*[fnCuts];
681  hESDDalitzPositronAfterNCrossedRowsTPC = new TH2F*[fnCuts];
682  hESDDalitzPositronAfterNCrossedRowsTPCPCut = new TH1F*[fnCuts];
683  hESDDalitzPosEleAfterDCAxy = new TH2F*[fnCuts];
684  hESDDalitzPosEleAfterDCAz = new TH2F*[fnCuts];
685  hESDDalitzElectronAfterTPCdEdxVsP = new TH2F*[fnCuts];
686  hESDDalitzPositronAfterTPCdEdxVsP = new TH2F*[fnCuts];
687  hESDDalitzElectronAfterTPCdEdxSignalVsP = new TH2F*[fnCuts];
688  hESDDalitzPositronAfterTPCdEdxSignalVsP = new TH2F*[fnCuts];
689  hESDDalitzElectronAfterTPCdEdxVsEta = new TH2F*[fnCuts];
690  hESDDalitzPositronAfterTPCdEdxVsEta = new TH2F*[fnCuts];
691  hESDDalitzElectronAfterTPCdEdxVsPhi = new TH2F*[fnCuts];
692  hESDDalitzPositronAfterTPCdEdxVsPhi = new TH2F*[fnCuts];
693  hESDEposEnegPsiPairDPhi = new TH2F*[fnCuts];
694  hESDEposEnegPsiPairEta = new TH2F*[fnCuts];
695  hESDEposEnegDPhiEta = new TH2F*[fnCuts];
696  hESDEposEnegDPhiEta = new TH2F*[fnCuts];
697  hESDEposEnegInvMassPt = new TH2F*[fnCuts];
698  hESDTruePi0EposEnegInvMassPi0Pt = new TH2F*[fnCuts];
699  hESDEposEnegLikeSignBackInvMassPt = new TH2F*[fnCuts];
700  hESDMotherInvMassOpeningAngleGammaElectron = new TH1F*[fnCuts];
701  hESDMotherPi0PtY = new TH2F*[fnCuts];
702  hESDMotherPi0PtAlpha = new TH2F*[fnCuts];
703  hESDMotherPi0PtOpenAngle = new TH2F*[fnCuts];
704 
705 
706  if ( fDoMesonQA > 1 ){
707  sESDConvGammaZR = new THnSparseF*[fnCuts];
708  sESDConvGammaXY = new THnSparseF*[fnCuts];
709  sESDMotherDalitzPlot = new THnSparseF*[fnCuts];
710  }
711 
712  if( fDoHistoDalitzMassLog ){
713 
714  xMinMassPair = 0.001;
715  xMaxMassPair = 0.801;
716 
717  }
718 
719 
720  }
721 
722 
723 
724  hESDMotherInvMassPt = new TH2F*[fnCuts];
725 
726  if(fDoChicAnalysis) {
727  hESDPi0MotherInvMassPt = new TH2F*[fnCuts];
728  hESDPi0MotherDiffInvMassPt = new TH2F*[fnCuts];
729  hESDPi0MotherDiffLimInvMassPt = new TH2F*[fnCuts];
730  hESDEposEnegInvMassPi0MotherPt = new TH2F*[fnCuts];
731  }
732  hESDMotherBackInvMassPt = new TH2F*[fnCuts];
733 
734 
735  for(Int_t iCut = 0; iCut<fnCuts;iCut++){
736 
737  TString cutstringEvent = ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber();
738  TString cutstringElectron = ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
739  TString cutstringMeson = ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
740  TString cutstringGamma = ((AliConversionPhotonCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
741 
742  fCutFolder[iCut] = new TList();
743  fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s_%s",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
744  fCutFolder[iCut]->SetOwner(kTRUE);
745  fOutputContainer->Add(fCutFolder[iCut]);
746 
747  fESDList[iCut] = new TList();
748  fESDList[iCut]->SetName(Form("%s_%s_%s_%s ESD histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
749  fESDList[iCut]->SetOwner(kTRUE);
750 
751  hNEvents[iCut] = new TH1I("NEvents","NEvents",13,-0.5,12.5);
752  hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
753  hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
754  hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
755  hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
756  hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
757  hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
758  hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
759  hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
760  hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
761  hNEvents[iCut]->GetXaxis()->SetBinLabel(10,"EMCAL problem");
762  hNEvents[iCut]->GetXaxis()->SetBinLabel(12,"SPD hits vs tracklet");
763  hNEvents[iCut]->GetXaxis()->SetBinLabel(13,"Out-of-Bunch pileup Past-Future");
764  fESDList[iCut]->Add(hNEvents[iCut]);
765 
766  if(fIsHeavyIon == 1 || fIsHeavyIon == 2) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",3000,0,3000);
767  else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
768  fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
769 
770 
771  if(fIsHeavyIon == 1) hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
772  else if(fIsHeavyIon == 2) hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
773  else hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
774  fESDList[iCut]->Add(hNV0Tracks[iCut]);
775 
776  hEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
777  fESDList[iCut]->Add(hEtaShift[iCut]);
778 
779  hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
780  fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
781 
782  hESDConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",600,-1.5,1.5);
783  fESDList[iCut]->Add(hESDConvGammaEta[iCut]);
784 
785  hESDDalitzElectronPt[iCut] = new TH1F("ESD_DalitzElectron_Pt","ESD_DalitzElectron_Pt",1000,0,25);
786  fESDList[iCut]->Add(hESDDalitzElectronPt[iCut]);
787 
788  hESDDalitzPositronPt[iCut] = new TH1F("ESD_DalitzPositron_Pt","ESD_DalitzPositron_Pt",1000,0,25);
789  fESDList[iCut]->Add(hESDDalitzPositronPt[iCut]);
790 
791 
792  hESDDalitzElectronPhi[iCut] = new TH1F("ESD_DalitzElectron_Phi","ESD_DalitzElectron_Phi",360,0,2*TMath::Pi());
793  fESDList[iCut]->Add(hESDDalitzElectronPhi[iCut]);
794 
795  hESDDalitzPositronPhi[iCut] = new TH1F("ESD_DalitzPositron_Phi","ESD_DalitzPositron_Phi",360,0,2*TMath::Pi());
796  fESDList[iCut]->Add(hESDDalitzPositronPhi[iCut]);
797 
798 
799 
800  if ( fDoMesonQA > 0 ) {
801 
802  fQAFolder[iCut] = new TList();
803  fQAFolder[iCut]->SetName(Form("%s_%s_%s_%s QA histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
804  fQAFolder[iCut]->SetOwner(kTRUE);
805 
806  const Int_t kPtBins=110;
807  Double_t binsPtDummy[kPtBins+1];
808  const Int_t kPBins = 109;
809  Double_t binsPDummy[kPBins+1];
810  binsPtDummy[0]=0.0;
811  binsPDummy[0]=0.05;
812 
813 
814 
815 
816 
817  for(Int_t i=1;i<kPtBins+1;i++){
818  if(binsPtDummy[i-1]+0.05<1.01)
819  binsPtDummy[i]=binsPtDummy[i-1]+0.05;
820  else
821  binsPtDummy[i]=binsPtDummy[i-1]+0.1;
822  }
823  for(Int_t i=1; i<kPBins+1;i++){
824  if( binsPDummy[i-1]+0.05<1.01)
825  binsPDummy[i] = binsPDummy[i-1]+0.05;
826  else
827  binsPDummy[i] = binsPDummy[i-1]+0.1;
828  }
829 
830  hNGoodESDTracksVsNGoodGammas[iCut] = new TH2F("hNGoodESDTracksVsNGoodGammas","hNGoodESDTracksVsNGoodGammas",200,-0.5,199.5,100,-0.5,99.5);
831  fQAFolder[iCut]->Add(hNGoodESDTracksVsNGoodGammas[iCut]);
832 
833  hNGoodESDTracksVsNGoodVGammas[iCut] = new TH2F("hNGoodESDTracksVsNVGoodVGammas","hNGoodESDTracksVsNGoodVGammas",200,-0.5,199.5,100,-0.5,99.5);
834  fQAFolder[iCut]->Add(hNGoodESDTracksVsNGoodVGammas[iCut]);
835 
836  fHistoSPDClusterTrackletBackground[iCut] = new TH2F("SPD tracklets vs SPD clusters","SPD tracklets vs SPD clusters",100,0,200,250,0,1000);
837  fQAFolder[iCut]->Add(fHistoSPDClusterTrackletBackground[iCut]);
838 
839 
840  hESDDalitzElectronAfterPt[iCut] = new TH1F("ESD_DalitzElectron_After_Pt","ESD_DalitzElectron_After_Pt",1000,0,25);
841  fQAFolder[iCut]->Add(hESDDalitzElectronAfterPt[iCut]);
842 
843  hESDDalitzPositronAfterPt[iCut] = new TH1F("ESD_DalitzPositron_After_Pt","ESD_DalitzPositron_After_Pt",1000,0,25);
844  fQAFolder[iCut]->Add(hESDDalitzPositronAfterPt[iCut]);
845 
846  hESDDalitzElectronAfterEta[iCut] = new TH1F("ESD_DalitzElectron_After_Eta","ESD_DalitzElectron_After_Eta",600,-1.5,1.5);
847  fQAFolder[iCut]->Add(hESDDalitzElectronAfterEta[iCut]);
848 
849  hESDDalitzElectronAfterEtaPCut[iCut] = new TH1F("ESD_DalitzElectron_After_Eta_PCut","ESD_DalitzElectron_After_Eta_PCut",600,-1.5,1.5);
850  fQAFolder[iCut]->Add(hESDDalitzElectronAfterEtaPCut[iCut]);
851 
852  hESDDalitzPositronAfterEta[iCut] = new TH1F("ESD_DalitzPositron_After_Eta","ESD_DalitzElectron_After_Eta",600,-1.5,1.5);
853  fQAFolder[iCut]->Add(hESDDalitzPositronAfterEta[iCut]);
854 
855  hESDDalitzPositronAfterEtaPCut[iCut] = new TH1F("ESD_DalitzPositron_After_Eta_PCut","ESD_DalitzElectron_After_Eta_PCut",600,-1.5,1.5);
856  fQAFolder[iCut]->Add(hESDDalitzPositronAfterEtaPCut[iCut]);
857 
858  hESDDalitzElectronAfterPhi[iCut] = new TH1F("ESD_DalitzElectron_After_Phi","ESD_DalitzElectron_After_Phi",360,0,2*TMath::Pi());
859  fQAFolder[iCut]->Add(hESDDalitzElectronAfterPhi[iCut]);
860 
861  hESDDalitzPositronAfterPhi[iCut] = new TH1F("ESD_DalitzPositron_After_Phi","ESD_DalitzPositron_After_Phi",360,0,2*TMath::Pi());
862  fQAFolder[iCut]->Add(hESDDalitzPositronAfterPhi[iCut]);
863 
864  hESDDalitzElectronAfterNClsITS[iCut] = new TH1F("ESD_DalitzElectron_After_NClsITS","ESD_DalitzElectron_After_NClsITS",7,-0.5,6.5);
865  fQAFolder[iCut]->Add(hESDDalitzElectronAfterNClsITS[iCut]);
866 
867  hESDDalitzElectronAfterNClsITSPCut[iCut] = new TH1F("ESD_DalitzElectron_After_NClsITS_PCut","ESD_DalitzElectron_After_NClsITS_PCut",7,-0.5,6.5);
868  fQAFolder[iCut]->Add(hESDDalitzElectronAfterNClsITSPCut[iCut]);
869 
870  hESDDalitzPositronAfterNClsITS[iCut] = new TH1F("ESD_DalitzPositron_After_NClsITS","ESD_DalitzPositron_After_NClsITS",7,-0.5,6.5);
871  fQAFolder[iCut]->Add(hESDDalitzPositronAfterNClsITS[iCut]);
872 
873  hESDDalitzPositronAfterNClsITSPCut[iCut] = new TH1F("ESD_DalitzPositron_After_NClsITS_PCut","ESD_DalitzPositron_After_NClsITS_PCut",7,-0.5,6.5);
874  fQAFolder[iCut]->Add(hESDDalitzPositronAfterNClsITSPCut[iCut]);
875 
876  hESDDalitzElectronAfterNFindClsTPC[iCut] = new TH2F("ESD_DalitzElectron_After_NFindClsTPC","ESD_DalitzElectron_After_NFindClsTPC",60,0,1.5,kPtBins,binsPtDummy);
877  fQAFolder[iCut]->Add(hESDDalitzElectronAfterNFindClsTPC[iCut]);
878 
879  hESDDalitzElectronAfterNFindClsTPCPCut[iCut] = new TH1F("ESD_DalitzElectron_After_NFindClsTPC_PCut","ESD_DalitzElectron_After_NFindClsTPC_PCut",60,0,1.5);
880  fQAFolder[iCut]->Add(hESDDalitzElectronAfterNFindClsTPCPCut[iCut]);
881 
882 
883  hESDDalitzPositronAfterNFindClsTPC[iCut] = new TH2F("ESD_DalitzPositron_After_NFindClsTPC","ESD_DalitzPositron_After_NFindClsTPC",60,0,1.5,kPtBins,binsPtDummy);
884  fQAFolder[iCut]->Add(hESDDalitzPositronAfterNFindClsTPC[iCut]);
885 
886  hESDDalitzPositronAfterNFindClsTPCPCut[iCut] = new TH1F("ESD_DalitzPositron_After_NFindClsTPC_PCut","ESD_DalitzPositron_After_NFindClsTPC_PCut",60,0,1.5);
887  fQAFolder[iCut]->Add(hESDDalitzPositronAfterNFindClsTPCPCut[iCut]);
888 
889 
890  hESDDalitzElectronAfterNClsTPC[iCut] = new TH2F("ESD_DalitzElectron_After_NClsTPC","ESD_DalitzElectron_After_NClsTPC",200,-0.5,199.5,kPtBins,binsPtDummy);
891  fQAFolder[iCut]->Add(hESDDalitzElectronAfterNClsTPC[iCut]);
892 
893  hESDDalitzElectronAfterNClsTPCPCut[iCut] = new TH1F("ESD_DalitzElectron_After_NClsTPC_PCut","ESD_DalitzElectron_After_NClsTPC_PCut",200,-0.5,199.5);
894  fQAFolder[iCut]->Add(hESDDalitzElectronAfterNClsTPCPCut[iCut]);
895 
896  hESDDalitzPositronAfterNClsTPC[iCut] = new TH2F("ESD_DalitzPositron_After_NClsTPC","ESD_DalitzPositron_After_NClsTPC",200,-0.5,199.5,kPtBins,binsPtDummy);
897  fQAFolder[iCut]->Add(hESDDalitzPositronAfterNClsTPC[iCut]);
898 
899  hESDDalitzPositronAfterNClsTPCPCut[iCut] = new TH1F("ESD_DalitzPositron_After_NClsTPC_PCut","ESD_DalitzPositron_After_NClsTPC_PCut",200,-0.5,199.5);
900  fQAFolder[iCut]->Add(hESDDalitzPositronAfterNClsTPCPCut[iCut]);
901 
902  hESDDalitzPositronAfterNCrossedRowsTPC[iCut] = new TH2F("ESD_DalitzPositron_After_NCrossedRowsTPC","ESD_DalitzPositron_After_NCrossedRowsTPC",165,-0.5,164.5,kPtBins,binsPtDummy);
903  fQAFolder[iCut]->Add(hESDDalitzPositronAfterNCrossedRowsTPC[iCut]);
904 
905  hESDDalitzPositronAfterNCrossedRowsTPCPCut[iCut] = new TH1F("ESD_DalitzPositron_After_NCrossedRowsTPC_PCut","ESD_DalitzPositron_After_NCrossedRowsTPC_PCut",165,-0.5,164.5);
906  fQAFolder[iCut]->Add(hESDDalitzPositronAfterNCrossedRowsTPCPCut[iCut]);
907 
908  hESDDalitzElectronAfterNCrossedRowsTPC[iCut] = new TH2F("ESD_DalitzElectron_After_NCrossedRowsTPC","ESD_DalitzElectron_After_NCrossedRowsTPC",165,-0.5,164.5,kPtBins,binsPtDummy);
909  fQAFolder[iCut]->Add(hESDDalitzElectronAfterNCrossedRowsTPC[iCut]);
910 
911  hESDDalitzElectronAfterNCrossedRowsTPCPCut[iCut] = new TH1F("ESD_DalitzElectron_After_NCrossedRowsTPC_PCut","ESD_DalitzElectron_After_NCrossedRowsTPC_PCut",165,-0.5,164.5);
912  fQAFolder[iCut]->Add(hESDDalitzElectronAfterNCrossedRowsTPCPCut[iCut]);
913 
914  hESDDalitzPosEleAfterDCAxy[iCut] = new TH2F("ESD_DalitzPosEle_After_DCAxy","ESD_DalitzPosEle_After_DCAxy",124,-0.62,0.62,kPtBins,binsPtDummy);
915  fQAFolder[iCut]->Add(hESDDalitzPosEleAfterDCAxy[iCut]);
916 
917  hESDDalitzPosEleAfterDCAz[iCut] = new TH2F("ESD_DalitzPosEle_After_DCAz","ESD_DalitzPosEle_After_DCAz",200,-1.0,1.0,kPtBins,binsPtDummy);
918  fQAFolder[iCut]->Add(hESDDalitzPosEleAfterDCAz[iCut]);
919 
920  hESDDalitzElectronAfterTPCdEdxVsP[iCut] = new TH2F("ESD_DalitzElectron_After_TPCdEdxVsP","ESD_DalitzElectron_After_TPCdEdxVsP_After_TPCdEdx",kPBins,binsPDummy,200,-10,10);
921  SetLogBinningXTH2(hESDDalitzElectronAfterTPCdEdxVsP[iCut]);
922  fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxVsP[iCut]);
923 
924  hESDDalitzPositronAfterTPCdEdxVsP[iCut] = new TH2F("ESD_DalitzPositron_After_TPCdEdxVsP","ESD_DalitzPositron_After_TPCdEdxVsP",kPBins,binsPDummy,200,-10,10);
925  SetLogBinningXTH2(hESDDalitzPositronAfterTPCdEdxVsP[iCut]);
926  fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxVsP[iCut]);
927 
928  hESDDalitzElectronAfterTPCdEdxSignalVsP[iCut] =new TH2F("ESD_DalitzElectron_After_TPCdEdxSignalVsP","ESD_DalitzElectron_After_TPCdEdxSignalVsP" ,kPBins,binsPDummy,200,0.0,200);
929  SetLogBinningXTH2(hESDDalitzElectronAfterTPCdEdxSignalVsP[iCut]);
930  fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxSignalVsP[iCut]);
931 
932  hESDDalitzPositronAfterTPCdEdxSignalVsP[iCut] =new TH2F("ESD_DalitzPositron_After_TPCdEdxSignalVsP","ESD_DalitzPositron_After_TPCdEdxSignalVsP" ,kPBins,binsPDummy,200,0.0,200);
933  SetLogBinningXTH2(hESDDalitzPositronAfterTPCdEdxSignalVsP[iCut]);
934  fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxSignalVsP[iCut]);
935 
936  hESDDalitzElectronAfterTPCdEdxVsEta[iCut] = new TH2F("ESD_DalitzElectron_After_TPCdEdxVsEta","ESD_DalitzElectron_After_TPCdEdxVsEta",140,-1.4,1.4,200,-10,10);
937  fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxVsEta[iCut]);
938 
939  hESDDalitzPositronAfterTPCdEdxVsEta[iCut] = new TH2F("ESD_DalitzPositron_After_TPCdEdxVsEta","ESD_DalitzPositron_After_TPCdEdxVsEta",140,-1.4,1.4,200,-10,10);
940  fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxVsEta[iCut]);
941 
942  hESDDalitzElectronAfterTPCdEdxVsPhi[iCut] = new TH2F("ESD_DalitzElectron_After_TPCdEdxVsPhi","ESD_DalitzElectron_After_TPCdEdxVsPhi",180,0,2*TMath::Pi(),200,-10,10);
943  fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxVsPhi[iCut]);
944 
945  hESDDalitzPositronAfterTPCdEdxVsPhi[iCut] = new TH2F("ESD_DalitzPositron_After_TPCdEdxVsPhi","ESD_DalitzPositron_After_TPCdEdxVsPhi",180,0,2*TMath::Pi(),200,-10,10);
946  fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxVsPhi[iCut]);
947 
948  hESDEposEnegPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_PsiPair_DPhi","ESD_EposEneg_PsiPair_DPhi",100,-1.0,1.0,100,-1.0,1.0 );
949  fQAFolder[iCut]->Add(hESDEposEnegPsiPairDPhi[iCut]);
950 
951  hESDEposEnegPsiPairEta[iCut] = new TH2F("ESD_EposEneg_PsiPair_Eta","ESD_EposEneg_PsiPair_Eta",100,-1.0,1.0,600,-1.5,1.5);
952  fQAFolder[iCut]->Add(hESDEposEnegPsiPairEta[iCut]);
953 
954  hESDEposEnegDPhiEta[iCut] = new TH2F("ESD_EposEneg_DPhi_Eta","ESD_EposEneg_DPhi_Eta",100,-1.0,1.0,600,-1.5,1.5);
955  fQAFolder[iCut]->Add(hESDEposEnegDPhiEta[iCut]);
956 
957 
958  hESDEposEnegInvMassPt[iCut] = new TH2F("ESD_EposEneg_InvMassPt","ESD_EposEneg_InvMassPt",nBinsMassPair,xMinMassPair,xMaxMassPair,100,0.,10.);
959  if(fDoHistoDalitzMassLog) SetLogBinningXTH2(hESDEposEnegInvMassPt[iCut]);
960  fQAFolder[iCut]->Add(hESDEposEnegInvMassPt[iCut]);
961 
962 
963  hESDEposEnegLikeSignBackInvMassPt[iCut] = new TH2F("ESD_EposEneg_LikeSignBack_InvMassPt","ESD_EposEneg_LikeSignBack_InvMassPt",4000,0.0,2.,100,0.,10.);
964  fQAFolder[iCut]->Add(hESDEposEnegLikeSignBackInvMassPt[iCut]);
965 
966 
967  if( fDoMesonQA > 1 ) {
968 
969  const Int_t nDimRZ = 2;
970  Int_t nBinsRZ[nDimRZ] = { 1200, 800};
971  Double_t xMinRZ[nDimRZ] = { -150, 0};
972  Double_t xMaxRZ[nDimRZ] = { 150, 200};
973 
974  const Int_t nDimXY = 2;
975  Int_t nBinsXY[nDimXY] = { 1200, 1200};
976  Double_t xMinXY[nDimXY] = { -150, -150};
977  Double_t xMaxXY[nDimXY] = { 150, 150};
978 
979  sESDConvGammaZR[iCut] = new THnSparseF("ESD_ConvGamma_ZR","ESD_ConvGamma_ZR",nDimRZ,nBinsRZ,xMinRZ,xMaxRZ);
980  fQAFolder[iCut]->Add(sESDConvGammaZR[iCut]);
981 
982  sESDConvGammaXY[iCut] = new THnSparseF("ESD_ConvGamma_XY","ESD_ConvGamma_XY",nDimXY,nBinsXY,xMinXY,xMaxXY);
983  fQAFolder[iCut]->Add(sESDConvGammaXY[iCut]);
984 
985 
986  const Int_t nDimDalPlot = 2;
987  Int_t nBinsDalPlot[nDimDalPlot] = { 4000, 4000};
988  Double_t xMinDalPlot[nDimDalPlot] = { 0, 0};
989  Double_t xMaxDalPlot[nDimDalPlot] = { 4.0, 4.0};
990 
991 
992  sESDMotherDalitzPlot[iCut] = new THnSparseF("ESD_Mother_DalitzPlot","ESD_Mother_DalitzPlot",nDimDalPlot,nBinsDalPlot,xMinDalPlot,xMaxDalPlot);
993  fQAFolder[iCut]->Add(sESDMotherDalitzPlot[iCut]);
994 
995  }
996  fCutFolder[iCut]->Add(fQAFolder[iCut]);
997  }
998 
999  hESDMotherInvMassPt[iCut] = new TH2F("ESD_DalitzMother_InvMass_Pt","ESD_DalitzMother_InvMass_Pt",800,0,0.8,250,0,25);
1000  fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
1001 
1002  if( fDoMesonQA > 0 ) {
1003 
1004  hESDMotherInvMassOpeningAngleGammaElectron[iCut] = new TH1F("ESD_MotherInvMass_OpeningAngle_GammaElectron", "ESD_MotherInvMass_OpeningAngle_GammaElectron",100,0.,TMath::Pi());
1005  fESDList[iCut]->Add(hESDMotherInvMassOpeningAngleGammaElectron[iCut]);
1006 
1007  hESDMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1008  SetLogBinningXTH2(hESDMotherPi0PtY[iCut]);
1009  fESDList[iCut]->Add(hESDMotherPi0PtY[iCut]);
1010  hESDMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",150,0.03,15.,100,0,1);
1011  SetLogBinningXTH2(hESDMotherPi0PtAlpha[iCut]);
1012  fESDList[iCut]->Add(hESDMotherPi0PtAlpha[iCut]);
1013  hESDMotherPi0PtOpenAngle[iCut] = new TH2F("ESD_MotherPi0_Pt_OpenAngle","ESD_MotherPi0_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
1014  SetLogBinningXTH2(hESDMotherPi0PtOpenAngle[iCut]);
1015  fESDList[iCut]->Add(hESDMotherPi0PtOpenAngle[iCut]);
1016  }
1017 
1018 
1019  if( fDoChicAnalysis) {
1020  hESDPi0MotherInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_InvMass_Pt","ESD_Pi0Mother_InvMass_Pt",4000,0,4,200,0,20);
1021  fESDList[iCut]->Add(hESDPi0MotherInvMassPt[iCut]);
1022  hESDPi0MotherDiffInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffInvMass_Pt","ESD_Pi0Mother_DiffInvMass_Pt",2000,0,2,200,0,20);
1023  fESDList[iCut]->Add(hESDPi0MotherDiffInvMassPt[iCut]);
1024  hESDPi0MotherDiffLimInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffLimInvMass_Pt","ESD_Pi0Mother_DiffLimInvMass_Pt",2000,0,2,200,0,20);
1025  fESDList[iCut]->Add(hESDPi0MotherDiffLimInvMassPt[iCut]);
1026  hESDEposEnegInvMassPi0MotherPt[iCut] = new TH2F("ESD_EposEnegInvMass_Pi0MotherPt","ESD_EposEnegInvMass_Pi0MotherPt",4000,0,4,200,0,20);
1027  fESDList[iCut]->Add(hESDEposEnegInvMassPi0MotherPt[iCut]);
1028  }
1029 
1030  hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_DalitzBackground_InvMass_Pt","ESD_DalitzBackground_InvMass_Pt",800,0,0.8,250,0,25);
1031  fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
1032 
1033  fCutFolder[iCut]->Add(fESDList[iCut]);
1034  }
1035 
1036 
1037  InitBack(); // Init Background Handler
1038 
1039 
1040  if( fIsMC ){
1041  // MC Histogramms
1042  fMCList = new TList*[fnCuts];
1043  // True Histogramms
1044  fTrueList = new TList*[fnCuts];
1045  hESDTrueConvGammaPt = new TH1F*[fnCuts];
1046  fHistoDoubleCountTrueConvGammaRPt = new TH2F*[fnCuts];
1047  hESDTruePositronPt = new TH1F*[fnCuts];
1048  hESDTrueElectronPt = new TH1F*[fnCuts];
1049  hESDTrueSecConvGammaPt = new TH1F*[fnCuts];
1050  hESDTrueSecPositronPt = new TH1F*[fnCuts];
1051  hESDTrueSecElectronPt = new TH1F*[fnCuts];
1052  hESDTruePi0DalitzConvGammaPt = new TH1F*[fnCuts];
1053 
1054  fHistoDoubleCountTruePi0InvMassPt = new TH2F*[fnCuts];
1055  fHistoDoubleCountTrueEtaInvMassPt = new TH2F*[fnCuts];
1056  hESDTruePi0DalitzPositronPt = new TH1F*[fnCuts];
1057  hESDTruePi0DalitzPositronPtMB = new TH1F*[fnCuts];
1058  hESDTruePi0DalitzElectronPt = new TH1F*[fnCuts];
1059  hESDTruePi0DalitzElectronPtMB = new TH1F*[fnCuts];
1060  hESDTruePi0DalitzSecConvGammaPt = new TH1F*[fnCuts];
1061  hESDTruePi0DalitzSecPositronPt = new TH1F*[fnCuts];
1062  hESDTruePi0DalitzSecElectronPt = new TH1F*[fnCuts];
1063 
1064  hMCAllGammaPt = new TH1F*[fnCuts];
1065  hMCAllGammaPi0Pt = new TH1F*[fnCuts];
1066  hMCConvGammaPt = new TH1F*[fnCuts];
1067  hMCConvGammaRSPt = new TH1F*[fnCuts];
1068  hMCConvGammaPi0Pt = new TH1F*[fnCuts];
1069  hMCAllPositronsPt = new TH1F*[fnCuts];
1070  hMCDecayPositronPi0Pt = new TH1F*[fnCuts];
1071  hMCAllElectronsPt = new TH1F*[fnCuts];
1072  hMCDecayElectronPi0Pt = new TH1F*[fnCuts];
1073 
1074  if( fDoMesonQA > 0 ) {
1075 
1076  hMCConvGammaEta = new TH1F*[fnCuts];
1077  hMCConvGammaR = new TH1F*[fnCuts];
1078  hMCAllPositronsEta = new TH1F*[fnCuts];
1079  hMCAllElectronsEta = new TH1F*[fnCuts];
1080  hMCConvGammaPtR = new TH2F*[fnCuts];
1081 
1082 
1083  }
1084  hMCPi0DalitzGammaPt = new TH1F*[fnCuts];
1085  hMCPi0DalitzElectronPt = new TH1F*[fnCuts];
1086  hMCPi0DalitzPositronPt = new TH1F*[fnCuts];
1087 
1088  hMCPi0Pt = new TH1F*[fnCuts];
1089  hMCPi0WOWeightPt = new TH1F*[fnCuts];
1090  hMCPi0GGPt = new TH1F*[fnCuts];
1091  hMCEtaPt = new TH1F*[fnCuts];
1092  hMCEtaGGPt = new TH1F*[fnCuts];
1093  hMCPi0InAccPt = new TH1F*[fnCuts];
1094  hMCPi0WOWeightInAccPt = new TH1F*[fnCuts];
1095  hMCPi0InAccOpeningAngleGammaElectron = new TH1F*[fnCuts];
1096  hMCEtaInAccPt = new TH1F*[fnCuts];
1097  hMCChiCPt = new TH1F*[fnCuts];
1098  hMCChiCInAccPt = new TH1F*[fnCuts];
1099 
1100 
1101  if ( fDoMesonQA > 0 ) {
1102 
1103  hMCPi0EposEnegInvMassPt = new TH2F*[fnCuts];
1104  hMCEtaEposEnegInvMassPt = new TH2F*[fnCuts];
1105  hESDEposEnegTruePi0DalitzInvMassPt = new TH2F*[fnCuts];
1106  hESDEposEnegTruePrimPi0DalitzInvMass = new TH1F*[fnCuts];
1107  hESDEposEnegTruePi0DalitzPsiPairDPhi = new TH2F*[fnCuts];
1108  hESDEposEnegTruePi0DalitzPsiPairMC = new TH1F*[fnCuts];
1109  hESDEposEnegTruePi0DalitzPsiPairEta = new TH2F*[fnCuts];
1110  hESDEposEnegTruePi0DalitzDPhiEta = new TH2F*[fnCuts];
1111  hESDEposEnegTrueEtaDalitzInvMassPt = new TH2F*[fnCuts];
1112  hESDEposEnegTruePrimEtaDalitzInvMass = new TH1F*[fnCuts];
1113  hESDEposEnegTrueEtaDalitzPsiPairDPhi = new TH2F*[fnCuts];
1114  hESDEposEnegTruePhotonInvMassPt = new TH2F*[fnCuts];
1115  hESDEposEnegTrueInvMassPt = new TH2F*[fnCuts];
1116  hESDEposEnegTrueMotherInvMassPt = new TH2F*[fnCuts];
1117  hESDEposEnegTruePhotonPsiPairDPhi = new TH2F*[fnCuts];
1118  hESDEposEnegTruePhotonPsiPairDPhiPtCut = new TH2F*[fnCuts];
1119  hESDEposEnegTrueJPsiInvMassPt = new TH2F*[fnCuts];
1120  hESDTrueConvGammaR = new TH1F*[fnCuts];
1121  hESDTrueConvGammaRMC = new TH1F*[fnCuts];
1122  hESDTrueConvGammaPtMC = new TH1F*[fnCuts];
1123  hESDTruePi0PtY = new TH2F*[fnCuts];
1124  hESDTruePi0PtAlpha = new TH2F*[fnCuts];
1125  hESDTruePi0PtOpenAngle = new TH2F*[fnCuts];
1126 
1127  if ( fDoMesonQA > 1 ) {
1128  hESDTruePi0DalitzConvGammaR = new TH1F*[fnCuts];
1129  sESDTruePi0DalitzPlot = new THnSparseF*[fnCuts];
1130  sMCPi0DalitzPlot = new THnSparseF*[fnCuts];
1131  }
1132 
1133 
1134  }
1135 
1136 
1137  if( fDoChicAnalysis ){
1138  hESDTrueMotherChiCInvMassPt = new TH2F*[fnCuts];
1139  hESDTrueMotherChiCDiffInvMassPt = new TH2F*[fnCuts];
1140  }
1141 
1142 
1143  hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
1144  hESDTrueMotherW0WeightsInvMassPt = new TH2F*[fnCuts];
1145  hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
1146  hESDTrueMotherPi0GGInvMassPt = new TH2F*[fnCuts];
1147  hESDTrueMotherPi0GGW0WeightsInvMassPt = new TH2F*[fnCuts];
1148  hESDTruePrimaryMotherPi0GGInvMassPt = new TH2F*[fnCuts];
1149  hESDTrueSecondaryMotherPi0GGInvMassPt = new TH2F*[fnCuts];
1150  hESDTruePrimaryPi0DalitzESDPtMCPt = new TH2F*[fnCuts];
1151  hESDTruePrimaryMotherInvMassMCPt = new TH2F*[fnCuts];
1152  hESDTruePrimaryMotherInvMassPt = new TH2F*[fnCuts];
1153  hESDTruePrimaryMotherW0WeightingInvMassPt = new TH2F*[fnCuts];
1154  hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
1155  hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
1156  hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
1157  hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
1158  hESDTrueMotherGGInvMassPt = new TH2F*[fnCuts];
1159  //}
1160 
1161  for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1162  TString cutstringEvent = ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber();
1163  TString cutstringElectron = ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
1164  TString cutstringMeson = ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
1165  TString cutstringGamma = ((AliConversionPhotonCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
1166 
1167  fMCList[iCut] = new TList();
1168  fMCList[iCut]->SetName(Form("%s_%s_%s_%s MC histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
1169  fMCList[iCut]->SetOwner(kTRUE);
1170  fCutFolder[iCut]->Add(fMCList[iCut]);
1171 
1172  hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
1173  fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
1174 
1175  hMCAllGammaPi0Pt[iCut] = new TH1F("MC_AllGammaPi0_Pt","MC_AllGammaPi0_Pt",250,0,25);
1176  fMCList[iCut]->Add(hMCAllGammaPi0Pt[iCut]);
1177 
1178  hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
1179  fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
1180 
1181  hMCConvGammaRSPt[iCut] = new TH1F("MC_ConvGamma_RS_Pt","MC_ConvGamma_RS_Pt",250,0,25);
1182  fMCList[iCut]->Add(hMCConvGammaRSPt[iCut]);
1183 
1184  hMCConvGammaPi0Pt[iCut] = new TH1F("MC_ConvGammaPi0_Pt","MC_ConvGammaPi0_Pt",250,0,25);
1185  fMCList[iCut]->Add(hMCConvGammaPi0Pt[iCut]);
1186 
1187  hMCAllPositronsPt[iCut] = new TH1F("MC_AllPositrons_Pt","MC_AllPositrons_Pt",1000,0,25);
1188  fMCList[iCut]->Add(hMCAllPositronsPt[iCut]);
1189 
1190  hMCDecayPositronPi0Pt[iCut] = new TH1F("MC_DecayPositronPi0_Pt","MC_DecayPositronPi0_Pt",1000,0,25);
1191  fMCList[iCut]->Add(hMCDecayPositronPi0Pt[iCut]);
1192 
1193  hMCAllElectronsPt[iCut] = new TH1F("MC_AllElectrons_Pt","MC_AllElectrons_Pt",1000,0,25);
1194  fMCList[iCut]->Add(hMCAllElectronsPt[iCut]);
1195 
1196  hMCDecayElectronPi0Pt[iCut] = new TH1F("MC_DecayElectronPi0_Pt","MC_DecayElectronPi0_Pt",1000,0,25);
1197  fMCList[iCut]->Add(hMCDecayElectronPi0Pt[iCut]);
1198 
1199  hMCPi0DalitzGammaPt[iCut] = new TH1F("MC_Pi0DalitzGamma_Pt","MC_Pi0DalitzGamma_Pt",250,0,25);
1200  hMCPi0DalitzGammaPt[iCut]->Sumw2();
1201  fMCList[iCut]->Add(hMCPi0DalitzGammaPt[iCut]);
1202 
1203  if ( fDoMesonQA > 0 ){
1204  hMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",600,-1.5,1.5);
1205  fMCList[iCut]->Add(hMCConvGammaEta[iCut]);
1206  hMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
1207  fMCList[iCut]->Add(hMCConvGammaR[iCut]);
1208  hMCAllPositronsEta[iCut] = new TH1F("MC_AllPositrons_Eta","MC_AllPositrons_Eta",600,-1.5,1.5);
1209  fMCList[iCut]->Add(hMCAllPositronsEta[iCut]);
1210  hMCAllElectronsEta[iCut] = new TH1F("MC_AllElectrons_Eta","MC_AllElectrons_Eta",600,-1.5,1.5);
1211  fMCList[iCut]->Add(hMCAllElectronsEta[iCut]);
1212  hMCConvGammaPtR[iCut] = new TH2F("MC_ConvGamma_Pt_R","MC_ConvGamma_Pt_R",250,0,25,180,0.,180.0);
1213  fMCList[iCut]->Add(hMCConvGammaPtR[iCut]);
1214 
1215  }
1216 
1217  hMCPi0DalitzPositronPt[iCut] = new TH1F("MC_Pi0DalitzPositron_Pt","MC_Pi0DalitzPositron_Pt",1000,0,25);
1218  hMCPi0DalitzPositronPt[iCut]->Sumw2();
1219  fMCList[iCut]->Add(hMCPi0DalitzPositronPt[iCut]);
1220 
1221  hMCPi0DalitzElectronPt[iCut] = new TH1F("MC_Pi0DalitzElectron_Pt","MC_Pi0DalitzElectron_Pt",1000,0,25);
1222  hMCPi0DalitzElectronPt[iCut]->Sumw2();
1223  fMCList[iCut]->Add(hMCPi0DalitzElectronPt[iCut]);
1224 
1225  hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
1226  hMCPi0Pt[iCut]->Sumw2();
1227  fMCList[iCut]->Add(hMCPi0Pt[iCut]);
1228 
1229  hMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
1230  hMCPi0WOWeightPt[iCut]->Sumw2();
1231  fMCList[iCut]->Add(hMCPi0WOWeightPt[iCut]);
1232 
1233  hMCPi0GGPt[iCut] = new TH1F("MC_Pi0_GG_Pt","MC_Pi0_GG_Pt",250,0,25);
1234  hMCPi0GGPt[iCut]->Sumw2();
1235  fMCList[iCut]->Add(hMCPi0GGPt[iCut]);
1236 
1237  hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
1238  hMCEtaPt[iCut]->Sumw2();
1239  fMCList[iCut]->Add(hMCEtaPt[iCut]);
1240 
1241  hMCEtaGGPt[iCut] = new TH1F("MC_Eta_GG_Pt","MC_Eta_GG_Pt",250,0,25);
1242  hMCEtaGGPt[iCut]->Sumw2();
1243  fMCList[iCut]->Add(hMCEtaGGPt[iCut]);
1244 
1245  hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0DalitzInAcc_Pt","MC_Pi0DalitzInAcc_Pt",250,0,25);
1246  hMCPi0InAccPt[iCut]->Sumw2();
1247  fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
1248 
1249  hMCPi0WOWeightInAccPt[iCut] = new TH1F("MC_Pi0WOWeightInAcc_Pt","MC_Pi0WOWeightInAcc_Pt",250,0,25);
1250  hMCPi0WOWeightInAccPt[iCut]->Sumw2();
1251  fMCList[iCut]->Add(hMCPi0WOWeightInAccPt[iCut]);
1252 
1253  hMCPi0InAccOpeningAngleGammaElectron[iCut] = new TH1F("MC_Pi0InAcc_OpeningAngle_GammaElectron","MC_Pi0InAcc_OpeningAngle_GammaElectron",100,0,TMath::Pi());
1254  fMCList[iCut]->Add(hMCPi0InAccOpeningAngleGammaElectron[iCut]);
1255 
1256 
1257 
1258  hMCEtaInAccPt[iCut] = new TH1F("MC_EtaDalitzInAcc_Pt","MC_EtaDalitzInAcc_Pt",250,0,25);
1259  hMCEtaInAccPt[iCut]->Sumw2();
1260  fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
1261 
1262  hMCChiCPt[iCut] = new TH1F("MC_ChiC_Pt","MC_ChiC_Pt",250,0,25);
1263  fMCList[iCut]->Add(hMCChiCPt[iCut]);
1264 
1265  hMCChiCInAccPt[iCut] = new TH1F("MC_ChiCInAcc_Pt","MC_ChiCInAcc_Pt",250,0,25);
1266  fMCList[iCut]->Add(hMCChiCInAccPt[iCut]);
1267 
1268  if ( fDoMesonQA > 0 ) {
1269  hMCPi0EposEnegInvMassPt[iCut] = new TH2F("MC_Pi0EposEneg_InvMassPt","MC_Pi0EposEneg_InvMassPt",100,0.0,0.5,100,0.,10.);
1270  fMCList[iCut]->Add(hMCPi0EposEnegInvMassPt[iCut]);
1271  hMCEtaEposEnegInvMassPt[iCut] = new TH2F("MC_EtaEposEneg_InvMassPt","MC_EtaEposEneg_InvMassPt",140,0.,0.7,100,0.,10.);
1272  fMCList[iCut]->Add(hMCEtaEposEnegInvMassPt[iCut]);
1273  }
1274 
1275  fTrueList[iCut] = new TList();
1276  fTrueList[iCut]->SetName(Form("%s_%s_%s_%s True histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
1277  fTrueList[iCut]->SetOwner(kTRUE);
1278  fCutFolder[iCut]->Add(fTrueList[iCut]);
1279 
1280  if ( fDoMesonQA > 0 ) {
1281 
1282  hESDEposEnegTruePi0DalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_InvMassPt","ESD_EposEneg_TruePi0Dalitz_InvMassPt",nBinsMassPair,xMinMassPair,xMaxMassPair,100,0.,10.);
1283  if(fDoHistoDalitzMassLog)SetLogBinningXTH2(hESDEposEnegTruePi0DalitzInvMassPt[iCut]);
1284  fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzInvMassPt[iCut]);
1285 
1286  hESDEposEnegTruePrimPi0DalitzInvMass[iCut] = new TH1F("ESD_EposEneg_TruePrimPi0Dalitz_InvMass","ESD_EposEneg_TruePrimPi0Dalitz_InvMass",nBinsMassPair,xMinMassPair,xMaxMassPair);
1287  fTrueList[iCut]->Add(hESDEposEnegTruePrimPi0DalitzInvMass[iCut]);
1288 
1289  hESDEposEnegTrueInvMassPt[iCut] = new TH2F("ESD_EposEneg_True_InvMassPt","ESD_EposEneg_True_InvMassPt",nBinsMassPair,xMinMassPair,xMaxMassPair,100,0.,10.);
1290  if(fDoHistoDalitzMassLog)SetLogBinningXTH2(hESDEposEnegTrueInvMassPt[iCut]);
1291  fTrueList[iCut]->Add(hESDEposEnegTrueInvMassPt[iCut]);
1292 
1293  hESDEposEnegTrueMotherInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueMother_InvMassPt","ESD_EposEneg_TrueMother_InvMassPt",nBinsMassPair,xMinMassPair,xMaxMassPair,100,0.,10.);
1294  if(fDoHistoDalitzMassLog)SetLogBinningXTH2(hESDEposEnegTrueMotherInvMassPt[iCut]);
1295  fTrueList[iCut]->Add(hESDEposEnegTrueMotherInvMassPt[iCut]);
1296 
1297  hESDEposEnegTrueEtaDalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueEtaDalitz_InvMassPt","ESD_EposEneg_TrueEtaDalitz_InvMassPt",nBinsMassPair,xMinMassPair,xMaxMassPair,100,0.,10.);
1298  if(fDoHistoDalitzMassLog)SetLogBinningXTH2(hESDEposEnegTrueEtaDalitzInvMassPt[iCut]);
1299  fTrueList[iCut]->Add(hESDEposEnegTrueEtaDalitzInvMassPt[iCut]);
1300 
1301  hESDEposEnegTruePrimEtaDalitzInvMass[iCut] = new TH1F("ESD_EposEneg_TruePrimEtaDalitz_InvMass","ESD_EposEneg_TruePrimEtaDalitz_InvMass",nBinsMassPair,xMinMassPair,xMaxMassPair);
1302  //if(fDoHistoDalitzMassLog)SetLogBinningXTH2(hESDEposEnegTruePrimEtaDalitzInvMass[iCut]);
1303  fTrueList[iCut]->Add(hESDEposEnegTruePrimEtaDalitzInvMass[iCut]);
1304 
1305  hESDEposEnegTruePhotonInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePhoton_InvMassPt","ESD_EposEneg_TruePhoton_InvMassPt",nBinsMassPair,xMinMassPair,xMaxMassPair,100,0.,10.);
1306  if(fDoHistoDalitzMassLog) SetLogBinningXTH2(hESDEposEnegTruePhotonInvMassPt[iCut]);
1307  fTrueList[iCut]->Add(hESDEposEnegTruePhotonInvMassPt[iCut]);
1308 
1309  hESDEposEnegTrueJPsiInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueJPsi_InvMassPt","ESD_EposEneg_TrueJPsi_InvMassPt",1000,0.,5.,100,0.,10.);
1310  fTrueList[iCut]->Add(hESDEposEnegTrueJPsiInvMassPt[iCut]);
1311 
1312 
1313  hESDEposEnegTruePi0DalitzPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_PsiPair_DPhi","ESD_EposEneg_TruePi0Dalitz_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
1314  fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzPsiPairDPhi[iCut]);
1315 
1316  hESDEposEnegTruePi0DalitzPsiPairMC[iCut] = new TH1F("ESD_EposEneg_TruePi0Dalitz_PsiPairMC","ESD_EposEneg_TruePi0Dalitz_PsiPairMC", 100, -1.0,1.0);
1317  fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzPsiPairMC[iCut]);
1318 
1319  hESDEposEnegTruePi0DalitzPsiPairEta[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_PsiPair_Eta","ESD_EposEneg_TruePi0Dalitz_PsiPair_Eta", 100, -1.0,1.0,600,-1.5,1.5 );
1320  fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzPsiPairEta[iCut]);
1321 
1322  hESDEposEnegTruePi0DalitzDPhiEta[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_DPhi_Eta","ESD_EposEneg_TruePi0Dalitz_DPhi_Eta", 100, -1.0,1.0,600,-1.5,1.5 );
1323  fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzDPhiEta[iCut]);
1324 
1325 
1326  hESDEposEnegTrueEtaDalitzPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TrueEtaDalitz_PsiPair_DPhi","ESD_EposEneg_TrueEtaDalitz_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
1327  fTrueList[iCut]->Add(hESDEposEnegTrueEtaDalitzPsiPairDPhi[iCut]);
1328 
1329 
1330  hESDEposEnegTruePhotonPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TruePhoton_PsiPair_DPhi","ESD_EposEneg_TruePhoton_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
1331  fTrueList[iCut]->Add(hESDEposEnegTruePhotonPsiPairDPhi[iCut]);
1332 
1333  hESDEposEnegTruePhotonPsiPairDPhiPtCut[iCut] = new TH2F("ESD_EposEneg_TruePhoton_PsiPair_DPhi_PtCut","ESD_EposEneg_TruePhoton_PsiPair_DPhi_PtCut", 100, -1.0,1.0,100,-1.0,1.0 );
1334  fTrueList[iCut]->Add(hESDEposEnegTruePhotonPsiPairDPhiPtCut[iCut]);
1335 
1336 
1337  hESDTrueConvGammaR[iCut] = new TH1F("ESD_TrueConvGamma_R","ESD_TrueConvGamma_R",800,0,200);
1338  fTrueList[iCut]->Add(hESDTrueConvGammaR[iCut]);
1339 
1340  hESDTrueConvGammaRMC[iCut] = new TH1F("ESD_TrueConvGamma_R_MC","ESD_TrueConvGamma_R_MC",800,0,200);
1341  fTrueList[iCut]->Add(hESDTrueConvGammaRMC[iCut]);
1342 
1343  hESDTrueConvGammaPtMC[iCut] = new TH1F("ESD_TrueConvGamma_Pt_MC","ESD_TrueConvGamma_Pt_MC",250,0,25);
1344  fTrueList[iCut]->Add(hESDTrueConvGammaPtMC[iCut]);
1345 
1346  hESDTruePi0EposEnegInvMassPi0Pt[iCut] = new TH2F("ESD_TruePi0EposEnegInvMass_Pi0Pt","ESD_TruePi0EposEnegInvMass_Pi0Pt",100,0.0,0.5,100,0.,10.);
1347  fTrueList[iCut]->Add(hESDTruePi0EposEnegInvMassPi0Pt[iCut]);
1348 
1349 
1350  hESDTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1351  SetLogBinningXTH2(hESDTruePi0PtY[iCut]);
1352  fTrueList[iCut]->Add(hESDTruePi0PtY[iCut]);
1353 
1354  hESDTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",150,0.03,15.,100,0,1);
1355  SetLogBinningXTH2(hESDTruePi0PtAlpha[iCut]);
1356  fTrueList[iCut]->Add(hESDTruePi0PtAlpha[iCut]);
1357 
1358  hESDTruePi0PtOpenAngle[iCut] = new TH2F("ESD_TruePi0_Pt_OpenAngle","ESD_TruePi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1359  SetLogBinningXTH2(hESDTruePi0PtOpenAngle[iCut]);
1360  fTrueList[iCut]->Add(hESDTruePi0PtOpenAngle[iCut]);
1361 
1362  if(fDoMesonQA > 1 ) {
1363  hESDTruePi0DalitzConvGammaR[iCut] = new TH1F("ESD_TruePi0DalitzConvGamma_R","hESDTruePi0DalitzConvGammaR",800,0,200);
1364  fTrueList[iCut]->Add(hESDTruePi0DalitzConvGammaR[iCut]);
1365 
1366 
1367  const Int_t nDimDalPlot = 2;
1368  Int_t nBinsDalPlot[nDimDalPlot] = { 4000, 4000};
1369  Double_t xMinDalPlot[nDimDalPlot] = { 0, 0};
1370  Double_t xMaxDalPlot[nDimDalPlot] = { 4.0, 4.0};
1371 
1372 
1373  sESDTruePi0DalitzPlot[iCut] = new THnSparseF("ESD_TruePi0Dalitz_DalitzPlot","ESD_TruePi0Dalitz_DalitzPlot",nDimDalPlot,nBinsDalPlot,xMinDalPlot,xMaxDalPlot);
1374  fQAFolder[iCut]->Add(sESDTruePi0DalitzPlot[iCut]);
1375 
1376  sMCPi0DalitzPlot[iCut] = new THnSparseF("MC_Pi0Dalitz_DalitzPlot","MC_Pi0Dalitz_DalitzPlot",nDimDalPlot,nBinsDalPlot,xMinDalPlot,xMaxDalPlot);
1377  fQAFolder[iCut]->Add(sMCPi0DalitzPlot[iCut]);
1378 
1379  }
1380 
1381  }
1382 
1383  hESDTruePositronPt[iCut] = new TH1F("ESD_TruePositron_Pt","ESD_TruePositron_Pt",1000,0,25);
1384  fTrueList[iCut]->Add(hESDTruePositronPt[iCut]);
1385 
1386  hESDTrueElectronPt[iCut] = new TH1F("ESD_TrueElectron_Pt","ESD_TrueElectron_Pt",1000,0,25);
1387  fTrueList[iCut]->Add(hESDTrueElectronPt[iCut]);
1388 
1389  hESDTrueSecPositronPt[iCut] = new TH1F("ESD_TrueSecPositron_Pt","ESD_TrueSecPositron_Pt",1000,0,25);
1390  fTrueList[iCut]->Add(hESDTrueSecPositronPt[iCut]);
1391 
1392  hESDTrueSecElectronPt[iCut] = new TH1F("ESD_TrueSecElectron_Pt","ESD_TrueSecElectron_Pt",1000,0,25);
1393  fTrueList[iCut]->Add(hESDTrueSecElectronPt[iCut]);
1394 
1395  hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
1396  fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
1397 
1398  fHistoDoubleCountTrueConvGammaRPt[iCut] = new TH2F("ESD_TrueDoubleCountConvGamma_R_Pt","ESD_TrueDoubleCountConvGamma_R_Pt",800,0,200,300,0,30);
1399  fTrueList[iCut]->Add(fHistoDoubleCountTrueConvGammaRPt[iCut]);
1400 
1401  hESDTrueSecConvGammaPt[iCut] = new TH1F("ESD_TrueSecConvGamma_Pt","ESD_TrueSecConvGamma_Pt",250,0,25);
1402  fTrueList[iCut]->Add(hESDTrueSecConvGammaPt[iCut]);
1403 
1404  hESDTruePi0DalitzConvGammaPt[iCut] = new TH1F("ESD_TruePi0DalitzConvGamma_Pt","ESD_TruePi0DalitzConvGamma_Pt",250,0,25);
1405  fTrueList[iCut]->Add(hESDTruePi0DalitzConvGammaPt[iCut]);
1406 
1407 
1408 
1409  fHistoDoubleCountTruePi0InvMassPt[iCut] = new TH2F("ESD_TrueDoubleCountPi0_InvMass_Pt","ESD_TrueDoubleCountPi0_InvMass_Pt",800,0,0.8,300,0,30);
1410  fTrueList[iCut]->Add(fHistoDoubleCountTruePi0InvMassPt[iCut]);
1411  fHistoDoubleCountTrueEtaInvMassPt[iCut] = new TH2F("ESD_TrueDoubleCountEta_InvMass_Pt","ESD_TrueDoubleCountEta_InvMass_Pt",800,0,0.8,300,0,30);
1412  fTrueList[iCut]->Add(fHistoDoubleCountTrueEtaInvMassPt[iCut]);
1413 
1414  hESDTruePi0DalitzElectronPt[iCut] = new TH1F("ESD_TruePi0DalitzElectron_Pt","ESD_TruePi0DalitzElectron_Pt",1000,0,25);
1415  fTrueList[iCut]->Add(hESDTruePi0DalitzElectronPt[iCut]);
1416 
1417  hESDTruePi0DalitzElectronPtMB[iCut] = new TH1F("ESD_TruePi0DalitzElectron_Pt_MB","ESD_TruePi0DalitzElectron_Pt_MB",1000,0,25);
1418  fTrueList[iCut]->Add(hESDTruePi0DalitzElectronPtMB[iCut]);
1419 
1420  hESDTruePi0DalitzPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzPositron_Pt","ESD_TruePi0DalitzPositron_Pt",1000,0,25);
1421  fTrueList[iCut]->Add(hESDTruePi0DalitzPositronPt[iCut]);
1422 
1423  hESDTruePi0DalitzPositronPtMB[iCut] = new TH1F("ESD_TruePi0DalitzPositron_Pt_MB","ESD_TruePi0DalitzPositron_Pt_MB",1000,0,25);
1424  fTrueList[iCut]->Add(hESDTruePi0DalitzPositronPtMB[iCut]);
1425 
1426 
1427  hESDTruePi0DalitzSecConvGammaPt[iCut] = new TH1F("ESD_TruePi0DalitzSecConvGamma_Pt","ESD_TruePi0DalitzSecConvGamma_Pt",250,0,25);
1428  fTrueList[iCut]->Add(hESDTruePi0DalitzSecConvGammaPt[iCut]);
1429 
1430  hESDTruePi0DalitzSecElectronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecElectron_Pt","ESD_TruePi0DalitzSecElectron_Pt",1000,0,25);
1431  fTrueList[iCut]->Add(hESDTruePi0DalitzSecElectronPt[iCut]);
1432 
1433  hESDTruePi0DalitzSecPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecPositron_Pt","ESD_TruePi0DalitzSecPositron_Pt",1000,0,25);
1434  fTrueList[iCut]->Add(hESDTruePi0DalitzSecPositronPt[iCut]);
1435 
1436  if( fDoChicAnalysis) {
1437  hESDTrueMotherChiCInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiC_InvMass_Pt","ESD_TrueMotherChiC_InvMass_Pt",4000,0,4,250,0,25);
1438  fTrueList[iCut]->Add(hESDTrueMotherChiCInvMassPt[iCut]);
1439  hESDTrueMotherChiCDiffInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiCDiff_InvMass_Pt","ESD_TrueMotherChiCDiff_InvMass_Pt",2000,0,2,250,0,25);
1440  fTrueList[iCut]->Add(hESDTrueMotherChiCDiffInvMassPt[iCut]);
1441  }
1442 
1443  hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
1444  hESDTrueMotherInvMassPt[iCut]->Sumw2();
1445  fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
1446 
1447  hESDTrueMotherW0WeightsInvMassPt[iCut] = new TH2F("ESD_TrueMotherW0Weights_InvMass_Pt","ESD_TrueMotherW0Weights_InvMass_Pt",800,0,0.8,250,0,25);
1448  hESDTrueMotherW0WeightsInvMassPt[iCut]->Sumw2();
1449  fTrueList[iCut]->Add(hESDTrueMotherW0WeightsInvMassPt[iCut]);
1450 
1451 
1452 
1453  hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueMother_Dalitz_InvMass_Pt","ESD_TrueMother_Dalitz_InvMass_Pt",800,0,0.8,250,0,25);
1454  hESDTrueMotherDalitzInvMassPt[iCut]->Sumw2();
1455  fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
1456 
1457 
1458 
1459 
1460 
1461  hESDTrueMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueMotherPi0GG_InvMass_Pt","ESD_TrueMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
1462  hESDTrueMotherPi0GGInvMassPt[iCut]->Sumw2();
1463  fTrueList[iCut]->Add(hESDTrueMotherPi0GGInvMassPt[iCut]);
1464 
1465  hESDTrueMotherPi0GGW0WeightsInvMassPt[iCut] = new TH2F("ESD_TrueMotherPi0GGW0Weights_InvMass_Pt","ESD_TrueMotherPi0GGW0Weights_InvMass_Pt",800,0,0.8,250,0,25);
1466  hESDTrueMotherPi0GGW0WeightsInvMassPt[iCut]->Sumw2();
1467  fTrueList[iCut]->Add(hESDTrueMotherPi0GGW0WeightsInvMassPt[iCut]);
1468 
1469  hESDTruePrimaryMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMotherPi0GG_InvMass_Pt","ESD_TruePrimaryMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
1470  hESDTruePrimaryMotherPi0GGInvMassPt[iCut]->Sumw2();
1471  fTrueList[iCut]->Add(hESDTruePrimaryMotherPi0GGInvMassPt[iCut]);
1472 
1473  hESDTrueSecondaryMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryMotherPi0GG_InvMass_Pt","ESD_TrueSecondaryMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
1474  hESDTrueSecondaryMotherPi0GGInvMassPt[iCut]->Sumw2();
1475  fTrueList[iCut]->Add(hESDTrueSecondaryMotherPi0GGInvMassPt[iCut]);
1476 
1477  hESDTruePrimaryPi0DalitzESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt","ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt",250,0,25,250,0,25);
1478  hESDTruePrimaryPi0DalitzESDPtMCPt[iCut]->Sumw2();
1479  fTrueList[iCut]->Add(hESDTruePrimaryPi0DalitzESDPtMCPt[iCut]);
1480  hESDTruePrimaryMotherInvMassMCPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_MCPt","ESD_TrueDalitzPrimaryMother_InvMass_MCPt",800,0,0.8,250,0,25);
1481  hESDTruePrimaryMotherInvMassMCPt[iCut]->Sumw2();
1482  fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassMCPt[iCut]);
1483  hESDTruePrimaryMotherInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_Pt","ESD_TruePrimaryMother_InvMass_Pt",800,0,0.8,250,0,25);
1484  hESDTruePrimaryMotherInvMassPt[iCut]->Sumw2();
1485  fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassPt[iCut]);
1486  hESDTruePrimaryMotherW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMotherW0Weighting_InvMass_Pt","ESD_TruePrimaryMotherW0Weighting_InvMass_Pt",800,0,0.8,250,0,25);
1487  hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]->Sumw2();
1488  fTrueList[iCut]->Add(hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]);
1489 
1490  hESDTrueSecondaryMotherInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMother_InvMass_Pt","ESD_TrueDalitzSecondaryMother_InvMass_Pt",800,0,0.8,250,0,25);
1491  hESDTrueSecondaryMotherInvMassPt[iCut]->Sumw2();
1492  fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
1493  // hESDTrueSecondaryMotherFromK0sInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt",1000,0,1,250,0,25);
1494  // fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
1495  hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckGG_InvMass_Pt","ESD_TrueDalitzBckGG_InvMass_Pt",800,0,0.8,250,0,25);
1496  fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
1497  hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckCont_InvMass_Pt","ESD_TrueDalitzBckCont_InvMass_Pt",800,0,0.8,250,0,25);
1498  fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
1499  // hESDTrueMotherGGInvMassPt[iCut] = new TH2F("ESD_TrueGammaGamma_InvMass_Pt","ESD_TrueGammaGamma_InvMass_Pt",1000,0,1,250,0,25);
1500  // fTrueList[iCut]->Add(hESDTrueMotherGGInvMassPt[iCut]);
1501 
1502  }
1503  }
1504 
1505  fVectorDoubleCountTruePi0s.clear();
1506  fVectorDoubleCountTrueEtas.clear();
1507  fVectorDoubleCountTrueConvGammas.clear();
1508 
1509  fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask(fV0ReaderName.Data());
1510  if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1511 
1512 
1513  if(fV0Reader)
1514  if((AliConvEventCuts*)fV0Reader->GetEventCuts())
1515  if(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms())
1516  fOutputContainer->Add(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms());
1517 
1518  if(fV0Reader)
1519  if((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())
1520  if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1521  fOutputContainer->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1522 
1523  if(fV0Reader && fV0Reader->GetProduceV0FindingEfficiency())
1524  if (fV0Reader->GetV0FindingEfficiencyHistograms())
1525  fOutputContainer->Add(fV0Reader->GetV0FindingEfficiencyHistograms());
1526 
1527 
1528 
1529 
1530 
1531  fElecSelector=(AliDalitzElectronSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("ElectronSelector");
1532  if(!fElecSelector){printf("Error: No ElectronSelector");return;} // GetV0Reader
1533 
1534  if( fElecSelector ){
1535  if ( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() ){
1536  fOutputContainer->Add( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() );
1537  }
1538  }
1539 
1540  for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1541 
1542  if( fCutElectronArray ){
1543  if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() ) {
1544  fCutFolder[iCut]->Add( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() );
1545  }
1546  }
1547 
1548  if( fCutMesonArray ) {
1549  if( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms() ) {
1550  fCutFolder[iCut]->Add( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms());
1551  }
1552  }
1553 
1554  if( fCutGammaArray ) {
1555  if( ((AliConversionPhotonCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() ) {
1556  fCutFolder[iCut]->Add( ((AliConversionPhotonCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() );
1557  }
1558  }
1559 
1560  if( fCutEventArray )
1561  if( ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutHistograms()){
1562  fCutFolder[iCut]->Add(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutHistograms());
1563  }
1564  }
1565 
1566  PostData(1, fOutputContainer);
1567 
1568 }
1569 
1570 //______________________________________________________________________
1571 void AliAnalysisTaskGammaConvDalitzV1::UserExec(Option_t *)
1572 {
1573 
1574  //
1575  // Execute analysis for current event
1576  //
1577 
1578  fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask(fV0ReaderName.Data());
1579  if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1580 
1581 
1582  Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
1583 
1584  // Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1585  if(eventQuality == 2 || eventQuality == 3){
1586  for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1587  hNEvents[iCut]->Fill(eventQuality);
1588  }
1589  return;
1590  }
1591 
1592  fElecSelector=(AliDalitzElectronSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("ElectronSelector");
1593  if(!fElecSelector){printf("Error: No ElectronSelector");return;} // GetV0Reader
1594 
1595 
1596  if(fIsMC) fMCEvent = MCEvent();
1597  fESDEvent = (AliESDEvent*)InputEvent();
1598  fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
1599 
1600  AliEventplane *EventPlane = fInputEvent->GetEventplane();
1601  if(fIsHeavyIon == 1)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
1602  else fEventPlaneAngle=0.0;
1603 
1604 
1605  fSelectorElectronIndex = fElecSelector->GetReconstructedElectronsIndex(); // Electrons from default Cut
1606  fSelectorPositronIndex = fElecSelector->GetReconstructedPositronsIndex(); // Positrons from default Cut
1607 
1608  CountESDTracks(); // Estimate Event Multiplicity
1609  fNumberOfESDTracks = fV0Reader->GetNumberOfPrimaryTracks();
1610  //AddTaskContainers(); //Add conatiner
1611 
1612  for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1613  fiCut = iCut;
1614  fNVirtualGammas = 0;
1615 
1616  Int_t eventNotAccepted =
1617  ((AliConvEventCuts*)fCutEventArray->At(iCut))
1618  ->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon,kFALSE);
1619 
1620 
1621  //Int_t eventNotAccepted = ((AliConvEventCuts*)fCutGammaArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon,kFALSE);
1622 
1623  if(eventNotAccepted){
1624  // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1625  hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1626  continue;
1627  }
1628 
1629  if(eventQuality != 0){// Event Not Accepted
1630  // cout << "event rejected due to: " <<eventQuality << endl;
1631  hNEvents[iCut]->Fill(eventQuality);
1632  continue;
1633  }
1634 
1635  hNEvents[iCut]->Fill(eventQuality);
1636  hNGoodESDTracks[iCut]->Fill(fNumberOfESDTracks);
1637 
1638  if(((AliConvEventCuts*)fCutEventArray->At(iCut))->IsHeavyIon() == 2) hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
1639  else hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1640 
1641  if(fMCEvent){ // Process MC Particle
1642  if(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetSignalRejection() != 0){
1643  ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetNotRejectedParticles( ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetSignalRejection(),
1644  ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetAcceptedHeader(),
1645  fMCEvent);
1646  }
1647  ProcessMCParticles();
1648  }
1649 
1650  ProcessPhotonCandidates(); // Process this cuts gammas
1651  ProcessElectronCandidates(); // Process this cuts gammas
1652 
1653  if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1654 
1655  fUnsmearedPx = new Double_t[fGoodGammas->GetEntries()]; // Store unsmeared Momenta
1656  fUnsmearedPy = new Double_t[fGoodGammas->GetEntries()];
1657  fUnsmearedPz = new Double_t[fGoodGammas->GetEntries()];
1658  fUnsmearedE = new Double_t[fGoodGammas->GetEntries()];
1659 
1660  for(Int_t gamma=0;gamma<fGoodGammas->GetEntries();gamma++){ // Smear the AODPhotons in MC
1661  fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Px();
1662  fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Py();
1663  fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Pz();
1664  fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->E();
1665  ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(gamma)));
1666  }
1667  }
1668 
1669  if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetUseVPhotonMCPmearing() && ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1670  // cout<<"Entro virtual photon smearing"<<endl;
1671  fUnsmearedVPx = new Double_t[fGoodVirtualGammas->GetEntries()]; // Store unsmeared Momenta
1672  fUnsmearedVPy = new Double_t[fGoodVirtualGammas->GetEntries()];
1673  fUnsmearedVPz = new Double_t[fGoodVirtualGammas->GetEntries()];
1674  fUnsmearedVE = new Double_t[fGoodVirtualGammas->GetEntries()];
1675 
1676  for(Int_t Vgamma=0;Vgamma<fGoodVirtualGammas->GetEntries();Vgamma++){ // Smear the AODPhotons in MC
1677  fUnsmearedVPx[Vgamma] = ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->Px();
1678  fUnsmearedVPy[Vgamma] = ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->Py();
1679  fUnsmearedVPz[Vgamma] = ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->Pz();
1680  fUnsmearedVE[Vgamma] = ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->E();
1681  ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->SmearVirtualPhoton(dynamic_cast<AliAODConversionPhoton*>(fGoodVirtualGammas->At(Vgamma)));
1682  }
1683  }
1684 
1685  ProcessVirtualGammasCandidates();
1686  CalculatePi0DalitzCandidates();
1687 
1688  if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->DoBGCalculation()){
1689  if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->BackgroundHandlerType() == 0){
1690 
1691 
1692  CalculateBackground();
1693  UpdateEventByEventData();
1694 
1695  }
1696  }
1697 
1698 
1699  if ( fDoMesonQA > 0) {
1700  hNGoodESDTracksVsNGoodGammas[iCut]->Fill(fNumberOfESDTrackskBoth,fGoodGammas->GetEntries());
1701  hNGoodESDTracksVsNGoodVGammas[iCut]->Fill(fNumberOfESDTrackskBoth,fNVirtualGammas);
1702  fHistoSPDClusterTrackletBackground[iCut]->Fill(fInputEvent->GetMultiplicity()->GetNumberOfTracklets(),(fInputEvent->GetNumberOfITSClusters(0)+fInputEvent->GetNumberOfITSClusters(1)));
1703  }
1704 
1705 
1706  if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1707 
1708  for(Int_t gamma=0;gamma<fGoodGammas->GetEntries();gamma++){ // Smear the AODPhotons in MC
1709  ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1710  ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1711  ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1712  ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetE(fUnsmearedE[gamma]);
1713  }
1714  delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1715  delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1716  delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1717  delete[] fUnsmearedE; fUnsmearedE = 0x0;
1718  }
1719 
1720  if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetUseVPhotonMCPmearing() && ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1721 
1722  for(Int_t Vgamma=0;Vgamma<fGoodVirtualGammas->GetEntries();Vgamma++){ // Smear the AODPhotons in MC
1723  ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->SetPx(fUnsmearedVPx[Vgamma]); // Reset Unsmeared Momenta
1724  ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->SetPy(fUnsmearedVPy[Vgamma]);
1725  ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->SetPz(fUnsmearedVPz[Vgamma]);
1726  ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->SetE(fUnsmearedVE[Vgamma]);
1727  }
1728  delete[] fUnsmearedVPx; fUnsmearedVPx = 0x0;
1729  delete[] fUnsmearedVPy; fUnsmearedVPy = 0x0;
1730  delete[] fUnsmearedVPz; fUnsmearedVPz = 0x0;
1731  delete[] fUnsmearedVE; fUnsmearedVE = 0x0;
1732  }
1733  fVectorDoubleCountTruePi0s.clear();
1734  fVectorDoubleCountTrueEtas.clear();
1735  fVectorDoubleCountTrueConvGammas.clear();
1736  fGoodGammas->Clear(); // delete this cuts good gammas
1737  fGoodVirtualGammas->Clear(); // delete this cuts good gammas
1738  }
1739 
1740  fSelectorElectronIndex.clear();
1741  fSelectorPositronIndex.clear();
1742 
1743  PostData( 1, fOutputContainer );
1744 }
1745 
1746 Bool_t AliAnalysisTaskGammaConvDalitzV1::Notify()
1747 {
1748  for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1749  if (((AliConvEventCuts*)fCutEventArray->At(iCut))->GetPeriodEnum() == AliConvEventCuts::kNoPeriod && ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetPeriodEnum() != AliConvEventCuts::kNoPeriod){
1750  ((AliConvEventCuts*)fCutEventArray->At(iCut))->SetPeriodEnumExplicit(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetPeriodEnum());
1751  } else if (((AliConvEventCuts*)fCutEventArray->At(iCut))->GetPeriodEnum() == AliConvEventCuts::kNoPeriod ){
1752  ((AliConvEventCuts*)fCutEventArray->At(iCut))->SetPeriodEnum(fV0Reader->GetPeriodName());
1753  }
1754 
1755 
1756  if( !((AliConvEventCuts*)fCutEventArray->At(iCut))->GetDoEtaShift() ){
1757 
1758  hEtaShift[iCut]->Fill(0.,0.);
1759  continue; // No Eta Shift requested, continue
1760  }
1761 
1762 
1763  if( ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1764  ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCorrectEtaShiftFromPeriod();
1765  ((AliConvEventCuts*)fCutEventArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1766  hEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetEtaShift()));
1767  continue;
1768  } else {
1769  printf(" Gamma Conversion Dalitz Task %s :: Eta Shift Manually Set to %f \n\n",
1770  (((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber()).Data(),((AliConvEventCuts*)fCutEventArray->At(iCut))->GetEtaShift());
1771  ((AliConvEventCuts*)fCutEventArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1772  hEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetEtaShift()));
1773  }
1774  }
1775 
1776  return kTRUE;
1777 }
1778 
1779 //________________________________________________________________________
1780 void AliAnalysisTaskGammaConvDalitzV1::Terminate(const Option_t *)
1781 {
1783 }
1784 
1785 //________________________________________________________________________
1786 void AliAnalysisTaskGammaConvDalitzV1::ProcessPhotonCandidates()
1787 {
1788  Int_t nV0 = 0;
1789  TList *GoodGammasStepOne = new TList();
1790  TList *GoodGammasStepTwo = new TList();
1791  // Loop over Photon Candidates allocated by ReaderV1
1792 
1793  for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1794  AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1795  if(!PhotonCandidate) continue;
1796  fIsFromMBHeader = kTRUE;
1797  if( fMCEvent && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0 ){
1798  Int_t isPosFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCEvent, fInputEvent);
1799  if(isPosFromMBHeader == 0 && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 3) continue;
1800  Int_t isNegFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCEvent,fInputEvent);
1801  if(isNegFromMBHeader == 0 && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 3) continue;
1802  if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1803  }
1804 
1805  if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fESDEvent)) continue;
1806 
1807  if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut() &&
1808  !((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // if no post reader loop is required add to events good gammas
1809 
1810  fGoodGammas->Add(PhotonCandidate);
1811  if(fIsFromMBHeader){
1812  hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1813  hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1814  if( fDoMesonQA > 1 ) {
1815 
1816  Double_t sparesFillZR[2] = {PhotonCandidate->GetConversionZ(),PhotonCandidate->GetConversionRadius()};
1817  sESDConvGammaZR[fiCut]->Fill(sparesFillZR);
1818  Double_t sparesFillXY[2] = {PhotonCandidate->GetConversionX(),PhotonCandidate->GetConversionY()};
1819  sESDConvGammaXY[fiCut]->Fill(sparesFillXY);
1820 
1821 
1822 
1823  }
1824  }
1825  if(fMCEvent){
1826  ProcessTruePhotonCandidates(PhotonCandidate);
1827  }
1828  } else if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1829  ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1830  nV0++;
1831  GoodGammasStepOne->Add(PhotonCandidate);
1832  } else if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut() &&
1833  ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1834  GoodGammasStepTwo->Add(PhotonCandidate);
1835  }
1836  }
1837 
1838 
1839  if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut()){
1840  for(Int_t i = 0;i<GoodGammasStepOne->GetEntries();i++){
1841  AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GoodGammasStepOne->At(i);
1842  if(!PhotonCandidate) continue;
1843  fIsFromMBHeader = kTRUE;
1844  if(fMCEvent && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0){
1845  Int_t isPosFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCEvent,fInputEvent);
1846  Int_t isNegFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCEvent,fInputEvent);
1847  if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1848  }
1849 
1850  if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GoodGammasStepOne->GetEntries())) continue;
1851  if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1852  fGoodGammas->Add(PhotonCandidate);
1853 
1854  if(fIsFromMBHeader){
1855  hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1856  hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1857  if( fDoMesonQA > 1 ){
1858  Double_t sparesFillZR[2] = {PhotonCandidate->GetConversionZ(),PhotonCandidate->GetConversionRadius()};
1859  sESDConvGammaZR[fiCut]->Fill(sparesFillZR);
1860  Double_t sparesFillXY[2] = {PhotonCandidate->GetConversionX(),PhotonCandidate->GetConversionY()};
1861  sESDConvGammaXY[fiCut]->Fill(sparesFillXY);
1862  }
1863  }
1864 
1865  if(fMCEvent){
1866  ProcessTruePhotonCandidates(PhotonCandidate);
1867  }
1868  } else GoodGammasStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1869  }
1870  }
1871  if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){
1872  for(Int_t i = 0;i<GoodGammasStepTwo->GetEntries();i++){
1873  AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GoodGammasStepTwo->At(i);
1874  if(!PhotonCandidate) continue;
1875  if(fMCEvent && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0){
1876  Int_t isPosFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCEvent,fInputEvent);
1877  Int_t isNegFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCEvent,fInputEvent);
1878  if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1879  }
1880  if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GoodGammasStepTwo,i)) continue;
1881  fGoodGammas->Add(PhotonCandidate); // Add gamma to current cut TList
1882 
1883  if(fIsFromMBHeader){
1884  hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt()); // Differences to old V0Reader in p_t due to conversion KF->TLorentzVector
1885  hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1886  if(fDoMesonQA > 1 ){
1887  Double_t sparesFillZR[2] = {PhotonCandidate->GetConversionZ(),PhotonCandidate->GetConversionRadius()};
1888  sESDConvGammaZR[fiCut]->Fill(sparesFillZR);
1889  Double_t sparesFillXY[2] = {PhotonCandidate->GetConversionX(),PhotonCandidate->GetConversionY()};
1890  sESDConvGammaXY[fiCut]->Fill(sparesFillXY);
1891  }
1892  }
1893 
1894  if(fMCEvent){
1895  ProcessTruePhotonCandidates(PhotonCandidate);
1896  }
1897  }
1898  }
1899 
1900  delete GoodGammasStepOne;
1901  GoodGammasStepOne = 0x0;
1902  delete GoodGammasStepTwo;
1903  GoodGammasStepTwo = 0x0;
1904 }
1905 
1906 //________________________________________________________________________
1907 void AliAnalysisTaskGammaConvDalitzV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1908 {
1909  // Process True Photons
1910  TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCEvent);
1911  TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCEvent);
1912 
1913  if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1914  if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){ // Not Same Mother == Combinatorial Bck
1915  return;
1916  } else if (posDaughter->GetMother(0) == -1){
1917  return;
1918  }
1919 
1920  if(TMath::Abs(posDaughter->GetPdgCode())!=11 || TMath::Abs(negDaughter->GetPdgCode())!=11) return; //One Particle is not electron
1921  if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1922  if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1923 
1924  TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCEvent);
1925  if(Photon->GetPdgCode() != 22) return; // Mother is no Photon
1926 
1927  // True Photon
1928 
1929  Int_t labelGamma = TruePhotonCandidate->GetMCParticleLabel(fMCEvent);
1930 
1931  if( labelGamma < fMCEvent->GetNumberOfPrimaries() ){
1932  if( fIsFromMBHeader ){
1933  hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1934  if (CheckVectorForDoubleCount(fVectorDoubleCountTrueConvGammas,posDaughter->GetMother(0))) fHistoDoubleCountTrueConvGammaRPt[fiCut]->Fill(TruePhotonCandidate->GetConversionRadius(),TruePhotonCandidate->Pt());
1935  if( fDoMesonQA > 0 ){
1936  hESDTrueConvGammaR[fiCut]->Fill(TruePhotonCandidate->GetConversionRadius());
1937  hESDTrueConvGammaRMC[fiCut]->Fill( posDaughter->R() );
1938  hESDTrueConvGammaPtMC[fiCut]->Fill( Photon->Pt());
1939  }
1940  }
1941  } else {
1942  if( fIsFromMBHeader){
1943  hESDTrueSecConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1944  }
1945  }
1946 
1947  if( IsPi0DalitzDaughter(labelGamma) == kTRUE ) {
1948  if( labelGamma < fMCEvent->GetNumberOfPrimaries() ) {
1949  if( fIsFromMBHeader ){
1950  hESDTruePi0DalitzConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1951  if( fDoMesonQA > 1 ){
1952  hESDTruePi0DalitzConvGammaR[fiCut]->Fill(TruePhotonCandidate->GetConversionRadius());
1953  }
1954  }
1955  } else {
1956  if( fIsFromMBHeader ) {
1957  hESDTruePi0DalitzSecConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1958  }
1959  }
1960  }
1961 
1962 
1963 }
1964 //________________________________________________________________________
1965 void AliAnalysisTaskGammaConvDalitzV1::ProcessVirtualGammasCandidates(){
1966 
1967  Double_t magField = fInputEvent->GetMagneticField();
1968 
1969 
1970  if( magField < 0.0 ){
1971  magField = 1.0;
1972  }
1973  else {
1974  magField = -1.0;
1975  }
1976 
1977 
1978  for(Int_t virtualGammaIndex=0; virtualGammaIndex < fGoodVirtualGammas->GetEntries(); virtualGammaIndex++ ){
1979  AliAODConversionPhoton *Vgamma=dynamic_cast<AliAODConversionPhoton*>(fGoodVirtualGammas->At(virtualGammaIndex));
1980 
1981  AliESDtrack* positronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
1982  AliESDtrack* electronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
1983 
1984  Bool_t isPhoton = kFALSE;
1985  Bool_t isPi0Dalitz = kFALSE;
1986  Bool_t isEtaDalitz = kFALSE;
1987  Bool_t isJPsi = kFALSE;
1988  Bool_t isTrueEposENeg = kFALSE;
1989  Bool_t isMotherPrimary = kFALSE;
1990 
1991 
1992  if ( fDoMesonQA > 0 ) {
1993 
1994  Double_t psiPair = GetPsiPair(positronVgamma,electronVgamma);
1995  Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronVgamma->GetConstrainedParam()->Phi()-positronVgamma->GetConstrainedParam()->Phi());
1996 
1997 
1998  hESDEposEnegPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1999  hESDEposEnegPsiPairEta[fiCut]->Fill(psiPair,Vgamma->Eta());
2000  hESDEposEnegDPhiEta[fiCut]->Fill(deltaPhi,Vgamma->Eta());
2001 
2002  hESDEposEnegInvMassPt[fiCut]->Fill(Vgamma->M(),Vgamma->Pt());
2003 
2004  if( fMCEvent ) {
2005 
2006  Int_t virtualGammaMCLabel = Vgamma->GetMCParticleLabel(fMCEvent);
2007 
2008  TParticle * negativeMC = 0x0;
2009  TParticle * positiveMC = 0x0;
2010  TParticle * mcVgamma = 0x0;
2011 
2012  if( virtualGammaMCLabel != -1 ){
2013  mcVgamma = (TParticle*)fMCEvent->Particle(virtualGammaMCLabel);
2014  }
2015 
2016  negativeMC = (TParticle*)Vgamma->GetNegativeMCDaughter(fMCEvent);
2017  positiveMC = (TParticle*)Vgamma->GetPositiveMCDaughter(fMCEvent);
2018 
2019 
2020  if( negativeMC && positiveMC ) {
2021  if( positiveMC->GetPdgCode() == ::kPositron && negativeMC->GetPdgCode() == ::kElectron )
2022  isTrueEposENeg = kTRUE;
2023  if( positiveMC->GetMother(0) > -1 && positiveMC->GetMother(0) < fMCEvent->GetNumberOfPrimaries() )
2024  isMotherPrimary = kTRUE;
2025  }
2026  if(mcVgamma){
2027  // Check if it is a true photon
2028  if(mcVgamma->GetPdgCode() == 22){
2029  isPhoton = kTRUE;
2030  } else if(mcVgamma->GetPdgCode() == 443){
2031  isJPsi = kTRUE;
2032  } else if( IsDalitz( mcVgamma ) ){
2033  if ( mcVgamma->GetPdgCode() == 111 ) isPi0Dalitz = kTRUE;
2034  else if( mcVgamma->GetPdgCode() == 221 ) isEtaDalitz = kTRUE;
2035  }
2036  }
2037 
2038  if(isPhoton){
2039  hESDEposEnegTruePhotonInvMassPt[fiCut]->Fill(Vgamma->M(),Vgamma->Pt());
2040  hESDEposEnegTruePhotonPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
2041  if( Vgamma->Pt() > 1.5 ){
2042  hESDEposEnegTruePhotonPsiPairDPhiPtCut[fiCut]->Fill(deltaPhi,psiPair);
2043  }
2044  } else if(isJPsi){
2045  hESDEposEnegTrueJPsiInvMassPt[fiCut]->Fill(Vgamma->M(),Vgamma->Pt());
2046  } else if(isPi0Dalitz){
2047 
2048  Double_t psiPairMC = GetPsiPairMC(positiveMC, negativeMC);
2049  hESDEposEnegTruePi0DalitzPsiPairMC[fiCut]->Fill(psiPairMC);
2050  hESDEposEnegTruePi0DalitzInvMassPt[fiCut]->Fill(Vgamma->M(),Vgamma->Pt());
2051  hESDEposEnegTruePi0DalitzPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
2052  hESDEposEnegTruePi0DalitzPsiPairEta[fiCut]->Fill(psiPair,Vgamma->Eta());
2053  hESDEposEnegTruePi0DalitzDPhiEta[fiCut]->Fill(deltaPhi,Vgamma->Eta());
2054 
2055  if( isMotherPrimary ) hESDEposEnegTruePrimPi0DalitzInvMass[fiCut]->Fill( Vgamma->M() );
2056  } else if(isEtaDalitz){
2057  hESDEposEnegTrueEtaDalitzInvMassPt[fiCut]->Fill(Vgamma->M(),Vgamma->Pt());
2058  hESDEposEnegTrueEtaDalitzPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
2059  if( isMotherPrimary ) hESDEposEnegTruePrimEtaDalitzInvMass[fiCut]->Fill( Vgamma->M() );
2060  } else if ( isTrueEposENeg && mcVgamma ){
2061 
2062  hESDEposEnegTrueMotherInvMassPt[fiCut]->Fill(Vgamma->M(), Vgamma->Pt());
2063  }
2064 
2065  if ( isTrueEposENeg ) hESDEposEnegTrueInvMassPt[fiCut]->Fill(Vgamma->M(), Vgamma->Pt());
2066 
2067  }
2068  }
2069  }
2070 }
2071 
2072 //________________________________________________________________________
2073 void AliAnalysisTaskGammaConvDalitzV1::ProcessElectronCandidates(){
2074 
2075  Double_t magField = fInputEvent->GetMagneticField();
2076 
2077  if( magField < 0.0 ){
2078  magField = 1.0;
2079  } else {
2080  magField = -1.0;
2081  }
2082 
2083  vector<Int_t> lGoodElectronIndexPrev(0);
2084  vector<Int_t> lGoodPositronIndexPrev(0);
2085 
2086  for(UInt_t i = 0; i < fSelectorElectronIndex.size(); i++){
2087 
2088  AliESDtrack* electronCandidate = fESDEvent->GetTrack(fSelectorElectronIndex[i]);
2089 
2090  Bool_t IsMCFromMBHeader = kTRUE;
2091 
2092  if( fMCEvent ) {
2093 
2094  Int_t isMCFromMBHeader = -1;
2095  Int_t labelelectron = TMath::Abs( electronCandidate->GetLabel() );
2096 
2097  if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0) {
2098  isMCFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(labelelectron,fMCEvent,fInputEvent);
2099  if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 3) continue;
2100  }
2101 
2102  if( isMCFromMBHeader != 2 ) IsMCFromMBHeader = kFALSE;
2103  }
2104 
2105  if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(electronCandidate) ) continue;
2106 
2107  lGoodElectronIndexPrev.push_back( fSelectorElectronIndex[i] );
2108  hESDDalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
2109  hESDDalitzElectronPhi[fiCut]->Fill(electronCandidate->Phi());
2110 
2111 
2112  if( fMCEvent ) {
2113 
2114  Int_t labelelectron = TMath::Abs( electronCandidate->GetLabel() );
2115  if( labelelectron < fMCEvent->GetNumberOfTracks() ){
2116  TParticle* electron = fMCEvent->Particle(labelelectron);
2117  if( electron->GetPdgCode() == 11 ){
2118  if( labelelectron < fMCEvent->GetNumberOfPrimaries() ){
2119  hESDTrueElectronPt[fiCut]->Fill(electronCandidate->Pt()); //primary electron
2120  } else {
2121  hESDTrueSecElectronPt[fiCut]->Fill(electronCandidate->Pt()); //secondary electron
2122  }
2123  if( IsPi0DalitzDaughter(labelelectron) == kTRUE && labelelectron < fMCEvent->GetNumberOfPrimaries() ) {
2124  if( electron->GetMother(0) < fMCEvent->GetNumberOfPrimaries() ) {
2125  hESDTruePi0DalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
2126  if( IsMCFromMBHeader == kTRUE ) hESDTruePi0DalitzElectronPtMB[fiCut]->Fill(electronCandidate->Pt());
2127  } else {
2128  hESDTruePi0DalitzSecElectronPt[fiCut]->Fill(electronCandidate->Pt());
2129  }
2130  }
2131  }
2132  }
2133  }
2134  }
2135 
2136  for(UInt_t i = 0; i < fSelectorPositronIndex.size(); i++){
2137 
2138  AliESDtrack* positronCandidate = fESDEvent->GetTrack( fSelectorPositronIndex[i] );
2139 
2140  Bool_t IsMCFromMBHeader = kTRUE;
2141 
2142  if( fMCEvent ) {
2143 
2144  Int_t isMCFromMBHeader = -1;
2145  Int_t labelpositron = TMath::Abs( positronCandidate->GetLabel() );
2146 
2147 
2148  if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0) {
2149  isMCFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(labelpositron,fMCEvent,fInputEvent);
2150  if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 3) continue;
2151  }
2152 
2153  if( isMCFromMBHeader != 2 ) IsMCFromMBHeader = kFALSE;
2154  }
2155 
2156  if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(positronCandidate) ) continue;
2157 
2158  lGoodPositronIndexPrev.push_back( fSelectorPositronIndex[i] );
2159  hESDDalitzPositronPt[fiCut]->Fill( positronCandidate->Pt() );
2160  hESDDalitzPositronPhi[fiCut]->Fill( positronCandidate->Phi() );
2161 
2162  if( fMCEvent ) {
2163  Int_t labelpositron = TMath::Abs( positronCandidate->GetLabel() );
2164 
2165  if( labelpositron < fMCEvent->GetNumberOfTracks() ) {
2166  TParticle* positron = fMCEvent->Particle(labelpositron);
2167  if( positron->GetPdgCode() == -11 ){
2168  if( labelpositron < fMCEvent->GetNumberOfPrimaries() ){
2169  hESDTruePositronPt[fiCut]->Fill(positronCandidate->Pt());
2170  } else {
2171  hESDTrueSecPositronPt[fiCut]->Fill(positronCandidate->Pt());
2172  }
2173  if( IsPi0DalitzDaughter(labelpositron) == kTRUE && labelpositron < fMCEvent->GetNumberOfPrimaries() ) {
2174  if( positron->GetMother(0) < fMCEvent->GetNumberOfPrimaries() ){
2175  hESDTruePi0DalitzPositronPt[fiCut]->Fill(positronCandidate->Pt());
2176  if ( IsMCFromMBHeader == kTRUE )hESDTruePi0DalitzPositronPtMB[fiCut]->Fill(positronCandidate->Pt());
2177  } else {
2178  hESDTruePi0DalitzSecPositronPt[fiCut]->Fill(positronCandidate->Pt());
2179  }
2180  }
2181  }
2182  }
2183  }
2184  }
2185 
2186  vector<Bool_t> lElectronPsiIndex(lGoodElectronIndexPrev.size(), kTRUE);
2187  vector<Bool_t> lPositronPsiIndex(lGoodPositronIndexPrev.size(), kTRUE);
2188 
2189  if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->DoPsiPairCut() == kTRUE ){
2190  for( UInt_t i = 0; i < lGoodElectronIndexPrev.size(); i++ ) {
2191  AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndexPrev[i]);
2192  for(UInt_t j = 0; j < lGoodPositronIndexPrev.size(); j++){
2193  AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndexPrev[j]);
2194  Double_t psiPair = GetPsiPair(positronCandidate,electronCandidate);
2195  Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->GetConstrainedParam()->Phi()-positronCandidate->GetConstrainedParam()->Phi());
2196 
2197  if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->IsFromGammaConversion(psiPair,deltaPhi ) ){
2198  lElectronPsiIndex[i] = kFALSE;
2199  lPositronPsiIndex[j] = kFALSE;
2200  }
2201  }
2202  }
2203  }
2204 
2205  vector<Int_t> lGoodElectronIndex(0);
2206  vector<Int_t> lGoodPositronIndex(0);
2207 
2208  for( UInt_t i = 0; i < lGoodElectronIndexPrev.size(); i++ ) {
2209  if( lElectronPsiIndex[i] == kTRUE )
2210  lGoodElectronIndex.push_back( lGoodElectronIndexPrev[i] );
2211  }
2212 
2213  for( UInt_t i = 0; i < lGoodPositronIndexPrev.size(); i++ ) {
2214  if( lPositronPsiIndex[i] == kTRUE )
2215  lGoodPositronIndex.push_back( lGoodPositronIndexPrev[i] );
2216  }
2217 
2218  for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
2219  AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndex[i]);
2220  AliKFParticle electronCandidateKF( *electronCandidate->GetConstrainedParam(), ::kElectron );
2221  TLorentzVector electronCandidateTLV;
2222  electronCandidateTLV.SetXYZM(electronCandidate->GetConstrainedParam()->Px(),electronCandidate->GetConstrainedParam()->Py(),electronCandidate->GetConstrainedParam()->Pz(),TDatabasePDG::Instance()->GetParticle( ::kElectron )->Mass());
2223 
2224 
2225  for(UInt_t j = 0; j < lGoodPositronIndex.size(); j++){
2226 
2227  AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndex[j]);
2228  AliKFParticle positronCandidateKF( *positronCandidate->GetConstrainedParam(), ::kPositron );
2229  TLorentzVector positronCandidateTLV;
2230 
2231  positronCandidateTLV.SetXYZM(positronCandidate->GetConstrainedParam()->Px(),positronCandidate->GetConstrainedParam()->Py(),positronCandidate->GetConstrainedParam()->Pz(),TDatabasePDG::Instance()->GetParticle( ::kPositron )->Mass());
2232  TLorentzVector *virtualPhotonTLV = 0;
2233  AliKFConversionPhoton* virtualPhoton = NULL;
2234  AliAODConversionPhoton *vphoton;
2235 
2236  if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetUseElectronMCSmearing() && ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->UseMCPSmearing() && fMCEvent){
2237  TLorentzVector smearelectronCandidateTLV = ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->SmearElectron(electronCandidateTLV);
2238  TLorentzVector smearpositronCandidateTLV = ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->SmearElectron(positronCandidateTLV);
2239  virtualPhotonTLV = new TLorentzVector( smearelectronCandidateTLV + smearpositronCandidateTLV );
2240  //TLorentzVector temp = electronCandidateTLV + positronCandidateTLV;
2241  //cout<<"Mass: "<<"NoSmearElectrons "<<temp.M() <<" SmearElectrons "<<virtualPhotonTLV->M()<<endl;
2242  vphoton= new AliAODConversionPhoton(virtualPhotonTLV);
2243  vphoton->SetMass(virtualPhotonTLV->M());
2244  } else {
2245  virtualPhoton = new AliKFConversionPhoton(electronCandidateKF,positronCandidateKF);
2246  if( fSetProductionVertextoVGamma == kTRUE ){
2247  AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
2248  primaryVertexImproved+=*virtualPhoton;
2249  virtualPhoton->SetProductionVertex(primaryVertexImproved);
2250  }
2251 
2252  vphoton= new AliAODConversionPhoton(virtualPhoton);
2253  }
2254  //virtualPhoton->SetTrackLabels( lGoodPositronIndex[j], lGoodElectronIndex[i]);
2255  vphoton->SetTrackLabels( lGoodPositronIndex[j], lGoodElectronIndex[i]);
2256 
2257  if( fMCEvent ) {
2258  Int_t labeln=TMath::Abs(electronCandidate->GetLabel());
2259  Int_t labelp=TMath::Abs(positronCandidate->GetLabel());
2260  TParticle *fNegativeMCParticle = fMCEvent->Particle(labeln);
2261  TParticle *fPositiveMCParticle = fMCEvent->Particle(labelp);
2262  if( fPositiveMCParticle && fNegativeMCParticle) {
2263  //virtualPhoton->SetMCLabelPositive(labelp);
2264  //virtualPhoton->SetMCLabelNegative(labeln);
2265  vphoton->SetMCLabelPositive(labelp);
2266  vphoton->SetMCLabelNegative(labeln);
2267 
2268  }
2269  }
2270 
2271 
2272  fGoodVirtualGammas->Add( vphoton );
2273 
2274  if( virtualPhoton ){
2275  delete virtualPhoton;
2276  virtualPhoton=NULL;
2277  }
2278  if ( virtualPhotonTLV ){
2279  delete virtualPhotonTLV;
2280  virtualPhotonTLV=NULL;
2281  }
2282 
2283  }
2284  }
2285 
2286  //Computing mixing event
2287  if( fDoMesonQA > 0 ) {
2288  for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
2289  AliESDtrack *electronCandidate1 = fESDEvent->GetTrack(lGoodElectronIndex[i]);
2290  AliKFParticle electronCandidate1KF( *electronCandidate1->GetConstrainedParam(), ::kElectron );
2291 
2292  for(UInt_t j = i+1; j < lGoodElectronIndex.size(); j++){
2293 
2294  AliESDtrack *electronCandidate2 = fESDEvent->GetTrack(lGoodElectronIndex[j]);
2295  AliKFParticle electronCandidate2KF( *electronCandidate2->GetConstrainedParam(), ::kElectron );
2296  AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(electronCandidate1KF,electronCandidate2KF);
2297 
2298  //AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
2299  //primaryVertexImproved+=*virtualPhoton;
2300  //virtualPhoton->SetProductionVertex(primaryVertexImproved);
2301 
2302  AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton);
2303  hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->M(),vphoton->Pt());
2304  delete vphoton;
2305  delete virtualPhoton;
2306  vphoton = 0x0;
2307  virtualPhoton = 0x0;
2308  }
2309  }
2310 
2311 
2312  for(UInt_t i = 0; i < lGoodPositronIndex.size(); i++){
2313  AliESDtrack *positronCandidate1 = fESDEvent->GetTrack(lGoodPositronIndex[i]);
2314  AliKFParticle positronCandidate1KF( *positronCandidate1->GetConstrainedParam(), ::kPositron );
2315 
2316  for(UInt_t j = i+1; j < lGoodPositronIndex.size(); j++){
2317 
2318  AliESDtrack *positronCandidate2 = fESDEvent->GetTrack(lGoodPositronIndex[j]);
2319  AliKFParticle positronCandidate2KF( *positronCandidate2->GetConstrainedParam(), ::kPositron );
2320  AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(positronCandidate1KF,positronCandidate2KF);
2321  //AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
2322  //primaryVertexImproved+=*virtualPhoton;
2323  //virtualPhoton->SetProductionVertex(primaryVertexImproved);
2324 
2325  AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton);
2326  hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->M(),vphoton->Pt());
2327  delete vphoton;
2328  delete virtualPhoton;
2329  vphoton = 0x0;
2330  virtualPhoton = 0x0;
2331 
2332  }
2333  }
2334  }
2335 }
2336 
2337 //________________________________________________________________________
2338 void AliAnalysisTaskGammaConvDalitzV1::CalculatePi0DalitzCandidates(){
2339 
2340  // Conversion Gammas
2341  if( fGoodGammas->GetEntries() > 0 && fGoodVirtualGammas->GetEntries() > 0 ){
2342  vector<Bool_t> lGoodVirtualGamma(fGoodVirtualGammas->GetEntries(), kFALSE);
2343 
2344  for(Int_t GammaIndex=0; GammaIndex<fGoodGammas->GetEntries(); GammaIndex++){
2345  AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(GammaIndex));
2346  if (gamma==NULL) continue;
2347  for(Int_t virtualGammaIndex=0;virtualGammaIndex<fGoodVirtualGammas->GetEntries();virtualGammaIndex++){
2348  AliAODConversionPhoton *Vgamma=dynamic_cast<AliAODConversionPhoton*>(fGoodVirtualGammas->At(virtualGammaIndex));
2349  if (Vgamma==NULL) continue;
2350  //Check for same Electron ID
2351  if(gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelPositive() ||
2352  gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelNegative() ||
2353  gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelPositive() ||
2354  gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelNegative() ) continue;
2355 
2356  AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma,Vgamma);
2357  pi0cand->SetLabels(GammaIndex,virtualGammaIndex);
2358 
2359 
2360  if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift())) ){
2361 
2362  //cout<< "Meson Accepted "<<endl;
2363  Int_t zbin = 0;
2364  Int_t mbin = 0;
2365  if(fDoTHnSparse && ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->DoBGCalculation()){
2366  if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->BackgroundHandlerType() == 0){
2367 
2368  zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
2369  if( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->UseTrackMultiplicity() ){
2370  mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
2371  } else {
2372  mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
2373  }
2374  }
2375  }
2376  if ( fDoMesonQA > 0 ) {
2377 
2378 
2379 
2380 
2381  if( fMCEvent ) {
2382 
2383  Int_t virtualGammaMCLabel = Vgamma->GetMCParticleLabel(fMCEvent);
2384 
2385  if( virtualGammaMCLabel > -1 ) {
2386 
2387  TParticle * negativeMC = (TParticle*)Vgamma->GetNegativeMCDaughter(fMCEvent);
2388  TParticle * positiveMC = (TParticle*)Vgamma->GetPositiveMCDaughter(fMCEvent);
2389  // TParticle * virtualGammaMotherMC = (TParticle*)fMCEvent->Particle(virtualGammaMCLabel);
2390 
2391  if( negativeMC->GetPdgCode() == 11 && positiveMC->GetPdgCode() == -11) { // Electrons ...
2392 
2393 
2394  if( IsPi0DalitzDaughter( Vgamma->GetMCLabelPositive() ) ){
2395 
2396  hESDTruePi0EposEnegInvMassPi0Pt[fiCut]->Fill( Vgamma->M(), pi0cand->Pt() );
2397 
2398 
2399  }
2400 
2401  }
2402 
2403  }
2404  }
2405 
2406  }
2407 
2408  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2409  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( pi0cand->Pt() , Vgamma->M() ) == kTRUE ){
2410 
2411  hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2412 
2413  if( fDoTHnSparse ){
2414  Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
2415  sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2416  }
2417 
2418 
2419  if(fMCEvent){
2420  ProcessTrueMesonCandidates(pi0cand,gamma,Vgamma);
2421  }
2422 
2423  if ( fDoMesonQA > 0 ) {
2424 
2425 
2426 
2427 
2428 
2429  AliESDtrack* positronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
2430  Double_t momPositron[3];
2431  positronVgamma->GetConstrainedPxPyPz(momPositron);
2432 
2433  AliESDtrack* electronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
2434  Double_t momElectron[3];
2435  electronVgamma->GetConstrainedPxPyPz(momElectron);
2436 
2437  TVector3 vGamma(gamma->GetPx(),gamma->GetPy(),gamma->GetPz());;
2438  TVector3 vPositron(momPositron[0],momPositron[1],momPositron[2]);
2439  TVector3 vElectron(momElectron[0],momElectron[1],momElectron[2]);
2440 
2441 
2442  hESDMotherInvMassOpeningAngleGammaElectron[fiCut]->Fill( vGamma.Angle(vPositron) );
2443  hESDMotherInvMassOpeningAngleGammaElectron[fiCut]->Fill( vGamma.Angle(vElectron) );
2444 
2445 
2446 
2447  if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
2448 
2449  if( fDoMesonQA > 1 ){
2450  TLorentzVector electronCandidateTLV(vElectron,TDatabasePDG::Instance()->GetParticle( ::kElectron )->Mass());
2451  TLorentzVector positronCandidateTLV(vPositron,TDatabasePDG::Instance()->GetParticle( ::kPositron )->Mass());
2452  TLorentzVector gammaTLV(vGamma,0);
2453  TLorentzVector GammaElectronCandidateTLV = gammaTLV + electronCandidateTLV;
2454  TLorentzVector GammaPositronCandidateTLV = gammaTLV + positronCandidateTLV;
2455  Double_t sparesDalitzPlot[2] = {GammaElectronCandidateTLV.M()*GammaElectronCandidateTLV.M(),GammaPositronCandidateTLV.M()*GammaPositronCandidateTLV.M()};
2456  sESDMotherDalitzPlot[fiCut]->Fill(sparesDalitzPlot);
2457 
2458 
2459  }
2460 
2461 
2462  hESDMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift());
2463  hESDMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),TMath::Abs(pi0cand->GetAlpha()));
2464  hESDMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2465 
2466  }
2467 
2468 
2469  if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
2470 
2471 
2472  if( pi0cand->M() > 0.1 && pi0cand->M() < 0.145 ){
2473  FillElectronQAHistos(Vgamma);
2474 
2475  lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
2476  fNVirtualGammas++;
2477  }
2478  }
2479  }
2480  }
2481  } else {
2482  hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2483  if( fDoTHnSparse ){
2484  Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
2485  sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2486  }
2487 
2488  if(fMCEvent){
2489  ProcessTrueMesonCandidates(pi0cand,gamma,Vgamma);
2490  }
2491 
2492  if ( fDoMesonQA > 0 ) {
2493 
2494 
2495  if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
2496 
2497  hESDMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift());
2498  hESDMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),TMath::Abs(pi0cand->GetAlpha()));
2499  hESDMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2500 
2501 
2502  }
2503 
2504  if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
2505 
2506  if( pi0cand->M() > 0.1 && pi0cand->M() < 0.145 ){
2507 
2508  FillElectronQAHistos(Vgamma);
2509  lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
2510  fNVirtualGammas++;
2511 
2512  }
2513  }
2514  }
2515  }
2516 
2517  if( fDoChicAnalysis) {
2518 
2519  hESDPi0MotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2520  hESDEposEnegInvMassPi0MotherPt[fiCut]->Fill(Vgamma->M(),pi0cand->Pt());
2521 
2522  Double_t diffMass = pi0cand->M() - Vgamma->M();
2523  hESDPi0MotherDiffInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
2524 
2525  if( Vgamma->M() > 2.5 && Vgamma->M() < 3.4){
2526  hESDPi0MotherDiffLimInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
2527  }
2528 
2529  if(fMCEvent){
2530  ProcessTrueChicCandidates(pi0cand,gamma,Vgamma);
2531  }
2532 
2533 
2534  }
2535 
2536 
2537  }
2538  delete pi0cand;
2539  pi0cand=0x0;
2540  }
2541  }
2542  }
2543 }
2544 
2545 //________________________________________________________________________
2546 void AliAnalysisTaskGammaConvDalitzV1::CalculateBackground(){
2547 
2548  Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
2549  Int_t mbin = 0;
2550 
2551 
2552  if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->UseTrackMultiplicity()){
2553  mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
2554  } else {
2555  mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
2556  }
2557 
2558 
2559  AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2560 
2561  if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->UseTrackMultiplicity()){
2562  for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2563 
2564  AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2565  if(fMoveParticleAccordingToVertex == kTRUE || ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0 ){
2566  bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2567  }
2568 
2569  for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
2570  AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
2571 
2572  for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2573  AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2574 
2575  if(fMoveParticleAccordingToVertex == kTRUE ){
2576  MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2577  }
2578 
2579  if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2580  RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2581  }
2582 
2583  AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2584  backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2585 
2586  if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE, ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift()))){
2587  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2588 
2589  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.M() ) == kTRUE ){
2590 
2591  hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2592  if(fDoTHnSparse){
2593  Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2594  sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2595  }
2596  }
2597  } else {
2598  hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2599  if(fDoTHnSparse){
2600  Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2601  sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2602  }
2603  }
2604  }
2605  delete backgroundCandidate;
2606  backgroundCandidate = 0x0;
2607  }
2608  }
2609  }
2610  } else {
2611  for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2612  AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2613  if(previousEventV0s){
2614  if(fMoveParticleAccordingToVertex == kTRUE || ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0 ){
2615  bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2616  }
2617  for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
2618  AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
2619  for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2620  AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2621  if(fMoveParticleAccordingToVertex == kTRUE ){
2622  MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2623  }
2624 
2625  if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2626  RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2627  }
2628 
2629  AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2630  backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2631 
2632  if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift()))){
2633  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2634  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.M() ) == kTRUE ){
2635  hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2636  if(fDoTHnSparse){
2637  Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2638  sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2639  }
2640  }
2641  } else {
2642  hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2643  if(fDoTHnSparse){
2644  Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2645  sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2646  }
2647  }
2648  }
2649  delete backgroundCandidate;
2650  backgroundCandidate = 0x0;
2651  }
2652  }
2653  }
2654  }
2655  }
2656 
2657 }
2658 
2659 
2660 //________________________________________________________________________
2661 void AliAnalysisTaskGammaConvDalitzV1::UpdateEventByEventData(){
2662  //see header file for documentation
2663 
2664  if(fGoodGammas->GetEntries() > 0 ){
2665  if( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->UseTrackMultiplicity() ){
2666  fBGHandler[fiCut]->AddEvent(fGoodGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fNumberOfESDTracks,fEventPlaneAngle);
2667  } else { // means we use #V0s for multiplicity
2668  fBGHandler[fiCut]->AddEvent(fGoodGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fGoodGammas->GetEntries(),fEventPlaneAngle);
2669  }
2670  }
2671 
2672 }
2673 
2674 //______________________________________________________________________
2675 void AliAnalysisTaskGammaConvDalitzV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate, AliAODConversionPhoton *TrueVirtualGammaCandidate)
2676 {
2677  // Process True Mesons
2678 
2679  if( TrueGammaCandidate->GetV0Index() < fESDEvent->GetNumberOfV0s() ){
2680 
2681 
2682 
2683  Bool_t isTruePi0 = kFALSE;
2684  Bool_t isTrueEta = kFALSE;
2685 
2686  Int_t gammaMCLabel = TrueGammaCandidate->GetMCParticleLabel(fMCEvent);
2687  Int_t gammaMotherLabel = -1;
2688 
2689 
2690 
2691 
2692 
2693  //Checking if the gamma candidate is a real gamma
2694 
2695 
2696  if(gammaMCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2697  // Daughters Gamma 0
2698  TParticle * negativeMC = (TParticle*)TrueGammaCandidate->GetNegativeMCDaughter(fMCEvent);
2699  TParticle * positiveMC = (TParticle*)TrueGammaCandidate->GetPositiveMCDaughter(fMCEvent);
2700  TParticle * gammaMC = (TParticle*)fMCEvent->Particle(gammaMCLabel);
2701 
2702  if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2703  if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2704  if(gammaMC->GetPdgCode() == 22){ // ... with Gamma Mother
2705  gammaMotherLabel=gammaMC->GetFirstMother();
2706  }
2707  }
2708  }
2709  }
2710 
2711 
2712 
2713  //Checking if the virtual gamma is a real virtual gamma
2714 
2715  Int_t virtualGammaMCLabel = TrueVirtualGammaCandidate->GetMCParticleLabel(fMCEvent);
2716  Int_t virtualGammaMotherLabel = -1;
2717  Int_t virtualGamma = -1;
2718 
2719 
2720 
2721  if( virtualGammaMCLabel != -1 ){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2722  // Daughters Gamma 1
2723  TParticle * negativeMC = (TParticle*)TrueVirtualGammaCandidate->GetNegativeMCDaughter(fMCEvent);
2724  TParticle * positiveMC = (TParticle*)TrueVirtualGammaCandidate->GetPositiveMCDaughter(fMCEvent);
2725  TParticle * virtualGammaMotherMC = (TParticle*)fMCEvent->Particle(virtualGammaMCLabel);
2726 
2727  if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2728 
2729  if( virtualGammaMotherMC->GetPdgCode() != 22 ){
2730  virtualGammaMotherLabel=virtualGammaMCLabel;
2731  virtualGamma = 1;
2732 
2733  } else if (negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2734  virtualGammaMotherLabel=virtualGammaMotherMC->GetFirstMother();
2735  virtualGamma = 0; //no virtual gamma
2736  }
2737  }
2738  }
2739 
2740 
2741  //Checking if both gamma and virtual gamma comming from Pi0 or Eta
2742 
2743 
2744  if( gammaMotherLabel >= 0 && ( gammaMotherLabel == virtualGammaMotherLabel) ){
2745  if(((TParticle*)fMCEvent->Particle(virtualGammaMotherLabel))->GetPdgCode() == 111){
2746  isTruePi0=kTRUE;
2747  if (CheckVectorForDoubleCount(fVectorDoubleCountTruePi0s,gammaMotherLabel)) fHistoDoubleCountTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2748  }
2749  if(((TParticle*)fMCEvent->Particle(virtualGammaMotherLabel))->GetPdgCode() == 221){
2750  isTrueEta=kTRUE;
2751  if (CheckVectorForDoubleCount(fVectorDoubleCountTrueEtas,gammaMotherLabel)) fHistoDoubleCountTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2752  }
2753  }
2754 
2755 
2756 
2757  if( isTruePi0 || isTrueEta ){ // True Pion or Eta
2758 
2759 
2760  if ( virtualGamma == 1 ) { //True Dalitz
2761  Float_t weighted= 1;
2762 
2763  Float_t weightMatBudget = 1.;
2764  if (fDoMaterialBudgetWeightingOfGammasForTrueMesons && ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->GetMaterialBudgetWeightsInitialized ()) {
2765  weightMatBudget = ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->GetMaterialBudgetCorrectingWeightForTrueGamma(TrueGammaCandidate);
2766  }
2767 
2768 
2769  if ( isTruePi0 && fDoMesonQA > 0 ) {
2770 
2771  if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2772 
2773 
2774 
2775  hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift());
2776  hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),TMath::Abs(Pi0Candidate->GetAlpha()));
2777  hESDTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2778 
2779  if( fDoMesonQA > 1 ) {
2780  AliESDtrack* positronVgamma = fESDEvent->GetTrack( TrueVirtualGammaCandidate->GetTrackLabelPositive() );
2781  Double_t momPositron[3];
2782  positronVgamma->GetConstrainedPxPyPz(momPositron);
2783 
2784  AliESDtrack* electronVgamma = fESDEvent->GetTrack( TrueVirtualGammaCandidate->GetTrackLabelNegative() );
2785  Double_t momElectron[3];
2786  electronVgamma->GetConstrainedPxPyPz(momElectron);
2787 
2788  TVector3 vGamma(TrueGammaCandidate->GetPx(),TrueGammaCandidate->GetPy(),TrueGammaCandidate->GetPz());;
2789  TVector3 vPositron(momPositron[0],momPositron[1],momPositron[2]);
2790  TVector3 vElectron(momElectron[0],momElectron[1],momElectron[2]);
2791 
2792  TLorentzVector electronCandidateTLV(vElectron,TDatabasePDG::Instance()->GetParticle( ::kElectron )->Mass());
2793  TLorentzVector positronCandidateTLV(vPositron,TDatabasePDG::Instance()->GetParticle( ::kPositron )->Mass());
2794  TLorentzVector gammaTLV(vGamma,0);
2795  TLorentzVector GammaElectronCandidateTLV = gammaTLV + electronCandidateTLV;
2796  TLorentzVector GammaPositronCandidateTLV = gammaTLV + positronCandidateTLV;
2797  Double_t sparesDalitzPlot[2] = {GammaElectronCandidateTLV.M()*GammaElectronCandidateTLV.M(),GammaPositronCandidateTLV.M()*GammaPositronCandidateTLV.M()};
2798  sESDTruePi0DalitzPlot[fiCut]->Fill(sparesDalitzPlot);
2799  }
2800 
2801  }
2802  }
2803 
2804 
2805 
2806  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2807  if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCEvent,fInputEvent)){
2808  if (((TParticle*)fMCEvent->Particle(gammaMotherLabel))->Pt()>0.005){
2809  weighted= ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetWeightForMeson(gammaMotherLabel,fMCEvent,fInputEvent);
2810  }
2811  }
2812  }
2813 
2814  hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted*weightMatBudget);
2815  hESDTrueMotherW0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2816  hESDTrueMotherDalitzInvMassPt[fiCut]->Fill( TrueVirtualGammaCandidate->M(),Pi0Candidate->Pt(),weighted*weightMatBudget);
2817 
2818  if(gammaMotherLabel < fMCEvent->GetNumberOfPrimaries()){ // Only primary pi0 for efficiency calculation
2819  hESDTruePrimaryMotherInvMassPt[fiCut]->Fill( Pi0Candidate->M(),Pi0Candidate->Pt(),weighted*weightMatBudget);
2820  hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill( Pi0Candidate->M(), Pi0Candidate->Pt() );
2821 
2822  hESDTruePrimaryMotherInvMassMCPt[fiCut]->Fill(Pi0Candidate->M(),((TParticle*)fMCEvent->Particle(virtualGammaMotherLabel))->Pt(),weighted*weightMatBudget);
2823  if(isTruePi0){ // Only primaries for unfolding
2824  hESDTruePrimaryPi0DalitzESDPtMCPt[fiCut]->Fill(Pi0Candidate->Pt(),((TParticle*)fMCEvent->Particle(virtualGammaMotherLabel))->Pt(),weighted*weightMatBudget);
2825  }
2826  } else { // Secondary Meson
2827  Float_t weightedSec= 1;
2828  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2829  Int_t secMotherLabel = ((TParticle*)fMCEvent->Particle(gammaMotherLabel))->GetMother(0);
2830  if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCEvent, fInputEvent) && fMCEvent->Particle(gammaMotherLabel)->GetPdgCode()==310){
2831  weightedSec= ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetWeightForMeson(secMotherLabel, fMCEvent, fInputEvent)/2.; //invariant mass is additive thus the weight for the daughters has to be devide by two for the K0s at a certain pt
2832  }
2833  }
2834  hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec*weightMatBudget);
2835  }
2836  } else if ( virtualGamma == 0 ){
2837 
2838  Float_t weightMatBudget = 1.;
2839  if (fDoMaterialBudgetWeightingOfGammasForTrueMesons && ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->GetMaterialBudgetWeightsInitialized ()) {
2840  weightMatBudget = ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->GetMaterialBudgetCorrectingWeightForTrueGamma(TrueGammaCandidate) * ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->GetMaterialBudgetCorrectingWeightForTrueGamma(TrueVirtualGammaCandidate);
2841  }
2842 
2843  Float_t weighted= 1;
2844  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2845  if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCEvent,fInputEvent)){
2846  if (((TParticle*)fMCEvent->Particle(gammaMotherLabel))->Pt()>0.005){
2847  weighted= ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetWeightForMeson(gammaMotherLabel,fMCEvent,fInputEvent);
2848  }
2849  }
2850  }
2851  hESDTrueMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted*weightMatBudget); // Pi0 from GG
2852  hESDTrueMotherPi0GGW0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2853 
2854  if( gammaMotherLabel < fMCEvent->GetNumberOfPrimaries() ){
2855  hESDTruePrimaryMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted*weightMatBudget);
2856  } else {
2857  Float_t weightedSec= 1;
2858  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2859  Int_t secMotherLabel = ((TParticle*)fMCEvent->Particle(gammaMotherLabel))->GetMother(0);
2860  if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCEvent, fInputEvent) && fMCEvent->Particle(gammaMotherLabel)->GetPdgCode()==310){
2861  weightedSec= ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetWeightForMeson(secMotherLabel, fMCEvent, fInputEvent)/2.; //invariant mass is additive thus the weight for the daughters has to be devide by two for the K0s at a certain pt
2862  }
2863  }
2864  hESDTrueSecondaryMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec*weightMatBudget);
2865  }
2866  }
2867  }
2868 
2869  if( !isTruePi0 && !isTrueEta ){ // Background
2870  if( gammaMotherLabel > -1 && virtualGammaMotherLabel > -1 && virtualGamma == 0 ){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2871  hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2872  } else { // No photon or without mother
2873  hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2874  }
2875  }
2876  }
2877 }
2878 
2879 //______________________________________________________________________
2880 void AliAnalysisTaskGammaConvDalitzV1::ProcessTrueChicCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate, AliAODConversionPhoton *TruejpsiCandidate)
2881 {
2882 
2883 
2884 
2885  if( TrueGammaCandidate->GetV0Index() < fESDEvent->GetNumberOfV0s() ){
2886 
2887 
2888 
2889  //Checking gamma
2890 
2891  Int_t gammaMCLabel = TrueGammaCandidate->GetMCParticleLabel(fMCEvent);
2892  Int_t gammaMotherLabel = -1;
2893 
2894 
2895 
2896  if( gammaMCLabel != -1){// Gamma is Combinatorial; MC Particles don't belong to the same Mother
2897  // Daughters Gamma 0
2898 
2899  TParticle * negativeMC = (TParticle*)TrueGammaCandidate->GetNegativeMCDaughter(fMCEvent);
2900  TParticle * positiveMC = (TParticle*)TrueGammaCandidate->GetPositiveMCDaughter(fMCEvent);
2901  TParticle * gammaMC = (TParticle*)fMCEvent->Particle(gammaMCLabel);
2902 
2903  if( TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11 ){ // Electrons ...
2904  if( negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() == 5 ){ // ... From Conversion ...
2905  if(gammaMC->GetPdgCode() == 22){ // ... with Gamma Mother
2906  gammaMotherLabel=gammaMC->GetFirstMother();
2907  }
2908  }
2909  }
2910  }
2911 
2912 
2913 
2914  //Checking jpsi
2915 
2916  Int_t jpsiMCLabel = TruejpsiCandidate->GetMCParticleLabel(fMCEvent);
2917  Int_t jpsiMotherLabel = -1;
2918 
2919 
2920 
2921  if( jpsiMCLabel != -1 ){
2922 
2923  TParticle * negativeMC = (TParticle*)TruejpsiCandidate->GetNegativeMCDaughter(fMCEvent);
2924  TParticle * positiveMC = (TParticle*)TruejpsiCandidate->GetPositiveMCDaughter(fMCEvent);
2925  TParticle * jpsiMC = (TParticle*)fMCEvent->Particle(jpsiMCLabel);
2926 
2927  if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2928 
2929 
2930  if(jpsiMC->GetPdgCode() == 443){
2931 
2932  jpsiMotherLabel=jpsiMC->GetFirstMother();
2933 
2934  }
2935 
2936 
2937  }
2938  }
2939 
2940 
2941  if( gammaMotherLabel>=0 && ( gammaMotherLabel == jpsiMotherLabel) ){
2942  if( ((TParticle*)fMCEvent->Particle(jpsiMotherLabel))->GetPdgCode() == 445 ||
2943  ((TParticle*)fMCEvent->Particle(jpsiMotherLabel))->GetPdgCode() == 10443 ||
2944  ((TParticle*)fMCEvent->Particle(jpsiMotherLabel))->GetPdgCode() == 20443 ){
2945 
2946  hESDTrueMotherChiCInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2947  hESDTrueMotherChiCDiffInvMassPt[fiCut]->Fill(Pi0Candidate->M()-TruejpsiCandidate->M(),Pi0Candidate->Pt());
2948  }
2949  }
2950 
2951  }
2952 }
2953 
2954 
2955 
2956 //________________________________________________________________________
2957 void AliAnalysisTaskGammaConvDalitzV1::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
2958 
2959  previousEventEP=previousEventEP+TMath::Pi();
2960  thisEventEP=thisEventEP+TMath::Pi();
2961  Double_t rotationValue= thisEventEP-previousEventEP;
2962  gamma->RotateZ(rotationValue);
2963 }
2964 
2965 
2966 //________________________________________________________________________
2967 void AliAnalysisTaskGammaConvDalitzV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
2968  //see header file for documentation
2969 
2970  Double_t dx = vertex->fX - fESDEvent->GetPrimaryVertex()->GetX();
2971  Double_t dy = vertex->fY - fESDEvent->GetPrimaryVertex()->GetY();
2972  Double_t dz = vertex->fZ - fESDEvent->GetPrimaryVertex()->GetZ();
2973 
2974  Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
2975  particle->SetConversionPoint(movedPlace);
2976 }
2977 
2978 
2979 //________________________________________________________________________
2980 void AliAnalysisTaskGammaConvDalitzV1::CountESDTracks(){
2981 
2982  // Using standard function for setting Cuts
2983  Bool_t selectPrimaries=kTRUE;
2984  AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
2985  EsdTrackCuts->SetMaxDCAToVertexZ(2);
2986  EsdTrackCuts->SetEtaRange(-0.8, 0.8);
2987  EsdTrackCuts->SetPtRange(0.15);
2988  EsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kBoth);
2989 
2990  fNumberOfESDTrackskBoth = 0;
2991  for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
2992  AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
2993  if(!curTrack) continue;
2994  if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTrackskBoth++;
2995  }
2996  delete EsdTrackCuts;
2997  EsdTrackCuts=0x0;
2998 
2999  return;
3000 }
3001 
3002 //_____________________________________________________________________________
3003 void AliAnalysisTaskGammaConvDalitzV1::ProcessMCParticles()
3004 {
3005 
3006 // Loop over all primary MC particle
3007 
3008  for(Int_t i = 0; i < fMCEvent->GetNumberOfPrimaries(); i++) {
3009 
3010  TParticle* particle = (TParticle *)fMCEvent->Particle(i);
3011  if (!particle) continue;
3012 
3013  Bool_t mcIsFromMB = kTRUE;
3014  Int_t isMCFromMBHeader = -1;
3015 
3016  if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0) {
3017  isMCFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(i,fMCEvent,fInputEvent);
3018  if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 3) continue;
3019  if(isMCFromMBHeader != 2) mcIsFromMB = kFALSE;
3020  }
3021 
3022  if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCEvent,kFALSE)){
3023  hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
3024 
3025  if( IsPi0DalitzDaughter( i ) == kTRUE ){
3026 
3027  hMCAllGammaPi0Pt[fiCut]->Fill(particle->Pt());
3028 
3029  }
3030 
3031 
3032 
3033  }
3034 
3035  if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCEvent,kTRUE)){
3036 
3037  hMCConvGammaPt[fiCut]->Fill(particle->Pt());
3038 
3039  if(fDoMesonQA > 0 ) {
3040  hMCConvGammaEta[fiCut]->Fill( particle->Eta());
3041  if(mcIsFromMB) {
3042  hMCConvGammaR[fiCut]->Fill( ((TParticle*)fMCEvent->Particle(particle->GetFirstDaughter()))->R() );
3043  hMCConvGammaPtR[fiCut]->Fill( particle->Pt(), ((TParticle*)fMCEvent->Particle(particle->GetFirstDaughter()))->R() );
3044  }
3045  }
3046 
3047  if(mcIsFromMB){
3048 
3049  hMCConvGammaRSPt[fiCut]->Fill(particle->Pt());
3050 
3051  }
3052 
3053  if( IsPi0DalitzDaughter( i ) == kTRUE ){
3054 
3055  hMCConvGammaPi0Pt[fiCut]->Fill(particle->Pt());
3056 
3057  }
3058 
3059  } // Converted MC Gamma
3060 
3061  if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(i,fMCEvent)){
3062  if( particle->GetPdgCode() == -11) {
3063  hMCAllPositronsPt[fiCut]->Fill(particle->Pt()); // All positrons
3064  if(fDoMesonQA > 0 ) hMCAllPositronsEta[fiCut]->Fill( particle->Eta() );
3065 
3066  if ( particle->GetMother(0) > -1 && particle->GetMother(0) < fMCEvent->GetNumberOfPrimaries() ) {
3067 
3068  if( IsPi0DalitzDaughter( i ) == kTRUE ){
3069  hMCDecayPositronPi0Pt[fiCut]->Fill(particle->Pt()); //Positrons from Pi0->Dalitz
3070  }
3071 
3072  }
3073  }
3074  if( particle->GetPdgCode() == 11){
3075  hMCAllElectronsPt[fiCut]->Fill(particle->Pt()); // All electrons
3076  if (fDoMesonQA > 0 ) hMCAllElectronsEta[fiCut]->Fill(particle->Eta()); // All electrons
3077 
3078  if ( particle->GetMother(0) > -1 && particle->GetMother(0) < fMCEvent->GetNumberOfPrimaries() ) {
3079 
3080  if( IsPi0DalitzDaughter( i ) == kTRUE ){
3081  hMCDecayElectronPi0Pt[fiCut]->Fill(particle->Pt()); //Electrons from Pi0->Dalitz
3082  }
3083 
3084  }
3085 
3086  }
3087  }
3088 
3089  if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMC( particle,fMCEvent,((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift() ) ){
3090  Float_t weighted= 1;
3091  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
3092  if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(i, fMCEvent, fInputEvent)){
3093  if (particle->Pt()>0.005){
3094  weighted= ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetWeightForMeson(i, fMCEvent,fInputEvent);
3095  }
3096  }
3097  }
3098  if(particle->GetPdgCode() == 111)hMCPi0GGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Pi0 GG decay
3099  if(particle->GetPdgCode() == 221)hMCEtaGGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Eta GG decay
3100  }
3101 
3102 
3103  Int_t labelgamma = -1;
3104  Int_t labelelectron = -1;
3105  Int_t labelpositron = -1;
3106 
3107 
3108  if( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMCDalitz(particle,fMCEvent,labelelectron,labelpositron,labelgamma,((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift())){
3109  Float_t weighted= 1;
3110  if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
3111  if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(i, fMCEvent,fInputEvent)){
3112  if (particle->Pt()>0.005){
3113  weighted= ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetWeightForMeson(i, fMCEvent,fInputEvent);
3114  }
3115  }
3116  }
3117  if(particle->GetPdgCode() == 111){
3118  hMCPi0Pt[fiCut]->Fill(particle->Pt(), weighted); // All MC Pi0
3119  hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
3120 
3121  }
3122  if(particle->GetPdgCode() == 221)hMCEtaPt[fiCut]->Fill(particle->Pt(), weighted); // All MC Eta
3123 
3124  // Check the acceptance for gamma and electrons
3125 
3126  TParticle *gamma = fMCEvent->Particle(labelgamma);
3127  TParticle *electron = fMCEvent->Particle(labelelectron);
3128  TParticle *positron = fMCEvent->Particle(labelpositron);
3129 
3130 
3131  if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(gamma,fMCEvent,kFALSE) &&
3132  ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelelectron,fMCEvent) &&
3133  ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelpositron,fMCEvent) ) {
3134 
3135  Double_t massDalitz = -1;
3136  Double_t angleGammaEpos = -1;
3137  Double_t angleGammaEneg = -1;
3138  Double_t massGammaEpos = -1;
3139  Double_t massGammaEneg = -1;
3140 
3141  if( fDoMesonQA > 0 ){
3142 
3143  TLorentzVector TLVEpos,TLVEneg,TLVgamma,TLVDalitz,TLVGammaEpos,TLVGammaEneg;
3144  Double_t electronMass = TDatabasePDG::Instance()->GetParticle( ::kElectron )->Mass();
3145  TLVEpos.SetXYZM(positron->Px(),positron->Py(),positron->Pz(),electronMass);
3146  TLVEneg.SetXYZM(electron->Px(),electron->Py(),electron->Pz(),electronMass);
3147  TLVgamma.SetXYZM(gamma->Px(),gamma->Py(),gamma->Pz(),0);
3148 
3149  TVector3 V3gamma(gamma->Px(),gamma->Py(),gamma->Pz());
3150  angleGammaEpos = V3gamma.Angle(TLVEpos.Vect());
3151  angleGammaEneg = V3gamma.Angle(TLVEneg.Vect());
3152 
3153  TLVDalitz = TLVEpos + TLVEneg ;
3154  massDalitz = TLVDalitz.M();
3155  TLVGammaEpos = TLVEpos + TLVgamma;
3156  TLVGammaEneg = TLVEneg + TLVgamma;
3157 
3158  massGammaEpos = TLVGammaEpos.M();
3159  massGammaEneg = TLVGammaEneg.M();
3160 
3161 
3162 
3163  }
3164 
3165  if(particle->GetPdgCode() == 111){
3166 
3167  hMCPi0InAccPt[fiCut]->Fill(particle->Pt() , weighted); // MC Pi0Dalitz with gamma and e+e- in acc
3168  hMCPi0WOWeightInAccPt[fiCut]->Fill(particle->Pt()); // MC Pi0 with gamma in acc NOT weighted
3169  hMCPi0DalitzGammaPt[fiCut]->Fill( gamma->Pt() );
3170  hMCPi0DalitzPositronPt[fiCut]->Fill( positron->Pt() );
3171  hMCPi0DalitzElectronPt[fiCut]->Fill( electron->Pt() );
3172 
3173 
3174 
3175  if ( fDoMesonQA > 0 ){
3176 
3177  hMCPi0EposEnegInvMassPt[fiCut]->Fill(massDalitz,particle->Pt());
3178  hMCPi0InAccOpeningAngleGammaElectron[fiCut]->Fill(angleGammaEpos);
3179  hMCPi0InAccOpeningAngleGammaElectron[fiCut]->Fill(angleGammaEneg);
3180 
3181  if ( fDoMesonQA > 1 ) {
3182 
3183  Double_t sMCDalitzPlot[2] = {massGammaEneg*massGammaEneg,massGammaEpos*massGammaEpos};
3184 
3185  sMCPi0DalitzPlot[fiCut]->Fill(sMCDalitzPlot);
3186 
3187  }
3188 
3189  }
3190  }
3191  if(particle->GetPdgCode() == 221){
3192  hMCEtaInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC EtaDalitz with gamma and e+e- in acc
3193  if( fDoMesonQA > 0 ) hMCEtaEposEnegInvMassPt[fiCut]->Fill( massDalitz, particle->Pt());
3194  }
3195  }
3196  }
3197 
3198  Int_t labelgammaChiC=-1;
3199  Int_t labelpositronChiC=-1;
3200  Int_t labelelectronChiC=-1;
3201 
3202  if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMCChiC(particle,fMCEvent,labelelectronChiC,labelpositronChiC,labelgammaChiC,((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift())){
3203 
3204  hMCChiCPt[fiCut]->Fill(particle->Pt()); // All MC ChiC
3205  TParticle * gammaChiC =fMCEvent->Particle(labelgammaChiC);
3206 
3207  if( ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC( gammaChiC,fMCEvent,kFALSE) &&
3208  ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelelectronChiC,fMCEvent) &&
3209  ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelpositronChiC,fMCEvent) ){
3210  hMCChiCInAccPt[fiCut]->Fill(particle->Pt()); // All MC ChiC
3211  }
3212  }
3213  }
3214 }
3215 
3216 //_____________________________________________________________________________
3217 Bool_t AliAnalysisTaskGammaConvDalitzV1::IsDalitz(TParticle *fMCMother) const
3218 {
3219 
3220  if( fMCMother->GetNDaughters() != 3 ) return kFALSE;
3221  if( fMCMother->GetPdgCode() != 111 && fMCMother->GetPdgCode() != 221 ) return kFALSE;
3222 
3223 
3224  TParticle *positron = 0x0;
3225  TParticle *electron = 0x0;
3226  TParticle *gamma = 0x0;
3227 
3228  for(Int_t index= fMCMother->GetFirstDaughter();index<= fMCMother->GetLastDaughter();index++){
3229  TParticle* temp = (TParticle*)fMCEvent->Particle( index );
3230  switch( temp->GetPdgCode() ) {
3231  case ::kPositron:
3232  positron = temp;
3233  break;
3234  case ::kElectron:
3235  electron = temp;
3236  break;
3237  case ::kGamma:
3238  gamma = temp;
3239  break;
3240  }
3241  }
3242 
3243  if( positron && electron && gamma) return kTRUE;
3244 
3245  return kFALSE;
3246 }
3247 
3248 //_____________________________________________________________________________________
3249 Bool_t AliAnalysisTaskGammaConvDalitzV1::IsPi0DalitzDaughter( Int_t label ) const
3250 {
3251 //
3252 // Returns true if the particle comes from Pi0 -> e+ e- gamma
3253 //
3254  Int_t motherLabel = fMCEvent->Particle( label )->GetMother(0);
3255 
3256  if( motherLabel < 0 || motherLabel >= fMCEvent->GetNumberOfTracks() ) return kFALSE;
3257 
3258  TParticle* mother = fMCEvent->Particle( motherLabel );
3259 
3260  if( mother->GetPdgCode() != 111 ) return kFALSE;
3261 
3262  if( IsDalitz( mother ) ) return kTRUE;
3263 
3264  return kFALSE;
3265 
3266 }
3267 
3268 void AliAnalysisTaskGammaConvDalitzV1::FillElectronQAHistos(AliAODConversionPhoton *Vgamma) const
3269 {
3270 
3271  AliESDtrack *positronVgamma = 0;
3272  AliESDtrack *electronVgamma = 0;
3273 
3274  Double_t clsToFPos = -1.0;
3275  Double_t clsToFNeg = -1.0;
3276 
3277  Double_t NumClsITSPos = -1.0;
3278  Double_t NumClsITSNeg = -1.0;
3279  Double_t NumClsTPCPos = -1.0;
3280  Double_t NumClsTPCNeg = -1.0;
3281  Double_t nCrossedRowsTPCPos = -1.0;
3282  Double_t nCrossedRowsTPCNeg = -1.0;
3283 
3284  Float_t dcaToVertexXYPos = -1.0;
3285  Float_t dcaToVertexZPos = -1.0;
3286  Float_t dcaToVertexXYNeg = -1.0;
3287  Float_t dcaToVertexZNeg = -1.0;
3288 
3289  Double_t nSigmaPosTPC = -999.;
3290  Double_t nSigmaNegTPC = -999.;
3291 
3292  positronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
3293  electronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
3294  clsToFPos = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(positronVgamma);
3295  clsToFNeg = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(electronVgamma);
3296 
3297  nSigmaPosTPC = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(positronVgamma, AliPID::kElectron) ;
3298  nSigmaNegTPC = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(electronVgamma, AliPID::kElectron) ;
3299 
3300  NumClsITSPos = positronVgamma->GetNcls(0); //Get number of ITS clusters
3301  NumClsITSNeg = electronVgamma->GetNcls(0);
3302  NumClsTPCPos = positronVgamma->GetNcls(1); //Get number of TPC clusters
3303  NumClsTPCNeg = electronVgamma->GetNcls(1);
3304 
3305  nCrossedRowsTPCPos = positronVgamma->GetTPCCrossedRows();
3306  nCrossedRowsTPCNeg = electronVgamma->GetTPCCrossedRows();
3307 
3308  Float_t bPos[2];
3309  Float_t bCovPos[3];
3310  positronVgamma->GetImpactParameters(bPos,bCovPos);
3311 
3312  if (bCovPos[0]<=0 || bCovPos[2]<=0) {
3313  AliDebug(1, "Estimated b resolution lower or equal zero!");
3314  bCovPos[0]=0; bCovPos[2]=0;
3315  }
3316 
3317  Float_t bNeg[2];
3318  Float_t bCovNeg[3];
3319  positronVgamma->GetImpactParameters(bNeg,bCovNeg);
3320 
3321  if (bCovNeg[0]<=0 || bCovNeg[2]<=0) {
3322  AliDebug(1, "Estimated b resolution lower or equal zero!");
3323  bCovNeg[0]=0; bCovNeg[2]=0;
3324  }
3325 
3326  dcaToVertexXYPos = bPos[0];
3327  dcaToVertexZPos = bPos[1];
3328  dcaToVertexXYNeg = bNeg[0];
3329  dcaToVertexZNeg = bNeg[1];
3330 
3331  if( electronVgamma->P() > 0.3 && electronVgamma->P() < 0.45 ){
3332 
3333  hESDDalitzElectronAfterEtaPCut[fiCut]->Fill( electronVgamma->Eta() );
3334  hESDDalitzElectronAfterNClsITSPCut[fiCut]->Fill( NumClsITSNeg );
3335  hESDDalitzElectronAfterNFindClsTPCPCut[fiCut]->Fill(clsToFNeg);
3336  hESDDalitzElectronAfterNClsTPCPCut[fiCut]->Fill( NumClsTPCNeg );
3337  hESDDalitzElectronAfterNCrossedRowsTPCPCut[fiCut]->Fill( nCrossedRowsTPCNeg );
3338  }
3339  if( positronVgamma->P() > 0.3 && positronVgamma->P() < 0.45 ){
3340 
3341  hESDDalitzPositronAfterEtaPCut[fiCut]->Fill( positronVgamma->Eta() );
3342  hESDDalitzPositronAfterNClsITSPCut[fiCut]->Fill( NumClsITSPos );
3343  hESDDalitzPositronAfterNFindClsTPCPCut[fiCut]->Fill(clsToFPos);
3344  hESDDalitzPositronAfterNClsTPCPCut[fiCut]->Fill( NumClsTPCPos );
3345  hESDDalitzPositronAfterNCrossedRowsTPCPCut[fiCut]->Fill( nCrossedRowsTPCPos );
3346  }
3347 
3348  hESDDalitzElectronAfterPt[fiCut]->Fill( electronVgamma->Pt() );
3349  hESDDalitzPositronAfterPt[fiCut]->Fill( positronVgamma->Pt() );
3350 
3351  hESDDalitzElectronAfterEta[fiCut]->Fill( electronVgamma->Eta() );
3352  hESDDalitzPositronAfterEta[fiCut]->Fill( positronVgamma->Eta() );
3353 
3354  hESDDalitzElectronAfterPhi[fiCut]->Fill( electronVgamma->Phi() );
3355  hESDDalitzPositronAfterPhi[fiCut]->Fill( positronVgamma->Phi() );
3356 
3357  hESDDalitzElectronAfterNFindClsTPC[fiCut]->Fill(clsToFNeg,electronVgamma->Pt());
3358  hESDDalitzPositronAfterNFindClsTPC[fiCut]->Fill(clsToFPos,positronVgamma->Pt());
3359 
3360  hESDDalitzElectronAfterNClsTPC[fiCut]->Fill( NumClsTPCNeg,electronVgamma->Pt());
3361  hESDDalitzPositronAfterNClsTPC[fiCut]->Fill( NumClsTPCPos,positronVgamma->Pt());
3362 
3363  hESDDalitzElectronAfterNCrossedRowsTPC[fiCut]->Fill( nCrossedRowsTPCNeg, electronVgamma->Pt() );
3364  hESDDalitzPositronAfterNCrossedRowsTPC[fiCut]->Fill( nCrossedRowsTPCPos, positronVgamma->Pt() );
3365 
3366  hESDDalitzElectronAfterNClsITS[fiCut]->Fill( NumClsITSNeg);
3367  hESDDalitzPositronAfterNClsITS[fiCut]->Fill( NumClsITSPos);
3368 
3369  hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYNeg, electronVgamma->Pt() );
3370  hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZNeg, electronVgamma->Pt() );
3371  hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYPos, positronVgamma->Pt() );
3372  hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZPos, positronVgamma->Pt() );
3373 
3374  hESDDalitzElectronAfterTPCdEdxVsP[fiCut]->Fill( electronVgamma->P(),nSigmaNegTPC);
3375  hESDDalitzPositronAfterTPCdEdxVsP[fiCut]->Fill( positronVgamma->P(), nSigmaPosTPC);
3376 
3377  hESDDalitzElectronAfterTPCdEdxVsEta[fiCut]->Fill( electronVgamma->Eta(),nSigmaNegTPC);
3378  hESDDalitzPositronAfterTPCdEdxVsEta[fiCut]->Fill( positronVgamma->Eta(),nSigmaPosTPC);
3379 
3380  hESDDalitzElectronAfterTPCdEdxVsPhi[fiCut]->Fill( electronVgamma->Phi(),nSigmaNegTPC);
3381  hESDDalitzPositronAfterTPCdEdxVsPhi[fiCut]->Fill( positronVgamma->Phi(),nSigmaPosTPC);
3382 
3383  hESDDalitzElectronAfterTPCdEdxSignalVsP[fiCut]->Fill( electronVgamma->P(), TMath::Abs(electronVgamma->GetTPCsignal()));
3384  hESDDalitzPositronAfterTPCdEdxSignalVsP[fiCut]->Fill( positronVgamma->P(), TMath::Abs(positronVgamma->GetTPCsignal()));
3385 
3386 }
3387 
3388 //_____________________________________________________________________________
3389 Double_t AliAnalysisTaskGammaConvDalitzV1::GetPsiPairMC(const TParticle *fMCPosParticle, const TParticle *fMCNegParticle) const
3390 {
3391 
3392 
3393 
3394  TVector3 posDaughter;
3395  TVector3 negDaughter;
3396 
3397  posDaughter.SetXYZ( fMCPosParticle->Px(), fMCPosParticle->Py(), fMCPosParticle->Pz() );
3398  negDaughter.SetXYZ( fMCNegParticle->Px(), fMCNegParticle->Py(), fMCNegParticle->Pz() );
3399 
3400  Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();
3401  Double_t openingAngle = posDaughter.Angle( negDaughter ); //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );
3402 
3403  if( openingAngle < 1e-20 ) return 0.;
3404 
3405  Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );
3406 
3407  return psiAngle;
3408 
3409 
3410 }
3411 
3412 
3413 
3414 //_____________________________________________________________________________
3415 Double_t AliAnalysisTaskGammaConvDalitzV1::GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg ) const
3416 {
3417  //
3418  // This angle is a measure for the contribution of the opening in polar
3419  // direction ?0 to the opening angle ? Pair
3420  //
3421  // Ref. Measurement of photons via conversion pairs with the PHENIX experiment at RHIC
3422  // Mas ter Thesis. Thorsten Dahms. 2005
3423  // https://twiki.cern.ch/twiki/pub/ALICE/GammaPhysicsPublications/tdahms_thesis.pdf
3424  //
3425  Double_t momPos[3];
3426  Double_t momNeg[3];
3427  if( trackPos->GetConstrainedPxPyPz(momPos) == 0 ) trackPos->GetPxPyPz( momPos );
3428  if( trackNeg->GetConstrainedPxPyPz(momNeg) == 0 ) trackNeg->GetPxPyPz( momNeg );
3429 
3430  TVector3 posDaughter;
3431  TVector3 negDaughter;
3432 
3433  posDaughter.SetXYZ( momPos[0], momPos[1], momPos[2] );
3434  negDaughter.SetXYZ( momNeg[0], momNeg[1], momNeg[2] );
3435 
3436  Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();
3437  Double_t openingAngle = posDaughter.Angle( negDaughter ); //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );
3438 
3439  if( openingAngle < 1e-20 ) return 0.;
3440 
3441  Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );
3442 
3443  return psiAngle;
3444 }
3445 
3446 //________________________________________________________________________
3447 void AliAnalysisTaskGammaConvDalitzV1::SetLogBinningXTH2(TH2* histoRebin){
3448  TAxis *axisafter = histoRebin->GetXaxis();
3449  Int_t bins = axisafter->GetNbins();
3450  Double_t from = axisafter->GetXmin();
3451  Double_t to = axisafter->GetXmax();
3452  Double_t *newbins = new Double_t[bins+1];
3453  newbins[0] = from;
3454  Double_t factor = TMath::Power(to/from, 1./bins);
3455  for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
3456  axisafter->Set(bins, newbins);
3457  delete [] newbins;
3458 }
3459 
3460 
3461 //_________________________________________________________________________________
3462 Bool_t AliAnalysisTaskGammaConvDalitzV1::CheckVectorForDoubleCount(vector<Int_t> &vec, Int_t tobechecked)
3463 {
3464  if(tobechecked > -1)
3465  {
3466  vector<Int_t>::iterator it;
3467  it = find (vec.begin(), vec.end(), tobechecked);
3468  if (it != vec.end()) return true;
3469  else{
3470  vec.push_back(tobechecked);
3471  return false;
3472  }
3473  }
3474  return false;
3475 }
AliConversionPhotonBase::GetMCParticle
TParticle * GetMCParticle(AliMCEvent *mcEvent)
Definition: AliConversionPhotonBase.cxx:69
AliAODConversionPhoton::GetPy
virtual Double_t GetPy() const
Definition: AliAODConversionPhoton.h:43
AliAnalysisTaskGammaConvDalitzV1::ProcessTruePhotonCandidates
void ProcessTruePhotonCandidates(AliAODConversionPhoton *)
Definition: AliAnalysisTaskGammaConvDalitzV1.cxx:1907
AliAnalysisTaskGammaConvDalitzV1::fVectorDoubleCountTruePi0s
vector< Int_t > fVectorDoubleCountTruePi0s
array of histos with double counted photons, R, pT
Definition: AliAnalysisTaskGammaConvDalitzV1.h:283
AliAODConversionMother::SetLabels
void SetLabels(Int_t label1, Int_t label2, Int_t label3=0)
Definition: AliAODConversionMother.h:58
Double_t
double Double_t
Definition: External.C:58
AliGammaConversionAODBGHandler::GetBGEventVertex
GammaConversionVertex * GetBGEventVertex(Int_t zbin, Int_t mbin, Int_t event)
Definition: AliGammaConversionAODBGHandler.h:81
TH2F
Definition: External.C:236
AliAnalysisTaskGammaConvDalitzV1::GetPsiPair
Double_t GetPsiPair(const AliESDtrack *trackPos, const AliESDtrack *trackNeg) const
Definition: AliAnalysisTaskGammaConvDalitzV1.cxx:3415
AliConversionPhotonBase::SetConversionPoint
void SetConversionPoint(Double_t convpoint[3])
Definition: AliConversionPhotonBase.h:89
AliDalitzElectronSelector::GetReconstructedPositronsIndex
vector< Int_t > GetReconstructedPositronsIndex()
Definition: AliDalitzElectronSelector.h:37
AliAODConversionPhoton::GetPz
virtual Double_t GetPz() const
Definition: AliAODConversionPhoton.h:44
AliConversionPhotonBase::SetMCLabelNegative
void SetMCLabelNegative(Int_t label)
Definition: AliConversionPhotonBase.h:66
AliAnalysisTaskGammaConvDalitzV1::MoveParticleAccordingToVertex
void MoveParticleAccordingToVertex(AliAODConversionPhoton *particle, const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex)
Definition: AliAnalysisTaskGammaConvDalitzV1.cxx:2967
AliV0ReaderV1::GetNumberOfPrimaryTracks
Int_t GetNumberOfPrimaryTracks()
Definition: AliV0ReaderV1.h:129
AliAnalysisTaskGammaConvDalitzV1::fHistoDoubleCountTrueEtaInvMassPt
TH2F ** fHistoDoubleCountTrueEtaInvMassPt
array of histos with double counted pi0s, invMass, pT
Definition: AliAnalysisTaskGammaConvDalitzV1.h:281
AliAnalysisTaskGammaConvDalitzV1::RotateParticleAccordingToEP
void RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP)
Definition: AliAnalysisTaskGammaConvDalitzV1.cxx:2957
AliV0ReaderV1::GetPeriodName
TString GetPeriodName()
Definition: AliV0ReaderV1.h:127
AliConversionPhotonBase::GetPositiveMCDaughter
TParticle * GetPositiveMCDaughter(AliMCEvent *mcEvent)
Definition: AliConversionPhotonBase.h:76
AliAnalysisTaskGammaConvDalitzV1::FillElectronQAHistos
void FillElectronQAHistos(AliAODConversionPhoton *Vgamma) const
Definition: AliAnalysisTaskGammaConvDalitzV1.cxx:3268
AliV0ReaderV1::GetProduceV0FindingEfficiency
Bool_t GetProduceV0FindingEfficiency()
Definition: AliV0ReaderV1.h:139
AliConversionPhotonBase::GetNegativeMCDaughter
TParticle * GetNegativeMCDaughter(AliMCEvent *mcEvent)
Definition: AliConversionPhotonBase.h:77
AliGammaConversionAODVector
std::vector< AliAODConversionPhoton * > AliGammaConversionAODVector
Definition: AliGammaConversionAODBGHandler.h:24
AliAnalysisTaskGammaConvDalitzV1::fVectorDoubleCountTrueEtas
vector< Int_t > fVectorDoubleCountTrueEtas
vector containing labels of validated pi0
Definition: AliAnalysisTaskGammaConvDalitzV1.h:284
Int_t
int Int_t
Definition: External.C:63
TH1I
Definition: External.C:204
UInt_t
unsigned int UInt_t
Definition: External.C:33
AliDalitzElectronSelector::GetReconstructedElectronsIndex
vector< Int_t > GetReconstructedElectronsIndex()
Definition: AliDalitzElectronSelector.h:36
Float_t
float Float_t
Definition: External.C:68
AliConversionPhotonBase::SetMCLabelPositive
void SetMCLabelPositive(Int_t label)
Definition: AliConversionPhotonBase.h:65
AliGammaConversionAODBGHandler::AddEvent
void AddEvent(TList *const eventGammas, Double_t xvalue, Double_t yvalue, Double_t zvalue, Int_t multiplicity, Double_t epvalue=-100)
Definition: AliGammaConversionAODBGHandler.cxx:567
AliAnalysisTaskGammaConvDalitzV1::fHistoDoubleCountTrueConvGammaRPt
TH2F ** fHistoDoubleCountTrueConvGammaRPt
array of histos with double counted etas, invMass, pT
Definition: AliAnalysisTaskGammaConvDalitzV1.h:282
AliAnalysisTaskGammaConvDalitzV1::hNV0Tracks
TH1I ** hNV0Tracks
array of histos with SPD tracklets vs SPD clusters for background rejection
Definition: AliAnalysisTaskGammaConvDalitzV1.h:278
AliV0ReaderV1::GetConversionCuts
AliConversionPhotonCuts * GetConversionCuts()
Definition: AliV0ReaderV1.h:89
AliAnalysisTaskGammaConvDalitzV1::fVectorDoubleCountTrueConvGammas
vector< Int_t > fVectorDoubleCountTrueConvGammas
vector containing labels of validated eta
Definition: AliAnalysisTaskGammaConvDalitzV1.h:285
AliConversionPhotonCuts
Class handling all kinds of selection cuts for Gamma Conversion analysis.
Definition: AliConversionPhotonCuts.h:76
AliConversionPhotonBase::GetMCParticleLabel
Int_t GetMCParticleLabel(AliMCEvent *mcEvent)
Definition: AliConversionPhotonBase.cxx:93
kBoth
Definition: FitMassSpectra.C:39
AliAODConversionMother::GetOpeningAngle
Double_t GetOpeningAngle() const
Definition: AliAODConversionMother.h:84
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
AliDalitzElectronSelector::GetDalitzElectronCuts
AliDalitzElectronCuts * GetDalitzElectronCuts()
Definition: AliDalitzElectronSelector.h:38
centMax
Double_t centMax
Definition: MuonTrackingEfficiency.C:51
AliConversionPhotonBase::SetTrackLabels
void SetTrackLabels(Int_t label1, Int_t label2)
Definition: AliConversionPhotonBase.h:54
AliGammaConversionAODBGHandler::GetBGGoodV0s
AliGammaConversionAODVector * GetBGGoodV0s(Int_t zbin, Int_t mbin, Int_t event)
Definition: AliGammaConversionAODBGHandler.cxx:704
AliAODConversionPhoton::GetPx
virtual Double_t GetPx() const
Definition: AliAODConversionPhoton.h:42
TH2
Definition: External.C:220
AliConversionMesonCuts
Class handling all kinds of selection cuts for Gamma Conversion analysis.
Definition: AliConversionMesonCuts.h:62
AliV0ReaderV1::GetReconstructedGammas
TClonesArray * GetReconstructedGammas() const
Definition: AliV0ReaderV1.h:85
AliConvEventCuts
Class handling all kinds of selection cuts for Gamma Conversion analysis.
Definition: AliConvEventCuts.h:55
AliAnalysisTaskGammaConvDalitzV1::IsDalitz
Bool_t IsDalitz(TParticle *fMCMother) const
Definition: AliAnalysisTaskGammaConvDalitzV1.cxx:3217
AliV0ReaderV1::GetEventCuts
AliConvEventCuts * GetEventCuts()
Definition: AliV0ReaderV1.h:90
Option_t
const char Option_t
Definition: External.C:48
AliAnalysisTaskGammaConvDalitzV1::ProcessTrueChicCandidates
void ProcessTrueChicCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate, AliAODConversionPhoton *TruejpsiCandidate)
Definition: AliAnalysisTaskGammaConvDalitzV1.cxx:2880
Bool_t
bool Bool_t
Definition: External.C:53
AliAnalysisTaskGammaConvDalitzV1::CheckVectorForDoubleCount
Bool_t CheckVectorForDoubleCount(vector< Int_t > &vec, Int_t tobechecked)
Definition: AliAnalysisTaskGammaConvDalitzV1.cxx:3462
AliAnalysisTaskGammaConvDalitzV1::ProcessTrueMesonCandidates
void ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate, AliAODConversionPhoton *TrueVirtualGammaCandidate)
Definition: AliAnalysisTaskGammaConvDalitzV1.cxx:2675
AliAnalysisTaskGammaConvDalitzV1::GetPsiPairMC
Double_t GetPsiPairMC(const TParticle *fMCPosParticle, const TParticle *fMCNegParticle) const
Definition: AliAnalysisTaskGammaConvDalitzV1.cxx:3389
AliAnalysisTaskGammaConvDalitzV1.h
AliAODConversionMother::CalculateDistanceOfClossetApproachToPrimVtx
void CalculateDistanceOfClossetApproachToPrimVtx(const AliVVertex *primVertex)
Definition: AliAODConversionMother.cxx:237
AliAnalysisTaskGammaConvDalitzV1::fBGHandler
AliGammaConversionAODBGHandler ** fBGHandler
Definition: AliAnalysisTaskGammaConvDalitzV1.h:100
AliConversionPhotonBase::GetConversionRadius
Double_t GetConversionRadius() const
Definition: AliConversionPhotonBase.h:91
AliV0ReaderV1::GetV0FindingEfficiencyHistograms
TList * GetV0FindingEfficiencyHistograms()
Definition: AliV0ReaderV1.h:140
centMin
Double_t centMin
Definition: MuonTrackingEfficiency.C:50