]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/GammaConv/AliAnalysisTaskGammaConvCalo.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- added additional event selection for LHC11a EMCAL analysis, due to hardware problem...
[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliAnalysisTaskGammaConvCalo.cxx
CommitLineData
8bdca7f1 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: Baldo Sahlmueller, Friederike Bock *
5 * Version 1.0 *
6 * *
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//////////////////////////////////////////////////////////////////
18//----------------------------------------------------------------
19// Class used to do analysis on conversion photons + calo photons
20//----------------------------------------------------------------
21//////////////////////////////////////////////////////////////////
22#include "TChain.h"
23#include "TTree.h"
24#include "TBranch.h"
25#include "TFile.h"
26#include "TH1F.h"
27#include "TH2F.h"
28#include "TH3F.h"
29#include "THnSparse.h"
30#include "TCanvas.h"
31#include "TNtuple.h"
32#include "AliAnalysisTask.h"
33#include "AliAnalysisManager.h"
34#include "AliESDEvent.h"
35#include "AliESDInputHandler.h"
36#include "AliMCEventHandler.h"
37#include "AliMCEvent.h"
38#include "AliMCParticle.h"
39#include "AliCentrality.h"
40#include "AliESDVZERO.h"
41#include "AliESDpid.h"
42#include "AliAnalysisTaskGammaConvCalo.h"
43#include "AliVParticle.h"
44#include "AliESDtrack.h"
45#include "AliESDtrackCuts.h"
46#include "AliKFVertex.h"
47#include "AliV0ReaderV1.h"
48#include "AliGenCocktailEventHeader.h"
49#include "AliConversionAODBGHandlerRP.h"
50#include "AliAODMCParticle.h"
51#include "AliAODMCHeader.h"
52#include "AliEventplane.h"
53#include "AliAnalysisTaskEMCALClusterizeFast.h"
54#include "AliAODEvent.h"
55#include "AliAODInputHandler.h"
56#include "AliESDEvent.h"
57#include "AliESDInputHandler.h"
58#include "AliInputEventHandler.h"
59
60ClassImp(AliAnalysisTaskGammaConvCalo)
61
62//________________________________________________________________________
63AliAnalysisTaskGammaConvCalo::AliAnalysisTaskGammaConvCalo(): AliAnalysisTaskSE(),
64 fV0Reader(NULL),
65 fBGHandler(NULL),
66 fBGHandlerRP(NULL),
67 fBGClusHandler(NULL),
68 fBGClusHandlerRP(NULL),
69 fInputEvent(NULL),
70 fMCEvent(NULL),
71 fMCStack(NULL),
72 fCutFolder(NULL),
73 fESDList(NULL),
74 fBackList(NULL),
75 fMotherList(NULL),
76 fPhotonDCAList(NULL),
77 fMesonDCAList(NULL),
78 fTrueList(NULL),
79 fMCList(NULL),
80 fHeaderNameList(NULL),
81 fTagOutputList(NULL),
82 fOutputContainer(NULL),
83 fReaderGammas(NULL),
84 fGammaCandidates(NULL),
85 fClusterCandidates(NULL),
344100c4 86 fEventCutArray(NULL),
87 fEventCuts(NULL),
8bdca7f1 88 fCutArray(NULL),
89 fConversionCuts(NULL),
90 fClusterCutArray(NULL),
91 fCaloPhotonCuts(NULL),
92 fMesonCutArray(NULL),
93 fMesonCuts(NULL),
94 fHistoConvGammaPt(NULL),
95 fHistoConvGammaR(NULL),
96 fHistoConvGammaEta(NULL),
97 fTreeConvGammaPtDcazCat(NULL),
98 fPtGamma(0),
99 fDCAzPhoton(0),
100 fRConvPhoton(0),
101 fEtaPhoton(0),
102 fCharCatPhoton(0),
103 fCharPhotonMCInfo(0),
104 fHistoMotherInvMassPt(NULL),
d53bf4ac 105 fHistoMotherMatchedInvMassPt(NULL),
8bdca7f1 106 fSparseMotherInvMassPtZM(NULL),
107 fHistoMotherBackInvMassPt(NULL),
108 fSparseMotherBackInvMassPtZM(NULL),
109 fHistoMotherInvMassEalpha(NULL),
110 fHistoMotherPi0PtY(NULL),
111 fHistoMotherEtaPtY(NULL),
112 fHistoMotherPi0PtAlpha(NULL),
113 fHistoMotherEtaPtAlpha(NULL),
114 fHistoMotherPi0PtOpenAngle(NULL),
115 fHistoMotherEtaPtOpenAngle(NULL),
4e8dcc76 116 fHistoMotherPi0ConvPhotonEtaPhi(NULL),
117 fHistoMotherEtaConvPhotonEtaPhi(NULL),
20af4b69 118 fHistoMotherInvMassECalib(NULL),
119 fHistoMotherInvMassECalibalpha(NULL),
8bdca7f1 120 fTreeMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
121 fInvMass(0),
122 fPt(0),
123 fDCAzGammaMin(0),
124 fDCAzGammaMax(0),
125 fCharFlag(0),
126 fCharMesonMCInfo(0),
127 fHistoConvGammaUntagged(NULL),
128 fHistoConvGammaTagged(NULL),
129 fHistoConvGammaPi0Tagged(NULL),
130 fHistoConvGammaEtaTagged(NULL),
131 fHistoPhotonPairAll(NULL),
132 fHistoPhotonPairAllGam(NULL),
133 fHistoClusGammaPt(NULL),
134 fHistoMCHeaders(NULL),
135 fHistoMCAllGammaPt(NULL),
20af4b69 136 fHistoMCAllGammaEMCALAccPt(NULL),
8bdca7f1 137 fHistoMCDecayGammaPi0Pt(NULL),
138 fHistoMCDecayGammaRhoPt(NULL),
139 fHistoMCDecayGammaEtaPt(NULL),
140 fHistoMCDecayGammaOmegaPt(NULL),
141 fHistoMCDecayGammaEtapPt(NULL),
142 fHistoMCDecayGammaPhiPt(NULL),
143 fHistoMCDecayGammaSigmaPt(NULL),
144 fHistoMCConvGammaPt(NULL),
145 fHistoMCConvGammaR(NULL),
146 fHistoMCConvGammaEta(NULL),
147 fHistoMCPi0Pt(NULL),
148 fHistoMCPi0WOWeightPt(NULL),
149 fHistoMCEtaPt(NULL),
150 fHistoMCEtaWOWeightPt(NULL),
151 fHistoMCPi0InAccPt(NULL),
152 fHistoMCEtaInAccPt(NULL),
153 fHistoMCPi0PtY(NULL),
154 fHistoMCEtaPtY(NULL),
de752898 155 fHistoMCPi0PtAlpha(NULL),
156 fHistoMCEtaPtAlpha(NULL),
8bdca7f1 157 fHistoMCK0sPt(NULL),
158 fHistoMCK0sWOWeightPt(NULL),
159 fHistoMCK0sPtY(NULL),
160 fHistoMCSecPi0PtvsSource(NULL),
161 fHistoMCSecPi0Source(NULL),
162 fHistoMCSecEtaPt(NULL),
163 fHistoMCSecEtaSource(NULL),
ed8bc1ca 164 fHistoTruePi0InvMassPt(NULL),
165 fHistoTrueEtaInvMassPt(NULL),
166 fHistoTruePi0CaloPhotonInvMassPt(NULL),
167 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
20af4b69 168 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
169 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
170 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
171 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
ed8bc1ca 172 fHistoTruePi0CaloElectronInvMassPt(NULL),
173 fHistoTrueEtaCaloElectronInvMassPt(NULL),
174 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
175 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
fd94f234 176 fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
ed8bc1ca 177 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
178 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
179 fHistoTruePrimaryPi0InvMassPt(NULL),
180 fHistoTruePrimaryEtaInvMassPt(NULL),
181 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
182 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
183 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
184 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
8bdca7f1 185 fHistoTruePrimaryPi0MCPtResolPt(NULL),
186 fHistoTruePrimaryEtaMCPtResolPt(NULL),
ed8bc1ca 187 fHistoTrueSecondaryPi0InvMassPt(NULL),
188 fHistoTrueSecondaryEtaInvMassPt(NULL),
189 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
8bdca7f1 190 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
ed8bc1ca 191 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
8bdca7f1 192 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
ed8bc1ca 193 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
8bdca7f1 194 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
195 fHistoTrueBckGGInvMassPt(NULL),
196 fHistoTrueBckContInvMassPt(NULL),
197 fHistoTruePi0PtY(NULL),
198 fHistoTrueEtaPtY(NULL),
199 fHistoTruePi0PtAlpha(NULL),
200 fHistoTrueEtaPtAlpha(NULL),
201 fHistoTruePi0PtOpenAngle(NULL),
202 fHistoTrueEtaPtOpenAngle(NULL),
8bdca7f1 203 fHistoTrueConvGammaPt(NULL),
204 fHistoTrueConvPi0GammaPt(NULL),
205 fHistoTrueConvGammaEta(NULL),
206 fHistoCombinatorialPt(NULL),
207 fHistoTruePrimaryConvGammaPt(NULL),
208 fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
209 fHistoTrueSecondaryConvGammaPt(NULL),
210 fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
211 fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
8bdca7f1 212 fHistoTrueClusGammaPt(NULL),
fd94f234 213 fHistoTrueClusUnConvGammaPt(NULL),
20af4b69 214 fHistoTrueClusUnConvGammaMCPt(NULL),
fd94f234 215 fHistoTrueClusElectronPt(NULL),
216 fHistoTrueClusConvGammaPt(NULL),
20af4b69 217 fHistoTrueClusConvGammaMCPt(NULL),
fd94f234 218 fHistoTrueClusConvGammaFullyPt(NULL),
219 fHistoTrueClusMergedGammaPt(NULL),
220 fHistoTrueClusMergedPartConvGammaPt(NULL),
221 fHistoTrueClusDalitzPt(NULL),
222 fHistoTrueClusDalitzMergedPt(NULL),
223 fHistoTrueClusPhotonFromElecMotherPt(NULL),
224 fHistoTrueClusShowerPt(NULL),
cc579963 225 fHistoTrueClusSubLeadingPt(NULL),
226 fHistoTrueClusNParticles(NULL),
fd94f234 227 fHistoTrueClusEMNonLeadingPt(NULL),
228 fHistoTrueNLabelsInClus(NULL),
8bdca7f1 229 fHistoTruePrimaryClusGammaPt(NULL),
230 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
231 fHistoNEvents(NULL),
232 fHistoNGoodESDTracks(NULL),
233 fHistoNGammaCandidates(NULL),
234 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
235 fHistoNV0Tracks(NULL),
236 fProfileEtaShift(NULL),
237 fEventPlaneAngle(-100),
238 fRandom(0),
239 fNGammaCandidates(0),
240 fUnsmearedPx(NULL),
241 fUnsmearedPy(NULL),
242 fUnsmearedPz(NULL),
243 fUnsmearedE(NULL),
244 fMCStackPos(NULL),
245 fMCStackNeg(NULL),
246 fESDArrayPos(NULL),
247 fESDArrayNeg(NULL),
248 fnCuts(0),
249 fiCut(0),
250 fMoveParticleAccordingToVertex(kTRUE),
251 fIsHeavyIon(0),
252 fDoMesonAnalysis(kTRUE),
253 fDoMesonQA(0),
254 fDoPhotonQA(0),
fd94f234 255 fDoClusterQA(0),
8bdca7f1 256 fIsFromMBHeader(kTRUE),
d53bf4ac 257 fIsMC(kFALSE)
8bdca7f1 258{
259
260}
261
262//________________________________________________________________________
263AliAnalysisTaskGammaConvCalo::AliAnalysisTaskGammaConvCalo(const char *name):
264 AliAnalysisTaskSE(name),
265 fV0Reader(NULL),
266 fBGHandler(NULL),
267 fBGHandlerRP(NULL),
268 fBGClusHandler(NULL),
269 fBGClusHandlerRP(NULL),
270 fInputEvent(NULL),
271 fMCEvent(NULL),
272 fMCStack(NULL),
273 fCutFolder(NULL),
274 fESDList(NULL),
275 fBackList(NULL),
276 fMotherList(NULL),
277 fPhotonDCAList(NULL),
278 fMesonDCAList(NULL),
279 fTrueList(NULL),
280 fMCList(NULL),
281 fHeaderNameList(NULL),
282 fTagOutputList(NULL),
283 fOutputContainer(0),
284 fReaderGammas(NULL),
285 fGammaCandidates(NULL),
286 fClusterCandidates(NULL),
344100c4 287 fEventCutArray(NULL),
288 fEventCuts(NULL),
8bdca7f1 289 fCutArray(NULL),
290 fConversionCuts(NULL),
291 fClusterCutArray(NULL),
292 fCaloPhotonCuts(NULL),
293 fMesonCutArray(NULL),
294 fMesonCuts(NULL),
295 fHistoConvGammaPt(NULL),
296 fHistoConvGammaR(NULL),
297 fHistoConvGammaEta(NULL),
298 fTreeConvGammaPtDcazCat(NULL),
299 fPtGamma(0),
300 fDCAzPhoton(0),
301 fRConvPhoton(0),
302 fEtaPhoton(0),
303 fCharCatPhoton(0),
304 fCharPhotonMCInfo(0),
305 fHistoMotherInvMassPt(NULL),
d53bf4ac 306 fHistoMotherMatchedInvMassPt(NULL),
8bdca7f1 307 fSparseMotherInvMassPtZM(NULL),
308 fHistoMotherBackInvMassPt(NULL),
309 fSparseMotherBackInvMassPtZM(NULL),
310 fHistoMotherInvMassEalpha(NULL),
311 fHistoMotherPi0PtY(NULL),
312 fHistoMotherEtaPtY(NULL),
313 fHistoMotherPi0PtAlpha(NULL),
314 fHistoMotherEtaPtAlpha(NULL),
315 fHistoMotherPi0PtOpenAngle(NULL),
316 fHistoMotherEtaPtOpenAngle(NULL),
4e8dcc76 317 fHistoMotherPi0ConvPhotonEtaPhi(NULL),
318 fHistoMotherEtaConvPhotonEtaPhi(NULL),
20af4b69 319 fHistoMotherInvMassECalib(NULL),
320 fHistoMotherInvMassECalibalpha(NULL),
8bdca7f1 321 fTreeMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
322 fInvMass(0),
323 fPt(0),
324 fDCAzGammaMin(0),
325 fDCAzGammaMax(0),
326 fCharFlag(0),
327 fCharMesonMCInfo(0),
328 fHistoConvGammaUntagged(NULL),
329 fHistoConvGammaTagged(NULL),
330 fHistoConvGammaPi0Tagged(NULL),
331 fHistoConvGammaEtaTagged(NULL),
332 fHistoPhotonPairAll(NULL),
333 fHistoPhotonPairAllGam(NULL),
334 fHistoClusGammaPt(NULL),
335 fHistoMCHeaders(NULL),
336 fHistoMCAllGammaPt(NULL),
20af4b69 337 fHistoMCAllGammaEMCALAccPt(NULL),
8bdca7f1 338 fHistoMCDecayGammaPi0Pt(NULL),
339 fHistoMCDecayGammaRhoPt(NULL),
340 fHistoMCDecayGammaEtaPt(NULL),
341 fHistoMCDecayGammaOmegaPt(NULL),
342 fHistoMCDecayGammaEtapPt(NULL),
343 fHistoMCDecayGammaPhiPt(NULL),
344 fHistoMCDecayGammaSigmaPt(NULL),
345 fHistoMCConvGammaPt(NULL),
346 fHistoMCConvGammaR(NULL),
347 fHistoMCConvGammaEta(NULL),
348 fHistoMCPi0Pt(NULL),
349 fHistoMCPi0WOWeightPt(NULL),
350 fHistoMCEtaPt(NULL),
351 fHistoMCEtaWOWeightPt(NULL),
352 fHistoMCPi0InAccPt(NULL),
353 fHistoMCEtaInAccPt(NULL),
354 fHistoMCPi0PtY(NULL),
355 fHistoMCEtaPtY(NULL),
de752898 356 fHistoMCPi0PtAlpha(NULL),
357 fHistoMCEtaPtAlpha(NULL),
8bdca7f1 358 fHistoMCK0sPt(NULL),
359 fHistoMCK0sWOWeightPt(NULL),
360 fHistoMCK0sPtY(NULL),
361 fHistoMCSecPi0PtvsSource(NULL),
362 fHistoMCSecPi0Source(NULL),
363 fHistoMCSecEtaPt(NULL),
364 fHistoMCSecEtaSource(NULL),
ed8bc1ca 365 fHistoTruePi0InvMassPt(NULL),
366 fHistoTrueEtaInvMassPt(NULL),
367 fHistoTruePi0CaloPhotonInvMassPt(NULL),
368 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
20af4b69 369 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
370 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
371 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
372 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
ed8bc1ca 373 fHistoTruePi0CaloElectronInvMassPt(NULL),
374 fHistoTrueEtaCaloElectronInvMassPt(NULL),
375 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
376 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
fd94f234 377 fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
ed8bc1ca 378 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
379 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
380 fHistoTruePrimaryPi0InvMassPt(NULL),
381 fHistoTruePrimaryEtaInvMassPt(NULL),
382 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
383 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
384 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
385 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
8bdca7f1 386 fHistoTruePrimaryPi0MCPtResolPt(NULL),
387 fHistoTruePrimaryEtaMCPtResolPt(NULL),
ed8bc1ca 388 fHistoTrueSecondaryPi0InvMassPt(NULL),
389 fHistoTrueSecondaryEtaInvMassPt(NULL),
390 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
8bdca7f1 391 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
ed8bc1ca 392 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
8bdca7f1 393 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
ed8bc1ca 394 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
8bdca7f1 395 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
396 fHistoTrueBckGGInvMassPt(NULL),
397 fHistoTrueBckContInvMassPt(NULL),
398 fHistoTruePi0PtY(NULL),
399 fHistoTrueEtaPtY(NULL),
400 fHistoTruePi0PtAlpha(NULL),
401 fHistoTrueEtaPtAlpha(NULL),
402 fHistoTruePi0PtOpenAngle(NULL),
403 fHistoTrueEtaPtOpenAngle(NULL),
8bdca7f1 404 fHistoTrueConvGammaPt(NULL),
405 fHistoTrueConvPi0GammaPt(NULL),
406 fHistoTrueConvGammaEta(NULL),
407 fHistoCombinatorialPt(NULL),
408 fHistoTruePrimaryConvGammaPt(NULL),
409 fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
410 fHistoTrueSecondaryConvGammaPt(NULL),
411 fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
412 fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
8bdca7f1 413 fHistoTrueClusGammaPt(NULL),
fd94f234 414 fHistoTrueClusUnConvGammaPt(NULL),
20af4b69 415 fHistoTrueClusUnConvGammaMCPt(NULL),
fd94f234 416 fHistoTrueClusElectronPt(NULL),
417 fHistoTrueClusConvGammaPt(NULL),
20af4b69 418 fHistoTrueClusConvGammaMCPt(NULL),
fd94f234 419 fHistoTrueClusConvGammaFullyPt(NULL),
420 fHistoTrueClusMergedGammaPt(NULL),
421 fHistoTrueClusMergedPartConvGammaPt(NULL),
422 fHistoTrueClusDalitzPt(NULL),
423 fHistoTrueClusDalitzMergedPt(NULL),
424 fHistoTrueClusPhotonFromElecMotherPt(NULL),
425 fHistoTrueClusShowerPt(NULL),
cc579963 426 fHistoTrueClusSubLeadingPt(NULL),
427 fHistoTrueClusNParticles(NULL),
fd94f234 428 fHistoTrueClusEMNonLeadingPt(NULL),
429 fHistoTrueNLabelsInClus(NULL),
8bdca7f1 430 fHistoTruePrimaryClusGammaPt(NULL),
431 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
432 fHistoNEvents(NULL),
433 fHistoNGoodESDTracks(NULL),
434 fHistoNGammaCandidates(NULL),
435 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
436 fHistoNV0Tracks(NULL),
437 fProfileEtaShift(NULL),
438 fEventPlaneAngle(-100),
439 fRandom(0),
440 fNGammaCandidates(0),
441 fUnsmearedPx(NULL),
442 fUnsmearedPy(NULL),
443 fUnsmearedPz(NULL),
444 fUnsmearedE(NULL),
445 fMCStackPos(NULL),
446 fMCStackNeg(NULL),
447 fESDArrayPos(NULL),
448 fESDArrayNeg(NULL),
449 fnCuts(0),
450 fiCut(0),
451 fMoveParticleAccordingToVertex(kTRUE),
452 fIsHeavyIon(0),
453 fDoMesonAnalysis(kTRUE),
454 fDoMesonQA(0),
455 fDoPhotonQA(0),
fd94f234 456 fDoClusterQA(0),
8bdca7f1 457 fIsFromMBHeader(kTRUE),
d53bf4ac 458 fIsMC(kFALSE)
8bdca7f1 459{
460 // Define output slots here
461 DefineOutput(1, TList::Class());
462}
463
464AliAnalysisTaskGammaConvCalo::~AliAnalysisTaskGammaConvCalo()
465{
466 if(fGammaCandidates){
467 delete fGammaCandidates;
468 fGammaCandidates = 0x0;
469 }
470 if(fClusterCandidates){
471 delete fClusterCandidates;
472 fClusterCandidates = 0x0;
473 }
474 if(fBGHandler){
475 delete[] fBGHandler;
476 fBGHandler = 0x0;
477 }
478 if(fBGHandlerRP){
479 delete[] fBGHandlerRP;
480 fBGHandlerRP = 0x0;
481 }
482 if(fBGClusHandler){
483 delete[] fBGClusHandler;
484 fBGClusHandler = 0x0;
485 }
486 if(fBGClusHandlerRP){
487 delete[] fBGClusHandlerRP;
488 fBGClusHandlerRP = 0x0;
489 }
490}
491//___________________________________________________________
492void AliAnalysisTaskGammaConvCalo::InitBack(){
493
494 const Int_t nDim = 4;
495 Int_t nBins[nDim] = {800,250,7,4};
496 Double_t xMin[nDim] = {0,0, 0,0};
497 Double_t xMax[nDim] = {0.8,25,7,4};
498
499 fSparseMotherInvMassPtZM = new THnSparseF*[fnCuts];
500 fSparseMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
501
502 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
503 fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
504
505 fBGClusHandler = new AliGammaConversionAODBGHandler*[fnCuts];
506 fBGClusHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
507
508 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
509 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
344100c4 510 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
511 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
512 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
513 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
8bdca7f1 514
344100c4 515 Int_t collisionSystem = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(0,1));
516 Int_t centMin = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(1,1));
517 Int_t centMax = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(2,1));
8bdca7f1 518
519 if(collisionSystem == 1 || collisionSystem == 2 ||
520 collisionSystem == 5 || collisionSystem == 8 ||
521 collisionSystem == 9){
522 centMin = centMin*10;
523 centMax = centMax*10;
524 if(centMax ==0 && centMax!=centMin) centMax=100;
525 } else if(collisionSystem == 3 || collisionSystem == 6){
526 centMin = centMin*5;
527 centMax = centMax*5;
528 } else if(collisionSystem == 4 || collisionSystem == 7){
529 centMin = ((centMin*5)+45);
530 centMax = ((centMax*5)+45);
531 }
532
533 fBackList[iCut] = new TList();
344100c4 534 fBackList[iCut]->SetName(Form("%s_%s_%s_%s Back histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(), cutstringMeson.Data()));
8bdca7f1 535 fBackList[iCut]->SetOwner(kTRUE);
536 fCutFolder[iCut]->Add(fBackList[iCut]);
537
538 fSparseMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
539 fBackList[iCut]->Add(fSparseMotherBackInvMassPtZM[iCut]);
540
541 fMotherList[iCut] = new TList();
344100c4 542 fMotherList[iCut]->SetName(Form("%s_%s_%s_%s Mother histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
8bdca7f1 543 fMotherList[iCut]->SetOwner(kTRUE);
544 fCutFolder[iCut]->Add(fMotherList[iCut]);
545
546 fSparseMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
547 fMotherList[iCut]->Add(fSparseMotherInvMassPtZM[iCut]);
548
549 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
550 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
551 collisionSystem,centMin,centMax,
552 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
cfd87ccd 553 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity(),
554 2,8,7);
8bdca7f1 555 fBGClusHandler[iCut] = new AliGammaConversionAODBGHandler(
556 collisionSystem,centMin,centMax,
557 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
cfd87ccd 558 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity(),
559 2,8,7);
8bdca7f1 560 fBGHandlerRP[iCut] = NULL;
561 } else{
562 fBGHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
344100c4 563 ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsHeavyIon(),
8bdca7f1 564 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
565 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
566 fBGClusHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
344100c4 567 ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsHeavyIon(),
8bdca7f1 568 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
569 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
570 fBGHandler[iCut] = NULL;
571 }
572 }
573 }
574}
575//________________________________________________________________________
576void AliAnalysisTaskGammaConvCalo::UserCreateOutputObjects(){
577
578 // Create histograms
579 if(fOutputContainer != NULL){
580 delete fOutputContainer;
581 fOutputContainer = NULL;
582 }
583 if(fOutputContainer == NULL){
584 fOutputContainer = new TList();
585 fOutputContainer->SetOwner(kTRUE);
586 }
587
588 // Array of current cut's gammas
589 fGammaCandidates = new TList();
590 fClusterCandidates = new TList();
591
592 fCutFolder = new TList*[fnCuts];
593 fESDList = new TList*[fnCuts];
594 fBackList = new TList*[fnCuts];
595 fMotherList = new TList*[fnCuts];
596 fHistoNEvents = new TH1I*[fnCuts];
597 fHistoNGoodESDTracks = new TH1I*[fnCuts];
598 fHistoNGammaCandidates = new TH1I*[fnCuts];
599 fHistoNGoodESDTracksVsNGammaCanditates = new TH2F*[fnCuts];
600 fHistoNV0Tracks = new TH1I*[fnCuts];
601 fProfileEtaShift = new TProfile*[fnCuts];
602 fHistoConvGammaPt = new TH1F*[fnCuts];
603
604 if (fDoPhotonQA == 2){
605 fPhotonDCAList = new TList*[fnCuts];
606 fTreeConvGammaPtDcazCat = new TTree*[fnCuts];
607 }
608 if (fDoPhotonQA > 0){
609 fHistoConvGammaR = new TH1F*[fnCuts];
610 fHistoConvGammaEta = new TH1F*[fnCuts];
611 }
612
613 if(fDoMesonAnalysis){
614 fHistoMotherInvMassPt = new TH2F*[fnCuts];
d53bf4ac 615 fHistoMotherMatchedInvMassPt = new TH2F*[fnCuts];
8bdca7f1 616 fHistoMotherBackInvMassPt = new TH2F*[fnCuts];
617 fHistoMotherInvMassEalpha = new TH2F*[fnCuts];
618 if (fDoMesonQA == 2){
619 fMesonDCAList = new TList*[fnCuts];
620 fTreeMesonsInvMassPtDcazMinDcazMaxFlag = new TTree*[fnCuts];
621 }
622 if (fDoMesonQA > 0){
623 fHistoMotherPi0PtY = new TH2F*[fnCuts];
624 fHistoMotherEtaPtY = new TH2F*[fnCuts];
625 fHistoMotherPi0PtAlpha = new TH2F*[fnCuts];
626 fHistoMotherEtaPtAlpha = new TH2F*[fnCuts];
627 fHistoMotherPi0PtOpenAngle = new TH2F*[fnCuts];
628 fHistoMotherEtaPtOpenAngle = new TH2F*[fnCuts];
4e8dcc76 629 fHistoMotherPi0ConvPhotonEtaPhi = new TH2F*[fnCuts];
630 fHistoMotherEtaConvPhotonEtaPhi = new TH2F*[fnCuts];
8bdca7f1 631 }
20af4b69 632 if(fDoMesonQA == 1){
633 fHistoMotherInvMassECalib = new TH2F*[fnCuts];
634 fHistoMotherInvMassECalibalpha = new TH2F*[fnCuts];
635 }
8bdca7f1 636 }
637 fTagOutputList = new TList*[fnCuts];
638
639 fHistoConvGammaUntagged = new TH1F*[fnCuts];
640 fHistoConvGammaTagged = new TH1F*[fnCuts];
641 fHistoConvGammaPi0Tagged = new TH1F*[fnCuts];
642 fHistoConvGammaEtaTagged = new TH1F*[fnCuts];
643 fHistoPhotonPairAll = new TH2F*[fnCuts];
644 fHistoPhotonPairAllGam = new TH2F*[fnCuts];
645
646 fHistoClusGammaPt = new TH1F*[fnCuts];
647
648 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
344100c4 649 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
650 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
651 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
652 TString cutstringMeson = "NoMesonCut";
8bdca7f1 653 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
654
655 fCutFolder[iCut] = new TList();
344100c4 656 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s_%s",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
8bdca7f1 657 fCutFolder[iCut]->SetOwner(kTRUE);
658 fOutputContainer->Add(fCutFolder[iCut]);
659 fESDList[iCut] = new TList();
344100c4 660 fESDList[iCut]->SetName(Form("%s_%s_%s_%s ESD histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
8bdca7f1 661 fESDList[iCut]->SetOwner(kTRUE);
662 fCutFolder[iCut]->Add(fESDList[iCut]);
663
7f070437 664 fHistoNEvents[iCut] = new TH1I("NEvents","NEvents",10,-0.5,9.5);
8bdca7f1 665 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
666 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
667 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
f57c67ac 668 if (((AliConvEventCuts*)fEventCutArray->At(iCut))->IsSpecialTrigger() > 1 ){
8bdca7f1 669 TString TriggerNames = "Not Trigger: ";
344100c4 670 TriggerNames = TriggerNames+ ( (AliConvEventCuts*)fEventCutArray->At(iCut))->GetSpecialTriggerName();
8bdca7f1 671 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
672 } else {
673 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
674 }
675 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
676 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
677 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
678 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
679 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
7f070437 680 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(10,"EMCAL problem");
8bdca7f1 681 fESDList[iCut]->Add(fHistoNEvents[iCut]);
682
683 if(fIsHeavyIon == 1) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
684 else if(fIsHeavyIon == 2) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",400,0,400);
685 else fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
686 fESDList[iCut]->Add(fHistoNGoodESDTracks[iCut]);
687 if(fIsHeavyIon == 1) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
688 else if(fIsHeavyIon == 2) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
689 else fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
690 fESDList[iCut]->Add(fHistoNGammaCandidates[iCut]);
691 if(fIsHeavyIon == 1) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",4000,0,4000,100,0,100);
692 else if(fIsHeavyIon == 2) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",400,0,400,50,0,50);
693 else fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",200,0,200,50,0,50);
694 fESDList[iCut]->Add(fHistoNGoodESDTracksVsNGammaCanditates[iCut]);
695
696
697 if(fIsHeavyIon == 1) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
698 else if(fIsHeavyIon == 2) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
699 else fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
700 fESDList[iCut]->Add(fHistoNV0Tracks[iCut]);
701 fProfileEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
702 fESDList[iCut]->Add(fProfileEtaShift[iCut]);
703 fHistoConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
704 fESDList[iCut]->Add(fHistoConvGammaPt[iCut]);
705
706 if (fDoPhotonQA == 2){
707 fPhotonDCAList[iCut] = new TList();
344100c4 708 fPhotonDCAList[iCut]->SetName(Form("%s_%s_%s_%s Photon DCA tree",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
8bdca7f1 709 fPhotonDCAList[iCut]->SetOwner(kTRUE);
710 fCutFolder[iCut]->Add(fPhotonDCAList[iCut]);
711
712 fTreeConvGammaPtDcazCat[iCut] = new TTree("ESD_ConvGamma_Pt_Dcaz_R_Eta","ESD_ConvGamma_Pt_Dcaz_R_Eta_Cat");
713 fTreeConvGammaPtDcazCat[iCut]->Branch("Pt",&fPtGamma,"fPtGamma/F");
714 fTreeConvGammaPtDcazCat[iCut]->Branch("DcaZPhoton",&fDCAzPhoton,"fDCAzPhoton/F");
715 // fTreeConvGammaPtDcazCat[iCut]->Branch("R",&fRConvPhoton,"fRConvPhoton/F");
716 // fTreeConvGammaPtDcazCat[iCut]->Branch("Eta",&fEtaPhoton,"fEtaPhoton/F");
717
718 fTreeConvGammaPtDcazCat[iCut]->Branch("cat",&fCharCatPhoton,"fCharCatPhoton/b");
719 if(fIsMC){
720 fTreeConvGammaPtDcazCat[iCut]->Branch("photonMCInfo",&fCharPhotonMCInfo,"fCharPhotonMCInfo/b");
721 }
722 fPhotonDCAList[iCut]->Add(fTreeConvGammaPtDcazCat[iCut]);
723 }
724
725 if (fDoPhotonQA > 0){
726 fHistoConvGammaR[iCut] = new TH1F("ESD_ConvGamma_R","ESD_ConvGamma_R",800,0,200);
727 fESDList[iCut]->Add(fHistoConvGammaR[iCut]);
728 fHistoConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",2000,-2,2);
729 fESDList[iCut]->Add(fHistoConvGammaEta[iCut]);
730 }
731
732 fTagOutputList[iCut] = new TList();
344100c4 733 fTagOutputList[iCut]->SetName(Form("%s_%s_%s_%s Tagging Output",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
8bdca7f1 734 fTagOutputList[iCut]->SetOwner(1);
735 fCutFolder[iCut]->Add(fTagOutputList[iCut]);
736
737 const Int_t nptbins = 200;
738 const Double_t ptmin = 0.;
739 const Double_t ptmax = 20.;
740
741 const Int_t nmbins = 180;
742 const Double_t mmin = 0.;
743 const Double_t mmax = 0.9;
744
745 // photon candidates
746 // this is maybe not necessary ...
747
748 fHistoConvGammaUntagged[iCut] = new TH1F("ConvGammaUntagged","",nptbins,ptmin,ptmax);
749 fHistoConvGammaUntagged[iCut]->SetXTitle("p_{T} (GeV/c)");
750 fTagOutputList[iCut]->Add(fHistoConvGammaUntagged[iCut]);
751
752 fHistoConvGammaTagged[iCut] = new TH1F("ConvGammaTagged","",nptbins,ptmin,ptmax);
753 fHistoConvGammaTagged[iCut]->SetXTitle("p_{T} (GeV/c)");
754 fTagOutputList[iCut]->Add(fHistoConvGammaTagged[iCut]);
755
756 fHistoConvGammaPi0Tagged[iCut] = new TH1F("ConvGammaPi0Tagged","",nptbins,ptmin,ptmax);
757 fHistoConvGammaPi0Tagged[iCut]->SetXTitle("p_{T} (GeV/c)");
758 fTagOutputList[iCut]->Add(fHistoConvGammaPi0Tagged[iCut]);
759
760 fHistoConvGammaEtaTagged[iCut] = new TH1F("ConvGammaEtaTagged","",nptbins,ptmin,ptmax);
761 fHistoConvGammaEtaTagged[iCut]->SetXTitle("p_{T} (GeV/c)");
762 fTagOutputList[iCut]->Add(fHistoConvGammaEtaTagged[iCut]);
763
764 // pairs
765 fHistoPhotonPairAll[iCut] = new TH2F("PhotonPairAll","",nmbins,mmin,mmax,nptbins,ptmin,ptmax);
766 fHistoPhotonPairAll[iCut]->SetXTitle("M_{inv} (GeV/cc)");
767 fHistoPhotonPairAll[iCut]->SetYTitle("p_{T} (GeV/c)");
768 fTagOutputList[iCut]->Add(fHistoPhotonPairAll[iCut]);
769
770 fHistoPhotonPairAllGam[iCut] = new TH2F("PhotonPairAllGammaConvPt","",nmbins,mmin,mmax,nptbins,ptmin,ptmax);
771 fHistoPhotonPairAllGam[iCut]->SetXTitle("M_{inv} (GeV/cc)");
772 fHistoPhotonPairAllGam[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
773 fTagOutputList[iCut]->Add(fHistoPhotonPairAllGam[iCut]);
774
775 fHistoClusGammaPt[iCut] = new TH1F("ClusGamma_Pt","ClusGamma_Pt",250,0,25);
776 fTagOutputList[iCut]->Add(fHistoClusGammaPt[iCut]);
777
778
779 if(fDoMesonAnalysis){
780 fHistoMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
781 fESDList[iCut]->Add(fHistoMotherInvMassPt[iCut]);
d53bf4ac 782 fHistoMotherMatchedInvMassPt[iCut] = new TH2F("ESD_MotherMatched_InvMass_Pt","ESD_MotherMatched_InvMass_Pt",800,0,0.8,250,0,25);
783 fESDList[iCut]->Add(fHistoMotherMatchedInvMassPt[iCut]);
8bdca7f1 784 fHistoMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
785 fESDList[iCut]->Add(fHistoMotherBackInvMassPt[iCut]);
786 fHistoMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
787 fESDList[iCut]->Add(fHistoMotherInvMassEalpha[iCut]);
788 if (fDoMesonQA == 2){
789 fMesonDCAList[iCut] = new TList();
344100c4 790 fMesonDCAList[iCut]->SetName(Form("%s_%s_%s_%s Meson DCA tree",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
8bdca7f1 791 fMesonDCAList[iCut]->SetOwner(kTRUE);
792 fCutFolder[iCut]->Add(fMesonDCAList[iCut]);
793
794 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut] = new TTree("ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag","ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag");
795 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("InvMass",&fInvMass,"fInvMass/F");
796 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("Pt",&fPt,"fPt/F");
797 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMin",&fDCAzGammaMin,"fDCAzGammaMin/F");
798 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMax",&fDCAzGammaMax,"fDCAzGammaMax/F");
799 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("kind",&fCharFlag,"fCharFlag/b");
800 if(fIsMC){
801 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("mesonMCInfo",&fCharMesonMCInfo,"fCharMesonMCInfo/b");
802 }
803 fMesonDCAList[iCut]->Add(fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]);
804
805 }
20af4b69 806 if(fDoMesonQA == 1){
41ed7315 807 fHistoMotherInvMassECalib[iCut] = new TH2F("ESD_Mother_InvMass_E_Calib","ESD_Mother_InvMass_E_Calib",800,0,0.8,250,0,25);
20af4b69 808 fESDList[iCut]->Add(fHistoMotherInvMassECalib[iCut]);
809 fHistoMotherInvMassECalibalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_Calib_alpha","ESD_Mother_InvMass_vs_E_Calib_alpha",800,0,0.8,250,0,25);
810 fESDList[iCut]->Add(fHistoMotherInvMassECalibalpha[iCut]);
811 }
812
8bdca7f1 813 if (fDoMesonQA > 0 ){
814 fHistoMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
815 SetLogBinningXTH2(fHistoMotherPi0PtY[iCut]);
816 fESDList[iCut]->Add(fHistoMotherPi0PtY[iCut]);
817 fHistoMotherEtaPtY[iCut] = new TH2F("ESD_MotherEta_Pt_Y","ESD_MotherEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
818 SetLogBinningXTH2(fHistoMotherEtaPtY[iCut]);
819 fESDList[iCut]->Add(fHistoMotherEtaPtY[iCut]);
820 fHistoMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",150,0.03,15.,100,0,1);
821 SetLogBinningXTH2(fHistoMotherPi0PtAlpha[iCut]);
822 fESDList[iCut]->Add(fHistoMotherPi0PtAlpha[iCut]);
823 fHistoMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",150,0.03,15.,100,0,1);
824 SetLogBinningXTH2(fHistoMotherEtaPtAlpha[iCut]);
825 fESDList[iCut]->Add(fHistoMotherEtaPtAlpha[iCut]);
f57c67ac 826 fHistoMotherPi0PtOpenAngle[iCut] = new TH2F("ESD_MotherPi0_Pt_OpenAngle","ESD_MotherPi0_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
8bdca7f1 827 SetLogBinningXTH2(fHistoMotherPi0PtOpenAngle[iCut]);
828 fESDList[iCut]->Add(fHistoMotherPi0PtOpenAngle[iCut]);
f57c67ac 829 fHistoMotherEtaPtOpenAngle[iCut] = new TH2F("ESD_MotherEta_Pt_OpenAngle","ESD_MotherEta_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
8bdca7f1 830 SetLogBinningXTH2(fHistoMotherEtaPtOpenAngle[iCut]);
831 fESDList[iCut]->Add(fHistoMotherEtaPtOpenAngle[iCut]);
4e8dcc76 832 fHistoMotherPi0ConvPhotonEtaPhi[iCut] = new TH2F("ESD_MotherPi0ConvPhoton_Eta_Phi","ESD_MotherPi0ConvPhoton_Eta_Phi",600,0,2*TMath::Pi(),400,-2,2);
833 fESDList[iCut]->Add(fHistoMotherPi0ConvPhotonEtaPhi[iCut]);
834 fHistoMotherEtaConvPhotonEtaPhi[iCut] = new TH2F("ESD_MotherEtaConvPhoton_Eta_Phi","ESD_MotherEtaConvPhoton_Eta_Phi",600,0,2*TMath::Pi(),400,-2,2);
835 fESDList[iCut]->Add(fHistoMotherEtaConvPhotonEtaPhi[iCut]);
8bdca7f1 836 }
837 }
838 }
839 if(fDoMesonAnalysis){
840 InitBack(); // Init Background Handler
841 }
842
843 if(fIsMC){
844 // MC Histogramms
fd94f234 845 fMCList = new TList*[fnCuts];
8bdca7f1 846 // True Histogramms
fd94f234 847 fTrueList = new TList*[fnCuts];
8bdca7f1 848 // Selected Header List
fd94f234 849 fHeaderNameList = new TList*[fnCuts];
850 fHistoMCHeaders = new TH1I*[fnCuts];
851 fHistoMCAllGammaPt = new TH1F*[fnCuts];
20af4b69 852 fHistoMCAllGammaEMCALAccPt = new TH1F*[fnCuts];
fd94f234 853 fHistoMCDecayGammaPi0Pt = new TH1F*[fnCuts];
854 fHistoMCDecayGammaRhoPt = new TH1F*[fnCuts];
855 fHistoMCDecayGammaEtaPt = new TH1F*[fnCuts];
856 fHistoMCDecayGammaOmegaPt = new TH1F*[fnCuts];
857 fHistoMCDecayGammaEtapPt = new TH1F*[fnCuts];
858 fHistoMCDecayGammaPhiPt = new TH1F*[fnCuts];
859 fHistoMCDecayGammaSigmaPt = new TH1F*[fnCuts];
860 fHistoMCConvGammaPt = new TH1F*[fnCuts];
861 fHistoTrueConvGammaPt = new TH1F*[fnCuts];
862 fHistoTrueConvPi0GammaPt = new TH1F*[fnCuts];
8bdca7f1 863
fd94f234 864 fHistoCombinatorialPt = new TH2F*[fnCuts];
865 fHistoTruePrimaryConvGammaPt = new TH1F*[fnCuts];
866 fHistoTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
867 fHistoTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
868 fHistoTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
869 fHistoTrueSecondaryConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
8bdca7f1 870
fd94f234 871 fHistoTrueClusGammaPt = new TH1F*[fnCuts];
872 fHistoTruePrimaryClusGammaPt = new TH1F*[fnCuts];
8bdca7f1 873 fHistoTruePrimaryClusGammaESDPtMCPt = new TH2F*[fnCuts];
874
875 if (fDoPhotonQA > 0){
fd94f234 876 fHistoMCConvGammaR = new TH1F*[fnCuts];
877 fHistoMCConvGammaEta = new TH1F*[fnCuts];
878 fHistoTrueConvGammaEta = new TH1F*[fnCuts];
879 }
880 if (fDoClusterQA > 0){
881 fHistoTrueClusUnConvGammaPt = new TH1F*[fnCuts];
20af4b69 882 fHistoTrueClusUnConvGammaMCPt = new TH1F*[fnCuts];
fd94f234 883 fHistoTrueClusElectronPt = new TH1F*[fnCuts];
884 fHistoTrueClusConvGammaPt = new TH1F*[fnCuts];
20af4b69 885 fHistoTrueClusConvGammaMCPt = new TH1F*[fnCuts];
fd94f234 886 fHistoTrueClusConvGammaFullyPt = new TH1F*[fnCuts];
887 fHistoTrueClusMergedGammaPt = new TH1F*[fnCuts];
888 fHistoTrueClusMergedPartConvGammaPt = new TH1F*[fnCuts];
889 fHistoTrueClusDalitzPt = new TH1F*[fnCuts];
890 fHistoTrueClusDalitzMergedPt = new TH1F*[fnCuts];
891 fHistoTrueClusPhotonFromElecMotherPt= new TH1F*[fnCuts];
892 fHistoTrueClusShowerPt = new TH1F*[fnCuts];
cc579963 893 fHistoTrueClusSubLeadingPt = new TH1F*[fnCuts];
894 fHistoTrueClusNParticles = new TH1I*[fnCuts];
fd94f234 895 fHistoTrueClusEMNonLeadingPt = new TH1F*[fnCuts];
896 fHistoTrueNLabelsInClus = new TH1F*[fnCuts];
8bdca7f1 897 }
898
899 if(fDoMesonAnalysis){
fd94f234 900 fHistoMCPi0Pt = new TH1F*[fnCuts];
901 fHistoMCPi0WOWeightPt = new TH1F*[fnCuts];
902 fHistoMCEtaPt = new TH1F*[fnCuts];
903 fHistoMCEtaWOWeightPt = new TH1F*[fnCuts];
904 fHistoMCPi0InAccPt = new TH1F*[fnCuts];
905 fHistoMCEtaInAccPt = new TH1F*[fnCuts];
8bdca7f1 906
ed8bc1ca 907 fHistoTruePi0InvMassPt = new TH2F*[fnCuts];
908 fHistoTrueEtaInvMassPt = new TH2F*[fnCuts];
909 fHistoTruePrimaryPi0InvMassPt = new TH2F*[fnCuts];
910 fHistoTruePrimaryEtaInvMassPt = new TH2F*[fnCuts];
911 fHistoTruePrimaryPi0W0WeightingInvMassPt = new TH2F*[fnCuts];
912 fHistoTruePrimaryEtaW0WeightingInvMassPt = new TH2F*[fnCuts];
913 fProfileTruePrimaryPi0WeightsInvMassPt = new TProfile2D*[fnCuts];
914 fProfileTruePrimaryEtaWeightsInvMassPt = new TProfile2D*[fnCuts];
915 fHistoTrueSecondaryPi0InvMassPt = new TH2F*[fnCuts];
916 fHistoTrueSecondaryEtaInvMassPt = new TH2F*[fnCuts];
917 fHistoTrueSecondaryPi0FromK0sInvMassPt = new TH2F*[fnCuts];
918 fHistoTrueSecondaryPi0FromEtaInvMassPt = new TH2F*[fnCuts];
919 fHistoTrueSecondaryPi0FromLambdaInvMassPt = new TH2F*[fnCuts];
8bdca7f1 920 if (fDoMesonQA > 0){
fd94f234 921 fHistoMCPi0PtY = new TH2F*[fnCuts];
922 fHistoMCEtaPtY = new TH2F*[fnCuts];
de752898 923 fHistoMCPi0PtAlpha = new TH2F*[fnCuts];
924 fHistoMCEtaPtAlpha = new TH2F*[fnCuts];
fd94f234 925 fHistoMCK0sPt = new TH1F*[fnCuts];
926 fHistoMCK0sWOWeightPt = new TH1F*[fnCuts];
927 fHistoMCK0sPtY = new TH2F*[fnCuts];
928 fHistoMCSecPi0PtvsSource = new TH2F*[fnCuts];
929 fHistoMCSecPi0Source = new TH1F*[fnCuts];
930 fHistoMCSecEtaPt = new TH1F*[fnCuts];
931 fHistoMCSecEtaSource = new TH1F*[fnCuts];
ed8bc1ca 932 fHistoTruePi0CaloPhotonInvMassPt = new TH2F*[fnCuts];
933 fHistoTrueEtaCaloPhotonInvMassPt = new TH2F*[fnCuts];
20af4b69 934 fHistoTruePi0CaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
935 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt = new TH2F*[fnCuts];
936 fHistoTrueEtaCaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
937 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt = new TH2F*[fnCuts];
ed8bc1ca 938 fHistoTruePi0CaloElectronInvMassPt = new TH2F*[fnCuts];
939 fHistoTrueEtaCaloElectronInvMassPt = new TH2F*[fnCuts];
940 fHistoTruePi0CaloMergedClusterInvMassPt = new TH2F*[fnCuts];
941 fHistoTrueEtaCaloMergedClusterInvMassPt = new TH2F*[fnCuts];
942 fHistoTruePi0CaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
943 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
fd94f234 944 fHistoTrueMotherCaloEMNonLeadingInvMassPt = new TH2F*[fnCuts];
945 fHistoTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
946 fHistoTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
947 fHistoTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
948 fHistoTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
949 fHistoTrueLambdaWithPi0DaughterMCPt = new TH1F*[fnCuts];
950 fHistoTrueBckGGInvMassPt = new TH2F*[fnCuts];
951 fHistoTrueBckContInvMassPt = new TH2F*[fnCuts];
952 fHistoTruePi0PtY = new TH2F*[fnCuts];
953 fHistoTrueEtaPtY = new TH2F*[fnCuts];
954 fHistoTruePi0PtAlpha = new TH2F*[fnCuts];
955 fHistoTrueEtaPtAlpha = new TH2F*[fnCuts];
956 fHistoTruePi0PtOpenAngle = new TH2F*[fnCuts];
957 fHistoTrueEtaPtOpenAngle = new TH2F*[fnCuts];
8bdca7f1 958 }
959 }
960
961
962
963 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
344100c4 964 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
965 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
966 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
967 TString cutstringMeson = "NoMesonCut";
8bdca7f1 968 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
969
970 fMCList[iCut] = new TList();
344100c4 971 fMCList[iCut]->SetName(Form("%s_%s_%s_%s MC histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
8bdca7f1 972 fMCList[iCut]->SetOwner(kTRUE);
973 fCutFolder[iCut]->Add(fMCList[iCut]);
974 fHistoMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
975 fMCList[iCut]->Add(fHistoMCHeaders[iCut]);
976 fHistoMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
977 fMCList[iCut]->Add(fHistoMCAllGammaPt[iCut]);
d404157c 978 fHistoMCAllGammaEMCALAccPt[iCut] = new TH1F("MC_AllGammaEMCALAcc_Pt","MC_AllGammaEMCALAcc_Pt",250,0,25);
20af4b69 979 fMCList[iCut]->Add(fHistoMCAllGammaEMCALAccPt[iCut]);
8bdca7f1 980 fHistoMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
981 fMCList[iCut]->Add(fHistoMCDecayGammaPi0Pt[iCut]);
982 fHistoMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
983 fMCList[iCut]->Add(fHistoMCDecayGammaRhoPt[iCut]);
984 fHistoMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
985 fMCList[iCut]->Add(fHistoMCDecayGammaEtaPt[iCut]);
986 fHistoMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
987 fMCList[iCut]->Add(fHistoMCDecayGammaOmegaPt[iCut]);
988 fHistoMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
989 fMCList[iCut]->Add(fHistoMCDecayGammaEtapPt[iCut]);
990 fHistoMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
991 fMCList[iCut]->Add(fHistoMCDecayGammaPhiPt[iCut]);
992 fHistoMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
993 fMCList[iCut]->Add(fHistoMCDecayGammaSigmaPt[iCut]);
994 fHistoMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
995 fMCList[iCut]->Add(fHistoMCConvGammaPt[iCut]);
996
997 if (fDoPhotonQA > 0){
998 fHistoMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
999 fMCList[iCut]->Add(fHistoMCConvGammaR[iCut]);
1000 fHistoMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",2000,-2,2);
1001 fMCList[iCut]->Add(fHistoMCConvGammaEta[iCut]);
1002 }
1003
1004 if(fDoMesonAnalysis){
1005 fHistoMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
1006 fHistoMCPi0Pt[iCut]->Sumw2();
1007 fMCList[iCut]->Add(fHistoMCPi0Pt[iCut]);
1008 fHistoMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
1009 fHistoMCPi0WOWeightPt[iCut]->Sumw2();
1010 fMCList[iCut]->Add(fHistoMCPi0WOWeightPt[iCut]);
1011
1012 fHistoMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
1013 fHistoMCEtaPt[iCut]->Sumw2();
1014 fMCList[iCut]->Add(fHistoMCEtaPt[iCut]);
1015 fHistoMCEtaWOWeightPt[iCut] = new TH1F("MC_Eta_WOWeights_Pt","MC_Eta_WOWeights_Pt",250,0,25);
1016 fHistoMCEtaWOWeightPt[iCut]->Sumw2();
1017 fMCList[iCut]->Add(fHistoMCEtaWOWeightPt[iCut]);
1018 fHistoMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
1019 fHistoMCPi0InAccPt[iCut]->Sumw2();
1020 fMCList[iCut]->Add(fHistoMCPi0InAccPt[iCut]);
1021 fHistoMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
1022 fHistoMCEtaInAccPt[iCut]->Sumw2();
1023 fMCList[iCut]->Add(fHistoMCEtaInAccPt[iCut]);
1024 if (fDoMesonQA > 0){
1025 fHistoMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1026 fHistoMCPi0PtY[iCut]->Sumw2();
1027 SetLogBinningXTH2(fHistoMCPi0PtY[iCut]);
1028 fMCList[iCut]->Add(fHistoMCPi0PtY[iCut]);
1029 fHistoMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1030 fHistoMCEtaPtY[iCut]->Sumw2();
1031 SetLogBinningXTH2(fHistoMCEtaPtY[iCut]);
1032 fMCList[iCut]->Add(fHistoMCEtaPtY[iCut]);
de752898 1033 fHistoMCPi0PtAlpha[iCut] = new TH2F("MC_Pi0_Pt_Alpha","MC_Pi0_Pt_Alpha",150,0.03,15.,100,0,1);
1034 SetLogBinningXTH2(fHistoMCPi0PtAlpha[iCut]);
1035 fMCList[iCut]->Add(fHistoMCPi0PtAlpha[iCut]);
1036 fHistoMCEtaPtAlpha[iCut] = new TH2F("MC_Eta_Pt_Alpha","MC_Eta_Pt_Alpha",150,0.03,15.,100,0,1);
1037 SetLogBinningXTH2(fHistoMCEtaPtAlpha[iCut]);
1038 fMCList[iCut]->Add(fHistoMCEtaPtAlpha[iCut]);
1039
8bdca7f1 1040 fHistoMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",150,0,15);
1041 fHistoMCK0sPt[iCut]->Sumw2();
1042 fMCList[iCut]->Add(fHistoMCK0sPt[iCut]);
1043 fHistoMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",150,0,15);
1044 fHistoMCK0sWOWeightPt[iCut]->Sumw2();
1045 fMCList[iCut]->Add(fHistoMCK0sWOWeightPt[iCut]);
1046 fHistoMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1047 fHistoMCK0sPtY[iCut]->Sumw2();
1048 SetLogBinningXTH2(fHistoMCK0sPtY[iCut]);
1049 fMCList[iCut]->Add(fHistoMCK0sPtY[iCut]);
1050
1051 fHistoMCSecPi0Source[iCut] = new TH1F("MC_SecPi0_Source","MC_SecPi0_Source",5000,0.,5000);
1052 fMCList[iCut]->Add(fHistoMCSecPi0Source[iCut]);
1053 fHistoMCSecEtaSource[iCut] = new TH1F("MC_SecEta_Source","MC_SecEta_Source",5000,0,5000);
1054 fMCList[iCut]->Add(fHistoMCSecEtaSource[iCut]);
1055 fHistoMCSecPi0PtvsSource[iCut] = new TH2F("MC_SecPi0_Pt_Source","MC_SecPi0_Pt_Source",250,0.0,25.,16,-0.5,15.5);
1056 fHistoMCSecPi0PtvsSource[iCut]->Sumw2();
1057 fMCList[iCut]->Add(fHistoMCSecPi0PtvsSource[iCut]);
1058 fHistoMCSecEtaPt[iCut] = new TH1F("MC_SecEta_Pt","MC_SecEta_Pt",250,0,25);
1059 fHistoMCSecEtaPt[iCut]->Sumw2();
1060 fMCList[iCut]->Add(fHistoMCSecEtaPt[iCut]);
1061 }
1062
1063 }
1064 fTrueList[iCut] = new TList();
344100c4 1065 fTrueList[iCut]->SetName(Form("%s_%s_%s_%s True histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
8bdca7f1 1066 fTrueList[iCut]->SetOwner(kTRUE);
1067 fCutFolder[iCut]->Add(fTrueList[iCut]);
1068
1069 fHistoTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
1070 fTrueList[iCut]->Add(fHistoTrueConvGammaPt[iCut]);
1071
41ed7315 1072 fHistoTrueConvPi0GammaPt[iCut] = new TH1F("ESD_TrueConvPi0Gamma_Pt","ESD_TrueConvPi0Gamma_Pt",250,0,25);
8bdca7f1 1073 fTrueList[iCut]->Add(fHistoTrueConvPi0GammaPt[iCut]);
1074
1075 fHistoCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
1076 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
1077 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
1078 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
1079 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
1080 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
1081 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
1082 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
1083 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
1084 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
1085 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
1086 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
1087 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
1088 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
1089 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
1090 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
1091 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
1092 fTrueList[iCut]->Add(fHistoCombinatorialPt[iCut]);
1093 fHistoTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
1094 fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaPt[iCut]);
1095 fHistoTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
1096 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaPt[iCut]);
1097
1098 fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
1099 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
1100 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
1101 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
fd94f234 1102
8bdca7f1 1103 fHistoTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
1104 fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaESDPtMCPt[iCut]);
1105
fd94f234 1106 fHistoTrueClusGammaPt[iCut] = new TH1F("TrueClusGamma_Pt","ESD_TrueClusGamma_Pt",250,0,25);
8bdca7f1 1107 fTagOutputList[iCut]->Add(fHistoTrueClusGammaPt[iCut]);
1108 fHistoTruePrimaryClusGammaPt[iCut] = new TH1F("TruePrimaryClusGamma_Pt","ESD_TruePrimaryClusGamma_Pt",250,0,25);
1109 fTagOutputList[iCut]->Add(fHistoTruePrimaryClusGammaPt[iCut]);
1110 fHistoTruePrimaryClusGammaESDPtMCPt[iCut] = new TH2F("TruePrimaryClusGamma_Pt_MCPt","ESD_TruePrimaryClusGamma_MCPt",250,0,25,250,0,25);
1111 fTagOutputList[iCut]->Add(fHistoTruePrimaryClusGammaESDPtMCPt[iCut]);
1112
fd94f234 1113 if (fDoPhotonQA > 0){
1114 fHistoTrueConvGammaEta[iCut] = new TH1F("ESD_TrueConvGamma_Eta","ESD_TrueConvGamma_Eta",2000,-2,2);
1115 fTrueList[iCut]->Add(fHistoTrueConvGammaEta[iCut]);
1116 }
1117 if (fDoClusterQA > 0){
1118 fHistoTrueClusUnConvGammaPt[iCut] = new TH1F("TrueClusUnConvGamma_Pt","TrueClusUnConvGamma_Pt",250,0,25);
1119 fTagOutputList[iCut]->Add(fHistoTrueClusUnConvGammaPt[iCut]);
20af4b69 1120 fHistoTrueClusUnConvGammaMCPt[iCut] = new TH1F("TrueClusUnConvGamma_MCPt","TrueClusUnConvGamma_MCPt",250,0,25);
1121 fTagOutputList[iCut]->Add(fHistoTrueClusUnConvGammaMCPt[iCut]);
fd94f234 1122 fHistoTrueClusElectronPt[iCut] = new TH1F("TrueClusElectron_Pt","TrueElectronGamma_Pt",250,0,25);
1123 fTagOutputList[iCut]->Add(fHistoTrueClusElectronPt[iCut]);
fd94f234 1124 fHistoTrueClusConvGammaPt[iCut] = new TH1F("TrueClusConvGamma_Pt","TrueClusConvGamma_Pt",250,0,25);
1125 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaPt[iCut]);
20af4b69 1126 fHistoTrueClusConvGammaMCPt[iCut] = new TH1F("TrueClusConvGamma_MCPt","TrueClusConvGamma_MCPt",250,0,25);
1127 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaMCPt[iCut]);
fd94f234 1128 fHistoTrueClusConvGammaFullyPt[iCut] = new TH1F("TrueClusConvGammaFullyContained_Pt","TrueClusConvGammaFullyContained_Pt",250,0,25);
1129 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaFullyPt[iCut]);
1130 fHistoTrueClusMergedGammaPt[iCut] = new TH1F("TrueClusMergedGamma_Pt","TrueClusMergedGamma_Pt",250,0,25);
1131 fTagOutputList[iCut]->Add(fHistoTrueClusMergedGammaPt[iCut]);
1132 fHistoTrueClusMergedPartConvGammaPt[iCut] = new TH1F("TrueClusMergedPartConvGamma_Pt","TrueClusMergedPartConvGamma_Pt",250,0,25);
1133 fTagOutputList[iCut]->Add(fHistoTrueClusMergedPartConvGammaPt[iCut]);
1134 fHistoTrueClusDalitzPt[iCut] = new TH1F("TrueClusDalitz_Pt","TrueClusDalitz_Pt",250,0,25);
1135 fTagOutputList[iCut]->Add(fHistoTrueClusDalitzPt[iCut]);
1136 fHistoTrueClusDalitzMergedPt[iCut] = new TH1F("TrueClusDalitzMerged_Pt","TrueClusDalitzMerged_Pt",250,0,25);
1137 fTagOutputList[iCut]->Add(fHistoTrueClusDalitzMergedPt[iCut]);
1138 fHistoTrueClusPhotonFromElecMotherPt[iCut] = new TH1F("TrueClusPhotonFromElecMother_Pt","TrueClusPhotonFromElecMother_Pt",250,0,25);
1139 fTagOutputList[iCut]->Add(fHistoTrueClusPhotonFromElecMotherPt[iCut]);
1140 fHistoTrueClusShowerPt[iCut] = new TH1F("TrueClusShower_Pt","TrueClusShower_Pt",250,0,25);
1141 fTagOutputList[iCut]->Add(fHistoTrueClusShowerPt[iCut]);
cc579963 1142 fHistoTrueClusSubLeadingPt[iCut] = new TH1F("TrueClusSubleading_Pt","TrueClusSubleading_Pt",250,0,25);
1143 fTagOutputList[iCut]->Add(fHistoTrueClusSubLeadingPt[iCut]);
1144 fHistoTrueClusNParticles[iCut] = new TH1I("TrueClusNParticles","TrueClusNParticles",20,0,20);
1145 fTagOutputList[iCut]->Add(fHistoTrueClusNParticles[iCut]);
fd94f234 1146 fHistoTrueClusEMNonLeadingPt[iCut] = new TH1F("TrueClusEMNonLeading_Pt","TrueClusEMNonLeading_Pt",250,0,25);
1147 fTagOutputList[iCut]->Add(fHistoTrueClusEMNonLeadingPt[iCut]);
1148 fHistoTrueNLabelsInClus[iCut] = new TH1F("TrueNLabelsInClus","TrueNLabelsInClus",100,-0.5,99.5);
1149 fTagOutputList[iCut]->Add(fHistoTrueNLabelsInClus[iCut]);
1150 }
1151
8bdca7f1 1152 if(fDoMesonAnalysis){
ed8bc1ca 1153 fHistoTruePi0InvMassPt[iCut] = new TH2F("ESD_TruePi0_InvMass_Pt","ESD_TruePi0_InvMass_Pt",800,0,0.8,250,0,25);
1154 fTrueList[iCut]->Add(fHistoTruePi0InvMassPt[iCut]);
1155 fHistoTrueEtaInvMassPt[iCut] = new TH2F("ESD_TrueEta_InvMass_Pt","ESD_TrueEta_InvMass_Pt",800,0,0.8,250,0,25);
1156 fTrueList[iCut]->Add(fHistoTrueEtaInvMassPt[iCut]);
1157
1158 fHistoTruePrimaryPi0InvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0_InvMass_Pt", "ESD_TruePrimaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1159 fHistoTruePrimaryPi0InvMassPt[iCut]->Sumw2();
1160 fTrueList[iCut]->Add(fHistoTruePrimaryPi0InvMassPt[iCut]);
1161 fHistoTruePrimaryEtaInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEta_InvMass_Pt", "ESD_TruePrimaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
1162 fHistoTruePrimaryEtaInvMassPt[iCut]->Sumw2();
1163 fTrueList[iCut]->Add(fHistoTruePrimaryEtaInvMassPt[iCut]);
1164
1165 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0W0Weights_InvMass_Pt", "ESD_TruePrimaryPi0W0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1166 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]->Sumw2();
1167 fTrueList[iCut]->Add(fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]);
1168 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEtaW0Weights_InvMass_Pt", "ESD_TruePrimaryEtaW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1169 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]->Sumw2();
1170 fTrueList[iCut]->Add(fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]);
1171
1172 fProfileTruePrimaryPi0WeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryPi0Weights_InvMass_Pt", "ESD_TruePrimaryPi0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1173 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->Sumw2();
1174 fTrueList[iCut]->Add(fProfileTruePrimaryPi0WeightsInvMassPt[iCut]);
1175 fProfileTruePrimaryEtaWeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryEtaWeights_InvMass_Pt", "ESD_TruePrimaryEtaWeights_InvMass_Pt", 800,0,0.8,250,0,25);
1176 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->Sumw2();
1177 fTrueList[iCut]->Add(fProfileTruePrimaryEtaWeightsInvMassPt[iCut]);
20af4b69 1178
ed8bc1ca 1179 fHistoTrueSecondaryPi0InvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0_InvMass_Pt", "ESD_TrueSecondaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1180 fHistoTrueSecondaryPi0InvMassPt[iCut]->Sumw2();
1181 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0InvMassPt[iCut]);
1182 fHistoTrueSecondaryEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryEta_InvMass_Pt", "ESD_TrueSecondaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
1183 fHistoTrueSecondaryEtaInvMassPt[iCut]->Sumw2();
1184 fTrueList[iCut]->Add(fHistoTrueSecondaryEtaInvMassPt[iCut]);
1185
1186 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromK0s_InvMass_Pt","ESD_TrueSecondaryPi0FromK0s_InvMass_Pt",800,0,0.8,250,0,25);
1187 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->Sumw2();
1188 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]);
1189 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromEta_InvMass_Pt","ESD_TrueSecondaryPi0FromEta_InvMass_Pt",800,0,0.8,250,0,25);
1190 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]);
1191 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromLambda_InvMass_Pt","ESD_TrueSecondaryPi0FromLambda_InvMass_Pt",800,0,0.8,250,0,25);
1192 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]);
1193 if (fDoMesonQA > 0){
1194 fHistoTruePi0CaloPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloPhoton_InvMass_Pt","ESD_TruePi0CaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1195 fTrueList[iCut]->Add(fHistoTruePi0CaloPhotonInvMassPt[iCut]);
1196 fHistoTrueEtaCaloPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloPhoton_InvMass_Pt","ESD_TrueEtaCaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1197 fTrueList[iCut]->Add(fHistoTrueEtaCaloPhotonInvMassPt[iCut]);
20af4b69 1198 fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhoton_InvMass_Pt","ESD_TruePi0CaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1199 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]);
1200 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt","ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1201 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut]);
20af4b69 1202 fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt","ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1203 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]);
1204 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt","ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1205 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut]);
1206
d404157c 1207 fHistoTruePi0CaloElectronInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloElectron_InvMass_Pt","ESD_TruePi0CaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
ed8bc1ca 1208 fTrueList[iCut]->Add(fHistoTruePi0CaloElectronInvMassPt[iCut]);
1209 fHistoTrueEtaCaloElectronInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloElectron_InvMass_Pt","ESD_TrueEtaCaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1210 fTrueList[iCut]->Add(fHistoTrueEtaCaloElectronInvMassPt[iCut]);
1211
1212 fHistoTruePi0CaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedCluster_InvMass_Pt","ESD_TruePi0CaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1213 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterInvMassPt[iCut]);
1214 fHistoTrueEtaCaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedCluster_InvMass_Pt","ESD_TrueEtaCaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1215 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]);
1216
fd94f234 1217 fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut] = new TH2F("ESD_TrueMotherCaloEMNonLeading_InvMass_Pt","ESD_TrueMotherCaloEMNonLeading_InvMass_Pt",800,0,0.8,250,0,25);
1218 fTrueList[iCut]->Add(fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut]);
ed8bc1ca 1219 fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt","ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1220 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]);
1221 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt","ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1222 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]);
fd94f234 1223
8bdca7f1 1224 fHistoTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1225 fHistoTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
1226 SetLogBinningXTH2(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1227 fTrueList[iCut]->Add(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1228 fHistoTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1229 fHistoTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
1230 SetLogBinningXTH2(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1231 fTrueList[iCut]->Add(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1232 fHistoTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
1233 fTrueList[iCut]->Add(fHistoTrueBckGGInvMassPt[iCut]);
1234 fHistoTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
1235 fTrueList[iCut]->Add(fHistoTrueBckContInvMassPt[iCut]);
1236 fHistoTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
1237 fTrueList[iCut]->Add(fHistoTrueK0sWithPi0DaughterMCPt[iCut]);
1238 fHistoTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
1239 fTrueList[iCut]->Add(fHistoTrueEtaWithPi0DaughterMCPt[iCut]);
1240 fHistoTrueLambdaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueLambdaWithPi0Daughter_MCPt","ESD_TrueLambdaWithPi0Daughter_MCPt",250,0,25);
1241 fTrueList[iCut]->Add(fHistoTrueLambdaWithPi0DaughterMCPt[iCut]);
1242
1243 fHistoTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1244 SetLogBinningXTH2(fHistoTruePi0PtY[iCut]);
1245 fTrueList[iCut]->Add(fHistoTruePi0PtY[iCut]);
1246 fHistoTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1247 SetLogBinningXTH2(fHistoTrueEtaPtY[iCut]);
1248 fTrueList[iCut]->Add(fHistoTrueEtaPtY[iCut]);
1249 fHistoTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",150,0.03,15.,100,0,1);
1250 SetLogBinningXTH2(fHistoTruePi0PtAlpha[iCut]);
1251 fTrueList[iCut]->Add(fHistoTruePi0PtAlpha[iCut]);
1252 fHistoTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",150,0.03,15.,100,0,1);
1253 SetLogBinningXTH2(fHistoTrueEtaPtAlpha[iCut]);
1254 fTrueList[iCut]->Add(fHistoTrueEtaPtAlpha[iCut]);
1255
1256 fHistoTruePi0PtOpenAngle[iCut] = new TH2F("ESD_TruePi0_Pt_OpenAngle","ESD_TruePi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1257 SetLogBinningXTH2(fHistoTruePi0PtOpenAngle[iCut]);
1258 fTrueList[iCut]->Add(fHistoTruePi0PtOpenAngle[iCut]);
1259 fHistoTrueEtaPtOpenAngle[iCut] = new TH2F("ESD_TrueEta_Pt_OpenAngle","ESD_TrueEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1260 SetLogBinningXTH2(fHistoTrueEtaPtOpenAngle[iCut]);
1261 fTrueList[iCut]->Add(fHistoTrueEtaPtOpenAngle[iCut]);
8bdca7f1 1262 }
1263 }
1264 }
1265 }
1266
1267 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1268 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1269
1270 if(fV0Reader)
344100c4 1271 if((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())
1272 if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1273 fOutputContainer->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1274 if(fV0Reader)
1275 if((AliConvEventCuts*)fV0Reader->GetEventCuts())
1276 if(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms())
1277 fOutputContainer->Add(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms());
1278
1279
8bdca7f1 1280 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
344100c4 1281 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))) continue;
1282 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms()){
1283 fCutFolder[iCut]->Add(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms());
1284 }
1285 if(!((AliConversionPhotonCuts*)fCutArray->At(iCut))) continue;
1286 if(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms()){
1287 fCutFolder[iCut]->Add(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms());
8bdca7f1 1288 }
1289 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))) continue;
1290 if(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms()){
1291 fCutFolder[iCut]->Add(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms());
1292 }
1293 if(fDoMesonAnalysis){
1294 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
1295 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
1296 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
1297 }
1298 }
1299 }
1300 PostData(1, fOutputContainer);
1301}
1302//_____________________________________________________________________________
1303Bool_t AliAnalysisTaskGammaConvCalo::Notify()
1304{
1305 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
344100c4 1306 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))->GetDoEtaShift()){
1307 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
8bdca7f1 1308 continue; // No Eta Shift requested, continue
1309 }
344100c4 1310 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1311 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
1312 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1313 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
8bdca7f1 1314 continue;
1315 }
1316 else{
1317 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
344100c4 1318 (((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber()).Data(),((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift());
1319 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1320 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
8bdca7f1 1321 }
1322 }
1323
1324 return kTRUE;
1325}
1326//_____________________________________________________________________________
1327void AliAnalysisTaskGammaConvCalo::UserExec(Option_t *)
1328{
1329 //
1330 // Called for each event
1331 //
344100c4 1332 Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
8bdca7f1 1333 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1334 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1335 fHistoNEvents[iCut]->Fill(eventQuality);
1336 }
1337 return;
1338 }
1339
1340 if(fIsMC) fMCEvent = MCEvent();
1341 if(fMCEvent == NULL) fIsMC = kFALSE;
1342
1343 fInputEvent = InputEvent();
1344
1345 if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
1346 fMCStack = fMCEvent->Stack();
1347 if(fMCStack == NULL) fIsMC = kFALSE;
1348 }
1349
d404157c 1350 if(fInputEvent->IsA()==AliAODEvent::Class()){
1351 fInputEvent->InitMagneticField();
1352 }
1353
8bdca7f1 1354 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
1355
1356 // ------------------- BeginEvent ----------------------------
1357
1358 AliEventplane *EventPlane = fInputEvent->GetEventplane();
1359 if(fIsHeavyIon ==1)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
1360 else fEventPlaneAngle=0.0;
1361
1362 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1363 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
1364 fV0Reader->RelabelAODs(kTRUE);
1365 }
1366
1367
1368 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1369
1370 fiCut = iCut;
7f070437 1371
1372 Bool_t isRunningEMCALrelAna = kFALSE;
1373 if (((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->GetClusterType() == 1) isRunningEMCALrelAna = kTRUE;
1374
1375 Int_t eventNotAccepted = ((AliConvEventCuts*)fEventCutArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon,isRunningEMCALrelAna);
8bdca7f1 1376
1377 if(eventNotAccepted){
1378 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1379 fHistoNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1380 continue;
1381 }
1382
1383 if(eventQuality != 0){// Event Not Accepted
1384 //cout << "event rejected due to: " <<eventQuality << endl;
1385 fHistoNEvents[iCut]->Fill(eventQuality);
1386 continue;
1387 }
1388
1389 fHistoNEvents[iCut]->Fill(eventQuality); // Should be 0 here
1390 fHistoNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
344100c4 1391 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->IsHeavyIon() == 2) fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
8bdca7f1 1392 else fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1393
1394 if(fIsMC){
1395 // Process MC Particle
344100c4 1396 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection() != 0){
8bdca7f1 1397 if(fInputEvent->IsA()==AliESDEvent::Class()){
344100c4 1398 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1399 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
8bdca7f1 1400 fMCEvent);
1401 }
1402 else if(fInputEvent->IsA()==AliAODEvent::Class()){
344100c4 1403 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1404 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
8bdca7f1 1405 fInputEvent);
1406 }
1407
344100c4 1408 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader()){
1409 for(Int_t i = 0;i<(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
8bdca7f1 1410 TString nameBin= fHistoMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
1411 if (nameBin.CompareTo("")== 0){
344100c4 1412 TString nameHeader = ((TObjString*)((TList*)((AliConvEventCuts*)fEventCutArray->At(iCut))
1413 ->GetAcceptedHeader())->At(i))->GetString();
1414 fHistoMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
8bdca7f1 1415 }
1416 }
1417 }
1418 }
1419 }
1420 if(fIsMC){
1421 if(fInputEvent->IsA()==AliESDEvent::Class())
1422 ProcessMCParticles();
1423 if(fInputEvent->IsA()==AliAODEvent::Class())
1424 ProcessAODMCParticles();
1425 }
1426
1427 // it is in the loop to have the same conversion cut string (used also for MC stuff that should be same for V0 and Cluster)
1428 ProcessClusters(); // process calo clusters
1429 ProcessPhotonCandidates(); // Process this cuts gammas
1430
1431 fHistoNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
1432 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks(),fGammaCandidates->GetEntries());
1433 if(fDoMesonAnalysis){ // Meson Analysis
1434 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1435 fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
1436 fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
1437 fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
1438 fUnsmearedE = new Double_t[fGammaCandidates->GetEntries()];
1439
1440 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1441 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
1442 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
1443 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
1444 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
1445 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
1446 }
1447 }
1448
1449 PhotonTagging(); // tag PCM photons with calorimeter
1450
1451 CalculatePi0Candidates(); // Combine Gammas from conversion and from calo
1452
1453 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1454 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1455 CalculateBackground(); // Combinatorial Background
1456 UpdateEventByEventData(); // Store Event for mixed Events
1457 }
1458 else{
1459 CalculateBackgroundRP(); // Combinatorial Background
1460 fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
1461 fBGClusHandlerRP[iCut]->AddEvent(fClusterCandidates,fInputEvent); // Store Event for mixed Events
1462 }
1463 }
1464 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1465 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1466 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1467 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1468 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1469 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
1470 }
1471 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1472 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1473 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1474 delete[] fUnsmearedE; fUnsmearedE = 0x0;
1475 }
1476 }
1477
1478 fGammaCandidates->Clear(); // delete this cuts good gammas
1479 fClusterCandidates->Clear(); // delete cluster candidates
1480 }
1481
1482 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1483 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
1484 fV0Reader->RelabelAODs(kFALSE);
1485 }
1486
1487 PostData(1, fOutputContainer);
1488}
1489
1490//________________________________________________________________________
1491void AliAnalysisTaskGammaConvCalo::ProcessClusters()
1492{
1493
1494 Int_t nclus = 0;
1495 nclus = fInputEvent->GetNumberOfCaloClusters();
1496
9df9736d 1497// cout << nclus << endl;
8bdca7f1 1498
1499 if(nclus == 0) return;
1500
1501 // vertex
1502 Double_t vertex[3] = {0};
1503 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1504
1505 // Loop over EMCal clusters
d53bf4ac 1506 for(Long_t i = 0; i < nclus; i++){
8bdca7f1 1507
20af4b69 1508 AliVCluster* clus = NULL;
1509 clus = fInputEvent->GetCaloCluster(i);
8bdca7f1 1510 if (!clus) continue;
1511 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelected(clus,fInputEvent,fIsMC)) continue;
1512 // TLorentzvector with cluster
1513 TLorentzVector clusterVector;
1514 clus->GetMomentum(clusterVector,vertex);
1515
1516 TLorentzVector* tmpvec = new TLorentzVector();
1517 tmpvec->SetPxPyPzE(clusterVector.Px(),clusterVector.Py(),clusterVector.Pz(),clusterVector.E());
1518
1519 // convert to AODConversionPhoton
1520 AliAODConversionPhoton *PhotonCandidate=new AliAODConversionPhoton(tmpvec);
1521 if(!PhotonCandidate) continue;
fd94f234 1522
1523 // Flag Photon as CaloPhoton
1524 PhotonCandidate->SetIsCaloPhoton();
d53bf4ac 1525 PhotonCandidate->SetCaloClusterRef(i);
8bdca7f1 1526 // get MC label
8bdca7f1 1527 if(fIsMC){
fd94f234 1528 Int_t* mclabelsCluster = clus->GetLabels();
1529 PhotonCandidate->SetNCaloPhotonMCLabels(clus->GetNLabels());
1530// cout << clus->GetNLabels() << endl;
1531 if (clus->GetNLabels()>0){
1532 for (Int_t k =0; k< (Int_t)clus->GetNLabels(); k++){
cc579963 1533 if (k< 20)PhotonCandidate->SetCaloPhotonMCLabel(k,mclabelsCluster[k]);
fd94f234 1534// Int_t pdgCode = fMCStack->Particle(mclabelsCluster[k])->GetPdgCode();
1535// cout << "label " << k << "\t" << mclabelsCluster[k] << " pdg code: " << pdgCode << endl;
1536 }
1537 }
8bdca7f1 1538 }
1539
fd94f234 1540 fIsFromMBHeader = kTRUE;
1541 // test whether largest contribution to cluster orginates in added signals
1542 if (fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetCaloPhotonMCLabel(0), fMCStack, fInputEvent) == 0) fIsFromMBHeader = kFALSE;
8bdca7f1 1543
1544 fHistoClusGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1545 fClusterCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1546
8bdca7f1 1547 if(fIsMC){
fd94f234 1548 if(fInputEvent->IsA()==AliESDEvent::Class()){
1549 ProcessTrueClusterCandidates(PhotonCandidate);
1550 } else {
1551 ProcessTrueClusterCandidatesAOD(PhotonCandidate);
1552 }
8bdca7f1 1553 }
1554
344100c4 1555 delete tmpvec;
8bdca7f1 1556 }
1557
1558}
1559
1560//________________________________________________________________________
1561void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1562{
fd94f234 1563
1564 TParticle *Photon = NULL;
1565 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1566 fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
8bdca7f1 1567
fd94f234 1568 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0)Photon = fMCStack->Particle(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1569 else return;
1570
8bdca7f1 1571 if(Photon == NULL){
1572 // cout << "no photon" << endl;
1573 return;
1574 }
fd94f234 1575
1576 TruePhotonCandidate->SetCaloPhotonMCFlags(fMCStack);
8bdca7f1 1577
1578 // True Photon
1579 if(fIsFromMBHeader){
fd94f234 1580 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1581 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1582 if (fDoClusterQA > 0){
20af4b69 1583 if (TruePhotonCandidate->IsLargestComponentPhoton()){
fd94f234 1584 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
20af4b69 1585 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1586 }
fd94f234 1587 if (TruePhotonCandidate->IsLargestComponentElectron())
1588 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
20af4b69 1589 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
fd94f234 1590 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
20af4b69 1591 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(Photon->GetMother(0)))->Pt());
1592 }
fd94f234 1593 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1594 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1595 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1596 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1597 if (TruePhotonCandidate->IsMergedPartConv())
1598 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1599 if (TruePhotonCandidate->IsDalitz())
1600 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1601 if (TruePhotonCandidate->IsDalitzMerged())
1602 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1603 if (TruePhotonCandidate->IsPhotonWithElecMother())
1604 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1605 if (TruePhotonCandidate->IsShower())
1606 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
cc579963 1607 if (TruePhotonCandidate->IsSubLeadingEM())
1608 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1609 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
fd94f234 1610 }
8bdca7f1 1611 }
1612
1613 if(Photon->GetMother(0) <= fMCStack->GetNprimary()){
1614 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1615 if(fIsFromMBHeader){
344100c4 1616 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1617 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
8bdca7f1 1618 }
fd94f234 1619 }
1620 return;
1621}
1622
1623
1624//________________________________________________________________________
1625void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1626{
1627 AliAODMCParticle *Photon = NULL;
1628 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1629 if (AODMCTrackArray){
1630 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1631 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0) Photon = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1632 else return;
1633 } else {
1634 AliInfo("AODMCTrackArray could not be loaded");
1635 return;
8bdca7f1 1636 }
1637
fd94f234 1638 if(Photon == NULL){
cc579963 1639 // cout << "no photon" << endl;
fd94f234 1640 return;
1641 }
1642 TruePhotonCandidate->SetCaloPhotonMCFlagsAOD(fInputEvent);
d404157c 1643 fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
fd94f234 1644 // True Photon
1645 if(fIsFromMBHeader){
1646 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1647 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1648 if (fDoClusterQA > 0){
20af4b69 1649 if (TruePhotonCandidate->IsLargestComponentPhoton()) {
fd94f234 1650 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
20af4b69 1651 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1652 }
fd94f234 1653 if (TruePhotonCandidate->IsLargestComponentElectron())
1654 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
20af4b69 1655 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()) {
fd94f234 1656 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
20af4b69 1657 AliAODMCParticle *Mother = (AliAODMCParticle*) AODMCTrackArray->At(Photon->GetMother());
1658 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(Mother->Pt());
1659 }
fd94f234 1660 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1661 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1662 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1663 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1664 if (TruePhotonCandidate->IsMergedPartConv())
1665 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1666 if (TruePhotonCandidate->IsDalitz())
1667 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1668 if (TruePhotonCandidate->IsDalitzMerged())
1669 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1670 if (TruePhotonCandidate->IsPhotonWithElecMother())
1671 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1672 if (TruePhotonCandidate->IsShower())
1673 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
cc579963 1674 if (TruePhotonCandidate->IsSubLeadingEM())
1675 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1676 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
fd94f234 1677 }
1678 }
8bdca7f1 1679
fd94f234 1680 // True Photon
1681 if(fIsFromMBHeader){
1682 fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1683// if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1684 }
1685
1686 if(Photon->IsPrimary()){
1687 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1688 if(fIsFromMBHeader){
1689 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1690 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1691 }
1692 }
1693}
8bdca7f1 1694
1695//________________________________________________________________________
1696void AliAnalysisTaskGammaConvCalo::ProcessPhotonCandidates()
1697{
1698 Int_t nV0 = 0;
1699 TList *GammaCandidatesStepOne = new TList();
1700 TList *GammaCandidatesStepTwo = new TList();
1701 // Loop over Photon Candidates allocated by ReaderV1
1702 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1703 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1704 if(!PhotonCandidate) continue;
1705 fIsFromMBHeader = kTRUE;
344100c4 1706 if(fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1707 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1708 if(isPosFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1709 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1710 if(isNegFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
8bdca7f1 1711 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1712 }
1713
344100c4 1714 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
1715 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(PhotonCandidate->GetPhotonPhi(),fEventPlaneAngle)) continue;
1716 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1717 !((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
8bdca7f1 1718 fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1719
1720 if(fIsFromMBHeader){
1721 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1722 if (fDoPhotonQA > 0){
1723 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1724 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1725 }
1726 }
1727 if(fIsMC){
1728 if(fInputEvent->IsA()==AliESDEvent::Class())
1729 ProcessTruePhotonCandidates(PhotonCandidate);
1730 if(fInputEvent->IsA()==AliAODEvent::Class())
1731 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1732 }
1733 if (fIsFromMBHeader && fDoPhotonQA == 2){
1734 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
344100c4 1735 fPtGamma = PhotonCandidate->Pt();
1736 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1737 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1738 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1739 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1740 fTreeConvGammaPtDcazCat[fiCut]->Fill();
8bdca7f1 1741 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
344100c4 1742 fPtGamma = PhotonCandidate->Pt();
1743 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1744 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1745 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1746 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1747 fTreeConvGammaPtDcazCat[fiCut]->Fill();
8bdca7f1 1748 }
1749 }
344100c4 1750 } else if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1751 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
8bdca7f1 1752 nV0++;
1753 GammaCandidatesStepOne->Add(PhotonCandidate);
344100c4 1754 } else if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1755 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
8bdca7f1 1756 GammaCandidatesStepTwo->Add(PhotonCandidate);
1757 }
1758 }
344100c4 1759 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
8bdca7f1 1760 for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1761 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1762 if(!PhotonCandidate) continue;
1763 fIsFromMBHeader = kTRUE;
344100c4 1764 if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1765 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1766 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
8bdca7f1 1767 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1768 }
344100c4 1769 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1770 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
8bdca7f1 1771 fGammaCandidates->Add(PhotonCandidate);
1772 if(fIsFromMBHeader){
1773 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1774 if (fDoPhotonQA > 0){
1775 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1776 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1777 }
1778 }
1779 }
1780 if(fIsMC){
1781 if(fInputEvent->IsA()==AliESDEvent::Class())
1782 ProcessTruePhotonCandidates(PhotonCandidate);
1783 if(fInputEvent->IsA()==AliAODEvent::Class())
1784 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1785 } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1786
1787 if (fIsFromMBHeader && fDoPhotonQA == 2){
1788 if (fIsHeavyIon ==1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1789 fPtGamma = PhotonCandidate->Pt();
1790 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1791 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1792 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1793 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1794 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1795 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1796 fPtGamma = PhotonCandidate->Pt();
1797 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1798 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1799 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1800 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1801 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1802 }
1803 }
1804 }
1805 }
344100c4 1806 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
8bdca7f1 1807 for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1808 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1809 if(!PhotonCandidate) continue;
1810 fIsFromMBHeader = kTRUE;
344100c4 1811 if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1812 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1813 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
8bdca7f1 1814 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1815 }
344100c4 1816 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
8bdca7f1 1817 fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1818 if(fIsFromMBHeader){
1819 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1820 if (fDoPhotonQA > 0){
1821 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1822 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1823 }
1824 }
1825 if(fIsMC){
1826 if(fInputEvent->IsA()==AliESDEvent::Class())
1827 ProcessTruePhotonCandidates(PhotonCandidate);
1828 if(fInputEvent->IsA()==AliAODEvent::Class())
1829 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1830 }
1831 if (fIsFromMBHeader){
1832 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1833 fPtGamma = PhotonCandidate->Pt();
1834 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1835 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1836 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1837 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1838 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1839 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1840 fPtGamma = PhotonCandidate->Pt();
1841 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1842 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1843 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1844 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1845 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1846 }
1847 }
1848 }
1849 }
1850
1851 delete GammaCandidatesStepOne;
1852 GammaCandidatesStepOne = 0x0;
1853 delete GammaCandidatesStepTwo;
1854 GammaCandidatesStepTwo = 0x0;
1855
1856}
1857//________________________________________________________________________
1858void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1859{
1860
1861 Double_t magField = fInputEvent->GetMagneticField();
1862 if( magField < 0.0 ){
1863 magField = 1.0;
1864 }
1865 else {
1866 magField = -1.0;
1867 }
1868
1869 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1870 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1871 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
1872 fCharPhotonMCInfo = 0;
1873
1874 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1875 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1876
1877 if(posDaughter->GetMother() != negDaughter->GetMother()){
1878 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1879 fCharPhotonMCInfo = 1;
1880 return;
1881 }
1882 else if(posDaughter->GetMother() == -1){
1883 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1884 fCharPhotonMCInfo = 1;
1885 return;
1886 }
1887
1888 if(pdgCode[0]!=11 || pdgCode[1]!=11){
1889 fCharPhotonMCInfo = 1;
1890 return; //One Particle is not a electron
1891 }
fd94f234 1892
8bdca7f1 1893 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
1894 fCharPhotonMCInfo = 1;
1895 return; // Same Charge
1896 }
1897
fd94f234 1898 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
8bdca7f1 1899 if(Photon->GetPdgCode() != 22){
8bdca7f1 1900 fCharPhotonMCInfo = 1;
1901 return; // Mother is no Photon
1902 }
1903
1904 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
1905 fCharPhotonMCInfo = 1;
1906 return;// check if the daughters come from a conversion
1907 }
1908 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1909
1910
1911
1912 // True Photon
1913 if(fIsFromMBHeader){
1914 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1915 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1916 }
8bdca7f1 1917 if(Photon->IsPrimary()){
1918 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1919 if(fIsFromMBHeader){
1920 fCharPhotonMCInfo = 6;
1921 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1922 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1923 }
1924 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1925 } else {
1926 if(fIsFromMBHeader){
1927 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1928 fCharPhotonMCInfo = 2;
1929 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1930 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1931 fCharPhotonMCInfo = 5;
1932 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1933 }
1934 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1935 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1936 fCharPhotonMCInfo = 4;
1937 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1938 }
1939 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1940 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1941 fCharPhotonMCInfo = 3;
1942 }
1943 }
41ed7315 1944 }
1945 if( ((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetPdgCode() == 111 ){
1946 fHistoTrueConvPi0GammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1947 }
8bdca7f1 1948}
1949//________________________________________________________________________
1950void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1951{
cc579963 1952
8bdca7f1 1953 Double_t magField = fInputEvent->GetMagneticField();
1954 if( magField < 0.0 ){
1955 magField = 1.0;
1956 }
1957 else {
1958 magField = -1.0;
1959 }
cc579963 1960
8bdca7f1 1961 // Process True Photons
1962 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1963 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
1964 fCharPhotonMCInfo = 0;
1965
1966 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1967 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1968 fCharPhotonMCInfo = 1;
1969 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
1970 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1971 return;
1972 }
1973 else if(posDaughter->GetMother(0) == -1){
1974 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1975 return;
1976 }
1977
1978 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1979
1980 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
cc579963 1981
8bdca7f1 1982 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
8bdca7f1 1983
1984 if(Photon->GetPdgCode() != 22){
8bdca7f1 1985 return; // Mother is no Photon
1986 }
1987
1988 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1989
8bdca7f1 1990 // True Photon
1991 if(fIsFromMBHeader){
1992 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1993 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1994 }
8bdca7f1 1995 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
1996 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1997 if(fIsFromMBHeader){
1998 fCharPhotonMCInfo = 6;
1999 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2000 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
2001
2002 }
2003 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
2004 }
2005 else{
2006 if(fIsFromMBHeader){
2007 fCharPhotonMCInfo = 2;
2008 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2009 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2010 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
2011 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2012 fCharPhotonMCInfo = 5;
2013 }
2014 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2015 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
2016 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2017 fCharPhotonMCInfo = 4;
2018 }
2019 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2020 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
2021 fCharPhotonMCInfo = 3;
2022 }
2023 }
2024 }
cc579963 2025
8bdca7f1 2026 // pi0 photon
2027 //Bool_t bpi0 = 0;
2028 Int_t imother = Photon->GetMother(0);
cc579963 2029 if(imother > -1){
2030 AliMCParticle* McMother = static_cast<AliMCParticle*>(fMCEvent->GetTrack(imother));
2031 //cout << fMCEvent->GetRunNumber() << " " << imother << " " << fMCEvent->GetNumberOfTracks() << endl;
2032 if(McMother->PdgCode() == 111) fHistoTrueConvPi0GammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
8bdca7f1 2033 }
cc579963 2034 return;
8bdca7f1 2035}
2036//________________________________________________________________________
2037void AliAnalysisTaskGammaConvCalo::ProcessAODMCParticles()
2038{
2039
2040 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2041
2042 // Loop over all primary MC particle
2043 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
2044
2045 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
2046 if (!particle) continue;
2047 if (!particle->IsPrimary()) continue;
2048
2049 Int_t isMCFromMBHeader = -1;
344100c4 2050 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2051 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2052 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
8bdca7f1 2053 }
2054
344100c4 2055 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2056 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
8bdca7f1 2057 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
d404157c 2058 if (abs(particle->Eta()) < 0.66 ){
2059 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
8bdca7f1 2060 }
d404157c 2061 if(particle->GetMother() >-1){ // Meson Decay Gamma
2062 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
2063 case 111: // Pi0
2064 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2065 break;
2066 case 113: // Rho0
2067 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2068 break;
2069 case 221: // Eta
2070 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2071 break;
2072 case 223: // Omega
2073 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2074 break;
2075 case 331: // Eta'
2076 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2077 break;
2078 case 333: // Phi
2079 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2080 break;
2081 case 3212: // Sigma
2082 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2083 break;
8bdca7f1 2084 }
d404157c 2085 }
2086 }
2087 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
2088 Double_t rConv = 0;
2089 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
2090 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
2091 if(!tmpDaughter) continue;
2092 if(abs(tmpDaughter->GetPdgCode()) == 11){
2093 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
8bdca7f1 2094 }
2095 }
d404157c 2096 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2097 if (fDoPhotonQA > 0){
2098 fHistoMCConvGammaR[fiCut]->Fill(rConv);
2099 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2100 }
2101 }
2102 // Converted MC Gamma
2103 if(fDoMesonAnalysis){
8bdca7f1 2104 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2105 Double_t mesonY = 10.;
2106 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
344100c4 2107 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
8bdca7f1 2108 } else {
344100c4 2109 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
8bdca7f1 2110 }
2111 Float_t weightedK0s= 1;
344100c4 2112 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
8bdca7f1 2113 if (particle->Pt()>0.005){
344100c4 2114 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
8bdca7f1 2115 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2116 }
2117 }
2118 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2119 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2120 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2121 }
2122 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
344100c4 2123 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
8bdca7f1 2124 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
2125 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
2126 Float_t weighted= 1;
344100c4 2127 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
8bdca7f1 2128 if (particle->Pt()>0.005){
344100c4 2129 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
8bdca7f1 2130 // if(particle->GetPdgCode() == 221){
2131 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2132 // }
2133 }
2134 }
2135 Double_t mesonY = 10.;
2136 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
344100c4 2137 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
8bdca7f1 2138 } else{
344100c4 2139 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
8bdca7f1 2140 }
2141
de752898 2142 Double_t alpha = -1;
2143 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2144 alpha = TMath::Abs((daughter0->E() - daughter1->E()))/(daughter0->E() + daughter1->E());
2145 }
2146
2147
8bdca7f1 2148 if(particle->GetPdgCode() == 111){
2149 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2150 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
de752898 2151 if (fDoMesonQA > 0){
2152 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2153 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2154 }
8bdca7f1 2155 } else if(particle->GetPdgCode() == 221){
2156 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2157 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
de752898 2158 if (fDoMesonQA > 0){
2159 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2160 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2161 }
8bdca7f1 2162 }
2163
2164 // Check the acceptance for both gammas
344100c4 2165 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
2166 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) &&
2167 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2168 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
8bdca7f1 2169
2170 if(particle->GetPdgCode() == 111){
2171 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2172 } else if(particle->GetPdgCode() == 221){
2173 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2174 }
2175 }
2176 }
2177 }
2178 }
2179
2180}
2181//________________________________________________________________________
2182void AliAnalysisTaskGammaConvCalo::ProcessMCParticles()
2183{
2184 // Loop over all primary MC particle
2185 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2186 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2187 if (!particle) continue;
2188
2189 Int_t isMCFromMBHeader = -1;
344100c4 2190 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2191 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2192 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
8bdca7f1 2193 }
2194
344100c4 2195 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2196 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
8bdca7f1 2197 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
20af4b69 2198 if (abs(particle->Eta()) < 0.66 ){
2199 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2200 }
2201
8bdca7f1 2202 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
2203 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
2204 case 111: // Pi0
2205 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2206 break;
2207 case 113: // Rho0
2208 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2209 break;
2210 case 221: // Eta
2211 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2212 break;
2213 case 223: // Omega
2214 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2215 break;
2216 case 331: // Eta'
2217 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2218 break;
2219 case 333: // Phi
2220 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2221 break;
2222 case 3212: // Sigma
2223 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2224 break;
2225 }
2226 }
2227 }
344100c4 2228 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
8bdca7f1 2229 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2230 if (fDoPhotonQA > 0){
2231 fHistoMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
2232 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2233 }
2234 } // Converted MC Gamma
2235 if(fDoMesonAnalysis){
2236 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2237 Double_t mesonY = 10.;
2238 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
344100c4 2239 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
8bdca7f1 2240 } else{
344100c4 2241 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
8bdca7f1 2242 }
2243 Float_t weightedK0s= 1;
344100c4 2244 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
8bdca7f1 2245 if (particle->Pt()>0.005){
344100c4 2246 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
8bdca7f1 2247 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2248 }
2249 }
2250 if (fMCStack->IsPhysicalPrimary(i)){
2251 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2252 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2253 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2254 }
2255 }
2256 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
344100c4 2257 ->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
8bdca7f1 2258 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
2259 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
2260
2261 Float_t weighted= 1;
344100c4 2262 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
8bdca7f1 2263 if (particle->Pt()>0.005){
344100c4 2264 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
8bdca7f1 2265 // if(particle->GetPdgCode() == 221){
2266 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2267 // }
2268 }
2269 }
2270 Double_t mesonY = 10.;
2271 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
344100c4 2272 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
8bdca7f1 2273 } else{
344100c4 2274 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
8bdca7f1 2275 }
de752898 2276
2277 Double_t alpha = -1;
2278 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2279 alpha = TMath::Abs((daughter0->Energy() - daughter1->Energy()))/(daughter0->Energy() + daughter1->Energy());
2280 }
2281
8bdca7f1 2282 if(particle->GetPdgCode() == 111){
2283 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2284 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
de752898 2285 if (fDoMesonQA > 0){
2286 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2287 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2288 }
8bdca7f1 2289 } else if(particle->GetPdgCode() == 221){
2290 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2291 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
de752898 2292 if (fDoMesonQA > 0){
2293 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2294 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2295 }
8bdca7f1 2296 }
2297
2298 // Check the acceptance for both gammas
344100c4 2299 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
2300 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) &&
2301 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2302 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
8bdca7f1 2303
2304 if(particle->GetPdgCode() == 111){
2305 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2306 } else if(particle->GetPdgCode() == 221){
2307 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2308 }
2309 }
2310 }
2311 }
2312 }
2313
2314 if (fDoMesonQA){
2315 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
2316 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2317 if (!particle) continue;
2318
2319 Int_t isMCFromMBHeader = -1;
344100c4 2320 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2321 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2322 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
8bdca7f1 2323 }
2324
2325 if(fDoMesonAnalysis){
344100c4 2326 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
8bdca7f1 2327 Float_t weighted= 1;
344100c4 2328 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
8bdca7f1 2329 if (particle->Pt()>0.005){
344100c4 2330 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
8bdca7f1 2331 // if(particle->GetPdgCode() == 221){
2332 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2333 // }
2334 }
2335 }
2336
2337 if(particle->GetPdgCode() == 111){
2338 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2339 Int_t source = GetSourceClassification(111,pdgCode);
2340 fHistoMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
2341 fHistoMCSecPi0Source[fiCut]->Fill(pdgCode);
2342 } else if(particle->GetPdgCode() == 221){
2343 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2344 fHistoMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2345 fHistoMCSecEtaSource[fiCut]->Fill(pdgCode);
2346 }
2347 }
2348 }
2349 }
2350 }
2351}
2352
2353//________________________________________________________________________
2354void AliAnalysisTaskGammaConvCalo::PhotonTagging(){
2355
2356 // Conversion Gammas
2357 if(fGammaCandidates->GetEntries()>0){
2358
2359 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
2360
2361 // get conversion photon
2362 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2363 if (gamma0==NULL) continue;
2364
2365 TLorentzVector photonVector;
2366 photonVector.SetPxPyPzE(gamma0->GetPx(),gamma0->GetPy(),gamma0->GetPz(),gamma0->GetPhotonP());
2367
2368 Bool_t btagpi0 = 0;
2369 Bool_t btageta = 0;
2370
2371 // loop over clusters
2372 for(Int_t secondGammaIndex = 0; secondGammaIndex<fClusterCandidates->GetEntries(); ++secondGammaIndex) {
2373
2374 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2375 if (gamma1==NULL) continue;
2376
2377 TLorentzVector clusterVector;
2378 clusterVector.SetPxPyPzE(gamma1->GetPx(),gamma1->GetPy(),gamma1->GetPz(),gamma1->GetPhotonP());
2379
2380 // do the tagging
2381 TLorentzVector pairVector = photonVector+clusterVector;
2382
2383 // see if pi0?
2384 if((pairVector.M() > 0.11 && pairVector.M() < 0.15)){
344100c4 2385 btagpi0 = 1;
8bdca7f1 2386 }
2387 // or eta
2388 if((pairVector.M() > 0.50 && pairVector.M() < 0.6)){
344100c4 2389 btageta = 1;
8bdca7f1 2390 }
2391 }// end loop over clusters
2392
2393 if(btagpi0 && btageta)
2394 fHistoConvGammaTagged[fiCut]->Fill(photonVector.Pt());
2395 else if(btagpi0 && !btageta)
2396 fHistoConvGammaPi0Tagged[fiCut]->Fill(photonVector.Pt());
2397 else if(btageta && !btagpi0)
2398 fHistoConvGammaEtaTagged[fiCut]->Fill(photonVector.Pt());
2399 else
2400 fHistoConvGammaUntagged[fiCut]->Fill(photonVector.Pt());
2401
2402 }// end loop over gammas
2403 }// end if
2404 return;
2405}
2406
2407//________________________________________________________________________
2408void AliAnalysisTaskGammaConvCalo::CalculatePi0Candidates(){
2409
2410 // Conversion Gammas
2411 if(fGammaCandidates->GetEntries()>0){
2412
2413 // vertex
2414 Double_t vertex[3] = {0};
2415 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
2416
2417 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2418 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2419 if (gamma0==NULL) continue;
2420
2421 for(Int_t secondGammaIndex=0;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
d53bf4ac 2422 Bool_t matched = kFALSE;
8bdca7f1 2423 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2424 if (gamma1==NULL) continue;
2425
d53bf4ac 2426 if (gamma1->GetIsCaloPhoton()){
2427 AliVCluster* cluster = fInputEvent->GetCaloCluster(gamma1->GetCaloClusterRef());
2428 matched = ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->MatchConvPhotonToCluster(gamma0,cluster, fInputEvent );
2429 }
2430
8bdca7f1 2431 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
2432 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
2433
d53bf4ac 2434
2435
344100c4 2436 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
d53bf4ac 2437 if (matched){
2438 fHistoMotherMatchedInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2439 } else {
2440 fHistoMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2441 }
8bdca7f1 2442 // fill new histograms
d53bf4ac 2443 if (!matched){
2444 fHistoPhotonPairAll[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2445 fHistoPhotonPairAllGam[fiCut]->Fill(pi0cand->M(),gamma0->Pt());
8bdca7f1 2446
d53bf4ac 2447 if(pi0cand->GetAlpha()<0.1)
2448 fHistoMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
2449
2450 if (fDoMesonQA > 0){
2451 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
2452 fHistoMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2453 fHistoMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
4e8dcc76 2454 fHistoMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2455 fHistoMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
8bdca7f1 2456 }
d53bf4ac 2457 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
2458 fHistoMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2459 fHistoMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2460 fHistoMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
4e8dcc76 2461 fHistoMotherEtaConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
d53bf4ac 2462 }
2463 }
2464 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
2465 Int_t zbin = 0;
2466 Int_t mbin = 0;
2467
2468 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
2469 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2470 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2471 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2472 } else {
2473 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2474 }
2475 } else{
2476 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2477 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2478 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2479 } else {
2480 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2481 }
8bdca7f1 2482 }
d53bf4ac 2483 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
2484 fSparseMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
8bdca7f1 2485 }
8bdca7f1 2486 }
2487
8bdca7f1 2488 if(fIsMC){
2489 if(fInputEvent->IsA()==AliESDEvent::Class())
d53bf4ac 2490 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1, matched);
8bdca7f1 2491 if(fInputEvent->IsA()==AliAODEvent::Class())
d53bf4ac 2492 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1, matched);
8bdca7f1 2493 }
d53bf4ac 2494 if (!matched){
2495 if (fDoMesonQA == 2){
2496 fInvMass = pi0cand->M();
2497 fPt = pi0cand->Pt();
2498 if (abs(gamma0->GetDCAzToPrimVtx()) < abs(gamma1->GetDCAzToPrimVtx())){
2499 fDCAzGammaMin = gamma0->GetDCAzToPrimVtx();
2500 fDCAzGammaMax = gamma1->GetDCAzToPrimVtx();
2501 } else {
2502 fDCAzGammaMin = gamma1->GetDCAzToPrimVtx();
2503 fDCAzGammaMax = gamma0->GetDCAzToPrimVtx();
2504 }
2505 fCharFlag = pi0cand->GetMesonQuality();
2506 // cout << "gamma 0: " << gamma0->GetV0Index()<< "\t" << gamma0->GetPx() << "\t" << gamma0->GetPy() << "\t" << gamma0->GetPz() << "\t" << endl;
2507 // cout << "gamma 1: " << gamma1->GetV0Index()<< "\t"<< gamma1->GetPx() << "\t" << gamma1->GetPy() << "\t" << gamma1->GetPz() << "\t" << endl;
2508 // cout << "pi0: "<<fInvMass << "\t" << fPt <<"\t" << fDCAzGammaMin << "\t" << fDCAzGammaMax << "\t" << (Int_t)fCharFlag << "\t" << (Int_t)fCharMesonMCInfo <<endl;
2509 if (fIsHeavyIon == 1 && fPt > 0.399 && fPt < 20. ) {
2510 if (fInvMass > 0.08 && fInvMass < 0.2) fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2511 if ((fInvMass > 0.45 && fInvMass < 0.6) && (fPt > 0.999 && fPt < 20.) )fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2512 } else if (fPt > 0.299 && fPt < 20. ) {
2513 if ( (fInvMass > 0.08 && fInvMass < 0.2) || (fInvMass > 0.45 && fInvMass < 0.6)) fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2514 }
8bdca7f1 2515 }
d53bf4ac 2516 if (fDoMesonQA == 1){
2517 fHistoMotherInvMassECalib[fiCut]->Fill(pi0cand->M(),gamma1->E());
2518 if(pi0cand->GetAlpha()<0.1)
2519 fHistoMotherInvMassECalibalpha[fiCut]->Fill(pi0cand->M(),gamma1->E());
8bdca7f1 2520 }
2521 }
2522 }
2523 delete pi0cand;
2524 pi0cand=0x0;
2525 }
2526 }
2527 }
2528}
2529//______________________________________________________________________
d53bf4ac 2530void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
8bdca7f1 2531{
2532 // Process True Mesons
2533 AliStack *MCStack = fMCEvent->Stack();
2534 fCharMesonMCInfo = 0;
2535 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2536 Bool_t isTruePi0 = kFALSE;
2537 Bool_t isTrueEta = kFALSE;
8bdca7f1 2538 Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
2539 Int_t gamma0MotherLabel = -1;
2540 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
fd94f234 2541 // Daughters Gamma 0
2542 TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
2543 TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
2544 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
2545 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2546 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2547 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
2548 gamma0MotherLabel=gammaMC0->GetFirstMother();
2549 }
8bdca7f1 2550 }
2551 }
fd94f234 2552 }
2553 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
2554
2555 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2556 Int_t gamma1MotherLabel = -1;
2557 // check if
2558
2559 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2560 // Daughters Gamma 1
2561 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
2562 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2563 // get mother of interest (pi0 or eta)
2564 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2565 gamma1MotherLabel=gammaMC1->GetMother(0);
2566 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2567 if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=MCStack->Particle(gammaMC1->GetMother(0))->GetMother(0);
2568 else gamma1MotherLabel=gammaMC1->GetMother(0);
2569 }
2570 } else {
2571 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2572 }
2573 }
2574
2575 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2576 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
2577 isTruePi0=kTRUE;
8bdca7f1 2578 }
fd94f234 2579 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
2580 isTrueEta=kTRUE;
8bdca7f1 2581 }
2582 }
fd94f234 2583
2584 if(isTruePi0 || isTrueEta){// True Pion or Eta
ed8bc1ca 2585 if (!matched){
2586 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2587 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2588 }
fd94f234 2589 if (fDoMesonQA > 0){
ed8bc1ca 2590 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2591 if(isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2592 if(isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2593 }
2594 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched){
2595 if(isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2596 if(isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2597 }
d53bf4ac 2598 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() ){
d53bf4ac 2599 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2600 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2601 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0){
20af4b69 2602 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
d53bf4ac 2603 }
2604 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta){
20af4b69 2605 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
d53bf4ac 2606 }
20af4b69 2607 }
ed8bc1ca 2608 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2609 if (isTruePi0 )fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2610 if (isTrueEta )fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2611 }
2612 if (TrueGammaCandidate1->IsMergedPartConv() && !matched){
2613 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2614 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2615 }
fd94f234 2616 }
d53bf4ac 2617 if (!matched){
2618 if (fDoMesonQA > 0){
2619 if (isTruePi0){
2620 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2621 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2622 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2623 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2624 }
2625 } else if (isTrueEta){
2626 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2627 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2628 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2629 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2630 }
8bdca7f1 2631 }
2632 }
d53bf4ac 2633
2634 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
2635 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma0MotherLabel))->GetMother(0);
2636 Float_t weightedSec= 1;
2637 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
2638 weightedSec= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),secMotherLabel, fMCStack, 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
2639 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
8bdca7f1 2640 }
ed8bc1ca 2641 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2642 if (isTrueEta) fHistoTrueSecondaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2643 fCharMesonMCInfo = 2;
2644 if (secMotherLabel >-1){
ed8bc1ca 2645 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310 && isTruePi0 ){
d53bf4ac 2646 fCharMesonMCInfo = 4;
ed8bc1ca 2647 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2648 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2649 }
ed8bc1ca 2650 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221 && isTruePi0){
d53bf4ac 2651 fCharMesonMCInfo = 3;
ed8bc1ca 2652 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2653 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2654 }
ed8bc1ca 2655 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==3122 && isTruePi0){
d53bf4ac 2656 fCharMesonMCInfo = 7;
ed8bc1ca 2657 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2658 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2659 }
8bdca7f1 2660 }
d53bf4ac 2661 } else { // Only primary pi0 for efficiency calculation
2662 fCharMesonMCInfo = 6;
2663 Float_t weighted= 1;
2664 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
2665 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
2666 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
2667 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2668 }
fd94f234 2669 }
ed8bc1ca 2670 if (isTruePi0){
2671 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2672 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2673 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2674 } else if (isTrueEta) {
2675 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2676 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2677 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2678 }
d53bf4ac 2679
2680 if (fDoMesonQA > 0){
2681 if(isTruePi0){ // Only primary pi0 for resolution
2682 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2683 }
2684 if (isTrueEta){ // Only primary eta for resolution
2685 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2686 }
8bdca7f1 2687 }
2688 }
d53bf4ac 2689 }
fd94f234 2690 } else if(!isTruePi0 && !isTrueEta){ // Background
2691 if (fDoMesonQA > 0){
2692 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2693 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2694 fCharMesonMCInfo = 1;
2695 } else { // No photon or without mother
2696 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
8bdca7f1 2697 }
2698 }
2699 }
2700 }
2701}
2702//______________________________________________________________________
d53bf4ac 2703void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
8bdca7f1 2704{
2705
2706 // Process True Mesons
2707 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2708 Bool_t isTruePi0 = kFALSE;
2709 Bool_t isTrueEta = kFALSE;
8bdca7f1 2710
2711 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
2712 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
2713
2714 fCharMesonMCInfo = 0;
2715 Int_t gamma0MCLabel = -1;
2716 Int_t gamma0MotherLabel = -1;
2717 if(!positiveMC||!negativeMC)
2718 return;
2719
2720 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
2721 gamma0MCLabel = positiveMC->GetMother();
2722 }
2723
2724 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2725 // Daughters Gamma 0
2726 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2727 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2728 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
2729 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
2730 gamma0MotherLabel=gammaMC0->GetMother();
2731 }
2732 }
8bdca7f1 2733 }
fd94f234 2734 }
2735
2736 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
8bdca7f1 2737 Int_t gamma1MotherLabel = -1;
fd94f234 2738 // check if
2739
8bdca7f1 2740 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2741 // Daughters Gamma 1
2742 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
fd94f234 2743 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2744 // get mother of interest (pi0 or eta)
2745 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
8bdca7f1 2746 gamma1MotherLabel=gammaMC1->GetMother();
fd94f234 2747 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2748 if (TrueGammaCandidate1->IsConversion()){
2749 AliAODMCParticle * gammaGrandMotherMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC1->GetMother()));
2750 gamma1MotherLabel=gammaGrandMotherMC1->GetMother();
2751 } else gamma1MotherLabel=gammaMC1->GetMother();
8bdca7f1 2752 }
fd94f234 2753 } else {
2754 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2755 }
8bdca7f1 2756 }
fd94f234 2757
8bdca7f1 2758 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
fd94f234 2759 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
8bdca7f1 2760 isTruePi0=kTRUE;
2761 }
fd94f234 2762 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
8bdca7f1 2763 isTrueEta=kTRUE;
2764 }
2765 }
2766
8bdca7f1 2767 if(isTruePi0 || isTrueEta){// True Pion or Eta
ed8bc1ca 2768 if (!matched){
2769 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2770 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2771 }
fd94f234 2772 if (fDoMesonQA > 0){
ed8bc1ca 2773 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2774 if (isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2775 if (isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2776 }
2777 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched) {
2778 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2779 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2780 }
20af4b69 2781 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()){
d53bf4ac 2782 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2783 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
20af4b69 2784 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0)
2785 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2786 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta)
2787 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2788 }
ed8bc1ca 2789 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2790 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2791 if (isTrueEta) fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2792 }
2793 if (TrueGammaCandidate1->IsMergedPartConv() && !matched) {
2794 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2795 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2796 }
fd94f234 2797 }
2798
d53bf4ac 2799 if ( !matched){
2800 if (fDoMesonQA > 0){
2801 if (isTruePi0){
2802 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2803 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2804 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2805 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2806 }
2807 } else if (isTrueEta){
2808 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2809 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2810 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2811 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2812 }
8bdca7f1 2813 }
2814 }
d53bf4ac 2815 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2816 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2817 Float_t weightedSec= 1;
2818 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2819 weightedSec= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),secMotherLabel, 0x0, 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
2820 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
8bdca7f1 2821 }
ed8bc1ca 2822 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2823 if (isTrueEta) fHistoTrueSecondaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2824
d53bf4ac 2825 fCharMesonMCInfo = 2;
2826 if (secMotherLabel >-1){
ed8bc1ca 2827 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310 && isTruePi0){
d53bf4ac 2828 fCharMesonMCInfo = 4;
ed8bc1ca 2829 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2830 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2831 }
ed8bc1ca 2832 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221 && isTruePi0){
d53bf4ac 2833 fCharMesonMCInfo = 3;
ed8bc1ca 2834 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2835 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2836 }
ed8bc1ca 2837 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122 && isTruePi0){
d53bf4ac 2838 fCharMesonMCInfo = 7;
ed8bc1ca 2839 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2840 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2841 }
8bdca7f1 2842 }
d53bf4ac 2843 } else{ // Only primary pi0 for efficiency calculation
2844 Float_t weighted= 1;
2845 fCharMesonMCInfo = 6;
2846 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2847 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2848 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2849 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2850 }
8bdca7f1 2851 }
ed8bc1ca 2852 if (isTruePi0){
2853 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2854 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2855 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2856 } else if (isTrueEta){
2857 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2858 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2859 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2860 }
d53bf4ac 2861 if (fDoMesonQA > 0){
2862 if(isTruePi0){ // Only primary pi0 for resolution
2863 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2864 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2865
2866 }
2867 if (isTrueEta){ // Only primary eta for resolution
2868 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2869 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2870 }
8bdca7f1 2871 }
2872 }
d53bf4ac 2873 }
8bdca7f1 2874 } else if(!isTruePi0 && !isTrueEta) { // Background
2875 if (fDoMesonQA > 0){
2876 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2877 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2878 fCharMesonMCInfo = 1;
2879 } else { // No photon or without mother
2880 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2881 }
2882 }
8bdca7f1 2883 }
2884}
344100c4 2885
8bdca7f1 2886//________________________________________________________________________
2887void AliAnalysisTaskGammaConvCalo::CalculateBackground(){
2888
2889 Int_t zbin= fBGClusHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2890 Int_t mbin = 0;
2891
2892 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2893 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2894 } else {
2895 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2896 }
2897
2898 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2899 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2900 for(Int_t nEventsInBG=0;nEventsInBG<fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2901 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2902 if(fMoveParticleAccordingToVertex == kTRUE){
2903 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2904 }
2905
2906 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2907 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2908 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2909 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2910 if(fMoveParticleAccordingToVertex == kTRUE){
2911 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2912 }
344100c4 2913 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
8bdca7f1 2914 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2915 }
2916
2917 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2918 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2919 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
344100c4 2920 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
8bdca7f1 2921 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2922 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2923 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2924 }
2925 delete backgroundCandidate;
2926 backgroundCandidate = 0x0;
2927 }
2928 }
2929 }
2930 } else {
2931 for(Int_t nEventsInBG=0;nEventsInBG <fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2932 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2933 if(previousEventV0s){
2934 if(fMoveParticleAccordingToVertex == kTRUE){
2935 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2936 }
2937 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2938 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2939 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2940
2941 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2942
2943 if(fMoveParticleAccordingToVertex == kTRUE){
2944 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2945 }
344100c4 2946 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
8bdca7f1 2947 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2948 }
2949
8bdca7f1 2950 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2951 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
344100c4 2952 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
8bdca7f1 2953 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2954 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2955 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2956 }
2957 delete backgroundCandidate;
2958 backgroundCandidate = 0x0;
2959 }
2960 }
2961 }
2962 }
2963 }
2964}
2965
2966//________________________________________________________________________
2967void AliAnalysisTaskGammaConvCalo::CalculateBackgroundRP(){
2968
2969 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2970 Int_t mbin = 0;
2971 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2972 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2973 } else {
2974 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2975 }
2976
2977
2978 //Rotation Method
2979 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2980 // Correct for the number of rotations
2981 // BG is for rotation the same, except for factor NRotations
2982 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
2983
2984 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2985
2986 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2987 if (gamma0==NULL) continue;
2988 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
2989 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
2990 if (gamma1 == NULL) continue;
344100c4 2991 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
8bdca7f1 2992 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2993
2994 RotateParticle(gamma1);
2995 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2996 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2997 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
344100c4 2998 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
8bdca7f1 2999 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3000 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3001 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3002 }
3003 }
3004 }
3005 }
344100c4 3006 } else {
8bdca7f1 3007 // Do Event Mixing
3008 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
3009
3010 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
3011
3012 if(previousEventGammas){
3013 // test weighted background
3014 Double_t weight=1.0;
3015 // Correct for the number of eventmixing:
3016 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
3017 // real combinations (since you cannot combine a photon with its own)
3018 // but BG leads to N_{a}*N_{b} combinations
3019 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
3020
3021 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3022 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3023 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
3024
3025 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
3026
3027 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3028 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3029 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
344100c4 3030 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
8bdca7f1 3031 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3032 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3033 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3034 }
3035 }
3036 }
3037 }
3038 }
3039 }
3040}
3041//________________________________________________________________________
3042void AliAnalysisTaskGammaConvCalo::RotateParticle(AliAODConversionPhoton *gamma){
3043 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
3044 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
3045 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
3046 gamma->RotateZ(rotationValue);
3047}
3048
3049//________________________________________________________________________
3050void AliAnalysisTaskGammaConvCalo::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
3051
3052 previousEventEP=previousEventEP+TMath::Pi();
3053 thisEventEP=thisEventEP+TMath::Pi();
3054 Double_t rotationValue= thisEventEP-previousEventEP;
3055 gamma->RotateZ(rotationValue);
3056}
3057
3058//________________________________________________________________________
3059void AliAnalysisTaskGammaConvCalo::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
3060 //see header file for documentation
3061
3062 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
3063 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
3064 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
3065
3066 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
3067 particle->SetConversionPoint(movedPlace);
3068}
3069//________________________________________________________________________
3070void AliAnalysisTaskGammaConvCalo::UpdateEventByEventData(){
3071 //see header file for documentation
3072 if(fGammaCandidates->GetEntries() >0 ){
3073 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3074 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3075 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3076 } else { // means we use #V0s for multiplicity
3077 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3078 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3079 }
3080 }
3081}
3082
3083
3084//________________________________________________________________________
3085void AliAnalysisTaskGammaConvCalo::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
3086{
3087 // Combinatorial Bck = 0 ee, 1 ep,i 2 ek, 3 ep, 4 emu, 5 pipi, 6 pik, 7 pip, 8 pimu, 9 kk, 10 kp, 11 kmu, 12 pp, 13 pmu, 14 mumu, 15 Rest
3088 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
3089 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
3090 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
3091 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
3092 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
3093 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
3094 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
3095 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
3096 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
3097 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
3098 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
3099 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
3100 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
3101 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
3102 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
3103 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
3104 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
3105 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
3106 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
3107 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
3108 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
3109 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
3110 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
3111 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
3112 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
3113 else {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
3114}
3115//________________________________________________________________________
3116void AliAnalysisTaskGammaConvCalo::RelabelAODPhotonCandidates(Bool_t mode){
3117
3118 // Relabeling For AOD Event
3119 // ESDiD -> AODiD
3120 // MCLabel -> AODMCLabel
3121
3122 if(mode){
3123 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
3124 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
3125 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
3126 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
3127 }
3128
3129 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
3130 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
3131 if(!PhotonCandidate) continue;
3132 if(!mode){// Back to ESD Labels
3133 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
3134 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
3135 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
3136 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
3137 continue;
3138 }
3139 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
3140 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
3141 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
3142 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
3143
3144 Bool_t AODLabelPos = kFALSE;
3145 Bool_t AODLabelNeg = kFALSE;
3146
3147 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
3148 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
3149 if(!AODLabelPos){
3150 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
3151 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
3152 PhotonCandidate->SetLabelPositive(i);
3153 AODLabelPos = kTRUE;
3154 }
3155 }
3156 if(!AODLabelNeg){
3157 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
3158 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
3159 PhotonCandidate->SetLabelNegative(i);
3160 AODLabelNeg = kTRUE;
3161 }
3162 }
3163 if(AODLabelNeg && AODLabelPos){
3164 break;
3165 }
3166 }
3167 if(!AODLabelPos || !AODLabelNeg){
3168 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
3169 }
3170 }
3171
3172
3173 if(!mode){
3174 delete[] fMCStackPos;
3175 delete[] fMCStackNeg;
3176 delete[] fESDArrayPos;
3177 delete[] fESDArrayNeg;
3178 }
3179}
3180
3181void AliAnalysisTaskGammaConvCalo::SetLogBinningXTH2(TH2* histoRebin){
3182 TAxis *axisafter = histoRebin->GetXaxis();
3183 Int_t bins = axisafter->GetNbins();
3184 Double_t from = axisafter->GetXmin();
3185 Double_t to = axisafter->GetXmax();
3186 Double_t *newbins = new Double_t[bins+1];
3187 newbins[0] = from;
3188 Double_t factor = TMath::Power(to/from, 1./bins);
3189 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
3190 axisafter->Set(bins, newbins);
3191 delete [] newbins;
3192}
3193
3194//________________________________________________________________________
3195void AliAnalysisTaskGammaConvCalo::Terminate(const Option_t *)
3196{
3197
3198 //fOutputContainer->Print(); // Will crash on GRID
3199}
3200
3201//________________________________________________________________________
3202Int_t AliAnalysisTaskGammaConvCalo::GetSourceClassification(Int_t daughter, Int_t pdgCode){
3203
3204 if (daughter == 111) {
3205 if (abs(pdgCode) == 310) return 1; // k0s
3206 else if (abs(pdgCode) == 3122) return 2; // Lambda
3207 else if (abs(pdgCode) == 130) return 3; // K0L
3208 else if (abs(pdgCode) == 2212) return 4; // proton
3209 else if (abs(pdgCode) == 2112) return 5; // neutron
3210 else if (abs(pdgCode) == 211) return 6; // pion
3211 else if (abs(pdgCode) == 321) return 7; // kaon
3212 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
3213 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112 ) return 9; // Sigma
3214 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114 ) return 10; // Delta
3215 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323 ) return 11; // K*
3216 else return 15;
3217 }
3218 return 15;
3219
3220}