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),
80 fHeaderNameList(NULL),
82 fOutputContainer(NULL),
84 fGammaCandidates(NULL),
85 fClusterCandidates(NULL),
89 fConversionCuts(NULL),
90 fClusterCutArray(NULL),
91 fCaloPhotonCuts(NULL),
94 fHistoConvGammaPt(NULL),
95 fHistoConvGammaR(NULL),
96 fHistoConvGammaEta(NULL),
97 fTreeConvGammaPtDcazCat(NULL),
103 fCharPhotonMCInfo(0),
104 fHistoMotherInvMassPt(NULL),
105 fHistoMotherMatchedInvMassPt(NULL),
106 fSparseMotherInvMassPtZM(NULL),
107 fHistoMotherBackInvMassPt(NULL),
108 fSparseMotherBackInvMassPtZM(NULL),
109 fHistoMotherInvMassEalpha(NULL),
110 fHistoMotherPi0PtY(NULL),
111 fHistoMotherEtaPtY(NULL),
112 fHistoMotherPi0PtAlpha(NULL),
113 fHistoMotherEtaPtAlpha(NULL),
114 fHistoMotherPi0PtOpenAngle(NULL),
115 fHistoMotherEtaPtOpenAngle(NULL),
116 fHistoMotherPi0ConvPhotonEtaPhi(NULL),
117 fHistoMotherEtaConvPhotonEtaPhi(NULL),
118 fHistoMotherInvMassECalib(NULL),
119 fHistoMotherInvMassECalibalpha(NULL),
120 fTreeMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
127 fHistoConvGammaUntagged(NULL),
128 fHistoConvGammaTagged(NULL),
129 fHistoConvGammaPi0Tagged(NULL),
130 fHistoConvGammaEtaTagged(NULL),
131 fHistoPhotonPairAll(NULL),
132 fHistoPhotonPairAllGam(NULL),
133 fHistoClusGammaPt(NULL),
134 fHistoMCHeaders(NULL),
135 fHistoMCAllGammaPt(NULL),
136 fHistoMCAllGammaEMCALAccPt(NULL),
137 fHistoMCDecayGammaPi0Pt(NULL),
138 fHistoMCDecayGammaRhoPt(NULL),
139 fHistoMCDecayGammaEtaPt(NULL),
140 fHistoMCDecayGammaOmegaPt(NULL),
141 fHistoMCDecayGammaEtapPt(NULL),
142 fHistoMCDecayGammaPhiPt(NULL),
143 fHistoMCDecayGammaSigmaPt(NULL),
144 fHistoMCConvGammaPt(NULL),
145 fHistoMCConvGammaR(NULL),
146 fHistoMCConvGammaEta(NULL),
148 fHistoMCPi0WOWeightPt(NULL),
150 fHistoMCEtaWOWeightPt(NULL),
151 fHistoMCPi0InAccPt(NULL),
152 fHistoMCEtaInAccPt(NULL),
153 fHistoMCPi0PtY(NULL),
154 fHistoMCEtaPtY(NULL),
155 fHistoMCPi0PtAlpha(NULL),
156 fHistoMCEtaPtAlpha(NULL),
158 fHistoMCK0sWOWeightPt(NULL),
159 fHistoMCK0sPtY(NULL),
160 fHistoMCSecPi0PtvsSource(NULL),
161 fHistoMCSecPi0Source(NULL),
162 fHistoMCSecEtaPt(NULL),
163 fHistoMCSecEtaSource(NULL),
164 fHistoTruePi0InvMassPt(NULL),
165 fHistoTrueEtaInvMassPt(NULL),
166 fHistoTruePi0CaloPhotonInvMassPt(NULL),
167 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
168 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
169 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
170 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
171 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
172 fHistoTruePi0CaloElectronInvMassPt(NULL),
173 fHistoTrueEtaCaloElectronInvMassPt(NULL),
174 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
175 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
176 fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
177 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
178 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
179 fHistoTruePrimaryPi0InvMassPt(NULL),
180 fHistoTruePrimaryEtaInvMassPt(NULL),
181 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
182 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
183 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
184 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
185 fHistoTruePrimaryPi0MCPtResolPt(NULL),
186 fHistoTruePrimaryEtaMCPtResolPt(NULL),
187 fHistoTrueMotherPi0ConvPhotonEtaPhi(NULL),
188 fHistoTrueMotherEtaConvPhotonEtaPhi(NULL),
189 fHistoTrueSecondaryPi0InvMassPt(NULL),
190 fHistoTrueSecondaryEtaInvMassPt(NULL),
191 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
192 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
193 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
194 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
195 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
196 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
197 fHistoTrueBckGGInvMassPt(NULL),
198 fHistoTrueBckContInvMassPt(NULL),
199 fHistoTruePi0PtY(NULL),
200 fHistoTrueEtaPtY(NULL),
201 fHistoTruePi0PtAlpha(NULL),
202 fHistoTrueEtaPtAlpha(NULL),
203 fHistoTruePi0PtOpenAngle(NULL),
204 fHistoTrueEtaPtOpenAngle(NULL),
205 fHistoTrueConvGammaPt(NULL),
206 fHistoTrueConvPi0GammaPt(NULL),
207 fHistoTrueConvGammaEta(NULL),
208 fHistoCombinatorialPt(NULL),
209 fHistoTruePrimaryConvGammaPt(NULL),
210 fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
211 fHistoTrueSecondaryConvGammaPt(NULL),
212 fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
213 fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
214 fHistoTrueClusGammaPt(NULL),
215 fHistoTrueClusUnConvGammaPt(NULL),
216 fHistoTrueClusUnConvGammaMCPt(NULL),
217 fHistoTrueClusElectronPt(NULL),
218 fHistoTrueClusConvGammaPt(NULL),
219 fHistoTrueClusConvGammaMCPt(NULL),
220 fHistoTrueClusConvGammaFullyPt(NULL),
221 fHistoTrueClusMergedGammaPt(NULL),
222 fHistoTrueClusMergedPartConvGammaPt(NULL),
223 fHistoTrueClusDalitzPt(NULL),
224 fHistoTrueClusDalitzMergedPt(NULL),
225 fHistoTrueClusPhotonFromElecMotherPt(NULL),
226 fHistoTrueClusShowerPt(NULL),
227 fHistoTrueClusSubLeadingPt(NULL),
228 fHistoTrueClusNParticles(NULL),
229 fHistoTrueClusEMNonLeadingPt(NULL),
230 fHistoTrueNLabelsInClus(NULL),
231 fHistoTruePrimaryClusGammaPt(NULL),
232 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
234 fHistoNGoodESDTracks(NULL),
235 fHistoNGammaCandidates(NULL),
236 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
237 fHistoNV0Tracks(NULL),
238 fProfileEtaShift(NULL),
239 fEventPlaneAngle(-100),
241 fNGammaCandidates(0),
252 fMoveParticleAccordingToVertex(kTRUE),
254 fDoMesonAnalysis(kTRUE),
258 fIsFromMBHeader(kTRUE),
264 //________________________________________________________________________
265 AliAnalysisTaskGammaConvCalo::AliAnalysisTaskGammaConvCalo(const char *name):
266 AliAnalysisTaskSE(name),
270 fBGClusHandler(NULL),
271 fBGClusHandlerRP(NULL),
279 fPhotonDCAList(NULL),
283 fHeaderNameList(NULL),
284 fTagOutputList(NULL),
287 fGammaCandidates(NULL),
288 fClusterCandidates(NULL),
289 fEventCutArray(NULL),
292 fConversionCuts(NULL),
293 fClusterCutArray(NULL),
294 fCaloPhotonCuts(NULL),
295 fMesonCutArray(NULL),
297 fHistoConvGammaPt(NULL),
298 fHistoConvGammaR(NULL),
299 fHistoConvGammaEta(NULL),
300 fTreeConvGammaPtDcazCat(NULL),
306 fCharPhotonMCInfo(0),
307 fHistoMotherInvMassPt(NULL),
308 fHistoMotherMatchedInvMassPt(NULL),
309 fSparseMotherInvMassPtZM(NULL),
310 fHistoMotherBackInvMassPt(NULL),
311 fSparseMotherBackInvMassPtZM(NULL),
312 fHistoMotherInvMassEalpha(NULL),
313 fHistoMotherPi0PtY(NULL),
314 fHistoMotherEtaPtY(NULL),
315 fHistoMotherPi0PtAlpha(NULL),
316 fHistoMotherEtaPtAlpha(NULL),
317 fHistoMotherPi0PtOpenAngle(NULL),
318 fHistoMotherEtaPtOpenAngle(NULL),
319 fHistoMotherPi0ConvPhotonEtaPhi(NULL),
320 fHistoMotherEtaConvPhotonEtaPhi(NULL),
321 fHistoMotherInvMassECalib(NULL),
322 fHistoMotherInvMassECalibalpha(NULL),
323 fTreeMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
330 fHistoConvGammaUntagged(NULL),
331 fHistoConvGammaTagged(NULL),
332 fHistoConvGammaPi0Tagged(NULL),
333 fHistoConvGammaEtaTagged(NULL),
334 fHistoPhotonPairAll(NULL),
335 fHistoPhotonPairAllGam(NULL),
336 fHistoClusGammaPt(NULL),
337 fHistoMCHeaders(NULL),
338 fHistoMCAllGammaPt(NULL),
339 fHistoMCAllGammaEMCALAccPt(NULL),
340 fHistoMCDecayGammaPi0Pt(NULL),
341 fHistoMCDecayGammaRhoPt(NULL),
342 fHistoMCDecayGammaEtaPt(NULL),
343 fHistoMCDecayGammaOmegaPt(NULL),
344 fHistoMCDecayGammaEtapPt(NULL),
345 fHistoMCDecayGammaPhiPt(NULL),
346 fHistoMCDecayGammaSigmaPt(NULL),
347 fHistoMCConvGammaPt(NULL),
348 fHistoMCConvGammaR(NULL),
349 fHistoMCConvGammaEta(NULL),
351 fHistoMCPi0WOWeightPt(NULL),
353 fHistoMCEtaWOWeightPt(NULL),
354 fHistoMCPi0InAccPt(NULL),
355 fHistoMCEtaInAccPt(NULL),
356 fHistoMCPi0PtY(NULL),
357 fHistoMCEtaPtY(NULL),
358 fHistoMCPi0PtAlpha(NULL),
359 fHistoMCEtaPtAlpha(NULL),
361 fHistoMCK0sWOWeightPt(NULL),
362 fHistoMCK0sPtY(NULL),
363 fHistoMCSecPi0PtvsSource(NULL),
364 fHistoMCSecPi0Source(NULL),
365 fHistoMCSecEtaPt(NULL),
366 fHistoMCSecEtaSource(NULL),
367 fHistoTruePi0InvMassPt(NULL),
368 fHistoTrueEtaInvMassPt(NULL),
369 fHistoTruePi0CaloPhotonInvMassPt(NULL),
370 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
371 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
372 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
373 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
374 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
375 fHistoTruePi0CaloElectronInvMassPt(NULL),
376 fHistoTrueEtaCaloElectronInvMassPt(NULL),
377 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
378 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
379 fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
380 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
381 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
382 fHistoTruePrimaryPi0InvMassPt(NULL),
383 fHistoTruePrimaryEtaInvMassPt(NULL),
384 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
385 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
386 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
387 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
388 fHistoTruePrimaryPi0MCPtResolPt(NULL),
389 fHistoTruePrimaryEtaMCPtResolPt(NULL),
390 fHistoTrueMotherPi0ConvPhotonEtaPhi(NULL),
391 fHistoTrueMotherEtaConvPhotonEtaPhi(NULL),
392 fHistoTrueSecondaryPi0InvMassPt(NULL),
393 fHistoTrueSecondaryEtaInvMassPt(NULL),
394 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
395 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
396 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
397 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
398 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
399 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
400 fHistoTrueBckGGInvMassPt(NULL),
401 fHistoTrueBckContInvMassPt(NULL),
402 fHistoTruePi0PtY(NULL),
403 fHistoTrueEtaPtY(NULL),
404 fHistoTruePi0PtAlpha(NULL),
405 fHistoTrueEtaPtAlpha(NULL),
406 fHistoTruePi0PtOpenAngle(NULL),
407 fHistoTrueEtaPtOpenAngle(NULL),
408 fHistoTrueConvGammaPt(NULL),
409 fHistoTrueConvPi0GammaPt(NULL),
410 fHistoTrueConvGammaEta(NULL),
411 fHistoCombinatorialPt(NULL),
412 fHistoTruePrimaryConvGammaPt(NULL),
413 fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
414 fHistoTrueSecondaryConvGammaPt(NULL),
415 fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
416 fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
417 fHistoTrueClusGammaPt(NULL),
418 fHistoTrueClusUnConvGammaPt(NULL),
419 fHistoTrueClusUnConvGammaMCPt(NULL),
420 fHistoTrueClusElectronPt(NULL),
421 fHistoTrueClusConvGammaPt(NULL),
422 fHistoTrueClusConvGammaMCPt(NULL),
423 fHistoTrueClusConvGammaFullyPt(NULL),
424 fHistoTrueClusMergedGammaPt(NULL),
425 fHistoTrueClusMergedPartConvGammaPt(NULL),
426 fHistoTrueClusDalitzPt(NULL),
427 fHistoTrueClusDalitzMergedPt(NULL),
428 fHistoTrueClusPhotonFromElecMotherPt(NULL),
429 fHistoTrueClusShowerPt(NULL),
430 fHistoTrueClusSubLeadingPt(NULL),
431 fHistoTrueClusNParticles(NULL),
432 fHistoTrueClusEMNonLeadingPt(NULL),
433 fHistoTrueNLabelsInClus(NULL),
434 fHistoTruePrimaryClusGammaPt(NULL),
435 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
437 fHistoNGoodESDTracks(NULL),
438 fHistoNGammaCandidates(NULL),
439 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
440 fHistoNV0Tracks(NULL),
441 fProfileEtaShift(NULL),
442 fEventPlaneAngle(-100),
444 fNGammaCandidates(0),
455 fMoveParticleAccordingToVertex(kTRUE),
457 fDoMesonAnalysis(kTRUE),
461 fIsFromMBHeader(kTRUE),
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 if (fDoMesonQA == 2){
623 fMesonDCAList = new TList*[fnCuts];
624 fTreeMesonsInvMassPtDcazMinDcazMaxFlag = new TTree*[fnCuts];
627 fHistoMotherPi0PtY = new TH2F*[fnCuts];
628 fHistoMotherEtaPtY = new TH2F*[fnCuts];
629 fHistoMotherPi0PtAlpha = new TH2F*[fnCuts];
630 fHistoMotherEtaPtAlpha = new TH2F*[fnCuts];
631 fHistoMotherPi0PtOpenAngle = new TH2F*[fnCuts];
632 fHistoMotherEtaPtOpenAngle = new TH2F*[fnCuts];
633 fHistoMotherPi0ConvPhotonEtaPhi = new TH2F*[fnCuts];
634 fHistoMotherEtaConvPhotonEtaPhi = new TH2F*[fnCuts];
637 fHistoMotherInvMassECalib = new TH2F*[fnCuts];
638 fHistoMotherInvMassECalibalpha = new TH2F*[fnCuts];
641 fTagOutputList = new TList*[fnCuts];
643 fHistoConvGammaUntagged = new TH1F*[fnCuts];
644 fHistoConvGammaTagged = new TH1F*[fnCuts];
645 fHistoConvGammaPi0Tagged = new TH1F*[fnCuts];
646 fHistoConvGammaEtaTagged = new TH1F*[fnCuts];
647 fHistoPhotonPairAll = new TH2F*[fnCuts];
648 fHistoPhotonPairAllGam = new TH2F*[fnCuts];
650 fHistoClusGammaPt = new TH1F*[fnCuts];
652 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
653 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
654 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
655 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
656 TString cutstringMeson = "NoMesonCut";
657 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
659 fCutFolder[iCut] = new TList();
660 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s_%s",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
661 fCutFolder[iCut]->SetOwner(kTRUE);
662 fOutputContainer->Add(fCutFolder[iCut]);
663 fESDList[iCut] = new TList();
664 fESDList[iCut]->SetName(Form("%s_%s_%s_%s ESD histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
665 fESDList[iCut]->SetOwner(kTRUE);
666 fCutFolder[iCut]->Add(fESDList[iCut]);
668 fHistoNEvents[iCut] = new TH1I("NEvents","NEvents",10,-0.5,9.5);
669 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
670 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
671 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
672 if (((AliConvEventCuts*)fEventCutArray->At(iCut))->IsSpecialTrigger() > 1 ){
673 TString TriggerNames = "Not Trigger: ";
674 TriggerNames = TriggerNames+ ( (AliConvEventCuts*)fEventCutArray->At(iCut))->GetSpecialTriggerName();
675 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
677 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
679 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
680 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
681 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
682 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
683 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
684 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(10,"EMCAL problem");
685 fESDList[iCut]->Add(fHistoNEvents[iCut]);
687 if(fIsHeavyIon == 1) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
688 else if(fIsHeavyIon == 2) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",400,0,400);
689 else fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
690 fESDList[iCut]->Add(fHistoNGoodESDTracks[iCut]);
691 if(fIsHeavyIon == 1) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
692 else if(fIsHeavyIon == 2) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
693 else fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
694 fESDList[iCut]->Add(fHistoNGammaCandidates[iCut]);
695 if(fIsHeavyIon == 1) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",4000,0,4000,100,0,100);
696 else if(fIsHeavyIon == 2) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",400,0,400,50,0,50);
697 else fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",200,0,200,50,0,50);
698 fESDList[iCut]->Add(fHistoNGoodESDTracksVsNGammaCanditates[iCut]);
701 if(fIsHeavyIon == 1) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
702 else if(fIsHeavyIon == 2) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
703 else fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
704 fESDList[iCut]->Add(fHistoNV0Tracks[iCut]);
705 fProfileEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
706 fESDList[iCut]->Add(fProfileEtaShift[iCut]);
707 fHistoConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
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("R",&fRConvPhoton,"fRConvPhoton/F");
720 // fTreeConvGammaPtDcazCat[iCut]->Branch("Eta",&fEtaPhoton,"fEtaPhoton/F");
722 fTreeConvGammaPtDcazCat[iCut]->Branch("cat",&fCharCatPhoton,"fCharCatPhoton/b");
724 fTreeConvGammaPtDcazCat[iCut]->Branch("photonMCInfo",&fCharPhotonMCInfo,"fCharPhotonMCInfo/b");
726 fPhotonDCAList[iCut]->Add(fTreeConvGammaPtDcazCat[iCut]);
729 if (fDoPhotonQA > 0){
730 fHistoConvGammaR[iCut] = new TH1F("ESD_ConvGamma_R","ESD_ConvGamma_R",800,0,200);
731 fESDList[iCut]->Add(fHistoConvGammaR[iCut]);
732 fHistoConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",2000,-2,2);
733 fESDList[iCut]->Add(fHistoConvGammaEta[iCut]);
736 fTagOutputList[iCut] = new TList();
737 fTagOutputList[iCut]->SetName(Form("%s_%s_%s_%s Tagging Output",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
738 fTagOutputList[iCut]->SetOwner(1);
739 fCutFolder[iCut]->Add(fTagOutputList[iCut]);
741 const Int_t nptbins = 200;
742 const Double_t ptmin = 0.;
743 const Double_t ptmax = 20.;
745 const Int_t nmbins = 180;
746 const Double_t mmin = 0.;
747 const Double_t mmax = 0.9;
750 // this is maybe not necessary ...
752 fHistoConvGammaUntagged[iCut] = new TH1F("ConvGammaUntagged","",nptbins,ptmin,ptmax);
753 fHistoConvGammaUntagged[iCut]->SetXTitle("p_{T} (GeV/c)");
754 fTagOutputList[iCut]->Add(fHistoConvGammaUntagged[iCut]);
756 fHistoConvGammaTagged[iCut] = new TH1F("ConvGammaTagged","",nptbins,ptmin,ptmax);
757 fHistoConvGammaTagged[iCut]->SetXTitle("p_{T} (GeV/c)");
758 fTagOutputList[iCut]->Add(fHistoConvGammaTagged[iCut]);
760 fHistoConvGammaPi0Tagged[iCut] = new TH1F("ConvGammaPi0Tagged","",nptbins,ptmin,ptmax);
761 fHistoConvGammaPi0Tagged[iCut]->SetXTitle("p_{T} (GeV/c)");
762 fTagOutputList[iCut]->Add(fHistoConvGammaPi0Tagged[iCut]);
764 fHistoConvGammaEtaTagged[iCut] = new TH1F("ConvGammaEtaTagged","",nptbins,ptmin,ptmax);
765 fHistoConvGammaEtaTagged[iCut]->SetXTitle("p_{T} (GeV/c)");
766 fTagOutputList[iCut]->Add(fHistoConvGammaEtaTagged[iCut]);
769 fHistoPhotonPairAll[iCut] = new TH2F("PhotonPairAll","",nmbins,mmin,mmax,nptbins,ptmin,ptmax);
770 fHistoPhotonPairAll[iCut]->SetXTitle("M_{inv} (GeV/cc)");
771 fHistoPhotonPairAll[iCut]->SetYTitle("p_{T} (GeV/c)");
772 fTagOutputList[iCut]->Add(fHistoPhotonPairAll[iCut]);
774 fHistoPhotonPairAllGam[iCut] = new TH2F("PhotonPairAllGammaConvPt","",nmbins,mmin,mmax,nptbins,ptmin,ptmax);
775 fHistoPhotonPairAllGam[iCut]->SetXTitle("M_{inv} (GeV/cc)");
776 fHistoPhotonPairAllGam[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
777 fTagOutputList[iCut]->Add(fHistoPhotonPairAllGam[iCut]);
779 fHistoClusGammaPt[iCut] = new TH1F("ClusGamma_Pt","ClusGamma_Pt",250,0,25);
780 fTagOutputList[iCut]->Add(fHistoClusGammaPt[iCut]);
783 if(fDoMesonAnalysis){
784 fHistoMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
785 fESDList[iCut]->Add(fHistoMotherInvMassPt[iCut]);
786 fHistoMotherMatchedInvMassPt[iCut] = new TH2F("ESD_MotherMatched_InvMass_Pt","ESD_MotherMatched_InvMass_Pt",800,0,0.8,250,0,25);
787 fESDList[iCut]->Add(fHistoMotherMatchedInvMassPt[iCut]);
788 fHistoMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
789 fESDList[iCut]->Add(fHistoMotherBackInvMassPt[iCut]);
790 fHistoMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
791 fESDList[iCut]->Add(fHistoMotherInvMassEalpha[iCut]);
792 if (fDoMesonQA == 2){
793 fMesonDCAList[iCut] = new TList();
794 fMesonDCAList[iCut]->SetName(Form("%s_%s_%s_%s Meson DCA tree",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
795 fMesonDCAList[iCut]->SetOwner(kTRUE);
796 fCutFolder[iCut]->Add(fMesonDCAList[iCut]);
798 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut] = new TTree("ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag","ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag");
799 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("InvMass",&fInvMass,"fInvMass/F");
800 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("Pt",&fPt,"fPt/F");
801 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMin",&fDCAzGammaMin,"fDCAzGammaMin/F");
802 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMax",&fDCAzGammaMax,"fDCAzGammaMax/F");
803 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("kind",&fCharFlag,"fCharFlag/b");
805 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("mesonMCInfo",&fCharMesonMCInfo,"fCharMesonMCInfo/b");
807 fMesonDCAList[iCut]->Add(fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]);
811 fHistoMotherInvMassECalib[iCut] = new TH2F("ESD_Mother_InvMass_E_Calib","ESD_Mother_InvMass_E_Calib",800,0,0.8,250,0,25);
812 fESDList[iCut]->Add(fHistoMotherInvMassECalib[iCut]);
813 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);
814 fESDList[iCut]->Add(fHistoMotherInvMassECalibalpha[iCut]);
817 if (fDoMesonQA > 0 ){
818 fHistoMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
819 SetLogBinningXTH2(fHistoMotherPi0PtY[iCut]);
820 fESDList[iCut]->Add(fHistoMotherPi0PtY[iCut]);
821 fHistoMotherEtaPtY[iCut] = new TH2F("ESD_MotherEta_Pt_Y","ESD_MotherEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
822 SetLogBinningXTH2(fHistoMotherEtaPtY[iCut]);
823 fESDList[iCut]->Add(fHistoMotherEtaPtY[iCut]);
824 fHistoMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",150,0.03,15.,100,0,1);
825 SetLogBinningXTH2(fHistoMotherPi0PtAlpha[iCut]);
826 fESDList[iCut]->Add(fHistoMotherPi0PtAlpha[iCut]);
827 fHistoMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",150,0.03,15.,100,0,1);
828 SetLogBinningXTH2(fHistoMotherEtaPtAlpha[iCut]);
829 fESDList[iCut]->Add(fHistoMotherEtaPtAlpha[iCut]);
830 fHistoMotherPi0PtOpenAngle[iCut] = new TH2F("ESD_MotherPi0_Pt_OpenAngle","ESD_MotherPi0_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
831 SetLogBinningXTH2(fHistoMotherPi0PtOpenAngle[iCut]);
832 fESDList[iCut]->Add(fHistoMotherPi0PtOpenAngle[iCut]);
833 fHistoMotherEtaPtOpenAngle[iCut] = new TH2F("ESD_MotherEta_Pt_OpenAngle","ESD_MotherEta_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
834 SetLogBinningXTH2(fHistoMotherEtaPtOpenAngle[iCut]);
835 fESDList[iCut]->Add(fHistoMotherEtaPtOpenAngle[iCut]);
836 fHistoMotherPi0ConvPhotonEtaPhi[iCut] = new TH2F("ESD_MotherPi0ConvPhoton_Eta_Phi","ESD_MotherPi0ConvPhoton_Eta_Phi",600,0,2*TMath::Pi(),400,-2,2);
837 fESDList[iCut]->Add(fHistoMotherPi0ConvPhotonEtaPhi[iCut]);
838 fHistoMotherEtaConvPhotonEtaPhi[iCut] = new TH2F("ESD_MotherEtaConvPhoton_Eta_Phi","ESD_MotherEtaConvPhoton_Eta_Phi",600,0,2*TMath::Pi(),400,-2,2);
839 fESDList[iCut]->Add(fHistoMotherEtaConvPhotonEtaPhi[iCut]);
843 if(fDoMesonAnalysis){
844 InitBack(); // Init Background Handler
849 fMCList = new TList*[fnCuts];
851 fTrueList = new TList*[fnCuts];
852 // Selected Header List
853 fHeaderNameList = new TList*[fnCuts];
854 fHistoMCHeaders = new TH1I*[fnCuts];
855 fHistoMCAllGammaPt = new TH1F*[fnCuts];
856 fHistoMCAllGammaEMCALAccPt = new TH1F*[fnCuts];
857 fHistoMCDecayGammaPi0Pt = new TH1F*[fnCuts];
858 fHistoMCDecayGammaRhoPt = new TH1F*[fnCuts];
859 fHistoMCDecayGammaEtaPt = new TH1F*[fnCuts];
860 fHistoMCDecayGammaOmegaPt = new TH1F*[fnCuts];
861 fHistoMCDecayGammaEtapPt = new TH1F*[fnCuts];
862 fHistoMCDecayGammaPhiPt = new TH1F*[fnCuts];
863 fHistoMCDecayGammaSigmaPt = new TH1F*[fnCuts];
864 fHistoMCConvGammaPt = new TH1F*[fnCuts];
865 fHistoTrueConvGammaPt = new TH1F*[fnCuts];
866 fHistoTrueConvPi0GammaPt = new TH1F*[fnCuts];
868 fHistoCombinatorialPt = new TH2F*[fnCuts];
869 fHistoTruePrimaryConvGammaPt = new TH1F*[fnCuts];
870 fHistoTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
871 fHistoTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
872 fHistoTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
873 fHistoTrueSecondaryConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
875 fHistoTrueClusGammaPt = new TH1F*[fnCuts];
876 fHistoTruePrimaryClusGammaPt = new TH1F*[fnCuts];
877 fHistoTruePrimaryClusGammaESDPtMCPt = new TH2F*[fnCuts];
879 if (fDoPhotonQA > 0){
880 fHistoMCConvGammaR = new TH1F*[fnCuts];
881 fHistoMCConvGammaEta = new TH1F*[fnCuts];
882 fHistoTrueConvGammaEta = new TH1F*[fnCuts];
884 if (fDoClusterQA > 0){
885 fHistoTrueClusUnConvGammaPt = new TH1F*[fnCuts];
886 fHistoTrueClusUnConvGammaMCPt = new TH1F*[fnCuts];
887 fHistoTrueClusElectronPt = new TH1F*[fnCuts];
888 fHistoTrueClusConvGammaPt = new TH1F*[fnCuts];
889 fHistoTrueClusConvGammaMCPt = new TH1F*[fnCuts];
890 fHistoTrueClusConvGammaFullyPt = new TH1F*[fnCuts];
891 fHistoTrueClusMergedGammaPt = new TH1F*[fnCuts];
892 fHistoTrueClusMergedPartConvGammaPt = new TH1F*[fnCuts];
893 fHistoTrueClusDalitzPt = new TH1F*[fnCuts];
894 fHistoTrueClusDalitzMergedPt = new TH1F*[fnCuts];
895 fHistoTrueClusPhotonFromElecMotherPt= new TH1F*[fnCuts];
896 fHistoTrueClusShowerPt = new TH1F*[fnCuts];
897 fHistoTrueClusSubLeadingPt = new TH1F*[fnCuts];
898 fHistoTrueClusNParticles = new TH1I*[fnCuts];
899 fHistoTrueClusEMNonLeadingPt = new TH1F*[fnCuts];
900 fHistoTrueNLabelsInClus = new TH1F*[fnCuts];
903 if(fDoMesonAnalysis){
904 fHistoMCPi0Pt = new TH1F*[fnCuts];
905 fHistoMCPi0WOWeightPt = new TH1F*[fnCuts];
906 fHistoMCEtaPt = new TH1F*[fnCuts];
907 fHistoMCEtaWOWeightPt = new TH1F*[fnCuts];
908 fHistoMCPi0InAccPt = new TH1F*[fnCuts];
909 fHistoMCEtaInAccPt = new TH1F*[fnCuts];
911 fHistoTruePi0InvMassPt = new TH2F*[fnCuts];
912 fHistoTrueEtaInvMassPt = new TH2F*[fnCuts];
913 fHistoTruePrimaryPi0InvMassPt = new TH2F*[fnCuts];
914 fHistoTruePrimaryEtaInvMassPt = new TH2F*[fnCuts];
915 fHistoTruePrimaryPi0W0WeightingInvMassPt = new TH2F*[fnCuts];
916 fHistoTruePrimaryEtaW0WeightingInvMassPt = new TH2F*[fnCuts];
917 fProfileTruePrimaryPi0WeightsInvMassPt = new TProfile2D*[fnCuts];
918 fProfileTruePrimaryEtaWeightsInvMassPt = new TProfile2D*[fnCuts];
919 fHistoTrueSecondaryPi0InvMassPt = new TH2F*[fnCuts];
920 fHistoTrueSecondaryEtaInvMassPt = new TH2F*[fnCuts];
921 fHistoTrueSecondaryPi0FromK0sInvMassPt = new TH2F*[fnCuts];
922 fHistoTrueSecondaryPi0FromEtaInvMassPt = new TH2F*[fnCuts];
923 fHistoTrueSecondaryPi0FromLambdaInvMassPt = new TH2F*[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];
969 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
970 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
971 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
972 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
973 TString cutstringMeson = "NoMesonCut";
974 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
976 fMCList[iCut] = new TList();
977 fMCList[iCut]->SetName(Form("%s_%s_%s_%s MC histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
978 fMCList[iCut]->SetOwner(kTRUE);
979 fCutFolder[iCut]->Add(fMCList[iCut]);
980 fHistoMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
981 fMCList[iCut]->Add(fHistoMCHeaders[iCut]);
982 fHistoMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
983 fMCList[iCut]->Add(fHistoMCAllGammaPt[iCut]);
984 fHistoMCAllGammaEMCALAccPt[iCut] = new TH1F("MC_AllGammaEMCALAcc_Pt","MC_AllGammaEMCALAcc_Pt",250,0,25);
985 fMCList[iCut]->Add(fHistoMCAllGammaEMCALAccPt[iCut]);
986 fHistoMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
987 fMCList[iCut]->Add(fHistoMCDecayGammaPi0Pt[iCut]);
988 fHistoMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
989 fMCList[iCut]->Add(fHistoMCDecayGammaRhoPt[iCut]);
990 fHistoMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
991 fMCList[iCut]->Add(fHistoMCDecayGammaEtaPt[iCut]);
992 fHistoMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
993 fMCList[iCut]->Add(fHistoMCDecayGammaOmegaPt[iCut]);
994 fHistoMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
995 fMCList[iCut]->Add(fHistoMCDecayGammaEtapPt[iCut]);
996 fHistoMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
997 fMCList[iCut]->Add(fHistoMCDecayGammaPhiPt[iCut]);
998 fHistoMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
999 fMCList[iCut]->Add(fHistoMCDecayGammaSigmaPt[iCut]);
1000 fHistoMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
1001 fMCList[iCut]->Add(fHistoMCConvGammaPt[iCut]);
1003 if (fDoPhotonQA > 0){
1004 fHistoMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
1005 fMCList[iCut]->Add(fHistoMCConvGammaR[iCut]);
1006 fHistoMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",2000,-2,2);
1007 fMCList[iCut]->Add(fHistoMCConvGammaEta[iCut]);
1010 if(fDoMesonAnalysis){
1011 fHistoMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
1012 fHistoMCPi0Pt[iCut]->Sumw2();
1013 fMCList[iCut]->Add(fHistoMCPi0Pt[iCut]);
1014 fHistoMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
1015 fHistoMCPi0WOWeightPt[iCut]->Sumw2();
1016 fMCList[iCut]->Add(fHistoMCPi0WOWeightPt[iCut]);
1018 fHistoMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
1019 fHistoMCEtaPt[iCut]->Sumw2();
1020 fMCList[iCut]->Add(fHistoMCEtaPt[iCut]);
1021 fHistoMCEtaWOWeightPt[iCut] = new TH1F("MC_Eta_WOWeights_Pt","MC_Eta_WOWeights_Pt",250,0,25);
1022 fHistoMCEtaWOWeightPt[iCut]->Sumw2();
1023 fMCList[iCut]->Add(fHistoMCEtaWOWeightPt[iCut]);
1024 fHistoMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
1025 fHistoMCPi0InAccPt[iCut]->Sumw2();
1026 fMCList[iCut]->Add(fHistoMCPi0InAccPt[iCut]);
1027 fHistoMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
1028 fHistoMCEtaInAccPt[iCut]->Sumw2();
1029 fMCList[iCut]->Add(fHistoMCEtaInAccPt[iCut]);
1030 if (fDoMesonQA > 0){
1031 fHistoMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1032 fHistoMCPi0PtY[iCut]->Sumw2();
1033 SetLogBinningXTH2(fHistoMCPi0PtY[iCut]);
1034 fMCList[iCut]->Add(fHistoMCPi0PtY[iCut]);
1035 fHistoMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1036 fHistoMCEtaPtY[iCut]->Sumw2();
1037 SetLogBinningXTH2(fHistoMCEtaPtY[iCut]);
1038 fMCList[iCut]->Add(fHistoMCEtaPtY[iCut]);
1039 fHistoMCPi0PtAlpha[iCut] = new TH2F("MC_Pi0_Pt_Alpha","MC_Pi0_Pt_Alpha",150,0.03,15.,100,0,1);
1040 SetLogBinningXTH2(fHistoMCPi0PtAlpha[iCut]);
1041 fMCList[iCut]->Add(fHistoMCPi0PtAlpha[iCut]);
1042 fHistoMCEtaPtAlpha[iCut] = new TH2F("MC_Eta_Pt_Alpha","MC_Eta_Pt_Alpha",150,0.03,15.,100,0,1);
1043 SetLogBinningXTH2(fHistoMCEtaPtAlpha[iCut]);
1044 fMCList[iCut]->Add(fHistoMCEtaPtAlpha[iCut]);
1046 fHistoMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",150,0,15);
1047 fHistoMCK0sPt[iCut]->Sumw2();
1048 fMCList[iCut]->Add(fHistoMCK0sPt[iCut]);
1049 fHistoMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",150,0,15);
1050 fHistoMCK0sWOWeightPt[iCut]->Sumw2();
1051 fMCList[iCut]->Add(fHistoMCK0sWOWeightPt[iCut]);
1052 fHistoMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1053 fHistoMCK0sPtY[iCut]->Sumw2();
1054 SetLogBinningXTH2(fHistoMCK0sPtY[iCut]);
1055 fMCList[iCut]->Add(fHistoMCK0sPtY[iCut]);
1057 fHistoMCSecPi0Source[iCut] = new TH1F("MC_SecPi0_Source","MC_SecPi0_Source",5000,0.,5000);
1058 fMCList[iCut]->Add(fHistoMCSecPi0Source[iCut]);
1059 fHistoMCSecEtaSource[iCut] = new TH1F("MC_SecEta_Source","MC_SecEta_Source",5000,0,5000);
1060 fMCList[iCut]->Add(fHistoMCSecEtaSource[iCut]);
1061 fHistoMCSecPi0PtvsSource[iCut] = new TH2F("MC_SecPi0_Pt_Source","MC_SecPi0_Pt_Source",250,0.0,25.,16,-0.5,15.5);
1062 fHistoMCSecPi0PtvsSource[iCut]->Sumw2();
1063 fMCList[iCut]->Add(fHistoMCSecPi0PtvsSource[iCut]);
1064 fHistoMCSecEtaPt[iCut] = new TH1F("MC_SecEta_Pt","MC_SecEta_Pt",250,0,25);
1065 fHistoMCSecEtaPt[iCut]->Sumw2();
1066 fMCList[iCut]->Add(fHistoMCSecEtaPt[iCut]);
1070 fTrueList[iCut] = new TList();
1071 fTrueList[iCut]->SetName(Form("%s_%s_%s_%s True histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
1072 fTrueList[iCut]->SetOwner(kTRUE);
1073 fCutFolder[iCut]->Add(fTrueList[iCut]);
1075 fHistoTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
1076 fTrueList[iCut]->Add(fHistoTrueConvGammaPt[iCut]);
1078 fHistoTrueConvPi0GammaPt[iCut] = new TH1F("ESD_TrueConvPi0Gamma_Pt","ESD_TrueConvPi0Gamma_Pt",250,0,25);
1079 fTrueList[iCut]->Add(fHistoTrueConvPi0GammaPt[iCut]);
1081 fHistoCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
1082 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
1083 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
1084 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
1085 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
1086 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
1087 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
1088 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
1089 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
1090 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
1091 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
1092 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
1093 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
1094 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
1095 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
1096 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
1097 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
1098 fTrueList[iCut]->Add(fHistoCombinatorialPt[iCut]);
1099 fHistoTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
1100 fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaPt[iCut]);
1101 fHistoTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
1102 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaPt[iCut]);
1104 fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
1105 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
1106 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
1107 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
1109 fHistoTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
1110 fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaESDPtMCPt[iCut]);
1112 fHistoTrueClusGammaPt[iCut] = new TH1F("TrueClusGamma_Pt","ESD_TrueClusGamma_Pt",250,0,25);
1113 fTagOutputList[iCut]->Add(fHistoTrueClusGammaPt[iCut]);
1114 fHistoTruePrimaryClusGammaPt[iCut] = new TH1F("TruePrimaryClusGamma_Pt","ESD_TruePrimaryClusGamma_Pt",250,0,25);
1115 fTagOutputList[iCut]->Add(fHistoTruePrimaryClusGammaPt[iCut]);
1116 fHistoTruePrimaryClusGammaESDPtMCPt[iCut] = new TH2F("TruePrimaryClusGamma_Pt_MCPt","ESD_TruePrimaryClusGamma_MCPt",250,0,25,250,0,25);
1117 fTagOutputList[iCut]->Add(fHistoTruePrimaryClusGammaESDPtMCPt[iCut]);
1119 if (fDoPhotonQA > 0){
1120 fHistoTrueConvGammaEta[iCut] = new TH1F("ESD_TrueConvGamma_Eta","ESD_TrueConvGamma_Eta",2000,-2,2);
1121 fTrueList[iCut]->Add(fHistoTrueConvGammaEta[iCut]);
1123 if (fDoClusterQA > 0){
1124 fHistoTrueClusUnConvGammaPt[iCut] = new TH1F("TrueClusUnConvGamma_Pt","TrueClusUnConvGamma_Pt",250,0,25);
1125 fTagOutputList[iCut]->Add(fHistoTrueClusUnConvGammaPt[iCut]);
1126 fHistoTrueClusUnConvGammaMCPt[iCut] = new TH1F("TrueClusUnConvGamma_MCPt","TrueClusUnConvGamma_MCPt",250,0,25);
1127 fTagOutputList[iCut]->Add(fHistoTrueClusUnConvGammaMCPt[iCut]);
1128 fHistoTrueClusElectronPt[iCut] = new TH1F("TrueClusElectron_Pt","TrueElectronGamma_Pt",250,0,25);
1129 fTagOutputList[iCut]->Add(fHistoTrueClusElectronPt[iCut]);
1130 fHistoTrueClusConvGammaPt[iCut] = new TH1F("TrueClusConvGamma_Pt","TrueClusConvGamma_Pt",250,0,25);
1131 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaPt[iCut]);
1132 fHistoTrueClusConvGammaMCPt[iCut] = new TH1F("TrueClusConvGamma_MCPt","TrueClusConvGamma_MCPt",250,0,25);
1133 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaMCPt[iCut]);
1134 fHistoTrueClusConvGammaFullyPt[iCut] = new TH1F("TrueClusConvGammaFullyContained_Pt","TrueClusConvGammaFullyContained_Pt",250,0,25);
1135 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaFullyPt[iCut]);
1136 fHistoTrueClusMergedGammaPt[iCut] = new TH1F("TrueClusMergedGamma_Pt","TrueClusMergedGamma_Pt",250,0,25);
1137 fTagOutputList[iCut]->Add(fHistoTrueClusMergedGammaPt[iCut]);
1138 fHistoTrueClusMergedPartConvGammaPt[iCut] = new TH1F("TrueClusMergedPartConvGamma_Pt","TrueClusMergedPartConvGamma_Pt",250,0,25);
1139 fTagOutputList[iCut]->Add(fHistoTrueClusMergedPartConvGammaPt[iCut]);
1140 fHistoTrueClusDalitzPt[iCut] = new TH1F("TrueClusDalitz_Pt","TrueClusDalitz_Pt",250,0,25);
1141 fTagOutputList[iCut]->Add(fHistoTrueClusDalitzPt[iCut]);
1142 fHistoTrueClusDalitzMergedPt[iCut] = new TH1F("TrueClusDalitzMerged_Pt","TrueClusDalitzMerged_Pt",250,0,25);
1143 fTagOutputList[iCut]->Add(fHistoTrueClusDalitzMergedPt[iCut]);
1144 fHistoTrueClusPhotonFromElecMotherPt[iCut] = new TH1F("TrueClusPhotonFromElecMother_Pt","TrueClusPhotonFromElecMother_Pt",250,0,25);
1145 fTagOutputList[iCut]->Add(fHistoTrueClusPhotonFromElecMotherPt[iCut]);
1146 fHistoTrueClusShowerPt[iCut] = new TH1F("TrueClusShower_Pt","TrueClusShower_Pt",250,0,25);
1147 fTagOutputList[iCut]->Add(fHistoTrueClusShowerPt[iCut]);
1148 fHistoTrueClusSubLeadingPt[iCut] = new TH1F("TrueClusSubleading_Pt","TrueClusSubleading_Pt",250,0,25);
1149 fTagOutputList[iCut]->Add(fHistoTrueClusSubLeadingPt[iCut]);
1150 fHistoTrueClusNParticles[iCut] = new TH1I("TrueClusNParticles","TrueClusNParticles",20,0,20);
1151 fTagOutputList[iCut]->Add(fHistoTrueClusNParticles[iCut]);
1152 fHistoTrueClusEMNonLeadingPt[iCut] = new TH1F("TrueClusEMNonLeading_Pt","TrueClusEMNonLeading_Pt",250,0,25);
1153 fTagOutputList[iCut]->Add(fHistoTrueClusEMNonLeadingPt[iCut]);
1154 fHistoTrueNLabelsInClus[iCut] = new TH1F("TrueNLabelsInClus","TrueNLabelsInClus",100,-0.5,99.5);
1155 fTagOutputList[iCut]->Add(fHistoTrueNLabelsInClus[iCut]);
1158 if(fDoMesonAnalysis){
1159 fHistoTruePi0InvMassPt[iCut] = new TH2F("ESD_TruePi0_InvMass_Pt","ESD_TruePi0_InvMass_Pt",800,0,0.8,250,0,25);
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 fTrueList[iCut]->Add(fHistoTrueEtaInvMassPt[iCut]);
1164 fHistoTruePrimaryPi0InvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0_InvMass_Pt", "ESD_TruePrimaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1165 fHistoTruePrimaryPi0InvMassPt[iCut]->Sumw2();
1166 fTrueList[iCut]->Add(fHistoTruePrimaryPi0InvMassPt[iCut]);
1167 fHistoTruePrimaryEtaInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEta_InvMass_Pt", "ESD_TruePrimaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
1168 fHistoTruePrimaryEtaInvMassPt[iCut]->Sumw2();
1169 fTrueList[iCut]->Add(fHistoTruePrimaryEtaInvMassPt[iCut]);
1171 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0W0Weights_InvMass_Pt", "ESD_TruePrimaryPi0W0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1172 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]->Sumw2();
1173 fTrueList[iCut]->Add(fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]);
1174 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEtaW0Weights_InvMass_Pt", "ESD_TruePrimaryEtaW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1175 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]->Sumw2();
1176 fTrueList[iCut]->Add(fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]);
1178 fProfileTruePrimaryPi0WeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryPi0Weights_InvMass_Pt", "ESD_TruePrimaryPi0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1179 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->Sumw2();
1180 fTrueList[iCut]->Add(fProfileTruePrimaryPi0WeightsInvMassPt[iCut]);
1181 fProfileTruePrimaryEtaWeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryEtaWeights_InvMass_Pt", "ESD_TruePrimaryEtaWeights_InvMass_Pt", 800,0,0.8,250,0,25);
1182 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->Sumw2();
1183 fTrueList[iCut]->Add(fProfileTruePrimaryEtaWeightsInvMassPt[iCut]);
1185 fHistoTrueSecondaryPi0InvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0_InvMass_Pt", "ESD_TrueSecondaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1186 fHistoTrueSecondaryPi0InvMassPt[iCut]->Sumw2();
1187 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0InvMassPt[iCut]);
1188 fHistoTrueSecondaryEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryEta_InvMass_Pt", "ESD_TrueSecondaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
1189 fHistoTrueSecondaryEtaInvMassPt[iCut]->Sumw2();
1190 fTrueList[iCut]->Add(fHistoTrueSecondaryEtaInvMassPt[iCut]);
1192 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromK0s_InvMass_Pt","ESD_TrueSecondaryPi0FromK0s_InvMass_Pt",800,0,0.8,250,0,25);
1193 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->Sumw2();
1194 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]);
1195 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromEta_InvMass_Pt","ESD_TrueSecondaryPi0FromEta_InvMass_Pt",800,0,0.8,250,0,25);
1196 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]);
1197 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromLambda_InvMass_Pt","ESD_TrueSecondaryPi0FromLambda_InvMass_Pt",800,0,0.8,250,0,25);
1198 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]);
1199 if (fDoMesonQA > 0){
1200 fHistoTruePi0CaloPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloPhoton_InvMass_Pt","ESD_TruePi0CaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1201 fTrueList[iCut]->Add(fHistoTruePi0CaloPhotonInvMassPt[iCut]);
1202 fHistoTrueEtaCaloPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloPhoton_InvMass_Pt","ESD_TrueEtaCaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1203 fTrueList[iCut]->Add(fHistoTrueEtaCaloPhotonInvMassPt[iCut]);
1204 fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhoton_InvMass_Pt","ESD_TruePi0CaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1205 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]);
1206 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt","ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1207 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut]);
1208 fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt","ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1209 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]);
1210 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt","ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1211 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut]);
1213 fHistoTruePi0CaloElectronInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloElectron_InvMass_Pt","ESD_TruePi0CaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1214 fTrueList[iCut]->Add(fHistoTruePi0CaloElectronInvMassPt[iCut]);
1215 fHistoTrueEtaCaloElectronInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloElectron_InvMass_Pt","ESD_TrueEtaCaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1216 fTrueList[iCut]->Add(fHistoTrueEtaCaloElectronInvMassPt[iCut]);
1218 fHistoTruePi0CaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedCluster_InvMass_Pt","ESD_TruePi0CaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1219 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterInvMassPt[iCut]);
1220 fHistoTrueEtaCaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedCluster_InvMass_Pt","ESD_TrueEtaCaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1221 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]);
1223 fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut] = new TH2F("ESD_TrueMotherCaloEMNonLeading_InvMass_Pt","ESD_TrueMotherCaloEMNonLeading_InvMass_Pt",800,0,0.8,250,0,25);
1224 fTrueList[iCut]->Add(fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut]);
1225 fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt","ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1226 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]);
1227 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt","ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1228 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]);
1230 fHistoTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1231 fHistoTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
1232 SetLogBinningXTH2(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1233 fTrueList[iCut]->Add(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1234 fHistoTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1235 fHistoTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
1236 SetLogBinningXTH2(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1237 fTrueList[iCut]->Add(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1238 fHistoTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
1239 fTrueList[iCut]->Add(fHistoTrueBckGGInvMassPt[iCut]);
1240 fHistoTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
1241 fTrueList[iCut]->Add(fHistoTrueBckContInvMassPt[iCut]);
1242 fHistoTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
1243 fTrueList[iCut]->Add(fHistoTrueK0sWithPi0DaughterMCPt[iCut]);
1244 fHistoTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
1245 fTrueList[iCut]->Add(fHistoTrueEtaWithPi0DaughterMCPt[iCut]);
1246 fHistoTrueLambdaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueLambdaWithPi0Daughter_MCPt","ESD_TrueLambdaWithPi0Daughter_MCPt",250,0,25);
1247 fTrueList[iCut]->Add(fHistoTrueLambdaWithPi0DaughterMCPt[iCut]);
1249 fHistoTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1250 SetLogBinningXTH2(fHistoTruePi0PtY[iCut]);
1251 fTrueList[iCut]->Add(fHistoTruePi0PtY[iCut]);
1252 fHistoTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1253 SetLogBinningXTH2(fHistoTrueEtaPtY[iCut]);
1254 fTrueList[iCut]->Add(fHistoTrueEtaPtY[iCut]);
1255 fHistoTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",150,0.03,15.,100,0,1);
1256 SetLogBinningXTH2(fHistoTruePi0PtAlpha[iCut]);
1257 fTrueList[iCut]->Add(fHistoTruePi0PtAlpha[iCut]);
1258 fHistoTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",150,0.03,15.,100,0,1);
1259 SetLogBinningXTH2(fHistoTrueEtaPtAlpha[iCut]);
1260 fTrueList[iCut]->Add(fHistoTrueEtaPtAlpha[iCut]);
1262 fHistoTruePi0PtOpenAngle[iCut] = new TH2F("ESD_TruePi0_Pt_OpenAngle","ESD_TruePi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1263 SetLogBinningXTH2(fHistoTruePi0PtOpenAngle[iCut]);
1264 fTrueList[iCut]->Add(fHistoTruePi0PtOpenAngle[iCut]);
1265 fHistoTrueEtaPtOpenAngle[iCut] = new TH2F("ESD_TrueEta_Pt_OpenAngle","ESD_TrueEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1266 SetLogBinningXTH2(fHistoTrueEtaPtOpenAngle[iCut]);
1267 fTrueList[iCut]->Add(fHistoTrueEtaPtOpenAngle[iCut]);
1269 fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut] = new TH2F("ESD_TrueMotherPi0ConvPhoton_Eta_Phi","ESD_TrueMotherPi0ConvPhoton_Eta_Phi",600,0,2*TMath::Pi(),400,-2,2);
1270 fTrueList[iCut]->Add(fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut]);
1271 fHistoTrueMotherEtaConvPhotonEtaPhi[iCut] = new TH2F("ESD_TrueMotherEtaConvPhoton_Eta_Phi","ESD_TrueMotherEtaConvPhoton_Eta_Phi",600,0,2*TMath::Pi(),400,-2,2);
1272 fTrueList[iCut]->Add(fHistoTrueMotherEtaConvPhotonEtaPhi[iCut]);
1279 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1280 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1283 if((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())
1284 if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1285 fOutputContainer->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1287 if((AliConvEventCuts*)fV0Reader->GetEventCuts())
1288 if(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms())
1289 fOutputContainer->Add(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms());
1292 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1293 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))) continue;
1294 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms()){
1295 fCutFolder[iCut]->Add(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms());
1297 if(!((AliConversionPhotonCuts*)fCutArray->At(iCut))) continue;
1298 if(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms()){
1299 fCutFolder[iCut]->Add(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms());
1301 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))) continue;
1302 if(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms()){
1303 fCutFolder[iCut]->Add(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms());
1305 if(fDoMesonAnalysis){
1306 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
1307 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
1308 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
1312 PostData(1, fOutputContainer);
1314 //_____________________________________________________________________________
1315 Bool_t AliAnalysisTaskGammaConvCalo::Notify()
1317 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1318 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))->GetDoEtaShift()){
1319 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1320 continue; // No Eta Shift requested, continue
1322 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1323 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
1324 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1325 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1329 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
1330 (((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber()).Data(),((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift());
1331 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1332 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1338 //_____________________________________________________________________________
1339 void AliAnalysisTaskGammaConvCalo::UserExec(Option_t *)
1342 // Called for each event
1344 Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
1345 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1346 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1347 fHistoNEvents[iCut]->Fill(eventQuality);
1352 if(fIsMC) fMCEvent = MCEvent();
1353 if(fMCEvent == NULL) fIsMC = kFALSE;
1355 fInputEvent = InputEvent();
1357 if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
1358 fMCStack = fMCEvent->Stack();
1359 if(fMCStack == NULL) fIsMC = kFALSE;
1362 if(fInputEvent->IsA()==AliAODEvent::Class()){
1363 fInputEvent->InitMagneticField();
1366 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
1368 // ------------------- BeginEvent ----------------------------
1370 AliEventplane *EventPlane = fInputEvent->GetEventplane();
1371 if(fIsHeavyIon ==1)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
1372 else fEventPlaneAngle=0.0;
1374 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1375 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
1376 fV0Reader->RelabelAODs(kTRUE);
1380 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1384 Bool_t isRunningEMCALrelAna = kFALSE;
1385 if (((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->GetClusterType() == 1) isRunningEMCALrelAna = kTRUE;
1387 Int_t eventNotAccepted = ((AliConvEventCuts*)fEventCutArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon,isRunningEMCALrelAna);
1389 if(eventNotAccepted){
1390 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1391 fHistoNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1395 if(eventQuality != 0){// Event Not Accepted
1396 //cout << "event rejected due to: " <<eventQuality << endl;
1397 fHistoNEvents[iCut]->Fill(eventQuality);
1401 fHistoNEvents[iCut]->Fill(eventQuality); // Should be 0 here
1402 fHistoNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
1403 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->IsHeavyIon() == 2) fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
1404 else fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1407 // Process MC Particle
1408 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection() != 0){
1409 if(fInputEvent->IsA()==AliESDEvent::Class()){
1410 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1411 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1414 else if(fInputEvent->IsA()==AliAODEvent::Class()){
1415 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1416 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1420 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader()){
1421 for(Int_t i = 0;i<(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
1422 TString nameBin= fHistoMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
1423 if (nameBin.CompareTo("")== 0){
1424 TString nameHeader = ((TObjString*)((TList*)((AliConvEventCuts*)fEventCutArray->At(iCut))
1425 ->GetAcceptedHeader())->At(i))->GetString();
1426 fHistoMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
1433 if(fInputEvent->IsA()==AliESDEvent::Class())
1434 ProcessMCParticles();
1435 if(fInputEvent->IsA()==AliAODEvent::Class())
1436 ProcessAODMCParticles();
1439 // 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)
1440 ProcessClusters(); // process calo clusters
1441 ProcessPhotonCandidates(); // Process this cuts gammas
1443 fHistoNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
1444 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks(),fGammaCandidates->GetEntries());
1445 if(fDoMesonAnalysis){ // Meson Analysis
1446 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1447 fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
1448 fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
1449 fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
1450 fUnsmearedE = new Double_t[fGammaCandidates->GetEntries()];
1452 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1453 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
1454 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
1455 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
1456 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
1457 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
1461 PhotonTagging(); // tag PCM photons with calorimeter
1463 CalculatePi0Candidates(); // Combine Gammas from conversion and from calo
1465 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1466 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1467 CalculateBackground(); // Combinatorial Background
1468 UpdateEventByEventData(); // Store Event for mixed Events
1471 CalculateBackgroundRP(); // Combinatorial Background
1472 fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
1473 fBGClusHandlerRP[iCut]->AddEvent(fClusterCandidates,fInputEvent); // Store Event for mixed Events
1476 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1477 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1478 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1479 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1480 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1481 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
1483 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1484 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1485 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1486 delete[] fUnsmearedE; fUnsmearedE = 0x0;
1490 fGammaCandidates->Clear(); // delete this cuts good gammas
1491 fClusterCandidates->Clear(); // delete cluster candidates
1494 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1495 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
1496 fV0Reader->RelabelAODs(kFALSE);
1499 PostData(1, fOutputContainer);
1502 //________________________________________________________________________
1503 void AliAnalysisTaskGammaConvCalo::ProcessClusters()
1507 nclus = fInputEvent->GetNumberOfCaloClusters();
1509 // cout << nclus << endl;
1511 if(nclus == 0) return;
1514 Double_t vertex[3] = {0};
1515 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1517 // Loop over EMCal clusters
1518 for(Long_t i = 0; i < nclus; i++){
1520 AliVCluster* clus = NULL;
1521 clus = fInputEvent->GetCaloCluster(i);
1522 if (!clus) continue;
1523 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelected(clus,fInputEvent,fIsMC)) continue;
1524 // TLorentzvector with cluster
1525 TLorentzVector clusterVector;
1526 clus->GetMomentum(clusterVector,vertex);
1528 TLorentzVector* tmpvec = new TLorentzVector();
1529 tmpvec->SetPxPyPzE(clusterVector.Px(),clusterVector.Py(),clusterVector.Pz(),clusterVector.E());
1531 // convert to AODConversionPhoton
1532 AliAODConversionPhoton *PhotonCandidate=new AliAODConversionPhoton(tmpvec);
1533 if(!PhotonCandidate) continue;
1535 // Flag Photon as CaloPhoton
1536 PhotonCandidate->SetIsCaloPhoton();
1537 PhotonCandidate->SetCaloClusterRef(i);
1540 Int_t* mclabelsCluster = clus->GetLabels();
1541 PhotonCandidate->SetNCaloPhotonMCLabels(clus->GetNLabels());
1542 // cout << clus->GetNLabels() << endl;
1543 if (clus->GetNLabels()>0){
1544 for (Int_t k =0; k< (Int_t)clus->GetNLabels(); k++){
1545 if (k< 20)PhotonCandidate->SetCaloPhotonMCLabel(k,mclabelsCluster[k]);
1546 // Int_t pdgCode = fMCStack->Particle(mclabelsCluster[k])->GetPdgCode();
1547 // cout << "label " << k << "\t" << mclabelsCluster[k] << " pdg code: " << pdgCode << endl;
1552 fIsFromMBHeader = kTRUE;
1553 // test whether largest contribution to cluster orginates in added signals
1554 if (fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetCaloPhotonMCLabel(0), fMCStack, fInputEvent) == 0) fIsFromMBHeader = kFALSE;
1556 fHistoClusGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1557 fClusterCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1560 if(fInputEvent->IsA()==AliESDEvent::Class()){
1561 ProcessTrueClusterCandidates(PhotonCandidate);
1563 ProcessTrueClusterCandidatesAOD(PhotonCandidate);
1572 //________________________________________________________________________
1573 void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1576 TParticle *Photon = NULL;
1577 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1578 fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1580 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0)Photon = fMCStack->Particle(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1584 // cout << "no photon" << endl;
1588 TruePhotonCandidate->SetCaloPhotonMCFlags(fMCStack);
1591 if(fIsFromMBHeader){
1592 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1593 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1594 if (fDoClusterQA > 0){
1595 if (TruePhotonCandidate->IsLargestComponentPhoton()){
1596 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1597 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1599 if (TruePhotonCandidate->IsLargestComponentElectron())
1600 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1601 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1602 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1603 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(Photon->GetMother(0)))->Pt());
1605 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1606 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1607 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1608 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1609 if (TruePhotonCandidate->IsMergedPartConv())
1610 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1611 if (TruePhotonCandidate->IsDalitz())
1612 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1613 if (TruePhotonCandidate->IsDalitzMerged())
1614 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1615 if (TruePhotonCandidate->IsPhotonWithElecMother())
1616 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1617 if (TruePhotonCandidate->IsShower())
1618 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1619 if (TruePhotonCandidate->IsSubLeadingEM())
1620 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1621 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1625 if(Photon->GetMother(0) <= fMCStack->GetNprimary()){
1626 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1627 if(fIsFromMBHeader){
1628 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1629 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1636 //________________________________________________________________________
1637 void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1639 AliAODMCParticle *Photon = NULL;
1640 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1641 if (AODMCTrackArray){
1642 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1643 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0) Photon = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1646 AliInfo("AODMCTrackArray could not be loaded");
1651 // cout << "no photon" << endl;
1654 TruePhotonCandidate->SetCaloPhotonMCFlagsAOD(fInputEvent);
1655 fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1657 if(fIsFromMBHeader){
1658 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1659 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1660 if (fDoClusterQA > 0){
1661 if (TruePhotonCandidate->IsLargestComponentPhoton()) {
1662 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1663 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1665 if (TruePhotonCandidate->IsLargestComponentElectron())
1666 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1667 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()) {
1668 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1669 AliAODMCParticle *Mother = (AliAODMCParticle*) AODMCTrackArray->At(Photon->GetMother());
1670 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(Mother->Pt());
1672 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1673 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1674 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1675 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1676 if (TruePhotonCandidate->IsMergedPartConv())
1677 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1678 if (TruePhotonCandidate->IsDalitz())
1679 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1680 if (TruePhotonCandidate->IsDalitzMerged())
1681 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1682 if (TruePhotonCandidate->IsPhotonWithElecMother())
1683 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1684 if (TruePhotonCandidate->IsShower())
1685 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1686 if (TruePhotonCandidate->IsSubLeadingEM())
1687 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1688 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1693 if(fIsFromMBHeader){
1694 fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1695 // if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1698 if(Photon->IsPrimary()){
1699 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1700 if(fIsFromMBHeader){
1701 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1702 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1707 //________________________________________________________________________
1708 void AliAnalysisTaskGammaConvCalo::ProcessPhotonCandidates()
1711 TList *GammaCandidatesStepOne = new TList();
1712 TList *GammaCandidatesStepTwo = new TList();
1713 // Loop over Photon Candidates allocated by ReaderV1
1714 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1715 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1716 if(!PhotonCandidate) continue;
1717 fIsFromMBHeader = kTRUE;
1718 if(fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1719 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1720 if(isPosFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1721 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1722 if(isNegFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1723 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1726 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
1727 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(PhotonCandidate->GetPhotonPhi(),fEventPlaneAngle)) continue;
1728 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1729 !((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1730 fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1732 if(fIsFromMBHeader){
1733 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1734 if (fDoPhotonQA > 0){
1735 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1736 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1740 if(fInputEvent->IsA()==AliESDEvent::Class())
1741 ProcessTruePhotonCandidates(PhotonCandidate);
1742 if(fInputEvent->IsA()==AliAODEvent::Class())
1743 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1745 if (fIsFromMBHeader && fDoPhotonQA == 2){
1746 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1747 fPtGamma = PhotonCandidate->Pt();
1748 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1749 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1750 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1751 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1752 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1753 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1754 fPtGamma = PhotonCandidate->Pt();
1755 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1756 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1757 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1758 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1759 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1762 } else if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1763 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1765 GammaCandidatesStepOne->Add(PhotonCandidate);
1766 } else if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1767 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1768 GammaCandidatesStepTwo->Add(PhotonCandidate);
1771 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
1772 for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1773 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1774 if(!PhotonCandidate) continue;
1775 fIsFromMBHeader = kTRUE;
1776 if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1777 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1778 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1779 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1781 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1782 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1783 fGammaCandidates->Add(PhotonCandidate);
1784 if(fIsFromMBHeader){
1785 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1786 if (fDoPhotonQA > 0){
1787 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1788 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1793 if(fInputEvent->IsA()==AliESDEvent::Class())
1794 ProcessTruePhotonCandidates(PhotonCandidate);
1795 if(fInputEvent->IsA()==AliAODEvent::Class())
1796 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1797 } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1799 if (fIsFromMBHeader && fDoPhotonQA == 2){
1800 if (fIsHeavyIon ==1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1801 fPtGamma = PhotonCandidate->Pt();
1802 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1803 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1804 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1805 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1806 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1807 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1808 fPtGamma = PhotonCandidate->Pt();
1809 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1810 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1811 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1812 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1813 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1818 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1819 for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1820 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1821 if(!PhotonCandidate) continue;
1822 fIsFromMBHeader = kTRUE;
1823 if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1824 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1825 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1826 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1828 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
1829 fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1830 if(fIsFromMBHeader){
1831 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1832 if (fDoPhotonQA > 0){
1833 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1834 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1838 if(fInputEvent->IsA()==AliESDEvent::Class())
1839 ProcessTruePhotonCandidates(PhotonCandidate);
1840 if(fInputEvent->IsA()==AliAODEvent::Class())
1841 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1843 if (fIsFromMBHeader){
1844 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1845 fPtGamma = PhotonCandidate->Pt();
1846 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1847 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1848 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1849 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1850 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1851 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1852 fPtGamma = PhotonCandidate->Pt();
1853 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1854 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1855 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1856 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1857 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1863 delete GammaCandidatesStepOne;
1864 GammaCandidatesStepOne = 0x0;
1865 delete GammaCandidatesStepTwo;
1866 GammaCandidatesStepTwo = 0x0;
1869 //________________________________________________________________________
1870 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1873 Double_t magField = fInputEvent->GetMagneticField();
1874 if( magField < 0.0 ){
1881 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1882 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1883 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
1884 fCharPhotonMCInfo = 0;
1886 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1887 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1889 if(posDaughter->GetMother() != negDaughter->GetMother()){
1890 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1891 fCharPhotonMCInfo = 1;
1894 else if(posDaughter->GetMother() == -1){
1895 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1896 fCharPhotonMCInfo = 1;
1900 if(pdgCode[0]!=11 || pdgCode[1]!=11){
1901 fCharPhotonMCInfo = 1;
1902 return; //One Particle is not a electron
1905 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
1906 fCharPhotonMCInfo = 1;
1907 return; // Same Charge
1910 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
1911 if(Photon->GetPdgCode() != 22){
1912 fCharPhotonMCInfo = 1;
1913 return; // Mother is no Photon
1916 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
1917 fCharPhotonMCInfo = 1;
1918 return;// check if the daughters come from a conversion
1920 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1925 if(fIsFromMBHeader){
1926 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1927 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1929 if(Photon->IsPrimary()){
1930 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1931 if(fIsFromMBHeader){
1932 fCharPhotonMCInfo = 6;
1933 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1934 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1936 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1938 if(fIsFromMBHeader){
1939 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1940 fCharPhotonMCInfo = 2;
1941 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1942 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1943 fCharPhotonMCInfo = 5;
1944 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1946 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1947 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1948 fCharPhotonMCInfo = 4;
1949 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1951 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1952 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1953 fCharPhotonMCInfo = 3;
1957 if( ((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetPdgCode() == 111 ){
1958 fHistoTrueConvPi0GammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1961 //________________________________________________________________________
1962 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1965 Double_t magField = fInputEvent->GetMagneticField();
1966 if( magField < 0.0 ){
1973 // Process True Photons
1974 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1975 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
1976 fCharPhotonMCInfo = 0;
1978 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1979 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1980 fCharPhotonMCInfo = 1;
1981 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
1982 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1985 else if(posDaughter->GetMother(0) == -1){
1986 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1990 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1992 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1994 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
1996 if(Photon->GetPdgCode() != 22){
1997 return; // Mother is no Photon
2000 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
2003 if(fIsFromMBHeader){
2004 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2005 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
2007 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
2008 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
2009 if(fIsFromMBHeader){
2010 fCharPhotonMCInfo = 6;
2011 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2012 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
2015 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
2018 if(fIsFromMBHeader){
2019 fCharPhotonMCInfo = 2;
2020 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2021 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2022 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
2023 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2024 fCharPhotonMCInfo = 5;
2026 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2027 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
2028 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2029 fCharPhotonMCInfo = 4;
2031 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2032 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
2033 fCharPhotonMCInfo = 3;
2040 Int_t imother = Photon->GetMother(0);
2042 AliMCParticle* McMother = static_cast<AliMCParticle*>(fMCEvent->GetTrack(imother));
2043 //cout << fMCEvent->GetRunNumber() << " " << imother << " " << fMCEvent->GetNumberOfTracks() << endl;
2044 if(McMother->PdgCode() == 111) fHistoTrueConvPi0GammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2048 //________________________________________________________________________
2049 void AliAnalysisTaskGammaConvCalo::ProcessAODMCParticles()
2052 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2054 // Loop over all primary MC particle
2055 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
2057 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
2058 if (!particle) continue;
2059 if (!particle->IsPrimary()) continue;
2061 Int_t isMCFromMBHeader = -1;
2062 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2063 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2064 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2067 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2068 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
2069 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2070 if (abs(particle->Eta()) < 0.66 ){
2071 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2073 if(particle->GetMother() >-1){ // Meson Decay Gamma
2074 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
2076 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2079 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2082 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2085 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2088 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2091 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2094 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2099 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
2101 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
2102 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
2103 if(!tmpDaughter) continue;
2104 if(abs(tmpDaughter->GetPdgCode()) == 11){
2105 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
2108 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2109 if (fDoPhotonQA > 0){
2110 fHistoMCConvGammaR[fiCut]->Fill(rConv);
2111 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2114 // Converted MC Gamma
2115 if(fDoMesonAnalysis){
2116 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2117 Double_t mesonY = 10.;
2118 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2119 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2121 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2123 Float_t weightedK0s= 1;
2124 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2125 if (particle->Pt()>0.005){
2126 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2127 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2130 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2131 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2132 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2134 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2135 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2136 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
2137 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
2138 Float_t weighted= 1;
2139 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2140 if (particle->Pt()>0.005){
2141 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2142 // if(particle->GetPdgCode() == 221){
2143 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2147 Double_t mesonY = 10.;
2148 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2149 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2151 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2154 Double_t alpha = -1;
2155 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2156 alpha = TMath::Abs((daughter0->E() - daughter1->E()))/(daughter0->E() + daughter1->E());
2160 if(particle->GetPdgCode() == 111){
2161 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2162 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2163 if (fDoMesonQA > 0){
2164 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2165 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2167 } else if(particle->GetPdgCode() == 221){
2168 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2169 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2170 if (fDoMesonQA > 0){
2171 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2172 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2176 // Check the acceptance for both gammas
2177 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
2178 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) &&
2179 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2180 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2182 if(particle->GetPdgCode() == 111){
2183 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2184 } else if(particle->GetPdgCode() == 221){
2185 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2193 //________________________________________________________________________
2194 void AliAnalysisTaskGammaConvCalo::ProcessMCParticles()
2196 // Loop over all primary MC particle
2197 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2198 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2199 if (!particle) continue;
2201 Int_t isMCFromMBHeader = -1;
2202 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2203 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2204 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2207 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2208 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
2209 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2210 if (abs(particle->Eta()) < 0.66 ){
2211 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2214 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
2215 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
2217 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2220 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2223 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2226 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2229 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2232 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2235 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2240 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
2241 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2242 if (fDoPhotonQA > 0){
2243 fHistoMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
2244 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2246 } // Converted MC Gamma
2247 if(fDoMesonAnalysis){
2248 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2249 Double_t mesonY = 10.;
2250 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2251 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2253 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2255 Float_t weightedK0s= 1;
2256 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2257 if (particle->Pt()>0.005){
2258 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2259 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2262 if (fMCStack->IsPhysicalPrimary(i)){
2263 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2264 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2265 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2268 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2269 ->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2270 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
2271 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
2273 Float_t weighted= 1;
2274 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2275 if (particle->Pt()>0.005){
2276 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2277 // if(particle->GetPdgCode() == 221){
2278 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2282 Double_t mesonY = 10.;
2283 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2284 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2286 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2289 Double_t alpha = -1;
2290 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2291 alpha = TMath::Abs((daughter0->Energy() - daughter1->Energy()))/(daughter0->Energy() + daughter1->Energy());
2294 if(particle->GetPdgCode() == 111){
2295 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2296 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2297 if (fDoMesonQA > 0){
2298 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2299 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2301 } else if(particle->GetPdgCode() == 221){
2302 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2303 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2304 if (fDoMesonQA > 0){
2305 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2306 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2310 // Check the acceptance for both gammas
2311 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
2312 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) &&
2313 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2314 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2316 if(particle->GetPdgCode() == 111){
2317 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2318 } else if(particle->GetPdgCode() == 221){
2319 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2327 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
2328 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2329 if (!particle) continue;
2331 Int_t isMCFromMBHeader = -1;
2332 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2333 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2334 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2337 if(fDoMesonAnalysis){
2338 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2339 Float_t weighted= 1;
2340 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2341 if (particle->Pt()>0.005){
2342 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2343 // if(particle->GetPdgCode() == 221){
2344 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2349 if(particle->GetPdgCode() == 111){
2350 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2351 Int_t source = GetSourceClassification(111,pdgCode);
2352 fHistoMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
2353 fHistoMCSecPi0Source[fiCut]->Fill(pdgCode);
2354 } else if(particle->GetPdgCode() == 221){
2355 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2356 fHistoMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2357 fHistoMCSecEtaSource[fiCut]->Fill(pdgCode);
2365 //________________________________________________________________________
2366 void AliAnalysisTaskGammaConvCalo::PhotonTagging(){
2368 // Conversion Gammas
2369 if(fGammaCandidates->GetEntries()>0){
2371 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
2373 // get conversion photon
2374 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2375 if (gamma0==NULL) continue;
2377 TLorentzVector photonVector;
2378 photonVector.SetPxPyPzE(gamma0->GetPx(),gamma0->GetPy(),gamma0->GetPz(),gamma0->GetPhotonP());
2383 // loop over clusters
2384 for(Int_t secondGammaIndex = 0; secondGammaIndex<fClusterCandidates->GetEntries(); ++secondGammaIndex) {
2386 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2387 if (gamma1==NULL) continue;
2389 TLorentzVector clusterVector;
2390 clusterVector.SetPxPyPzE(gamma1->GetPx(),gamma1->GetPy(),gamma1->GetPz(),gamma1->GetPhotonP());
2393 TLorentzVector pairVector = photonVector+clusterVector;
2396 if((pairVector.M() > 0.11 && pairVector.M() < 0.15)){
2400 if((pairVector.M() > 0.50 && pairVector.M() < 0.6)){
2403 }// end loop over clusters
2405 if(btagpi0 && btageta)
2406 fHistoConvGammaTagged[fiCut]->Fill(photonVector.Pt());
2407 else if(btagpi0 && !btageta)
2408 fHistoConvGammaPi0Tagged[fiCut]->Fill(photonVector.Pt());
2409 else if(btageta && !btagpi0)
2410 fHistoConvGammaEtaTagged[fiCut]->Fill(photonVector.Pt());
2412 fHistoConvGammaUntagged[fiCut]->Fill(photonVector.Pt());
2414 }// end loop over gammas
2419 //________________________________________________________________________
2420 void AliAnalysisTaskGammaConvCalo::CalculatePi0Candidates(){
2422 // Conversion Gammas
2423 if(fGammaCandidates->GetEntries()>0){
2426 Double_t vertex[3] = {0};
2427 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
2429 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2430 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2431 if (gamma0==NULL) continue;
2433 for(Int_t secondGammaIndex=0;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
2434 Bool_t matched = kFALSE;
2435 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2436 if (gamma1==NULL) continue;
2438 if (gamma1->GetIsCaloPhoton()){
2439 AliVCluster* cluster = fInputEvent->GetCaloCluster(gamma1->GetCaloClusterRef());
2440 matched = ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->MatchConvPhotonToCluster(gamma0,cluster, fInputEvent );
2443 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
2444 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
2448 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2450 fHistoMotherMatchedInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2452 fHistoMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2454 // fill new histograms
2456 fHistoPhotonPairAll[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2457 fHistoPhotonPairAllGam[fiCut]->Fill(pi0cand->M(),gamma0->Pt());
2459 if(pi0cand->GetAlpha()<0.1)
2460 fHistoMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
2462 if (fDoMesonQA > 0){
2463 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
2464 fHistoMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2465 fHistoMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2466 fHistoMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2467 fHistoMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
2469 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
2470 fHistoMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2471 fHistoMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2472 fHistoMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2473 fHistoMotherEtaConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
2476 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
2480 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
2481 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2482 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2483 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2485 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2488 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2489 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2490 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2492 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2495 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
2496 fSparseMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2501 if(fInputEvent->IsA()==AliESDEvent::Class())
2502 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1, matched);
2503 if(fInputEvent->IsA()==AliAODEvent::Class())
2504 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1, matched);
2507 if (fDoMesonQA == 2){
2508 fInvMass = pi0cand->M();
2509 fPt = pi0cand->Pt();
2510 if (abs(gamma0->GetDCAzToPrimVtx()) < abs(gamma1->GetDCAzToPrimVtx())){
2511 fDCAzGammaMin = gamma0->GetDCAzToPrimVtx();
2512 fDCAzGammaMax = gamma1->GetDCAzToPrimVtx();
2514 fDCAzGammaMin = gamma1->GetDCAzToPrimVtx();
2515 fDCAzGammaMax = gamma0->GetDCAzToPrimVtx();
2517 fCharFlag = pi0cand->GetMesonQuality();
2518 // cout << "gamma 0: " << gamma0->GetV0Index()<< "\t" << gamma0->GetPx() << "\t" << gamma0->GetPy() << "\t" << gamma0->GetPz() << "\t" << endl;
2519 // cout << "gamma 1: " << gamma1->GetV0Index()<< "\t"<< gamma1->GetPx() << "\t" << gamma1->GetPy() << "\t" << gamma1->GetPz() << "\t" << endl;
2520 // cout << "pi0: "<<fInvMass << "\t" << fPt <<"\t" << fDCAzGammaMin << "\t" << fDCAzGammaMax << "\t" << (Int_t)fCharFlag << "\t" << (Int_t)fCharMesonMCInfo <<endl;
2521 if (fIsHeavyIon == 1 && fPt > 0.399 && fPt < 20. ) {
2522 if (fInvMass > 0.08 && fInvMass < 0.2) fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2523 if ((fInvMass > 0.45 && fInvMass < 0.6) && (fPt > 0.999 && fPt < 20.) )fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2524 } else if (fPt > 0.299 && fPt < 20. ) {
2525 if ( (fInvMass > 0.08 && fInvMass < 0.2) || (fInvMass > 0.45 && fInvMass < 0.6)) fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2528 if (fDoMesonQA == 1){
2529 fHistoMotherInvMassECalib[fiCut]->Fill(pi0cand->M(),gamma1->E());
2530 if(pi0cand->GetAlpha()<0.1)
2531 fHistoMotherInvMassECalibalpha[fiCut]->Fill(pi0cand->M(),gamma1->E());
2541 //______________________________________________________________________
2542 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2544 // Process True Mesons
2545 AliStack *MCStack = fMCEvent->Stack();
2546 fCharMesonMCInfo = 0;
2547 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2548 Bool_t isTruePi0 = kFALSE;
2549 Bool_t isTrueEta = kFALSE;
2550 Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
2551 Int_t gamma0MotherLabel = -1;
2552 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2553 // Daughters Gamma 0
2554 TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
2555 TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
2556 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
2557 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2558 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2559 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
2560 gamma0MotherLabel=gammaMC0->GetFirstMother();
2565 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
2567 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2568 Int_t gamma1MotherLabel = -1;
2571 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2572 // Daughters Gamma 1
2573 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
2574 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2575 // get mother of interest (pi0 or eta)
2576 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2577 gamma1MotherLabel=gammaMC1->GetMother(0);
2578 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2579 if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=MCStack->Particle(gammaMC1->GetMother(0))->GetMother(0);
2580 else gamma1MotherLabel=gammaMC1->GetMother(0);
2583 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2587 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2588 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
2591 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
2596 if(isTruePi0 || isTrueEta){// True Pion or Eta
2598 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2599 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2601 if (fDoMesonQA > 0){
2602 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2603 if(isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2604 if(isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2606 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched){
2607 if(isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2608 if(isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2610 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() ){
2611 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2612 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2613 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0){
2614 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2616 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta){
2617 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2620 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2621 if (isTruePi0 )fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2622 if (isTrueEta )fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2624 if (TrueGammaCandidate1->IsMergedPartConv() && !matched){
2625 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2626 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2630 if (fDoMesonQA > 0){
2632 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2633 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2634 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2635 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2636 fHistoTrueMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2638 } else if (isTrueEta){
2639 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2640 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2641 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2642 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2643 fHistoTrueMotherEtaConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2648 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
2649 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma0MotherLabel))->GetMother(0);
2650 Float_t weightedSec= 1;
2651 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
2652 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
2653 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2655 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2656 if (isTrueEta) fHistoTrueSecondaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2657 fCharMesonMCInfo = 2;
2658 if (secMotherLabel >-1){
2659 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310 && isTruePi0 ){
2660 fCharMesonMCInfo = 4;
2661 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2662 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2664 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221 && isTruePi0){
2665 fCharMesonMCInfo = 3;
2666 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2667 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2669 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==3122 && isTruePi0){
2670 fCharMesonMCInfo = 7;
2671 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2672 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2675 } else { // Only primary pi0 for efficiency calculation
2676 fCharMesonMCInfo = 6;
2677 Float_t weighted= 1;
2678 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
2679 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
2680 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
2681 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2685 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2686 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2687 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2688 } else if (isTrueEta) {
2689 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2690 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2691 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2694 if (fDoMesonQA > 0){
2695 if(isTruePi0){ // Only primary pi0 for resolution
2696 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2698 if (isTrueEta){ // Only primary eta for resolution
2699 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2704 } else if(!isTruePi0 && !isTrueEta){ // Background
2705 if (fDoMesonQA > 0){
2706 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2707 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2708 fCharMesonMCInfo = 1;
2709 } else { // No photon or without mother
2710 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2716 //______________________________________________________________________
2717 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2720 // Process True Mesons
2721 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2722 Bool_t isTruePi0 = kFALSE;
2723 Bool_t isTrueEta = kFALSE;
2725 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
2726 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
2728 fCharMesonMCInfo = 0;
2729 Int_t gamma0MCLabel = -1;
2730 Int_t gamma0MotherLabel = -1;
2731 if(!positiveMC||!negativeMC)
2734 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
2735 gamma0MCLabel = positiveMC->GetMother();
2738 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2739 // Daughters Gamma 0
2740 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2741 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2742 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
2743 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
2744 gamma0MotherLabel=gammaMC0->GetMother();
2750 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2751 Int_t gamma1MotherLabel = -1;
2754 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2755 // Daughters Gamma 1
2756 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2757 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2758 // get mother of interest (pi0 or eta)
2759 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2760 gamma1MotherLabel=gammaMC1->GetMother();
2761 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2762 if (TrueGammaCandidate1->IsConversion()){
2763 AliAODMCParticle * gammaGrandMotherMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC1->GetMother()));
2764 gamma1MotherLabel=gammaGrandMotherMC1->GetMother();
2765 } else gamma1MotherLabel=gammaMC1->GetMother();
2768 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2772 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2773 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2776 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2781 if(isTruePi0 || isTrueEta){// True Pion or Eta
2783 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2784 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2786 if (fDoMesonQA > 0){
2787 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2788 if (isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2789 if (isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2791 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched) {
2792 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2793 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2795 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()){
2796 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2797 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2798 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0)
2799 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2800 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta)
2801 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2803 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2804 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2805 if (isTrueEta) fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2807 if (TrueGammaCandidate1->IsMergedPartConv() && !matched) {
2808 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2809 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2814 if (fDoMesonQA > 0){
2816 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2817 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2818 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2819 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2820 fHistoTrueMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2822 } else if (isTrueEta){
2823 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2824 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2825 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2826 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2827 fHistoTrueMotherEtaConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2831 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2832 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2833 Float_t weightedSec= 1;
2834 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2835 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
2836 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2838 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2839 if (isTrueEta) fHistoTrueSecondaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2841 fCharMesonMCInfo = 2;
2842 if (secMotherLabel >-1){
2843 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310 && isTruePi0){
2844 fCharMesonMCInfo = 4;
2845 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2846 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2848 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221 && isTruePi0){
2849 fCharMesonMCInfo = 3;
2850 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2851 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2853 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122 && isTruePi0){
2854 fCharMesonMCInfo = 7;
2855 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2856 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2859 } else{ // Only primary pi0 for efficiency calculation
2860 Float_t weighted= 1;
2861 fCharMesonMCInfo = 6;
2862 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2863 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2864 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2865 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2869 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2870 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2871 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2872 } else if (isTrueEta){
2873 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2874 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2875 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2877 if (fDoMesonQA > 0){
2878 if(isTruePi0){ // Only primary pi0 for resolution
2879 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2880 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2883 if (isTrueEta){ // Only primary eta for resolution
2884 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2885 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2890 } else if(!isTruePi0 && !isTrueEta) { // Background
2891 if (fDoMesonQA > 0){
2892 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2893 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2894 fCharMesonMCInfo = 1;
2895 } else { // No photon or without mother
2896 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2902 //________________________________________________________________________
2903 void AliAnalysisTaskGammaConvCalo::CalculateBackground(){
2905 Int_t zbin= fBGClusHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2908 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2909 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2911 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2914 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2915 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2916 for(Int_t nEventsInBG=0;nEventsInBG<fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2917 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2918 if(fMoveParticleAccordingToVertex == kTRUE){
2919 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2922 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2923 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2924 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2925 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2926 if(fMoveParticleAccordingToVertex == kTRUE){
2927 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2929 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2930 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2933 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2934 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2935 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2936 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2937 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2938 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2939 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2941 delete backgroundCandidate;
2942 backgroundCandidate = 0x0;
2947 for(Int_t nEventsInBG=0;nEventsInBG <fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2948 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2949 if(previousEventV0s){
2950 if(fMoveParticleAccordingToVertex == kTRUE){
2951 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2953 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2954 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2955 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2957 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2959 if(fMoveParticleAccordingToVertex == kTRUE){
2960 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2962 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2963 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2966 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2967 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2968 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2969 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2970 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2971 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2973 delete backgroundCandidate;
2974 backgroundCandidate = 0x0;
2982 //________________________________________________________________________
2983 void AliAnalysisTaskGammaConvCalo::CalculateBackgroundRP(){
2985 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2987 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2988 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2990 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2995 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2996 // Correct for the number of rotations
2997 // BG is for rotation the same, except for factor NRotations
2998 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
3000 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3002 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3003 if (gamma0==NULL) continue;
3004 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
3005 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
3006 if (gamma1 == NULL) continue;
3007 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
3008 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
3010 RotateParticle(gamma1);
3011 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3012 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3013 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3014 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3015 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3016 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3017 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3024 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
3026 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
3028 if(previousEventGammas){
3029 // test weighted background
3030 Double_t weight=1.0;
3031 // Correct for the number of eventmixing:
3032 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
3033 // real combinations (since you cannot combine a photon with its own)
3034 // but BG leads to N_{a}*N_{b} combinations
3035 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
3037 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3038 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3039 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
3041 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
3043 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3044 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3045 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3046 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3047 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3048 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3049 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3057 //________________________________________________________________________
3058 void AliAnalysisTaskGammaConvCalo::RotateParticle(AliAODConversionPhoton *gamma){
3059 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
3060 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
3061 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
3062 gamma->RotateZ(rotationValue);
3065 //________________________________________________________________________
3066 void AliAnalysisTaskGammaConvCalo::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
3068 previousEventEP=previousEventEP+TMath::Pi();
3069 thisEventEP=thisEventEP+TMath::Pi();
3070 Double_t rotationValue= thisEventEP-previousEventEP;
3071 gamma->RotateZ(rotationValue);
3074 //________________________________________________________________________
3075 void AliAnalysisTaskGammaConvCalo::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
3076 //see header file for documentation
3078 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
3079 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
3080 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
3082 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
3083 particle->SetConversionPoint(movedPlace);
3085 //________________________________________________________________________
3086 void AliAnalysisTaskGammaConvCalo::UpdateEventByEventData(){
3087 //see header file for documentation
3088 if(fGammaCandidates->GetEntries() >0 ){
3089 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3090 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3091 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3092 } else { // means we use #V0s for multiplicity
3093 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3094 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3100 //________________________________________________________________________
3101 void AliAnalysisTaskGammaConvCalo::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
3103 // 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
3104 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
3105 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
3106 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
3107 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
3108 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
3109 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
3110 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
3111 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
3112 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
3113 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
3114 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
3115 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
3116 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
3117 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
3118 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
3119 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
3120 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
3121 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
3122 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
3123 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
3124 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
3125 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
3126 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
3127 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
3128 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
3129 else {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
3131 //________________________________________________________________________
3132 void AliAnalysisTaskGammaConvCalo::RelabelAODPhotonCandidates(Bool_t mode){
3134 // Relabeling For AOD Event
3136 // MCLabel -> AODMCLabel
3139 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
3140 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
3141 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
3142 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
3145 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
3146 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
3147 if(!PhotonCandidate) continue;
3148 if(!mode){// Back to ESD Labels
3149 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
3150 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
3151 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
3152 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
3155 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
3156 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
3157 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
3158 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
3160 Bool_t AODLabelPos = kFALSE;
3161 Bool_t AODLabelNeg = kFALSE;
3163 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
3164 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
3166 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
3167 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
3168 PhotonCandidate->SetLabelPositive(i);
3169 AODLabelPos = kTRUE;
3173 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
3174 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
3175 PhotonCandidate->SetLabelNegative(i);
3176 AODLabelNeg = kTRUE;
3179 if(AODLabelNeg && AODLabelPos){
3183 if(!AODLabelPos || !AODLabelNeg){
3184 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
3190 delete[] fMCStackPos;
3191 delete[] fMCStackNeg;
3192 delete[] fESDArrayPos;
3193 delete[] fESDArrayNeg;
3197 void AliAnalysisTaskGammaConvCalo::SetLogBinningXTH2(TH2* histoRebin){
3198 TAxis *axisafter = histoRebin->GetXaxis();
3199 Int_t bins = axisafter->GetNbins();
3200 Double_t from = axisafter->GetXmin();
3201 Double_t to = axisafter->GetXmax();
3202 Double_t *newbins = new Double_t[bins+1];
3204 Double_t factor = TMath::Power(to/from, 1./bins);
3205 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
3206 axisafter->Set(bins, newbins);
3210 //________________________________________________________________________
3211 void AliAnalysisTaskGammaConvCalo::Terminate(const Option_t *)
3214 //fOutputContainer->Print(); // Will crash on GRID
3217 //________________________________________________________________________
3218 Int_t AliAnalysisTaskGammaConvCalo::GetSourceClassification(Int_t daughter, Int_t pdgCode){
3220 if (daughter == 111) {
3221 if (abs(pdgCode) == 310) return 1; // k0s
3222 else if (abs(pdgCode) == 3122) return 2; // Lambda
3223 else if (abs(pdgCode) == 130) return 3; // K0L
3224 else if (abs(pdgCode) == 2212) return 4; // proton
3225 else if (abs(pdgCode) == 2112) return 5; // neutron
3226 else if (abs(pdgCode) == 211) return 6; // pion
3227 else if (abs(pdgCode) == 321) return 7; // kaon
3228 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
3229 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112 ) return 9; // Sigma
3230 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114 ) return 10; // Delta
3231 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323 ) return 11; // K*
git://git.uio.no / u / mrichter / AliRoot.git / blob