]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/GammaConv/AliAnalysisTaskGammaCalo.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- added missing pi0 histograms for calo conv
[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliAnalysisTaskGammaCalo.cxx
CommitLineData
d53bf4ac 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 "AliAnalysisTaskGammaCalo.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 "AliAODMCParticle.h"
50#include "AliAODMCHeader.h"
51#include "AliEventplane.h"
52#include "AliAnalysisTaskEMCALClusterizeFast.h"
53#include "AliAODEvent.h"
54#include "AliAODInputHandler.h"
55#include "AliESDEvent.h"
56#include "AliESDInputHandler.h"
57#include "AliInputEventHandler.h"
58
59ClassImp(AliAnalysisTaskGammaCalo)
60
61//________________________________________________________________________
62AliAnalysisTaskGammaCalo::AliAnalysisTaskGammaCalo(): AliAnalysisTaskSE(),
63 fV0Reader(NULL),
64 fBGHandler(NULL),
65 fInputEvent(NULL),
66 fMCEvent(NULL),
67 fMCStack(NULL),
68 fCutFolder(NULL),
69 fESDList(NULL),
70 fBackList(NULL),
71 fMotherList(NULL),
72 fTrueList(NULL),
73 fMCList(NULL),
74 fHeaderNameList(NULL),
75 fOutputContainer(NULL),
76 fClusterCandidates(NULL),
77 fEventCutArray(NULL),
78 fEventCuts(NULL),
79 fClusterCutArray(NULL),
80 fCaloPhotonCuts(NULL),
81 fMesonCutArray(NULL),
82 fMesonCuts(NULL),
83 fHistoMotherInvMassPt(NULL),
8c96b4f9 84 fHistoMotherInvMass3ClusterPt(NULL),
d53bf4ac 85 fSparseMotherInvMassPtZM(NULL),
86 fHistoMotherBackInvMassPt(NULL),
87 fSparseMotherBackInvMassPtZM(NULL),
88 fHistoMotherInvMassEalpha(NULL),
89 fHistoMotherPi0PtY(NULL),
90 fHistoMotherEtaPtY(NULL),
91 fHistoMotherPi0PtAlpha(NULL),
92 fHistoMotherEtaPtAlpha(NULL),
93 fHistoMotherPi0PtOpenAngle(NULL),
94 fHistoMotherEtaPtOpenAngle(NULL),
95 fHistoMotherInvMassECalib(NULL),
96 fHistoMotherInvMassECalibalpha(NULL),
97 fHistoClusGammaPt(NULL),
ecd3e131 98 fHistoClusOverlapHeadersGammaPt(NULL),
d53bf4ac 99 fHistoMCHeaders(NULL),
100 fHistoMCAllGammaPt(NULL),
101 fHistoMCDecayGammaPi0Pt(NULL),
102 fHistoMCDecayGammaRhoPt(NULL),
103 fHistoMCDecayGammaEtaPt(NULL),
104 fHistoMCDecayGammaOmegaPt(NULL),
105 fHistoMCDecayGammaEtapPt(NULL),
106 fHistoMCDecayGammaPhiPt(NULL),
107 fHistoMCDecayGammaSigmaPt(NULL),
108 fHistoMCPi0Pt(NULL),
109 fHistoMCPi0WOWeightPt(NULL),
110 fHistoMCEtaPt(NULL),
111 fHistoMCEtaWOWeightPt(NULL),
112 fHistoMCPi0InAccPt(NULL),
113 fHistoMCEtaInAccPt(NULL),
114 fHistoMCPi0PtY(NULL),
115 fHistoMCEtaPtY(NULL),
de752898 116 fHistoMCPi0PtAlpha(NULL),
117 fHistoMCEtaPtAlpha(NULL),
d53bf4ac 118 fHistoMCK0sPt(NULL),
119 fHistoMCK0sWOWeightPt(NULL),
120 fHistoMCK0sPtY(NULL),
121 fHistoMCSecPi0PtvsSource(NULL),
122 fHistoMCSecPi0Source(NULL),
123 fHistoMCSecEtaPt(NULL),
124 fHistoMCSecEtaSource(NULL),
ed8bc1ca 125 fHistoTruePi0InvMassPt(NULL),
126 fHistoTrueEtaInvMassPt(NULL),
127 fHistoTruePi0CaloPhotonInvMassPt(NULL),
128 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
d53bf4ac 129 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
130 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
ed8bc1ca 131 fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt(NULL),
132 fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt(NULL),
133 fHistoTruePi0CaloElectronInvMassPt(NULL),
134 fHistoTrueEtaCaloElectronInvMassPt(NULL),
135 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
136 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
137 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
138 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
def90c8b 139 fHistoTruePi0NonMergedElectronPhotonInvMassPt(NULL),
140 fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt(NULL),
5cd70387 141 fHistoTruePi0Category1(NULL),
142 fHistoTrueEtaCategory1(NULL),
143 fHistoTruePi0Category2(NULL),
144 fHistoTrueEtaCategory2(NULL),
145 fHistoTruePi0Category3(NULL),
146 fHistoTrueEtaCategory3(NULL),
147 fHistoTruePi0Category4_6(NULL),
148 fHistoTrueEtaCategory4_6(NULL),
149 fHistoTruePi0Category5(NULL),
150 fHistoTrueEtaCategory5(NULL),
151 fHistoTruePi0Category7(NULL),
152 fHistoTrueEtaCategory7(NULL),
153 fHistoTruePi0Category8(NULL),
154 fHistoTrueEtaCategory8(NULL),
ed8bc1ca 155 fHistoTruePrimaryPi0InvMassPt(NULL),
156 fHistoTruePrimaryEtaInvMassPt(NULL),
157 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
158 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
159 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
160 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
d53bf4ac 161 fHistoTruePrimaryPi0MCPtResolPt(NULL),
162 fHistoTruePrimaryEtaMCPtResolPt(NULL),
ed8bc1ca 163 fHistoTrueSecondaryPi0InvMassPt(NULL),
ed8bc1ca 164 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
d53bf4ac 165 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
ed8bc1ca 166 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
d53bf4ac 167 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
ed8bc1ca 168 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
d53bf4ac 169 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
170 fHistoTrueBckGGInvMassPt(NULL),
171 fHistoTrueBckContInvMassPt(NULL),
172 fHistoTruePi0PtY(NULL),
173 fHistoTrueEtaPtY(NULL),
174 fHistoTruePi0PtAlpha(NULL),
175 fHistoTrueEtaPtAlpha(NULL),
176 fHistoTruePi0PtOpenAngle(NULL),
177 fHistoTrueEtaPtOpenAngle(NULL),
178 fHistoClusPhotonBGPt(NULL),
179 fHistoClusPhotonPlusConvBGPt(NULL),
180 fHistoTrueClusGammaPt(NULL),
181 fHistoTrueClusUnConvGammaPt(NULL),
182 fHistoTrueClusUnConvGammaMCPt(NULL),
183 fHistoTrueClusElectronPt(NULL),
184 fHistoTrueClusConvGammaPt(NULL),
185 fHistoTrueClusConvGammaMCPt(NULL),
186 fHistoTrueClusConvGammaFullyPt(NULL),
187 fHistoTrueClusMergedGammaPt(NULL),
188 fHistoTrueClusMergedPartConvGammaPt(NULL),
189 fHistoTrueClusDalitzPt(NULL),
190 fHistoTrueClusDalitzMergedPt(NULL),
191 fHistoTrueClusPhotonFromElecMotherPt(NULL),
192 fHistoTrueClusShowerPt(NULL),
193 fHistoTrueClusSubLeadingPt(NULL),
194 fHistoTrueClusNParticles(NULL),
195 fHistoTrueClusEMNonLeadingPt(NULL),
196 fHistoTrueNLabelsInClus(NULL),
197 fHistoTruePrimaryClusGammaPt(NULL),
198 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
199 fHistoTruePrimaryClusConvGammaPt(NULL),
200 fHistoTruePrimaryClusConvGammaESDPtMCPt(NULL),
201 fHistoTrueSecondaryClusGammaPt(NULL),
202 fHistoTrueSecondaryClusConvGammaPt(NULL),
203 fHistoTrueSecondaryClusGammaFromXFromK0sPt(NULL),
204 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt(NULL),
205 fHistoTrueSecondaryClusGammaFromXFromLambdaPt(NULL),
206 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt(NULL),
207 fHistoTrueSecondaryClusGammaFromXFromEtasPt(NULL),
208 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt(NULL),
209 fHistoNEvents(NULL),
210 fHistoNGoodESDTracks(NULL),
211 fHistoNGammaCandidates(NULL),
212 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
213 fHistoNV0Tracks(NULL),
214 fProfileEtaShift(NULL),
215 fEventPlaneAngle(-100),
216 fRandom(0),
217 fnCuts(0),
218 fiCut(0),
219 fIsHeavyIon(0),
220 fDoMesonAnalysis(kTRUE),
221 fDoMesonQA(0),
222 fDoClusterQA(0),
223 fIsFromMBHeader(kTRUE),
ecd3e131 224 fIsOverlappingWithOtherHeader(kFALSE),
d53bf4ac 225 fIsMC(kFALSE)
226{
227
228}
229
230//________________________________________________________________________
231AliAnalysisTaskGammaCalo::AliAnalysisTaskGammaCalo(const char *name):
232 AliAnalysisTaskSE(name),
233 fV0Reader(NULL),
234 fBGHandler(NULL),
235 fInputEvent(NULL),
236 fMCEvent(NULL),
237 fMCStack(NULL),
238 fCutFolder(NULL),
239 fESDList(NULL),
240 fBackList(NULL),
241 fMotherList(NULL),
242 fTrueList(NULL),
243 fMCList(NULL),
244 fHeaderNameList(NULL),
245 fOutputContainer(0),
246 fClusterCandidates(NULL),
247 fEventCutArray(NULL),
248 fEventCuts(NULL),
249 fClusterCutArray(NULL),
250 fCaloPhotonCuts(NULL),
251 fMesonCutArray(NULL),
252 fMesonCuts(NULL),
253 fHistoMotherInvMassPt(NULL),
8c96b4f9 254 fHistoMotherInvMass3ClusterPt(NULL),
d53bf4ac 255 fSparseMotherInvMassPtZM(NULL),
256 fHistoMotherBackInvMassPt(NULL),
257 fSparseMotherBackInvMassPtZM(NULL),
258 fHistoMotherInvMassEalpha(NULL),
259 fHistoMotherPi0PtY(NULL),
260 fHistoMotherEtaPtY(NULL),
261 fHistoMotherPi0PtAlpha(NULL),
262 fHistoMotherEtaPtAlpha(NULL),
263 fHistoMotherPi0PtOpenAngle(NULL),
264 fHistoMotherEtaPtOpenAngle(NULL),
265 fHistoMotherInvMassECalib(NULL),
266 fHistoMotherInvMassECalibalpha(NULL),
267 fHistoClusGammaPt(NULL),
ecd3e131 268 fHistoClusOverlapHeadersGammaPt(NULL),
d53bf4ac 269 fHistoMCHeaders(NULL),
270 fHistoMCAllGammaPt(NULL),
271 fHistoMCDecayGammaPi0Pt(NULL),
272 fHistoMCDecayGammaRhoPt(NULL),
273 fHistoMCDecayGammaEtaPt(NULL),
274 fHistoMCDecayGammaOmegaPt(NULL),
275 fHistoMCDecayGammaEtapPt(NULL),
276 fHistoMCDecayGammaPhiPt(NULL),
277 fHistoMCDecayGammaSigmaPt(NULL),
278 fHistoMCPi0Pt(NULL),
279 fHistoMCPi0WOWeightPt(NULL),
280 fHistoMCEtaPt(NULL),
281 fHistoMCEtaWOWeightPt(NULL),
282 fHistoMCPi0InAccPt(NULL),
283 fHistoMCEtaInAccPt(NULL),
284 fHistoMCPi0PtY(NULL),
285 fHistoMCEtaPtY(NULL),
de752898 286 fHistoMCPi0PtAlpha(NULL),
287 fHistoMCEtaPtAlpha(NULL),
d53bf4ac 288 fHistoMCK0sPt(NULL),
289 fHistoMCK0sWOWeightPt(NULL),
290 fHistoMCK0sPtY(NULL),
291 fHistoMCSecPi0PtvsSource(NULL),
292 fHistoMCSecPi0Source(NULL),
293 fHistoMCSecEtaPt(NULL),
294 fHistoMCSecEtaSource(NULL),
ed8bc1ca 295 fHistoTruePi0InvMassPt(NULL),
296 fHistoTrueEtaInvMassPt(NULL),
297 fHistoTruePi0CaloPhotonInvMassPt(NULL),
298 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
d53bf4ac 299 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
300 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
ed8bc1ca 301 fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt(NULL),
302 fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt(NULL),
303 fHistoTruePi0CaloElectronInvMassPt(NULL),
304 fHistoTrueEtaCaloElectronInvMassPt(NULL),
305 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
306 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
307 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
308 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
def90c8b 309 fHistoTruePi0NonMergedElectronPhotonInvMassPt(NULL),
310 fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt(NULL),
5cd70387 311 fHistoTruePi0Category1(NULL),
312 fHistoTrueEtaCategory1(NULL),
313 fHistoTruePi0Category2(NULL),
314 fHistoTrueEtaCategory2(NULL),
315 fHistoTruePi0Category3(NULL),
316 fHistoTrueEtaCategory3(NULL),
317 fHistoTruePi0Category4_6(NULL),
318 fHistoTrueEtaCategory4_6(NULL),
319 fHistoTruePi0Category5(NULL),
320 fHistoTrueEtaCategory5(NULL),
321 fHistoTruePi0Category7(NULL),
322 fHistoTrueEtaCategory7(NULL),
323 fHistoTruePi0Category8(NULL),
324 fHistoTrueEtaCategory8(NULL),
ed8bc1ca 325 fHistoTruePrimaryPi0InvMassPt(NULL),
326 fHistoTruePrimaryEtaInvMassPt(NULL),
327 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
328 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
329 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
330 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
d53bf4ac 331 fHistoTruePrimaryPi0MCPtResolPt(NULL),
332 fHistoTruePrimaryEtaMCPtResolPt(NULL),
ed8bc1ca 333 fHistoTrueSecondaryPi0InvMassPt(NULL),
ed8bc1ca 334 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
d53bf4ac 335 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
ed8bc1ca 336 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
d53bf4ac 337 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
ed8bc1ca 338 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
d53bf4ac 339 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
340 fHistoTrueBckGGInvMassPt(NULL),
341 fHistoTrueBckContInvMassPt(NULL),
342 fHistoTruePi0PtY(NULL),
343 fHistoTrueEtaPtY(NULL),
344 fHistoTruePi0PtAlpha(NULL),
345 fHistoTrueEtaPtAlpha(NULL),
346 fHistoTruePi0PtOpenAngle(NULL),
347 fHistoTrueEtaPtOpenAngle(NULL),
348 fHistoClusPhotonBGPt(NULL),
349 fHistoClusPhotonPlusConvBGPt(NULL),
350 fHistoTrueClusGammaPt(NULL),
351 fHistoTrueClusUnConvGammaPt(NULL),
352 fHistoTrueClusUnConvGammaMCPt(NULL),
353 fHistoTrueClusElectronPt(NULL),
354 fHistoTrueClusConvGammaPt(NULL),
355 fHistoTrueClusConvGammaMCPt(NULL),
356 fHistoTrueClusConvGammaFullyPt(NULL),
357 fHistoTrueClusMergedGammaPt(NULL),
358 fHistoTrueClusMergedPartConvGammaPt(NULL),
359 fHistoTrueClusDalitzPt(NULL),
360 fHistoTrueClusDalitzMergedPt(NULL),
361 fHistoTrueClusPhotonFromElecMotherPt(NULL),
362 fHistoTrueClusShowerPt(NULL),
363 fHistoTrueClusSubLeadingPt(NULL),
364 fHistoTrueClusNParticles(NULL),
365 fHistoTrueClusEMNonLeadingPt(NULL),
366 fHistoTrueNLabelsInClus(NULL),
367 fHistoTruePrimaryClusGammaPt(NULL),
368 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
369 fHistoTruePrimaryClusConvGammaPt(NULL),
370 fHistoTruePrimaryClusConvGammaESDPtMCPt(NULL),
371 fHistoTrueSecondaryClusGammaPt(NULL),
372 fHistoTrueSecondaryClusConvGammaPt(NULL),
373 fHistoTrueSecondaryClusGammaFromXFromK0sPt(NULL),
374 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt(NULL),
375 fHistoTrueSecondaryClusGammaFromXFromLambdaPt(NULL),
376 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt(NULL),
377 fHistoTrueSecondaryClusGammaFromXFromEtasPt(NULL),
378 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt(NULL),
379 fHistoNEvents(NULL),
380 fHistoNGoodESDTracks(NULL),
381 fHistoNGammaCandidates(NULL),
382 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
383 fHistoNV0Tracks(NULL),
384 fProfileEtaShift(NULL),
385 fEventPlaneAngle(-100),
386 fRandom(0),
387 fnCuts(0),
388 fiCut(0),
389 fIsHeavyIon(0),
390 fDoMesonAnalysis(kTRUE),
391 fDoMesonQA(0),
392 fDoClusterQA(0),
393 fIsFromMBHeader(kTRUE),
ecd3e131 394 fIsOverlappingWithOtherHeader(kFALSE),
d53bf4ac 395 fIsMC(kFALSE)
396{
397 // Define output slots here
398 DefineOutput(1, TList::Class());
399}
400
401AliAnalysisTaskGammaCalo::~AliAnalysisTaskGammaCalo()
402{
403 if(fClusterCandidates){
404 delete fClusterCandidates;
405 fClusterCandidates = 0x0;
406 }
407 if(fBGHandler){
408 delete[] fBGHandler;
409 fBGHandler = 0x0;
410 }
411}
412//___________________________________________________________
413void AliAnalysisTaskGammaCalo::InitBack(){
414
415 const Int_t nDim = 4;
cfd87ccd 416 Int_t nBins[nDim] = {800,250,7,6};
d53bf4ac 417 Double_t xMin[nDim] = {0,0, 0,0};
cfd87ccd 418 Double_t xMax[nDim] = {0.8,25,7,6};
d53bf4ac 419
420 fSparseMotherInvMassPtZM = new THnSparseF*[fnCuts];
421 fSparseMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
422
423 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
424
425
426 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
427 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
428 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
429 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
430 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
431
432 Int_t collisionSystem = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(0,1));
433 Int_t centMin = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(1,1));
434 Int_t centMax = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(2,1));
435
436 if(collisionSystem == 1 || collisionSystem == 2 ||
437 collisionSystem == 5 || collisionSystem == 8 ||
438 collisionSystem == 9){
439 centMin = centMin*10;
440 centMax = centMax*10;
441 if(centMax ==0 && centMax!=centMin) centMax=100;
442 } else if(collisionSystem == 3 || collisionSystem == 6){
443 centMin = centMin*5;
444 centMax = centMax*5;
445 } else if(collisionSystem == 4 || collisionSystem == 7){
446 centMin = ((centMin*5)+45);
447 centMax = ((centMax*5)+45);
448 }
449
450 fBackList[iCut] = new TList();
451 fBackList[iCut]->SetName(Form("%s_%s_%s Back histograms",cutstringEvent.Data(),cutstringCalo.Data(), cutstringMeson.Data()));
452 fBackList[iCut]->SetOwner(kTRUE);
453 fCutFolder[iCut]->Add(fBackList[iCut]);
454
455 fSparseMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
456 fBackList[iCut]->Add(fSparseMotherBackInvMassPtZM[iCut]);
457
458 fMotherList[iCut] = new TList();
459 fMotherList[iCut]->SetName(Form("%s_%s_%s Mother histograms",cutstringEvent.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
460 fMotherList[iCut]->SetOwner(kTRUE);
461 fCutFolder[iCut]->Add(fMotherList[iCut]);
462
463 fSparseMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
464 fMotherList[iCut]->Add(fSparseMotherInvMassPtZM[iCut]);
465
466 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
467 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
468 collisionSystem,centMin,centMax,
469 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
cfd87ccd 470 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity(),
471 4,8,7);
d53bf4ac 472 }
473 }
474 }
475}
476//________________________________________________________________________
477void AliAnalysisTaskGammaCalo::UserCreateOutputObjects(){
478
479 // Create histograms
480 if(fOutputContainer != NULL){
481 delete fOutputContainer;
482 fOutputContainer = NULL;
483 }
484 if(fOutputContainer == NULL){
485 fOutputContainer = new TList();
486 fOutputContainer->SetOwner(kTRUE);
487 }
488
489 // Array of current cut's gammas
490 fClusterCandidates = new TList();
491
492 fCutFolder = new TList*[fnCuts];
493 fESDList = new TList*[fnCuts];
494 fBackList = new TList*[fnCuts];
495 fMotherList = new TList*[fnCuts];
496 fHistoNEvents = new TH1I*[fnCuts];
497 fHistoNGoodESDTracks = new TH1I*[fnCuts];
498 fHistoNGammaCandidates = new TH1I*[fnCuts];
499 fHistoNGoodESDTracksVsNGammaCanditates = new TH2F*[fnCuts];
500 fHistoNV0Tracks = new TH1I*[fnCuts];
501 fProfileEtaShift = new TProfile*[fnCuts];
502
503 if(fDoMesonAnalysis){
504 fHistoMotherInvMassPt = new TH2F*[fnCuts];
8c96b4f9 505 fHistoMotherInvMass3ClusterPt = new TH2F*[fnCuts];
d53bf4ac 506 fHistoMotherBackInvMassPt = new TH2F*[fnCuts];
507 fHistoMotherInvMassEalpha = new TH2F*[fnCuts];
508 if (fDoMesonQA > 0){
509 fHistoMotherPi0PtY = new TH2F*[fnCuts];
510 fHistoMotherEtaPtY = new TH2F*[fnCuts];
511 fHistoMotherPi0PtAlpha = new TH2F*[fnCuts];
512 fHistoMotherEtaPtAlpha = new TH2F*[fnCuts];
513 fHistoMotherPi0PtOpenAngle = new TH2F*[fnCuts];
514 fHistoMotherEtaPtOpenAngle = new TH2F*[fnCuts];
515 }
516 if(fDoMesonQA == 1){
517 fHistoMotherInvMassECalib = new TH2F*[fnCuts];
518 fHistoMotherInvMassECalibalpha = new TH2F*[fnCuts];
519 }
520 }
521
522 fHistoClusGammaPt = new TH1F*[fnCuts];
ecd3e131 523 fHistoClusOverlapHeadersGammaPt = new TH1F*[fnCuts];
d53bf4ac 524
525 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
526 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
527 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
528 TString cutstringMeson = "NoMesonCut";
529 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
530
531 fCutFolder[iCut] = new TList();
532 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s",cutstringEvent.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
533 fCutFolder[iCut]->SetOwner(kTRUE);
534 fOutputContainer->Add(fCutFolder[iCut]);
535 fESDList[iCut] = new TList();
536 fESDList[iCut]->SetName(Form("%s_%s_%s ESD histograms",cutstringEvent.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
537 fESDList[iCut]->SetOwner(kTRUE);
538 fCutFolder[iCut]->Add(fESDList[iCut]);
539
7f070437 540 fHistoNEvents[iCut] = new TH1I("NEvents","NEvents",10,-0.5,9.5);
d53bf4ac 541 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
542 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
543 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
f57c67ac 544 if (((AliConvEventCuts*)fEventCutArray->At(iCut))->IsSpecialTrigger() > 1 ){
d53bf4ac 545 TString TriggerNames = "Not Trigger: ";
546 TriggerNames = TriggerNames+ ( (AliConvEventCuts*)fEventCutArray->At(iCut))->GetSpecialTriggerName();
547 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
548 } else {
549 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
550 }
551 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
552 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
553 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
554 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
555 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
7f070437 556 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(10,"EMCAL problems");
d53bf4ac 557 fESDList[iCut]->Add(fHistoNEvents[iCut]);
558
559 if(fIsHeavyIon == 1) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
560 else if(fIsHeavyIon == 2) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",400,0,400);
561 else fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
562 fESDList[iCut]->Add(fHistoNGoodESDTracks[iCut]);
563 if(fIsHeavyIon == 1) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",600,0,600);
564 else if(fIsHeavyIon == 2) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",400,0,400);
565 else fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
566 fESDList[iCut]->Add(fHistoNGammaCandidates[iCut]);
567 if(fIsHeavyIon == 1) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",4000,0,4000,600,0,600);
568 else if(fIsHeavyIon == 2) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",400,0,400,400,0,400);
569 else fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",200,0,200,100,0,100);
570 fESDList[iCut]->Add(fHistoNGoodESDTracksVsNGammaCanditates[iCut]);
571
572
573 if(fIsHeavyIon == 1) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
574 else if(fIsHeavyIon == 2) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
575 else fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
576 fESDList[iCut]->Add(fHistoNV0Tracks[iCut]);
577 fProfileEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
578 fESDList[iCut]->Add(fProfileEtaShift[iCut]);
579
580 fHistoClusGammaPt[iCut] = new TH1F("ClusGamma_Pt","ClusGamma_Pt",250,0,25);
581 fESDList[iCut]->Add(fHistoClusGammaPt[iCut]);
ecd3e131 582 fHistoClusOverlapHeadersGammaPt[iCut] = new TH1F("ClusGammaOverlapHeaders_Pt","ClusGammaOverlapHeaders_Pt",250,0,25);
583 fESDList[iCut]->Add(fHistoClusOverlapHeadersGammaPt[iCut]);
d53bf4ac 584
585 if(fDoMesonAnalysis){
586 fHistoMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
587 fESDList[iCut]->Add(fHistoMotherInvMassPt[iCut]);
8c96b4f9 588 fHistoMotherInvMass3ClusterPt[iCut] = new TH2F("ESD_Mother_InvMass3Cluster_Pt","ESD_Mother_InvMass3Cluster_Pt",800,0,0.8,250,0,25);
589 fESDList[iCut]->Add(fHistoMotherInvMass3ClusterPt[iCut]);
d53bf4ac 590 fHistoMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
591 fESDList[iCut]->Add(fHistoMotherBackInvMassPt[iCut]);
592 fHistoMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
593 fESDList[iCut]->Add(fHistoMotherInvMassEalpha[iCut]);
594 if(fDoMesonQA == 1){
595 fHistoMotherInvMassECalib[iCut] = new TH2F("ESD_Mother_InvMass_Pt_Calib","ESD_Mother_InvMass_Pt_Calib",800,0,0.8,250,0,25);
596 fESDList[iCut]->Add(fHistoMotherInvMassECalib[iCut]);
597 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);
598 fESDList[iCut]->Add(fHistoMotherInvMassECalibalpha[iCut]);
599 }
600
601 if (fDoMesonQA > 0 ){
602 fHistoMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
603 SetLogBinningXTH2(fHistoMotherPi0PtY[iCut]);
604 fESDList[iCut]->Add(fHistoMotherPi0PtY[iCut]);
605 fHistoMotherEtaPtY[iCut] = new TH2F("ESD_MotherEta_Pt_Y","ESD_MotherEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
606 SetLogBinningXTH2(fHistoMotherEtaPtY[iCut]);
607 fESDList[iCut]->Add(fHistoMotherEtaPtY[iCut]);
608 fHistoMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",150,0.03,15.,100,0,1);
609 SetLogBinningXTH2(fHistoMotherPi0PtAlpha[iCut]);
610 fESDList[iCut]->Add(fHistoMotherPi0PtAlpha[iCut]);
611 fHistoMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",150,0.03,15.,100,0,1);
612 SetLogBinningXTH2(fHistoMotherEtaPtAlpha[iCut]);
613 fESDList[iCut]->Add(fHistoMotherEtaPtAlpha[iCut]);
f57c67ac 614 fHistoMotherPi0PtOpenAngle[iCut] = new TH2F("ESD_MotherPi0_Pt_OpenAngle","ESD_MotherPi0_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
d53bf4ac 615 SetLogBinningXTH2(fHistoMotherPi0PtOpenAngle[iCut]);
616 fESDList[iCut]->Add(fHistoMotherPi0PtOpenAngle[iCut]);
f57c67ac 617 fHistoMotherEtaPtOpenAngle[iCut] = new TH2F("ESD_MotherEta_Pt_OpenAngle","ESD_MotherEta_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
d53bf4ac 618 SetLogBinningXTH2(fHistoMotherEtaPtOpenAngle[iCut]);
619 fESDList[iCut]->Add(fHistoMotherEtaPtOpenAngle[iCut]);
620 }
621 }
622 }
623 if(fDoMesonAnalysis){
624 InitBack(); // Init Background Handler
625 }
626
627 if(fIsMC){
628 // MC Histogramms
629 fMCList = new TList*[fnCuts];
630 // True Histogramms
631 fTrueList = new TList*[fnCuts];
632 // Selected Header List
633 fHeaderNameList = new TList*[fnCuts];
634 fHistoMCHeaders = new TH1I*[fnCuts];
635 fHistoMCAllGammaPt = new TH1F*[fnCuts];
636 fHistoMCDecayGammaPi0Pt = new TH1F*[fnCuts];
637 fHistoMCDecayGammaRhoPt = new TH1F*[fnCuts];
638 fHistoMCDecayGammaEtaPt = new TH1F*[fnCuts];
639 fHistoMCDecayGammaOmegaPt = new TH1F*[fnCuts];
640 fHistoMCDecayGammaEtapPt = new TH1F*[fnCuts];
641 fHistoMCDecayGammaPhiPt = new TH1F*[fnCuts];
642 fHistoMCDecayGammaSigmaPt = new TH1F*[fnCuts];
643
644 fHistoClusPhotonBGPt = new TH2F*[fnCuts];
645 fHistoClusPhotonPlusConvBGPt = new TH2F*[fnCuts];
646
647 fHistoTrueClusGammaPt = new TH1F*[fnCuts];
648 fHistoTruePrimaryClusGammaPt = new TH1F*[fnCuts];
649 fHistoTruePrimaryClusGammaESDPtMCPt = new TH2F*[fnCuts];
650 fHistoTruePrimaryClusConvGammaPt = new TH1F*[fnCuts];
651 fHistoTruePrimaryClusConvGammaESDPtMCPt = new TH2F*[fnCuts];
652 fHistoTrueSecondaryClusGammaPt = new TH1F*[fnCuts];
653 fHistoTrueSecondaryClusConvGammaPt = new TH1F*[fnCuts];
654 fHistoTrueSecondaryClusGammaFromXFromK0sPt = new TH1F*[fnCuts];
655 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
656 fHistoTrueSecondaryClusGammaFromXFromLambdaPt = new TH1F*[fnCuts];
657 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
658 fHistoTrueSecondaryClusGammaFromXFromEtasPt = new TH1F*[fnCuts];
659 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt = new TH1F*[fnCuts];
660
d53bf4ac 661 if (fDoClusterQA > 0){
662 fHistoTrueClusUnConvGammaPt = new TH1F*[fnCuts];
663 fHistoTrueClusUnConvGammaMCPt = new TH1F*[fnCuts];
664 fHistoTrueClusElectronPt = new TH1F*[fnCuts];
665 fHistoTrueClusConvGammaPt = new TH1F*[fnCuts];
666 fHistoTrueClusConvGammaMCPt = new TH1F*[fnCuts];
667 fHistoTrueClusConvGammaFullyPt = new TH1F*[fnCuts];
668 fHistoTrueClusMergedGammaPt = new TH1F*[fnCuts];
669 fHistoTrueClusMergedPartConvGammaPt = new TH1F*[fnCuts];
670 fHistoTrueClusDalitzPt = new TH1F*[fnCuts];
671 fHistoTrueClusDalitzMergedPt = new TH1F*[fnCuts];
672 fHistoTrueClusPhotonFromElecMotherPt= new TH1F*[fnCuts];
673 fHistoTrueClusShowerPt = new TH1F*[fnCuts];
674 fHistoTrueClusSubLeadingPt = new TH1F*[fnCuts];
675 fHistoTrueClusNParticles = new TH1I*[fnCuts];
676 fHistoTrueClusEMNonLeadingPt = new TH1F*[fnCuts];
677 fHistoTrueNLabelsInClus = new TH1F*[fnCuts];
678 }
679
680 if(fDoMesonAnalysis){
681 fHistoMCPi0Pt = new TH1F*[fnCuts];
682 fHistoMCPi0WOWeightPt = new TH1F*[fnCuts];
683 fHistoMCEtaPt = new TH1F*[fnCuts];
684 fHistoMCEtaWOWeightPt = new TH1F*[fnCuts];
685 fHistoMCPi0InAccPt = new TH1F*[fnCuts];
686 fHistoMCEtaInAccPt = new TH1F*[fnCuts];
687
ed8bc1ca 688 fHistoTruePi0InvMassPt = new TH2F*[fnCuts];
689 fHistoTrueEtaInvMassPt = new TH2F*[fnCuts];
690 fHistoTruePrimaryPi0InvMassPt = new TH2F*[fnCuts];
691 fHistoTruePrimaryEtaInvMassPt = new TH2F*[fnCuts];
692 fHistoTruePrimaryPi0W0WeightingInvMassPt = new TH2F*[fnCuts];
693 fHistoTruePrimaryEtaW0WeightingInvMassPt = new TH2F*[fnCuts];
694 fProfileTruePrimaryPi0WeightsInvMassPt = new TProfile2D*[fnCuts];
695 fProfileTruePrimaryEtaWeightsInvMassPt = new TProfile2D*[fnCuts];
696 fHistoTrueSecondaryPi0InvMassPt = new TH2F*[fnCuts];
ed8bc1ca 697 fHistoTrueSecondaryPi0FromK0sInvMassPt = new TH2F*[fnCuts];
698 fHistoTrueSecondaryPi0FromEtaInvMassPt = new TH2F*[fnCuts];
699 fHistoTrueSecondaryPi0FromLambdaInvMassPt = new TH2F*[fnCuts];
d53bf4ac 700 if (fDoMesonQA > 0){
701 fHistoMCPi0PtY = new TH2F*[fnCuts];
702 fHistoMCEtaPtY = new TH2F*[fnCuts];
de752898 703 fHistoMCPi0PtAlpha = new TH2F*[fnCuts];
704 fHistoMCEtaPtAlpha = new TH2F*[fnCuts];
d53bf4ac 705 fHistoMCK0sPt = new TH1F*[fnCuts];
706 fHistoMCK0sWOWeightPt = new TH1F*[fnCuts];
707 fHistoMCK0sPtY = new TH2F*[fnCuts];
708 fHistoMCSecPi0PtvsSource = new TH2F*[fnCuts];
709 fHistoMCSecPi0Source = new TH1F*[fnCuts];
710 fHistoMCSecEtaPt = new TH1F*[fnCuts];
711 fHistoMCSecEtaSource = new TH1F*[fnCuts];
ed8bc1ca 712 fHistoTruePi0CaloPhotonInvMassPt = new TH2F*[fnCuts];
713 fHistoTrueEtaCaloPhotonInvMassPt = new TH2F*[fnCuts];
714 fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt= new TH2F*[fnCuts];
715 fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt= new TH2F*[fnCuts];
d53bf4ac 716 fHistoTruePi0CaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
717 fHistoTrueEtaCaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
ed8bc1ca 718 fHistoTruePi0CaloElectronInvMassPt = new TH2F*[fnCuts];
719 fHistoTrueEtaCaloElectronInvMassPt = new TH2F*[fnCuts];
720 fHistoTruePi0CaloMergedClusterInvMassPt = new TH2F*[fnCuts];
721 fHistoTrueEtaCaloMergedClusterInvMassPt = new TH2F*[fnCuts];
722 fHistoTruePi0CaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
723 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
def90c8b 724 fHistoTruePi0NonMergedElectronPhotonInvMassPt = new TH2F*[fnCuts];
725 fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt = new TH2F*[fnCuts];
d53bf4ac 726 fHistoTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
727 fHistoTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
728 fHistoTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
729 fHistoTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
730 fHistoTrueLambdaWithPi0DaughterMCPt = new TH1F*[fnCuts];
731 fHistoTrueBckGGInvMassPt = new TH2F*[fnCuts];
732 fHistoTrueBckContInvMassPt = new TH2F*[fnCuts];
733 fHistoTruePi0PtY = new TH2F*[fnCuts];
734 fHistoTrueEtaPtY = new TH2F*[fnCuts];
735 fHistoTruePi0PtAlpha = new TH2F*[fnCuts];
736 fHistoTrueEtaPtAlpha = new TH2F*[fnCuts];
737 fHistoTruePi0PtOpenAngle = new TH2F*[fnCuts];
738 fHistoTrueEtaPtOpenAngle = new TH2F*[fnCuts];
739 }
5cd70387 740 if (fDoMesonQA==2){
741 fHistoTruePi0Category1 = new TH2F*[fnCuts];
742 fHistoTrueEtaCategory1 = new TH2F*[fnCuts];
743 fHistoTruePi0Category2 = new TH2F*[fnCuts];
744 fHistoTrueEtaCategory2 = new TH2F*[fnCuts];
745 fHistoTruePi0Category3 = new TH2F*[fnCuts];
746 fHistoTrueEtaCategory3 = new TH2F*[fnCuts];
747 fHistoTruePi0Category4_6 = new TH2F*[fnCuts];
748 fHistoTrueEtaCategory4_6 = new TH2F*[fnCuts];
749 fHistoTruePi0Category5 = new TH2F*[fnCuts];
750 fHistoTrueEtaCategory5 = new TH2F*[fnCuts];
751 fHistoTruePi0Category7 = new TH2F*[fnCuts];
752 fHistoTrueEtaCategory7 = new TH2F*[fnCuts];
753 fHistoTruePi0Category8 = new TH2F*[fnCuts];
754 fHistoTrueEtaCategory8 = new TH2F*[fnCuts];
755 }
d53bf4ac 756 }
757
758
759
760 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
761 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
762 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
763 TString cutstringMeson = "NoMesonCut";
764 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
765
766 fMCList[iCut] = new TList();
767 fMCList[iCut]->SetName(Form("%s_%s_%s MC histograms",cutstringEvent.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
768 fMCList[iCut]->SetOwner(kTRUE);
769 fCutFolder[iCut]->Add(fMCList[iCut]);
770 fHistoMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
771 fMCList[iCut]->Add(fHistoMCHeaders[iCut]);
772 fHistoMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
773 fMCList[iCut]->Add(fHistoMCAllGammaPt[iCut]);
774 fHistoMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
775 fMCList[iCut]->Add(fHistoMCDecayGammaPi0Pt[iCut]);
776 fHistoMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
777 fMCList[iCut]->Add(fHistoMCDecayGammaRhoPt[iCut]);
778 fHistoMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
779 fMCList[iCut]->Add(fHistoMCDecayGammaEtaPt[iCut]);
780 fHistoMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
781 fMCList[iCut]->Add(fHistoMCDecayGammaOmegaPt[iCut]);
782 fHistoMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
783 fMCList[iCut]->Add(fHistoMCDecayGammaEtapPt[iCut]);
784 fHistoMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
785 fMCList[iCut]->Add(fHistoMCDecayGammaPhiPt[iCut]);
786 fHistoMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
787 fMCList[iCut]->Add(fHistoMCDecayGammaSigmaPt[iCut]);
788
789 if(fDoMesonAnalysis){
790 fHistoMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
791 fHistoMCPi0Pt[iCut]->Sumw2();
792 fMCList[iCut]->Add(fHistoMCPi0Pt[iCut]);
793 fHistoMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
794 fHistoMCPi0WOWeightPt[iCut]->Sumw2();
795 fMCList[iCut]->Add(fHistoMCPi0WOWeightPt[iCut]);
796
797 fHistoMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
798 fHistoMCEtaPt[iCut]->Sumw2();
799 fMCList[iCut]->Add(fHistoMCEtaPt[iCut]);
800 fHistoMCEtaWOWeightPt[iCut] = new TH1F("MC_Eta_WOWeights_Pt","MC_Eta_WOWeights_Pt",250,0,25);
801 fHistoMCEtaWOWeightPt[iCut]->Sumw2();
802 fMCList[iCut]->Add(fHistoMCEtaWOWeightPt[iCut]);
803 fHistoMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
804 fHistoMCPi0InAccPt[iCut]->Sumw2();
805 fMCList[iCut]->Add(fHistoMCPi0InAccPt[iCut]);
806 fHistoMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
807 fHistoMCEtaInAccPt[iCut]->Sumw2();
808 fMCList[iCut]->Add(fHistoMCEtaInAccPt[iCut]);
809 if (fDoMesonQA > 0){
810 fHistoMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
811 fHistoMCPi0PtY[iCut]->Sumw2();
812 SetLogBinningXTH2(fHistoMCPi0PtY[iCut]);
813 fMCList[iCut]->Add(fHistoMCPi0PtY[iCut]);
814 fHistoMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
815 fHistoMCEtaPtY[iCut]->Sumw2();
816 SetLogBinningXTH2(fHistoMCEtaPtY[iCut]);
817 fMCList[iCut]->Add(fHistoMCEtaPtY[iCut]);
de752898 818 fHistoMCPi0PtAlpha[iCut] = new TH2F("MC_Pi0_Pt_Alpha","MC_Pi0_Pt_Alpha",150,0.03,15.,100,0,1);
819 SetLogBinningXTH2(fHistoMCPi0PtAlpha[iCut]);
820 fMCList[iCut]->Add(fHistoMCPi0PtAlpha[iCut]);
821 fHistoMCEtaPtAlpha[iCut] = new TH2F("MC_Eta_Pt_Alpha","MC_Eta_Pt_Alpha",150,0.03,15.,100,0,1);
822 SetLogBinningXTH2(fHistoMCEtaPtAlpha[iCut]);
823 fMCList[iCut]->Add(fHistoMCEtaPtAlpha[iCut]);
824
d53bf4ac 825 fHistoMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",150,0,15);
826 fHistoMCK0sPt[iCut]->Sumw2();
827 fMCList[iCut]->Add(fHistoMCK0sPt[iCut]);
828 fHistoMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",150,0,15);
829 fHistoMCK0sWOWeightPt[iCut]->Sumw2();
830 fMCList[iCut]->Add(fHistoMCK0sWOWeightPt[iCut]);
831 fHistoMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",150,0.03,15.,150,-1.5,1.5);
832 fHistoMCK0sPtY[iCut]->Sumw2();
833 SetLogBinningXTH2(fHistoMCK0sPtY[iCut]);
834 fMCList[iCut]->Add(fHistoMCK0sPtY[iCut]);
835
836 fHistoMCSecPi0Source[iCut] = new TH1F("MC_SecPi0_Source","MC_SecPi0_Source",5000,0.,5000);
837 fMCList[iCut]->Add(fHistoMCSecPi0Source[iCut]);
838 fHistoMCSecEtaSource[iCut] = new TH1F("MC_SecEta_Source","MC_SecEta_Source",5000,0,5000);
839 fMCList[iCut]->Add(fHistoMCSecEtaSource[iCut]);
840 fHistoMCSecPi0PtvsSource[iCut] = new TH2F("MC_SecPi0_Pt_Source","MC_SecPi0_Pt_Source",250,0.0,25.,16,-0.5,15.5);
841 fHistoMCSecPi0PtvsSource[iCut]->Sumw2();
842 fMCList[iCut]->Add(fHistoMCSecPi0PtvsSource[iCut]);
843 fHistoMCSecEtaPt[iCut] = new TH1F("MC_SecEta_Pt","MC_SecEta_Pt",250,0,25);
844 fHistoMCSecEtaPt[iCut]->Sumw2();
845 fMCList[iCut]->Add(fHistoMCSecEtaPt[iCut]);
846 }
847
848 }
849 fTrueList[iCut] = new TList();
850 fTrueList[iCut]->SetName(Form("%s_%s_%s True histograms",cutstringEvent.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
851 fTrueList[iCut]->SetOwner(kTRUE);
852 fCutFolder[iCut]->Add(fTrueList[iCut]);
853
854 fHistoClusPhotonBGPt[iCut] = new TH2F("ESD_TrueClusPhotonBG_Pt","ESD_TrueClusPhotonBG_Pt",250,0,25,9,-0.5,8.5);
855 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec");
856 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 2,"Pion");
857 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 3,"Proton");
858 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 4,"Kaon");
859 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 5,"Neutron");
860 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 6,"K0s");
861 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 7,"Lambda");
862 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 8,"Muon");
863 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel(9,"Rest");
864 fTrueList[iCut]->Add(fHistoClusPhotonBGPt[iCut]);
865 fHistoClusPhotonPlusConvBGPt[iCut] = new TH2F("ESD_TrueClusPhotonPlusConvBG_Pt","ESD_TrueClusPhotonPlusConvBG_Pt",250,0,25,9,-0.5,8.5);
866 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec");
867 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 2,"Pion");
868 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 3,"Proton");
869 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 4,"Kaon");
870 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 5,"Neutron");
871 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 6,"K0s");
872 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 7,"Lambda");
873 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 8,"Muon");
874 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel(9,"Rest");
875 fTrueList[iCut]->Add(fHistoClusPhotonPlusConvBGPt[iCut]);
876
877 fHistoTrueClusGammaPt[iCut] = new TH1F("TrueClusGamma_Pt","ESD_TrueClusGamma_Pt",250,0,25);
878 fTrueList[iCut]->Add(fHistoTrueClusGammaPt[iCut]);
879 fHistoTruePrimaryClusGammaPt[iCut] = new TH1F("TruePrimaryClusGamma_Pt","ESD_TruePrimaryClusGamma_Pt",250,0,25);
880 fTrueList[iCut]->Add(fHistoTruePrimaryClusGammaPt[iCut]);
881 fHistoTruePrimaryClusGammaESDPtMCPt[iCut] = new TH2F("TruePrimaryClusGamma_Pt_MCPt","ESD_TruePrimaryClusGamma_MCPt",250,0,25,250,0,25);
882 fTrueList[iCut]->Add(fHistoTruePrimaryClusGammaESDPtMCPt[iCut]);
883 fHistoTruePrimaryClusConvGammaPt[iCut] = new TH1F("TruePrimaryClusConvGamma_Pt","ESD_TruePrimaryClusConvGamma_Pt",250,0,25);
884 fTrueList[iCut]->Add(fHistoTruePrimaryClusConvGammaPt[iCut]);
885 fHistoTruePrimaryClusConvGammaESDPtMCPt[iCut] = new TH2F("TruePrimaryClusConvGamma_Pt_MCPt","ESD_TruePrimaryClusConvGamma_MCPt",250,0,25,250,0,25);
886 fTrueList[iCut]->Add(fHistoTruePrimaryClusConvGammaESDPtMCPt[iCut]);
887 fHistoTrueSecondaryClusGammaPt[iCut] = new TH1F("ESD_TrueSecondaryClusGamma_Pt","ESD_TrueSecondaryClusGamma_Pt",250,0,25);
888 fTrueList[iCut]->Add(fHistoTrueSecondaryClusGammaPt[iCut]);
889 fHistoTrueSecondaryClusConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryClusConvGamma_Pt","ESD_TrueSecondaryClusConvGamma_Pt",250,0,25);
890 fTrueList[iCut]->Add(fHistoTrueSecondaryClusConvGammaPt[iCut]);
891
892 fHistoTrueSecondaryClusGammaFromXFromK0sPt[iCut] = new TH1F("ESD_TrueSecondaryClusGammaFromXFromK0s_Pt", "ESD_TrueSecondaryClusGammaFromXFromK0s_Pt",250,0,25);
893 fTrueList[iCut]->Add(fHistoTrueSecondaryClusGammaFromXFromK0sPt[iCut]);
894 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt[iCut] = new TH1F("ESD_TrueSecondaryClusConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryClusConvGammaFromXFromK0s_Pt",250,0,25);
895 fTrueList[iCut]->Add(fHistoTrueSecondaryClusConvGammaFromXFromK0sPt[iCut]);
896 fHistoTrueSecondaryClusGammaFromXFromLambdaPt[iCut] = new TH1F("ESD_TrueSecondaryClusGammaFromXFromLambda_Pt", "ESD_TrueSecondaryClusGammaFromXFromLambda_Pt",250,0,25);
897 fTrueList[iCut]->Add(fHistoTrueSecondaryClusGammaFromXFromLambdaPt[iCut]);
898 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt[iCut] = new TH1F("ESD_TrueSecondaryClusConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryClusConvGammaFromXFromLambda_Pt",250,0,25);
899 fTrueList[iCut]->Add(fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt[iCut]);
900 fHistoTrueSecondaryClusGammaFromXFromEtasPt[iCut] = new TH1F("ESD_TrueSecondaryClusGammaFromXFromEtas_Pt", "ESD_TrueSecondaryClusGammaFromXFromEtas_Pt",250,0,25);
901 fTrueList[iCut]->Add(fHistoTrueSecondaryClusGammaFromXFromEtasPt[iCut]);
902 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt[iCut] = new TH1F("ESD_TrueSecondaryClusConvGammaFromXFromEtas_Pt", "ESD_TrueSecondaryClusConvGammaFromXFromEtas_Pt",250,0,25);
903 fTrueList[iCut]->Add(fHistoTrueSecondaryClusConvGammaFromXFromEtasPt[iCut]);
904
905
906 if (fDoClusterQA > 0){
907 fHistoTrueClusUnConvGammaPt[iCut] = new TH1F("TrueClusUnConvGamma_Pt","TrueClusUnConvGamma_Pt",250,0,25);
908 fTrueList[iCut]->Add(fHistoTrueClusUnConvGammaPt[iCut]);
909 fHistoTrueClusUnConvGammaMCPt[iCut] = new TH1F("TrueClusUnConvGamma_MCPt","TrueClusUnConvGamma_MCPt",250,0,25);
910 fTrueList[iCut]->Add(fHistoTrueClusUnConvGammaMCPt[iCut]);
911 fHistoTrueClusElectronPt[iCut] = new TH1F("TrueClusElectron_Pt","TrueElectronGamma_Pt",250,0,25);
912 fTrueList[iCut]->Add(fHistoTrueClusElectronPt[iCut]);
913 fHistoTrueClusConvGammaPt[iCut] = new TH1F("TrueClusConvGamma_Pt","TrueClusConvGamma_Pt",250,0,25);
914 fTrueList[iCut]->Add(fHistoTrueClusConvGammaPt[iCut]);
915 fHistoTrueClusConvGammaMCPt[iCut] = new TH1F("TrueClusConvGamma_MCPt","TrueClusConvGamma_MCPt",250,0,25);
916 fTrueList[iCut]->Add(fHistoTrueClusConvGammaMCPt[iCut]);
917 fHistoTrueClusConvGammaFullyPt[iCut] = new TH1F("TrueClusConvGammaFullyContained_Pt","TrueClusConvGammaFullyContained_Pt",250,0,25);
918 fTrueList[iCut]->Add(fHistoTrueClusConvGammaFullyPt[iCut]);
919 fHistoTrueClusMergedGammaPt[iCut] = new TH1F("TrueClusMergedGamma_Pt","TrueClusMergedGamma_Pt",250,0,25);
920 fTrueList[iCut]->Add(fHistoTrueClusMergedGammaPt[iCut]);
921 fHistoTrueClusMergedPartConvGammaPt[iCut] = new TH1F("TrueClusMergedPartConvGamma_Pt","TrueClusMergedPartConvGamma_Pt",250,0,25);
922 fTrueList[iCut]->Add(fHistoTrueClusMergedPartConvGammaPt[iCut]);
923 fHistoTrueClusDalitzPt[iCut] = new TH1F("TrueClusDalitz_Pt","TrueClusDalitz_Pt",250,0,25);
924 fTrueList[iCut]->Add(fHistoTrueClusDalitzPt[iCut]);
925 fHistoTrueClusDalitzMergedPt[iCut] = new TH1F("TrueClusDalitzMerged_Pt","TrueClusDalitzMerged_Pt",250,0,25);
926 fTrueList[iCut]->Add(fHistoTrueClusDalitzMergedPt[iCut]);
927 fHistoTrueClusPhotonFromElecMotherPt[iCut] = new TH1F("TrueClusPhotonFromElecMother_Pt","TrueClusPhotonFromElecMother_Pt",250,0,25);
928 fTrueList[iCut]->Add(fHistoTrueClusPhotonFromElecMotherPt[iCut]);
929 fHistoTrueClusShowerPt[iCut] = new TH1F("TrueClusShower_Pt","TrueClusShower_Pt",250,0,25);
930 fTrueList[iCut]->Add(fHistoTrueClusShowerPt[iCut]);
931 fHistoTrueClusSubLeadingPt[iCut] = new TH1F("TrueClusSubleading_Pt","TrueClusSubleading_Pt",250,0,25);
932 fTrueList[iCut]->Add(fHistoTrueClusSubLeadingPt[iCut]);
933 fHistoTrueClusNParticles[iCut] = new TH1I("TrueClusNParticles","TrueClusNParticles",20,0,20);
934 fTrueList[iCut]->Add(fHistoTrueClusNParticles[iCut]);
935 fHistoTrueClusEMNonLeadingPt[iCut] = new TH1F("TrueClusEMNonLeading_Pt","TrueClusEMNonLeading_Pt",250,0,25);
936 fTrueList[iCut]->Add(fHistoTrueClusEMNonLeadingPt[iCut]);
937 fHistoTrueNLabelsInClus[iCut] = new TH1F("TrueNLabelsInClus","TrueNLabelsInClus",100,-0.5,99.5);
938 fTrueList[iCut]->Add(fHistoTrueNLabelsInClus[iCut]);
939 }
940
941 if(fDoMesonAnalysis){
ed8bc1ca 942 fHistoTruePi0InvMassPt[iCut] = new TH2F("ESD_TruePi0_InvMass_Pt","ESD_TruePi0_InvMass_Pt",800,0,0.8,250,0,25);
943 fTrueList[iCut]->Add(fHistoTruePi0InvMassPt[iCut]);
944 fHistoTrueEtaInvMassPt[iCut] = new TH2F("ESD_TrueEta_InvMass_Pt","ESD_TrueEta_InvMass_Pt",800,0,0.8,250,0,25);
945 fTrueList[iCut]->Add(fHistoTrueEtaInvMassPt[iCut]);
946
947 fHistoTruePrimaryPi0InvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0_InvMass_Pt", "ESD_TruePrimaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
948 fHistoTruePrimaryPi0InvMassPt[iCut]->Sumw2();
949 fTrueList[iCut]->Add(fHistoTruePrimaryPi0InvMassPt[iCut]);
950 fHistoTruePrimaryEtaInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEta_InvMass_Pt", "ESD_TruePrimaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
951 fHistoTruePrimaryEtaInvMassPt[iCut]->Sumw2();
952 fTrueList[iCut]->Add(fHistoTruePrimaryEtaInvMassPt[iCut]);
953
954 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0W0Weights_InvMass_Pt", "ESD_TruePrimaryPi0W0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
955 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]->Sumw2();
956 fTrueList[iCut]->Add(fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]);
957 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEtaW0Weights_InvMass_Pt", "ESD_TruePrimaryEtaW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
958 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]->Sumw2();
959 fTrueList[iCut]->Add(fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]);
960
961 fProfileTruePrimaryPi0WeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryPi0Weights_InvMass_Pt", "ESD_TruePrimaryPi0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
962 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->Sumw2();
963 fTrueList[iCut]->Add(fProfileTruePrimaryPi0WeightsInvMassPt[iCut]);
964 fProfileTruePrimaryEtaWeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryEtaWeights_InvMass_Pt", "ESD_TruePrimaryEtaWeights_InvMass_Pt", 800,0,0.8,250,0,25);
965 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->Sumw2();
966 fTrueList[iCut]->Add(fProfileTruePrimaryEtaWeightsInvMassPt[iCut]);
967
968 fHistoTrueSecondaryPi0InvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0_InvMass_Pt", "ESD_TrueSecondaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
969 fHistoTrueSecondaryPi0InvMassPt[iCut]->Sumw2();
970 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0InvMassPt[iCut]);
ed8bc1ca 971
972 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromK0s_InvMass_Pt","ESD_TrueSecondaryPi0FromK0s_InvMass_Pt",800,0,0.8,250,0,25);
973 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->Sumw2();
974 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]);
975 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromEta_InvMass_Pt","ESD_TrueSecondaryPi0FromEta_InvMass_Pt",800,0,0.8,250,0,25);
976 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]);
977 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromLambda_InvMass_Pt","ESD_TrueSecondaryPi0FromLambda_InvMass_Pt",800,0,0.8,250,0,25);
978 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]);
d53bf4ac 979 if (fDoMesonQA > 0){
ed8bc1ca 980 fHistoTruePi0CaloPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloPhoton_InvMass_Pt","ESD_TruePi0CaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
981 fTrueList[iCut]->Add(fHistoTruePi0CaloPhotonInvMassPt[iCut]);
982 fHistoTrueEtaCaloPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloPhoton_InvMass_Pt","ESD_TrueEtaCaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
983 fTrueList[iCut]->Add(fHistoTrueEtaCaloPhotonInvMassPt[iCut]);
984
985 fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMixedPhotonConvertedPhoton_InvMass_Pt","ESD_TruePi0CaloMixedPhotonConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
986 fTrueList[iCut]->Add(fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt[iCut]);
987 fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMixedPhotonConvertedPhoton_InvMass_Pt","ESD_TrueEtaCaloMixedPhotonConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
988 fTrueList[iCut]->Add(fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt[iCut]);
d53bf4ac 989
990 fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhoton_InvMass_Pt","ESD_TruePi0CaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
991 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]);
d53bf4ac 992 fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt","ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
993 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]);
994
ed8bc1ca 995 fHistoTruePi0CaloElectronInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloElectron_InvMass_Pt","ESD_TruePi0CaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
996 fTrueList[iCut]->Add(fHistoTruePi0CaloElectronInvMassPt[iCut]);
997 fHistoTrueEtaCaloElectronInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloElectron_InvMass_Pt","ESD_TrueEtaCaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
998 fTrueList[iCut]->Add(fHistoTrueEtaCaloElectronInvMassPt[iCut]);
999
1000 fHistoTruePi0CaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedCluster_InvMass_Pt","ESD_TruePi0CaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1001 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterInvMassPt[iCut]);
1002 fHistoTrueEtaCaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedCluster_InvMass_Pt","ESD_TrueEtaCaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1003 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]);
1004
1005 fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt","ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1006 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]);
1007 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt","ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1008 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]);
1009
def90c8b 1010 fHistoTruePi0NonMergedElectronPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0NonMergedElectronPhoton_InvMass_Pt","ESD_TruePi0NonMergedElectronPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1011 fTrueList[iCut]->Add(fHistoTruePi0NonMergedElectronPhotonInvMassPt[iCut]);
1012 fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0NonMergedElectronMergedPhoton_InvMass_Pt","ESD_TruePi0NonMergedElectronMergedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1013 fTrueList[iCut]->Add(fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt[iCut]);
d53bf4ac 1014
1015 fHistoTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1016 fHistoTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
1017 SetLogBinningXTH2(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1018 fTrueList[iCut]->Add(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1019 fHistoTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1020 fHistoTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
1021 SetLogBinningXTH2(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1022 fTrueList[iCut]->Add(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1023 fHistoTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
1024 fTrueList[iCut]->Add(fHistoTrueBckGGInvMassPt[iCut]);
1025 fHistoTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
1026 fTrueList[iCut]->Add(fHistoTrueBckContInvMassPt[iCut]);
1027 fHistoTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
1028 fTrueList[iCut]->Add(fHistoTrueK0sWithPi0DaughterMCPt[iCut]);
1029 fHistoTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
1030 fTrueList[iCut]->Add(fHistoTrueEtaWithPi0DaughterMCPt[iCut]);
1031 fHistoTrueLambdaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueLambdaWithPi0Daughter_MCPt","ESD_TrueLambdaWithPi0Daughter_MCPt",250,0,25);
1032 fTrueList[iCut]->Add(fHistoTrueLambdaWithPi0DaughterMCPt[iCut]);
1033
1034 fHistoTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1035 SetLogBinningXTH2(fHistoTruePi0PtY[iCut]);
1036 fTrueList[iCut]->Add(fHistoTruePi0PtY[iCut]);
1037 fHistoTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1038 SetLogBinningXTH2(fHistoTrueEtaPtY[iCut]);
1039 fTrueList[iCut]->Add(fHistoTrueEtaPtY[iCut]);
1040 fHistoTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",150,0.03,15.,100,0,1);
1041 SetLogBinningXTH2(fHistoTruePi0PtAlpha[iCut]);
1042 fTrueList[iCut]->Add(fHistoTruePi0PtAlpha[iCut]);
1043 fHistoTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",150,0.03,15.,100,0,1);
1044 SetLogBinningXTH2(fHistoTrueEtaPtAlpha[iCut]);
1045 fTrueList[iCut]->Add(fHistoTrueEtaPtAlpha[iCut]);
1046
1047 fHistoTruePi0PtOpenAngle[iCut] = new TH2F("ESD_TruePi0_Pt_OpenAngle","ESD_TruePi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1048 SetLogBinningXTH2(fHistoTruePi0PtOpenAngle[iCut]);
1049 fTrueList[iCut]->Add(fHistoTruePi0PtOpenAngle[iCut]);
1050 fHistoTrueEtaPtOpenAngle[iCut] = new TH2F("ESD_TrueEta_Pt_OpenAngle","ESD_TrueEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1051 SetLogBinningXTH2(fHistoTrueEtaPtOpenAngle[iCut]);
1052 fTrueList[iCut]->Add(fHistoTrueEtaPtOpenAngle[iCut]);
1053 }
5cd70387 1054
1055 if (fDoMesonQA == 2){
1056 fHistoTruePi0Category1[iCut] = new TH2F("ESD_TruePi0Category1_InvMass_Pt","ESD_TruePi0Category1_InvMass_Pt",800,0,0.8,250,0,25);
1057 fTrueList[iCut]->Add(fHistoTruePi0Category1[iCut]);
1058 fHistoTrueEtaCategory1[iCut] = new TH2F("ESD_TrueEtaCategory1_InvMass_Pt","ESD_TrueEtaCategory1_InvMass_Pt",800,0,0.8,250,0,25);
1059 fTrueList[iCut]->Add(fHistoTrueEtaCategory1[iCut]);
1060 fHistoTruePi0Category2[iCut] = new TH2F("ESD_TruePi0Category2_InvMass_Pt","ESD_TruePi0Category2_InvMass_Pt",800,0,0.8,250,0,25);
1061 fTrueList[iCut]->Add(fHistoTruePi0Category2[iCut]);
1062 fHistoTrueEtaCategory2[iCut] = new TH2F("ESD_TrueEtaCategory2_InvMass_Pt","ESD_TrueEtaCategory2_InvMass_Pt",800,0,0.8,250,0,25);
1063 fTrueList[iCut]->Add(fHistoTrueEtaCategory2[iCut]);
1064 fHistoTruePi0Category3[iCut] = new TH2F("ESD_TruePi0Category3_InvMass_Pt","ESD_TruePi0Category3_InvMass_Pt",800,0,0.8,250,0,25);
1065 fTrueList[iCut]->Add(fHistoTruePi0Category3[iCut]);
1066 fHistoTrueEtaCategory3[iCut] = new TH2F("ESD_TrueEtaCategory3_InvMass_Pt","ESD_TrueEtaCategory3_InvMass_Pt",800,0,0.8,250,0,25);
1067 fTrueList[iCut]->Add(fHistoTrueEtaCategory3[iCut]);
1068 fHistoTruePi0Category4_6[iCut] = new TH2F("ESD_TruePi0Category4_6_InvMass_Pt","ESD_TruePi0Category4_6_InvMass_Pt",800,0,0.8,250,0,25);
1069 fTrueList[iCut]->Add(fHistoTruePi0Category4_6[iCut]);
1070 fHistoTrueEtaCategory4_6[iCut] = new TH2F("ESD_TrueEtaCategory4_6_InvMass_Pt","ESD_TrueEtaCategory4_6_InvMass_Pt",800,0,0.8,250,0,25);
1071 fTrueList[iCut]->Add(fHistoTrueEtaCategory4_6[iCut]);
1072 fHistoTruePi0Category5[iCut] = new TH2F("ESD_TruePi0Category5_InvMass_Pt","ESD_TruePi0Category5_InvMass_Pt",800,0,0.8,250,0,25);
1073 fTrueList[iCut]->Add(fHistoTruePi0Category5[iCut]);
1074 fHistoTrueEtaCategory5[iCut] = new TH2F("ESD_TrueEtaCategory5_InvMass_Pt","ESD_TrueEtaCategory5_InvMass_Pt",800,0,0.8,250,0,25);
1075 fTrueList[iCut]->Add(fHistoTrueEtaCategory5[iCut]);
1076 fHistoTruePi0Category7[iCut] = new TH2F("ESD_TruePi0Category7_InvMass_Pt","ESD_TruePi0Category7_InvMass_Pt",800,0,0.8,250,0,25);
1077 fTrueList[iCut]->Add(fHistoTruePi0Category7[iCut]);
1078 fHistoTrueEtaCategory7[iCut] = new TH2F("ESD_TrueEtaCategory7_InvMass_Pt","ESD_TrueEtaCategory7_InvMass_Pt",800,0,0.8,250,0,25);
1079 fTrueList[iCut]->Add(fHistoTrueEtaCategory7[iCut]);
1080 fHistoTruePi0Category8[iCut] = new TH2F("ESD_TruePi0Category8_InvMass_Pt","ESD_TruePi0Category8_InvMass_Pt",800,0,0.8,250,0,25);
1081 fTrueList[iCut]->Add(fHistoTruePi0Category8[iCut]);
1082 fHistoTrueEtaCategory8[iCut] = new TH2F("ESD_TrueEtaCategory8_InvMass_Pt","ESD_TrueEtaCategory8_InvMass_Pt",800,0,0.8,250,0,25);
1083 fTrueList[iCut]->Add(fHistoTrueEtaCategory8[iCut]);
1084 }
d53bf4ac 1085 }
1086 }
1087 }
1088
1089 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1090 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1091
1092 if(fV0Reader)
1093 if((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())
1094 if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1095 fOutputContainer->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1096 if(fV0Reader)
1097 if((AliConvEventCuts*)fV0Reader->GetEventCuts())
1098 if(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms())
1099 fOutputContainer->Add(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms());
1100
1101
1102 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1103 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))) continue;
1104 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms()){
1105 fCutFolder[iCut]->Add(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms());
1106 }
1107 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))) continue;
1108 if(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms()){
1109 fCutFolder[iCut]->Add(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms());
1110 }
1111 if(fDoMesonAnalysis){
1112 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
1113 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
1114 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
1115 }
1116 }
1117 }
1118 PostData(1, fOutputContainer);
1119}
1120//_____________________________________________________________________________
1121Bool_t AliAnalysisTaskGammaCalo::Notify()
1122{
1123 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1124 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))->GetDoEtaShift()){
1125 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1126 continue; // No Eta Shift requested, continue
1127 }
1128 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1129 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
1130 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1131 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1132 continue;
1133 }
1134 else{
1135 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
1136 (((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber()).Data(),((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift());
1137 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1138 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1139 }
1140 }
1141
1142 return kTRUE;
1143}
1144//_____________________________________________________________________________
1145void AliAnalysisTaskGammaCalo::UserExec(Option_t *)
1146{
1147 //
1148 // Called for each event
1149 //
1150 Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
1151 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1152 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1153 fHistoNEvents[iCut]->Fill(eventQuality);
1154 }
1155 return;
1156 }
1157
1158 if(fIsMC) fMCEvent = MCEvent();
1159 if(fMCEvent == NULL) fIsMC = kFALSE;
1160
1161 fInputEvent = InputEvent();
1162
1163 if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
1164 fMCStack = fMCEvent->Stack();
1165 if(fMCStack == NULL) fIsMC = kFALSE;
1166 }
1167
1168 // ------------------- BeginEvent ----------------------------
1169
1170 AliEventplane *EventPlane = fInputEvent->GetEventplane();
1171 if(fIsHeavyIon ==1)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
1172 else fEventPlaneAngle=0.0;
1173
1174 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1175
1176 fiCut = iCut;
7f070437 1177
1178 Bool_t isRunningEMCALrelAna = kFALSE;
1179 if (((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->GetClusterType() == 1) isRunningEMCALrelAna = kTRUE;
1180
1181 Int_t eventNotAccepted = ((AliConvEventCuts*)fEventCutArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon, isRunningEMCALrelAna);
d53bf4ac 1182
1183 if(eventNotAccepted){
1184 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1185 fHistoNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1186 continue;
1187 }
1188
1189 if(eventQuality != 0){// Event Not Accepted
1190 //cout << "event rejected due to: " <<eventQuality << endl;
1191 fHistoNEvents[iCut]->Fill(eventQuality);
1192 continue;
1193 }
1194
1195 fHistoNEvents[iCut]->Fill(eventQuality); // Should be 0 here
1196 fHistoNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
1197 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->IsHeavyIon() == 2) fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
1198 else fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1199
1200 if(fIsMC){
1201 // Process MC Particle
1202 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection() != 0){
1203 if(fInputEvent->IsA()==AliESDEvent::Class()){
1204 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1205 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1206 fMCEvent);
1207 }
1208 else if(fInputEvent->IsA()==AliAODEvent::Class()){
1209 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1210 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1211 fInputEvent);
1212 }
1213
1214 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader()){
1215 for(Int_t i = 0;i<(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
1216 TString nameBin= fHistoMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
1217 if (nameBin.CompareTo("")== 0){
1218 TString nameHeader = ((TObjString*)((TList*)((AliConvEventCuts*)fEventCutArray->At(iCut))
1219 ->GetAcceptedHeader())->At(i))->GetString();
1220 fHistoMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
1221 }
1222 }
1223 }
1224 }
1225 }
1226 if(fIsMC){
1227 if(fInputEvent->IsA()==AliESDEvent::Class())
1228 ProcessMCParticles();
1229 if(fInputEvent->IsA()==AliAODEvent::Class())
1230 ProcessAODMCParticles();
1231 }
1232
1233 // 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)
1234 ProcessClusters(); // process calo clusters
1235
1236 fHistoNGammaCandidates[iCut]->Fill(fClusterCandidates->GetEntries());
1237 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks(),fClusterCandidates->GetEntries());
1238 if(fDoMesonAnalysis){ // Meson Analysis
cfd87ccd 1239
d53bf4ac 1240 CalculatePi0Candidates(); // Combine Gammas from conversion and from calo
d53bf4ac 1241 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1242 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
cfd87ccd 1243
d53bf4ac 1244 CalculateBackground(); // Combinatorial Background
1245 UpdateEventByEventData(); // Store Event for mixed Events
1246 }
1247
1248 }
1249 }
1250
1251 fClusterCandidates->Clear(); // delete cluster candidates
1252 }
1253
1254 PostData(1, fOutputContainer);
1255}
1256
1257//________________________________________________________________________
1258void AliAnalysisTaskGammaCalo::ProcessClusters()
1259{
1260
1261 Int_t nclus = 0;
1262 nclus = fInputEvent->GetNumberOfCaloClusters();
1263
1264// cout << nclus << endl;
1265
1266 if(nclus == 0) return;
1267
1268 // vertex
1269 Double_t vertex[3] = {0};
1270 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1271
1272 // Loop over EMCal clusters
1273 for(Long_t i = 0; i < nclus; i++){
1274
1275 AliVCluster* clus = NULL;
1276 clus = fInputEvent->GetCaloCluster(i);
1277 if (!clus) continue;
1278 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelected(clus,fInputEvent,fIsMC)) continue;
1279 // TLorentzvector with cluster
1280 TLorentzVector clusterVector;
1281 clus->GetMomentum(clusterVector,vertex);
1282
1283 TLorentzVector* tmpvec = new TLorentzVector();
1284 tmpvec->SetPxPyPzE(clusterVector.Px(),clusterVector.Py(),clusterVector.Pz(),clusterVector.E());
1285
1286 // convert to AODConversionPhoton
1287 AliAODConversionPhoton *PhotonCandidate=new AliAODConversionPhoton(tmpvec);
1288 if(!PhotonCandidate) continue;
1289
1290 // Flag Photon as CaloPhoton
1291 PhotonCandidate->SetIsCaloPhoton();
1292 PhotonCandidate->SetCaloClusterRef(i);
1293 // get MC label
1294 if(fIsMC){
1295 Int_t* mclabelsCluster = clus->GetLabels();
1296 PhotonCandidate->SetNCaloPhotonMCLabels(clus->GetNLabels());
1297// cout << clus->GetNLabels() << endl;
1298 if (clus->GetNLabels()>0){
1299 for (Int_t k =0; k< (Int_t)clus->GetNLabels(); k++){
1300 if (k< 20)PhotonCandidate->SetCaloPhotonMCLabel(k,mclabelsCluster[k]);
1301// Int_t pdgCode = fMCStack->Particle(mclabelsCluster[k])->GetPdgCode();
1302// cout << "label " << k << "\t" << mclabelsCluster[k] << " pdg code: " << pdgCode << endl;
1303 }
1304 }
1305 }
1306
1307 fIsFromMBHeader = kTRUE;
ecd3e131 1308 fIsOverlappingWithOtherHeader = kFALSE;
d53bf4ac 1309 // test whether largest contribution to cluster orginates in added signals
1310 if (fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetCaloPhotonMCLabel(0), fMCStack, fInputEvent) == 0) fIsFromMBHeader = kFALSE;
ecd3e131 1311 if (fIsMC ){
1312 if (clus->GetNLabels()>1){
1313 Int_t* mclabelsCluster = clus->GetLabels();
1314 for (Int_t l = 1; l < (Int_t)clus->GetNLabels(); l++ ){
1315 if (((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(mclabelsCluster[l], fMCStack, fInputEvent) == 0) fIsOverlappingWithOtherHeader = kTRUE;
1316 }
1317 }
1318 }
d53bf4ac 1319
ecd3e131 1320 if (fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
1321 fHistoClusGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1322 fClusterCandidates->Add(PhotonCandidate);
1323 }
1324 if (fIsFromMBHeader && fIsOverlappingWithOtherHeader) fHistoClusOverlapHeadersGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1325 // if no second loop is required add to events good gammas
d53bf4ac 1326
1327 if(fIsMC){
1328 if(fInputEvent->IsA()==AliESDEvent::Class()){
1329 ProcessTrueClusterCandidates(PhotonCandidate);
1330 } else {
1331 ProcessTrueClusterCandidatesAOD(PhotonCandidate);
1332 }
1333 }
1334
1335 delete tmpvec;
1336 }
1337
1338}
1339
1340//________________________________________________________________________
1341void AliAnalysisTaskGammaCalo::ProcessTrueClusterCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1342{
1343
1344 TParticle *Photon = NULL;
1345 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
d404157c 1346 if (fDoClusterQA > 0) fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
d53bf4ac 1347
1348 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0)Photon = fMCStack->Particle(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1349 else return;
1350
1351 if(Photon == NULL){
1352 // cout << "no photon" << endl;
1353 return;
1354 }
1355
1356 Int_t pdgCodeParticle = Photon->GetPdgCode();
1357 TruePhotonCandidate->SetCaloPhotonMCFlags(fMCStack);
1358
1359 // True Photon
ecd3e131 1360 if(fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
d53bf4ac 1361 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1362 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1363 if (fDoClusterQA > 0){
1364 if (TruePhotonCandidate->IsLargestComponentPhoton()){
1365 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1366 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1367 }
1368 if (TruePhotonCandidate->IsLargestComponentElectron())
1369 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1370 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1371 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1372 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(Photon->GetMother(0)))->Pt());
1373 }
1374 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1375 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1376 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1377 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1378 if (TruePhotonCandidate->IsMergedPartConv())
1379 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1380 if (TruePhotonCandidate->IsDalitz())
1381 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1382 if (TruePhotonCandidate->IsDalitzMerged())
1383 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1384 if (TruePhotonCandidate->IsPhotonWithElecMother())
1385 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1386 if (TruePhotonCandidate->IsShower())
1387 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1388 if (TruePhotonCandidate->IsSubLeadingEM())
1389 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1390 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1391 if (!TruePhotonCandidate->IsLargestComponentPhoton())
1392 FillPhotonBackgroundHist(TruePhotonCandidate,pdgCodeParticle);
1393 if (!(TruePhotonCandidate->IsLargestComponentPhoton() || (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())) )
1394 FillPhotonPlusConversionBackgroundHist(TruePhotonCandidate,pdgCodeParticle);
1395 }
1396
1397 if(Photon->GetMother(0) <= fMCStack->GetNprimary()){
1398 if (TruePhotonCandidate->IsLargestComponentPhoton()){
1399 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1400 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1401 }
1402 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1403 fHistoTruePrimaryClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1404 fHistoTruePrimaryClusConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1405 }
1406
1407 } else {
1408 if (TruePhotonCandidate->IsLargestComponentPhoton())
1409 fHistoTrueSecondaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1410 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1411 fHistoTrueSecondaryClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1412 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1){
1413 if(fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
1414 if (TruePhotonCandidate->IsLargestComponentPhoton())
1415 fHistoTrueSecondaryClusGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1416 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1417 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1418 }
1419 if(fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
1420 if (TruePhotonCandidate->IsLargestComponentPhoton())
1421 fHistoTrueSecondaryClusGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1422 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1423 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1424 }
1425 if(fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
1426 if (TruePhotonCandidate->IsLargestComponentPhoton())
1427 fHistoTrueSecondaryClusGammaFromXFromEtasPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1428 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1429 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1430
1431 }
1432 }
1433 }
1434 }
1435 return;
1436}
1437
1438
1439//________________________________________________________________________
1440void AliAnalysisTaskGammaCalo::ProcessTrueClusterCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1441{
1442 AliAODMCParticle *Photon = NULL;
1443 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
d404157c 1444 if (fDoClusterQA > 0) fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
d53bf4ac 1445 if (AODMCTrackArray){
1446 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1447 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0) Photon = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1448 else return;
1449 } else {
1450 AliInfo("AODMCTrackArray could not be loaded");
1451 return;
1452 }
1453
1454 if(Photon == NULL){
1455 // cout << "no photon" << endl;
1456 return;
1457 }
1458 Int_t pdgCodeParticle = Photon->GetPdgCode();
1459 TruePhotonCandidate->SetCaloPhotonMCFlagsAOD(fInputEvent);
1460
1461 // True Photon
ecd3e131 1462 if(fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
d53bf4ac 1463 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1464 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1465 if (fDoClusterQA > 0){
1466 if (TruePhotonCandidate->IsLargestComponentPhoton()) {
1467 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1468 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1469 }
1470 if (TruePhotonCandidate->IsLargestComponentElectron())
1471 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1472 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()) {
1473 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1474 AliAODMCParticle *Mother = (AliAODMCParticle*) AODMCTrackArray->At(Photon->GetMother());
1475 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(Mother->Pt());
1476 }
1477 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1478 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1479 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1480 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1481 if (TruePhotonCandidate->IsMergedPartConv())
1482 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1483 if (TruePhotonCandidate->IsDalitz())
1484 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1485 if (TruePhotonCandidate->IsDalitzMerged())
1486 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1487 if (TruePhotonCandidate->IsPhotonWithElecMother())
1488 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1489 if (TruePhotonCandidate->IsShower())
1490 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1491 if (TruePhotonCandidate->IsSubLeadingEM())
1492 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1493 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1494
1495 if (!TruePhotonCandidate->IsLargestComponentPhoton())
1496 FillPhotonBackgroundHist(TruePhotonCandidate,pdgCodeParticle);
1497 if (!(TruePhotonCandidate->IsLargestComponentPhoton() || (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())) )
1498 FillPhotonPlusConversionBackgroundHist(TruePhotonCandidate,pdgCodeParticle);
1499 }
1500
1501 if(Photon->IsPrimary()){
1502 if (TruePhotonCandidate->IsLargestComponentPhoton()){
1503 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1504 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1505 }
1506 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1507 fHistoTruePrimaryClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1508 fHistoTruePrimaryClusConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1509 }
1510
1511 } else {
1512 if (TruePhotonCandidate->IsLargestComponentPhoton())
1513 fHistoTrueSecondaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1514 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1515 fHistoTrueSecondaryClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1516 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1){
1517 if(((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1518 if (TruePhotonCandidate->IsLargestComponentPhoton())
1519 fHistoTrueSecondaryClusGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1520 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1521 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1522 }
1523 if(((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1524 if (TruePhotonCandidate->IsLargestComponentPhoton())
1525 fHistoTrueSecondaryClusGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1526 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1527 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1528 }
1529 if(((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1530 if (TruePhotonCandidate->IsLargestComponentPhoton())
1531 fHistoTrueSecondaryClusGammaFromXFromEtasPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1532 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1533 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1534
1535 }
1536 }
1537 }
1538 }
1539}
1540
1541//________________________________________________________________________
1542void AliAnalysisTaskGammaCalo::ProcessAODMCParticles()
1543{
1544
1545 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1546
1547 // Loop over all primary MC particle
1548 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
1549
1550 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
1551 if (!particle) continue;
1552 if (!particle->IsPrimary()) continue;
1553
1554 Int_t isMCFromMBHeader = -1;
1555 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1556 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1557 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1558 }
1559
1560 if(((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedAODMC(particle,AODMCTrackArray)){
1561 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1562 if(particle->GetMother() >-1){ // Meson Decay Gamma
1563 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
1564 case 111: // Pi0
1565 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1566 break;
1567 case 113: // Rho0
1568 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1569 break;
1570 case 221: // Eta
1571 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1572 break;
1573 case 223: // Omega
1574 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1575 break;
1576 case 331: // Eta'
1577 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1578 break;
1579 case 333: // Phi
1580 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1581 break;
1582 case 3212: // Sigma
1583 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1584 break;
1585 }
1586 }
1587 }
de752898 1588 // Converted MC Gamma
d53bf4ac 1589 if(fDoMesonAnalysis){
1590 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1591 Double_t mesonY = 10.;
1592 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1593 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1594 } else {
1595 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1596 }
1597 Float_t weightedK0s= 1;
1598 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1599 if (particle->Pt()>0.005){
1600 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1601 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1602 }
1603 }
1604 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1605 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1606 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1607 }
1608 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1609 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
1610 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
1611 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
1612 Float_t weighted= 1;
1613 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1614 if (particle->Pt()>0.005){
1615 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
d53bf4ac 1616 }
1617 }
de752898 1618
d53bf4ac 1619 Double_t mesonY = 10.;
1620 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1621 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1622 } else{
1623 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1624 }
de752898 1625 Double_t alpha = -1;
1626 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
1627 alpha = TMath::Abs((daughter0->E() - daughter1->E()))/(daughter0->E() + daughter1->E());
1628 }
d53bf4ac 1629
1630 if(particle->GetPdgCode() == 111){
1631 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1632 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
de752898 1633 if (fDoMesonQA > 0){
1634 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1635 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha);
1636 }
d53bf4ac 1637 } else if(particle->GetPdgCode() == 221){
1638 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1639 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
de752898 1640 if (fDoMesonQA > 0){
1641 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1642 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha);
1643 }
d53bf4ac 1644 }
1645
1646 // Check the acceptance for both gammas
1647 if(((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedAODMC(daughter0,AODMCTrackArray) &&
1648 ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedAODMC(daughter1,AODMCTrackArray) ){
1649
1650 if(particle->GetPdgCode() == 111){
1651 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1652 } else if(particle->GetPdgCode() == 221){
1653 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1654 }
1655 }
1656 }
1657 }
1658 }
1659
1660}
1661//________________________________________________________________________
1662void AliAnalysisTaskGammaCalo::ProcessMCParticles()
1663{
1664 // Loop over all primary MC particle
1665 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
1666 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1667 if (!particle) continue;
1668
1669 Int_t isMCFromMBHeader = -1;
1670 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1671 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1672 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1673 }
1674
1675 if(((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedMC(particle,fMCStack)){
1676 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1677 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
1678 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
1679 case 111: // Pi0
1680 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1681 break;
1682 case 113: // Rho0
1683 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1684 break;
1685 case 221: // Eta
1686 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1687 break;
1688 case 223: // Omega
1689 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1690 break;
1691 case 331: // Eta'
1692 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1693 break;
1694 case 333: // Phi
1695 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1696 break;
1697 case 3212: // Sigma
1698 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1699 break;
1700 }
1701 }
1702 }
1703 if(fDoMesonAnalysis){
1704 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1705 Double_t mesonY = 10.;
1706 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1707 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1708 } else{
1709 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1710 }
1711 Float_t weightedK0s= 1;
1712 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1713 if (particle->Pt()>0.005){
1714 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1715 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1716 }
1717 }
1718 if (fMCStack->IsPhysicalPrimary(i)){
1719 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1720 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1721 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1722 }
1723 }
1724 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1725 ->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
1726 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
1727 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
1728
1729 Float_t weighted= 1;
1730 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1731 if (particle->Pt()>0.005){
1732 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1733 // if(particle->GetPdgCode() == 221){
1734 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1735 // }
1736 }
1737 }
1738 Double_t mesonY = 10.;
1739 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1740 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1741 } else{
1742 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1743 }
de752898 1744
1745 Double_t alpha = -1;
1746 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
1747 alpha = TMath::Abs((daughter0->Energy() - daughter1->Energy()))/(daughter0->Energy() + daughter1->Energy());
1748 }
1749
d53bf4ac 1750 if(particle->GetPdgCode() == 111){
1751 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1752 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
de752898 1753 if (fDoMesonQA > 0){
1754 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1755 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
1756 }
d53bf4ac 1757 } else if(particle->GetPdgCode() == 221){
1758 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1759 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
de752898 1760 if (fDoMesonQA > 0){
1761 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1762 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
1763 }
d53bf4ac 1764 }
1765
1766 // Check the acceptance for both gammas
1767 if(((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedMC(daughter0,fMCStack) &&
1768 ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedMC(daughter1,fMCStack) ){
1769 if(particle->GetPdgCode() == 111){
1770 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1771 } else if(particle->GetPdgCode() == 221){
1772 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1773 }
1774 }
1775 }
1776 }
1777 }
1778
1779 if (fDoMesonQA){
1780 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
1781 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1782 if (!particle) continue;
1783
1784 Int_t isMCFromMBHeader = -1;
1785 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1786 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1787 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1788 }
1789
1790 if(fDoMesonAnalysis){
1791 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
1792 Float_t weighted= 1;
1793 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1794 if (particle->Pt()>0.005){
1795 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1796 // if(particle->GetPdgCode() == 221){
1797 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1798 // }
1799 }
1800 }
1801
1802 if(particle->GetPdgCode() == 111){
1803 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
1804 Int_t source = GetSourceClassification(111,pdgCode);
1805 fHistoMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
1806 fHistoMCSecPi0Source[fiCut]->Fill(pdgCode);
1807 } else if(particle->GetPdgCode() == 221){
1808 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
1809 fHistoMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1810 fHistoMCSecEtaSource[fiCut]->Fill(pdgCode);
1811 }
1812 }
1813 }
1814 }
1815 }
1816}
1817
1818//________________________________________________________________________
1819void AliAnalysisTaskGammaCalo::CalculatePi0Candidates(){
1820
1821 // Conversion Gammas
1822 if(fClusterCandidates->GetEntries()>0){
1823
1824 // vertex
1825 Double_t vertex[3] = {0};
1826 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1827
1828 for(Int_t firstGammaIndex=0;firstGammaIndex<fClusterCandidates->GetEntries();firstGammaIndex++){
1829 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(firstGammaIndex));
1830 if (gamma0==NULL) continue;
1831
72cfe7c8 1832 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
d53bf4ac 1833 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
1834 if (gamma1==NULL) continue;
8c96b4f9 1835
d53bf4ac 1836 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
1837 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
cfd87ccd 1838
d53bf4ac 1839 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
1840 fHistoMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1841 // fill new histograms
1842 if(pi0cand->GetAlpha()<0.1)
1843 fHistoMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
1844
1845 if (fDoMesonQA > 0){
1846 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
1847 fHistoMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
1848 fHistoMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1849 fHistoMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
1850 }
1851 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
1852 fHistoMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
1853 fHistoMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1854 fHistoMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
1855 }
1856 }
1857 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
1858 Int_t zbin = 0;
1859 Int_t mbin = 0;
1860
1861 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
1862 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1863 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1864 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1865 } else {
1866 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fClusterCandidates->GetEntries());
1867 }
1868 }
1869 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1870 fSparseMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1871 }
1872
1873 if(fIsMC){
1874 if(fInputEvent->IsA()==AliESDEvent::Class())
1875 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1);
1876 if(fInputEvent->IsA()==AliAODEvent::Class())
1877 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1);
1878 }
1879
1880 if (fDoMesonQA == 1){
1881 fHistoMotherInvMassECalib[fiCut]->Fill(pi0cand->M(),gamma1->E());
1882 if(pi0cand->GetAlpha()<0.1)
1883 fHistoMotherInvMassECalibalpha[fiCut]->Fill(pi0cand->M(),gamma1->E());
1884 }
1885
1886 }
8c96b4f9 1887 for (Int_t thirdGammaIndex=0;thirdGammaIndex<fClusterCandidates->GetEntries();thirdGammaIndex++){
1888 if (firstGammaIndex == thirdGammaIndex || secondGammaIndex == thirdGammaIndex ) continue;
1889 AliAODConversionPhoton *gamma2=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(thirdGammaIndex));
1890 if (gamma2==NULL) continue;
1891
1892 AliAODConversionMother *pi0cand2 = new AliAODConversionMother(pi0cand,gamma2);
1893 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand2,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
1894 fHistoMotherInvMass3ClusterPt[fiCut]->Fill(pi0cand2->M(),pi0cand2->Pt());
1895 }
1896 delete pi0cand2;
1897 pi0cand2=0x0;
1898
1899 }
1900
d53bf4ac 1901 delete pi0cand;
1902 pi0cand=0x0;
1903 }
1904 }
1905 }
1906}
1907//______________________________________________________________________
1908void AliAnalysisTaskGammaCalo::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1909{
1910 // Process True Mesons
1911 AliStack *MCStack = fMCEvent->Stack();
1912
5cd70387 1913 Bool_t isTruePi0 = kFALSE;
1914 Bool_t isTrueEta = kFALSE;
1915 Bool_t isSameConvertedGamma = kFALSE;
1916 Int_t convertedPhotonLabel0 = -1;
1917 Int_t convertedPhotonLabel1 = -1;
1918
d53bf4ac 1919 Int_t gamma0MCLabel = TrueGammaCandidate0->GetCaloPhotonMCLabel(0); // get most probable MC label
1920 Int_t gamma0MotherLabel = -1;
1921
1922 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1923 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
1924 if (TrueGammaCandidate0->IsLargestComponentPhoton() || TrueGammaCandidate0->IsLargestComponentElectron()){ // largest component is electro magnetic
1925 // get mother of interest (pi0 or eta)
1926 if (TrueGammaCandidate0->IsLargestComponentPhoton()){ // for photons its the direct mother
1927 gamma0MotherLabel=gammaMC0->GetMother(0);
1928 } else if (TrueGammaCandidate0->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
5cd70387 1929 convertedPhotonLabel0 = gammaMC0->GetMother(0);
d53bf4ac 1930 if (TrueGammaCandidate0->IsConversion()) gamma0MotherLabel=MCStack->Particle(gammaMC0->GetMother(0))->GetMother(0);
1931 else gamma0MotherLabel=gammaMC0->GetMother(0);
1932 }
1933 }
1934 }
1935 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
1936
1937 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
1938 Int_t gamma1MotherLabel = -1;
1939 // check if
1940
1941 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1942 // Daughters Gamma 1
1943 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
1944 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
1945 // get mother of interest (pi0 or eta)
1946 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
1947 gamma1MotherLabel=gammaMC1->GetMother(0);
1948 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
5cd70387 1949 convertedPhotonLabel1 = gammaMC1->GetMother(0);
d53bf4ac 1950 if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=MCStack->Particle(gammaMC1->GetMother(0))->GetMother(0);
1951 else gamma1MotherLabel=gammaMC1->GetMother(0);
1952 }
1953 }
1954 }
1955
1956 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1957 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
1958 isTruePi0=kTRUE;
1959 }
1960 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
1961 isTrueEta=kTRUE;
1962 }
1963 }
1964
ea1bc51e 1965 if (convertedPhotonLabel0 > -1 && convertedPhotonLabel1 > -1){
5cd70387 1966 if (convertedPhotonLabel0==convertedPhotonLabel1) isSameConvertedGamma = kTRUE;
1967 }
1968
d53bf4ac 1969 if(isTruePi0 || isTrueEta){// True Pion or Eta
ed8bc1ca 1970 if (isTruePi0) fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1971 if (isTrueEta) fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
d53bf4ac 1972 if (fDoMesonQA > 0){
1973 // both gammas are real gammas
ed8bc1ca 1974 if (TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate1->IsLargestComponentPhoton()) {
1975 if (isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1976 if (isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1977 }
d53bf4ac 1978 // both particles are electrons
ed8bc1ca 1979 if (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate1->IsLargestComponentElectron() ) {
1980 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1981 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1982 }
d53bf4ac 1983 // both particles are converted electrons
1984 if ((TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion()) && (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()) ){
d53bf4ac 1985 if (isTruePi0 )fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1986 if (isTrueEta )fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1987 }
1988 // 1 gamma is converted the other one is normals
1989 if ( (TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()) ||
1990 (TrueGammaCandidate1->IsLargestComponentPhoton() && TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion())
ed8bc1ca 1991 ) {
1992 if (isTruePi0) fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1993 if (isTrueEta) fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1994 }
def90c8b 1995
1996 if ( (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion() && TrueGammaCandidate1->IsLargestComponentPhoton() && !TrueGammaCandidate1->IsMerged()) ||
1997 (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() && TrueGammaCandidate0->IsLargestComponentPhoton() && !TrueGammaCandidate0->IsMerged())
1998 ) {
1999 if (isTruePi0) fHistoTruePi0NonMergedElectronPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2000 }
2001
2002 if ( (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion() && TrueGammaCandidate1->IsLargestComponentPhoton() && TrueGammaCandidate1->IsMerged()) ||
2003 (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() && TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate0->IsMerged())
2004 ) {
2005 if (isTruePi0) fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2006 }
2007
d53bf4ac 2008 // at least one of the photon is merged
ed8bc1ca 2009 if (TrueGammaCandidate0->IsMerged() || TrueGammaCandidate0->IsMergedPartConv() || TrueGammaCandidate0->IsDalitzMerged() || TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged() ){
2010 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2011 if (isTrueEta) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2012 }
d53bf4ac 2013 // at least one of the photon is merged and part conv
ed8bc1ca 2014 if (TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate0->IsMergedPartConv()) {
2015 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2016 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2017 }
d53bf4ac 2018 }
2019
5cd70387 2020 if (fDoMesonQA == 2){
2021 // category 1: 2 real photons unmerged
2022 if (TrueGammaCandidate0->IsLargestComponentPhoton() && !TrueGammaCandidate0->IsMerged() && TrueGammaCandidate1->IsLargestComponentPhoton() && !TrueGammaCandidate1->IsMerged()) {
2023 if (isTruePi0) fHistoTruePi0Category1[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2024 if (isTrueEta) fHistoTrueEtaCategory1[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2025 }
2026 // category 2, 3: 1 real photons unmerged, 1 electron (category 2 merged, category 3 unmerged )
2027 // -> photon 0 is unconverted
2028 if ( (TrueGammaCandidate0->IsLargestComponentPhoton() && !TrueGammaCandidate0->IsMerged()) && (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion())) {
2029 if (isTruePi0){
ecd3e131 2030 if (TrueGammaCandidate1->IsMergedPartConv()) fHistoTruePi0Category2[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
ea1bc51e 2031 if (!TrueGammaCandidate1->IsMergedPartConv()){
2032 fHistoTruePi0Category3[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2033 }
5cd70387 2034 }
2035 if (isTrueEta){
ecd3e131 2036 if (TrueGammaCandidate1->IsMergedPartConv()) fHistoTrueEtaCategory2[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2037 if (!TrueGammaCandidate1->IsMergedPartConv()) fHistoTrueEtaCategory3[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
5cd70387 2038 }
2039 }
2040 // -> photon 1 is unconverted
2041 if ( ( TrueGammaCandidate1->IsLargestComponentPhoton() && !TrueGammaCandidate1->IsMerged()) && (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion())) {
2042 if (isTruePi0){
ecd3e131 2043 if (TrueGammaCandidate0->IsMergedPartConv()) fHistoTruePi0Category2[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
ea1bc51e 2044 if (!TrueGammaCandidate0->IsMergedPartConv()){
2045 fHistoTruePi0Category3[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2046 }
5cd70387 2047 }
2048 if (isTrueEta){
ecd3e131 2049 if (TrueGammaCandidate0->IsMergedPartConv()) fHistoTrueEtaCategory2[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2050 if (!TrueGammaCandidate0->IsMergedPartConv()) fHistoTrueEtaCategory3[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
5cd70387 2051 }
2052 }
2053
2054 // category 4 & 6, 5, 7, 8
2055 if ( (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion()) && (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()) ){
2056 if (isTruePi0){
2057 // category 4: both electrons are from same conversion
ecd3e131 2058 if (isSameConvertedGamma && !TrueGammaCandidate0->IsMergedPartConv() && !TrueGammaCandidate1->IsMergedPartConv() ) fHistoTruePi0Category4_6[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
5cd70387 2059 if (!isSameConvertedGamma ){
ecd3e131 2060 if (!TrueGammaCandidate0->IsMergedPartConv() && !TrueGammaCandidate1->IsMergedPartConv()){ // category 5: both electrons from different converted photons, electrons not merged
5cd70387 2061 fHistoTruePi0Category5[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
ecd3e131 2062 } else if (TrueGammaCandidate0->IsMergedPartConv() && TrueGammaCandidate1->IsMergedPartConv()){ // category 8: both electrons from different converted photons, both electrons merged
5cd70387 2063 fHistoTruePi0Category8[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2064 } else { // category 7: both electrons from different converted photons, 1 electrons not merged, 1 electron merged
2065 fHistoTruePi0Category7[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2066 }
2067 }
2068 }
2069 if (isTrueEta){
2070 // category 4: both electrons are from same conversion
ecd3e131 2071 if (isSameConvertedGamma && !TrueGammaCandidate0->IsMergedPartConv() && !TrueGammaCandidate1->IsMergedPartConv()) fHistoTrueEtaCategory4_6[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
5cd70387 2072 if (!isSameConvertedGamma ){
ecd3e131 2073 if (!TrueGammaCandidate0->IsMergedPartConv() && !TrueGammaCandidate1->IsMergedPartConv()){ // category 5: both electrons from different converted photons, electrons not merged
5cd70387 2074 fHistoTrueEtaCategory5[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
ecd3e131 2075 } else if (TrueGammaCandidate0->IsMergedPartConv() && TrueGammaCandidate1->IsMergedPartConv()){ // category 8: both electrons from different converted photons, both electrons merged
5cd70387 2076 fHistoTrueEtaCategory8[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2077 } else { // category 7: both electrons from different converted photons, 1 electrons not merged, 1 electron merged
2078 fHistoTrueEtaCategory7[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2079 }
2080 }
2081 }
2082 }
2083 }
2084
d53bf4ac 2085 if (fDoMesonQA > 0){
2086 if (isTruePi0){
2087 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2088 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2089 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2090 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2091 }
2092 } else if (isTrueEta){
2093 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2094 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2095 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2096 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2097 }
2098 }
2099 }
2100
2101 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
2102 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma0MotherLabel))->GetMother(0);
2103 Float_t weightedSec= 1;
2104 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
2105 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
2106 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2107 }
ed8bc1ca 2108 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2109 if (secMotherLabel >-1){
ed8bc1ca 2110 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310 && isTruePi0){
2111 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2112 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2113 }
ed8bc1ca 2114 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221 && isTruePi0){
2115 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2116 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2117 }
ed8bc1ca 2118 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==3122 && isTruePi0){
2119 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2120 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2121 }
2122 }
2123 } else { // Only primary pi0 for efficiency calculation
2124 Float_t weighted= 1;
2125 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
2126 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
2127 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
2128 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2129 }
2130 }
ed8bc1ca 2131 if (isTruePi0){
2132 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2133 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2134 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2135 } else if (isTrueEta){
2136 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2137 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2138 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2139 }
d53bf4ac 2140
2141 if (fDoMesonQA > 0){
2142 if(isTruePi0){ // Only primary pi0 for resolution
2143 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2144 }
2145 if (isTrueEta){ // Only primary eta for resolution
2146 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2147 }
2148 }
2149 }
2150 } else if(!isTruePi0 && !isTrueEta){ // Background
2151 if (fDoMesonQA > 0){
2152 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2153 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2154 } else { // No photon or without mother
2155 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2156 }
2157 }
2158 }
2159
2160}
2161//______________________________________________________________________
2162void AliAnalysisTaskGammaCalo::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
2163{
2164
2165 // Process True Mesons
2166 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
5cd70387 2167 Bool_t isTruePi0 = kFALSE;
2168 Bool_t isTrueEta = kFALSE;
2169 Bool_t isSameConvertedGamma = kFALSE;
2170 Int_t convertedPhotonLabel0 = -1;
2171 Int_t convertedPhotonLabel1 = -1;
d53bf4ac 2172
5cd70387 2173 Int_t gamma0MCLabel = TrueGammaCandidate0->GetCaloPhotonMCLabel(0); // get most probable MC label
2174 Int_t gamma0MotherLabel = -1;
2175
2176 // check if
d53bf4ac 2177 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2178 // Daughters Gamma 0
2179 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2180 if (TrueGammaCandidate0->IsLargestComponentPhoton() || TrueGammaCandidate0->IsLargestComponentElectron()){ // largest component is electro magnetic
2181 // get mother of interest (pi0 or eta)
2182 if (TrueGammaCandidate0->IsLargestComponentPhoton()){ // for photons its the direct mother
2183 gamma0MotherLabel=gammaMC0->GetMother();
2184 } else if (TrueGammaCandidate0->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2185 if (TrueGammaCandidate0->IsConversion()){
5cd70387 2186 convertedPhotonLabel0 = gammaMC0->GetMother();
d53bf4ac 2187 AliAODMCParticle * gammaGrandMotherMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC0->GetMother()));
2188 gamma0MotherLabel=gammaGrandMotherMC0->GetMother();
2189 } else gamma0MotherLabel=gammaMC0->GetMother();
2190 }
2191 }
2192 }
2193
5cd70387 2194 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2195 Int_t gamma1MotherLabel = -1;
2196
2197 // check if
d53bf4ac 2198 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2199 // Daughters Gamma 1
2200 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2201 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2202 // get mother of interest (pi0 or eta)
2203 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2204 gamma1MotherLabel=gammaMC1->GetMother();
2205 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2206 if (TrueGammaCandidate1->IsConversion()){
5cd70387 2207 convertedPhotonLabel1 = gammaMC1->GetMother();
d53bf4ac 2208 AliAODMCParticle * gammaGrandMotherMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC1->GetMother()));
2209 gamma1MotherLabel=gammaGrandMotherMC1->GetMother();
2210 } else gamma1MotherLabel=gammaMC1->GetMother();
2211 }
2212 }
2213 }
2214
2215 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2216 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2217 isTruePi0=kTRUE;
2218 }
2219 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2220 isTrueEta=kTRUE;
2221 }
2222 }
5cd70387 2223
2224 if (convertedPhotonLabel0 > -1 && convertedPhotonLabel1 > 1){
2225 if (convertedPhotonLabel0==convertedPhotonLabel1) isSameConvertedGamma = kTRUE;
2226 }
2227
d53bf4ac 2228
2229 if(isTruePi0 || isTrueEta){// True Pion or Eta
ed8bc1ca 2230 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2231 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
d53bf4ac 2232 if (fDoMesonQA > 0){
2233 // both gammas are real gammas
ed8bc1ca 2234 if (TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate1->IsLargestComponentPhoton()) {
2235 if (isTruePi0)fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2236 if (isTrueEta)fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2237 }
d53bf4ac 2238 // both particles are electrons
ed8bc1ca 2239 if (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate1->IsLargestComponentElectron() ) {
2240 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2241 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2242 }
d53bf4ac 2243 // both particles are converted electrons
2244 if ((TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion()) && (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()) ){
d53bf4ac 2245 if (isTruePi0 )fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2246 if (isTrueEta )fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2247 }
2248 // 1 gamma is converted the other one is normals
2249 if ( (TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()) ||
2250 (TrueGammaCandidate1->IsLargestComponentPhoton() && TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion())
ed8bc1ca 2251 ) {
2252 if (isTruePi0) fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2253 if (isTrueEta) fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2254 }
def90c8b 2255
2256 if ( (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion() && TrueGammaCandidate1->IsLargestComponentPhoton() && !TrueGammaCandidate1->IsMerged()) ||
2257 (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() && TrueGammaCandidate0->IsLargestComponentPhoton() && !TrueGammaCandidate0->IsMerged())
2258 ) {
2259 if (isTruePi0) fHistoTruePi0NonMergedElectronPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2260 }
2261
2262 if ( (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion() && TrueGammaCandidate1->IsLargestComponentPhoton() && TrueGammaCandidate1->IsMerged()) ||
2263 (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() && TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate0->IsMerged())
2264 ) {
2265 if (isTruePi0) fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2266 }
2267
d53bf4ac 2268 // at least one of the photon is merged
ed8bc1ca 2269 if (TrueGammaCandidate0->IsMerged() || TrueGammaCandidate0->IsMergedPartConv() || TrueGammaCandidate0->IsDalitzMerged() || TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged() ){
2270 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2271 if (isTrueEta) fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2272 }
d53bf4ac 2273 // at least one of the photon is merged and part conv
ed8bc1ca 2274 if (TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate0->IsMergedPartConv()) {
2275 if (isTruePi0)fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2276 if (isTrueEta)fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2277 }
d53bf4ac 2278 }
2279
5cd70387 2280 if (fDoMesonQA == 2){
2281 // category 1: 2 real photons unmerged
2282 if (TrueGammaCandidate0->IsLargestComponentPhoton() && !TrueGammaCandidate0->IsMerged() && TrueGammaCandidate1->IsLargestComponentPhoton() && !TrueGammaCandidate1->IsMerged()) {
2283 if (isTruePi0) fHistoTruePi0Category1[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2284 if (isTrueEta) fHistoTrueEtaCategory1[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2285 }
2286 // category 2, 3: 1 real photons unmerged, 1 electron (category 2 merged, category 3 unmerged )
2287 // -> photon 0 is unconverted
2288 if ( (TrueGammaCandidate0->IsLargestComponentPhoton() && !TrueGammaCandidate0->IsMerged()) && (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion())) {
2289 if (isTruePi0){
ecd3e131 2290 if (TrueGammaCandidate1->IsMergedPartConv()) fHistoTruePi0Category2[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2291 if (!TrueGammaCandidate1->IsMergedPartConv()) fHistoTruePi0Category3[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
5cd70387 2292 }
2293 if (isTrueEta){
ecd3e131 2294 if (TrueGammaCandidate1->IsMergedPartConv()) fHistoTrueEtaCategory2[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2295 if (!TrueGammaCandidate1->IsMergedPartConv()) fHistoTrueEtaCategory3[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
5cd70387 2296 }
2297 }
2298 // -> photon 1 is unconverted
2299 if ( ( TrueGammaCandidate1->IsLargestComponentPhoton() && !TrueGammaCandidate1->IsMerged()) && (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion())) {
2300 if (isTruePi0){
ecd3e131 2301 if (TrueGammaCandidate0->IsMergedPartConv()) fHistoTruePi0Category2[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2302 if (!TrueGammaCandidate0->IsMergedPartConv()) fHistoTruePi0Category3[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
5cd70387 2303 }
2304 if (isTrueEta){
ecd3e131 2305 if (TrueGammaCandidate0->IsMergedPartConv()) fHistoTrueEtaCategory2[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2306 if (!TrueGammaCandidate0->IsMergedPartConv()) fHistoTrueEtaCategory3[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
5cd70387 2307 }
2308 }
2309
2310 // category 4 & 6, 5, 7, 8
2311 if ( (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion()) && (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()) ){
2312 if (isTruePi0){
2313 // category 4: both electrons are from same conversion
ecd3e131 2314 if (isSameConvertedGamma && !TrueGammaCandidate0->IsMergedPartConv() && !TrueGammaCandidate1->IsMergedPartConv() ) fHistoTruePi0Category4_6[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
5cd70387 2315 if (!isSameConvertedGamma ){
ecd3e131 2316 if (!TrueGammaCandidate0->IsMergedPartConv() && !TrueGammaCandidate1->IsMerged()){ // category 5: both electrons from different converted photons, electrons not merged
5cd70387 2317 fHistoTruePi0Category5[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
ecd3e131 2318 } else if (TrueGammaCandidate0->IsMergedPartConv() && TrueGammaCandidate1->IsMerged()){ // category 8: both electrons from different converted photons, both electrons merged
5cd70387 2319 fHistoTruePi0Category8[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2320 } else { // category 7: both electrons from different converted photons, 1 electrons not merged, 1 electron merged
2321 fHistoTruePi0Category7[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2322 }
2323 }
2324 }
2325 if (isTrueEta){
2326 // category 4: both electrons are from same conversion
ecd3e131 2327 if (isSameConvertedGamma && !TrueGammaCandidate0->IsMergedPartConv() && !TrueGammaCandidate1->IsMergedPartConv()) fHistoTrueEtaCategory4_6[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
5cd70387 2328 if (!isSameConvertedGamma ){
ecd3e131 2329 if (!TrueGammaCandidate0->IsMergedPartConv() && !TrueGammaCandidate1->IsMergedPartConv()){ // category 5: both electrons from different converted photons, electrons not merged
5cd70387 2330 fHistoTrueEtaCategory5[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
ecd3e131 2331 } else if (TrueGammaCandidate0->IsMergedPartConv() && TrueGammaCandidate1->IsMergedPartConv()){ // category 8: both electrons from different converted photons, both electrons merged
5cd70387 2332 fHistoTrueEtaCategory8[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2333 } else { // category 7: both electrons from different converted photons, 1 electrons not merged, 1 electron merged
2334 fHistoTrueEtaCategory7[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2335 }
2336 }
2337 }
2338 }
2339 }
2340
d53bf4ac 2341 if (fDoMesonQA > 0){
2342 if (isTruePi0){
2343 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2344 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2345 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2346 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2347 }
2348 } else if (isTrueEta){
2349 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2350 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2351 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2352 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2353 }
2354 }
2355 }
2356 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2357 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2358 Float_t weightedSec= 1;
2359 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2360 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
2361 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2362 }
ed8bc1ca 2363 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2364 if (secMotherLabel >-1){
ed8bc1ca 2365 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310 && isTruePi0 ){
2366 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2367 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2368 }
ed8bc1ca 2369 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221 && isTruePi0){
2370 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2371 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2372 }
ed8bc1ca 2373 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122 && isTruePi0){
2374 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
d53bf4ac 2375 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2376 }
2377 }
2378 } else{ // Only primary pi0 for efficiency calculation
2379 Float_t weighted= 1;
2380 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2381 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2382 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2383 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2384 }
2385 }
ed8bc1ca 2386 if (isTruePi0){
2387 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2388 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2389 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2390 } else if (isTrueEta){
2391 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2392 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2393 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2394 }
d53bf4ac 2395 if (fDoMesonQA > 0){
2396 if(isTruePi0){ // Only primary pi0 for resolution
2397 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2398 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2399
2400 }
2401 if (isTrueEta){ // Only primary eta for resolution
2402 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2403 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2404 }
2405 }
2406 }
2407 } else if(!isTruePi0 && !isTrueEta) { // Background
2408 if (fDoMesonQA > 0){
2409 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2410 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2411 } else { // No photon or without mother
2412 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2413 }
2414 }
2415 }
2416}
2417
2418//________________________________________________________________________
2419void AliAnalysisTaskGammaCalo::CalculateBackground(){
2420
2421 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2422 Int_t mbin = 0;
2423
2424 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2425 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2426 } else {
2427 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fClusterCandidates->GetEntries());
2428 }
2429
2430 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2431 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2432 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
d53bf4ac 2433 for(Int_t iCurrent=0;iCurrent<fClusterCandidates->GetEntries();iCurrent++){
2434 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fClusterCandidates->At(iCurrent));
2435 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2436 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2437 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2438 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
cfd87ccd 2439
d53bf4ac 2440 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2441 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2442 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2443 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2444 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2445 }
2446 delete backgroundCandidate;
2447 backgroundCandidate = 0x0;
2448 }
2449 }
2450 }
2451 } else {
2452 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2453 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2454 if(previousEventV0s){
2455 for(Int_t iCurrent=0;iCurrent<fClusterCandidates->GetEntries();iCurrent++){
2456 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fClusterCandidates->At(iCurrent));
2457 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2458
2459 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2460 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2461 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
cfd87ccd 2462
d53bf4ac 2463 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2464 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2465 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2466 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2467 }
2468 delete backgroundCandidate;
2469 backgroundCandidate = 0x0;
2470 }
2471 }
2472 }
2473 }
2474 }
2475}
2476
2477//________________________________________________________________________
2478void AliAnalysisTaskGammaCalo::RotateParticle(AliAODConversionPhoton *gamma){
2479 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
2480 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
2481 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
2482 gamma->RotateZ(rotationValue);
2483}
2484
2485//________________________________________________________________________
2486void AliAnalysisTaskGammaCalo::UpdateEventByEventData(){
2487 //see header file for documentation
2488 if(fClusterCandidates->GetEntries() >0 ){
2489 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2490 fBGHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
2491 } else { // means we use #V0s for multiplicity
2492 fBGHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fClusterCandidates->GetEntries(),fEventPlaneAngle);
2493 }
2494 }
2495}
2496
2497
2498//________________________________________________________________________
2499void AliAnalysisTaskGammaCalo::FillPhotonBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode)
2500{
2501 // Bck = 0 e+-, 1 pi+-, 2 p+-, 3 K+-, 4 n, 5 K0s, 6 Lambda, 7 mu+-, 8 rest
2502 if(fIsFromMBHeader){
2503 if(abs(pdgCode) == 11) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);
2504 else if( abs(pdgCode)==211) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);
2505 else if( abs(pdgCode)==2212) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);
2506 else if( abs(pdgCode)==321) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);
2507 else if( abs(pdgCode)==2112) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);
2508 else if( abs(pdgCode)==310) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);
2509 else if( abs(pdgCode)==3122) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);
2510 else if( abs(pdgCode)==13) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);
2511 else fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);
2512 }
2513}
2514
2515//________________________________________________________________________
2516void AliAnalysisTaskGammaCalo::FillPhotonPlusConversionBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode)
2517{
2518 // Bck = 0 e+-, 1 pi+-, 2 p+-, 3 K+-, 4 n, 5 K0s, 6 Lambda, 7 mu+-, 8 rest
2519 if(fIsFromMBHeader){
2520 if(abs(pdgCode) == 11) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);
2521 else if( abs(pdgCode)==211) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);
2522 else if( abs(pdgCode)==2212) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);
2523 else if( abs(pdgCode)==321) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);
2524 else if( abs(pdgCode)==2112) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);
2525 else if( abs(pdgCode)==310) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);
2526 else if( abs(pdgCode)==3122) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);
2527 else if( abs(pdgCode)==13) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);
2528 else fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);
2529 }
2530}
2531
2532
2533void AliAnalysisTaskGammaCalo::SetLogBinningXTH2(TH2* histoRebin){
2534 TAxis *axisafter = histoRebin->GetXaxis();
2535 Int_t bins = axisafter->GetNbins();
2536 Double_t from = axisafter->GetXmin();
2537 Double_t to = axisafter->GetXmax();
2538 Double_t *newbins = new Double_t[bins+1];
2539 newbins[0] = from;
2540 Double_t factor = TMath::Power(to/from, 1./bins);
2541 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
2542 axisafter->Set(bins, newbins);
2543 delete [] newbins;
2544}
2545
2546//________________________________________________________________________
2547void AliAnalysisTaskGammaCalo::Terminate(const Option_t *)
2548{
2549
2550 //fOutputContainer->Print(); // Will crash on GRID
2551}
2552
2553//________________________________________________________________________
2554Int_t AliAnalysisTaskGammaCalo::GetSourceClassification(Int_t daughter, Int_t pdgCode){
2555
2556 if (daughter == 111) {
2557 if (abs(pdgCode) == 310) return 1; // k0s
2558 else if (abs(pdgCode) == 3122) return 2; // Lambda
2559 else if (abs(pdgCode) == 130) return 3; // K0L
2560 else if (abs(pdgCode) == 2212) return 4; // proton
2561 else if (abs(pdgCode) == 2112) return 5; // neutron
2562 else if (abs(pdgCode) == 211) return 6; // pion
2563 else if (abs(pdgCode) == 321) return 7; // kaon
2564 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
2565 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112 ) return 9; // Sigma
2566 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114 ) return 10; // Delta
2567 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323 ) return 11; // K*
2568 else return 15;
2569 }
2570 return 15;
2571
2572}