1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: Baldo Sahlmueller, Friederike Bock *
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 **************************************************************************/
17 //////////////////////////////////////////////////////////////////
18 //----------------------------------------------------------------
19 // Class used to do analysis on conversion photons + calo photons
20 //----------------------------------------------------------------
21 //////////////////////////////////////////////////////////////////
29 #include "THnSparse.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"
59 ClassImp(AliAnalysisTaskGammaCalo)
61 //________________________________________________________________________
62 AliAnalysisTaskGammaCalo::AliAnalysisTaskGammaCalo(): AliAnalysisTaskSE(),
74 fHeaderNameList(NULL),
75 fOutputContainer(NULL),
76 fClusterCandidates(NULL),
79 fClusterCutArray(NULL),
80 fCaloPhotonCuts(NULL),
83 fHistoMotherInvMassPt(NULL),
84 fHistoMotherInvMass3ClusterPt(NULL),
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),
98 fHistoMCHeaders(NULL),
99 fHistoMCAllGammaPt(NULL),
100 fHistoMCDecayGammaPi0Pt(NULL),
101 fHistoMCDecayGammaRhoPt(NULL),
102 fHistoMCDecayGammaEtaPt(NULL),
103 fHistoMCDecayGammaOmegaPt(NULL),
104 fHistoMCDecayGammaEtapPt(NULL),
105 fHistoMCDecayGammaPhiPt(NULL),
106 fHistoMCDecayGammaSigmaPt(NULL),
108 fHistoMCPi0WOWeightPt(NULL),
110 fHistoMCEtaWOWeightPt(NULL),
111 fHistoMCPi0InAccPt(NULL),
112 fHistoMCEtaInAccPt(NULL),
113 fHistoMCPi0PtY(NULL),
114 fHistoMCEtaPtY(NULL),
115 fHistoMCPi0PtAlpha(NULL),
116 fHistoMCEtaPtAlpha(NULL),
118 fHistoMCK0sWOWeightPt(NULL),
119 fHistoMCK0sPtY(NULL),
120 fHistoMCSecPi0PtvsSource(NULL),
121 fHistoMCSecPi0Source(NULL),
122 fHistoMCSecEtaPt(NULL),
123 fHistoMCSecEtaSource(NULL),
124 fHistoTruePi0InvMassPt(NULL),
125 fHistoTrueEtaInvMassPt(NULL),
126 fHistoTruePi0CaloPhotonInvMassPt(NULL),
127 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
128 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
129 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
130 fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt(NULL),
131 fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt(NULL),
132 fHistoTruePi0CaloElectronInvMassPt(NULL),
133 fHistoTrueEtaCaloElectronInvMassPt(NULL),
134 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
135 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
136 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
137 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
138 fHistoTruePi0NonMergedElectronPhotonInvMassPt(NULL),
139 fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt(NULL),
140 fHistoTruePrimaryPi0InvMassPt(NULL),
141 fHistoTruePrimaryEtaInvMassPt(NULL),
142 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
143 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
144 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
145 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
146 fHistoTruePrimaryPi0MCPtResolPt(NULL),
147 fHistoTruePrimaryEtaMCPtResolPt(NULL),
148 fHistoTrueSecondaryPi0InvMassPt(NULL),
149 fHistoTrueSecondaryEtaInvMassPt(NULL),
150 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
151 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
152 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
153 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
154 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
155 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
156 fHistoTrueBckGGInvMassPt(NULL),
157 fHistoTrueBckContInvMassPt(NULL),
158 fHistoTruePi0PtY(NULL),
159 fHistoTrueEtaPtY(NULL),
160 fHistoTruePi0PtAlpha(NULL),
161 fHistoTrueEtaPtAlpha(NULL),
162 fHistoTruePi0PtOpenAngle(NULL),
163 fHistoTrueEtaPtOpenAngle(NULL),
164 fHistoClusPhotonBGPt(NULL),
165 fHistoClusPhotonPlusConvBGPt(NULL),
166 fHistoTrueClusGammaPt(NULL),
167 fHistoTrueClusUnConvGammaPt(NULL),
168 fHistoTrueClusUnConvGammaMCPt(NULL),
169 fHistoTrueClusElectronPt(NULL),
170 fHistoTrueClusConvGammaPt(NULL),
171 fHistoTrueClusConvGammaMCPt(NULL),
172 fHistoTrueClusConvGammaFullyPt(NULL),
173 fHistoTrueClusMergedGammaPt(NULL),
174 fHistoTrueClusMergedPartConvGammaPt(NULL),
175 fHistoTrueClusDalitzPt(NULL),
176 fHistoTrueClusDalitzMergedPt(NULL),
177 fHistoTrueClusPhotonFromElecMotherPt(NULL),
178 fHistoTrueClusShowerPt(NULL),
179 fHistoTrueClusSubLeadingPt(NULL),
180 fHistoTrueClusNParticles(NULL),
181 fHistoTrueClusEMNonLeadingPt(NULL),
182 fHistoTrueNLabelsInClus(NULL),
183 fHistoTruePrimaryClusGammaPt(NULL),
184 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
185 fHistoTruePrimaryClusConvGammaPt(NULL),
186 fHistoTruePrimaryClusConvGammaESDPtMCPt(NULL),
187 fHistoTrueSecondaryClusGammaPt(NULL),
188 fHistoTrueSecondaryClusConvGammaPt(NULL),
189 fHistoTrueSecondaryClusGammaFromXFromK0sPt(NULL),
190 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt(NULL),
191 fHistoTrueSecondaryClusGammaFromXFromLambdaPt(NULL),
192 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt(NULL),
193 fHistoTrueSecondaryClusGammaFromXFromEtasPt(NULL),
194 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt(NULL),
196 fHistoNGoodESDTracks(NULL),
197 fHistoNGammaCandidates(NULL),
198 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
199 fHistoNV0Tracks(NULL),
200 fProfileEtaShift(NULL),
201 fEventPlaneAngle(-100),
206 fDoMesonAnalysis(kTRUE),
209 fIsFromMBHeader(kTRUE),
215 //________________________________________________________________________
216 AliAnalysisTaskGammaCalo::AliAnalysisTaskGammaCalo(const char *name):
217 AliAnalysisTaskSE(name),
229 fHeaderNameList(NULL),
231 fClusterCandidates(NULL),
232 fEventCutArray(NULL),
234 fClusterCutArray(NULL),
235 fCaloPhotonCuts(NULL),
236 fMesonCutArray(NULL),
238 fHistoMotherInvMassPt(NULL),
239 fHistoMotherInvMass3ClusterPt(NULL),
240 fSparseMotherInvMassPtZM(NULL),
241 fHistoMotherBackInvMassPt(NULL),
242 fSparseMotherBackInvMassPtZM(NULL),
243 fHistoMotherInvMassEalpha(NULL),
244 fHistoMotherPi0PtY(NULL),
245 fHistoMotherEtaPtY(NULL),
246 fHistoMotherPi0PtAlpha(NULL),
247 fHistoMotherEtaPtAlpha(NULL),
248 fHistoMotherPi0PtOpenAngle(NULL),
249 fHistoMotherEtaPtOpenAngle(NULL),
250 fHistoMotherInvMassECalib(NULL),
251 fHistoMotherInvMassECalibalpha(NULL),
252 fHistoClusGammaPt(NULL),
253 fHistoMCHeaders(NULL),
254 fHistoMCAllGammaPt(NULL),
255 fHistoMCDecayGammaPi0Pt(NULL),
256 fHistoMCDecayGammaRhoPt(NULL),
257 fHistoMCDecayGammaEtaPt(NULL),
258 fHistoMCDecayGammaOmegaPt(NULL),
259 fHistoMCDecayGammaEtapPt(NULL),
260 fHistoMCDecayGammaPhiPt(NULL),
261 fHistoMCDecayGammaSigmaPt(NULL),
263 fHistoMCPi0WOWeightPt(NULL),
265 fHistoMCEtaWOWeightPt(NULL),
266 fHistoMCPi0InAccPt(NULL),
267 fHistoMCEtaInAccPt(NULL),
268 fHistoMCPi0PtY(NULL),
269 fHistoMCEtaPtY(NULL),
270 fHistoMCPi0PtAlpha(NULL),
271 fHistoMCEtaPtAlpha(NULL),
273 fHistoMCK0sWOWeightPt(NULL),
274 fHistoMCK0sPtY(NULL),
275 fHistoMCSecPi0PtvsSource(NULL),
276 fHistoMCSecPi0Source(NULL),
277 fHistoMCSecEtaPt(NULL),
278 fHistoMCSecEtaSource(NULL),
279 fHistoTruePi0InvMassPt(NULL),
280 fHistoTrueEtaInvMassPt(NULL),
281 fHistoTruePi0CaloPhotonInvMassPt(NULL),
282 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
283 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
284 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
285 fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt(NULL),
286 fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt(NULL),
287 fHistoTruePi0CaloElectronInvMassPt(NULL),
288 fHistoTrueEtaCaloElectronInvMassPt(NULL),
289 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
290 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
291 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
292 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
293 fHistoTruePi0NonMergedElectronPhotonInvMassPt(NULL),
294 fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt(NULL),
295 fHistoTruePrimaryPi0InvMassPt(NULL),
296 fHistoTruePrimaryEtaInvMassPt(NULL),
297 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
298 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
299 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
300 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
301 fHistoTruePrimaryPi0MCPtResolPt(NULL),
302 fHistoTruePrimaryEtaMCPtResolPt(NULL),
303 fHistoTrueSecondaryPi0InvMassPt(NULL),
304 fHistoTrueSecondaryEtaInvMassPt(NULL),
305 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
306 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
307 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
308 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
309 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
310 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
311 fHistoTrueBckGGInvMassPt(NULL),
312 fHistoTrueBckContInvMassPt(NULL),
313 fHistoTruePi0PtY(NULL),
314 fHistoTrueEtaPtY(NULL),
315 fHistoTruePi0PtAlpha(NULL),
316 fHistoTrueEtaPtAlpha(NULL),
317 fHistoTruePi0PtOpenAngle(NULL),
318 fHistoTrueEtaPtOpenAngle(NULL),
319 fHistoClusPhotonBGPt(NULL),
320 fHistoClusPhotonPlusConvBGPt(NULL),
321 fHistoTrueClusGammaPt(NULL),
322 fHistoTrueClusUnConvGammaPt(NULL),
323 fHistoTrueClusUnConvGammaMCPt(NULL),
324 fHistoTrueClusElectronPt(NULL),
325 fHistoTrueClusConvGammaPt(NULL),
326 fHistoTrueClusConvGammaMCPt(NULL),
327 fHistoTrueClusConvGammaFullyPt(NULL),
328 fHistoTrueClusMergedGammaPt(NULL),
329 fHistoTrueClusMergedPartConvGammaPt(NULL),
330 fHistoTrueClusDalitzPt(NULL),
331 fHistoTrueClusDalitzMergedPt(NULL),
332 fHistoTrueClusPhotonFromElecMotherPt(NULL),
333 fHistoTrueClusShowerPt(NULL),
334 fHistoTrueClusSubLeadingPt(NULL),
335 fHistoTrueClusNParticles(NULL),
336 fHistoTrueClusEMNonLeadingPt(NULL),
337 fHistoTrueNLabelsInClus(NULL),
338 fHistoTruePrimaryClusGammaPt(NULL),
339 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
340 fHistoTruePrimaryClusConvGammaPt(NULL),
341 fHistoTruePrimaryClusConvGammaESDPtMCPt(NULL),
342 fHistoTrueSecondaryClusGammaPt(NULL),
343 fHistoTrueSecondaryClusConvGammaPt(NULL),
344 fHistoTrueSecondaryClusGammaFromXFromK0sPt(NULL),
345 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt(NULL),
346 fHistoTrueSecondaryClusGammaFromXFromLambdaPt(NULL),
347 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt(NULL),
348 fHistoTrueSecondaryClusGammaFromXFromEtasPt(NULL),
349 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt(NULL),
351 fHistoNGoodESDTracks(NULL),
352 fHistoNGammaCandidates(NULL),
353 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
354 fHistoNV0Tracks(NULL),
355 fProfileEtaShift(NULL),
356 fEventPlaneAngle(-100),
361 fDoMesonAnalysis(kTRUE),
364 fIsFromMBHeader(kTRUE),
367 // Define output slots here
368 DefineOutput(1, TList::Class());
371 AliAnalysisTaskGammaCalo::~AliAnalysisTaskGammaCalo()
373 if(fClusterCandidates){
374 delete fClusterCandidates;
375 fClusterCandidates = 0x0;
382 //___________________________________________________________
383 void AliAnalysisTaskGammaCalo::InitBack(){
385 const Int_t nDim = 4;
386 Int_t nBins[nDim] = {800,250,7,4};
387 Double_t xMin[nDim] = {0,0, 0,0};
388 Double_t xMax[nDim] = {0.8,25,7,4};
390 fSparseMotherInvMassPtZM = new THnSparseF*[fnCuts];
391 fSparseMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
393 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
396 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
397 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
398 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
399 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
400 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
402 Int_t collisionSystem = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(0,1));
403 Int_t centMin = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(1,1));
404 Int_t centMax = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(2,1));
406 if(collisionSystem == 1 || collisionSystem == 2 ||
407 collisionSystem == 5 || collisionSystem == 8 ||
408 collisionSystem == 9){
409 centMin = centMin*10;
410 centMax = centMax*10;
411 if(centMax ==0 && centMax!=centMin) centMax=100;
412 } else if(collisionSystem == 3 || collisionSystem == 6){
415 } else if(collisionSystem == 4 || collisionSystem == 7){
416 centMin = ((centMin*5)+45);
417 centMax = ((centMax*5)+45);
420 fBackList[iCut] = new TList();
421 fBackList[iCut]->SetName(Form("%s_%s_%s Back histograms",cutstringEvent.Data(),cutstringCalo.Data(), cutstringMeson.Data()));
422 fBackList[iCut]->SetOwner(kTRUE);
423 fCutFolder[iCut]->Add(fBackList[iCut]);
425 fSparseMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
426 fBackList[iCut]->Add(fSparseMotherBackInvMassPtZM[iCut]);
428 fMotherList[iCut] = new TList();
429 fMotherList[iCut]->SetName(Form("%s_%s_%s Mother histograms",cutstringEvent.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
430 fMotherList[iCut]->SetOwner(kTRUE);
431 fCutFolder[iCut]->Add(fMotherList[iCut]);
433 fSparseMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
434 fMotherList[iCut]->Add(fSparseMotherInvMassPtZM[iCut]);
436 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
437 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
438 collisionSystem,centMin,centMax,
439 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
440 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity());
445 //________________________________________________________________________
446 void AliAnalysisTaskGammaCalo::UserCreateOutputObjects(){
449 if(fOutputContainer != NULL){
450 delete fOutputContainer;
451 fOutputContainer = NULL;
453 if(fOutputContainer == NULL){
454 fOutputContainer = new TList();
455 fOutputContainer->SetOwner(kTRUE);
458 // Array of current cut's gammas
459 fClusterCandidates = new TList();
461 fCutFolder = new TList*[fnCuts];
462 fESDList = new TList*[fnCuts];
463 fBackList = new TList*[fnCuts];
464 fMotherList = new TList*[fnCuts];
465 fHistoNEvents = new TH1I*[fnCuts];
466 fHistoNGoodESDTracks = new TH1I*[fnCuts];
467 fHistoNGammaCandidates = new TH1I*[fnCuts];
468 fHistoNGoodESDTracksVsNGammaCanditates = new TH2F*[fnCuts];
469 fHistoNV0Tracks = new TH1I*[fnCuts];
470 fProfileEtaShift = new TProfile*[fnCuts];
472 if(fDoMesonAnalysis){
473 fHistoMotherInvMassPt = new TH2F*[fnCuts];
474 fHistoMotherInvMass3ClusterPt = new TH2F*[fnCuts];
475 fHistoMotherBackInvMassPt = new TH2F*[fnCuts];
476 fHistoMotherInvMassEalpha = new TH2F*[fnCuts];
478 fHistoMotherPi0PtY = new TH2F*[fnCuts];
479 fHistoMotherEtaPtY = new TH2F*[fnCuts];
480 fHistoMotherPi0PtAlpha = new TH2F*[fnCuts];
481 fHistoMotherEtaPtAlpha = new TH2F*[fnCuts];
482 fHistoMotherPi0PtOpenAngle = new TH2F*[fnCuts];
483 fHistoMotherEtaPtOpenAngle = new TH2F*[fnCuts];
486 fHistoMotherInvMassECalib = new TH2F*[fnCuts];
487 fHistoMotherInvMassECalibalpha = new TH2F*[fnCuts];
491 fHistoClusGammaPt = new TH1F*[fnCuts];
493 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
494 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
495 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
496 TString cutstringMeson = "NoMesonCut";
497 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
499 fCutFolder[iCut] = new TList();
500 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s",cutstringEvent.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
501 fCutFolder[iCut]->SetOwner(kTRUE);
502 fOutputContainer->Add(fCutFolder[iCut]);
503 fESDList[iCut] = new TList();
504 fESDList[iCut]->SetName(Form("%s_%s_%s ESD histograms",cutstringEvent.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
505 fESDList[iCut]->SetOwner(kTRUE);
506 fCutFolder[iCut]->Add(fESDList[iCut]);
508 fHistoNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
509 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
510 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
511 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
512 if (((AliConvEventCuts*)fEventCutArray->At(iCut))->IsSpecialTrigger() == 4 ){
513 TString TriggerNames = "Not Trigger: ";
514 TriggerNames = TriggerNames+ ( (AliConvEventCuts*)fEventCutArray->At(iCut))->GetSpecialTriggerName();
515 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
517 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
519 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
520 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
521 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
522 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
523 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
524 fESDList[iCut]->Add(fHistoNEvents[iCut]);
526 if(fIsHeavyIon == 1) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
527 else if(fIsHeavyIon == 2) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",400,0,400);
528 else fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
529 fESDList[iCut]->Add(fHistoNGoodESDTracks[iCut]);
530 if(fIsHeavyIon == 1) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",600,0,600);
531 else if(fIsHeavyIon == 2) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",400,0,400);
532 else fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
533 fESDList[iCut]->Add(fHistoNGammaCandidates[iCut]);
534 if(fIsHeavyIon == 1) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",4000,0,4000,600,0,600);
535 else if(fIsHeavyIon == 2) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",400,0,400,400,0,400);
536 else fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",200,0,200,100,0,100);
537 fESDList[iCut]->Add(fHistoNGoodESDTracksVsNGammaCanditates[iCut]);
540 if(fIsHeavyIon == 1) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
541 else if(fIsHeavyIon == 2) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
542 else fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
543 fESDList[iCut]->Add(fHistoNV0Tracks[iCut]);
544 fProfileEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
545 fESDList[iCut]->Add(fProfileEtaShift[iCut]);
547 fHistoClusGammaPt[iCut] = new TH1F("ClusGamma_Pt","ClusGamma_Pt",250,0,25);
548 fESDList[iCut]->Add(fHistoClusGammaPt[iCut]);
551 if(fDoMesonAnalysis){
552 fHistoMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
553 fESDList[iCut]->Add(fHistoMotherInvMassPt[iCut]);
554 fHistoMotherInvMass3ClusterPt[iCut] = new TH2F("ESD_Mother_InvMass3Cluster_Pt","ESD_Mother_InvMass3Cluster_Pt",800,0,0.8,250,0,25);
555 fESDList[iCut]->Add(fHistoMotherInvMass3ClusterPt[iCut]);
556 fHistoMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
557 fESDList[iCut]->Add(fHistoMotherBackInvMassPt[iCut]);
558 fHistoMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
559 fESDList[iCut]->Add(fHistoMotherInvMassEalpha[iCut]);
561 fHistoMotherInvMassECalib[iCut] = new TH2F("ESD_Mother_InvMass_Pt_Calib","ESD_Mother_InvMass_Pt_Calib",800,0,0.8,250,0,25);
562 fESDList[iCut]->Add(fHistoMotherInvMassECalib[iCut]);
563 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);
564 fESDList[iCut]->Add(fHistoMotherInvMassECalibalpha[iCut]);
567 if (fDoMesonQA > 0 ){
568 fHistoMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
569 SetLogBinningXTH2(fHistoMotherPi0PtY[iCut]);
570 fESDList[iCut]->Add(fHistoMotherPi0PtY[iCut]);
571 fHistoMotherEtaPtY[iCut] = new TH2F("ESD_MotherEta_Pt_Y","ESD_MotherEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
572 SetLogBinningXTH2(fHistoMotherEtaPtY[iCut]);
573 fESDList[iCut]->Add(fHistoMotherEtaPtY[iCut]);
574 fHistoMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",150,0.03,15.,100,0,1);
575 SetLogBinningXTH2(fHistoMotherPi0PtAlpha[iCut]);
576 fESDList[iCut]->Add(fHistoMotherPi0PtAlpha[iCut]);
577 fHistoMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",150,0.03,15.,100,0,1);
578 SetLogBinningXTH2(fHistoMotherEtaPtAlpha[iCut]);
579 fESDList[iCut]->Add(fHistoMotherEtaPtAlpha[iCut]);
580 fHistoMotherPi0PtOpenAngle[iCut] = new TH2F("ESD_MotherPi0_Pt_OpenAngle","ESD_MotherPi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
581 SetLogBinningXTH2(fHistoMotherPi0PtOpenAngle[iCut]);
582 fESDList[iCut]->Add(fHistoMotherPi0PtOpenAngle[iCut]);
583 fHistoMotherEtaPtOpenAngle[iCut] = new TH2F("ESD_MotherEta_Pt_OpenAngle","ESD_MotherEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
584 SetLogBinningXTH2(fHistoMotherEtaPtOpenAngle[iCut]);
585 fESDList[iCut]->Add(fHistoMotherEtaPtOpenAngle[iCut]);
589 if(fDoMesonAnalysis){
590 InitBack(); // Init Background Handler
595 fMCList = new TList*[fnCuts];
597 fTrueList = new TList*[fnCuts];
598 // Selected Header List
599 fHeaderNameList = new TList*[fnCuts];
600 fHistoMCHeaders = new TH1I*[fnCuts];
601 fHistoMCAllGammaPt = new TH1F*[fnCuts];
602 fHistoMCDecayGammaPi0Pt = new TH1F*[fnCuts];
603 fHistoMCDecayGammaRhoPt = new TH1F*[fnCuts];
604 fHistoMCDecayGammaEtaPt = new TH1F*[fnCuts];
605 fHistoMCDecayGammaOmegaPt = new TH1F*[fnCuts];
606 fHistoMCDecayGammaEtapPt = new TH1F*[fnCuts];
607 fHistoMCDecayGammaPhiPt = new TH1F*[fnCuts];
608 fHistoMCDecayGammaSigmaPt = new TH1F*[fnCuts];
610 fHistoClusPhotonBGPt = new TH2F*[fnCuts];
611 fHistoClusPhotonPlusConvBGPt = new TH2F*[fnCuts];
613 fHistoTrueClusGammaPt = new TH1F*[fnCuts];
614 fHistoTruePrimaryClusGammaPt = new TH1F*[fnCuts];
615 fHistoTruePrimaryClusGammaESDPtMCPt = new TH2F*[fnCuts];
616 fHistoTruePrimaryClusConvGammaPt = new TH1F*[fnCuts];
617 fHistoTruePrimaryClusConvGammaESDPtMCPt = new TH2F*[fnCuts];
618 fHistoTrueSecondaryClusGammaPt = new TH1F*[fnCuts];
619 fHistoTrueSecondaryClusConvGammaPt = new TH1F*[fnCuts];
620 fHistoTrueSecondaryClusGammaFromXFromK0sPt = new TH1F*[fnCuts];
621 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
622 fHistoTrueSecondaryClusGammaFromXFromLambdaPt = new TH1F*[fnCuts];
623 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
624 fHistoTrueSecondaryClusGammaFromXFromEtasPt = new TH1F*[fnCuts];
625 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt = new TH1F*[fnCuts];
627 if (fDoClusterQA > 0){
628 fHistoTrueClusUnConvGammaPt = new TH1F*[fnCuts];
629 fHistoTrueClusUnConvGammaMCPt = new TH1F*[fnCuts];
630 fHistoTrueClusElectronPt = new TH1F*[fnCuts];
631 fHistoTrueClusConvGammaPt = new TH1F*[fnCuts];
632 fHistoTrueClusConvGammaMCPt = new TH1F*[fnCuts];
633 fHistoTrueClusConvGammaFullyPt = new TH1F*[fnCuts];
634 fHistoTrueClusMergedGammaPt = new TH1F*[fnCuts];
635 fHistoTrueClusMergedPartConvGammaPt = new TH1F*[fnCuts];
636 fHistoTrueClusDalitzPt = new TH1F*[fnCuts];
637 fHistoTrueClusDalitzMergedPt = new TH1F*[fnCuts];
638 fHistoTrueClusPhotonFromElecMotherPt= new TH1F*[fnCuts];
639 fHistoTrueClusShowerPt = new TH1F*[fnCuts];
640 fHistoTrueClusSubLeadingPt = new TH1F*[fnCuts];
641 fHistoTrueClusNParticles = new TH1I*[fnCuts];
642 fHistoTrueClusEMNonLeadingPt = new TH1F*[fnCuts];
643 fHistoTrueNLabelsInClus = new TH1F*[fnCuts];
646 if(fDoMesonAnalysis){
647 fHistoMCPi0Pt = new TH1F*[fnCuts];
648 fHistoMCPi0WOWeightPt = new TH1F*[fnCuts];
649 fHistoMCEtaPt = new TH1F*[fnCuts];
650 fHistoMCEtaWOWeightPt = new TH1F*[fnCuts];
651 fHistoMCPi0InAccPt = new TH1F*[fnCuts];
652 fHistoMCEtaInAccPt = new TH1F*[fnCuts];
654 fHistoTruePi0InvMassPt = new TH2F*[fnCuts];
655 fHistoTrueEtaInvMassPt = new TH2F*[fnCuts];
656 fHistoTruePrimaryPi0InvMassPt = new TH2F*[fnCuts];
657 fHistoTruePrimaryEtaInvMassPt = new TH2F*[fnCuts];
658 fHistoTruePrimaryPi0W0WeightingInvMassPt = new TH2F*[fnCuts];
659 fHistoTruePrimaryEtaW0WeightingInvMassPt = new TH2F*[fnCuts];
660 fProfileTruePrimaryPi0WeightsInvMassPt = new TProfile2D*[fnCuts];
661 fProfileTruePrimaryEtaWeightsInvMassPt = new TProfile2D*[fnCuts];
662 fHistoTrueSecondaryPi0InvMassPt = new TH2F*[fnCuts];
663 fHistoTrueSecondaryEtaInvMassPt = new TH2F*[fnCuts];
664 fHistoTrueSecondaryPi0FromK0sInvMassPt = new TH2F*[fnCuts];
665 fHistoTrueSecondaryPi0FromEtaInvMassPt = new TH2F*[fnCuts];
666 fHistoTrueSecondaryPi0FromLambdaInvMassPt = new TH2F*[fnCuts];
668 fHistoMCPi0PtY = new TH2F*[fnCuts];
669 fHistoMCEtaPtY = new TH2F*[fnCuts];
670 fHistoMCPi0PtAlpha = new TH2F*[fnCuts];
671 fHistoMCEtaPtAlpha = new TH2F*[fnCuts];
672 fHistoMCK0sPt = new TH1F*[fnCuts];
673 fHistoMCK0sWOWeightPt = new TH1F*[fnCuts];
674 fHistoMCK0sPtY = new TH2F*[fnCuts];
675 fHistoMCSecPi0PtvsSource = new TH2F*[fnCuts];
676 fHistoMCSecPi0Source = new TH1F*[fnCuts];
677 fHistoMCSecEtaPt = new TH1F*[fnCuts];
678 fHistoMCSecEtaSource = new TH1F*[fnCuts];
679 fHistoTruePi0CaloPhotonInvMassPt = new TH2F*[fnCuts];
680 fHistoTrueEtaCaloPhotonInvMassPt = new TH2F*[fnCuts];
681 fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt= new TH2F*[fnCuts];
682 fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt= new TH2F*[fnCuts];
683 fHistoTruePi0CaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
684 fHistoTrueEtaCaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
685 fHistoTruePi0CaloElectronInvMassPt = new TH2F*[fnCuts];
686 fHistoTrueEtaCaloElectronInvMassPt = new TH2F*[fnCuts];
687 fHistoTruePi0CaloMergedClusterInvMassPt = new TH2F*[fnCuts];
688 fHistoTrueEtaCaloMergedClusterInvMassPt = new TH2F*[fnCuts];
689 fHistoTruePi0CaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
690 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
691 fHistoTruePi0NonMergedElectronPhotonInvMassPt = new TH2F*[fnCuts];
692 fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt = new TH2F*[fnCuts];
693 fHistoTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
694 fHistoTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
695 fHistoTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
696 fHistoTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
697 fHistoTrueLambdaWithPi0DaughterMCPt = new TH1F*[fnCuts];
698 fHistoTrueBckGGInvMassPt = new TH2F*[fnCuts];
699 fHistoTrueBckContInvMassPt = new TH2F*[fnCuts];
700 fHistoTruePi0PtY = new TH2F*[fnCuts];
701 fHistoTrueEtaPtY = new TH2F*[fnCuts];
702 fHistoTruePi0PtAlpha = new TH2F*[fnCuts];
703 fHistoTrueEtaPtAlpha = new TH2F*[fnCuts];
704 fHistoTruePi0PtOpenAngle = new TH2F*[fnCuts];
705 fHistoTrueEtaPtOpenAngle = new TH2F*[fnCuts];
711 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
712 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
713 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
714 TString cutstringMeson = "NoMesonCut";
715 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
717 fMCList[iCut] = new TList();
718 fMCList[iCut]->SetName(Form("%s_%s_%s MC histograms",cutstringEvent.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
719 fMCList[iCut]->SetOwner(kTRUE);
720 fCutFolder[iCut]->Add(fMCList[iCut]);
721 fHistoMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
722 fMCList[iCut]->Add(fHistoMCHeaders[iCut]);
723 fHistoMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
724 fMCList[iCut]->Add(fHistoMCAllGammaPt[iCut]);
725 fHistoMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
726 fMCList[iCut]->Add(fHistoMCDecayGammaPi0Pt[iCut]);
727 fHistoMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
728 fMCList[iCut]->Add(fHistoMCDecayGammaRhoPt[iCut]);
729 fHistoMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
730 fMCList[iCut]->Add(fHistoMCDecayGammaEtaPt[iCut]);
731 fHistoMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
732 fMCList[iCut]->Add(fHistoMCDecayGammaOmegaPt[iCut]);
733 fHistoMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
734 fMCList[iCut]->Add(fHistoMCDecayGammaEtapPt[iCut]);
735 fHistoMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
736 fMCList[iCut]->Add(fHistoMCDecayGammaPhiPt[iCut]);
737 fHistoMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
738 fMCList[iCut]->Add(fHistoMCDecayGammaSigmaPt[iCut]);
740 if(fDoMesonAnalysis){
741 fHistoMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
742 fHistoMCPi0Pt[iCut]->Sumw2();
743 fMCList[iCut]->Add(fHistoMCPi0Pt[iCut]);
744 fHistoMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
745 fHistoMCPi0WOWeightPt[iCut]->Sumw2();
746 fMCList[iCut]->Add(fHistoMCPi0WOWeightPt[iCut]);
748 fHistoMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
749 fHistoMCEtaPt[iCut]->Sumw2();
750 fMCList[iCut]->Add(fHistoMCEtaPt[iCut]);
751 fHistoMCEtaWOWeightPt[iCut] = new TH1F("MC_Eta_WOWeights_Pt","MC_Eta_WOWeights_Pt",250,0,25);
752 fHistoMCEtaWOWeightPt[iCut]->Sumw2();
753 fMCList[iCut]->Add(fHistoMCEtaWOWeightPt[iCut]);
754 fHistoMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
755 fHistoMCPi0InAccPt[iCut]->Sumw2();
756 fMCList[iCut]->Add(fHistoMCPi0InAccPt[iCut]);
757 fHistoMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
758 fHistoMCEtaInAccPt[iCut]->Sumw2();
759 fMCList[iCut]->Add(fHistoMCEtaInAccPt[iCut]);
761 fHistoMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
762 fHistoMCPi0PtY[iCut]->Sumw2();
763 SetLogBinningXTH2(fHistoMCPi0PtY[iCut]);
764 fMCList[iCut]->Add(fHistoMCPi0PtY[iCut]);
765 fHistoMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
766 fHistoMCEtaPtY[iCut]->Sumw2();
767 SetLogBinningXTH2(fHistoMCEtaPtY[iCut]);
768 fMCList[iCut]->Add(fHistoMCEtaPtY[iCut]);
769 fHistoMCPi0PtAlpha[iCut] = new TH2F("MC_Pi0_Pt_Alpha","MC_Pi0_Pt_Alpha",150,0.03,15.,100,0,1);
770 SetLogBinningXTH2(fHistoMCPi0PtAlpha[iCut]);
771 fMCList[iCut]->Add(fHistoMCPi0PtAlpha[iCut]);
772 fHistoMCEtaPtAlpha[iCut] = new TH2F("MC_Eta_Pt_Alpha","MC_Eta_Pt_Alpha",150,0.03,15.,100,0,1);
773 SetLogBinningXTH2(fHistoMCEtaPtAlpha[iCut]);
774 fMCList[iCut]->Add(fHistoMCEtaPtAlpha[iCut]);
776 fHistoMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",150,0,15);
777 fHistoMCK0sPt[iCut]->Sumw2();
778 fMCList[iCut]->Add(fHistoMCK0sPt[iCut]);
779 fHistoMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",150,0,15);
780 fHistoMCK0sWOWeightPt[iCut]->Sumw2();
781 fMCList[iCut]->Add(fHistoMCK0sWOWeightPt[iCut]);
782 fHistoMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",150,0.03,15.,150,-1.5,1.5);
783 fHistoMCK0sPtY[iCut]->Sumw2();
784 SetLogBinningXTH2(fHistoMCK0sPtY[iCut]);
785 fMCList[iCut]->Add(fHistoMCK0sPtY[iCut]);
787 fHistoMCSecPi0Source[iCut] = new TH1F("MC_SecPi0_Source","MC_SecPi0_Source",5000,0.,5000);
788 fMCList[iCut]->Add(fHistoMCSecPi0Source[iCut]);
789 fHistoMCSecEtaSource[iCut] = new TH1F("MC_SecEta_Source","MC_SecEta_Source",5000,0,5000);
790 fMCList[iCut]->Add(fHistoMCSecEtaSource[iCut]);
791 fHistoMCSecPi0PtvsSource[iCut] = new TH2F("MC_SecPi0_Pt_Source","MC_SecPi0_Pt_Source",250,0.0,25.,16,-0.5,15.5);
792 fHistoMCSecPi0PtvsSource[iCut]->Sumw2();
793 fMCList[iCut]->Add(fHistoMCSecPi0PtvsSource[iCut]);
794 fHistoMCSecEtaPt[iCut] = new TH1F("MC_SecEta_Pt","MC_SecEta_Pt",250,0,25);
795 fHistoMCSecEtaPt[iCut]->Sumw2();
796 fMCList[iCut]->Add(fHistoMCSecEtaPt[iCut]);
800 fTrueList[iCut] = new TList();
801 fTrueList[iCut]->SetName(Form("%s_%s_%s True histograms",cutstringEvent.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
802 fTrueList[iCut]->SetOwner(kTRUE);
803 fCutFolder[iCut]->Add(fTrueList[iCut]);
805 fHistoClusPhotonBGPt[iCut] = new TH2F("ESD_TrueClusPhotonBG_Pt","ESD_TrueClusPhotonBG_Pt",250,0,25,9,-0.5,8.5);
806 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec");
807 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 2,"Pion");
808 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 3,"Proton");
809 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 4,"Kaon");
810 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 5,"Neutron");
811 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 6,"K0s");
812 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 7,"Lambda");
813 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel( 8,"Muon");
814 fHistoClusPhotonBGPt[iCut]->GetYaxis()->SetBinLabel(9,"Rest");
815 fTrueList[iCut]->Add(fHistoClusPhotonBGPt[iCut]);
816 fHistoClusPhotonPlusConvBGPt[iCut] = new TH2F("ESD_TrueClusPhotonPlusConvBG_Pt","ESD_TrueClusPhotonPlusConvBG_Pt",250,0,25,9,-0.5,8.5);
817 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec");
818 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 2,"Pion");
819 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 3,"Proton");
820 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 4,"Kaon");
821 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 5,"Neutron");
822 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 6,"K0s");
823 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 7,"Lambda");
824 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel( 8,"Muon");
825 fHistoClusPhotonPlusConvBGPt[iCut]->GetYaxis()->SetBinLabel(9,"Rest");
826 fTrueList[iCut]->Add(fHistoClusPhotonPlusConvBGPt[iCut]);
828 fHistoTrueClusGammaPt[iCut] = new TH1F("TrueClusGamma_Pt","ESD_TrueClusGamma_Pt",250,0,25);
829 fTrueList[iCut]->Add(fHistoTrueClusGammaPt[iCut]);
830 fHistoTruePrimaryClusGammaPt[iCut] = new TH1F("TruePrimaryClusGamma_Pt","ESD_TruePrimaryClusGamma_Pt",250,0,25);
831 fTrueList[iCut]->Add(fHistoTruePrimaryClusGammaPt[iCut]);
832 fHistoTruePrimaryClusGammaESDPtMCPt[iCut] = new TH2F("TruePrimaryClusGamma_Pt_MCPt","ESD_TruePrimaryClusGamma_MCPt",250,0,25,250,0,25);
833 fTrueList[iCut]->Add(fHistoTruePrimaryClusGammaESDPtMCPt[iCut]);
834 fHistoTruePrimaryClusConvGammaPt[iCut] = new TH1F("TruePrimaryClusConvGamma_Pt","ESD_TruePrimaryClusConvGamma_Pt",250,0,25);
835 fTrueList[iCut]->Add(fHistoTruePrimaryClusConvGammaPt[iCut]);
836 fHistoTruePrimaryClusConvGammaESDPtMCPt[iCut] = new TH2F("TruePrimaryClusConvGamma_Pt_MCPt","ESD_TruePrimaryClusConvGamma_MCPt",250,0,25,250,0,25);
837 fTrueList[iCut]->Add(fHistoTruePrimaryClusConvGammaESDPtMCPt[iCut]);
838 fHistoTrueSecondaryClusGammaPt[iCut] = new TH1F("ESD_TrueSecondaryClusGamma_Pt","ESD_TrueSecondaryClusGamma_Pt",250,0,25);
839 fTrueList[iCut]->Add(fHistoTrueSecondaryClusGammaPt[iCut]);
840 fHistoTrueSecondaryClusConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryClusConvGamma_Pt","ESD_TrueSecondaryClusConvGamma_Pt",250,0,25);
841 fTrueList[iCut]->Add(fHistoTrueSecondaryClusConvGammaPt[iCut]);
843 fHistoTrueSecondaryClusGammaFromXFromK0sPt[iCut] = new TH1F("ESD_TrueSecondaryClusGammaFromXFromK0s_Pt", "ESD_TrueSecondaryClusGammaFromXFromK0s_Pt",250,0,25);
844 fTrueList[iCut]->Add(fHistoTrueSecondaryClusGammaFromXFromK0sPt[iCut]);
845 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt[iCut] = new TH1F("ESD_TrueSecondaryClusConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryClusConvGammaFromXFromK0s_Pt",250,0,25);
846 fTrueList[iCut]->Add(fHistoTrueSecondaryClusConvGammaFromXFromK0sPt[iCut]);
847 fHistoTrueSecondaryClusGammaFromXFromLambdaPt[iCut] = new TH1F("ESD_TrueSecondaryClusGammaFromXFromLambda_Pt", "ESD_TrueSecondaryClusGammaFromXFromLambda_Pt",250,0,25);
848 fTrueList[iCut]->Add(fHistoTrueSecondaryClusGammaFromXFromLambdaPt[iCut]);
849 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt[iCut] = new TH1F("ESD_TrueSecondaryClusConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryClusConvGammaFromXFromLambda_Pt",250,0,25);
850 fTrueList[iCut]->Add(fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt[iCut]);
851 fHistoTrueSecondaryClusGammaFromXFromEtasPt[iCut] = new TH1F("ESD_TrueSecondaryClusGammaFromXFromEtas_Pt", "ESD_TrueSecondaryClusGammaFromXFromEtas_Pt",250,0,25);
852 fTrueList[iCut]->Add(fHistoTrueSecondaryClusGammaFromXFromEtasPt[iCut]);
853 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt[iCut] = new TH1F("ESD_TrueSecondaryClusConvGammaFromXFromEtas_Pt", "ESD_TrueSecondaryClusConvGammaFromXFromEtas_Pt",250,0,25);
854 fTrueList[iCut]->Add(fHistoTrueSecondaryClusConvGammaFromXFromEtasPt[iCut]);
857 if (fDoClusterQA > 0){
858 fHistoTrueClusUnConvGammaPt[iCut] = new TH1F("TrueClusUnConvGamma_Pt","TrueClusUnConvGamma_Pt",250,0,25);
859 fTrueList[iCut]->Add(fHistoTrueClusUnConvGammaPt[iCut]);
860 fHistoTrueClusUnConvGammaMCPt[iCut] = new TH1F("TrueClusUnConvGamma_MCPt","TrueClusUnConvGamma_MCPt",250,0,25);
861 fTrueList[iCut]->Add(fHistoTrueClusUnConvGammaMCPt[iCut]);
862 fHistoTrueClusElectronPt[iCut] = new TH1F("TrueClusElectron_Pt","TrueElectronGamma_Pt",250,0,25);
863 fTrueList[iCut]->Add(fHistoTrueClusElectronPt[iCut]);
864 fHistoTrueClusConvGammaPt[iCut] = new TH1F("TrueClusConvGamma_Pt","TrueClusConvGamma_Pt",250,0,25);
865 fTrueList[iCut]->Add(fHistoTrueClusConvGammaPt[iCut]);
866 fHistoTrueClusConvGammaMCPt[iCut] = new TH1F("TrueClusConvGamma_MCPt","TrueClusConvGamma_MCPt",250,0,25);
867 fTrueList[iCut]->Add(fHistoTrueClusConvGammaMCPt[iCut]);
868 fHistoTrueClusConvGammaFullyPt[iCut] = new TH1F("TrueClusConvGammaFullyContained_Pt","TrueClusConvGammaFullyContained_Pt",250,0,25);
869 fTrueList[iCut]->Add(fHistoTrueClusConvGammaFullyPt[iCut]);
870 fHistoTrueClusMergedGammaPt[iCut] = new TH1F("TrueClusMergedGamma_Pt","TrueClusMergedGamma_Pt",250,0,25);
871 fTrueList[iCut]->Add(fHistoTrueClusMergedGammaPt[iCut]);
872 fHistoTrueClusMergedPartConvGammaPt[iCut] = new TH1F("TrueClusMergedPartConvGamma_Pt","TrueClusMergedPartConvGamma_Pt",250,0,25);
873 fTrueList[iCut]->Add(fHistoTrueClusMergedPartConvGammaPt[iCut]);
874 fHistoTrueClusDalitzPt[iCut] = new TH1F("TrueClusDalitz_Pt","TrueClusDalitz_Pt",250,0,25);
875 fTrueList[iCut]->Add(fHistoTrueClusDalitzPt[iCut]);
876 fHistoTrueClusDalitzMergedPt[iCut] = new TH1F("TrueClusDalitzMerged_Pt","TrueClusDalitzMerged_Pt",250,0,25);
877 fTrueList[iCut]->Add(fHistoTrueClusDalitzMergedPt[iCut]);
878 fHistoTrueClusPhotonFromElecMotherPt[iCut] = new TH1F("TrueClusPhotonFromElecMother_Pt","TrueClusPhotonFromElecMother_Pt",250,0,25);
879 fTrueList[iCut]->Add(fHistoTrueClusPhotonFromElecMotherPt[iCut]);
880 fHistoTrueClusShowerPt[iCut] = new TH1F("TrueClusShower_Pt","TrueClusShower_Pt",250,0,25);
881 fTrueList[iCut]->Add(fHistoTrueClusShowerPt[iCut]);
882 fHistoTrueClusSubLeadingPt[iCut] = new TH1F("TrueClusSubleading_Pt","TrueClusSubleading_Pt",250,0,25);
883 fTrueList[iCut]->Add(fHistoTrueClusSubLeadingPt[iCut]);
884 fHistoTrueClusNParticles[iCut] = new TH1I("TrueClusNParticles","TrueClusNParticles",20,0,20);
885 fTrueList[iCut]->Add(fHistoTrueClusNParticles[iCut]);
886 fHistoTrueClusEMNonLeadingPt[iCut] = new TH1F("TrueClusEMNonLeading_Pt","TrueClusEMNonLeading_Pt",250,0,25);
887 fTrueList[iCut]->Add(fHistoTrueClusEMNonLeadingPt[iCut]);
888 fHistoTrueNLabelsInClus[iCut] = new TH1F("TrueNLabelsInClus","TrueNLabelsInClus",100,-0.5,99.5);
889 fTrueList[iCut]->Add(fHistoTrueNLabelsInClus[iCut]);
892 if(fDoMesonAnalysis){
893 fHistoTruePi0InvMassPt[iCut] = new TH2F("ESD_TruePi0_InvMass_Pt","ESD_TruePi0_InvMass_Pt",800,0,0.8,250,0,25);
894 fTrueList[iCut]->Add(fHistoTruePi0InvMassPt[iCut]);
895 fHistoTrueEtaInvMassPt[iCut] = new TH2F("ESD_TrueEta_InvMass_Pt","ESD_TrueEta_InvMass_Pt",800,0,0.8,250,0,25);
896 fTrueList[iCut]->Add(fHistoTrueEtaInvMassPt[iCut]);
898 fHistoTruePrimaryPi0InvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0_InvMass_Pt", "ESD_TruePrimaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
899 fHistoTruePrimaryPi0InvMassPt[iCut]->Sumw2();
900 fTrueList[iCut]->Add(fHistoTruePrimaryPi0InvMassPt[iCut]);
901 fHistoTruePrimaryEtaInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEta_InvMass_Pt", "ESD_TruePrimaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
902 fHistoTruePrimaryEtaInvMassPt[iCut]->Sumw2();
903 fTrueList[iCut]->Add(fHistoTruePrimaryEtaInvMassPt[iCut]);
905 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0W0Weights_InvMass_Pt", "ESD_TruePrimaryPi0W0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
906 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]->Sumw2();
907 fTrueList[iCut]->Add(fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]);
908 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEtaW0Weights_InvMass_Pt", "ESD_TruePrimaryEtaW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
909 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]->Sumw2();
910 fTrueList[iCut]->Add(fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]);
912 fProfileTruePrimaryPi0WeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryPi0Weights_InvMass_Pt", "ESD_TruePrimaryPi0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
913 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->Sumw2();
914 fTrueList[iCut]->Add(fProfileTruePrimaryPi0WeightsInvMassPt[iCut]);
915 fProfileTruePrimaryEtaWeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryEtaWeights_InvMass_Pt", "ESD_TruePrimaryEtaWeights_InvMass_Pt", 800,0,0.8,250,0,25);
916 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->Sumw2();
917 fTrueList[iCut]->Add(fProfileTruePrimaryEtaWeightsInvMassPt[iCut]);
919 fHistoTrueSecondaryPi0InvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0_InvMass_Pt", "ESD_TrueSecondaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
920 fHistoTrueSecondaryPi0InvMassPt[iCut]->Sumw2();
921 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0InvMassPt[iCut]);
922 fHistoTrueSecondaryEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryEta_InvMass_Pt", "ESD_TrueSecondaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
923 fHistoTrueSecondaryEtaInvMassPt[iCut]->Sumw2();
924 fTrueList[iCut]->Add(fHistoTrueSecondaryEtaInvMassPt[iCut]);
926 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromK0s_InvMass_Pt","ESD_TrueSecondaryPi0FromK0s_InvMass_Pt",800,0,0.8,250,0,25);
927 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->Sumw2();
928 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]);
929 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromEta_InvMass_Pt","ESD_TrueSecondaryPi0FromEta_InvMass_Pt",800,0,0.8,250,0,25);
930 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]);
931 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromLambda_InvMass_Pt","ESD_TrueSecondaryPi0FromLambda_InvMass_Pt",800,0,0.8,250,0,25);
932 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]);
934 fHistoTruePi0CaloPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloPhoton_InvMass_Pt","ESD_TruePi0CaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
935 fTrueList[iCut]->Add(fHistoTruePi0CaloPhotonInvMassPt[iCut]);
936 fHistoTrueEtaCaloPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloPhoton_InvMass_Pt","ESD_TrueEtaCaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
937 fTrueList[iCut]->Add(fHistoTrueEtaCaloPhotonInvMassPt[iCut]);
939 fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMixedPhotonConvertedPhoton_InvMass_Pt","ESD_TruePi0CaloMixedPhotonConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
940 fTrueList[iCut]->Add(fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt[iCut]);
941 fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMixedPhotonConvertedPhoton_InvMass_Pt","ESD_TrueEtaCaloMixedPhotonConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
942 fTrueList[iCut]->Add(fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt[iCut]);
944 fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhoton_InvMass_Pt","ESD_TruePi0CaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
945 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]);
946 fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt","ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
947 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]);
949 fHistoTruePi0CaloElectronInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloElectron_InvMass_Pt","ESD_TruePi0CaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
950 fTrueList[iCut]->Add(fHistoTruePi0CaloElectronInvMassPt[iCut]);
951 fHistoTrueEtaCaloElectronInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloElectron_InvMass_Pt","ESD_TrueEtaCaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
952 fTrueList[iCut]->Add(fHistoTrueEtaCaloElectronInvMassPt[iCut]);
954 fHistoTruePi0CaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedCluster_InvMass_Pt","ESD_TruePi0CaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
955 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterInvMassPt[iCut]);
956 fHistoTrueEtaCaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedCluster_InvMass_Pt","ESD_TrueEtaCaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
957 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]);
959 fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt","ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
960 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]);
961 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt","ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
962 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]);
964 fHistoTruePi0NonMergedElectronPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0NonMergedElectronPhoton_InvMass_Pt","ESD_TruePi0NonMergedElectronPhoton_InvMass_Pt",800,0,0.8,250,0,25);
965 fTrueList[iCut]->Add(fHistoTruePi0NonMergedElectronPhotonInvMassPt[iCut]);
966 fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0NonMergedElectronMergedPhoton_InvMass_Pt","ESD_TruePi0NonMergedElectronMergedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
967 fTrueList[iCut]->Add(fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt[iCut]);
969 fHistoTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
970 fHistoTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
971 SetLogBinningXTH2(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
972 fTrueList[iCut]->Add(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
973 fHistoTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
974 fHistoTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
975 SetLogBinningXTH2(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
976 fTrueList[iCut]->Add(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
977 fHistoTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
978 fTrueList[iCut]->Add(fHistoTrueBckGGInvMassPt[iCut]);
979 fHistoTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
980 fTrueList[iCut]->Add(fHistoTrueBckContInvMassPt[iCut]);
981 fHistoTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
982 fTrueList[iCut]->Add(fHistoTrueK0sWithPi0DaughterMCPt[iCut]);
983 fHistoTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
984 fTrueList[iCut]->Add(fHistoTrueEtaWithPi0DaughterMCPt[iCut]);
985 fHistoTrueLambdaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueLambdaWithPi0Daughter_MCPt","ESD_TrueLambdaWithPi0Daughter_MCPt",250,0,25);
986 fTrueList[iCut]->Add(fHistoTrueLambdaWithPi0DaughterMCPt[iCut]);
988 fHistoTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
989 SetLogBinningXTH2(fHistoTruePi0PtY[iCut]);
990 fTrueList[iCut]->Add(fHistoTruePi0PtY[iCut]);
991 fHistoTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
992 SetLogBinningXTH2(fHistoTrueEtaPtY[iCut]);
993 fTrueList[iCut]->Add(fHistoTrueEtaPtY[iCut]);
994 fHistoTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",150,0.03,15.,100,0,1);
995 SetLogBinningXTH2(fHistoTruePi0PtAlpha[iCut]);
996 fTrueList[iCut]->Add(fHistoTruePi0PtAlpha[iCut]);
997 fHistoTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",150,0.03,15.,100,0,1);
998 SetLogBinningXTH2(fHistoTrueEtaPtAlpha[iCut]);
999 fTrueList[iCut]->Add(fHistoTrueEtaPtAlpha[iCut]);
1001 fHistoTruePi0PtOpenAngle[iCut] = new TH2F("ESD_TruePi0_Pt_OpenAngle","ESD_TruePi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1002 SetLogBinningXTH2(fHistoTruePi0PtOpenAngle[iCut]);
1003 fTrueList[iCut]->Add(fHistoTruePi0PtOpenAngle[iCut]);
1004 fHistoTrueEtaPtOpenAngle[iCut] = new TH2F("ESD_TrueEta_Pt_OpenAngle","ESD_TrueEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1005 SetLogBinningXTH2(fHistoTrueEtaPtOpenAngle[iCut]);
1006 fTrueList[iCut]->Add(fHistoTrueEtaPtOpenAngle[iCut]);
1012 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1013 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1016 if((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())
1017 if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1018 fOutputContainer->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1020 if((AliConvEventCuts*)fV0Reader->GetEventCuts())
1021 if(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms())
1022 fOutputContainer->Add(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms());
1025 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1026 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))) continue;
1027 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms()){
1028 fCutFolder[iCut]->Add(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms());
1030 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))) continue;
1031 if(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms()){
1032 fCutFolder[iCut]->Add(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms());
1034 if(fDoMesonAnalysis){
1035 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
1036 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
1037 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
1041 PostData(1, fOutputContainer);
1043 //_____________________________________________________________________________
1044 Bool_t AliAnalysisTaskGammaCalo::Notify()
1046 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1047 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))->GetDoEtaShift()){
1048 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1049 continue; // No Eta Shift requested, continue
1051 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1052 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
1053 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1054 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1058 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
1059 (((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber()).Data(),((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift());
1060 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1061 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1067 //_____________________________________________________________________________
1068 void AliAnalysisTaskGammaCalo::UserExec(Option_t *)
1071 // Called for each event
1073 Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
1074 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1075 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1076 fHistoNEvents[iCut]->Fill(eventQuality);
1081 if(fIsMC) fMCEvent = MCEvent();
1082 if(fMCEvent == NULL) fIsMC = kFALSE;
1084 fInputEvent = InputEvent();
1086 if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
1087 fMCStack = fMCEvent->Stack();
1088 if(fMCStack == NULL) fIsMC = kFALSE;
1091 // ------------------- BeginEvent ----------------------------
1093 AliEventplane *EventPlane = fInputEvent->GetEventplane();
1094 if(fIsHeavyIon ==1)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
1095 else fEventPlaneAngle=0.0;
1097 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1100 Int_t eventNotAccepted = ((AliConvEventCuts*)fEventCutArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
1102 if(eventNotAccepted){
1103 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1104 fHistoNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1108 if(eventQuality != 0){// Event Not Accepted
1109 //cout << "event rejected due to: " <<eventQuality << endl;
1110 fHistoNEvents[iCut]->Fill(eventQuality);
1114 fHistoNEvents[iCut]->Fill(eventQuality); // Should be 0 here
1115 fHistoNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
1116 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->IsHeavyIon() == 2) fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
1117 else fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1120 // Process MC Particle
1121 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection() != 0){
1122 if(fInputEvent->IsA()==AliESDEvent::Class()){
1123 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1124 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1127 else if(fInputEvent->IsA()==AliAODEvent::Class()){
1128 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1129 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1133 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader()){
1134 for(Int_t i = 0;i<(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
1135 TString nameBin= fHistoMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
1136 if (nameBin.CompareTo("")== 0){
1137 TString nameHeader = ((TObjString*)((TList*)((AliConvEventCuts*)fEventCutArray->At(iCut))
1138 ->GetAcceptedHeader())->At(i))->GetString();
1139 fHistoMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
1146 if(fInputEvent->IsA()==AliESDEvent::Class())
1147 ProcessMCParticles();
1148 if(fInputEvent->IsA()==AliAODEvent::Class())
1149 ProcessAODMCParticles();
1152 // 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)
1153 ProcessClusters(); // process calo clusters
1155 fHistoNGammaCandidates[iCut]->Fill(fClusterCandidates->GetEntries());
1156 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks(),fClusterCandidates->GetEntries());
1157 if(fDoMesonAnalysis){ // Meson Analysis
1159 CalculatePi0Candidates(); // Combine Gammas from conversion and from calo
1161 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1162 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1163 CalculateBackground(); // Combinatorial Background
1164 UpdateEventByEventData(); // Store Event for mixed Events
1170 fClusterCandidates->Clear(); // delete cluster candidates
1173 PostData(1, fOutputContainer);
1176 //________________________________________________________________________
1177 void AliAnalysisTaskGammaCalo::ProcessClusters()
1181 nclus = fInputEvent->GetNumberOfCaloClusters();
1183 // cout << nclus << endl;
1185 if(nclus == 0) return;
1188 Double_t vertex[3] = {0};
1189 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1191 // Loop over EMCal clusters
1192 for(Long_t i = 0; i < nclus; i++){
1194 AliVCluster* clus = NULL;
1195 clus = fInputEvent->GetCaloCluster(i);
1196 if (!clus) continue;
1197 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelected(clus,fInputEvent,fIsMC)) continue;
1198 // TLorentzvector with cluster
1199 TLorentzVector clusterVector;
1200 clus->GetMomentum(clusterVector,vertex);
1202 TLorentzVector* tmpvec = new TLorentzVector();
1203 tmpvec->SetPxPyPzE(clusterVector.Px(),clusterVector.Py(),clusterVector.Pz(),clusterVector.E());
1205 // convert to AODConversionPhoton
1206 AliAODConversionPhoton *PhotonCandidate=new AliAODConversionPhoton(tmpvec);
1207 if(!PhotonCandidate) continue;
1209 // Flag Photon as CaloPhoton
1210 PhotonCandidate->SetIsCaloPhoton();
1211 PhotonCandidate->SetCaloClusterRef(i);
1214 Int_t* mclabelsCluster = clus->GetLabels();
1215 PhotonCandidate->SetNCaloPhotonMCLabels(clus->GetNLabels());
1216 // cout << clus->GetNLabels() << endl;
1217 if (clus->GetNLabels()>0){
1218 for (Int_t k =0; k< (Int_t)clus->GetNLabels(); k++){
1219 if (k< 20)PhotonCandidate->SetCaloPhotonMCLabel(k,mclabelsCluster[k]);
1220 // Int_t pdgCode = fMCStack->Particle(mclabelsCluster[k])->GetPdgCode();
1221 // cout << "label " << k << "\t" << mclabelsCluster[k] << " pdg code: " << pdgCode << endl;
1226 fIsFromMBHeader = kTRUE;
1227 // test whether largest contribution to cluster orginates in added signals
1228 if (fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetCaloPhotonMCLabel(0), fMCStack, fInputEvent) == 0) fIsFromMBHeader = kFALSE;
1230 if (fIsFromMBHeader)fHistoClusGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1231 fClusterCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1234 if(fInputEvent->IsA()==AliESDEvent::Class()){
1235 ProcessTrueClusterCandidates(PhotonCandidate);
1237 ProcessTrueClusterCandidatesAOD(PhotonCandidate);
1246 //________________________________________________________________________
1247 void AliAnalysisTaskGammaCalo::ProcessTrueClusterCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1250 TParticle *Photon = NULL;
1251 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1252 if (fDoClusterQA > 0) fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1254 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0)Photon = fMCStack->Particle(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1258 // cout << "no photon" << endl;
1262 Int_t pdgCodeParticle = Photon->GetPdgCode();
1263 TruePhotonCandidate->SetCaloPhotonMCFlags(fMCStack);
1266 if(fIsFromMBHeader){
1267 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1268 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1269 if (fDoClusterQA > 0){
1270 if (TruePhotonCandidate->IsLargestComponentPhoton()){
1271 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1272 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1274 if (TruePhotonCandidate->IsLargestComponentElectron())
1275 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1276 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1277 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1278 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(Photon->GetMother(0)))->Pt());
1280 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1281 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1282 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1283 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1284 if (TruePhotonCandidate->IsMergedPartConv())
1285 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1286 if (TruePhotonCandidate->IsDalitz())
1287 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1288 if (TruePhotonCandidate->IsDalitzMerged())
1289 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1290 if (TruePhotonCandidate->IsPhotonWithElecMother())
1291 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1292 if (TruePhotonCandidate->IsShower())
1293 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1294 if (TruePhotonCandidate->IsSubLeadingEM())
1295 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1296 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1297 if (!TruePhotonCandidate->IsLargestComponentPhoton())
1298 FillPhotonBackgroundHist(TruePhotonCandidate,pdgCodeParticle);
1299 if (!(TruePhotonCandidate->IsLargestComponentPhoton() || (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())) )
1300 FillPhotonPlusConversionBackgroundHist(TruePhotonCandidate,pdgCodeParticle);
1303 if(Photon->GetMother(0) <= fMCStack->GetNprimary()){
1304 if (TruePhotonCandidate->IsLargestComponentPhoton()){
1305 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1306 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1308 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1309 fHistoTruePrimaryClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1310 fHistoTruePrimaryClusConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1314 if (TruePhotonCandidate->IsLargestComponentPhoton())
1315 fHistoTrueSecondaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1316 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1317 fHistoTrueSecondaryClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1318 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1){
1319 if(fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
1320 if (TruePhotonCandidate->IsLargestComponentPhoton())
1321 fHistoTrueSecondaryClusGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1322 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1323 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1325 if(fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
1326 if (TruePhotonCandidate->IsLargestComponentPhoton())
1327 fHistoTrueSecondaryClusGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1328 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1329 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1331 if(fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
1332 if (TruePhotonCandidate->IsLargestComponentPhoton())
1333 fHistoTrueSecondaryClusGammaFromXFromEtasPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1334 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1335 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1345 //________________________________________________________________________
1346 void AliAnalysisTaskGammaCalo::ProcessTrueClusterCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1348 AliAODMCParticle *Photon = NULL;
1349 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1350 if (fDoClusterQA > 0) fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1351 if (AODMCTrackArray){
1352 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1353 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0) Photon = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1356 AliInfo("AODMCTrackArray could not be loaded");
1361 // cout << "no photon" << endl;
1364 Int_t pdgCodeParticle = Photon->GetPdgCode();
1365 TruePhotonCandidate->SetCaloPhotonMCFlagsAOD(fInputEvent);
1368 if(fIsFromMBHeader){
1369 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1370 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1371 if (fDoClusterQA > 0){
1372 if (TruePhotonCandidate->IsLargestComponentPhoton()) {
1373 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1374 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1376 if (TruePhotonCandidate->IsLargestComponentElectron())
1377 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1378 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()) {
1379 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1380 AliAODMCParticle *Mother = (AliAODMCParticle*) AODMCTrackArray->At(Photon->GetMother());
1381 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(Mother->Pt());
1383 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1384 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1385 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1386 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1387 if (TruePhotonCandidate->IsMergedPartConv())
1388 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1389 if (TruePhotonCandidate->IsDalitz())
1390 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1391 if (TruePhotonCandidate->IsDalitzMerged())
1392 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1393 if (TruePhotonCandidate->IsPhotonWithElecMother())
1394 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1395 if (TruePhotonCandidate->IsShower())
1396 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1397 if (TruePhotonCandidate->IsSubLeadingEM())
1398 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1399 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1401 if (!TruePhotonCandidate->IsLargestComponentPhoton())
1402 FillPhotonBackgroundHist(TruePhotonCandidate,pdgCodeParticle);
1403 if (!(TruePhotonCandidate->IsLargestComponentPhoton() || (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())) )
1404 FillPhotonPlusConversionBackgroundHist(TruePhotonCandidate,pdgCodeParticle);
1407 if(Photon->IsPrimary()){
1408 if (TruePhotonCandidate->IsLargestComponentPhoton()){
1409 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1410 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1412 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1413 fHistoTruePrimaryClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1414 fHistoTruePrimaryClusConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1418 if (TruePhotonCandidate->IsLargestComponentPhoton())
1419 fHistoTrueSecondaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1420 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1421 fHistoTrueSecondaryClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1422 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1){
1423 if(((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1424 if (TruePhotonCandidate->IsLargestComponentPhoton())
1425 fHistoTrueSecondaryClusGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1426 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1427 fHistoTrueSecondaryClusConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1429 if(((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1430 if (TruePhotonCandidate->IsLargestComponentPhoton())
1431 fHistoTrueSecondaryClusGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1432 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1433 fHistoTrueSecondaryClusConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1435 if(((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1436 if (TruePhotonCandidate->IsLargestComponentPhoton())
1437 fHistoTrueSecondaryClusGammaFromXFromEtasPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1438 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion())
1439 fHistoTrueSecondaryClusConvGammaFromXFromEtasPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1447 //________________________________________________________________________
1448 void AliAnalysisTaskGammaCalo::ProcessAODMCParticles()
1451 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1453 // Loop over all primary MC particle
1454 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
1456 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
1457 if (!particle) continue;
1458 if (!particle->IsPrimary()) continue;
1460 Int_t isMCFromMBHeader = -1;
1461 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1462 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1463 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1466 if(((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedAODMC(particle,AODMCTrackArray)){
1467 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1468 if(particle->GetMother() >-1){ // Meson Decay Gamma
1469 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
1471 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1474 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1477 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1480 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1483 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1486 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1489 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1494 // Converted MC Gamma
1495 if(fDoMesonAnalysis){
1496 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1497 Double_t mesonY = 10.;
1498 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1499 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1501 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1503 Float_t weightedK0s= 1;
1504 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1505 if (particle->Pt()>0.005){
1506 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1507 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1510 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1511 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1512 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1514 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1515 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
1516 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
1517 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
1518 Float_t weighted= 1;
1519 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1520 if (particle->Pt()>0.005){
1521 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1525 Double_t mesonY = 10.;
1526 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1527 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1529 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1531 Double_t alpha = -1;
1532 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
1533 alpha = TMath::Abs((daughter0->E() - daughter1->E()))/(daughter0->E() + daughter1->E());
1536 if(particle->GetPdgCode() == 111){
1537 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1538 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1539 if (fDoMesonQA > 0){
1540 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1541 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha);
1543 } else if(particle->GetPdgCode() == 221){
1544 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1545 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
1546 if (fDoMesonQA > 0){
1547 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1548 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha);
1552 // Check the acceptance for both gammas
1553 if(((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedAODMC(daughter0,AODMCTrackArray) &&
1554 ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedAODMC(daughter1,AODMCTrackArray) ){
1556 if(particle->GetPdgCode() == 111){
1557 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1558 } else if(particle->GetPdgCode() == 221){
1559 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1567 //________________________________________________________________________
1568 void AliAnalysisTaskGammaCalo::ProcessMCParticles()
1570 // Loop over all primary MC particle
1571 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
1572 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1573 if (!particle) continue;
1575 Int_t isMCFromMBHeader = -1;
1576 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1577 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1578 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1581 if(((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedMC(particle,fMCStack)){
1582 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1583 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
1584 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
1586 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1589 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1592 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1595 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1598 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1601 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1604 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1609 if(fDoMesonAnalysis){
1610 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1611 Double_t mesonY = 10.;
1612 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1613 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1615 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1617 Float_t weightedK0s= 1;
1618 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1619 if (particle->Pt()>0.005){
1620 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1621 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1624 if (fMCStack->IsPhysicalPrimary(i)){
1625 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1626 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1627 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1630 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1631 ->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
1632 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
1633 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
1635 Float_t weighted= 1;
1636 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1637 if (particle->Pt()>0.005){
1638 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1639 // if(particle->GetPdgCode() == 221){
1640 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1644 Double_t mesonY = 10.;
1645 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1646 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1648 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
1651 Double_t alpha = -1;
1652 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
1653 alpha = TMath::Abs((daughter0->Energy() - daughter1->Energy()))/(daughter0->Energy() + daughter1->Energy());
1656 if(particle->GetPdgCode() == 111){
1657 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1658 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1659 if (fDoMesonQA > 0){
1660 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1661 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
1663 } else if(particle->GetPdgCode() == 221){
1664 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1665 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
1666 if (fDoMesonQA > 0){
1667 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1668 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
1672 // Check the acceptance for both gammas
1673 if(((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedMC(daughter0,fMCStack) &&
1674 ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelectedMC(daughter1,fMCStack) ){
1675 if(particle->GetPdgCode() == 111){
1676 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1677 } else if(particle->GetPdgCode() == 221){
1678 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1686 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
1687 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1688 if (!particle) continue;
1690 Int_t isMCFromMBHeader = -1;
1691 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1692 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1693 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1696 if(fDoMesonAnalysis){
1697 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
1698 Float_t weighted= 1;
1699 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1700 if (particle->Pt()>0.005){
1701 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1702 // if(particle->GetPdgCode() == 221){
1703 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1708 if(particle->GetPdgCode() == 111){
1709 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
1710 Int_t source = GetSourceClassification(111,pdgCode);
1711 fHistoMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
1712 fHistoMCSecPi0Source[fiCut]->Fill(pdgCode);
1713 } else if(particle->GetPdgCode() == 221){
1714 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
1715 fHistoMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1716 fHistoMCSecEtaSource[fiCut]->Fill(pdgCode);
1724 //________________________________________________________________________
1725 void AliAnalysisTaskGammaCalo::CalculatePi0Candidates(){
1727 // Conversion Gammas
1728 if(fClusterCandidates->GetEntries()>0){
1731 Double_t vertex[3] = {0};
1732 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1734 for(Int_t firstGammaIndex=0;firstGammaIndex<fClusterCandidates->GetEntries();firstGammaIndex++){
1735 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(firstGammaIndex));
1736 if (gamma0==NULL) continue;
1738 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
1739 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
1740 if (gamma1==NULL) continue;
1742 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
1743 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
1747 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
1748 fHistoMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1749 // fill new histograms
1750 if(pi0cand->GetAlpha()<0.1)
1751 fHistoMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
1753 if (fDoMesonQA > 0){
1754 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
1755 fHistoMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
1756 fHistoMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1757 fHistoMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
1759 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
1760 fHistoMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
1761 fHistoMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1762 fHistoMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
1765 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
1769 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
1770 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1771 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1772 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1774 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fClusterCandidates->GetEntries());
1777 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1778 fSparseMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1782 if(fInputEvent->IsA()==AliESDEvent::Class())
1783 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1);
1784 if(fInputEvent->IsA()==AliAODEvent::Class())
1785 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1);
1788 if (fDoMesonQA == 1){
1789 fHistoMotherInvMassECalib[fiCut]->Fill(pi0cand->M(),gamma1->E());
1790 if(pi0cand->GetAlpha()<0.1)
1791 fHistoMotherInvMassECalibalpha[fiCut]->Fill(pi0cand->M(),gamma1->E());
1795 for (Int_t thirdGammaIndex=0;thirdGammaIndex<fClusterCandidates->GetEntries();thirdGammaIndex++){
1796 if (firstGammaIndex == thirdGammaIndex || secondGammaIndex == thirdGammaIndex ) continue;
1797 AliAODConversionPhoton *gamma2=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(thirdGammaIndex));
1798 if (gamma2==NULL) continue;
1800 AliAODConversionMother *pi0cand2 = new AliAODConversionMother(pi0cand,gamma2);
1801 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand2,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
1802 fHistoMotherInvMass3ClusterPt[fiCut]->Fill(pi0cand2->M(),pi0cand2->Pt());
1815 //______________________________________________________________________
1816 void AliAnalysisTaskGammaCalo::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1818 // Process True Mesons
1819 AliStack *MCStack = fMCEvent->Stack();
1821 Bool_t isTruePi0 = kFALSE;
1822 Bool_t isTrueEta = kFALSE;
1823 Int_t gamma0MCLabel = TrueGammaCandidate0->GetCaloPhotonMCLabel(0); // get most probable MC label
1824 Int_t gamma0MotherLabel = -1;
1826 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1827 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
1828 if (TrueGammaCandidate0->IsLargestComponentPhoton() || TrueGammaCandidate0->IsLargestComponentElectron()){ // largest component is electro magnetic
1829 // get mother of interest (pi0 or eta)
1830 if (TrueGammaCandidate0->IsLargestComponentPhoton()){ // for photons its the direct mother
1831 gamma0MotherLabel=gammaMC0->GetMother(0);
1832 } else if (TrueGammaCandidate0->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
1833 if (TrueGammaCandidate0->IsConversion()) gamma0MotherLabel=MCStack->Particle(gammaMC0->GetMother(0))->GetMother(0);
1834 else gamma0MotherLabel=gammaMC0->GetMother(0);
1838 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
1840 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
1841 Int_t gamma1MotherLabel = -1;
1844 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1845 // Daughters Gamma 1
1846 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
1847 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
1848 // get mother of interest (pi0 or eta)
1849 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
1850 gamma1MotherLabel=gammaMC1->GetMother(0);
1851 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
1852 if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=MCStack->Particle(gammaMC1->GetMother(0))->GetMother(0);
1853 else gamma1MotherLabel=gammaMC1->GetMother(0);
1858 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1859 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
1862 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
1867 if(isTruePi0 || isTrueEta){// True Pion or Eta
1868 if (isTruePi0) fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1869 if (isTrueEta) fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1870 if (fDoMesonQA > 0){
1871 // both gammas are real gammas
1872 if (TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate1->IsLargestComponentPhoton()) {
1873 if (isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1874 if (isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1876 // both particles are electrons
1877 if (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate1->IsLargestComponentElectron() ) {
1878 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1879 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1881 // both particles are converted electrons
1882 if ((TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion()) && (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()) ){
1883 if (isTruePi0 )fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1884 if (isTrueEta )fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1886 // 1 gamma is converted the other one is normals
1887 if ( (TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()) ||
1888 (TrueGammaCandidate1->IsLargestComponentPhoton() && TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion())
1890 if (isTruePi0) fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1891 if (isTrueEta) fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1894 if ( (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion() && TrueGammaCandidate1->IsLargestComponentPhoton() && !TrueGammaCandidate1->IsMerged()) ||
1895 (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() && TrueGammaCandidate0->IsLargestComponentPhoton() && !TrueGammaCandidate0->IsMerged())
1897 if (isTruePi0) fHistoTruePi0NonMergedElectronPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1900 if ( (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion() && TrueGammaCandidate1->IsLargestComponentPhoton() && TrueGammaCandidate1->IsMerged()) ||
1901 (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() && TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate0->IsMerged())
1903 if (isTruePi0) fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1906 // at least one of the photon is merged
1907 if (TrueGammaCandidate0->IsMerged() || TrueGammaCandidate0->IsMergedPartConv() || TrueGammaCandidate0->IsDalitzMerged() || TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged() ){
1908 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1909 if (isTrueEta) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1911 // at least one of the photon is merged and part conv
1912 if (TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate0->IsMergedPartConv()) {
1913 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1914 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1918 if (fDoMesonQA > 0){
1920 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
1921 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
1922 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
1923 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
1925 } else if (isTrueEta){
1926 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
1927 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
1928 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
1929 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
1934 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
1935 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma0MotherLabel))->GetMother(0);
1936 Float_t weightedSec= 1;
1937 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1938 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
1939 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1941 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1942 if (isTrueEta) fHistoTrueSecondaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1943 if (secMotherLabel >-1){
1944 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310 && isTruePi0){
1945 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1946 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
1948 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221 && isTruePi0){
1949 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1950 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
1952 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==3122 && isTruePi0){
1953 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1954 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
1957 } else { // Only primary pi0 for efficiency calculation
1958 Float_t weighted= 1;
1959 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
1960 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
1961 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
1962 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
1966 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1967 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1968 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1969 } else if (isTrueEta){
1970 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1971 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1972 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1975 if (fDoMesonQA > 0){
1976 if(isTruePi0){ // Only primary pi0 for resolution
1977 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1979 if (isTrueEta){ // Only primary eta for resolution
1980 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1984 } else if(!isTruePi0 && !isTrueEta){ // Background
1985 if (fDoMesonQA > 0){
1986 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
1987 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1988 } else { // No photon or without mother
1989 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1995 //______________________________________________________________________
1996 void AliAnalysisTaskGammaCalo::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1999 // Process True Mesons
2000 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2001 Bool_t isTruePi0 = kFALSE;
2002 Bool_t isTrueEta = kFALSE;
2004 Int_t gamma0MCLabel = TrueGammaCandidate0->GetCaloPhotonMCLabel(0); // get most probable MC label
2005 Int_t gamma0MotherLabel = -1;
2008 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2009 // Daughters Gamma 0
2010 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2011 if (TrueGammaCandidate0->IsLargestComponentPhoton() || TrueGammaCandidate0->IsLargestComponentElectron()){ // largest component is electro magnetic
2012 // get mother of interest (pi0 or eta)
2013 if (TrueGammaCandidate0->IsLargestComponentPhoton()){ // for photons its the direct mother
2014 gamma0MotherLabel=gammaMC0->GetMother();
2015 } else if (TrueGammaCandidate0->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2016 if (TrueGammaCandidate0->IsConversion()){
2017 AliAODMCParticle * gammaGrandMotherMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC0->GetMother()));
2018 gamma0MotherLabel=gammaGrandMotherMC0->GetMother();
2019 } else gamma0MotherLabel=gammaMC0->GetMother();
2024 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2025 Int_t gamma1MotherLabel = -1;
2028 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2029 // Daughters Gamma 1
2030 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2031 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2032 // get mother of interest (pi0 or eta)
2033 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2034 gamma1MotherLabel=gammaMC1->GetMother();
2035 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2036 if (TrueGammaCandidate1->IsConversion()){
2037 AliAODMCParticle * gammaGrandMotherMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC1->GetMother()));
2038 gamma1MotherLabel=gammaGrandMotherMC1->GetMother();
2039 } else gamma1MotherLabel=gammaMC1->GetMother();
2044 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2045 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2048 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2053 if(isTruePi0 || isTrueEta){// True Pion or Eta
2054 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2055 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2056 if (fDoMesonQA > 0){
2057 // both gammas are real gammas
2058 if (TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate1->IsLargestComponentPhoton()) {
2059 if (isTruePi0)fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2060 if (isTrueEta)fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2062 // both particles are electrons
2063 if (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate1->IsLargestComponentElectron() ) {
2064 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2065 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2067 // both particles are converted electrons
2068 if ((TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion()) && (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()) ){
2069 if (isTruePi0 )fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2070 if (isTrueEta )fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2072 // 1 gamma is converted the other one is normals
2073 if ( (TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()) ||
2074 (TrueGammaCandidate1->IsLargestComponentPhoton() && TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion())
2076 if (isTruePi0) fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2077 if (isTrueEta) fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2080 if ( (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion() && TrueGammaCandidate1->IsLargestComponentPhoton() && !TrueGammaCandidate1->IsMerged()) ||
2081 (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() && TrueGammaCandidate0->IsLargestComponentPhoton() && !TrueGammaCandidate0->IsMerged())
2083 if (isTruePi0) fHistoTruePi0NonMergedElectronPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2086 if ( (TrueGammaCandidate0->IsLargestComponentElectron() && TrueGammaCandidate0->IsConversion() && TrueGammaCandidate1->IsLargestComponentPhoton() && TrueGammaCandidate1->IsMerged()) ||
2087 (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() && TrueGammaCandidate0->IsLargestComponentPhoton() && TrueGammaCandidate0->IsMerged())
2089 if (isTruePi0) fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2092 // at least one of the photon is merged
2093 if (TrueGammaCandidate0->IsMerged() || TrueGammaCandidate0->IsMergedPartConv() || TrueGammaCandidate0->IsDalitzMerged() || TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged() ){
2094 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2095 if (isTrueEta) fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2097 // at least one of the photon is merged and part conv
2098 if (TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate0->IsMergedPartConv()) {
2099 if (isTruePi0)fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2100 if (isTrueEta)fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2104 if (fDoMesonQA > 0){
2106 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2107 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2108 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2109 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2111 } else if (isTrueEta){
2112 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2113 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2114 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2115 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2119 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2120 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2121 Float_t weightedSec= 1;
2122 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2123 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
2124 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2126 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2127 if (isTrueEta) fHistoTrueSecondaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2128 if (secMotherLabel >-1){
2129 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310 && isTruePi0 ){
2130 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2131 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2133 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221 && isTruePi0){
2134 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2135 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2137 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122 && isTruePi0){
2138 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2139 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2142 } else{ // Only primary pi0 for efficiency calculation
2143 Float_t weighted= 1;
2144 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2145 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2146 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2147 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2151 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2152 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2153 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2154 } else if (isTrueEta){
2155 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2156 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2157 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2159 if (fDoMesonQA > 0){
2160 if(isTruePi0){ // Only primary pi0 for resolution
2161 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2162 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2165 if (isTrueEta){ // Only primary eta for resolution
2166 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2167 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2171 } else if(!isTruePi0 && !isTrueEta) { // Background
2172 if (fDoMesonQA > 0){
2173 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2174 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2175 } else { // No photon or without mother
2176 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2182 //________________________________________________________________________
2183 void AliAnalysisTaskGammaCalo::CalculateBackground(){
2185 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2188 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2189 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2191 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fClusterCandidates->GetEntries());
2194 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2195 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2196 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2198 for(Int_t iCurrent=0;iCurrent<fClusterCandidates->GetEntries();iCurrent++){
2199 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fClusterCandidates->At(iCurrent));
2200 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2201 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2202 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2203 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2204 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2205 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2206 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2207 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2208 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2210 delete backgroundCandidate;
2211 backgroundCandidate = 0x0;
2216 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2217 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2218 if(previousEventV0s){
2219 for(Int_t iCurrent=0;iCurrent<fClusterCandidates->GetEntries();iCurrent++){
2220 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fClusterCandidates->At(iCurrent));
2221 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2223 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2224 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2225 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2226 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2227 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2228 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2229 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2231 delete backgroundCandidate;
2232 backgroundCandidate = 0x0;
2240 //________________________________________________________________________
2241 void AliAnalysisTaskGammaCalo::RotateParticle(AliAODConversionPhoton *gamma){
2242 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
2243 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
2244 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
2245 gamma->RotateZ(rotationValue);
2248 //________________________________________________________________________
2249 void AliAnalysisTaskGammaCalo::UpdateEventByEventData(){
2250 //see header file for documentation
2251 if(fClusterCandidates->GetEntries() >0 ){
2252 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2253 fBGHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
2254 } else { // means we use #V0s for multiplicity
2255 fBGHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fClusterCandidates->GetEntries(),fEventPlaneAngle);
2261 //________________________________________________________________________
2262 void AliAnalysisTaskGammaCalo::FillPhotonBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode)
2264 // Bck = 0 e+-, 1 pi+-, 2 p+-, 3 K+-, 4 n, 5 K0s, 6 Lambda, 7 mu+-, 8 rest
2265 if(fIsFromMBHeader){
2266 if(abs(pdgCode) == 11) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);
2267 else if( abs(pdgCode)==211) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);
2268 else if( abs(pdgCode)==2212) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);
2269 else if( abs(pdgCode)==321) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);
2270 else if( abs(pdgCode)==2112) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);
2271 else if( abs(pdgCode)==310) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);
2272 else if( abs(pdgCode)==3122) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);
2273 else if( abs(pdgCode)==13) fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);
2274 else fHistoClusPhotonBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);
2278 //________________________________________________________________________
2279 void AliAnalysisTaskGammaCalo::FillPhotonPlusConversionBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode)
2281 // Bck = 0 e+-, 1 pi+-, 2 p+-, 3 K+-, 4 n, 5 K0s, 6 Lambda, 7 mu+-, 8 rest
2282 if(fIsFromMBHeader){
2283 if(abs(pdgCode) == 11) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);
2284 else if( abs(pdgCode)==211) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);
2285 else if( abs(pdgCode)==2212) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);
2286 else if( abs(pdgCode)==321) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);
2287 else if( abs(pdgCode)==2112) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);
2288 else if( abs(pdgCode)==310) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);
2289 else if( abs(pdgCode)==3122) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);
2290 else if( abs(pdgCode)==13) fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);
2291 else fHistoClusPhotonPlusConvBGPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);
2296 void AliAnalysisTaskGammaCalo::SetLogBinningXTH2(TH2* histoRebin){
2297 TAxis *axisafter = histoRebin->GetXaxis();
2298 Int_t bins = axisafter->GetNbins();
2299 Double_t from = axisafter->GetXmin();
2300 Double_t to = axisafter->GetXmax();
2301 Double_t *newbins = new Double_t[bins+1];
2303 Double_t factor = TMath::Power(to/from, 1./bins);
2304 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
2305 axisafter->Set(bins, newbins);
2309 //________________________________________________________________________
2310 void AliAnalysisTaskGammaCalo::Terminate(const Option_t *)
2313 //fOutputContainer->Print(); // Will crash on GRID
2316 //________________________________________________________________________
2317 Int_t AliAnalysisTaskGammaCalo::GetSourceClassification(Int_t daughter, Int_t pdgCode){
2319 if (daughter == 111) {
2320 if (abs(pdgCode) == 310) return 1; // k0s
2321 else if (abs(pdgCode) == 3122) return 2; // Lambda
2322 else if (abs(pdgCode) == 130) return 3; // K0L
2323 else if (abs(pdgCode) == 2212) return 4; // proton
2324 else if (abs(pdgCode) == 2112) return 5; // neutron
2325 else if (abs(pdgCode) == 211) return 6; // pion
2326 else if (abs(pdgCode) == 321) return 7; // kaon
2327 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
2328 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112 ) return 9; // Sigma
2329 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114 ) return 10; // Delta
2330 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323 ) return 11; // K*