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 "AliAnalysisTaskGammaConvCalo.h"
43 #include "AliVParticle.h"
44 #include "AliESDtrack.h"
45 #include "AliESDtrackCuts.h"
46 #include "AliKFVertex.h"
47 #include "AliV0ReaderV1.h"
48 #include "AliGenCocktailEventHeader.h"
49 #include "AliConversionAODBGHandlerRP.h"
50 #include "AliAODMCParticle.h"
51 #include "AliAODMCHeader.h"
52 #include "AliEventplane.h"
53 #include "AliAnalysisTaskEMCALClusterizeFast.h"
54 #include "AliAODEvent.h"
55 #include "AliAODInputHandler.h"
56 #include "AliESDEvent.h"
57 #include "AliESDInputHandler.h"
58 #include "AliInputEventHandler.h"
60 ClassImp(AliAnalysisTaskGammaConvCalo)
62 //________________________________________________________________________
63 AliAnalysisTaskGammaConvCalo::AliAnalysisTaskGammaConvCalo(): AliAnalysisTaskSE(),
68 fBGClusHandlerRP(NULL),
79 fHeaderNameList(NULL),
80 fClusterOutputList(NULL),
81 fOutputContainer(NULL),
83 fGammaCandidates(NULL),
84 fClusterCandidates(NULL),
88 fConversionCuts(NULL),
89 fClusterCutArray(NULL),
90 fCaloPhotonCuts(NULL),
93 fHistoConvGammaPt(NULL),
94 fHistoConvGammaR(NULL),
95 fHistoConvGammaEta(NULL),
96 fTreeConvGammaPtDcazCat(NULL),
102 fCharPhotonMCInfo(0),
103 fHistoMotherInvMassPt(NULL),
104 fHistoMotherMatchedInvMassPt(NULL),
105 fSparseMotherInvMassPtZM(NULL),
106 fHistoMotherBackInvMassPt(NULL),
107 fSparseMotherBackInvMassPtZM(NULL),
108 fHistoMotherInvMassEalpha(NULL),
109 fHistoMotherPi0PtY(NULL),
110 fHistoMotherEtaPtY(NULL),
111 fHistoMotherPi0PtAlpha(NULL),
112 fHistoMotherEtaPtAlpha(NULL),
113 fHistoMotherPi0PtOpenAngle(NULL),
114 fHistoMotherEtaPtOpenAngle(NULL),
115 fHistoMotherPi0ConvPhotonEtaPhi(NULL),
116 fHistoMotherEtaConvPhotonEtaPhi(NULL),
117 fHistoMotherInvMassECalib(NULL),
118 fHistoMotherInvMassECalibalpha(NULL),
119 fHistoPhotonPairPtconv(NULL),
120 fHistoPhotonPairMixedEventPtconv(NULL),
121 fHistoClusGammaPt(NULL),
122 fHistoClusOverlapHeadersGammaPt(NULL),
123 fHistoMCHeaders(NULL),
124 fHistoMCAllGammaPt(NULL),
125 fHistoMCAllGammaEMCALAccPt(NULL),
126 fHistoMCDecayGammaPi0Pt(NULL),
127 fHistoMCDecayGammaRhoPt(NULL),
128 fHistoMCDecayGammaEtaPt(NULL),
129 fHistoMCDecayGammaOmegaPt(NULL),
130 fHistoMCDecayGammaEtapPt(NULL),
131 fHistoMCDecayGammaPhiPt(NULL),
132 fHistoMCDecayGammaSigmaPt(NULL),
133 fHistoMCConvGammaPt(NULL),
134 fHistoMCConvGammaR(NULL),
135 fHistoMCConvGammaEta(NULL),
137 fHistoMCPi0WOWeightPt(NULL),
139 fHistoMCEtaWOWeightPt(NULL),
140 fHistoMCPi0InAccPt(NULL),
141 fHistoMCEtaInAccPt(NULL),
142 fHistoMCPi0PtY(NULL),
143 fHistoMCEtaPtY(NULL),
144 fHistoMCPi0PtAlpha(NULL),
145 fHistoMCEtaPtAlpha(NULL),
147 fHistoMCK0sWOWeightPt(NULL),
148 fHistoMCK0sPtY(NULL),
149 fHistoMCSecPi0PtvsSource(NULL),
150 fHistoMCSecPi0Source(NULL),
151 fHistoMCSecEtaPt(NULL),
152 fHistoMCSecEtaSource(NULL),
153 fHistoTruePi0InvMassPt(NULL),
154 fHistoTrueEtaInvMassPt(NULL),
155 fHistoTruePi0CaloPhotonInvMassPt(NULL),
156 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
157 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
158 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
159 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
160 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
161 fHistoTruePi0CaloElectronInvMassPt(NULL),
162 fHistoTrueEtaCaloElectronInvMassPt(NULL),
163 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
164 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
165 fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
166 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
167 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
168 fHistoTruePrimaryPi0InvMassPt(NULL),
169 fHistoTruePrimaryEtaInvMassPt(NULL),
170 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
171 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
172 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
173 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
174 fHistoTruePrimaryPi0MCPtResolPt(NULL),
175 fHistoTruePrimaryEtaMCPtResolPt(NULL),
176 fHistoTrueMotherPi0ConvPhotonEtaPhi(NULL),
177 fHistoTrueMotherEtaConvPhotonEtaPhi(NULL),
178 fHistoTrueSecondaryPi0InvMassPt(NULL),
179 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
180 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
181 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
182 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
183 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
184 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
185 fHistoTrueBckGGInvMassPt(NULL),
186 fHistoTrueBckContInvMassPt(NULL),
187 fHistoTruePi0PtY(NULL),
188 fHistoTrueEtaPtY(NULL),
189 fHistoTruePi0PtAlpha(NULL),
190 fHistoTrueEtaPtAlpha(NULL),
191 fHistoTruePi0PtOpenAngle(NULL),
192 fHistoTrueEtaPtOpenAngle(NULL),
193 fHistoTrueConvGammaPt(NULL),
194 fHistoTrueConvPi0GammaPt(NULL),
195 fHistoTrueConvGammaEta(NULL),
196 fHistoCombinatorialPt(NULL),
197 fHistoTruePrimaryConvGammaPt(NULL),
198 fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
199 fHistoTrueSecondaryConvGammaPt(NULL),
200 fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
201 fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
202 fHistoTrueClusGammaPt(NULL),
203 fHistoTrueClusUnConvGammaPt(NULL),
204 fHistoTrueClusUnConvGammaMCPt(NULL),
205 fHistoTrueClusElectronPt(NULL),
206 fHistoTrueClusConvGammaPt(NULL),
207 fHistoTrueClusConvGammaMCPt(NULL),
208 fHistoTrueClusConvGammaFullyPt(NULL),
209 fHistoTrueClusMergedGammaPt(NULL),
210 fHistoTrueClusMergedPartConvGammaPt(NULL),
211 fHistoTrueClusDalitzPt(NULL),
212 fHistoTrueClusDalitzMergedPt(NULL),
213 fHistoTrueClusPhotonFromElecMotherPt(NULL),
214 fHistoTrueClusShowerPt(NULL),
215 fHistoTrueClusSubLeadingPt(NULL),
216 fHistoTrueClusNParticles(NULL),
217 fHistoTrueClusEMNonLeadingPt(NULL),
218 fHistoTrueNLabelsInClus(NULL),
219 fHistoTruePrimaryClusGammaPt(NULL),
220 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
221 fHistoTruePrimaryPi0PhotonPairPtconv(NULL),
222 fHistoTruePrimaryPi0DCPtconv(NULL),
223 fHistoTruePrimaryPi0MissingPtconv(NULL),
224 fHistoTruePrimaryEtaPhotonPairPtconv(NULL),
225 fHistoTruePrimaryEtaDCPtconv(NULL),
226 fHistoTruePrimaryEtaMissingPtconv(NULL),
227 fHistoTrueSecondaryPi0PhotonPairPtconv(NULL),
228 fHistoTrueSecondaryPi0DCPtconv(NULL),
229 fHistoTrueSecondaryPi0MissingPtconv(NULL),
230 fStringRecTruePi0s(NULL),
231 fStringRecTrueEtas(NULL),
233 fHistoNGoodESDTracks(NULL),
234 fHistoNGammaCandidates(NULL),
235 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
236 fHistoNV0Tracks(NULL),
237 fProfileEtaShift(NULL),
238 fEventPlaneAngle(-100),
240 fNGammaCandidates(0),
251 fMoveParticleAccordingToVertex(kTRUE),
253 fDoMesonAnalysis(kTRUE),
257 fIsFromMBHeader(kTRUE),
258 fIsOverlappingWithOtherHeader(kFALSE),
264 //________________________________________________________________________
265 AliAnalysisTaskGammaConvCalo::AliAnalysisTaskGammaConvCalo(const char *name):
266 AliAnalysisTaskSE(name),
270 fBGClusHandler(NULL),
271 fBGClusHandlerRP(NULL),
279 fPhotonDCAList(NULL),
282 fHeaderNameList(NULL),
283 fClusterOutputList(NULL),
286 fGammaCandidates(NULL),
287 fClusterCandidates(NULL),
288 fEventCutArray(NULL),
291 fConversionCuts(NULL),
292 fClusterCutArray(NULL),
293 fCaloPhotonCuts(NULL),
294 fMesonCutArray(NULL),
296 fHistoConvGammaPt(NULL),
297 fHistoConvGammaR(NULL),
298 fHistoConvGammaEta(NULL),
299 fTreeConvGammaPtDcazCat(NULL),
305 fCharPhotonMCInfo(0),
306 fHistoMotherInvMassPt(NULL),
307 fHistoMotherMatchedInvMassPt(NULL),
308 fSparseMotherInvMassPtZM(NULL),
309 fHistoMotherBackInvMassPt(NULL),
310 fSparseMotherBackInvMassPtZM(NULL),
311 fHistoMotherInvMassEalpha(NULL),
312 fHistoMotherPi0PtY(NULL),
313 fHistoMotherEtaPtY(NULL),
314 fHistoMotherPi0PtAlpha(NULL),
315 fHistoMotherEtaPtAlpha(NULL),
316 fHistoMotherPi0PtOpenAngle(NULL),
317 fHistoMotherEtaPtOpenAngle(NULL),
318 fHistoMotherPi0ConvPhotonEtaPhi(NULL),
319 fHistoMotherEtaConvPhotonEtaPhi(NULL),
320 fHistoMotherInvMassECalib(NULL),
321 fHistoMotherInvMassECalibalpha(NULL),
322 fHistoPhotonPairPtconv(NULL),
323 fHistoPhotonPairMixedEventPtconv(NULL),
324 fHistoClusGammaPt(NULL),
325 fHistoClusOverlapHeadersGammaPt(NULL),
326 fHistoMCHeaders(NULL),
327 fHistoMCAllGammaPt(NULL),
328 fHistoMCAllGammaEMCALAccPt(NULL),
329 fHistoMCDecayGammaPi0Pt(NULL),
330 fHistoMCDecayGammaRhoPt(NULL),
331 fHistoMCDecayGammaEtaPt(NULL),
332 fHistoMCDecayGammaOmegaPt(NULL),
333 fHistoMCDecayGammaEtapPt(NULL),
334 fHistoMCDecayGammaPhiPt(NULL),
335 fHistoMCDecayGammaSigmaPt(NULL),
336 fHistoMCConvGammaPt(NULL),
337 fHistoMCConvGammaR(NULL),
338 fHistoMCConvGammaEta(NULL),
340 fHistoMCPi0WOWeightPt(NULL),
342 fHistoMCEtaWOWeightPt(NULL),
343 fHistoMCPi0InAccPt(NULL),
344 fHistoMCEtaInAccPt(NULL),
345 fHistoMCPi0PtY(NULL),
346 fHistoMCEtaPtY(NULL),
347 fHistoMCPi0PtAlpha(NULL),
348 fHistoMCEtaPtAlpha(NULL),
350 fHistoMCK0sWOWeightPt(NULL),
351 fHistoMCK0sPtY(NULL),
352 fHistoMCSecPi0PtvsSource(NULL),
353 fHistoMCSecPi0Source(NULL),
354 fHistoMCSecEtaPt(NULL),
355 fHistoMCSecEtaSource(NULL),
356 fHistoTruePi0InvMassPt(NULL),
357 fHistoTrueEtaInvMassPt(NULL),
358 fHistoTruePi0CaloPhotonInvMassPt(NULL),
359 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
360 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
361 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
362 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
363 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
364 fHistoTruePi0CaloElectronInvMassPt(NULL),
365 fHistoTrueEtaCaloElectronInvMassPt(NULL),
366 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
367 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
368 fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
369 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
370 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
371 fHistoTruePrimaryPi0InvMassPt(NULL),
372 fHistoTruePrimaryEtaInvMassPt(NULL),
373 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
374 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
375 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
376 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
377 fHistoTruePrimaryPi0MCPtResolPt(NULL),
378 fHistoTruePrimaryEtaMCPtResolPt(NULL),
379 fHistoTrueMotherPi0ConvPhotonEtaPhi(NULL),
380 fHistoTrueMotherEtaConvPhotonEtaPhi(NULL),
381 fHistoTrueSecondaryPi0InvMassPt(NULL),
382 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
383 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
384 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
385 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
386 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
387 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
388 fHistoTrueBckGGInvMassPt(NULL),
389 fHistoTrueBckContInvMassPt(NULL),
390 fHistoTruePi0PtY(NULL),
391 fHistoTrueEtaPtY(NULL),
392 fHistoTruePi0PtAlpha(NULL),
393 fHistoTrueEtaPtAlpha(NULL),
394 fHistoTruePi0PtOpenAngle(NULL),
395 fHistoTrueEtaPtOpenAngle(NULL),
396 fHistoTrueConvGammaPt(NULL),
397 fHistoTrueConvPi0GammaPt(NULL),
398 fHistoTrueConvGammaEta(NULL),
399 fHistoCombinatorialPt(NULL),
400 fHistoTruePrimaryConvGammaPt(NULL),
401 fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
402 fHistoTrueSecondaryConvGammaPt(NULL),
403 fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
404 fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
405 fHistoTrueClusGammaPt(NULL),
406 fHistoTrueClusUnConvGammaPt(NULL),
407 fHistoTrueClusUnConvGammaMCPt(NULL),
408 fHistoTrueClusElectronPt(NULL),
409 fHistoTrueClusConvGammaPt(NULL),
410 fHistoTrueClusConvGammaMCPt(NULL),
411 fHistoTrueClusConvGammaFullyPt(NULL),
412 fHistoTrueClusMergedGammaPt(NULL),
413 fHistoTrueClusMergedPartConvGammaPt(NULL),
414 fHistoTrueClusDalitzPt(NULL),
415 fHistoTrueClusDalitzMergedPt(NULL),
416 fHistoTrueClusPhotonFromElecMotherPt(NULL),
417 fHistoTrueClusShowerPt(NULL),
418 fHistoTrueClusSubLeadingPt(NULL),
419 fHistoTrueClusNParticles(NULL),
420 fHistoTrueClusEMNonLeadingPt(NULL),
421 fHistoTrueNLabelsInClus(NULL),
422 fHistoTruePrimaryClusGammaPt(NULL),
423 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
424 fHistoTruePrimaryPi0PhotonPairPtconv(NULL),
425 fHistoTruePrimaryPi0DCPtconv(NULL),
426 fHistoTruePrimaryPi0MissingPtconv(NULL),
427 fHistoTruePrimaryEtaPhotonPairPtconv(NULL),
428 fHistoTruePrimaryEtaDCPtconv(NULL),
429 fHistoTruePrimaryEtaMissingPtconv(NULL),
430 fHistoTrueSecondaryPi0PhotonPairPtconv(NULL),
431 fHistoTrueSecondaryPi0DCPtconv(NULL),
432 fHistoTrueSecondaryPi0MissingPtconv(NULL),
433 fStringRecTruePi0s(NULL),
434 fStringRecTrueEtas(NULL),
436 fHistoNGoodESDTracks(NULL),
437 fHistoNGammaCandidates(NULL),
438 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
439 fHistoNV0Tracks(NULL),
440 fProfileEtaShift(NULL),
441 fEventPlaneAngle(-100),
443 fNGammaCandidates(0),
454 fMoveParticleAccordingToVertex(kTRUE),
456 fDoMesonAnalysis(kTRUE),
460 fIsFromMBHeader(kTRUE),
461 fIsOverlappingWithOtherHeader(kFALSE),
464 // Define output slots here
465 DefineOutput(1, TList::Class());
468 AliAnalysisTaskGammaConvCalo::~AliAnalysisTaskGammaConvCalo()
470 if(fGammaCandidates){
471 delete fGammaCandidates;
472 fGammaCandidates = 0x0;
474 if(fClusterCandidates){
475 delete fClusterCandidates;
476 fClusterCandidates = 0x0;
483 delete[] fBGHandlerRP;
487 delete[] fBGClusHandler;
488 fBGClusHandler = 0x0;
490 if(fBGClusHandlerRP){
491 delete[] fBGClusHandlerRP;
492 fBGClusHandlerRP = 0x0;
495 //___________________________________________________________
496 void AliAnalysisTaskGammaConvCalo::InitBack(){
498 const Int_t nDim = 4;
499 Int_t nBins[nDim] = {800,250,7,4};
500 Double_t xMin[nDim] = {0,0, 0,0};
501 Double_t xMax[nDim] = {0.8,25,7,4};
503 fSparseMotherInvMassPtZM = new THnSparseF*[fnCuts];
504 fSparseMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
506 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
507 fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
509 fBGClusHandler = new AliGammaConversionAODBGHandler*[fnCuts];
510 fBGClusHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
512 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
513 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
514 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
515 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
516 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
517 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
519 Int_t collisionSystem = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(0,1));
520 Int_t centMin = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(1,1));
521 Int_t centMax = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(2,1));
523 if(collisionSystem == 1 || collisionSystem == 2 ||
524 collisionSystem == 5 || collisionSystem == 8 ||
525 collisionSystem == 9){
526 centMin = centMin*10;
527 centMax = centMax*10;
528 if(centMax ==0 && centMax!=centMin) centMax=100;
529 } else if(collisionSystem == 3 || collisionSystem == 6){
532 } else if(collisionSystem == 4 || collisionSystem == 7){
533 centMin = ((centMin*5)+45);
534 centMax = ((centMax*5)+45);
537 fBackList[iCut] = new TList();
538 fBackList[iCut]->SetName(Form("%s_%s_%s_%s Back histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(), cutstringMeson.Data()));
539 fBackList[iCut]->SetOwner(kTRUE);
540 fCutFolder[iCut]->Add(fBackList[iCut]);
542 fSparseMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
543 fBackList[iCut]->Add(fSparseMotherBackInvMassPtZM[iCut]);
545 fMotherList[iCut] = new TList();
546 fMotherList[iCut]->SetName(Form("%s_%s_%s_%s Mother histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
547 fMotherList[iCut]->SetOwner(kTRUE);
548 fCutFolder[iCut]->Add(fMotherList[iCut]);
550 fSparseMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
551 fMotherList[iCut]->Add(fSparseMotherInvMassPtZM[iCut]);
553 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
554 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
555 collisionSystem,centMin,centMax,
556 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
557 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity(),
559 fBGClusHandler[iCut] = new AliGammaConversionAODBGHandler(
560 collisionSystem,centMin,centMax,
561 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
562 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity(),
564 fBGHandlerRP[iCut] = NULL;
566 fBGHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
567 ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsHeavyIon(),
568 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
569 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
570 fBGClusHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
571 ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsHeavyIon(),
572 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
573 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
574 fBGHandler[iCut] = NULL;
579 //________________________________________________________________________
580 void AliAnalysisTaskGammaConvCalo::UserCreateOutputObjects(){
583 if(fOutputContainer != NULL){
584 delete fOutputContainer;
585 fOutputContainer = NULL;
587 if(fOutputContainer == NULL){
588 fOutputContainer = new TList();
589 fOutputContainer->SetOwner(kTRUE);
592 // Array of current cut's gammas
593 fGammaCandidates = new TList();
594 fClusterCandidates = new TList();
596 fCutFolder = new TList*[fnCuts];
597 fESDList = new TList*[fnCuts];
598 fBackList = new TList*[fnCuts];
599 fMotherList = new TList*[fnCuts];
600 fHistoNEvents = new TH1I*[fnCuts];
601 fHistoNGoodESDTracks = new TH1I*[fnCuts];
602 fHistoNGammaCandidates = new TH1I*[fnCuts];
603 fHistoNGoodESDTracksVsNGammaCanditates = new TH2F*[fnCuts];
604 fHistoNV0Tracks = new TH1I*[fnCuts];
605 fProfileEtaShift = new TProfile*[fnCuts];
606 fHistoConvGammaPt = new TH1F*[fnCuts];
608 if (fDoPhotonQA == 2){
609 fPhotonDCAList = new TList*[fnCuts];
610 fTreeConvGammaPtDcazCat = new TTree*[fnCuts];
612 if (fDoPhotonQA > 0){
613 fHistoConvGammaR = new TH1F*[fnCuts];
614 fHistoConvGammaEta = new TH1F*[fnCuts];
617 if(fDoMesonAnalysis){
618 fHistoMotherInvMassPt = new TH2F*[fnCuts];
619 fHistoMotherMatchedInvMassPt = new TH2F*[fnCuts];
620 fHistoMotherBackInvMassPt = new TH2F*[fnCuts];
621 fHistoMotherInvMassEalpha = new TH2F*[fnCuts];
622 fHistoPhotonPairPtconv = new TH2F*[fnCuts];
623 fHistoPhotonPairMixedEventPtconv = new TH2F*[fnCuts];
625 fHistoMotherPi0PtY = new TH2F*[fnCuts];
626 fHistoMotherEtaPtY = new TH2F*[fnCuts];
627 fHistoMotherPi0PtAlpha = new TH2F*[fnCuts];
628 fHistoMotherEtaPtAlpha = new TH2F*[fnCuts];
629 fHistoMotherPi0PtOpenAngle = new TH2F*[fnCuts];
630 fHistoMotherEtaPtOpenAngle = new TH2F*[fnCuts];
631 fHistoMotherPi0ConvPhotonEtaPhi = new TH2F*[fnCuts];
632 fHistoMotherEtaConvPhotonEtaPhi = new TH2F*[fnCuts];
635 fHistoMotherInvMassECalib = new TH2F*[fnCuts];
636 fHistoMotherInvMassECalibalpha = new TH2F*[fnCuts];
640 fClusterOutputList = new TList*[fnCuts];
641 fHistoClusGammaPt = new TH1F*[fnCuts];
642 fHistoClusOverlapHeadersGammaPt = new TH1F*[fnCuts];
644 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
645 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
646 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
647 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
648 TString cutstringMeson = "NoMesonCut";
649 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
651 fCutFolder[iCut] = new TList();
652 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s_%s",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
653 fCutFolder[iCut]->SetOwner(kTRUE);
654 fOutputContainer->Add(fCutFolder[iCut]);
655 fESDList[iCut] = new TList();
656 fESDList[iCut]->SetName(Form("%s_%s_%s_%s ESD histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
657 fESDList[iCut]->SetOwner(kTRUE);
658 fCutFolder[iCut]->Add(fESDList[iCut]);
660 fHistoNEvents[iCut] = new TH1I("NEvents","NEvents",10,-0.5,9.5);
661 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
662 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
663 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
664 if (((AliConvEventCuts*)fEventCutArray->At(iCut))->IsSpecialTrigger() > 1 ){
665 TString TriggerNames = "Not Trigger: ";
666 TriggerNames = TriggerNames+ ( (AliConvEventCuts*)fEventCutArray->At(iCut))->GetSpecialTriggerName();
667 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
669 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
671 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
672 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
673 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
674 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
675 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
676 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(10,"EMCAL problem");
677 fESDList[iCut]->Add(fHistoNEvents[iCut]);
679 if(fIsHeavyIon == 1) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
680 else if(fIsHeavyIon == 2) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",400,0,400);
681 else fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
682 fHistoNGoodESDTracks[iCut]->SetXTitle("# TPC tracks");
683 fESDList[iCut]->Add(fHistoNGoodESDTracks[iCut]);
685 if(fIsHeavyIon == 1) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
686 else if(fIsHeavyIon == 2) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
687 else fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
688 fHistoNGammaCandidates[iCut]->SetXTitle("# accepted $#gamma_{conv}");
689 fESDList[iCut]->Add(fHistoNGammaCandidates[iCut]);
691 if(fIsHeavyIon == 1) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",4000,0,4000,100,0,100);
692 else if(fIsHeavyIon == 2) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",400,0,400,50,0,50);
693 else fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",200,0,200,50,0,50);
694 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->SetXTitle("# TPC tracks");
695 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->SetYTitle("# accepted $#gamma_{conv}");
696 fESDList[iCut]->Add(fHistoNGoodESDTracksVsNGammaCanditates[iCut]);
699 if(fIsHeavyIon == 1) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
700 else if(fIsHeavyIon == 2) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
701 else fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
702 fHistoNV0Tracks[iCut]->SetXTitle("VZERO amp [arb. units]");
703 fESDList[iCut]->Add(fHistoNV0Tracks[iCut]);
704 fProfileEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
705 fESDList[iCut]->Add(fProfileEtaShift[iCut]);
706 fHistoConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
707 fHistoConvGammaPt[iCut]->SetXTitle("p_{T,conv} (GeV/c)");
708 fESDList[iCut]->Add(fHistoConvGammaPt[iCut]);
710 if (fDoPhotonQA == 2){
711 fPhotonDCAList[iCut] = new TList();
712 fPhotonDCAList[iCut]->SetName(Form("%s_%s_%s_%s Photon DCA tree",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
713 fPhotonDCAList[iCut]->SetOwner(kTRUE);
714 fCutFolder[iCut]->Add(fPhotonDCAList[iCut]);
716 fTreeConvGammaPtDcazCat[iCut] = new TTree("ESD_ConvGamma_Pt_Dcaz_R_Eta","ESD_ConvGamma_Pt_Dcaz_R_Eta_Cat");
717 fTreeConvGammaPtDcazCat[iCut]->Branch("Pt",&fPtGamma,"fPtGamma/F");
718 fTreeConvGammaPtDcazCat[iCut]->Branch("DcaZPhoton",&fDCAzPhoton,"fDCAzPhoton/F");
719 fTreeConvGammaPtDcazCat[iCut]->Branch("cat",&fCharCatPhoton,"fCharCatPhoton/b");
721 fTreeConvGammaPtDcazCat[iCut]->Branch("photonMCInfo",&fCharPhotonMCInfo,"fCharPhotonMCInfo/b");
723 fPhotonDCAList[iCut]->Add(fTreeConvGammaPtDcazCat[iCut]);
726 if (fDoPhotonQA > 0){
727 fHistoConvGammaR[iCut] = new TH1F("ESD_ConvGamma_R","ESD_ConvGamma_R",800,0,200);
728 fHistoConvGammaR[iCut]->SetXTitle("R_{conv} (cm)");
729 fESDList[iCut]->Add(fHistoConvGammaR[iCut]);
730 fHistoConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",2000,-2,2);
731 fHistoConvGammaEta[iCut]->SetXTitle("#eta_{conv}");
732 fESDList[iCut]->Add(fHistoConvGammaEta[iCut]);
735 fClusterOutputList[iCut] = new TList();
736 fClusterOutputList[iCut]->SetName(Form("%s_%s_%s_%s Cluster Output",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
737 fClusterOutputList[iCut]->SetOwner(1);
738 fCutFolder[iCut]->Add(fClusterOutputList[iCut]);
740 fHistoClusGammaPt[iCut] = new TH1F("ClusGamma_Pt","ClusGamma_Pt",250,0,25);
741 fHistoClusGammaPt[iCut]->SetXTitle("p_{T,clus} (GeV/c)");
742 fClusterOutputList[iCut]->Add(fHistoClusGammaPt[iCut]);
743 fHistoClusOverlapHeadersGammaPt[iCut] = new TH1F("ClusGammaOverlapHeaders_Pt","ClusGammaOverlapHeaders_Pt",250,0,25);
744 fHistoClusOverlapHeadersGammaPt[iCut]->SetXTitle("p_{T,clus} (GeV/c), selected header w/ overlap");
745 fClusterOutputList[iCut]->Add(fHistoClusOverlapHeadersGammaPt[iCut]);
747 if(fDoMesonAnalysis){
748 fHistoMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
749 fHistoMotherInvMassPt[iCut]->SetXTitle("M_{inv} (GeV/c^{2})");
750 fHistoMotherInvMassPt[iCut]->SetYTitle("p_{T,pair} (GeV/c)");
751 fESDList[iCut]->Add(fHistoMotherInvMassPt[iCut]);
753 fHistoMotherMatchedInvMassPt[iCut] = new TH2F("ESD_MotherMatched_InvMass_Pt","ESD_MotherMatched_InvMass_Pt",800,0,0.8,250,0,25);
754 fHistoMotherMatchedInvMassPt[iCut]->SetXTitle("M_{inv} (GeV/c^{2}) matched conv e^{+/-} to cluster");
755 fHistoMotherMatchedInvMassPt[iCut]->SetYTitle("p_{T,pair} (GeV/c)");
756 fESDList[iCut]->Add(fHistoMotherMatchedInvMassPt[iCut]);
758 fHistoMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
759 fHistoMotherBackInvMassPt[iCut]->SetXTitle("M_{inv, mxed} (GeV/c^{2})");
760 fHistoMotherBackInvMassPt[iCut]->SetYTitle("p_{T,BG pair} (GeV/c)");
761 fESDList[iCut]->Add(fHistoMotherBackInvMassPt[iCut]);
763 fHistoMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
764 fHistoMotherInvMassEalpha[iCut]->SetXTitle("M_{inv} (GeV/c^{2})");
765 fHistoMotherInvMassEalpha[iCut]->SetYTitle("p_{T,pair} (GeV/c)");
766 fESDList[iCut]->Add(fHistoMotherInvMassEalpha[iCut]);
768 fHistoPhotonPairPtconv[iCut] = new TH2F("ESD_Mother_InvMass_PtConv","",800,0,0.8,250,0,25);
769 fHistoPhotonPairPtconv[iCut]->SetXTitle("M_{inv} (GeV/c^{2})");
770 fHistoPhotonPairPtconv[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
771 fESDList[iCut]->Add(fHistoPhotonPairPtconv[iCut]);
773 fHistoPhotonPairMixedEventPtconv[iCut] = new TH2F("ESD_Background_InvMass_PtConv","",800,0,0.8,250,0,25);
774 fHistoPhotonPairMixedEventPtconv[iCut]->SetXTitle("M_{inv,mixed} (GeV/c^{2})");
775 fHistoPhotonPairMixedEventPtconv[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
776 fESDList[iCut]->Add(fHistoPhotonPairMixedEventPtconv[iCut]);
779 fHistoMotherInvMassECalib[iCut] = new TH2F("ESD_Mother_InvMass_E_Calib","ESD_Mother_InvMass_E_Calib",800,0,0.8,250,0,25);
780 fHistoMotherInvMassECalib[iCut]->SetXTitle("M_{inv} (GeV/c^{2})");
781 fHistoMotherInvMassECalib[iCut]->SetYTitle("p_{T,cluster} (GeV/c)");
782 fESDList[iCut]->Add(fHistoMotherInvMassECalib[iCut]);
784 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);
785 fHistoMotherInvMassECalibalpha[iCut]->SetXTitle("M_{inv} (GeV/c^{2})");
786 fHistoMotherInvMassECalibalpha[iCut]->SetYTitle("p_{T,cluster} (GeV/c)");
787 fESDList[iCut]->Add(fHistoMotherInvMassECalibalpha[iCut]);
790 if (fDoMesonQA > 0 ){
791 fHistoMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
792 fHistoMotherPi0PtY[iCut]->SetXTitle("p_{T, #pi^{0} cand} (GeV/c)");
793 fHistoMotherPi0PtY[iCut]->SetYTitle("y_{#pi^{0} cand}");
794 SetLogBinningXTH2(fHistoMotherPi0PtY[iCut]);
795 fESDList[iCut]->Add(fHistoMotherPi0PtY[iCut]);
796 fHistoMotherEtaPtY[iCut] = new TH2F("ESD_MotaherEta_Pt_Y","ESD_MotherEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
797 fHistoMotherEtaPtY[iCut]->SetXTitle("p_{T, #eta cand} (GeV/c)");
798 fHistoMotherEtaPtY[iCut]->SetYTitle("y_{ #eta cand}");
799 SetLogBinningXTH2(fHistoMotherEtaPtY[iCut]);
800 fESDList[iCut]->Add(fHistoMotherEtaPtY[iCut]);
801 fHistoMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",150,0.03,15.,100,0,1);
802 fHistoMotherPi0PtAlpha[iCut]->SetXTitle("p_{T, #pi^{0} cand} (GeV/c)");
803 fHistoMotherPi0PtAlpha[iCut]->SetYTitle("#alpha_{#pi^{0} cand}");
804 SetLogBinningXTH2(fHistoMotherPi0PtAlpha[iCut]);
805 fESDList[iCut]->Add(fHistoMotherPi0PtAlpha[iCut]);
806 fHistoMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",150,0.03,15.,100,0,1);
807 fHistoMotherEtaPtAlpha[iCut]->SetXTitle("p_{T, #eta cand} (GeV/c)");
808 fHistoMotherEtaPtAlpha[iCut]->SetYTitle("#alpha_{#eta cand}");
809 SetLogBinningXTH2(fHistoMotherEtaPtAlpha[iCut]);
810 fESDList[iCut]->Add(fHistoMotherEtaPtAlpha[iCut]);
811 fHistoMotherPi0PtOpenAngle[iCut] = new TH2F("ESD_MotherPi0_Pt_OpenAngle","ESD_MotherPi0_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
812 fHistoMotherPi0PtOpenAngle[iCut]->SetXTitle("p_{T, #pi^{0} cand} (GeV/c)");
813 fHistoMotherPi0PtOpenAngle[iCut]->SetYTitle("#theta_{#pi^{0} cand}");
814 SetLogBinningXTH2(fHistoMotherPi0PtOpenAngle[iCut]);
815 fESDList[iCut]->Add(fHistoMotherPi0PtOpenAngle[iCut]);
816 fHistoMotherEtaPtOpenAngle[iCut] = new TH2F("ESD_MotherEta_Pt_OpenAngle","ESD_MotherEta_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
817 fHistoMotherEtaPtOpenAngle[iCut]->SetXTitle("p_{T, #eta cand} (GeV/c)");
818 fHistoMotherEtaPtOpenAngle[iCut]->SetYTitle("#theta_{#eta cand}");
819 SetLogBinningXTH2(fHistoMotherEtaPtOpenAngle[iCut]);
820 fESDList[iCut]->Add(fHistoMotherEtaPtOpenAngle[iCut]);
821 fHistoMotherPi0ConvPhotonEtaPhi[iCut] = new TH2F("ESD_MotherPi0ConvPhoton_Eta_Phi","ConvPhoton under #pi^{0} peak",600,0,2*TMath::Pi(),200,-1,1);
822 fHistoMotherPi0ConvPhotonEtaPhi[iCut]->SetXTitle("#phi_{#gamma_{conv}} (rad)");
823 fHistoMotherPi0ConvPhotonEtaPhi[iCut]->SetYTitle("#eta_{#gamma_{conv}}");
824 fESDList[iCut]->Add(fHistoMotherPi0ConvPhotonEtaPhi[iCut]);
825 fHistoMotherEtaConvPhotonEtaPhi[iCut] = new TH2F("ESD_MotherEtaConvPhoton_Eta_Phi","ConvPhoton under #eta peak",600,0,2*TMath::Pi(),200,-1,1);
826 fHistoMotherEtaConvPhotonEtaPhi[iCut]->SetXTitle("#phi_{#gamma_{conv}} (rad)");
827 fHistoMotherEtaConvPhotonEtaPhi[iCut]->SetYTitle("#eta_{#gamma_{conv}}");
828 fESDList[iCut]->Add(fHistoMotherEtaConvPhotonEtaPhi[iCut]);
832 if(fDoMesonAnalysis){
833 InitBack(); // Init Background Handler
838 fMCList = new TList*[fnCuts];
840 fTrueList = new TList*[fnCuts];
841 // Selected Header List
842 fHeaderNameList = new TList*[fnCuts];
843 fHistoMCHeaders = new TH1I*[fnCuts];
844 fHistoMCAllGammaPt = new TH1F*[fnCuts];
845 fHistoMCAllGammaEMCALAccPt = new TH1F*[fnCuts];
846 fHistoMCDecayGammaPi0Pt = new TH1F*[fnCuts];
847 fHistoMCDecayGammaRhoPt = new TH1F*[fnCuts];
848 fHistoMCDecayGammaEtaPt = new TH1F*[fnCuts];
849 fHistoMCDecayGammaOmegaPt = new TH1F*[fnCuts];
850 fHistoMCDecayGammaEtapPt = new TH1F*[fnCuts];
851 fHistoMCDecayGammaPhiPt = new TH1F*[fnCuts];
852 fHistoMCDecayGammaSigmaPt = new TH1F*[fnCuts];
853 fHistoMCConvGammaPt = new TH1F*[fnCuts];
854 fHistoTrueConvGammaPt = new TH1F*[fnCuts];
855 fHistoTrueConvPi0GammaPt = new TH1F*[fnCuts];
857 fHistoCombinatorialPt = new TH2F*[fnCuts];
858 fHistoTruePrimaryConvGammaPt = new TH1F*[fnCuts];
859 fHistoTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
860 fHistoTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
861 fHistoTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
862 fHistoTrueSecondaryConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
864 fHistoTrueClusGammaPt = new TH1F*[fnCuts];
865 fHistoTruePrimaryClusGammaPt = new TH1F*[fnCuts];
866 fHistoTruePrimaryClusGammaESDPtMCPt = new TH2F*[fnCuts];
868 if (fDoPhotonQA > 0){
869 fHistoMCConvGammaR = new TH1F*[fnCuts];
870 fHistoMCConvGammaEta = new TH1F*[fnCuts];
871 fHistoTrueConvGammaEta = new TH1F*[fnCuts];
873 if (fDoClusterQA > 0){
874 fHistoTrueClusUnConvGammaPt = new TH1F*[fnCuts];
875 fHistoTrueClusUnConvGammaMCPt = new TH1F*[fnCuts];
876 fHistoTrueClusElectronPt = new TH1F*[fnCuts];
877 fHistoTrueClusConvGammaPt = new TH1F*[fnCuts];
878 fHistoTrueClusConvGammaMCPt = new TH1F*[fnCuts];
879 fHistoTrueClusConvGammaFullyPt = new TH1F*[fnCuts];
880 fHistoTrueClusMergedGammaPt = new TH1F*[fnCuts];
881 fHistoTrueClusMergedPartConvGammaPt = new TH1F*[fnCuts];
882 fHistoTrueClusDalitzPt = new TH1F*[fnCuts];
883 fHistoTrueClusDalitzMergedPt = new TH1F*[fnCuts];
884 fHistoTrueClusPhotonFromElecMotherPt= new TH1F*[fnCuts];
885 fHistoTrueClusShowerPt = new TH1F*[fnCuts];
886 fHistoTrueClusSubLeadingPt = new TH1F*[fnCuts];
887 fHistoTrueClusNParticles = new TH1I*[fnCuts];
888 fHistoTrueClusEMNonLeadingPt = new TH1F*[fnCuts];
889 fHistoTrueNLabelsInClus = new TH1F*[fnCuts];
892 if(fDoMesonAnalysis){
893 fHistoMCPi0Pt = new TH1F*[fnCuts];
894 fHistoMCPi0WOWeightPt = new TH1F*[fnCuts];
895 fHistoMCEtaPt = new TH1F*[fnCuts];
896 fHistoMCEtaWOWeightPt = new TH1F*[fnCuts];
897 fHistoMCPi0InAccPt = new TH1F*[fnCuts];
898 fHistoMCEtaInAccPt = new TH1F*[fnCuts];
900 fHistoTruePi0InvMassPt = new TH2F*[fnCuts];
901 fHistoTrueEtaInvMassPt = new TH2F*[fnCuts];
902 fHistoTruePrimaryPi0InvMassPt = new TH2F*[fnCuts];
903 fHistoTruePrimaryEtaInvMassPt = new TH2F*[fnCuts];
904 fHistoTruePrimaryPi0W0WeightingInvMassPt = new TH2F*[fnCuts];
905 fHistoTruePrimaryEtaW0WeightingInvMassPt = new TH2F*[fnCuts];
906 fProfileTruePrimaryPi0WeightsInvMassPt = new TProfile2D*[fnCuts];
907 fProfileTruePrimaryEtaWeightsInvMassPt = new TProfile2D*[fnCuts];
908 fHistoTrueSecondaryPi0InvMassPt = new TH2F*[fnCuts];
909 fHistoTrueSecondaryPi0FromK0sInvMassPt = new TH2F*[fnCuts];
910 fHistoTrueSecondaryPi0FromEtaInvMassPt = new TH2F*[fnCuts];
911 fHistoTrueSecondaryPi0FromLambdaInvMassPt = new TH2F*[fnCuts];
912 fHistoTruePrimaryPi0PhotonPairPtconv = new TH2F*[fnCuts];
913 fHistoTrueSecondaryPi0PhotonPairPtconv = new TH2F*[fnCuts];
914 fHistoTruePrimaryEtaPhotonPairPtconv = new TH2F*[fnCuts];
915 fHistoTruePrimaryPi0DCPtconv = new TH1F*[fnCuts];
916 fHistoTrueSecondaryPi0DCPtconv = new TH1F*[fnCuts];
917 fHistoTruePrimaryEtaDCPtconv = new TH1F*[fnCuts];
918 fHistoTruePrimaryPi0MissingPtconv = new TH1F*[fnCuts];
919 fHistoTrueSecondaryPi0MissingPtconv = new TH1F*[fnCuts];
920 fHistoTruePrimaryEtaMissingPtconv = new TH1F*[fnCuts];
921 fStringRecTruePi0s = new TString[fnCuts];
922 fStringRecTrueEtas = new TString[fnCuts];
925 fHistoMCPi0PtY = new TH2F*[fnCuts];
926 fHistoMCEtaPtY = new TH2F*[fnCuts];
927 fHistoMCPi0PtAlpha = new TH2F*[fnCuts];
928 fHistoMCEtaPtAlpha = new TH2F*[fnCuts];
929 fHistoMCK0sPt = new TH1F*[fnCuts];
930 fHistoMCK0sWOWeightPt = new TH1F*[fnCuts];
931 fHistoMCK0sPtY = new TH2F*[fnCuts];
932 fHistoMCSecPi0PtvsSource = new TH2F*[fnCuts];
933 fHistoMCSecPi0Source = new TH1F*[fnCuts];
934 fHistoMCSecEtaPt = new TH1F*[fnCuts];
935 fHistoMCSecEtaSource = new TH1F*[fnCuts];
936 fHistoTruePi0CaloPhotonInvMassPt = new TH2F*[fnCuts];
937 fHistoTrueEtaCaloPhotonInvMassPt = new TH2F*[fnCuts];
938 fHistoTruePi0CaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
939 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt = new TH2F*[fnCuts];
940 fHistoTrueEtaCaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
941 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt = new TH2F*[fnCuts];
942 fHistoTruePi0CaloElectronInvMassPt = new TH2F*[fnCuts];
943 fHistoTrueEtaCaloElectronInvMassPt = new TH2F*[fnCuts];
944 fHistoTruePi0CaloMergedClusterInvMassPt = new TH2F*[fnCuts];
945 fHistoTrueEtaCaloMergedClusterInvMassPt = new TH2F*[fnCuts];
946 fHistoTruePi0CaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
947 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
948 fHistoTrueMotherCaloEMNonLeadingInvMassPt = new TH2F*[fnCuts];
949 fHistoTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
950 fHistoTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
951 fHistoTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
952 fHistoTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
953 fHistoTrueLambdaWithPi0DaughterMCPt = new TH1F*[fnCuts];
954 fHistoTrueBckGGInvMassPt = new TH2F*[fnCuts];
955 fHistoTrueBckContInvMassPt = new TH2F*[fnCuts];
956 fHistoTruePi0PtY = new TH2F*[fnCuts];
957 fHistoTrueEtaPtY = new TH2F*[fnCuts];
958 fHistoTruePi0PtAlpha = new TH2F*[fnCuts];
959 fHistoTrueEtaPtAlpha = new TH2F*[fnCuts];
960 fHistoTruePi0PtOpenAngle = new TH2F*[fnCuts];
961 fHistoTrueEtaPtOpenAngle = new TH2F*[fnCuts];
962 fHistoTrueMotherPi0ConvPhotonEtaPhi = new TH2F*[fnCuts];
963 fHistoTrueMotherEtaConvPhotonEtaPhi = new TH2F*[fnCuts];
967 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
968 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
969 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
970 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
971 TString cutstringMeson = "NoMesonCut";
972 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
974 fMCList[iCut] = new TList();
975 fMCList[iCut]->SetName(Form("%s_%s_%s_%s MC histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
976 fMCList[iCut]->SetOwner(kTRUE);
977 fCutFolder[iCut]->Add(fMCList[iCut]);
978 fHistoMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
979 fMCList[iCut]->Add(fHistoMCHeaders[iCut]);
980 fHistoMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
981 fMCList[iCut]->Add(fHistoMCAllGammaPt[iCut]);
982 fHistoMCAllGammaEMCALAccPt[iCut] = new TH1F("MC_AllGammaEMCALAcc_Pt","MC_AllGammaEMCALAcc_Pt",250,0,25);
983 fMCList[iCut]->Add(fHistoMCAllGammaEMCALAccPt[iCut]);
984 fHistoMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
985 fMCList[iCut]->Add(fHistoMCDecayGammaPi0Pt[iCut]);
986 fHistoMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
987 fMCList[iCut]->Add(fHistoMCDecayGammaRhoPt[iCut]);
988 fHistoMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
989 fMCList[iCut]->Add(fHistoMCDecayGammaEtaPt[iCut]);
990 fHistoMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
991 fMCList[iCut]->Add(fHistoMCDecayGammaOmegaPt[iCut]);
992 fHistoMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
993 fMCList[iCut]->Add(fHistoMCDecayGammaEtapPt[iCut]);
994 fHistoMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
995 fMCList[iCut]->Add(fHistoMCDecayGammaPhiPt[iCut]);
996 fHistoMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
997 fMCList[iCut]->Add(fHistoMCDecayGammaSigmaPt[iCut]);
998 fHistoMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
999 fMCList[iCut]->Add(fHistoMCConvGammaPt[iCut]);
1001 if (fDoPhotonQA > 0){
1002 fHistoMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
1003 fMCList[iCut]->Add(fHistoMCConvGammaR[iCut]);
1004 fHistoMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",2000,-2,2);
1005 fMCList[iCut]->Add(fHistoMCConvGammaEta[iCut]);
1008 if(fDoMesonAnalysis){
1009 fHistoMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
1010 fHistoMCPi0Pt[iCut]->Sumw2();
1011 fMCList[iCut]->Add(fHistoMCPi0Pt[iCut]);
1012 fHistoMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
1013 fHistoMCPi0WOWeightPt[iCut]->Sumw2();
1014 fMCList[iCut]->Add(fHistoMCPi0WOWeightPt[iCut]);
1016 fHistoMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
1017 fHistoMCEtaPt[iCut]->Sumw2();
1018 fMCList[iCut]->Add(fHistoMCEtaPt[iCut]);
1019 fHistoMCEtaWOWeightPt[iCut] = new TH1F("MC_Eta_WOWeights_Pt","MC_Eta_WOWeights_Pt",250,0,25);
1020 fHistoMCEtaWOWeightPt[iCut]->Sumw2();
1021 fMCList[iCut]->Add(fHistoMCEtaWOWeightPt[iCut]);
1022 fHistoMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
1023 fHistoMCPi0InAccPt[iCut]->Sumw2();
1024 fMCList[iCut]->Add(fHistoMCPi0InAccPt[iCut]);
1025 fHistoMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
1026 fHistoMCEtaInAccPt[iCut]->Sumw2();
1027 fMCList[iCut]->Add(fHistoMCEtaInAccPt[iCut]);
1028 if (fDoMesonQA > 0){
1029 fHistoMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1030 fHistoMCPi0PtY[iCut]->Sumw2();
1031 SetLogBinningXTH2(fHistoMCPi0PtY[iCut]);
1032 fMCList[iCut]->Add(fHistoMCPi0PtY[iCut]);
1033 fHistoMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1034 fHistoMCEtaPtY[iCut]->Sumw2();
1035 SetLogBinningXTH2(fHistoMCEtaPtY[iCut]);
1036 fMCList[iCut]->Add(fHistoMCEtaPtY[iCut]);
1037 fHistoMCPi0PtAlpha[iCut] = new TH2F("MC_Pi0_Pt_Alpha","MC_Pi0_Pt_Alpha",150,0.03,15.,100,0,1);
1038 SetLogBinningXTH2(fHistoMCPi0PtAlpha[iCut]);
1039 fMCList[iCut]->Add(fHistoMCPi0PtAlpha[iCut]);
1040 fHistoMCEtaPtAlpha[iCut] = new TH2F("MC_Eta_Pt_Alpha","MC_Eta_Pt_Alpha",150,0.03,15.,100,0,1);
1041 SetLogBinningXTH2(fHistoMCEtaPtAlpha[iCut]);
1042 fMCList[iCut]->Add(fHistoMCEtaPtAlpha[iCut]);
1044 fHistoMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",150,0,15);
1045 fHistoMCK0sPt[iCut]->Sumw2();
1046 fMCList[iCut]->Add(fHistoMCK0sPt[iCut]);
1047 fHistoMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",150,0,15);
1048 fHistoMCK0sWOWeightPt[iCut]->Sumw2();
1049 fMCList[iCut]->Add(fHistoMCK0sWOWeightPt[iCut]);
1050 fHistoMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1051 fHistoMCK0sPtY[iCut]->Sumw2();
1052 SetLogBinningXTH2(fHistoMCK0sPtY[iCut]);
1053 fMCList[iCut]->Add(fHistoMCK0sPtY[iCut]);
1055 fHistoMCSecPi0Source[iCut] = new TH1F("MC_SecPi0_Source","MC_SecPi0_Source",5000,0.,5000);
1056 fMCList[iCut]->Add(fHistoMCSecPi0Source[iCut]);
1057 fHistoMCSecEtaSource[iCut] = new TH1F("MC_SecEta_Source","MC_SecEta_Source",5000,0,5000);
1058 fMCList[iCut]->Add(fHistoMCSecEtaSource[iCut]);
1059 fHistoMCSecPi0PtvsSource[iCut] = new TH2F("MC_SecPi0_Pt_Source","MC_SecPi0_Pt_Source",250,0.0,25.,16,-0.5,15.5);
1060 fHistoMCSecPi0PtvsSource[iCut]->Sumw2();
1061 fMCList[iCut]->Add(fHistoMCSecPi0PtvsSource[iCut]);
1062 fHistoMCSecEtaPt[iCut] = new TH1F("MC_SecEta_Pt","MC_SecEta_Pt",250,0,25);
1063 fHistoMCSecEtaPt[iCut]->Sumw2();
1064 fMCList[iCut]->Add(fHistoMCSecEtaPt[iCut]);
1068 fTrueList[iCut] = new TList();
1069 fTrueList[iCut]->SetName(Form("%s_%s_%s_%s True histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
1070 fTrueList[iCut]->SetOwner(kTRUE);
1071 fCutFolder[iCut]->Add(fTrueList[iCut]);
1073 fHistoTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
1074 fTrueList[iCut]->Add(fHistoTrueConvGammaPt[iCut]);
1076 fHistoTrueConvPi0GammaPt[iCut] = new TH1F("ESD_TrueConvPi0Gamma_Pt","ESD_TrueConvPi0Gamma_Pt",250,0,25);
1077 fTrueList[iCut]->Add(fHistoTrueConvPi0GammaPt[iCut]);
1079 fHistoCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
1080 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
1081 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
1082 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
1083 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
1084 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
1085 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
1086 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
1087 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
1088 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
1089 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
1090 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
1091 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
1092 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
1093 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
1094 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
1095 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
1096 fTrueList[iCut]->Add(fHistoCombinatorialPt[iCut]);
1097 fHistoTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
1098 fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaPt[iCut]);
1099 fHistoTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
1100 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaPt[iCut]);
1102 fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
1103 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
1104 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
1105 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
1107 fHistoTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
1108 fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaESDPtMCPt[iCut]);
1110 fHistoTrueClusGammaPt[iCut] = new TH1F("TrueClusGamma_Pt","ESD_TrueClusGamma_Pt",250,0,25);
1111 fClusterOutputList[iCut]->Add(fHistoTrueClusGammaPt[iCut]);
1112 fHistoTruePrimaryClusGammaPt[iCut] = new TH1F("TruePrimaryClusGamma_Pt","ESD_TruePrimaryClusGamma_Pt",250,0,25);
1113 fClusterOutputList[iCut]->Add(fHistoTruePrimaryClusGammaPt[iCut]);
1114 fHistoTruePrimaryClusGammaESDPtMCPt[iCut] = new TH2F("TruePrimaryClusGamma_Pt_MCPt","ESD_TruePrimaryClusGamma_MCPt",250,0,25,250,0,25);
1115 fClusterOutputList[iCut]->Add(fHistoTruePrimaryClusGammaESDPtMCPt[iCut]);
1117 if (fDoPhotonQA > 0){
1118 fHistoTrueConvGammaEta[iCut] = new TH1F("ESD_TrueConvGamma_Eta","ESD_TrueConvGamma_Eta",2000,-2,2);
1119 fTrueList[iCut]->Add(fHistoTrueConvGammaEta[iCut]);
1121 if (fDoClusterQA > 0){
1122 fHistoTrueClusUnConvGammaPt[iCut] = new TH1F("TrueClusUnConvGamma_Pt","TrueClusUnConvGamma_Pt",250,0,25);
1123 fClusterOutputList[iCut]->Add(fHistoTrueClusUnConvGammaPt[iCut]);
1124 fHistoTrueClusUnConvGammaMCPt[iCut] = new TH1F("TrueClusUnConvGamma_MCPt","TrueClusUnConvGamma_MCPt",250,0,25);
1125 fClusterOutputList[iCut]->Add(fHistoTrueClusUnConvGammaMCPt[iCut]);
1126 fHistoTrueClusElectronPt[iCut] = new TH1F("TrueClusElectron_Pt","TrueElectronGamma_Pt",250,0,25);
1127 fClusterOutputList[iCut]->Add(fHistoTrueClusElectronPt[iCut]);
1128 fHistoTrueClusConvGammaPt[iCut] = new TH1F("TrueClusConvGamma_Pt","TrueClusConvGamma_Pt",250,0,25);
1129 fClusterOutputList[iCut]->Add(fHistoTrueClusConvGammaPt[iCut]);
1130 fHistoTrueClusConvGammaMCPt[iCut] = new TH1F("TrueClusConvGamma_MCPt","TrueClusConvGamma_MCPt",250,0,25);
1131 fClusterOutputList[iCut]->Add(fHistoTrueClusConvGammaMCPt[iCut]);
1132 fHistoTrueClusConvGammaFullyPt[iCut] = new TH1F("TrueClusConvGammaFullyContained_Pt","TrueClusConvGammaFullyContained_Pt",250,0,25);
1133 fClusterOutputList[iCut]->Add(fHistoTrueClusConvGammaFullyPt[iCut]);
1134 fHistoTrueClusMergedGammaPt[iCut] = new TH1F("TrueClusMergedGamma_Pt","TrueClusMergedGamma_Pt",250,0,25);
1135 fClusterOutputList[iCut]->Add(fHistoTrueClusMergedGammaPt[iCut]);
1136 fHistoTrueClusMergedPartConvGammaPt[iCut] = new TH1F("TrueClusMergedPartConvGamma_Pt","TrueClusMergedPartConvGamma_Pt",250,0,25);
1137 fClusterOutputList[iCut]->Add(fHistoTrueClusMergedPartConvGammaPt[iCut]);
1138 fHistoTrueClusDalitzPt[iCut] = new TH1F("TrueClusDalitz_Pt","TrueClusDalitz_Pt",250,0,25);
1139 fClusterOutputList[iCut]->Add(fHistoTrueClusDalitzPt[iCut]);
1140 fHistoTrueClusDalitzMergedPt[iCut] = new TH1F("TrueClusDalitzMerged_Pt","TrueClusDalitzMerged_Pt",250,0,25);
1141 fClusterOutputList[iCut]->Add(fHistoTrueClusDalitzMergedPt[iCut]);
1142 fHistoTrueClusPhotonFromElecMotherPt[iCut] = new TH1F("TrueClusPhotonFromElecMother_Pt","TrueClusPhotonFromElecMother_Pt",250,0,25);
1143 fClusterOutputList[iCut]->Add(fHistoTrueClusPhotonFromElecMotherPt[iCut]);
1144 fHistoTrueClusShowerPt[iCut] = new TH1F("TrueClusShower_Pt","TrueClusShower_Pt",250,0,25);
1145 fClusterOutputList[iCut]->Add(fHistoTrueClusShowerPt[iCut]);
1146 fHistoTrueClusSubLeadingPt[iCut] = new TH1F("TrueClusSubleading_Pt","TrueClusSubleading_Pt",250,0,25);
1147 fClusterOutputList[iCut]->Add(fHistoTrueClusSubLeadingPt[iCut]);
1148 fHistoTrueClusNParticles[iCut] = new TH1I("TrueClusNParticles","TrueClusNParticles",20,0,20);
1149 fClusterOutputList[iCut]->Add(fHistoTrueClusNParticles[iCut]);
1150 fHistoTrueClusEMNonLeadingPt[iCut] = new TH1F("TrueClusEMNonLeading_Pt","TrueClusEMNonLeading_Pt",250,0,25);
1151 fClusterOutputList[iCut]->Add(fHistoTrueClusEMNonLeadingPt[iCut]);
1152 fHistoTrueNLabelsInClus[iCut] = new TH1F("TrueNLabelsInClus","TrueNLabelsInClus",100,-0.5,99.5);
1153 fClusterOutputList[iCut]->Add(fHistoTrueNLabelsInClus[iCut]);
1156 if(fDoMesonAnalysis){
1157 fHistoTruePi0InvMassPt[iCut] = new TH2F("ESD_TruePi0_InvMass_Pt","ESD_TruePi0_InvMass_Pt",800,0,0.8,250,0,25);
1158 fHistoTruePi0InvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2})");
1159 fHistoTruePi0InvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1160 fTrueList[iCut]->Add(fHistoTruePi0InvMassPt[iCut]);
1161 fHistoTrueEtaInvMassPt[iCut] = new TH2F("ESD_TrueEta_InvMass_Pt","ESD_TrueEta_InvMass_Pt",800,0,0.8,250,0,25);
1162 fHistoTruePi0InvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2})");
1163 fHistoTruePi0InvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1164 fTrueList[iCut]->Add(fHistoTrueEtaInvMassPt[iCut]);
1166 fHistoTruePrimaryPi0InvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0_InvMass_Pt", "ESD_TruePrimaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1167 fHistoTruePrimaryPi0InvMassPt[iCut]->SetXTitle("M_{inv,prim #pi^{0}} (GeV/c^{2})");
1168 fHistoTruePrimaryPi0InvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1169 fHistoTruePrimaryPi0InvMassPt[iCut]->Sumw2();
1170 fTrueList[iCut]->Add(fHistoTruePrimaryPi0InvMassPt[iCut]);
1172 fHistoTruePrimaryEtaInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEta_InvMass_Pt", "ESD_TruePrimaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
1173 fHistoTruePrimaryEtaInvMassPt[iCut]->SetXTitle("M_{inv,prim #eta} (GeV/c^{2})");
1174 fHistoTruePrimaryEtaInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1175 fHistoTruePrimaryEtaInvMassPt[iCut]->Sumw2();
1176 fTrueList[iCut]->Add(fHistoTruePrimaryEtaInvMassPt[iCut]);
1178 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0W0Weights_InvMass_Pt", "ESD_TruePrimaryPi0W0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1179 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]->SetXTitle("M_{inv,prim #pi^{0}} (GeV/c^{2})");
1180 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1181 fTrueList[iCut]->Add(fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]);
1183 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEtaW0Weights_InvMass_Pt", "ESD_TruePrimaryEtaW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1184 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]->SetXTitle("M_{inv,prim #eta} (GeV/c^{2})");
1185 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1186 fTrueList[iCut]->Add(fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]);
1188 fProfileTruePrimaryPi0WeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryPi0Weights_InvMass_Pt", "ESD_TruePrimaryPi0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1189 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->SetXTitle("M_{inv,prim #pi^{0}} (GeV/c^{2})");
1190 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1191 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->Sumw2();
1192 fTrueList[iCut]->Add(fProfileTruePrimaryPi0WeightsInvMassPt[iCut]);
1193 fProfileTruePrimaryEtaWeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryEtaWeights_InvMass_Pt", "ESD_TruePrimaryEtaWeights_InvMass_Pt", 800,0,0.8,250,0,25);
1194 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->SetXTitle("M_{inv,prim #eta} (GeV/c^{2})");
1195 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1196 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->Sumw2();
1197 fTrueList[iCut]->Add(fProfileTruePrimaryEtaWeightsInvMassPt[iCut]);
1199 fHistoTrueSecondaryPi0InvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0_InvMass_Pt", "ESD_TrueSecondaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1200 fHistoTrueSecondaryPi0InvMassPt[iCut]->SetXTitle("M_{inv,sec #pi^{0}} (GeV/c^{2})");
1201 fHistoTrueSecondaryPi0InvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1202 fHistoTrueSecondaryPi0InvMassPt[iCut]->Sumw2();
1203 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0InvMassPt[iCut]);
1205 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromK0s_InvMass_Pt","ESD_TrueSecondaryPi0FromK0s_InvMass_Pt",800,0,0.8,250,0,25);
1206 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0} from K^{0}_{S}} (GeV/c^{2})");
1207 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1208 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->Sumw2();
1209 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]);
1210 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromEta_InvMass_Pt","ESD_TrueSecondaryPi0FromEta_InvMass_Pt",800,0,0.8,250,0,25);
1211 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0} from #eta} (GeV/c^{2})");
1212 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1213 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]);
1214 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromLambda_InvMass_Pt","ESD_TrueSecondaryPi0FromLambda_InvMass_Pt",800,0,0.8,250,0,25);
1215 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0} from #Lambda} (GeV/c^{2})");
1216 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1217 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]);
1219 fHistoTruePrimaryPi0PhotonPairPtconv[iCut] = new TH2F("ESD_TruePrimaryPi0_InvMass_PtConv","",800,0,0.8,250,0,25);
1220 fHistoTruePrimaryPi0PhotonPairPtconv[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2})");
1221 fHistoTruePrimaryPi0PhotonPairPtconv[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
1222 fHistoTruePrimaryPi0PhotonPairPtconv[iCut]->Sumw2();
1223 fTrueList[iCut]->Add(fHistoTruePrimaryPi0PhotonPairPtconv[iCut]);
1225 fHistoTrueSecondaryPi0PhotonPairPtconv[iCut] = new TH2F("ESD_TrueSecondaryPi0_InvMass_PtConv","",800,0,0.8,250,0,25);
1226 fHistoTrueSecondaryPi0PhotonPairPtconv[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2})");
1227 fHistoTrueSecondaryPi0PhotonPairPtconv[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
1228 fHistoTrueSecondaryPi0PhotonPairPtconv[iCut]->Sumw2();
1229 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0PhotonPairPtconv[iCut]);
1231 fHistoTruePrimaryEtaPhotonPairPtconv[iCut] = new TH2F("ESD_TruePrimaryEta_InvMass_PtConv","",800,0,0.8,250,0,25);
1232 fHistoTruePrimaryEtaPhotonPairPtconv[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2})");
1233 fHistoTruePrimaryEtaPhotonPairPtconv[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
1234 fHistoTruePrimaryEtaPhotonPairPtconv[iCut]->Sumw2();
1235 fTrueList[iCut]->Add(fHistoTruePrimaryEtaPhotonPairPtconv[iCut]);
1237 fHistoTruePrimaryPi0DCPtconv[iCut] = new TH1F("ESD_TruePrimaryPi0DC_PtConv","",250,0,25);
1238 fHistoTruePrimaryPi0DCPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1239 fHistoTruePrimaryPi0DCPtconv[iCut]->Sumw2();
1240 fTrueList[iCut]->Add(fHistoTruePrimaryPi0DCPtconv[iCut]);
1242 fHistoTrueSecondaryPi0DCPtconv[iCut] = new TH1F("ESD_TrueSecondaryPi0DC_PtConv","",250,0,25);
1243 fHistoTrueSecondaryPi0DCPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1244 fHistoTrueSecondaryPi0DCPtconv[iCut]->Sumw2();
1245 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0DCPtconv[iCut]);
1247 fHistoTruePrimaryEtaDCPtconv[iCut] = new TH1F("ESD_TruePrimaryEtaDC_PtConv","",250,0,25);
1248 fHistoTruePrimaryEtaDCPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1249 fHistoTruePrimaryEtaDCPtconv[iCut]->Sumw2();
1250 fTrueList[iCut]->Add(fHistoTruePrimaryEtaDCPtconv[iCut]);
1252 fHistoTruePrimaryPi0MissingPtconv[iCut] = new TH1F("ESD_TruePrimaryPi0Missing_PtConv","",250,0,25);
1253 fHistoTruePrimaryPi0MissingPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1254 fHistoTruePrimaryPi0MissingPtconv[iCut]->Sumw2();
1255 fTrueList[iCut]->Add(fHistoTruePrimaryPi0MissingPtconv[iCut]);
1257 fHistoTrueSecondaryPi0MissingPtconv[iCut] = new TH1F("ESD_TrueSecondaryPi0Missing_PtConv","",250,0,25);
1258 fHistoTrueSecondaryPi0MissingPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1259 fHistoTrueSecondaryPi0MissingPtconv[iCut]->Sumw2();
1260 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0MissingPtconv[iCut]);
1262 fHistoTruePrimaryEtaMissingPtconv[iCut] = new TH1F("ESD_TruePrimaryEtaMissing_PtConv","",250,0,25);
1263 fHistoTruePrimaryEtaMissingPtconv[iCut]->SetXTitle("#gamma^{conv} p_{T} (GeV/c)");
1264 fHistoTruePrimaryEtaMissingPtconv[iCut]->Sumw2();
1265 fTrueList[iCut]->Add(fHistoTruePrimaryEtaMissingPtconv[iCut]);
1267 if (fDoMesonQA > 0){
1268 fHistoTruePi0CaloPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloPhoton_InvMass_Pt","ESD_TruePi0CaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1269 fHistoTruePi0CaloPhotonInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma #gamma");
1270 fHistoTruePi0CaloPhotonInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1271 fTrueList[iCut]->Add(fHistoTruePi0CaloPhotonInvMassPt[iCut]);
1273 fHistoTrueEtaCaloPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloPhoton_InvMass_Pt","ESD_TrueEtaCaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1274 fHistoTrueEtaCaloPhotonInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma #gamma");
1275 fHistoTrueEtaCaloPhotonInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1276 fTrueList[iCut]->Add(fHistoTrueEtaCaloPhotonInvMassPt[iCut]);
1278 fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhoton_InvMass_Pt","ESD_TruePi0CaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1279 fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma #gamma_{conv}");
1280 fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1281 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]);
1283 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt","ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1284 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma #gamma_{conv,matched}");
1285 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1286 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut]);
1288 fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt","ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1289 fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma #gamma_{conv}");
1290 fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1291 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]);
1293 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt","ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1294 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma #gamma_{conv,matched}");
1295 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1296 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut]);
1298 fHistoTruePi0CaloElectronInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloElectron_InvMass_Pt","ESD_TruePi0CaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1299 fHistoTruePi0CaloElectronInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma e^{#pm}");
1300 fHistoTruePi0CaloElectronInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1301 fTrueList[iCut]->Add(fHistoTruePi0CaloElectronInvMassPt[iCut]);
1302 fHistoTrueEtaCaloElectronInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloElectron_InvMass_Pt","ESD_TrueEtaCaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1303 fHistoTrueEtaCaloElectronInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma e^{#pm}");
1304 fHistoTrueEtaCaloElectronInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1305 fTrueList[iCut]->Add(fHistoTrueEtaCaloElectronInvMassPt[iCut]);
1307 fHistoTruePi0CaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedCluster_InvMass_Pt","ESD_TruePi0CaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1308 fHistoTruePi0CaloMergedClusterInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma merged cluster");
1309 fHistoTruePi0CaloMergedClusterInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1310 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterInvMassPt[iCut]);
1311 fHistoTrueEtaCaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedCluster_InvMass_Pt","ESD_TrueEtaCaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1312 fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma merged cluster");
1313 fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1314 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]);
1316 fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut] = new TH2F("ESD_TrueMotherCaloEMNonLeading_InvMass_Pt","ESD_TrueMotherCaloEMNonLeading_InvMass_Pt",800,0,0.8,250,0,25);
1317 fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut]->SetXTitle("M_{inv} (GeV/c^{2}) #gamma cluster no leading EM");
1318 fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut]->SetYTitle("#pair p_{T} (GeV/c)");
1319 fTrueList[iCut]->Add(fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut]);
1320 fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt","ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1321 fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]->SetXTitle("M_{inv,#pi^{0}} (GeV/c^{2}) #gamma merged cluster, part conv");
1322 fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]->SetYTitle("#pi^{0} p_{T} (GeV/c)");
1323 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]);
1324 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt","ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1325 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]->SetXTitle("M_{inv,#eta} (GeV/c^{2}) #gamma merged cluster, part conv");
1326 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]->SetYTitle("#eta p_{T} (GeV/c)");
1327 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]);
1329 fHistoTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1330 fHistoTruePrimaryPi0MCPtResolPt[iCut]->SetXTitle("#pi^{0} p_{T,MC} (GeV/c)");
1331 fHistoTruePrimaryPi0MCPtResolPt[iCut]->SetYTitle("#pi^{0} (p_{T,rec}-p_{T,MC})/p_{T,MC} ()");
1332 fHistoTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
1333 SetLogBinningXTH2(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1334 fTrueList[iCut]->Add(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1336 fHistoTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1337 fHistoTruePrimaryEtaMCPtResolPt[iCut]->SetXTitle("#eta p_{T,MC} (GeV/c)");
1338 fHistoTruePrimaryEtaMCPtResolPt[iCut]->SetYTitle("#eta (p_{T,rec}-p_{T,MC})/p_{T,MC} ()");
1339 fHistoTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
1340 SetLogBinningXTH2(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1341 fTrueList[iCut]->Add(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1343 fHistoTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
1344 fHistoTrueBckGGInvMassPt[iCut]->SetXTitle("M_{inv} (GeV/c^{2}) #gamma #gamma no signal");
1345 fHistoTrueBckGGInvMassPt[iCut]->SetYTitle("#pair p_{T} (GeV/c)");
1346 fTrueList[iCut]->Add(fHistoTrueBckGGInvMassPt[iCut]);
1347 fHistoTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
1348 fHistoTrueBckContInvMassPt[iCut]->SetXTitle("M_{inv} (GeV/c^{2}) contamination");
1349 fHistoTrueBckContInvMassPt[iCut]->SetYTitle("#pair p_{T} (GeV/c)");
1350 fTrueList[iCut]->Add(fHistoTrueBckContInvMassPt[iCut]);
1351 fHistoTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
1352 fHistoTrueK0sWithPi0DaughterMCPt[iCut]->SetXTitle("K^{0}_{s} p_{MC,T} (GeV/c) for K^{0}_{s} where #pi^{0} rec ");
1353 fTrueList[iCut]->Add(fHistoTrueK0sWithPi0DaughterMCPt[iCut]);
1354 fHistoTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
1355 fHistoTrueEtaWithPi0DaughterMCPt[iCut]->SetXTitle("#eta p_{MC,T} (GeV/c) for #eta where #pi^{0} rec ");
1356 fTrueList[iCut]->Add(fHistoTrueEtaWithPi0DaughterMCPt[iCut]);
1357 fHistoTrueLambdaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueLambdaWithPi0Daughter_MCPt","ESD_TrueLambdaWithPi0Daughter_MCPt",250,0,25);
1358 fHistoTrueLambdaWithPi0DaughterMCPt[iCut]->SetXTitle("#Lambda p_{MC,T} (GeV/c) for #Lambda where #pi^{0} rec ");
1359 fTrueList[iCut]->Add(fHistoTrueLambdaWithPi0DaughterMCPt[iCut]);
1361 fHistoTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1362 fHistoTruePi0PtY[iCut]->SetYTitle("Y_{#pi^{0}}");
1363 fHistoTruePi0PtY[iCut]->SetXTitle("#pi^{0} p_{T} (GeV/c)");
1364 SetLogBinningXTH2(fHistoTruePi0PtY[iCut]);
1365 fTrueList[iCut]->Add(fHistoTruePi0PtY[iCut]);
1366 fHistoTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1367 fHistoTrueEtaPtY[iCut]->SetYTitle("Y_{#eta}");
1368 fHistoTrueEtaPtY[iCut]->SetXTitle("#eta p_{T} (GeV/c)");
1369 SetLogBinningXTH2(fHistoTrueEtaPtY[iCut]);
1370 fTrueList[iCut]->Add(fHistoTrueEtaPtY[iCut]);
1371 fHistoTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",150,0.03,15.,100,0,1);
1372 fHistoTruePi0PtAlpha[iCut]->SetYTitle("#alpha_{#pi^{0}}");
1373 fHistoTruePi0PtAlpha[iCut]->SetXTitle("#pi^{0} p_{T} (GeV/c)");
1374 SetLogBinningXTH2(fHistoTruePi0PtAlpha[iCut]);
1375 fTrueList[iCut]->Add(fHistoTruePi0PtAlpha[iCut]);
1376 fHistoTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",150,0.03,15.,100,0,1);
1377 fHistoTrueEtaPtAlpha[iCut]->SetYTitle("#alpha_{#eta}");
1378 fHistoTrueEtaPtAlpha[iCut]->SetXTitle("#eta p_{T} (GeV/c)");
1379 SetLogBinningXTH2(fHistoTrueEtaPtAlpha[iCut]);
1380 fTrueList[iCut]->Add(fHistoTrueEtaPtAlpha[iCut]);
1382 fHistoTruePi0PtOpenAngle[iCut] = new TH2F("ESD_TruePi0_Pt_OpenAngle","ESD_TruePi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1383 fHistoTruePi0PtOpenAngle[iCut]->SetYTitle("#theta_{#pi^{0}}");
1384 fHistoTruePi0PtOpenAngle[iCut]->SetXTitle("#pi^{0} p_{T} (GeV/c)");
1385 SetLogBinningXTH2(fHistoTruePi0PtOpenAngle[iCut]);
1386 fTrueList[iCut]->Add(fHistoTruePi0PtOpenAngle[iCut]);
1387 fHistoTrueEtaPtOpenAngle[iCut] = new TH2F("ESD_TrueEta_Pt_OpenAngle","ESD_TrueEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1388 fHistoTrueEtaPtOpenAngle[iCut]->SetYTitle("#theta_{#eta}");
1389 fHistoTrueEtaPtOpenAngle[iCut]->SetXTitle("#eta p_{T} (GeV/c)");
1390 SetLogBinningXTH2(fHistoTrueEtaPtOpenAngle[iCut]);
1391 fTrueList[iCut]->Add(fHistoTrueEtaPtOpenAngle[iCut]);
1393 fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut] = new TH2F("ESD_TrueMotherPi0ConvPhoton_Eta_Phi","conv photons for true #pi^{0}",600,0,2*TMath::Pi(),200,-1,1);
1394 fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut]->SetXTitle("#phi_{#gamma_{conv}} (rad)");
1395 fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut]->SetYTitle("#eta_{#gamma_{conv}}");
1396 fTrueList[iCut]->Add(fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut]);
1397 fHistoTrueMotherEtaConvPhotonEtaPhi[iCut] = new TH2F("ESD_TrueMotherEtaConvPhoton_Eta_Phi","conv photons for true #eta",600,0,2*TMath::Pi(),200,-1,1);
1398 fHistoTrueMotherEtaConvPhotonEtaPhi[iCut]->SetXTitle("#phi_{#gamma_{conv}} (rad)");
1399 fHistoTrueMotherEtaConvPhotonEtaPhi[iCut]->SetYTitle("#eta_{#gamma_{conv}}");
1400 fTrueList[iCut]->Add(fHistoTrueMotherEtaConvPhotonEtaPhi[iCut]);
1407 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1408 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1411 if((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())
1412 if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1413 fOutputContainer->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1415 if((AliConvEventCuts*)fV0Reader->GetEventCuts())
1416 if(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms())
1417 fOutputContainer->Add(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms());
1420 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1421 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))) continue;
1422 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms()){
1423 fCutFolder[iCut]->Add(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms());
1425 if(!((AliConversionPhotonCuts*)fCutArray->At(iCut))) continue;
1426 if(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms()){
1427 fCutFolder[iCut]->Add(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms());
1429 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))) continue;
1430 if(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms()){
1431 fCutFolder[iCut]->Add(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms());
1433 if(fDoMesonAnalysis){
1434 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
1435 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
1436 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
1440 PostData(1, fOutputContainer);
1442 //_____________________________________________________________________________
1443 Bool_t AliAnalysisTaskGammaConvCalo::Notify()
1445 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1446 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))->GetDoEtaShift()){
1447 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1448 continue; // No Eta Shift requested, continue
1450 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1451 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
1452 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1453 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1457 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
1458 (((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber()).Data(),((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift());
1459 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1460 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1466 //_____________________________________________________________________________
1467 void AliAnalysisTaskGammaConvCalo::UserExec(Option_t *)
1470 // Called for each event
1472 Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
1473 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1474 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1475 fHistoNEvents[iCut]->Fill(eventQuality);
1480 if(fIsMC) fMCEvent = MCEvent();
1481 if(fMCEvent == NULL) fIsMC = kFALSE;
1483 fInputEvent = InputEvent();
1485 if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
1486 fMCStack = fMCEvent->Stack();
1487 if(fMCStack == NULL) fIsMC = kFALSE;
1490 if(fInputEvent->IsA()==AliAODEvent::Class()){
1491 fInputEvent->InitMagneticField();
1494 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
1496 // ------------------- BeginEvent ----------------------------
1498 AliEventplane *EventPlane = fInputEvent->GetEventplane();
1499 if(fIsHeavyIon ==1)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
1500 else fEventPlaneAngle=0.0;
1502 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1503 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
1504 fV0Reader->RelabelAODs(kTRUE);
1508 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1512 Bool_t isRunningEMCALrelAna = kFALSE;
1513 if (((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->GetClusterType() == 1) isRunningEMCALrelAna = kTRUE;
1515 Int_t eventNotAccepted = ((AliConvEventCuts*)fEventCutArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon,isRunningEMCALrelAna);
1517 if(eventNotAccepted){
1518 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1519 fHistoNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1523 if(eventQuality != 0){// Event Not Accepted
1524 //cout << "event rejected due to: " <<eventQuality << endl;
1525 fHistoNEvents[iCut]->Fill(eventQuality);
1529 fHistoNEvents[iCut]->Fill(eventQuality); // Should be 0 here
1530 fHistoNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
1531 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->IsHeavyIon() == 2) fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
1532 else fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1535 // Process MC Particle
1536 fStringRecTruePi0s[iCut] = "";
1537 fStringRecTrueEtas[iCut] = "";
1538 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection() != 0){
1539 if(fInputEvent->IsA()==AliESDEvent::Class()){
1540 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1541 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1544 else if(fInputEvent->IsA()==AliAODEvent::Class()){
1545 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1546 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1550 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader()){
1551 for(Int_t i = 0;i<(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
1552 TString nameBin= fHistoMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
1553 if (nameBin.CompareTo("")== 0){
1554 TString nameHeader = ((TObjString*)((TList*)((AliConvEventCuts*)fEventCutArray->At(iCut))
1555 ->GetAcceptedHeader())->At(i))->GetString();
1556 fHistoMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
1563 if(fInputEvent->IsA()==AliESDEvent::Class())
1564 ProcessMCParticles();
1565 if(fInputEvent->IsA()==AliAODEvent::Class())
1566 ProcessAODMCParticles();
1569 // 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)
1570 ProcessClusters(); // process calo clusters
1571 ProcessPhotonCandidates(); // Process this cuts gammas
1573 fHistoNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
1574 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks(),fGammaCandidates->GetEntries());
1575 if(fDoMesonAnalysis){ // Meson Analysis
1576 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1577 fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
1578 fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
1579 fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
1580 fUnsmearedE = new Double_t[fGammaCandidates->GetEntries()];
1582 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1583 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
1584 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
1585 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
1586 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
1587 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
1591 CalculatePi0Candidates(); // Combine Gammas from conversion and from calo
1593 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1594 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1595 CalculateBackground(); // Combinatorial Background
1596 UpdateEventByEventData(); // Store Event for mixed Events
1599 CalculateBackgroundRP(); // Combinatorial Background
1600 fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
1601 fBGClusHandlerRP[iCut]->AddEvent(fClusterCandidates,fInputEvent); // Store Event for mixed Events
1605 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class()){
1606 ProcessConversionPhotonsForMissingTagsAOD(); //Count missing tags
1607 } else if (fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
1608 ProcessConversionPhotonsForMissingTags(); //Count missing tags
1611 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1612 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1613 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1614 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1615 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1616 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
1618 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1619 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1620 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1621 delete[] fUnsmearedE; fUnsmearedE = 0x0;
1625 fGammaCandidates->Clear(); // delete this cuts good gammas
1626 fClusterCandidates->Clear(); // delete cluster candidates
1629 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1630 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
1631 fV0Reader->RelabelAODs(kFALSE);
1634 PostData(1, fOutputContainer);
1637 //________________________________________________________________________
1638 void AliAnalysisTaskGammaConvCalo::ProcessClusters()
1642 nclus = fInputEvent->GetNumberOfCaloClusters();
1644 // cout << nclus << endl;
1646 if(nclus == 0) return;
1649 Double_t vertex[3] = {0};
1650 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1652 // Loop over EMCal clusters
1653 for(Long_t i = 0; i < nclus; i++){
1655 AliVCluster* clus = NULL;
1656 clus = fInputEvent->GetCaloCluster(i);
1657 if (!clus) continue;
1658 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelected(clus,fInputEvent,fIsMC)) continue;
1659 // TLorentzvector with cluster
1660 TLorentzVector clusterVector;
1661 clus->GetMomentum(clusterVector,vertex);
1663 TLorentzVector* tmpvec = new TLorentzVector();
1664 tmpvec->SetPxPyPzE(clusterVector.Px(),clusterVector.Py(),clusterVector.Pz(),clusterVector.E());
1666 // convert to AODConversionPhoton
1667 AliAODConversionPhoton *PhotonCandidate=new AliAODConversionPhoton(tmpvec);
1668 if(!PhotonCandidate) continue;
1670 // Flag Photon as CaloPhoton
1671 PhotonCandidate->SetIsCaloPhoton();
1672 PhotonCandidate->SetCaloClusterRef(i);
1675 Int_t* mclabelsCluster = clus->GetLabels();
1676 PhotonCandidate->SetNCaloPhotonMCLabels(clus->GetNLabels());
1677 // cout << clus->GetNLabels() << endl;
1678 if (clus->GetNLabels()>0){
1679 for (Int_t k =0; k< (Int_t)clus->GetNLabels(); k++){
1680 if (k< 20)PhotonCandidate->SetCaloPhotonMCLabel(k,mclabelsCluster[k]);
1681 // Int_t pdgCode = fMCStack->Particle(mclabelsCluster[k])->GetPdgCode();
1682 // cout << "label " << k << "\t" << mclabelsCluster[k] << " pdg code: " << pdgCode << endl;
1687 fIsFromMBHeader = kTRUE;
1688 fIsOverlappingWithOtherHeader = kFALSE;
1689 // test whether largest contribution to cluster orginates in added signals
1690 if (fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetCaloPhotonMCLabel(0), fMCStack, fInputEvent) == 0) fIsFromMBHeader = kFALSE;
1692 if (clus->GetNLabels()>1){
1693 Int_t* mclabelsCluster = clus->GetLabels();
1694 for (Int_t l = 1; l < (Int_t)clus->GetNLabels(); l++ ){
1695 if (((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(mclabelsCluster[l], fMCStack, fInputEvent) == 0) fIsOverlappingWithOtherHeader = kTRUE;
1700 if (fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
1701 fHistoClusGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1702 fClusterCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1704 if (fIsFromMBHeader && fIsOverlappingWithOtherHeader) fHistoClusOverlapHeadersGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1707 if(fInputEvent->IsA()==AliESDEvent::Class()){
1708 ProcessTrueClusterCandidates(PhotonCandidate);
1710 ProcessTrueClusterCandidatesAOD(PhotonCandidate);
1719 //________________________________________________________________________
1720 void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1723 TParticle *Photon = NULL;
1724 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1725 fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1727 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0)Photon = fMCStack->Particle(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1731 // cout << "no photon" << endl;
1735 TruePhotonCandidate->SetCaloPhotonMCFlags(fMCStack);
1738 if(fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
1739 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1740 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1741 if (fDoClusterQA > 0){
1742 if (TruePhotonCandidate->IsLargestComponentPhoton()){
1743 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1744 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1746 if (TruePhotonCandidate->IsLargestComponentElectron())
1747 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1748 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1749 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1750 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(Photon->GetMother(0)))->Pt());
1752 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1753 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1754 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1755 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1756 if (TruePhotonCandidate->IsMergedPartConv())
1757 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1758 if (TruePhotonCandidate->IsDalitz())
1759 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1760 if (TruePhotonCandidate->IsDalitzMerged())
1761 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1762 if (TruePhotonCandidate->IsPhotonWithElecMother())
1763 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1764 if (TruePhotonCandidate->IsShower())
1765 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1766 if (TruePhotonCandidate->IsSubLeadingEM())
1767 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1768 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1772 if(Photon->GetMother(0) <= fMCStack->GetNprimary()){
1773 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1774 if(fIsFromMBHeader){
1775 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1776 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1783 //________________________________________________________________________
1784 void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1786 AliAODMCParticle *Photon = NULL;
1787 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1788 if (AODMCTrackArray){
1789 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1790 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0) Photon = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1793 AliInfo("AODMCTrackArray could not be loaded");
1798 // cout << "no photon" << endl;
1801 TruePhotonCandidate->SetCaloPhotonMCFlagsAOD(fInputEvent);
1802 fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1804 if(fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
1805 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1806 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1807 if (fDoClusterQA > 0){
1808 if (TruePhotonCandidate->IsLargestComponentPhoton()) {
1809 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1810 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1812 if (TruePhotonCandidate->IsLargestComponentElectron())
1813 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1814 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()) {
1815 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1816 AliAODMCParticle *Mother = (AliAODMCParticle*) AODMCTrackArray->At(Photon->GetMother());
1817 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(Mother->Pt());
1819 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1820 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1821 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1822 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1823 if (TruePhotonCandidate->IsMergedPartConv())
1824 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1825 if (TruePhotonCandidate->IsDalitz())
1826 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1827 if (TruePhotonCandidate->IsDalitzMerged())
1828 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1829 if (TruePhotonCandidate->IsPhotonWithElecMother())
1830 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1831 if (TruePhotonCandidate->IsShower())
1832 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1833 if (TruePhotonCandidate->IsSubLeadingEM())
1834 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1835 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1840 if(fIsFromMBHeader){
1841 fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1842 // if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1845 if(Photon->IsPrimary()){
1846 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1847 if(fIsFromMBHeader){
1848 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1849 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1854 //________________________________________________________________________
1855 void AliAnalysisTaskGammaConvCalo::ProcessPhotonCandidates()
1858 TList *GammaCandidatesStepOne = new TList();
1859 TList *GammaCandidatesStepTwo = new TList();
1860 // Loop over Photon Candidates allocated by ReaderV1
1861 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1862 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1863 if(!PhotonCandidate) continue;
1864 fIsFromMBHeader = kTRUE;
1865 if(fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1866 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1867 if(isPosFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1868 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1869 if(isNegFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1870 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1873 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
1874 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(PhotonCandidate->GetPhotonPhi(),fEventPlaneAngle)) continue;
1875 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1876 !((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1877 fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1879 if(fIsFromMBHeader){
1880 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1881 if (fDoPhotonQA > 0){
1882 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1883 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1887 if(fInputEvent->IsA()==AliESDEvent::Class())
1888 ProcessTruePhotonCandidates(PhotonCandidate);
1889 if(fInputEvent->IsA()==AliAODEvent::Class())
1890 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1892 if (fIsFromMBHeader && fDoPhotonQA == 2){
1893 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1894 fPtGamma = PhotonCandidate->Pt();
1895 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1896 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1897 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1898 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1899 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1900 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1901 fPtGamma = PhotonCandidate->Pt();
1902 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1903 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1904 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1905 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1906 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1909 } else if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1910 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1912 GammaCandidatesStepOne->Add(PhotonCandidate);
1913 } else if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1914 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1915 GammaCandidatesStepTwo->Add(PhotonCandidate);
1918 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
1919 for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1920 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1921 if(!PhotonCandidate) continue;
1922 fIsFromMBHeader = kTRUE;
1923 if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1924 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1925 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1926 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1928 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1929 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1930 fGammaCandidates->Add(PhotonCandidate);
1931 if(fIsFromMBHeader){
1932 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1933 if (fDoPhotonQA > 0){
1934 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1935 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1940 if(fInputEvent->IsA()==AliESDEvent::Class())
1941 ProcessTruePhotonCandidates(PhotonCandidate);
1942 if(fInputEvent->IsA()==AliAODEvent::Class())
1943 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1944 } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1946 if (fIsFromMBHeader && fDoPhotonQA == 2){
1947 if (fIsHeavyIon ==1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1948 fPtGamma = PhotonCandidate->Pt();
1949 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1950 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1951 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1952 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1953 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1954 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1955 fPtGamma = PhotonCandidate->Pt();
1956 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1957 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1958 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1959 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1960 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1965 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1966 for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1967 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1968 if(!PhotonCandidate) continue;
1969 fIsFromMBHeader = kTRUE;
1970 if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1971 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1972 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1973 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1975 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
1976 fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1977 if(fIsFromMBHeader){
1978 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1979 if (fDoPhotonQA > 0){
1980 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1981 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1985 if(fInputEvent->IsA()==AliESDEvent::Class())
1986 ProcessTruePhotonCandidates(PhotonCandidate);
1987 if(fInputEvent->IsA()==AliAODEvent::Class())
1988 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1990 if (fIsFromMBHeader){
1991 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1992 fPtGamma = PhotonCandidate->Pt();
1993 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1994 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1995 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1996 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1997 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1998 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1999 fPtGamma = PhotonCandidate->Pt();
2000 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
2001 fRConvPhoton = PhotonCandidate->GetConversionRadius();
2002 fEtaPhoton = PhotonCandidate->GetPhotonEta();
2003 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
2004 fTreeConvGammaPtDcazCat[fiCut]->Fill();
2010 delete GammaCandidatesStepOne;
2011 GammaCandidatesStepOne = 0x0;
2012 delete GammaCandidatesStepTwo;
2013 GammaCandidatesStepTwo = 0x0;
2017 //________________________________________________________________________
2018 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
2021 Double_t magField = fInputEvent->GetMagneticField();
2022 if( magField < 0.0 ){
2029 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2030 if (AODMCTrackArray == NULL) return;
2031 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
2032 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
2033 fCharPhotonMCInfo = 0;
2035 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
2036 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
2038 if(posDaughter->GetMother() != negDaughter->GetMother()){
2039 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2040 fCharPhotonMCInfo = 1;
2043 else if(posDaughter->GetMother() == -1){
2044 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2045 fCharPhotonMCInfo = 1;
2049 if(pdgCode[0]!=11 || pdgCode[1]!=11){
2050 fCharPhotonMCInfo = 1;
2051 return; //One Particle is not a electron
2054 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
2055 fCharPhotonMCInfo = 1;
2056 return; // Same Charge
2059 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
2060 if(Photon->GetPdgCode() != 22){
2061 fCharPhotonMCInfo = 1;
2062 return; // Mother is no Photon
2065 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
2066 fCharPhotonMCInfo = 1;
2067 return;// check if the daughters come from a conversion
2069 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
2074 if(fIsFromMBHeader){
2075 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2076 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
2078 if(Photon->IsPrimary()){
2079 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
2080 if(fIsFromMBHeader){
2081 fCharPhotonMCInfo = 6;
2082 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2083 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
2085 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
2087 if(fIsFromMBHeader){
2088 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2089 fCharPhotonMCInfo = 2;
2090 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
2091 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
2092 fCharPhotonMCInfo = 5;
2093 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2095 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
2096 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
2097 fCharPhotonMCInfo = 4;
2098 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2100 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
2101 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
2102 fCharPhotonMCInfo = 3;
2106 TruePhotonCandidate->SetIsTrueConvertedPhoton();
2109 //________________________________________________________________________
2110 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
2113 Double_t magField = fInputEvent->GetMagneticField();
2114 if( magField < 0.0 ){
2121 // Process True Photons
2122 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
2123 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
2124 fCharPhotonMCInfo = 0;
2126 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
2127 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
2128 fCharPhotonMCInfo = 1;
2129 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
2130 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2133 else if(posDaughter->GetMother(0) == -1){
2134 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2138 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
2140 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
2142 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
2144 if(Photon->GetPdgCode() != 22){
2145 return; // Mother is no Photon
2148 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
2151 if(fIsFromMBHeader){
2152 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2153 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
2155 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
2156 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
2157 if(fIsFromMBHeader){
2158 fCharPhotonMCInfo = 6;
2159 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2160 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
2162 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
2164 if(fIsFromMBHeader){
2165 fCharPhotonMCInfo = 2;
2166 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2167 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2168 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
2169 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2170 fCharPhotonMCInfo = 5;
2172 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2173 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
2174 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2175 fCharPhotonMCInfo = 4;
2177 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2178 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
2179 fCharPhotonMCInfo = 3;
2183 TruePhotonCandidate->SetIsTrueConvertedPhoton();
2186 //________________________________________________________________________
2187 void AliAnalysisTaskGammaConvCalo::ProcessAODMCParticles()
2190 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2191 if (AODMCTrackArray == NULL) return;
2193 // Loop over all primary MC particle
2194 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
2196 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
2197 if (!particle) continue;
2198 if (!particle->IsPrimary()) continue;
2200 Int_t isMCFromMBHeader = -1;
2201 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2202 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2203 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2206 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2207 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
2208 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2209 if (abs(particle->Eta()) < 0.66 ){
2210 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2212 if(particle->GetMother() >-1){ // Meson Decay Gamma
2213 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
2215 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2218 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2221 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2224 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2227 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2230 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2233 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2238 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
2240 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
2241 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
2242 if(!tmpDaughter) continue;
2243 if(abs(tmpDaughter->GetPdgCode()) == 11){
2244 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
2247 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2248 if (fDoPhotonQA > 0){
2249 fHistoMCConvGammaR[fiCut]->Fill(rConv);
2250 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2253 // Converted MC Gamma
2254 if(fDoMesonAnalysis){
2255 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2256 Double_t mesonY = 10.;
2257 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2258 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2260 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2262 Float_t weightedK0s= 1;
2263 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2264 if (particle->Pt()>0.005){
2265 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2266 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2269 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2270 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2271 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2273 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2274 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2275 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
2276 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
2277 Float_t weighted= 1;
2278 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2279 if (particle->Pt()>0.005){
2280 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2281 // if(particle->GetPdgCode() == 221){
2282 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2286 Double_t mesonY = 10.;
2287 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2288 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2290 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2293 Double_t alpha = -1;
2294 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2295 alpha = TMath::Abs((daughter0->E() - daughter1->E()))/(daughter0->E() + daughter1->E());
2299 if(particle->GetPdgCode() == 111){
2300 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2301 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2302 if (fDoMesonQA > 0){
2303 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2304 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2306 } else if(particle->GetPdgCode() == 221){
2307 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2308 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2309 if (fDoMesonQA > 0){
2310 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2311 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2315 // Check the acceptance for both gammas
2316 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
2317 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) &&
2318 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2319 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2321 if(particle->GetPdgCode() == 111){
2322 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2323 } else if(particle->GetPdgCode() == 221){
2324 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2332 //________________________________________________________________________
2333 void AliAnalysisTaskGammaConvCalo::ProcessMCParticles()
2335 // Loop over all primary MC particle
2336 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2337 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2338 if (!particle) continue;
2340 Int_t isMCFromMBHeader = -1;
2341 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2342 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2343 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2346 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2347 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
2348 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2349 if (abs(particle->Eta()) < 0.66 ){
2350 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2353 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
2354 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
2356 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2359 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2362 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2365 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2368 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2371 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2374 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2379 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
2380 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2381 if (fDoPhotonQA > 0){
2382 fHistoMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
2383 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2385 } // Converted MC Gamma
2386 if(fDoMesonAnalysis){
2387 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2388 Double_t mesonY = 10.;
2389 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2390 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2392 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2394 Float_t weightedK0s= 1;
2395 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2396 if (particle->Pt()>0.005){
2397 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2398 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2401 if (fMCStack->IsPhysicalPrimary(i)){
2402 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2403 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2404 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2407 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2408 ->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2409 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
2410 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
2412 Float_t weighted= 1;
2413 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2414 if (particle->Pt()>0.005){
2415 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2416 // if(particle->GetPdgCode() == 221){
2417 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2421 Double_t mesonY = 10.;
2422 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2423 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2425 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2428 Double_t alpha = -1;
2429 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2430 alpha = TMath::Abs((daughter0->Energy() - daughter1->Energy()))/(daughter0->Energy() + daughter1->Energy());
2433 if(particle->GetPdgCode() == 111){
2434 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2435 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2436 if (fDoMesonQA > 0){
2437 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2438 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2440 } else if(particle->GetPdgCode() == 221){
2441 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2442 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2443 if (fDoMesonQA > 0){
2444 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2445 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2449 // Check the acceptance for both gammas
2450 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
2451 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) &&
2452 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2453 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2455 if(particle->GetPdgCode() == 111){
2456 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2457 } else if(particle->GetPdgCode() == 221){
2458 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2466 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
2467 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2468 if (!particle) continue;
2470 Int_t isMCFromMBHeader = -1;
2471 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2472 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2473 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2476 if(fDoMesonAnalysis){
2477 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2478 Float_t weighted= 1;
2479 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2480 if (particle->Pt()>0.005){
2481 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2482 // if(particle->GetPdgCode() == 221){
2483 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2488 if(particle->GetPdgCode() == 111){
2489 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2490 Int_t source = GetSourceClassification(111,pdgCode);
2491 fHistoMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
2492 fHistoMCSecPi0Source[fiCut]->Fill(pdgCode);
2493 } else if(particle->GetPdgCode() == 221){
2494 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2495 fHistoMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2496 fHistoMCSecEtaSource[fiCut]->Fill(pdgCode);
2504 //________________________________________________________________________
2505 void AliAnalysisTaskGammaConvCalo::CalculatePi0Candidates(){
2507 // Conversion Gammas
2508 if(fGammaCandidates->GetEntries()>0){
2511 Double_t vertex[3] = {0};
2512 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
2514 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2515 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2516 if (gamma0==NULL) continue;
2518 for(Int_t secondGammaIndex=0;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
2519 Bool_t matched = kFALSE;
2520 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2521 if (gamma1==NULL) continue;
2523 if (gamma1->GetIsCaloPhoton()){
2524 AliVCluster* cluster = fInputEvent->GetCaloCluster(gamma1->GetCaloClusterRef());
2525 matched = ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->MatchConvPhotonToCluster(gamma0,cluster, fInputEvent );
2528 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
2529 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
2533 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2535 fHistoMotherMatchedInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2537 fHistoMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2539 // fill new histograms
2541 fHistoPhotonPairPtconv[fiCut]->Fill(pi0cand->M(),gamma0->Pt());
2542 if(pi0cand->GetAlpha()<0.1)
2543 fHistoMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
2545 if (fDoMesonQA > 0){
2546 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
2547 fHistoMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2548 fHistoMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2549 fHistoMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2550 fHistoMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
2552 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
2553 fHistoMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2554 fHistoMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2555 fHistoMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2556 fHistoMotherEtaConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
2559 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
2563 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
2564 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2565 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2566 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2568 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2571 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2572 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2573 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2575 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2578 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
2579 fSparseMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2584 if(fInputEvent->IsA()==AliESDEvent::Class())
2585 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1, matched);
2586 if(fInputEvent->IsA()==AliAODEvent::Class())
2587 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1, matched);
2590 if (fDoMesonQA == 1){
2591 fHistoMotherInvMassECalib[fiCut]->Fill(pi0cand->M(),gamma1->E());
2592 if(pi0cand->GetAlpha()<0.1)
2593 fHistoMotherInvMassECalibalpha[fiCut]->Fill(pi0cand->M(),gamma1->E());
2603 //______________________________________________________________________
2604 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2606 // Process True Mesons
2607 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2608 Bool_t isTruePi0 = kFALSE;
2609 Bool_t isTrueEta = kFALSE;
2610 Int_t gamma0MCLabel = -1;
2611 Int_t gamma0MotherLabel = -1;
2612 if (TrueGammaCandidate0->IsTrueConvertedPhoton()){
2613 gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(fMCStack);
2614 TParticle * gammaMC0 = (TParticle*)fMCStack->Particle(gamma0MCLabel);
2615 gamma0MotherLabel=gammaMC0->GetFirstMother();
2618 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
2620 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2621 Int_t gamma1MotherLabel = -1;
2624 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2625 // Daughters Gamma 1
2626 TParticle * gammaMC1 = (TParticle*)fMCStack->Particle(gamma1MCLabel);
2627 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2628 // get mother of interest (pi0 or eta)
2629 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2630 gamma1MotherLabel=gammaMC1->GetMother(0);
2631 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2632 if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=fMCStack->Particle(gammaMC1->GetMother(0))->GetMother(0);
2633 else gamma1MotherLabel=gammaMC1->GetMother(0);
2636 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2640 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2641 if(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
2644 if(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
2649 if(isTruePi0 || isTrueEta){// True Pion or Eta
2651 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2652 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2654 if (fDoMesonQA > 0){
2655 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2656 if(isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2657 if(isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2659 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched){
2660 if(isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2661 if(isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2663 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() ){
2664 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2665 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2666 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0){
2667 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2669 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta){
2670 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2673 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2674 if (isTruePi0 )fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2675 if (isTrueEta )fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2677 if (TrueGammaCandidate1->IsMergedPartConv() && !matched){
2678 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2679 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2683 if (fDoMesonQA > 0){
2685 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2686 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2687 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2688 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2689 fHistoTrueMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2691 } else if (isTrueEta){
2692 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2693 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2694 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2695 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2696 fHistoTrueMotherEtaConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2701 if(gamma0MotherLabel >= fMCStack->GetNprimary()){ // Secondary Meson
2702 Int_t secMotherLabel = ((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetMother(0);
2703 Float_t weightedSec= 1;
2704 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && fMCStack->Particle(secMotherLabel)->GetPdgCode()==310){
2705 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
2706 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2709 fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2710 fHistoTrueSecondaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weightedSec);
2711 if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2712 fHistoTrueSecondaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weightedSec);
2715 if (secMotherLabel >-1){
2716 if(fMCStack->Particle(secMotherLabel)->GetPdgCode()==310 && isTruePi0 ){
2717 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2718 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(fMCStack->Particle(secMotherLabel)->Pt());
2720 if(fMCStack->Particle(secMotherLabel)->GetPdgCode()==221 && isTruePi0){
2721 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2722 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(fMCStack->Particle(secMotherLabel)->Pt());
2724 if(fMCStack->Particle(secMotherLabel)->GetPdgCode()==3122 && isTruePi0){
2725 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2726 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(fMCStack->Particle(secMotherLabel)->Pt());
2729 } else { // Only primary pi0 for efficiency calculation
2730 Float_t weighted= 1;
2731 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
2732 if (((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
2733 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
2734 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2738 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2739 fHistoTruePrimaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2740 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2741 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2742 if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2743 fHistoTruePrimaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2746 } else if (isTrueEta) {
2747 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2748 fHistoTruePrimaryEtaPhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2749 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2750 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2751 if(CheckIfContainedInString(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
2752 fHistoTruePrimaryEtaDCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2756 if (fDoMesonQA > 0){
2757 if(isTruePi0){ // Only primary pi0 for resolution
2758 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2760 if (isTrueEta){ // Only primary eta for resolution
2761 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2766 } else if(!isTruePi0 && !isTrueEta){ // Background
2767 if (fDoMesonQA > 0){
2768 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2769 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2770 } else { // No photon or without mother
2771 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2775 if (isTrueEta && !matched){
2776 fStringRecTrueEtas[fiCut].Append(Form("%i,",gamma0MotherLabel));
2778 if (isTruePi0 && !matched){
2779 fStringRecTruePi0s[fiCut].Append(Form("%i,",gamma0MotherLabel));
2784 //______________________________________________________________________
2785 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2788 // Process True Mesons
2789 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2790 if (AODMCTrackArray == NULL) return;
2791 Bool_t isTruePi0 = kFALSE;
2792 Bool_t isTrueEta = kFALSE;
2794 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
2795 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
2797 Int_t gamma0MCLabel = -1;
2798 Int_t gamma0MotherLabel = -1;
2799 if(!positiveMC||!negativeMC)
2802 if (TrueGammaCandidate0->IsTrueConvertedPhoton()){
2803 gamma0MCLabel = positiveMC->GetMother();
2804 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2805 gamma0MotherLabel=gammaMC0->GetMother();
2808 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
2809 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2810 Int_t gamma1MotherLabel = -1;
2813 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2814 // Daughters Gamma 1
2815 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2816 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2817 // get mother of interest (pi0 or eta)
2818 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2819 gamma1MotherLabel=gammaMC1->GetMother();
2820 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2821 if (TrueGammaCandidate1->IsConversion()){
2822 AliAODMCParticle * gammaGrandMotherMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC1->GetMother()));
2823 gamma1MotherLabel=gammaGrandMotherMC1->GetMother();
2824 } else gamma1MotherLabel=gammaMC1->GetMother();
2827 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2831 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2832 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2835 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2840 if(isTruePi0 || isTrueEta){// True Pion or Eta
2842 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2843 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2845 if (fDoMesonQA > 0){
2846 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2847 if (isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2848 if (isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2850 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched) {
2851 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2852 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2854 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()){
2855 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2856 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2857 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0)
2858 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2859 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta)
2860 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2862 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2863 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2864 if (isTrueEta) fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2866 if (TrueGammaCandidate1->IsMergedPartConv() && !matched) {
2867 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2868 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2873 if (fDoMesonQA > 0){
2875 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2876 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2877 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2878 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2879 fHistoTrueMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2881 } else if (isTrueEta){
2882 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2883 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2884 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2885 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2886 fHistoTrueMotherEtaConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2890 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2891 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2892 Float_t weightedSec= 1;
2893 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2894 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
2895 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2898 fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2899 fHistoTrueSecondaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weightedSec);
2900 if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2901 fHistoTrueSecondaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weightedSec);
2904 if (secMotherLabel >-1){
2905 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310 && isTruePi0){
2906 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2907 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2909 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221 && isTruePi0){
2910 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2911 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2913 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122 && isTruePi0){
2914 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2915 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2918 } else{ // Only primary pi0 for efficiency calculation
2919 Float_t weighted= 1;
2920 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2921 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2922 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2923 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2927 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2928 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2929 fHistoTruePrimaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2930 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2931 if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2932 fHistoTruePrimaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2934 } else if (isTrueEta){
2935 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2936 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2937 fHistoTruePrimaryEtaPhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2938 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2939 if(CheckIfContainedInString(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
2940 fHistoTruePrimaryEtaDCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2943 if (fDoMesonQA > 0){
2944 if(isTruePi0){ // Only primary pi0 for resolution
2945 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2946 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2949 if (isTrueEta){ // Only primary eta for resolution
2950 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2951 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2956 } else if(!isTruePi0 && !isTrueEta) { // Background
2957 if (fDoMesonQA > 0){
2958 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2959 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2960 } else { // No photon or without mother
2961 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2966 if (isTrueEta && !matched){
2967 fStringRecTrueEtas[fiCut].Append(Form("%i,",gamma0MotherLabel));
2969 if (isTruePi0 && !matched){
2970 fStringRecTruePi0s[fiCut].Append(Form("%i,",gamma0MotherLabel));
2977 //________________________________________________________________________
2978 void AliAnalysisTaskGammaConvCalo::CalculateBackground(){
2980 Int_t zbin= fBGClusHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2983 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2984 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2986 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2989 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2990 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2991 for(Int_t nEventsInBG=0;nEventsInBG<fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2992 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2993 if(fMoveParticleAccordingToVertex == kTRUE || ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2994 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2997 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2998 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2999 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
3000 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
3001 if(fMoveParticleAccordingToVertex == kTRUE){
3003 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
3006 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
3008 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
3012 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
3013 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3014 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3015 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
3016 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
3017 fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate->M(),currentEventGoodV0.Pt());
3018 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
3019 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
3021 delete backgroundCandidate;
3022 backgroundCandidate = 0x0;
3027 for(Int_t nEventsInBG=0;nEventsInBG <fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
3028 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
3029 if(previousEventV0s){
3030 if(fMoveParticleAccordingToVertex == kTRUE || ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0 ){
3031 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
3033 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3034 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3035 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
3037 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
3039 if(fMoveParticleAccordingToVertex == kTRUE){
3041 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
3044 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
3046 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
3050 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
3051 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3052 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
3053 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
3054 fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate->M(),currentEventGoodV0.Pt());
3055 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
3056 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
3058 delete backgroundCandidate;
3059 backgroundCandidate = 0x0;
3067 //________________________________________________________________________
3068 void AliAnalysisTaskGammaConvCalo::CalculateBackgroundRP(){
3070 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
3072 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3073 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
3075 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
3080 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
3081 // Correct for the number of rotations
3082 // BG is for rotation the same, except for factor NRotations
3083 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
3085 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3087 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3088 if (gamma0==NULL) continue;
3089 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
3090 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
3091 if (gamma1 == NULL) continue;
3092 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
3093 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
3095 RotateParticle(gamma1);
3096 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3097 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3098 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3099 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3100 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3101 fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate.M(),gamma0->Pt());
3102 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3103 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3110 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
3112 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
3114 if(previousEventGammas){
3115 // test weighted background
3116 Double_t weight=1.0;
3117 // Correct for the number of eventmixing:
3118 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
3119 // real combinations (since you cannot combine a photon with its own)
3120 // but BG leads to N_{a}*N_{b} combinations
3121 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
3123 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3124 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3125 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
3127 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
3129 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3130 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3131 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3132 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3133 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3134 fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate.M(),gamma0->Pt());
3135 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3136 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3144 //________________________________________________________________________
3145 void AliAnalysisTaskGammaConvCalo::RotateParticle(AliAODConversionPhoton *gamma){
3146 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
3147 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
3148 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
3149 gamma->RotateZ(rotationValue);
3152 //________________________________________________________________________
3153 void AliAnalysisTaskGammaConvCalo::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
3155 previousEventEP=previousEventEP+TMath::Pi();
3156 thisEventEP=thisEventEP+TMath::Pi();
3157 Double_t rotationValue= thisEventEP-previousEventEP;
3158 gamma->RotateZ(rotationValue);
3161 //________________________________________________________________________
3162 void AliAnalysisTaskGammaConvCalo::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
3163 //see header file for documentation
3165 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
3166 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
3167 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
3169 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
3170 particle->SetConversionPoint(movedPlace);
3172 //________________________________________________________________________
3173 void AliAnalysisTaskGammaConvCalo::UpdateEventByEventData(){
3174 //see header file for documentation
3175 if(fGammaCandidates->GetEntries() >0 ){
3176 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3177 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3178 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3179 } else { // means we use #V0s for multiplicity
3180 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3181 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3187 //________________________________________________________________________
3188 void AliAnalysisTaskGammaConvCalo::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
3190 // Combinatorial Bck = 0 ee, 1 ep,i 2 ek, 3 ep, 4 emu, 5 pipi, 6 pik, 7 pip, 8 pimu, 9 kk, 10 kp, 11 kmu, 12 pp, 13 pmu, 14 mumu, 15 Rest
3191 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
3192 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
3193 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
3194 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
3195 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
3196 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
3197 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
3198 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
3199 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
3200 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
3201 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
3202 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
3203 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
3204 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
3205 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
3206 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
3207 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
3208 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
3209 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
3210 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
3211 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
3212 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
3213 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
3214 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
3215 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
3216 else {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
3218 //________________________________________________________________________
3219 void AliAnalysisTaskGammaConvCalo::RelabelAODPhotonCandidates(Bool_t mode){
3221 // Relabeling For AOD Event
3223 // MCLabel -> AODMCLabel
3226 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
3227 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
3228 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
3229 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
3232 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
3233 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
3234 if(!PhotonCandidate) continue;
3235 if(!mode){// Back to ESD Labels
3236 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
3237 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
3238 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
3239 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
3242 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
3243 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
3244 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
3245 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
3247 Bool_t AODLabelPos = kFALSE;
3248 Bool_t AODLabelNeg = kFALSE;
3250 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
3251 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
3253 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
3254 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
3255 PhotonCandidate->SetLabelPositive(i);
3256 AODLabelPos = kTRUE;
3260 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
3261 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
3262 PhotonCandidate->SetLabelNegative(i);
3263 AODLabelNeg = kTRUE;
3266 if(AODLabelNeg && AODLabelPos){
3270 if(!AODLabelPos || !AODLabelNeg){
3271 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
3277 delete[] fMCStackPos;
3278 delete[] fMCStackNeg;
3279 delete[] fESDArrayPos;
3280 delete[] fESDArrayNeg;
3284 void AliAnalysisTaskGammaConvCalo::SetLogBinningXTH2(TH2* histoRebin){
3285 TAxis *axisafter = histoRebin->GetXaxis();
3286 Int_t bins = axisafter->GetNbins();
3287 Double_t from = axisafter->GetXmin();
3288 Double_t to = axisafter->GetXmax();
3289 Double_t *newbins = new Double_t[bins+1];
3291 Double_t factor = TMath::Power(to/from, 1./bins);
3292 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
3293 axisafter->Set(bins, newbins);
3297 //________________________________________________________________________
3298 void AliAnalysisTaskGammaConvCalo::Terminate(const Option_t *)
3301 //fOutputContainer->Print(); // Will crash on GRID
3304 //________________________________________________________________________
3305 Int_t AliAnalysisTaskGammaConvCalo::GetSourceClassification(Int_t daughter, Int_t pdgCode){
3307 if (daughter == 111) {
3308 if (abs(pdgCode) == 310) return 1; // k0s
3309 else if (abs(pdgCode) == 3122) return 2; // Lambda
3310 else if (abs(pdgCode) == 130) return 3; // K0L
3311 else if (abs(pdgCode) == 2212) return 4; // proton
3312 else if (abs(pdgCode) == 2112) return 5; // neutron
3313 else if (abs(pdgCode) == 211) return 6; // pion
3314 else if (abs(pdgCode) == 321) return 7; // kaon
3315 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
3316 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112 ) return 9; // Sigma
3317 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114 ) return 10; // Delta
3318 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323 ) return 11; // K*
3325 //_________________________________________________________________________________
3326 Bool_t AliAnalysisTaskGammaConvCalo::CheckIfContainedInString(TString input, Int_t tobechecked){
3327 TObjArray *arr = input.Tokenize(",");
3328 for (Int_t i = 0; i < arr->GetEntriesFast();i++){
3329 TString tempStr = ((TObjString*)arr->At(i))->GetString();
3330 if (tempStr.Atoi() == tobechecked) return kTRUE;
3335 //_________________________________________________________________________________
3336 Bool_t AliAnalysisTaskGammaConvCalo::CheckIfContainedInStringAndAppend(TString &input, Int_t tobechecked){
3337 TObjArray *arr = input.Tokenize(",");
3338 Bool_t isContained = kFALSE;
3339 for (Int_t i = 0; i < arr->GetEntriesFast();i++){
3340 TString tempStr = ((TObjString*)arr->At(i))->GetString();
3341 if (tempStr.Atoi() == tobechecked) isContained= kTRUE;
3343 if (!isContained)input.Append(Form("%i,",tobechecked));
3347 //_________________________________________________________________________________
3348 void AliAnalysisTaskGammaConvCalo::ProcessConversionPhotonsForMissingTags (){
3350 if (!fMCStack) return;
3352 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3353 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3354 if (gamma0->IsTrueConvertedPhoton()){
3355 Int_t gamma0MotherLabel = -1;
3356 Int_t gamma0MCLabel = gamma0->GetMCParticleLabel(fMCStack);
3357 if(gamma0MCLabel != -1){
3358 TParticle * gammaMC0 = (TParticle*)fMCStack->Particle(gamma0MCLabel);
3359 gamma0MotherLabel=gammaMC0->GetFirstMother();
3360 if (gamma0MotherLabel>-1){
3361 if(((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetPdgCode() == 111){
3362 if (!CheckIfContainedInStringAndAppend(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
3363 if (gamma0MotherLabel >= fMCStack->GetNprimary()){
3364 Int_t secMotherLabel = ((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetMother(0);
3365 Float_t weightedSec= 1;
3366 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && fMCStack->Particle(secMotherLabel)->GetPdgCode()==310){
3367 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
3369 fHistoTrueSecondaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weightedSec);
3371 Float_t weighted= 1;
3372 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma0MotherLabel, fMCStack, fInputEvent)){
3373 if (((TParticle*)fMCStack->Particle(gamma0MotherLabel))->Pt()>0.005){
3374 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma0MotherLabel, fMCStack, fInputEvent);
3377 fHistoTruePrimaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
3380 } else if(((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetPdgCode() == 221){
3381 if (!CheckIfContainedInStringAndAppend(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
3382 Float_t weighted= 1;
3383 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma0MotherLabel, fMCStack, fInputEvent)){
3384 if (((TParticle*)fMCStack->Particle(gamma0MotherLabel))->Pt()>0.005){
3385 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma0MotherLabel, fMCStack, fInputEvent);
3388 fHistoTruePrimaryEtaMissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
3398 //_________________________________________________________________________________
3399 void AliAnalysisTaskGammaConvCalo::ProcessConversionPhotonsForMissingTagsAOD (){
3401 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
3403 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3404 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3406 if (gamma0->IsTrueConvertedPhoton()){
3407 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0->GetMCLabelPositive()));
3408 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0->GetMCLabelNegative()));
3410 Int_t gamma0MCLabel = -1;
3411 Int_t gamma0MotherLabel = -1;
3412 if(!positiveMC||!negativeMC)
3415 if (gamma0->IsTrueConvertedPhoton()){
3416 gamma0MCLabel = positiveMC->GetMother();
3417 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
3418 gamma0MotherLabel=gammaMC0->GetMother();
3420 if (gamma0MotherLabel>-1){
3421 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma0MotherLabel))->GetPdgCode() == 111){
3422 if (!CheckIfContainedInStringAndAppend(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
3423 if (!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){
3424 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->GetMother();
3425 Float_t weightedSec= 1;
3426 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
3427 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
3429 fHistoTrueSecondaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weightedSec);
3431 Float_t weighted= 1;
3432 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma0MotherLabel, 0x0, fInputEvent)){
3433 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->Pt()>0.005){
3434 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma0MotherLabel, 0x0, fInputEvent);
3437 fHistoTruePrimaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
3440 } else if(((AliAODMCParticle*)AODMCTrackArray->At(gamma0MotherLabel))->GetPdgCode() == 221){
3441 if (!CheckIfContainedInStringAndAppend(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
3442 Float_t weighted= 1;
3443 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma0MotherLabel, 0x0, fInputEvent)){
3444 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->Pt()>0.005){
3445 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma0MotherLabel, 0x0, fInputEvent);
3448 fHistoTruePrimaryEtaMissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
git://git.uio.no / u / mrichter / AliRoot.git / blob