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(),400,-2,2);
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(),400,-2,2);
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 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
2031 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
2032 fCharPhotonMCInfo = 0;
2034 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
2035 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
2037 if(posDaughter->GetMother() != negDaughter->GetMother()){
2038 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2039 fCharPhotonMCInfo = 1;
2042 else if(posDaughter->GetMother() == -1){
2043 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2044 fCharPhotonMCInfo = 1;
2048 if(pdgCode[0]!=11 || pdgCode[1]!=11){
2049 fCharPhotonMCInfo = 1;
2050 return; //One Particle is not a electron
2053 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
2054 fCharPhotonMCInfo = 1;
2055 return; // Same Charge
2058 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
2059 if(Photon->GetPdgCode() != 22){
2060 fCharPhotonMCInfo = 1;
2061 return; // Mother is no Photon
2064 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
2065 fCharPhotonMCInfo = 1;
2066 return;// check if the daughters come from a conversion
2068 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
2073 if(fIsFromMBHeader){
2074 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2075 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
2077 if(Photon->IsPrimary()){
2078 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
2079 if(fIsFromMBHeader){
2080 fCharPhotonMCInfo = 6;
2081 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2082 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
2084 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
2086 if(fIsFromMBHeader){
2087 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2088 fCharPhotonMCInfo = 2;
2089 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
2090 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
2091 fCharPhotonMCInfo = 5;
2092 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2094 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
2095 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
2096 fCharPhotonMCInfo = 4;
2097 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2099 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
2100 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
2101 fCharPhotonMCInfo = 3;
2105 TruePhotonCandidate->SetIsTrueConvertedPhoton();
2108 //________________________________________________________________________
2109 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
2112 Double_t magField = fInputEvent->GetMagneticField();
2113 if( magField < 0.0 ){
2120 // Process True Photons
2121 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
2122 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
2123 fCharPhotonMCInfo = 0;
2125 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
2126 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
2127 fCharPhotonMCInfo = 1;
2128 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
2129 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2132 else if(posDaughter->GetMother(0) == -1){
2133 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2137 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
2139 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
2141 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
2143 if(Photon->GetPdgCode() != 22){
2144 return; // Mother is no Photon
2147 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
2150 if(fIsFromMBHeader){
2151 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2152 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
2154 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
2155 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
2156 if(fIsFromMBHeader){
2157 fCharPhotonMCInfo = 6;
2158 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2159 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
2161 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
2163 if(fIsFromMBHeader){
2164 fCharPhotonMCInfo = 2;
2165 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2166 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2167 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
2168 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2169 fCharPhotonMCInfo = 5;
2171 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2172 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
2173 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2174 fCharPhotonMCInfo = 4;
2176 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2177 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
2178 fCharPhotonMCInfo = 3;
2182 TruePhotonCandidate->SetIsTrueConvertedPhoton();
2185 //________________________________________________________________________
2186 void AliAnalysisTaskGammaConvCalo::ProcessAODMCParticles()
2189 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2191 // Loop over all primary MC particle
2192 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
2194 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
2195 if (!particle) continue;
2196 if (!particle->IsPrimary()) continue;
2198 Int_t isMCFromMBHeader = -1;
2199 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2200 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2201 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2204 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2205 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
2206 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2207 if (abs(particle->Eta()) < 0.66 ){
2208 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2210 if(particle->GetMother() >-1){ // Meson Decay Gamma
2211 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
2213 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2216 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2219 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2222 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2225 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2228 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2231 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2236 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
2238 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
2239 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
2240 if(!tmpDaughter) continue;
2241 if(abs(tmpDaughter->GetPdgCode()) == 11){
2242 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
2245 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2246 if (fDoPhotonQA > 0){
2247 fHistoMCConvGammaR[fiCut]->Fill(rConv);
2248 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2251 // Converted MC Gamma
2252 if(fDoMesonAnalysis){
2253 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2254 Double_t mesonY = 10.;
2255 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2256 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2258 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2260 Float_t weightedK0s= 1;
2261 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2262 if (particle->Pt()>0.005){
2263 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2264 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2267 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2268 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2269 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2271 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2272 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2273 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
2274 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
2275 Float_t weighted= 1;
2276 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2277 if (particle->Pt()>0.005){
2278 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2279 // if(particle->GetPdgCode() == 221){
2280 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2284 Double_t mesonY = 10.;
2285 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2286 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2288 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2291 Double_t alpha = -1;
2292 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2293 alpha = TMath::Abs((daughter0->E() - daughter1->E()))/(daughter0->E() + daughter1->E());
2297 if(particle->GetPdgCode() == 111){
2298 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2299 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2300 if (fDoMesonQA > 0){
2301 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2302 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2304 } else if(particle->GetPdgCode() == 221){
2305 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2306 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2307 if (fDoMesonQA > 0){
2308 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2309 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2313 // Check the acceptance for both gammas
2314 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
2315 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) &&
2316 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2317 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2319 if(particle->GetPdgCode() == 111){
2320 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2321 } else if(particle->GetPdgCode() == 221){
2322 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2330 //________________________________________________________________________
2331 void AliAnalysisTaskGammaConvCalo::ProcessMCParticles()
2333 // Loop over all primary MC particle
2334 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2335 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2336 if (!particle) continue;
2338 Int_t isMCFromMBHeader = -1;
2339 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2340 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2341 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2344 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2345 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
2346 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2347 if (abs(particle->Eta()) < 0.66 ){
2348 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2351 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
2352 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
2354 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2357 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2360 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2363 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2366 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2369 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2372 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2377 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
2378 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2379 if (fDoPhotonQA > 0){
2380 fHistoMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
2381 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2383 } // Converted MC Gamma
2384 if(fDoMesonAnalysis){
2385 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2386 Double_t mesonY = 10.;
2387 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2388 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2390 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2392 Float_t weightedK0s= 1;
2393 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2394 if (particle->Pt()>0.005){
2395 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2396 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2399 if (fMCStack->IsPhysicalPrimary(i)){
2400 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2401 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2402 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2405 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2406 ->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2407 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
2408 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
2410 Float_t weighted= 1;
2411 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2412 if (particle->Pt()>0.005){
2413 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2414 // if(particle->GetPdgCode() == 221){
2415 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2419 Double_t mesonY = 10.;
2420 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2421 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2423 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2426 Double_t alpha = -1;
2427 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2428 alpha = TMath::Abs((daughter0->Energy() - daughter1->Energy()))/(daughter0->Energy() + daughter1->Energy());
2431 if(particle->GetPdgCode() == 111){
2432 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2433 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2434 if (fDoMesonQA > 0){
2435 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2436 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2438 } else if(particle->GetPdgCode() == 221){
2439 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2440 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2441 if (fDoMesonQA > 0){
2442 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2443 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2447 // Check the acceptance for both gammas
2448 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
2449 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) &&
2450 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2451 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2453 if(particle->GetPdgCode() == 111){
2454 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2455 } else if(particle->GetPdgCode() == 221){
2456 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2464 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
2465 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2466 if (!particle) continue;
2468 Int_t isMCFromMBHeader = -1;
2469 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2470 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2471 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2474 if(fDoMesonAnalysis){
2475 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2476 Float_t weighted= 1;
2477 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2478 if (particle->Pt()>0.005){
2479 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2480 // if(particle->GetPdgCode() == 221){
2481 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2486 if(particle->GetPdgCode() == 111){
2487 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2488 Int_t source = GetSourceClassification(111,pdgCode);
2489 fHistoMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
2490 fHistoMCSecPi0Source[fiCut]->Fill(pdgCode);
2491 } else if(particle->GetPdgCode() == 221){
2492 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2493 fHistoMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2494 fHistoMCSecEtaSource[fiCut]->Fill(pdgCode);
2502 //________________________________________________________________________
2503 void AliAnalysisTaskGammaConvCalo::CalculatePi0Candidates(){
2505 // Conversion Gammas
2506 if(fGammaCandidates->GetEntries()>0){
2509 Double_t vertex[3] = {0};
2510 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
2512 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2513 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2514 if (gamma0==NULL) continue;
2516 for(Int_t secondGammaIndex=0;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
2517 Bool_t matched = kFALSE;
2518 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2519 if (gamma1==NULL) continue;
2521 if (gamma1->GetIsCaloPhoton()){
2522 AliVCluster* cluster = fInputEvent->GetCaloCluster(gamma1->GetCaloClusterRef());
2523 matched = ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->MatchConvPhotonToCluster(gamma0,cluster, fInputEvent );
2526 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
2527 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
2531 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2533 fHistoMotherMatchedInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2535 fHistoMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2537 // fill new histograms
2539 fHistoPhotonPairPtconv[fiCut]->Fill(pi0cand->M(),gamma0->Pt());
2540 if(pi0cand->GetAlpha()<0.1)
2541 fHistoMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
2543 if (fDoMesonQA > 0){
2544 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
2545 fHistoMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2546 fHistoMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2547 fHistoMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2548 fHistoMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
2550 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
2551 fHistoMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2552 fHistoMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2553 fHistoMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2554 fHistoMotherEtaConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
2557 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
2561 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
2562 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2563 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2564 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2566 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2569 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2570 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2571 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2573 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2576 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
2577 fSparseMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2582 if(fInputEvent->IsA()==AliESDEvent::Class())
2583 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1, matched);
2584 if(fInputEvent->IsA()==AliAODEvent::Class())
2585 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1, matched);
2588 if (fDoMesonQA == 1){
2589 fHistoMotherInvMassECalib[fiCut]->Fill(pi0cand->M(),gamma1->E());
2590 if(pi0cand->GetAlpha()<0.1)
2591 fHistoMotherInvMassECalibalpha[fiCut]->Fill(pi0cand->M(),gamma1->E());
2601 //______________________________________________________________________
2602 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2604 // Process True Mesons
2605 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2606 Bool_t isTruePi0 = kFALSE;
2607 Bool_t isTrueEta = kFALSE;
2608 Int_t gamma0MCLabel = -1;
2609 Int_t gamma0MotherLabel = -1;
2610 if (TrueGammaCandidate0->IsTrueConvertedPhoton()){
2611 gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(fMCStack);
2612 TParticle * gammaMC0 = (TParticle*)fMCStack->Particle(gamma0MCLabel);
2613 gamma0MotherLabel=gammaMC0->GetFirstMother();
2616 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
2618 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2619 Int_t gamma1MotherLabel = -1;
2622 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2623 // Daughters Gamma 1
2624 TParticle * gammaMC1 = (TParticle*)fMCStack->Particle(gamma1MCLabel);
2625 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2626 // get mother of interest (pi0 or eta)
2627 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2628 gamma1MotherLabel=gammaMC1->GetMother(0);
2629 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2630 if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=fMCStack->Particle(gammaMC1->GetMother(0))->GetMother(0);
2631 else gamma1MotherLabel=gammaMC1->GetMother(0);
2634 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2638 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2639 if(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
2642 if(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
2647 if(isTruePi0 || isTrueEta){// True Pion or Eta
2649 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2650 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2652 if (fDoMesonQA > 0){
2653 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2654 if(isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2655 if(isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2657 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched){
2658 if(isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2659 if(isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2661 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() ){
2662 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2663 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2664 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0){
2665 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2667 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta){
2668 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2671 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2672 if (isTruePi0 )fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2673 if (isTrueEta )fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2675 if (TrueGammaCandidate1->IsMergedPartConv() && !matched){
2676 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2677 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2681 if (fDoMesonQA > 0){
2683 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2684 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2685 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2686 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2687 fHistoTrueMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2689 } else if (isTrueEta){
2690 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2691 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2692 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2693 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2694 fHistoTrueMotherEtaConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2699 if(gamma0MotherLabel >= fMCStack->GetNprimary()){ // Secondary Meson
2700 Int_t secMotherLabel = ((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetMother(0);
2701 Float_t weightedSec= 1;
2702 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && fMCStack->Particle(secMotherLabel)->GetPdgCode()==310){
2703 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
2704 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2707 fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2708 fHistoTrueSecondaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weightedSec);
2709 if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2710 fHistoTrueSecondaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weightedSec);
2713 if (secMotherLabel >-1){
2714 if(fMCStack->Particle(secMotherLabel)->GetPdgCode()==310 && isTruePi0 ){
2715 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2716 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(fMCStack->Particle(secMotherLabel)->Pt());
2718 if(fMCStack->Particle(secMotherLabel)->GetPdgCode()==221 && isTruePi0){
2719 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2720 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(fMCStack->Particle(secMotherLabel)->Pt());
2722 if(fMCStack->Particle(secMotherLabel)->GetPdgCode()==3122 && isTruePi0){
2723 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2724 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(fMCStack->Particle(secMotherLabel)->Pt());
2727 } else { // Only primary pi0 for efficiency calculation
2728 Float_t weighted= 1;
2729 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
2730 if (((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
2731 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
2732 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2736 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2737 fHistoTruePrimaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2738 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2739 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2740 if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2741 fHistoTruePrimaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2744 } else if (isTrueEta) {
2745 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2746 fHistoTruePrimaryEtaPhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2747 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2748 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2749 if(CheckIfContainedInString(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
2750 fHistoTruePrimaryEtaDCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2754 if (fDoMesonQA > 0){
2755 if(isTruePi0){ // Only primary pi0 for resolution
2756 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2758 if (isTrueEta){ // Only primary eta for resolution
2759 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)fMCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2764 } else if(!isTruePi0 && !isTrueEta){ // Background
2765 if (fDoMesonQA > 0){
2766 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2767 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2768 } else { // No photon or without mother
2769 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2773 if (isTrueEta && !matched){
2774 fStringRecTrueEtas[fiCut].Append(Form("%i,",gamma0MotherLabel));
2776 if (isTruePi0 && !matched){
2777 fStringRecTruePi0s[fiCut].Append(Form("%i,",gamma0MotherLabel));
2782 //______________________________________________________________________
2783 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2786 // Process True Mesons
2787 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2788 Bool_t isTruePi0 = kFALSE;
2789 Bool_t isTrueEta = kFALSE;
2791 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
2792 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
2794 Int_t gamma0MCLabel = -1;
2795 Int_t gamma0MotherLabel = -1;
2796 if(!positiveMC||!negativeMC)
2799 if (TrueGammaCandidate0->IsTrueConvertedPhoton()){
2800 gamma0MCLabel = positiveMC->GetMother();
2801 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2802 gamma0MotherLabel=gammaMC0->GetMother();
2805 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
2806 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2807 Int_t gamma1MotherLabel = -1;
2810 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2811 // Daughters Gamma 1
2812 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2813 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2814 // get mother of interest (pi0 or eta)
2815 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2816 gamma1MotherLabel=gammaMC1->GetMother();
2817 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2818 if (TrueGammaCandidate1->IsConversion()){
2819 AliAODMCParticle * gammaGrandMotherMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC1->GetMother()));
2820 gamma1MotherLabel=gammaGrandMotherMC1->GetMother();
2821 } else gamma1MotherLabel=gammaMC1->GetMother();
2824 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2828 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2829 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2832 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2837 if(isTruePi0 || isTrueEta){// True Pion or Eta
2839 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2840 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2842 if (fDoMesonQA > 0){
2843 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2844 if (isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2845 if (isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2847 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched) {
2848 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2849 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2851 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()){
2852 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2853 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2854 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0)
2855 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2856 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta)
2857 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2859 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2860 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2861 if (isTrueEta) fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2863 if (TrueGammaCandidate1->IsMergedPartConv() && !matched) {
2864 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2865 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2870 if (fDoMesonQA > 0){
2872 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2873 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2874 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2875 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2876 fHistoTrueMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2878 } else if (isTrueEta){
2879 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2880 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2881 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2882 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2883 fHistoTrueMotherEtaConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2887 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2888 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2889 Float_t weightedSec= 1;
2890 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2891 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
2892 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2895 fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2896 fHistoTrueSecondaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weightedSec);
2897 if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2898 fHistoTrueSecondaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weightedSec);
2901 if (secMotherLabel >-1){
2902 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310 && isTruePi0){
2903 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2904 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2906 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221 && isTruePi0){
2907 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2908 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2910 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122 && isTruePi0){
2911 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2912 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2915 } else{ // Only primary pi0 for efficiency calculation
2916 Float_t weighted= 1;
2917 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2918 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2919 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2920 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2924 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2925 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2926 fHistoTruePrimaryPi0PhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2927 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2928 if(CheckIfContainedInString(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
2929 fHistoTruePrimaryPi0DCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2931 } else if (isTrueEta){
2932 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2933 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2934 fHistoTruePrimaryEtaPhotonPairPtconv[fiCut]->Fill(Pi0Candidate->M(),TrueGammaCandidate0->Pt(),weighted);
2935 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2936 if(CheckIfContainedInString(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
2937 fHistoTruePrimaryEtaDCPtconv[fiCut]->Fill(TrueGammaCandidate0->Pt(),weighted);
2940 if (fDoMesonQA > 0){
2941 if(isTruePi0){ // Only primary pi0 for resolution
2942 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2943 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2946 if (isTrueEta){ // Only primary eta for resolution
2947 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2948 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2953 } else if(!isTruePi0 && !isTrueEta) { // Background
2954 if (fDoMesonQA > 0){
2955 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2956 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2957 } else { // No photon or without mother
2958 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2963 if (isTrueEta && !matched){
2964 fStringRecTrueEtas[fiCut].Append(Form("%i,",gamma0MotherLabel));
2966 if (isTruePi0 && !matched){
2967 fStringRecTruePi0s[fiCut].Append(Form("%i,",gamma0MotherLabel));
2974 //________________________________________________________________________
2975 void AliAnalysisTaskGammaConvCalo::CalculateBackground(){
2977 Int_t zbin= fBGClusHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2980 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2981 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2983 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2986 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2987 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2988 for(Int_t nEventsInBG=0;nEventsInBG<fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2989 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2990 if(fMoveParticleAccordingToVertex == kTRUE){
2991 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2994 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2995 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2996 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2997 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2998 if(fMoveParticleAccordingToVertex == kTRUE){
2999 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
3001 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
3002 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
3005 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
3006 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3007 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3008 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
3009 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
3010 fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate->M(),currentEventGoodV0.Pt());
3011 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
3012 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
3014 delete backgroundCandidate;
3015 backgroundCandidate = 0x0;
3020 for(Int_t nEventsInBG=0;nEventsInBG <fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
3021 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
3022 if(previousEventV0s){
3023 if(fMoveParticleAccordingToVertex == kTRUE){
3024 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
3026 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3027 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3028 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
3030 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
3032 if(fMoveParticleAccordingToVertex == kTRUE){
3033 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
3035 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
3036 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
3039 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
3040 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3041 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
3042 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
3043 fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate->M(),currentEventGoodV0.Pt());
3044 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
3045 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
3047 delete backgroundCandidate;
3048 backgroundCandidate = 0x0;
3056 //________________________________________________________________________
3057 void AliAnalysisTaskGammaConvCalo::CalculateBackgroundRP(){
3059 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
3061 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3062 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
3064 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
3069 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
3070 // Correct for the number of rotations
3071 // BG is for rotation the same, except for factor NRotations
3072 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
3074 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3076 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3077 if (gamma0==NULL) continue;
3078 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
3079 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
3080 if (gamma1 == NULL) continue;
3081 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
3082 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
3084 RotateParticle(gamma1);
3085 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3086 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3087 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3088 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3089 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3090 fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate.M(),gamma0->Pt());
3091 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3092 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3099 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
3101 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
3103 if(previousEventGammas){
3104 // test weighted background
3105 Double_t weight=1.0;
3106 // Correct for the number of eventmixing:
3107 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
3108 // real combinations (since you cannot combine a photon with its own)
3109 // but BG leads to N_{a}*N_{b} combinations
3110 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
3112 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3113 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3114 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
3116 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
3118 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3119 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3120 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3121 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3122 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3123 fHistoPhotonPairMixedEventPtconv[fiCut]->Fill(backgroundCandidate.M(),gamma0->Pt());
3124 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3125 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3133 //________________________________________________________________________
3134 void AliAnalysisTaskGammaConvCalo::RotateParticle(AliAODConversionPhoton *gamma){
3135 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
3136 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
3137 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
3138 gamma->RotateZ(rotationValue);
3141 //________________________________________________________________________
3142 void AliAnalysisTaskGammaConvCalo::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
3144 previousEventEP=previousEventEP+TMath::Pi();
3145 thisEventEP=thisEventEP+TMath::Pi();
3146 Double_t rotationValue= thisEventEP-previousEventEP;
3147 gamma->RotateZ(rotationValue);
3150 //________________________________________________________________________
3151 void AliAnalysisTaskGammaConvCalo::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
3152 //see header file for documentation
3154 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
3155 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
3156 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
3158 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
3159 particle->SetConversionPoint(movedPlace);
3161 //________________________________________________________________________
3162 void AliAnalysisTaskGammaConvCalo::UpdateEventByEventData(){
3163 //see header file for documentation
3164 if(fGammaCandidates->GetEntries() >0 ){
3165 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3166 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3167 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3168 } else { // means we use #V0s for multiplicity
3169 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3170 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3176 //________________________________________________________________________
3177 void AliAnalysisTaskGammaConvCalo::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
3179 // 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
3180 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
3181 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
3182 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
3183 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
3184 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
3185 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
3186 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
3187 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
3188 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
3189 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
3190 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
3191 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
3192 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
3193 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
3194 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
3195 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
3196 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
3197 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
3198 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
3199 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
3200 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
3201 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
3202 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
3203 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
3204 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
3205 else {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
3207 //________________________________________________________________________
3208 void AliAnalysisTaskGammaConvCalo::RelabelAODPhotonCandidates(Bool_t mode){
3210 // Relabeling For AOD Event
3212 // MCLabel -> AODMCLabel
3215 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
3216 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
3217 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
3218 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
3221 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
3222 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
3223 if(!PhotonCandidate) continue;
3224 if(!mode){// Back to ESD Labels
3225 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
3226 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
3227 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
3228 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
3231 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
3232 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
3233 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
3234 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
3236 Bool_t AODLabelPos = kFALSE;
3237 Bool_t AODLabelNeg = kFALSE;
3239 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
3240 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
3242 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
3243 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
3244 PhotonCandidate->SetLabelPositive(i);
3245 AODLabelPos = kTRUE;
3249 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
3250 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
3251 PhotonCandidate->SetLabelNegative(i);
3252 AODLabelNeg = kTRUE;
3255 if(AODLabelNeg && AODLabelPos){
3259 if(!AODLabelPos || !AODLabelNeg){
3260 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
3266 delete[] fMCStackPos;
3267 delete[] fMCStackNeg;
3268 delete[] fESDArrayPos;
3269 delete[] fESDArrayNeg;
3273 void AliAnalysisTaskGammaConvCalo::SetLogBinningXTH2(TH2* histoRebin){
3274 TAxis *axisafter = histoRebin->GetXaxis();
3275 Int_t bins = axisafter->GetNbins();
3276 Double_t from = axisafter->GetXmin();
3277 Double_t to = axisafter->GetXmax();
3278 Double_t *newbins = new Double_t[bins+1];
3280 Double_t factor = TMath::Power(to/from, 1./bins);
3281 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
3282 axisafter->Set(bins, newbins);
3286 //________________________________________________________________________
3287 void AliAnalysisTaskGammaConvCalo::Terminate(const Option_t *)
3290 //fOutputContainer->Print(); // Will crash on GRID
3293 //________________________________________________________________________
3294 Int_t AliAnalysisTaskGammaConvCalo::GetSourceClassification(Int_t daughter, Int_t pdgCode){
3296 if (daughter == 111) {
3297 if (abs(pdgCode) == 310) return 1; // k0s
3298 else if (abs(pdgCode) == 3122) return 2; // Lambda
3299 else if (abs(pdgCode) == 130) return 3; // K0L
3300 else if (abs(pdgCode) == 2212) return 4; // proton
3301 else if (abs(pdgCode) == 2112) return 5; // neutron
3302 else if (abs(pdgCode) == 211) return 6; // pion
3303 else if (abs(pdgCode) == 321) return 7; // kaon
3304 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
3305 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112 ) return 9; // Sigma
3306 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114 ) return 10; // Delta
3307 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323 ) return 11; // K*
3314 //_________________________________________________________________________________
3315 Bool_t AliAnalysisTaskGammaConvCalo::CheckIfContainedInString(TString input, Int_t tobechecked){
3316 TObjArray *arr = input.Tokenize(",");
3317 for (Int_t i = 0; i < arr->GetEntriesFast();i++){
3318 TString tempStr = ((TObjString*)arr->At(i))->GetString();
3319 if (tempStr.Atoi() == tobechecked) return kTRUE;
3324 //_________________________________________________________________________________
3325 Bool_t AliAnalysisTaskGammaConvCalo::CheckIfContainedInStringAndAppend(TString &input, Int_t tobechecked){
3326 TObjArray *arr = input.Tokenize(",");
3327 Bool_t isContained = kFALSE;
3328 for (Int_t i = 0; i < arr->GetEntriesFast();i++){
3329 TString tempStr = ((TObjString*)arr->At(i))->GetString();
3330 if (tempStr.Atoi() == tobechecked) isContained= kTRUE;
3332 if (!isContained)input.Append(Form("%i,",tobechecked));
3336 //_________________________________________________________________________________
3337 void AliAnalysisTaskGammaConvCalo::ProcessConversionPhotonsForMissingTags (){
3339 if (!fMCStack) return;
3341 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3342 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3343 if (gamma0->IsTrueConvertedPhoton()){
3344 Int_t gamma0MotherLabel = -1;
3345 Int_t gamma0MCLabel = gamma0->GetMCParticleLabel(fMCStack);
3346 if(gamma0MCLabel != -1){
3347 TParticle * gammaMC0 = (TParticle*)fMCStack->Particle(gamma0MCLabel);
3348 gamma0MotherLabel=gammaMC0->GetFirstMother();
3349 if (gamma0MotherLabel>-1){
3350 if(((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetPdgCode() == 111){
3351 if (!CheckIfContainedInStringAndAppend(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
3352 if (gamma0MotherLabel >= fMCStack->GetNprimary()){
3353 Int_t secMotherLabel = ((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetMother(0);
3354 Float_t weightedSec= 1;
3355 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && fMCStack->Particle(secMotherLabel)->GetPdgCode()==310){
3356 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
3358 fHistoTrueSecondaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weightedSec);
3360 Float_t weighted= 1;
3361 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma0MotherLabel, fMCStack, fInputEvent)){
3362 if (((TParticle*)fMCStack->Particle(gamma0MotherLabel))->Pt()>0.005){
3363 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma0MotherLabel, fMCStack, fInputEvent);
3366 fHistoTruePrimaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
3369 } else if(((TParticle*)fMCStack->Particle(gamma0MotherLabel))->GetPdgCode() == 221){
3370 if (!CheckIfContainedInStringAndAppend(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
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 fHistoTruePrimaryEtaMissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
3387 //_________________________________________________________________________________
3388 void AliAnalysisTaskGammaConvCalo::ProcessConversionPhotonsForMissingTagsAOD (){
3390 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
3392 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3393 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3395 if (gamma0->IsTrueConvertedPhoton()){
3396 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0->GetMCLabelPositive()));
3397 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0->GetMCLabelNegative()));
3399 Int_t gamma0MCLabel = -1;
3400 Int_t gamma0MotherLabel = -1;
3401 if(!positiveMC||!negativeMC)
3404 if (gamma0->IsTrueConvertedPhoton()){
3405 gamma0MCLabel = positiveMC->GetMother();
3406 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
3407 gamma0MotherLabel=gammaMC0->GetMother();
3409 if (gamma0MotherLabel>-1){
3410 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma0MotherLabel))->GetPdgCode() == 111){
3411 if (!CheckIfContainedInStringAndAppend(fStringRecTruePi0s[fiCut],gamma0MotherLabel)){
3412 if (!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){
3413 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->GetMother();
3414 Float_t weightedSec= 1;
3415 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
3416 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
3418 fHistoTrueSecondaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weightedSec);
3420 Float_t weighted= 1;
3421 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma0MotherLabel, 0x0, fInputEvent)){
3422 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->Pt()>0.005){
3423 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma0MotherLabel, 0x0, fInputEvent);
3426 fHistoTruePrimaryPi0MissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
3429 } else if(((AliAODMCParticle*)AODMCTrackArray->At(gamma0MotherLabel))->GetPdgCode() == 221){
3430 if (!CheckIfContainedInStringAndAppend(fStringRecTrueEtas[fiCut],gamma0MotherLabel)){
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 fHistoTruePrimaryEtaMissingPtconv[fiCut]->Fill(gamma0->Pt(),weighted);
git://git.uio.no / u / mrichter / AliRoot.git / blob