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 fHistoClusOverlapHeadersGammaPt(NULL),
135 fHistoMCHeaders(NULL),
136 fHistoMCAllGammaPt(NULL),
137 fHistoMCAllGammaEMCALAccPt(NULL),
138 fHistoMCDecayGammaPi0Pt(NULL),
139 fHistoMCDecayGammaRhoPt(NULL),
140 fHistoMCDecayGammaEtaPt(NULL),
141 fHistoMCDecayGammaOmegaPt(NULL),
142 fHistoMCDecayGammaEtapPt(NULL),
143 fHistoMCDecayGammaPhiPt(NULL),
144 fHistoMCDecayGammaSigmaPt(NULL),
145 fHistoMCConvGammaPt(NULL),
146 fHistoMCConvGammaR(NULL),
147 fHistoMCConvGammaEta(NULL),
149 fHistoMCPi0WOWeightPt(NULL),
151 fHistoMCEtaWOWeightPt(NULL),
152 fHistoMCPi0InAccPt(NULL),
153 fHistoMCEtaInAccPt(NULL),
154 fHistoMCPi0PtY(NULL),
155 fHistoMCEtaPtY(NULL),
156 fHistoMCPi0PtAlpha(NULL),
157 fHistoMCEtaPtAlpha(NULL),
159 fHistoMCK0sWOWeightPt(NULL),
160 fHistoMCK0sPtY(NULL),
161 fHistoMCSecPi0PtvsSource(NULL),
162 fHistoMCSecPi0Source(NULL),
163 fHistoMCSecEtaPt(NULL),
164 fHistoMCSecEtaSource(NULL),
165 fHistoTruePi0InvMassPt(NULL),
166 fHistoTrueEtaInvMassPt(NULL),
167 fHistoTruePi0CaloPhotonInvMassPt(NULL),
168 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
169 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
170 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
171 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
172 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
173 fHistoTruePi0CaloElectronInvMassPt(NULL),
174 fHistoTrueEtaCaloElectronInvMassPt(NULL),
175 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
176 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
177 fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
178 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
179 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
180 fHistoTruePrimaryPi0InvMassPt(NULL),
181 fHistoTruePrimaryEtaInvMassPt(NULL),
182 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
183 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
184 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
185 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
186 fHistoTruePrimaryPi0MCPtResolPt(NULL),
187 fHistoTruePrimaryEtaMCPtResolPt(NULL),
188 fHistoTrueMotherPi0ConvPhotonEtaPhi(NULL),
189 fHistoTrueMotherEtaConvPhotonEtaPhi(NULL),
190 fHistoTrueSecondaryPi0InvMassPt(NULL),
191 fHistoTrueSecondaryEtaInvMassPt(NULL),
192 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
193 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
194 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
195 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
196 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
197 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
198 fHistoTrueBckGGInvMassPt(NULL),
199 fHistoTrueBckContInvMassPt(NULL),
200 fHistoTruePi0PtY(NULL),
201 fHistoTrueEtaPtY(NULL),
202 fHistoTruePi0PtAlpha(NULL),
203 fHistoTrueEtaPtAlpha(NULL),
204 fHistoTruePi0PtOpenAngle(NULL),
205 fHistoTrueEtaPtOpenAngle(NULL),
206 fHistoTrueConvGammaPt(NULL),
207 fHistoTrueConvPi0GammaPt(NULL),
208 fHistoTrueConvGammaEta(NULL),
209 fHistoCombinatorialPt(NULL),
210 fHistoTruePrimaryConvGammaPt(NULL),
211 fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
212 fHistoTrueSecondaryConvGammaPt(NULL),
213 fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
214 fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
215 fHistoTrueClusGammaPt(NULL),
216 fHistoTrueClusUnConvGammaPt(NULL),
217 fHistoTrueClusUnConvGammaMCPt(NULL),
218 fHistoTrueClusElectronPt(NULL),
219 fHistoTrueClusConvGammaPt(NULL),
220 fHistoTrueClusConvGammaMCPt(NULL),
221 fHistoTrueClusConvGammaFullyPt(NULL),
222 fHistoTrueClusMergedGammaPt(NULL),
223 fHistoTrueClusMergedPartConvGammaPt(NULL),
224 fHistoTrueClusDalitzPt(NULL),
225 fHistoTrueClusDalitzMergedPt(NULL),
226 fHistoTrueClusPhotonFromElecMotherPt(NULL),
227 fHistoTrueClusShowerPt(NULL),
228 fHistoTrueClusSubLeadingPt(NULL),
229 fHistoTrueClusNParticles(NULL),
230 fHistoTrueClusEMNonLeadingPt(NULL),
231 fHistoTrueNLabelsInClus(NULL),
232 fHistoTruePrimaryClusGammaPt(NULL),
233 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
235 fHistoNGoodESDTracks(NULL),
236 fHistoNGammaCandidates(NULL),
237 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
238 fHistoNV0Tracks(NULL),
239 fProfileEtaShift(NULL),
240 fEventPlaneAngle(-100),
242 fNGammaCandidates(0),
253 fMoveParticleAccordingToVertex(kTRUE),
255 fDoMesonAnalysis(kTRUE),
259 fIsFromMBHeader(kTRUE),
260 fIsOverlappingWithOtherHeader(kFALSE),
266 //________________________________________________________________________
267 AliAnalysisTaskGammaConvCalo::AliAnalysisTaskGammaConvCalo(const char *name):
268 AliAnalysisTaskSE(name),
272 fBGClusHandler(NULL),
273 fBGClusHandlerRP(NULL),
281 fPhotonDCAList(NULL),
285 fHeaderNameList(NULL),
286 fTagOutputList(NULL),
289 fGammaCandidates(NULL),
290 fClusterCandidates(NULL),
291 fEventCutArray(NULL),
294 fConversionCuts(NULL),
295 fClusterCutArray(NULL),
296 fCaloPhotonCuts(NULL),
297 fMesonCutArray(NULL),
299 fHistoConvGammaPt(NULL),
300 fHistoConvGammaR(NULL),
301 fHistoConvGammaEta(NULL),
302 fTreeConvGammaPtDcazCat(NULL),
308 fCharPhotonMCInfo(0),
309 fHistoMotherInvMassPt(NULL),
310 fHistoMotherMatchedInvMassPt(NULL),
311 fSparseMotherInvMassPtZM(NULL),
312 fHistoMotherBackInvMassPt(NULL),
313 fSparseMotherBackInvMassPtZM(NULL),
314 fHistoMotherInvMassEalpha(NULL),
315 fHistoMotherPi0PtY(NULL),
316 fHistoMotherEtaPtY(NULL),
317 fHistoMotherPi0PtAlpha(NULL),
318 fHistoMotherEtaPtAlpha(NULL),
319 fHistoMotherPi0PtOpenAngle(NULL),
320 fHistoMotherEtaPtOpenAngle(NULL),
321 fHistoMotherPi0ConvPhotonEtaPhi(NULL),
322 fHistoMotherEtaConvPhotonEtaPhi(NULL),
323 fHistoMotherInvMassECalib(NULL),
324 fHistoMotherInvMassECalibalpha(NULL),
325 fTreeMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
332 fHistoConvGammaUntagged(NULL),
333 fHistoConvGammaTagged(NULL),
334 fHistoConvGammaPi0Tagged(NULL),
335 fHistoConvGammaEtaTagged(NULL),
336 fHistoPhotonPairAll(NULL),
337 fHistoPhotonPairAllGam(NULL),
338 fHistoClusGammaPt(NULL),
339 fHistoClusOverlapHeadersGammaPt(NULL),
340 fHistoMCHeaders(NULL),
341 fHistoMCAllGammaPt(NULL),
342 fHistoMCAllGammaEMCALAccPt(NULL),
343 fHistoMCDecayGammaPi0Pt(NULL),
344 fHistoMCDecayGammaRhoPt(NULL),
345 fHistoMCDecayGammaEtaPt(NULL),
346 fHistoMCDecayGammaOmegaPt(NULL),
347 fHistoMCDecayGammaEtapPt(NULL),
348 fHistoMCDecayGammaPhiPt(NULL),
349 fHistoMCDecayGammaSigmaPt(NULL),
350 fHistoMCConvGammaPt(NULL),
351 fHistoMCConvGammaR(NULL),
352 fHistoMCConvGammaEta(NULL),
354 fHistoMCPi0WOWeightPt(NULL),
356 fHistoMCEtaWOWeightPt(NULL),
357 fHistoMCPi0InAccPt(NULL),
358 fHistoMCEtaInAccPt(NULL),
359 fHistoMCPi0PtY(NULL),
360 fHistoMCEtaPtY(NULL),
361 fHistoMCPi0PtAlpha(NULL),
362 fHistoMCEtaPtAlpha(NULL),
364 fHistoMCK0sWOWeightPt(NULL),
365 fHistoMCK0sPtY(NULL),
366 fHistoMCSecPi0PtvsSource(NULL),
367 fHistoMCSecPi0Source(NULL),
368 fHistoMCSecEtaPt(NULL),
369 fHistoMCSecEtaSource(NULL),
370 fHistoTruePi0InvMassPt(NULL),
371 fHistoTrueEtaInvMassPt(NULL),
372 fHistoTruePi0CaloPhotonInvMassPt(NULL),
373 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
374 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
375 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
376 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
377 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
378 fHistoTruePi0CaloElectronInvMassPt(NULL),
379 fHistoTrueEtaCaloElectronInvMassPt(NULL),
380 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
381 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
382 fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
383 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
384 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
385 fHistoTruePrimaryPi0InvMassPt(NULL),
386 fHistoTruePrimaryEtaInvMassPt(NULL),
387 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
388 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
389 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
390 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
391 fHistoTruePrimaryPi0MCPtResolPt(NULL),
392 fHistoTruePrimaryEtaMCPtResolPt(NULL),
393 fHistoTrueMotherPi0ConvPhotonEtaPhi(NULL),
394 fHistoTrueMotherEtaConvPhotonEtaPhi(NULL),
395 fHistoTrueSecondaryPi0InvMassPt(NULL),
396 fHistoTrueSecondaryEtaInvMassPt(NULL),
397 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
398 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
399 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
400 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
401 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
402 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
403 fHistoTrueBckGGInvMassPt(NULL),
404 fHistoTrueBckContInvMassPt(NULL),
405 fHistoTruePi0PtY(NULL),
406 fHistoTrueEtaPtY(NULL),
407 fHistoTruePi0PtAlpha(NULL),
408 fHistoTrueEtaPtAlpha(NULL),
409 fHistoTruePi0PtOpenAngle(NULL),
410 fHistoTrueEtaPtOpenAngle(NULL),
411 fHistoTrueConvGammaPt(NULL),
412 fHistoTrueConvPi0GammaPt(NULL),
413 fHistoTrueConvGammaEta(NULL),
414 fHistoCombinatorialPt(NULL),
415 fHistoTruePrimaryConvGammaPt(NULL),
416 fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
417 fHistoTrueSecondaryConvGammaPt(NULL),
418 fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
419 fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
420 fHistoTrueClusGammaPt(NULL),
421 fHistoTrueClusUnConvGammaPt(NULL),
422 fHistoTrueClusUnConvGammaMCPt(NULL),
423 fHistoTrueClusElectronPt(NULL),
424 fHistoTrueClusConvGammaPt(NULL),
425 fHistoTrueClusConvGammaMCPt(NULL),
426 fHistoTrueClusConvGammaFullyPt(NULL),
427 fHistoTrueClusMergedGammaPt(NULL),
428 fHistoTrueClusMergedPartConvGammaPt(NULL),
429 fHistoTrueClusDalitzPt(NULL),
430 fHistoTrueClusDalitzMergedPt(NULL),
431 fHistoTrueClusPhotonFromElecMotherPt(NULL),
432 fHistoTrueClusShowerPt(NULL),
433 fHistoTrueClusSubLeadingPt(NULL),
434 fHistoTrueClusNParticles(NULL),
435 fHistoTrueClusEMNonLeadingPt(NULL),
436 fHistoTrueNLabelsInClus(NULL),
437 fHistoTruePrimaryClusGammaPt(NULL),
438 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
440 fHistoNGoodESDTracks(NULL),
441 fHistoNGammaCandidates(NULL),
442 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
443 fHistoNV0Tracks(NULL),
444 fProfileEtaShift(NULL),
445 fEventPlaneAngle(-100),
447 fNGammaCandidates(0),
458 fMoveParticleAccordingToVertex(kTRUE),
460 fDoMesonAnalysis(kTRUE),
464 fIsFromMBHeader(kTRUE),
465 fIsOverlappingWithOtherHeader(kFALSE),
468 // Define output slots here
469 DefineOutput(1, TList::Class());
472 AliAnalysisTaskGammaConvCalo::~AliAnalysisTaskGammaConvCalo()
474 if(fGammaCandidates){
475 delete fGammaCandidates;
476 fGammaCandidates = 0x0;
478 if(fClusterCandidates){
479 delete fClusterCandidates;
480 fClusterCandidates = 0x0;
487 delete[] fBGHandlerRP;
491 delete[] fBGClusHandler;
492 fBGClusHandler = 0x0;
494 if(fBGClusHandlerRP){
495 delete[] fBGClusHandlerRP;
496 fBGClusHandlerRP = 0x0;
499 //___________________________________________________________
500 void AliAnalysisTaskGammaConvCalo::InitBack(){
502 const Int_t nDim = 4;
503 Int_t nBins[nDim] = {800,250,7,4};
504 Double_t xMin[nDim] = {0,0, 0,0};
505 Double_t xMax[nDim] = {0.8,25,7,4};
507 fSparseMotherInvMassPtZM = new THnSparseF*[fnCuts];
508 fSparseMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
510 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
511 fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
513 fBGClusHandler = new AliGammaConversionAODBGHandler*[fnCuts];
514 fBGClusHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
516 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
517 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
518 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
519 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
520 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
521 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
523 Int_t collisionSystem = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(0,1));
524 Int_t centMin = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(1,1));
525 Int_t centMax = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(2,1));
527 if(collisionSystem == 1 || collisionSystem == 2 ||
528 collisionSystem == 5 || collisionSystem == 8 ||
529 collisionSystem == 9){
530 centMin = centMin*10;
531 centMax = centMax*10;
532 if(centMax ==0 && centMax!=centMin) centMax=100;
533 } else if(collisionSystem == 3 || collisionSystem == 6){
536 } else if(collisionSystem == 4 || collisionSystem == 7){
537 centMin = ((centMin*5)+45);
538 centMax = ((centMax*5)+45);
541 fBackList[iCut] = new TList();
542 fBackList[iCut]->SetName(Form("%s_%s_%s_%s Back histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(), cutstringMeson.Data()));
543 fBackList[iCut]->SetOwner(kTRUE);
544 fCutFolder[iCut]->Add(fBackList[iCut]);
546 fSparseMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
547 fBackList[iCut]->Add(fSparseMotherBackInvMassPtZM[iCut]);
549 fMotherList[iCut] = new TList();
550 fMotherList[iCut]->SetName(Form("%s_%s_%s_%s Mother histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
551 fMotherList[iCut]->SetOwner(kTRUE);
552 fCutFolder[iCut]->Add(fMotherList[iCut]);
554 fSparseMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
555 fMotherList[iCut]->Add(fSparseMotherInvMassPtZM[iCut]);
557 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
558 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
559 collisionSystem,centMin,centMax,
560 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
561 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity(),
563 fBGClusHandler[iCut] = new AliGammaConversionAODBGHandler(
564 collisionSystem,centMin,centMax,
565 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
566 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity(),
568 fBGHandlerRP[iCut] = NULL;
570 fBGHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
571 ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsHeavyIon(),
572 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
573 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
574 fBGClusHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
575 ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsHeavyIon(),
576 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
577 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
578 fBGHandler[iCut] = NULL;
583 //________________________________________________________________________
584 void AliAnalysisTaskGammaConvCalo::UserCreateOutputObjects(){
587 if(fOutputContainer != NULL){
588 delete fOutputContainer;
589 fOutputContainer = NULL;
591 if(fOutputContainer == NULL){
592 fOutputContainer = new TList();
593 fOutputContainer->SetOwner(kTRUE);
596 // Array of current cut's gammas
597 fGammaCandidates = new TList();
598 fClusterCandidates = new TList();
600 fCutFolder = new TList*[fnCuts];
601 fESDList = new TList*[fnCuts];
602 fBackList = new TList*[fnCuts];
603 fMotherList = new TList*[fnCuts];
604 fHistoNEvents = new TH1I*[fnCuts];
605 fHistoNGoodESDTracks = new TH1I*[fnCuts];
606 fHistoNGammaCandidates = new TH1I*[fnCuts];
607 fHistoNGoodESDTracksVsNGammaCanditates = new TH2F*[fnCuts];
608 fHistoNV0Tracks = new TH1I*[fnCuts];
609 fProfileEtaShift = new TProfile*[fnCuts];
610 fHistoConvGammaPt = new TH1F*[fnCuts];
612 if (fDoPhotonQA == 2){
613 fPhotonDCAList = new TList*[fnCuts];
614 fTreeConvGammaPtDcazCat = new TTree*[fnCuts];
616 if (fDoPhotonQA > 0){
617 fHistoConvGammaR = new TH1F*[fnCuts];
618 fHistoConvGammaEta = new TH1F*[fnCuts];
621 if(fDoMesonAnalysis){
622 fHistoMotherInvMassPt = new TH2F*[fnCuts];
623 fHistoMotherMatchedInvMassPt = new TH2F*[fnCuts];
624 fHistoMotherBackInvMassPt = new TH2F*[fnCuts];
625 fHistoMotherInvMassEalpha = new TH2F*[fnCuts];
626 if (fDoMesonQA == 2){
627 fMesonDCAList = new TList*[fnCuts];
628 fTreeMesonsInvMassPtDcazMinDcazMaxFlag = new TTree*[fnCuts];
631 fHistoMotherPi0PtY = new TH2F*[fnCuts];
632 fHistoMotherEtaPtY = new TH2F*[fnCuts];
633 fHistoMotherPi0PtAlpha = new TH2F*[fnCuts];
634 fHistoMotherEtaPtAlpha = new TH2F*[fnCuts];
635 fHistoMotherPi0PtOpenAngle = new TH2F*[fnCuts];
636 fHistoMotherEtaPtOpenAngle = new TH2F*[fnCuts];
637 fHistoMotherPi0ConvPhotonEtaPhi = new TH2F*[fnCuts];
638 fHistoMotherEtaConvPhotonEtaPhi = new TH2F*[fnCuts];
641 fHistoMotherInvMassECalib = new TH2F*[fnCuts];
642 fHistoMotherInvMassECalibalpha = new TH2F*[fnCuts];
645 fTagOutputList = new TList*[fnCuts];
647 fHistoConvGammaUntagged = new TH1F*[fnCuts];
648 fHistoConvGammaTagged = new TH1F*[fnCuts];
649 fHistoConvGammaPi0Tagged = new TH1F*[fnCuts];
650 fHistoConvGammaEtaTagged = new TH1F*[fnCuts];
651 fHistoPhotonPairAll = new TH2F*[fnCuts];
652 fHistoPhotonPairAllGam = new TH2F*[fnCuts];
654 fHistoClusGammaPt = new TH1F*[fnCuts];
655 fHistoClusOverlapHeadersGammaPt = new TH1F*[fnCuts];
657 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
658 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
659 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
660 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
661 TString cutstringMeson = "NoMesonCut";
662 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
664 fCutFolder[iCut] = new TList();
665 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s_%s",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
666 fCutFolder[iCut]->SetOwner(kTRUE);
667 fOutputContainer->Add(fCutFolder[iCut]);
668 fESDList[iCut] = new TList();
669 fESDList[iCut]->SetName(Form("%s_%s_%s_%s ESD histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
670 fESDList[iCut]->SetOwner(kTRUE);
671 fCutFolder[iCut]->Add(fESDList[iCut]);
673 fHistoNEvents[iCut] = new TH1I("NEvents","NEvents",10,-0.5,9.5);
674 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
675 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
676 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
677 if (((AliConvEventCuts*)fEventCutArray->At(iCut))->IsSpecialTrigger() > 1 ){
678 TString TriggerNames = "Not Trigger: ";
679 TriggerNames = TriggerNames+ ( (AliConvEventCuts*)fEventCutArray->At(iCut))->GetSpecialTriggerName();
680 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
682 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
684 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
685 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
686 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
687 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
688 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
689 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(10,"EMCAL problem");
690 fESDList[iCut]->Add(fHistoNEvents[iCut]);
692 if(fIsHeavyIon == 1) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
693 else if(fIsHeavyIon == 2) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",400,0,400);
694 else fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
695 fESDList[iCut]->Add(fHistoNGoodESDTracks[iCut]);
696 if(fIsHeavyIon == 1) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
697 else if(fIsHeavyIon == 2) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
698 else fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
699 fESDList[iCut]->Add(fHistoNGammaCandidates[iCut]);
700 if(fIsHeavyIon == 1) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",4000,0,4000,100,0,100);
701 else if(fIsHeavyIon == 2) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",400,0,400,50,0,50);
702 else fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",200,0,200,50,0,50);
703 fESDList[iCut]->Add(fHistoNGoodESDTracksVsNGammaCanditates[iCut]);
706 if(fIsHeavyIon == 1) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
707 else if(fIsHeavyIon == 2) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
708 else fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
709 fESDList[iCut]->Add(fHistoNV0Tracks[iCut]);
710 fProfileEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
711 fESDList[iCut]->Add(fProfileEtaShift[iCut]);
712 fHistoConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
713 fESDList[iCut]->Add(fHistoConvGammaPt[iCut]);
715 if (fDoPhotonQA == 2){
716 fPhotonDCAList[iCut] = new TList();
717 fPhotonDCAList[iCut]->SetName(Form("%s_%s_%s_%s Photon DCA tree",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
718 fPhotonDCAList[iCut]->SetOwner(kTRUE);
719 fCutFolder[iCut]->Add(fPhotonDCAList[iCut]);
721 fTreeConvGammaPtDcazCat[iCut] = new TTree("ESD_ConvGamma_Pt_Dcaz_R_Eta","ESD_ConvGamma_Pt_Dcaz_R_Eta_Cat");
722 fTreeConvGammaPtDcazCat[iCut]->Branch("Pt",&fPtGamma,"fPtGamma/F");
723 fTreeConvGammaPtDcazCat[iCut]->Branch("DcaZPhoton",&fDCAzPhoton,"fDCAzPhoton/F");
724 // fTreeConvGammaPtDcazCat[iCut]->Branch("R",&fRConvPhoton,"fRConvPhoton/F");
725 // fTreeConvGammaPtDcazCat[iCut]->Branch("Eta",&fEtaPhoton,"fEtaPhoton/F");
727 fTreeConvGammaPtDcazCat[iCut]->Branch("cat",&fCharCatPhoton,"fCharCatPhoton/b");
729 fTreeConvGammaPtDcazCat[iCut]->Branch("photonMCInfo",&fCharPhotonMCInfo,"fCharPhotonMCInfo/b");
731 fPhotonDCAList[iCut]->Add(fTreeConvGammaPtDcazCat[iCut]);
734 if (fDoPhotonQA > 0){
735 fHistoConvGammaR[iCut] = new TH1F("ESD_ConvGamma_R","ESD_ConvGamma_R",800,0,200);
736 fESDList[iCut]->Add(fHistoConvGammaR[iCut]);
737 fHistoConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",2000,-2,2);
738 fESDList[iCut]->Add(fHistoConvGammaEta[iCut]);
741 fTagOutputList[iCut] = new TList();
742 fTagOutputList[iCut]->SetName(Form("%s_%s_%s_%s Tagging Output",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
743 fTagOutputList[iCut]->SetOwner(1);
744 fCutFolder[iCut]->Add(fTagOutputList[iCut]);
746 const Int_t nptbins = 200;
747 const Double_t ptmin = 0.;
748 const Double_t ptmax = 20.;
750 const Int_t nmbins = 180;
751 const Double_t mmin = 0.;
752 const Double_t mmax = 0.9;
755 // this is maybe not necessary ...
757 fHistoConvGammaUntagged[iCut] = new TH1F("ConvGammaUntagged","",nptbins,ptmin,ptmax);
758 fHistoConvGammaUntagged[iCut]->SetXTitle("p_{T} (GeV/c)");
759 fTagOutputList[iCut]->Add(fHistoConvGammaUntagged[iCut]);
761 fHistoConvGammaTagged[iCut] = new TH1F("ConvGammaTagged","",nptbins,ptmin,ptmax);
762 fHistoConvGammaTagged[iCut]->SetXTitle("p_{T} (GeV/c)");
763 fTagOutputList[iCut]->Add(fHistoConvGammaTagged[iCut]);
765 fHistoConvGammaPi0Tagged[iCut] = new TH1F("ConvGammaPi0Tagged","",nptbins,ptmin,ptmax);
766 fHistoConvGammaPi0Tagged[iCut]->SetXTitle("p_{T} (GeV/c)");
767 fTagOutputList[iCut]->Add(fHistoConvGammaPi0Tagged[iCut]);
769 fHistoConvGammaEtaTagged[iCut] = new TH1F("ConvGammaEtaTagged","",nptbins,ptmin,ptmax);
770 fHistoConvGammaEtaTagged[iCut]->SetXTitle("p_{T} (GeV/c)");
771 fTagOutputList[iCut]->Add(fHistoConvGammaEtaTagged[iCut]);
774 fHistoPhotonPairAll[iCut] = new TH2F("PhotonPairAll","",nmbins,mmin,mmax,nptbins,ptmin,ptmax);
775 fHistoPhotonPairAll[iCut]->SetXTitle("M_{inv} (GeV/cc)");
776 fHistoPhotonPairAll[iCut]->SetYTitle("p_{T} (GeV/c)");
777 fTagOutputList[iCut]->Add(fHistoPhotonPairAll[iCut]);
779 fHistoPhotonPairAllGam[iCut] = new TH2F("PhotonPairAllGammaConvPt","",nmbins,mmin,mmax,nptbins,ptmin,ptmax);
780 fHistoPhotonPairAllGam[iCut]->SetXTitle("M_{inv} (GeV/cc)");
781 fHistoPhotonPairAllGam[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
782 fTagOutputList[iCut]->Add(fHistoPhotonPairAllGam[iCut]);
784 fHistoClusGammaPt[iCut] = new TH1F("ClusGamma_Pt","ClusGamma_Pt",250,0,25);
785 fTagOutputList[iCut]->Add(fHistoClusGammaPt[iCut]);
786 fHistoClusOverlapHeadersGammaPt[iCut] = new TH1F("ClusGammaOverlapHeaders_Pt","ClusGammaOverlapHeaders_Pt",250,0,25);
787 fTagOutputList[iCut]->Add(fHistoClusOverlapHeadersGammaPt[iCut]);
790 if(fDoMesonAnalysis){
791 fHistoMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
792 fESDList[iCut]->Add(fHistoMotherInvMassPt[iCut]);
793 fHistoMotherMatchedInvMassPt[iCut] = new TH2F("ESD_MotherMatched_InvMass_Pt","ESD_MotherMatched_InvMass_Pt",800,0,0.8,250,0,25);
794 fESDList[iCut]->Add(fHistoMotherMatchedInvMassPt[iCut]);
795 fHistoMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
796 fESDList[iCut]->Add(fHistoMotherBackInvMassPt[iCut]);
797 fHistoMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
798 fESDList[iCut]->Add(fHistoMotherInvMassEalpha[iCut]);
799 if (fDoMesonQA == 2){
800 fMesonDCAList[iCut] = new TList();
801 fMesonDCAList[iCut]->SetName(Form("%s_%s_%s_%s Meson DCA tree",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
802 fMesonDCAList[iCut]->SetOwner(kTRUE);
803 fCutFolder[iCut]->Add(fMesonDCAList[iCut]);
805 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut] = new TTree("ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag","ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag");
806 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("InvMass",&fInvMass,"fInvMass/F");
807 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("Pt",&fPt,"fPt/F");
808 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMin",&fDCAzGammaMin,"fDCAzGammaMin/F");
809 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMax",&fDCAzGammaMax,"fDCAzGammaMax/F");
810 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("kind",&fCharFlag,"fCharFlag/b");
812 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("mesonMCInfo",&fCharMesonMCInfo,"fCharMesonMCInfo/b");
814 fMesonDCAList[iCut]->Add(fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]);
818 fHistoMotherInvMassECalib[iCut] = new TH2F("ESD_Mother_InvMass_E_Calib","ESD_Mother_InvMass_E_Calib",800,0,0.8,250,0,25);
819 fESDList[iCut]->Add(fHistoMotherInvMassECalib[iCut]);
820 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);
821 fESDList[iCut]->Add(fHistoMotherInvMassECalibalpha[iCut]);
824 if (fDoMesonQA > 0 ){
825 fHistoMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
826 SetLogBinningXTH2(fHistoMotherPi0PtY[iCut]);
827 fESDList[iCut]->Add(fHistoMotherPi0PtY[iCut]);
828 fHistoMotherEtaPtY[iCut] = new TH2F("ESD_MotherEta_Pt_Y","ESD_MotherEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
829 SetLogBinningXTH2(fHistoMotherEtaPtY[iCut]);
830 fESDList[iCut]->Add(fHistoMotherEtaPtY[iCut]);
831 fHistoMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",150,0.03,15.,100,0,1);
832 SetLogBinningXTH2(fHistoMotherPi0PtAlpha[iCut]);
833 fESDList[iCut]->Add(fHistoMotherPi0PtAlpha[iCut]);
834 fHistoMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",150,0.03,15.,100,0,1);
835 SetLogBinningXTH2(fHistoMotherEtaPtAlpha[iCut]);
836 fESDList[iCut]->Add(fHistoMotherEtaPtAlpha[iCut]);
837 fHistoMotherPi0PtOpenAngle[iCut] = new TH2F("ESD_MotherPi0_Pt_OpenAngle","ESD_MotherPi0_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
838 SetLogBinningXTH2(fHistoMotherPi0PtOpenAngle[iCut]);
839 fESDList[iCut]->Add(fHistoMotherPi0PtOpenAngle[iCut]);
840 fHistoMotherEtaPtOpenAngle[iCut] = new TH2F("ESD_MotherEta_Pt_OpenAngle","ESD_MotherEta_Pt_OpenAngle",150,0.03,15.,100,0,TMath::Pi());
841 SetLogBinningXTH2(fHistoMotherEtaPtOpenAngle[iCut]);
842 fESDList[iCut]->Add(fHistoMotherEtaPtOpenAngle[iCut]);
843 fHistoMotherPi0ConvPhotonEtaPhi[iCut] = new TH2F("ESD_MotherPi0ConvPhoton_Eta_Phi","ESD_MotherPi0ConvPhoton_Eta_Phi",600,0,2*TMath::Pi(),400,-2,2);
844 fESDList[iCut]->Add(fHistoMotherPi0ConvPhotonEtaPhi[iCut]);
845 fHistoMotherEtaConvPhotonEtaPhi[iCut] = new TH2F("ESD_MotherEtaConvPhoton_Eta_Phi","ESD_MotherEtaConvPhoton_Eta_Phi",600,0,2*TMath::Pi(),400,-2,2);
846 fESDList[iCut]->Add(fHistoMotherEtaConvPhotonEtaPhi[iCut]);
850 if(fDoMesonAnalysis){
851 InitBack(); // Init Background Handler
856 fMCList = new TList*[fnCuts];
858 fTrueList = new TList*[fnCuts];
859 // Selected Header List
860 fHeaderNameList = new TList*[fnCuts];
861 fHistoMCHeaders = new TH1I*[fnCuts];
862 fHistoMCAllGammaPt = new TH1F*[fnCuts];
863 fHistoMCAllGammaEMCALAccPt = new TH1F*[fnCuts];
864 fHistoMCDecayGammaPi0Pt = new TH1F*[fnCuts];
865 fHistoMCDecayGammaRhoPt = new TH1F*[fnCuts];
866 fHistoMCDecayGammaEtaPt = new TH1F*[fnCuts];
867 fHistoMCDecayGammaOmegaPt = new TH1F*[fnCuts];
868 fHistoMCDecayGammaEtapPt = new TH1F*[fnCuts];
869 fHistoMCDecayGammaPhiPt = new TH1F*[fnCuts];
870 fHistoMCDecayGammaSigmaPt = new TH1F*[fnCuts];
871 fHistoMCConvGammaPt = new TH1F*[fnCuts];
872 fHistoTrueConvGammaPt = new TH1F*[fnCuts];
873 fHistoTrueConvPi0GammaPt = new TH1F*[fnCuts];
875 fHistoCombinatorialPt = new TH2F*[fnCuts];
876 fHistoTruePrimaryConvGammaPt = new TH1F*[fnCuts];
877 fHistoTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
878 fHistoTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
879 fHistoTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
880 fHistoTrueSecondaryConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
882 fHistoTrueClusGammaPt = new TH1F*[fnCuts];
883 fHistoTruePrimaryClusGammaPt = new TH1F*[fnCuts];
884 fHistoTruePrimaryClusGammaESDPtMCPt = new TH2F*[fnCuts];
886 if (fDoPhotonQA > 0){
887 fHistoMCConvGammaR = new TH1F*[fnCuts];
888 fHistoMCConvGammaEta = new TH1F*[fnCuts];
889 fHistoTrueConvGammaEta = new TH1F*[fnCuts];
891 if (fDoClusterQA > 0){
892 fHistoTrueClusUnConvGammaPt = new TH1F*[fnCuts];
893 fHistoTrueClusUnConvGammaMCPt = new TH1F*[fnCuts];
894 fHistoTrueClusElectronPt = new TH1F*[fnCuts];
895 fHistoTrueClusConvGammaPt = new TH1F*[fnCuts];
896 fHistoTrueClusConvGammaMCPt = new TH1F*[fnCuts];
897 fHistoTrueClusConvGammaFullyPt = new TH1F*[fnCuts];
898 fHistoTrueClusMergedGammaPt = new TH1F*[fnCuts];
899 fHistoTrueClusMergedPartConvGammaPt = new TH1F*[fnCuts];
900 fHistoTrueClusDalitzPt = new TH1F*[fnCuts];
901 fHistoTrueClusDalitzMergedPt = new TH1F*[fnCuts];
902 fHistoTrueClusPhotonFromElecMotherPt= new TH1F*[fnCuts];
903 fHistoTrueClusShowerPt = new TH1F*[fnCuts];
904 fHistoTrueClusSubLeadingPt = new TH1F*[fnCuts];
905 fHistoTrueClusNParticles = new TH1I*[fnCuts];
906 fHistoTrueClusEMNonLeadingPt = new TH1F*[fnCuts];
907 fHistoTrueNLabelsInClus = new TH1F*[fnCuts];
910 if(fDoMesonAnalysis){
911 fHistoMCPi0Pt = new TH1F*[fnCuts];
912 fHistoMCPi0WOWeightPt = new TH1F*[fnCuts];
913 fHistoMCEtaPt = new TH1F*[fnCuts];
914 fHistoMCEtaWOWeightPt = new TH1F*[fnCuts];
915 fHistoMCPi0InAccPt = new TH1F*[fnCuts];
916 fHistoMCEtaInAccPt = new TH1F*[fnCuts];
918 fHistoTruePi0InvMassPt = new TH2F*[fnCuts];
919 fHistoTrueEtaInvMassPt = new TH2F*[fnCuts];
920 fHistoTruePrimaryPi0InvMassPt = new TH2F*[fnCuts];
921 fHistoTruePrimaryEtaInvMassPt = new TH2F*[fnCuts];
922 fHistoTruePrimaryPi0W0WeightingInvMassPt = new TH2F*[fnCuts];
923 fHistoTruePrimaryEtaW0WeightingInvMassPt = new TH2F*[fnCuts];
924 fProfileTruePrimaryPi0WeightsInvMassPt = new TProfile2D*[fnCuts];
925 fProfileTruePrimaryEtaWeightsInvMassPt = new TProfile2D*[fnCuts];
926 fHistoTrueSecondaryPi0InvMassPt = new TH2F*[fnCuts];
927 fHistoTrueSecondaryEtaInvMassPt = new TH2F*[fnCuts];
928 fHistoTrueSecondaryPi0FromK0sInvMassPt = new TH2F*[fnCuts];
929 fHistoTrueSecondaryPi0FromEtaInvMassPt = new TH2F*[fnCuts];
930 fHistoTrueSecondaryPi0FromLambdaInvMassPt = new TH2F*[fnCuts];
932 fHistoMCPi0PtY = new TH2F*[fnCuts];
933 fHistoMCEtaPtY = new TH2F*[fnCuts];
934 fHistoMCPi0PtAlpha = new TH2F*[fnCuts];
935 fHistoMCEtaPtAlpha = new TH2F*[fnCuts];
936 fHistoMCK0sPt = new TH1F*[fnCuts];
937 fHistoMCK0sWOWeightPt = new TH1F*[fnCuts];
938 fHistoMCK0sPtY = new TH2F*[fnCuts];
939 fHistoMCSecPi0PtvsSource = new TH2F*[fnCuts];
940 fHistoMCSecPi0Source = new TH1F*[fnCuts];
941 fHistoMCSecEtaPt = new TH1F*[fnCuts];
942 fHistoMCSecEtaSource = new TH1F*[fnCuts];
943 fHistoTruePi0CaloPhotonInvMassPt = new TH2F*[fnCuts];
944 fHistoTrueEtaCaloPhotonInvMassPt = new TH2F*[fnCuts];
945 fHistoTruePi0CaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
946 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt = new TH2F*[fnCuts];
947 fHistoTrueEtaCaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
948 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt = new TH2F*[fnCuts];
949 fHistoTruePi0CaloElectronInvMassPt = new TH2F*[fnCuts];
950 fHistoTrueEtaCaloElectronInvMassPt = new TH2F*[fnCuts];
951 fHistoTruePi0CaloMergedClusterInvMassPt = new TH2F*[fnCuts];
952 fHistoTrueEtaCaloMergedClusterInvMassPt = new TH2F*[fnCuts];
953 fHistoTruePi0CaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
954 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
955 fHistoTrueMotherCaloEMNonLeadingInvMassPt = new TH2F*[fnCuts];
956 fHistoTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
957 fHistoTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
958 fHistoTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
959 fHistoTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
960 fHistoTrueLambdaWithPi0DaughterMCPt = new TH1F*[fnCuts];
961 fHistoTrueBckGGInvMassPt = new TH2F*[fnCuts];
962 fHistoTrueBckContInvMassPt = new TH2F*[fnCuts];
963 fHistoTruePi0PtY = new TH2F*[fnCuts];
964 fHistoTrueEtaPtY = new TH2F*[fnCuts];
965 fHistoTruePi0PtAlpha = new TH2F*[fnCuts];
966 fHistoTrueEtaPtAlpha = new TH2F*[fnCuts];
967 fHistoTruePi0PtOpenAngle = new TH2F*[fnCuts];
968 fHistoTrueEtaPtOpenAngle = new TH2F*[fnCuts];
969 fHistoTrueMotherPi0ConvPhotonEtaPhi = new TH2F*[fnCuts];
970 fHistoTrueMotherEtaConvPhotonEtaPhi = new TH2F*[fnCuts];
976 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
977 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
978 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
979 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
980 TString cutstringMeson = "NoMesonCut";
981 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
983 fMCList[iCut] = new TList();
984 fMCList[iCut]->SetName(Form("%s_%s_%s_%s MC histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
985 fMCList[iCut]->SetOwner(kTRUE);
986 fCutFolder[iCut]->Add(fMCList[iCut]);
987 fHistoMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
988 fMCList[iCut]->Add(fHistoMCHeaders[iCut]);
989 fHistoMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
990 fMCList[iCut]->Add(fHistoMCAllGammaPt[iCut]);
991 fHistoMCAllGammaEMCALAccPt[iCut] = new TH1F("MC_AllGammaEMCALAcc_Pt","MC_AllGammaEMCALAcc_Pt",250,0,25);
992 fMCList[iCut]->Add(fHistoMCAllGammaEMCALAccPt[iCut]);
993 fHistoMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
994 fMCList[iCut]->Add(fHistoMCDecayGammaPi0Pt[iCut]);
995 fHistoMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
996 fMCList[iCut]->Add(fHistoMCDecayGammaRhoPt[iCut]);
997 fHistoMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
998 fMCList[iCut]->Add(fHistoMCDecayGammaEtaPt[iCut]);
999 fHistoMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
1000 fMCList[iCut]->Add(fHistoMCDecayGammaOmegaPt[iCut]);
1001 fHistoMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
1002 fMCList[iCut]->Add(fHistoMCDecayGammaEtapPt[iCut]);
1003 fHistoMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
1004 fMCList[iCut]->Add(fHistoMCDecayGammaPhiPt[iCut]);
1005 fHistoMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
1006 fMCList[iCut]->Add(fHistoMCDecayGammaSigmaPt[iCut]);
1007 fHistoMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
1008 fMCList[iCut]->Add(fHistoMCConvGammaPt[iCut]);
1010 if (fDoPhotonQA > 0){
1011 fHistoMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
1012 fMCList[iCut]->Add(fHistoMCConvGammaR[iCut]);
1013 fHistoMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",2000,-2,2);
1014 fMCList[iCut]->Add(fHistoMCConvGammaEta[iCut]);
1017 if(fDoMesonAnalysis){
1018 fHistoMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
1019 fHistoMCPi0Pt[iCut]->Sumw2();
1020 fMCList[iCut]->Add(fHistoMCPi0Pt[iCut]);
1021 fHistoMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
1022 fHistoMCPi0WOWeightPt[iCut]->Sumw2();
1023 fMCList[iCut]->Add(fHistoMCPi0WOWeightPt[iCut]);
1025 fHistoMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
1026 fHistoMCEtaPt[iCut]->Sumw2();
1027 fMCList[iCut]->Add(fHistoMCEtaPt[iCut]);
1028 fHistoMCEtaWOWeightPt[iCut] = new TH1F("MC_Eta_WOWeights_Pt","MC_Eta_WOWeights_Pt",250,0,25);
1029 fHistoMCEtaWOWeightPt[iCut]->Sumw2();
1030 fMCList[iCut]->Add(fHistoMCEtaWOWeightPt[iCut]);
1031 fHistoMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
1032 fHistoMCPi0InAccPt[iCut]->Sumw2();
1033 fMCList[iCut]->Add(fHistoMCPi0InAccPt[iCut]);
1034 fHistoMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
1035 fHistoMCEtaInAccPt[iCut]->Sumw2();
1036 fMCList[iCut]->Add(fHistoMCEtaInAccPt[iCut]);
1037 if (fDoMesonQA > 0){
1038 fHistoMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1039 fHistoMCPi0PtY[iCut]->Sumw2();
1040 SetLogBinningXTH2(fHistoMCPi0PtY[iCut]);
1041 fMCList[iCut]->Add(fHistoMCPi0PtY[iCut]);
1042 fHistoMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1043 fHistoMCEtaPtY[iCut]->Sumw2();
1044 SetLogBinningXTH2(fHistoMCEtaPtY[iCut]);
1045 fMCList[iCut]->Add(fHistoMCEtaPtY[iCut]);
1046 fHistoMCPi0PtAlpha[iCut] = new TH2F("MC_Pi0_Pt_Alpha","MC_Pi0_Pt_Alpha",150,0.03,15.,100,0,1);
1047 SetLogBinningXTH2(fHistoMCPi0PtAlpha[iCut]);
1048 fMCList[iCut]->Add(fHistoMCPi0PtAlpha[iCut]);
1049 fHistoMCEtaPtAlpha[iCut] = new TH2F("MC_Eta_Pt_Alpha","MC_Eta_Pt_Alpha",150,0.03,15.,100,0,1);
1050 SetLogBinningXTH2(fHistoMCEtaPtAlpha[iCut]);
1051 fMCList[iCut]->Add(fHistoMCEtaPtAlpha[iCut]);
1053 fHistoMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",150,0,15);
1054 fHistoMCK0sPt[iCut]->Sumw2();
1055 fMCList[iCut]->Add(fHistoMCK0sPt[iCut]);
1056 fHistoMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",150,0,15);
1057 fHistoMCK0sWOWeightPt[iCut]->Sumw2();
1058 fMCList[iCut]->Add(fHistoMCK0sWOWeightPt[iCut]);
1059 fHistoMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1060 fHistoMCK0sPtY[iCut]->Sumw2();
1061 SetLogBinningXTH2(fHistoMCK0sPtY[iCut]);
1062 fMCList[iCut]->Add(fHistoMCK0sPtY[iCut]);
1064 fHistoMCSecPi0Source[iCut] = new TH1F("MC_SecPi0_Source","MC_SecPi0_Source",5000,0.,5000);
1065 fMCList[iCut]->Add(fHistoMCSecPi0Source[iCut]);
1066 fHistoMCSecEtaSource[iCut] = new TH1F("MC_SecEta_Source","MC_SecEta_Source",5000,0,5000);
1067 fMCList[iCut]->Add(fHistoMCSecEtaSource[iCut]);
1068 fHistoMCSecPi0PtvsSource[iCut] = new TH2F("MC_SecPi0_Pt_Source","MC_SecPi0_Pt_Source",250,0.0,25.,16,-0.5,15.5);
1069 fHistoMCSecPi0PtvsSource[iCut]->Sumw2();
1070 fMCList[iCut]->Add(fHistoMCSecPi0PtvsSource[iCut]);
1071 fHistoMCSecEtaPt[iCut] = new TH1F("MC_SecEta_Pt","MC_SecEta_Pt",250,0,25);
1072 fHistoMCSecEtaPt[iCut]->Sumw2();
1073 fMCList[iCut]->Add(fHistoMCSecEtaPt[iCut]);
1077 fTrueList[iCut] = new TList();
1078 fTrueList[iCut]->SetName(Form("%s_%s_%s_%s True histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
1079 fTrueList[iCut]->SetOwner(kTRUE);
1080 fCutFolder[iCut]->Add(fTrueList[iCut]);
1082 fHistoTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
1083 fTrueList[iCut]->Add(fHistoTrueConvGammaPt[iCut]);
1085 fHistoTrueConvPi0GammaPt[iCut] = new TH1F("ESD_TrueConvPi0Gamma_Pt","ESD_TrueConvPi0Gamma_Pt",250,0,25);
1086 fTrueList[iCut]->Add(fHistoTrueConvPi0GammaPt[iCut]);
1088 fHistoCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
1089 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
1090 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
1091 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
1092 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
1093 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
1094 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
1095 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
1096 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
1097 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
1098 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
1099 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
1100 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
1101 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
1102 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
1103 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
1104 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
1105 fTrueList[iCut]->Add(fHistoCombinatorialPt[iCut]);
1106 fHistoTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
1107 fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaPt[iCut]);
1108 fHistoTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
1109 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaPt[iCut]);
1111 fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
1112 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
1113 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
1114 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
1116 fHistoTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
1117 fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaESDPtMCPt[iCut]);
1119 fHistoTrueClusGammaPt[iCut] = new TH1F("TrueClusGamma_Pt","ESD_TrueClusGamma_Pt",250,0,25);
1120 fTagOutputList[iCut]->Add(fHistoTrueClusGammaPt[iCut]);
1121 fHistoTruePrimaryClusGammaPt[iCut] = new TH1F("TruePrimaryClusGamma_Pt","ESD_TruePrimaryClusGamma_Pt",250,0,25);
1122 fTagOutputList[iCut]->Add(fHistoTruePrimaryClusGammaPt[iCut]);
1123 fHistoTruePrimaryClusGammaESDPtMCPt[iCut] = new TH2F("TruePrimaryClusGamma_Pt_MCPt","ESD_TruePrimaryClusGamma_MCPt",250,0,25,250,0,25);
1124 fTagOutputList[iCut]->Add(fHistoTruePrimaryClusGammaESDPtMCPt[iCut]);
1126 if (fDoPhotonQA > 0){
1127 fHistoTrueConvGammaEta[iCut] = new TH1F("ESD_TrueConvGamma_Eta","ESD_TrueConvGamma_Eta",2000,-2,2);
1128 fTrueList[iCut]->Add(fHistoTrueConvGammaEta[iCut]);
1130 if (fDoClusterQA > 0){
1131 fHistoTrueClusUnConvGammaPt[iCut] = new TH1F("TrueClusUnConvGamma_Pt","TrueClusUnConvGamma_Pt",250,0,25);
1132 fTagOutputList[iCut]->Add(fHistoTrueClusUnConvGammaPt[iCut]);
1133 fHistoTrueClusUnConvGammaMCPt[iCut] = new TH1F("TrueClusUnConvGamma_MCPt","TrueClusUnConvGamma_MCPt",250,0,25);
1134 fTagOutputList[iCut]->Add(fHistoTrueClusUnConvGammaMCPt[iCut]);
1135 fHistoTrueClusElectronPt[iCut] = new TH1F("TrueClusElectron_Pt","TrueElectronGamma_Pt",250,0,25);
1136 fTagOutputList[iCut]->Add(fHistoTrueClusElectronPt[iCut]);
1137 fHistoTrueClusConvGammaPt[iCut] = new TH1F("TrueClusConvGamma_Pt","TrueClusConvGamma_Pt",250,0,25);
1138 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaPt[iCut]);
1139 fHistoTrueClusConvGammaMCPt[iCut] = new TH1F("TrueClusConvGamma_MCPt","TrueClusConvGamma_MCPt",250,0,25);
1140 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaMCPt[iCut]);
1141 fHistoTrueClusConvGammaFullyPt[iCut] = new TH1F("TrueClusConvGammaFullyContained_Pt","TrueClusConvGammaFullyContained_Pt",250,0,25);
1142 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaFullyPt[iCut]);
1143 fHistoTrueClusMergedGammaPt[iCut] = new TH1F("TrueClusMergedGamma_Pt","TrueClusMergedGamma_Pt",250,0,25);
1144 fTagOutputList[iCut]->Add(fHistoTrueClusMergedGammaPt[iCut]);
1145 fHistoTrueClusMergedPartConvGammaPt[iCut] = new TH1F("TrueClusMergedPartConvGamma_Pt","TrueClusMergedPartConvGamma_Pt",250,0,25);
1146 fTagOutputList[iCut]->Add(fHistoTrueClusMergedPartConvGammaPt[iCut]);
1147 fHistoTrueClusDalitzPt[iCut] = new TH1F("TrueClusDalitz_Pt","TrueClusDalitz_Pt",250,0,25);
1148 fTagOutputList[iCut]->Add(fHistoTrueClusDalitzPt[iCut]);
1149 fHistoTrueClusDalitzMergedPt[iCut] = new TH1F("TrueClusDalitzMerged_Pt","TrueClusDalitzMerged_Pt",250,0,25);
1150 fTagOutputList[iCut]->Add(fHistoTrueClusDalitzMergedPt[iCut]);
1151 fHistoTrueClusPhotonFromElecMotherPt[iCut] = new TH1F("TrueClusPhotonFromElecMother_Pt","TrueClusPhotonFromElecMother_Pt",250,0,25);
1152 fTagOutputList[iCut]->Add(fHistoTrueClusPhotonFromElecMotherPt[iCut]);
1153 fHistoTrueClusShowerPt[iCut] = new TH1F("TrueClusShower_Pt","TrueClusShower_Pt",250,0,25);
1154 fTagOutputList[iCut]->Add(fHistoTrueClusShowerPt[iCut]);
1155 fHistoTrueClusSubLeadingPt[iCut] = new TH1F("TrueClusSubleading_Pt","TrueClusSubleading_Pt",250,0,25);
1156 fTagOutputList[iCut]->Add(fHistoTrueClusSubLeadingPt[iCut]);
1157 fHistoTrueClusNParticles[iCut] = new TH1I("TrueClusNParticles","TrueClusNParticles",20,0,20);
1158 fTagOutputList[iCut]->Add(fHistoTrueClusNParticles[iCut]);
1159 fHistoTrueClusEMNonLeadingPt[iCut] = new TH1F("TrueClusEMNonLeading_Pt","TrueClusEMNonLeading_Pt",250,0,25);
1160 fTagOutputList[iCut]->Add(fHistoTrueClusEMNonLeadingPt[iCut]);
1161 fHistoTrueNLabelsInClus[iCut] = new TH1F("TrueNLabelsInClus","TrueNLabelsInClus",100,-0.5,99.5);
1162 fTagOutputList[iCut]->Add(fHistoTrueNLabelsInClus[iCut]);
1165 if(fDoMesonAnalysis){
1166 fHistoTruePi0InvMassPt[iCut] = new TH2F("ESD_TruePi0_InvMass_Pt","ESD_TruePi0_InvMass_Pt",800,0,0.8,250,0,25);
1167 fTrueList[iCut]->Add(fHistoTruePi0InvMassPt[iCut]);
1168 fHistoTrueEtaInvMassPt[iCut] = new TH2F("ESD_TrueEta_InvMass_Pt","ESD_TrueEta_InvMass_Pt",800,0,0.8,250,0,25);
1169 fTrueList[iCut]->Add(fHistoTrueEtaInvMassPt[iCut]);
1171 fHistoTruePrimaryPi0InvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0_InvMass_Pt", "ESD_TruePrimaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1172 fHistoTruePrimaryPi0InvMassPt[iCut]->Sumw2();
1173 fTrueList[iCut]->Add(fHistoTruePrimaryPi0InvMassPt[iCut]);
1174 fHistoTruePrimaryEtaInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEta_InvMass_Pt", "ESD_TruePrimaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
1175 fHistoTruePrimaryEtaInvMassPt[iCut]->Sumw2();
1176 fTrueList[iCut]->Add(fHistoTruePrimaryEtaInvMassPt[iCut]);
1178 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0W0Weights_InvMass_Pt", "ESD_TruePrimaryPi0W0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1179 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]->Sumw2();
1180 fTrueList[iCut]->Add(fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]);
1181 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEtaW0Weights_InvMass_Pt", "ESD_TruePrimaryEtaW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1182 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]->Sumw2();
1183 fTrueList[iCut]->Add(fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]);
1185 fProfileTruePrimaryPi0WeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryPi0Weights_InvMass_Pt", "ESD_TruePrimaryPi0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1186 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->Sumw2();
1187 fTrueList[iCut]->Add(fProfileTruePrimaryPi0WeightsInvMassPt[iCut]);
1188 fProfileTruePrimaryEtaWeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryEtaWeights_InvMass_Pt", "ESD_TruePrimaryEtaWeights_InvMass_Pt", 800,0,0.8,250,0,25);
1189 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->Sumw2();
1190 fTrueList[iCut]->Add(fProfileTruePrimaryEtaWeightsInvMassPt[iCut]);
1192 fHistoTrueSecondaryPi0InvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0_InvMass_Pt", "ESD_TrueSecondaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1193 fHistoTrueSecondaryPi0InvMassPt[iCut]->Sumw2();
1194 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0InvMassPt[iCut]);
1195 fHistoTrueSecondaryEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryEta_InvMass_Pt", "ESD_TrueSecondaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
1196 fHistoTrueSecondaryEtaInvMassPt[iCut]->Sumw2();
1197 fTrueList[iCut]->Add(fHistoTrueSecondaryEtaInvMassPt[iCut]);
1199 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromK0s_InvMass_Pt","ESD_TrueSecondaryPi0FromK0s_InvMass_Pt",800,0,0.8,250,0,25);
1200 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->Sumw2();
1201 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]);
1202 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromEta_InvMass_Pt","ESD_TrueSecondaryPi0FromEta_InvMass_Pt",800,0,0.8,250,0,25);
1203 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]);
1204 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromLambda_InvMass_Pt","ESD_TrueSecondaryPi0FromLambda_InvMass_Pt",800,0,0.8,250,0,25);
1205 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]);
1206 if (fDoMesonQA > 0){
1207 fHistoTruePi0CaloPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloPhoton_InvMass_Pt","ESD_TruePi0CaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1208 fTrueList[iCut]->Add(fHistoTruePi0CaloPhotonInvMassPt[iCut]);
1209 fHistoTrueEtaCaloPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloPhoton_InvMass_Pt","ESD_TrueEtaCaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1210 fTrueList[iCut]->Add(fHistoTrueEtaCaloPhotonInvMassPt[iCut]);
1211 fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhoton_InvMass_Pt","ESD_TruePi0CaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1212 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]);
1213 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt","ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1214 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut]);
1215 fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt","ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1216 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]);
1217 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt","ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1218 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut]);
1220 fHistoTruePi0CaloElectronInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloElectron_InvMass_Pt","ESD_TruePi0CaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1221 fTrueList[iCut]->Add(fHistoTruePi0CaloElectronInvMassPt[iCut]);
1222 fHistoTrueEtaCaloElectronInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloElectron_InvMass_Pt","ESD_TrueEtaCaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1223 fTrueList[iCut]->Add(fHistoTrueEtaCaloElectronInvMassPt[iCut]);
1225 fHistoTruePi0CaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedCluster_InvMass_Pt","ESD_TruePi0CaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1226 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterInvMassPt[iCut]);
1227 fHistoTrueEtaCaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedCluster_InvMass_Pt","ESD_TrueEtaCaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1228 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]);
1230 fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut] = new TH2F("ESD_TrueMotherCaloEMNonLeading_InvMass_Pt","ESD_TrueMotherCaloEMNonLeading_InvMass_Pt",800,0,0.8,250,0,25);
1231 fTrueList[iCut]->Add(fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut]);
1232 fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt","ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1233 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]);
1234 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt","ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1235 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]);
1237 fHistoTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1238 fHistoTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
1239 SetLogBinningXTH2(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1240 fTrueList[iCut]->Add(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1241 fHistoTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1242 fHistoTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
1243 SetLogBinningXTH2(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1244 fTrueList[iCut]->Add(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1245 fHistoTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
1246 fTrueList[iCut]->Add(fHistoTrueBckGGInvMassPt[iCut]);
1247 fHistoTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
1248 fTrueList[iCut]->Add(fHistoTrueBckContInvMassPt[iCut]);
1249 fHistoTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
1250 fTrueList[iCut]->Add(fHistoTrueK0sWithPi0DaughterMCPt[iCut]);
1251 fHistoTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
1252 fTrueList[iCut]->Add(fHistoTrueEtaWithPi0DaughterMCPt[iCut]);
1253 fHistoTrueLambdaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueLambdaWithPi0Daughter_MCPt","ESD_TrueLambdaWithPi0Daughter_MCPt",250,0,25);
1254 fTrueList[iCut]->Add(fHistoTrueLambdaWithPi0DaughterMCPt[iCut]);
1256 fHistoTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1257 SetLogBinningXTH2(fHistoTruePi0PtY[iCut]);
1258 fTrueList[iCut]->Add(fHistoTruePi0PtY[iCut]);
1259 fHistoTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1260 SetLogBinningXTH2(fHistoTrueEtaPtY[iCut]);
1261 fTrueList[iCut]->Add(fHistoTrueEtaPtY[iCut]);
1262 fHistoTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",150,0.03,15.,100,0,1);
1263 SetLogBinningXTH2(fHistoTruePi0PtAlpha[iCut]);
1264 fTrueList[iCut]->Add(fHistoTruePi0PtAlpha[iCut]);
1265 fHistoTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",150,0.03,15.,100,0,1);
1266 SetLogBinningXTH2(fHistoTrueEtaPtAlpha[iCut]);
1267 fTrueList[iCut]->Add(fHistoTrueEtaPtAlpha[iCut]);
1269 fHistoTruePi0PtOpenAngle[iCut] = new TH2F("ESD_TruePi0_Pt_OpenAngle","ESD_TruePi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1270 SetLogBinningXTH2(fHistoTruePi0PtOpenAngle[iCut]);
1271 fTrueList[iCut]->Add(fHistoTruePi0PtOpenAngle[iCut]);
1272 fHistoTrueEtaPtOpenAngle[iCut] = new TH2F("ESD_TrueEta_Pt_OpenAngle","ESD_TrueEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1273 SetLogBinningXTH2(fHistoTrueEtaPtOpenAngle[iCut]);
1274 fTrueList[iCut]->Add(fHistoTrueEtaPtOpenAngle[iCut]);
1276 fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut] = new TH2F("ESD_TrueMotherPi0ConvPhoton_Eta_Phi","ESD_TrueMotherPi0ConvPhoton_Eta_Phi",600,0,2*TMath::Pi(),400,-2,2);
1277 fTrueList[iCut]->Add(fHistoTrueMotherPi0ConvPhotonEtaPhi[iCut]);
1278 fHistoTrueMotherEtaConvPhotonEtaPhi[iCut] = new TH2F("ESD_TrueMotherEtaConvPhoton_Eta_Phi","ESD_TrueMotherEtaConvPhoton_Eta_Phi",600,0,2*TMath::Pi(),400,-2,2);
1279 fTrueList[iCut]->Add(fHistoTrueMotherEtaConvPhotonEtaPhi[iCut]);
1286 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1287 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1290 if((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())
1291 if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1292 fOutputContainer->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1294 if((AliConvEventCuts*)fV0Reader->GetEventCuts())
1295 if(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms())
1296 fOutputContainer->Add(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms());
1299 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1300 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))) continue;
1301 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms()){
1302 fCutFolder[iCut]->Add(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms());
1304 if(!((AliConversionPhotonCuts*)fCutArray->At(iCut))) continue;
1305 if(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms()){
1306 fCutFolder[iCut]->Add(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms());
1308 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))) continue;
1309 if(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms()){
1310 fCutFolder[iCut]->Add(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms());
1312 if(fDoMesonAnalysis){
1313 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
1314 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
1315 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
1319 PostData(1, fOutputContainer);
1321 //_____________________________________________________________________________
1322 Bool_t AliAnalysisTaskGammaConvCalo::Notify()
1324 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1325 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))->GetDoEtaShift()){
1326 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1327 continue; // No Eta Shift requested, continue
1329 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1330 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
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
1336 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
1337 (((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber()).Data(),((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift());
1338 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1339 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1345 //_____________________________________________________________________________
1346 void AliAnalysisTaskGammaConvCalo::UserExec(Option_t *)
1349 // Called for each event
1351 Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
1352 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1353 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1354 fHistoNEvents[iCut]->Fill(eventQuality);
1359 if(fIsMC) fMCEvent = MCEvent();
1360 if(fMCEvent == NULL) fIsMC = kFALSE;
1362 fInputEvent = InputEvent();
1364 if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
1365 fMCStack = fMCEvent->Stack();
1366 if(fMCStack == NULL) fIsMC = kFALSE;
1369 if(fInputEvent->IsA()==AliAODEvent::Class()){
1370 fInputEvent->InitMagneticField();
1373 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
1375 // ------------------- BeginEvent ----------------------------
1377 AliEventplane *EventPlane = fInputEvent->GetEventplane();
1378 if(fIsHeavyIon ==1)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
1379 else fEventPlaneAngle=0.0;
1381 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1382 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
1383 fV0Reader->RelabelAODs(kTRUE);
1387 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1391 Bool_t isRunningEMCALrelAna = kFALSE;
1392 if (((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->GetClusterType() == 1) isRunningEMCALrelAna = kTRUE;
1394 Int_t eventNotAccepted = ((AliConvEventCuts*)fEventCutArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon,isRunningEMCALrelAna);
1396 if(eventNotAccepted){
1397 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1398 fHistoNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1402 if(eventQuality != 0){// Event Not Accepted
1403 //cout << "event rejected due to: " <<eventQuality << endl;
1404 fHistoNEvents[iCut]->Fill(eventQuality);
1408 fHistoNEvents[iCut]->Fill(eventQuality); // Should be 0 here
1409 fHistoNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
1410 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->IsHeavyIon() == 2) fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
1411 else fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1414 // Process MC Particle
1415 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection() != 0){
1416 if(fInputEvent->IsA()==AliESDEvent::Class()){
1417 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1418 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1421 else if(fInputEvent->IsA()==AliAODEvent::Class()){
1422 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1423 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1427 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader()){
1428 for(Int_t i = 0;i<(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
1429 TString nameBin= fHistoMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
1430 if (nameBin.CompareTo("")== 0){
1431 TString nameHeader = ((TObjString*)((TList*)((AliConvEventCuts*)fEventCutArray->At(iCut))
1432 ->GetAcceptedHeader())->At(i))->GetString();
1433 fHistoMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
1440 if(fInputEvent->IsA()==AliESDEvent::Class())
1441 ProcessMCParticles();
1442 if(fInputEvent->IsA()==AliAODEvent::Class())
1443 ProcessAODMCParticles();
1446 // 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)
1447 ProcessClusters(); // process calo clusters
1448 ProcessPhotonCandidates(); // Process this cuts gammas
1450 fHistoNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
1451 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks(),fGammaCandidates->GetEntries());
1452 if(fDoMesonAnalysis){ // Meson Analysis
1453 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1454 fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
1455 fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
1456 fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
1457 fUnsmearedE = new Double_t[fGammaCandidates->GetEntries()];
1459 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1460 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
1461 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
1462 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
1463 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
1464 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
1468 PhotonTagging(); // tag PCM photons with calorimeter
1470 CalculatePi0Candidates(); // Combine Gammas from conversion and from calo
1472 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1473 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1474 CalculateBackground(); // Combinatorial Background
1475 UpdateEventByEventData(); // Store Event for mixed Events
1478 CalculateBackgroundRP(); // Combinatorial Background
1479 fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
1480 fBGClusHandlerRP[iCut]->AddEvent(fClusterCandidates,fInputEvent); // Store Event for mixed Events
1483 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1484 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1485 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1486 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1487 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1488 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
1490 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1491 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1492 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1493 delete[] fUnsmearedE; fUnsmearedE = 0x0;
1497 fGammaCandidates->Clear(); // delete this cuts good gammas
1498 fClusterCandidates->Clear(); // delete cluster candidates
1501 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1502 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
1503 fV0Reader->RelabelAODs(kFALSE);
1506 PostData(1, fOutputContainer);
1509 //________________________________________________________________________
1510 void AliAnalysisTaskGammaConvCalo::ProcessClusters()
1514 nclus = fInputEvent->GetNumberOfCaloClusters();
1516 // cout << nclus << endl;
1518 if(nclus == 0) return;
1521 Double_t vertex[3] = {0};
1522 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1524 // Loop over EMCal clusters
1525 for(Long_t i = 0; i < nclus; i++){
1527 AliVCluster* clus = NULL;
1528 clus = fInputEvent->GetCaloCluster(i);
1529 if (!clus) continue;
1530 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelected(clus,fInputEvent,fIsMC)) continue;
1531 // TLorentzvector with cluster
1532 TLorentzVector clusterVector;
1533 clus->GetMomentum(clusterVector,vertex);
1535 TLorentzVector* tmpvec = new TLorentzVector();
1536 tmpvec->SetPxPyPzE(clusterVector.Px(),clusterVector.Py(),clusterVector.Pz(),clusterVector.E());
1538 // convert to AODConversionPhoton
1539 AliAODConversionPhoton *PhotonCandidate=new AliAODConversionPhoton(tmpvec);
1540 if(!PhotonCandidate) continue;
1542 // Flag Photon as CaloPhoton
1543 PhotonCandidate->SetIsCaloPhoton();
1544 PhotonCandidate->SetCaloClusterRef(i);
1547 Int_t* mclabelsCluster = clus->GetLabels();
1548 PhotonCandidate->SetNCaloPhotonMCLabels(clus->GetNLabels());
1549 // cout << clus->GetNLabels() << endl;
1550 if (clus->GetNLabels()>0){
1551 for (Int_t k =0; k< (Int_t)clus->GetNLabels(); k++){
1552 if (k< 20)PhotonCandidate->SetCaloPhotonMCLabel(k,mclabelsCluster[k]);
1553 // Int_t pdgCode = fMCStack->Particle(mclabelsCluster[k])->GetPdgCode();
1554 // cout << "label " << k << "\t" << mclabelsCluster[k] << " pdg code: " << pdgCode << endl;
1559 fIsFromMBHeader = kTRUE;
1560 fIsOverlappingWithOtherHeader = kFALSE;
1561 // test whether largest contribution to cluster orginates in added signals
1562 if (fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetCaloPhotonMCLabel(0), fMCStack, fInputEvent) == 0) fIsFromMBHeader = kFALSE;
1564 if (clus->GetNLabels()>1){
1565 Int_t* mclabelsCluster = clus->GetLabels();
1566 for (Int_t l = 1; l < (Int_t)clus->GetNLabels(); l++ ){
1567 if (((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(mclabelsCluster[l], fMCStack, fInputEvent) == 0) fIsOverlappingWithOtherHeader = kTRUE;
1572 if (fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
1573 fHistoClusGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1574 fClusterCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1576 if (fIsFromMBHeader && fIsOverlappingWithOtherHeader) fHistoClusOverlapHeadersGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1579 if(fInputEvent->IsA()==AliESDEvent::Class()){
1580 ProcessTrueClusterCandidates(PhotonCandidate);
1582 ProcessTrueClusterCandidatesAOD(PhotonCandidate);
1591 //________________________________________________________________________
1592 void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1595 TParticle *Photon = NULL;
1596 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1597 fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1599 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0)Photon = fMCStack->Particle(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1603 // cout << "no photon" << endl;
1607 TruePhotonCandidate->SetCaloPhotonMCFlags(fMCStack);
1610 if(fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
1611 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1612 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1613 if (fDoClusterQA > 0){
1614 if (TruePhotonCandidate->IsLargestComponentPhoton()){
1615 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1616 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1618 if (TruePhotonCandidate->IsLargestComponentElectron())
1619 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1620 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1621 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1622 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(Photon->GetMother(0)))->Pt());
1624 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1625 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1626 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1627 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1628 if (TruePhotonCandidate->IsMergedPartConv())
1629 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1630 if (TruePhotonCandidate->IsDalitz())
1631 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1632 if (TruePhotonCandidate->IsDalitzMerged())
1633 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1634 if (TruePhotonCandidate->IsPhotonWithElecMother())
1635 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1636 if (TruePhotonCandidate->IsShower())
1637 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1638 if (TruePhotonCandidate->IsSubLeadingEM())
1639 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1640 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1644 if(Photon->GetMother(0) <= fMCStack->GetNprimary()){
1645 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1646 if(fIsFromMBHeader){
1647 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1648 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1655 //________________________________________________________________________
1656 void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1658 AliAODMCParticle *Photon = NULL;
1659 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1660 if (AODMCTrackArray){
1661 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1662 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0) Photon = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1665 AliInfo("AODMCTrackArray could not be loaded");
1670 // cout << "no photon" << endl;
1673 TruePhotonCandidate->SetCaloPhotonMCFlagsAOD(fInputEvent);
1674 fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1676 if(fIsFromMBHeader && !fIsOverlappingWithOtherHeader){
1677 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1678 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1679 if (fDoClusterQA > 0){
1680 if (TruePhotonCandidate->IsLargestComponentPhoton()) {
1681 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1682 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1684 if (TruePhotonCandidate->IsLargestComponentElectron())
1685 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1686 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()) {
1687 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1688 AliAODMCParticle *Mother = (AliAODMCParticle*) AODMCTrackArray->At(Photon->GetMother());
1689 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(Mother->Pt());
1691 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1692 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1693 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1694 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1695 if (TruePhotonCandidate->IsMergedPartConv())
1696 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1697 if (TruePhotonCandidate->IsDalitz())
1698 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1699 if (TruePhotonCandidate->IsDalitzMerged())
1700 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1701 if (TruePhotonCandidate->IsPhotonWithElecMother())
1702 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1703 if (TruePhotonCandidate->IsShower())
1704 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1705 if (TruePhotonCandidate->IsSubLeadingEM())
1706 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1707 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1712 if(fIsFromMBHeader){
1713 fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1714 // if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1717 if(Photon->IsPrimary()){
1718 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1719 if(fIsFromMBHeader){
1720 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1721 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1726 //________________________________________________________________________
1727 void AliAnalysisTaskGammaConvCalo::ProcessPhotonCandidates()
1730 TList *GammaCandidatesStepOne = new TList();
1731 TList *GammaCandidatesStepTwo = new TList();
1732 // Loop over Photon Candidates allocated by ReaderV1
1733 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1734 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1735 if(!PhotonCandidate) continue;
1736 fIsFromMBHeader = kTRUE;
1737 if(fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1738 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1739 if(isPosFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1740 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1741 if(isNegFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1742 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1745 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
1746 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(PhotonCandidate->GetPhotonPhi(),fEventPlaneAngle)) continue;
1747 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1748 !((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1749 fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1751 if(fIsFromMBHeader){
1752 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1753 if (fDoPhotonQA > 0){
1754 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1755 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1759 if(fInputEvent->IsA()==AliESDEvent::Class())
1760 ProcessTruePhotonCandidates(PhotonCandidate);
1761 if(fInputEvent->IsA()==AliAODEvent::Class())
1762 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1764 if (fIsFromMBHeader && fDoPhotonQA == 2){
1765 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1766 fPtGamma = PhotonCandidate->Pt();
1767 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1768 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1769 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1770 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1771 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1772 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1773 fPtGamma = PhotonCandidate->Pt();
1774 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1775 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1776 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1777 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1778 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1781 } else if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1782 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1784 GammaCandidatesStepOne->Add(PhotonCandidate);
1785 } else if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1786 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1787 GammaCandidatesStepTwo->Add(PhotonCandidate);
1790 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
1791 for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1792 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1793 if(!PhotonCandidate) continue;
1794 fIsFromMBHeader = kTRUE;
1795 if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1796 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1797 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1798 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1800 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1801 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1802 fGammaCandidates->Add(PhotonCandidate);
1803 if(fIsFromMBHeader){
1804 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1805 if (fDoPhotonQA > 0){
1806 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1807 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1812 if(fInputEvent->IsA()==AliESDEvent::Class())
1813 ProcessTruePhotonCandidates(PhotonCandidate);
1814 if(fInputEvent->IsA()==AliAODEvent::Class())
1815 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1816 } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1818 if (fIsFromMBHeader && fDoPhotonQA == 2){
1819 if (fIsHeavyIon ==1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1820 fPtGamma = PhotonCandidate->Pt();
1821 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1822 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1823 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1824 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1825 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1826 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1827 fPtGamma = PhotonCandidate->Pt();
1828 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1829 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1830 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1831 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1832 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1837 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1838 for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1839 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1840 if(!PhotonCandidate) continue;
1841 fIsFromMBHeader = kTRUE;
1842 if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1843 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1844 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1845 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1847 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
1848 fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1849 if(fIsFromMBHeader){
1850 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1851 if (fDoPhotonQA > 0){
1852 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1853 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1857 if(fInputEvent->IsA()==AliESDEvent::Class())
1858 ProcessTruePhotonCandidates(PhotonCandidate);
1859 if(fInputEvent->IsA()==AliAODEvent::Class())
1860 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1862 if (fIsFromMBHeader){
1863 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1864 fPtGamma = PhotonCandidate->Pt();
1865 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1866 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1867 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1868 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1869 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1870 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1871 fPtGamma = PhotonCandidate->Pt();
1872 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1873 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1874 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1875 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1876 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1882 delete GammaCandidatesStepOne;
1883 GammaCandidatesStepOne = 0x0;
1884 delete GammaCandidatesStepTwo;
1885 GammaCandidatesStepTwo = 0x0;
1888 //________________________________________________________________________
1889 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1892 Double_t magField = fInputEvent->GetMagneticField();
1893 if( magField < 0.0 ){
1900 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1901 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1902 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
1903 fCharPhotonMCInfo = 0;
1905 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1906 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1908 if(posDaughter->GetMother() != negDaughter->GetMother()){
1909 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1910 fCharPhotonMCInfo = 1;
1913 else if(posDaughter->GetMother() == -1){
1914 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1915 fCharPhotonMCInfo = 1;
1919 if(pdgCode[0]!=11 || pdgCode[1]!=11){
1920 fCharPhotonMCInfo = 1;
1921 return; //One Particle is not a electron
1924 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
1925 fCharPhotonMCInfo = 1;
1926 return; // Same Charge
1929 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
1930 if(Photon->GetPdgCode() != 22){
1931 fCharPhotonMCInfo = 1;
1932 return; // Mother is no Photon
1935 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
1936 fCharPhotonMCInfo = 1;
1937 return;// check if the daughters come from a conversion
1939 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1944 if(fIsFromMBHeader){
1945 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1946 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1948 if(Photon->IsPrimary()){
1949 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1950 if(fIsFromMBHeader){
1951 fCharPhotonMCInfo = 6;
1952 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1953 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1955 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1957 if(fIsFromMBHeader){
1958 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1959 fCharPhotonMCInfo = 2;
1960 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1961 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1962 fCharPhotonMCInfo = 5;
1963 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1965 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1966 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1967 fCharPhotonMCInfo = 4;
1968 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1970 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1971 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1972 fCharPhotonMCInfo = 3;
1976 if( ((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetPdgCode() == 111 ){
1977 fHistoTrueConvPi0GammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1980 //________________________________________________________________________
1981 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1984 Double_t magField = fInputEvent->GetMagneticField();
1985 if( magField < 0.0 ){
1992 // Process True Photons
1993 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1994 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
1995 fCharPhotonMCInfo = 0;
1997 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1998 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1999 fCharPhotonMCInfo = 1;
2000 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
2001 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2004 else if(posDaughter->GetMother(0) == -1){
2005 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
2009 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
2011 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
2013 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
2015 if(Photon->GetPdgCode() != 22){
2016 return; // Mother is no Photon
2019 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
2022 if(fIsFromMBHeader){
2023 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2024 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
2026 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
2027 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
2028 if(fIsFromMBHeader){
2029 fCharPhotonMCInfo = 6;
2030 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2031 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
2034 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
2037 if(fIsFromMBHeader){
2038 fCharPhotonMCInfo = 2;
2039 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2040 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2041 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
2042 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2043 fCharPhotonMCInfo = 5;
2045 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2046 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
2047 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2048 fCharPhotonMCInfo = 4;
2050 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2051 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
2052 fCharPhotonMCInfo = 3;
2059 Int_t imother = Photon->GetMother(0);
2061 AliMCParticle* McMother = static_cast<AliMCParticle*>(fMCEvent->GetTrack(imother));
2062 //cout << fMCEvent->GetRunNumber() << " " << imother << " " << fMCEvent->GetNumberOfTracks() << endl;
2063 if(McMother->PdgCode() == 111) fHistoTrueConvPi0GammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2067 //________________________________________________________________________
2068 void AliAnalysisTaskGammaConvCalo::ProcessAODMCParticles()
2071 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2073 // Loop over all primary MC particle
2074 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
2076 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
2077 if (!particle) continue;
2078 if (!particle->IsPrimary()) continue;
2080 Int_t isMCFromMBHeader = -1;
2081 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2082 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2083 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2086 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2087 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
2088 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2089 if (abs(particle->Eta()) < 0.66 ){
2090 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2092 if(particle->GetMother() >-1){ // Meson Decay Gamma
2093 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
2095 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2098 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2101 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2104 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2107 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2110 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2113 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2118 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
2120 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
2121 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
2122 if(!tmpDaughter) continue;
2123 if(abs(tmpDaughter->GetPdgCode()) == 11){
2124 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
2127 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2128 if (fDoPhotonQA > 0){
2129 fHistoMCConvGammaR[fiCut]->Fill(rConv);
2130 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2133 // Converted MC Gamma
2134 if(fDoMesonAnalysis){
2135 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2136 Double_t mesonY = 10.;
2137 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2138 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2140 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2142 Float_t weightedK0s= 1;
2143 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2144 if (particle->Pt()>0.005){
2145 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2146 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2149 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2150 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2151 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2153 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2154 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2155 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
2156 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
2157 Float_t weighted= 1;
2158 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2159 if (particle->Pt()>0.005){
2160 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2161 // if(particle->GetPdgCode() == 221){
2162 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2166 Double_t mesonY = 10.;
2167 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2168 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2170 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2173 Double_t alpha = -1;
2174 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2175 alpha = TMath::Abs((daughter0->E() - daughter1->E()))/(daughter0->E() + daughter1->E());
2179 if(particle->GetPdgCode() == 111){
2180 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2181 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2182 if (fDoMesonQA > 0){
2183 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2184 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2186 } else if(particle->GetPdgCode() == 221){
2187 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2188 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2189 if (fDoMesonQA > 0){
2190 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2191 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2195 // Check the acceptance for both gammas
2196 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
2197 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) &&
2198 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2199 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2201 if(particle->GetPdgCode() == 111){
2202 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2203 } else if(particle->GetPdgCode() == 221){
2204 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2212 //________________________________________________________________________
2213 void AliAnalysisTaskGammaConvCalo::ProcessMCParticles()
2215 // Loop over all primary MC particle
2216 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2217 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2218 if (!particle) continue;
2220 Int_t isMCFromMBHeader = -1;
2221 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2222 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2223 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2226 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2227 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
2228 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2229 if (abs(particle->Eta()) < 0.66 ){
2230 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2233 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
2234 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
2236 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2239 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2242 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2245 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2248 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2251 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2254 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2259 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
2260 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2261 if (fDoPhotonQA > 0){
2262 fHistoMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
2263 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2265 } // Converted MC Gamma
2266 if(fDoMesonAnalysis){
2267 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2268 Double_t mesonY = 10.;
2269 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2270 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2272 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2274 Float_t weightedK0s= 1;
2275 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2276 if (particle->Pt()>0.005){
2277 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2278 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2281 if (fMCStack->IsPhysicalPrimary(i)){
2282 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2283 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2284 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2287 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2288 ->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2289 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
2290 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
2292 Float_t weighted= 1;
2293 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2294 if (particle->Pt()>0.005){
2295 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2296 // if(particle->GetPdgCode() == 221){
2297 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2301 Double_t mesonY = 10.;
2302 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2303 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2305 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2308 Double_t alpha = -1;
2309 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2310 alpha = TMath::Abs((daughter0->Energy() - daughter1->Energy()))/(daughter0->Energy() + daughter1->Energy());
2313 if(particle->GetPdgCode() == 111){
2314 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2315 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2316 if (fDoMesonQA > 0){
2317 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2318 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2320 } else if(particle->GetPdgCode() == 221){
2321 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2322 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2323 if (fDoMesonQA > 0){
2324 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2325 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2329 // Check the acceptance for both gammas
2330 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
2331 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) &&
2332 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2333 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2335 if(particle->GetPdgCode() == 111){
2336 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2337 } else if(particle->GetPdgCode() == 221){
2338 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2346 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
2347 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2348 if (!particle) continue;
2350 Int_t isMCFromMBHeader = -1;
2351 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2352 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2353 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2356 if(fDoMesonAnalysis){
2357 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2358 Float_t weighted= 1;
2359 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2360 if (particle->Pt()>0.005){
2361 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2362 // if(particle->GetPdgCode() == 221){
2363 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2368 if(particle->GetPdgCode() == 111){
2369 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2370 Int_t source = GetSourceClassification(111,pdgCode);
2371 fHistoMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
2372 fHistoMCSecPi0Source[fiCut]->Fill(pdgCode);
2373 } else if(particle->GetPdgCode() == 221){
2374 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2375 fHistoMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2376 fHistoMCSecEtaSource[fiCut]->Fill(pdgCode);
2384 //________________________________________________________________________
2385 void AliAnalysisTaskGammaConvCalo::PhotonTagging(){
2387 // Conversion Gammas
2388 if(fGammaCandidates->GetEntries()>0){
2390 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
2392 // get conversion photon
2393 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2394 if (gamma0==NULL) continue;
2396 TLorentzVector photonVector;
2397 photonVector.SetPxPyPzE(gamma0->GetPx(),gamma0->GetPy(),gamma0->GetPz(),gamma0->GetPhotonP());
2402 // loop over clusters
2403 for(Int_t secondGammaIndex = 0; secondGammaIndex<fClusterCandidates->GetEntries(); ++secondGammaIndex) {
2405 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2406 if (gamma1==NULL) continue;
2408 TLorentzVector clusterVector;
2409 clusterVector.SetPxPyPzE(gamma1->GetPx(),gamma1->GetPy(),gamma1->GetPz(),gamma1->GetPhotonP());
2412 TLorentzVector pairVector = photonVector+clusterVector;
2415 if((pairVector.M() > 0.11 && pairVector.M() < 0.15)){
2419 if((pairVector.M() > 0.50 && pairVector.M() < 0.6)){
2422 }// end loop over clusters
2424 if(btagpi0 && btageta)
2425 fHistoConvGammaTagged[fiCut]->Fill(photonVector.Pt());
2426 else if(btagpi0 && !btageta)
2427 fHistoConvGammaPi0Tagged[fiCut]->Fill(photonVector.Pt());
2428 else if(btageta && !btagpi0)
2429 fHistoConvGammaEtaTagged[fiCut]->Fill(photonVector.Pt());
2431 fHistoConvGammaUntagged[fiCut]->Fill(photonVector.Pt());
2433 }// end loop over gammas
2438 //________________________________________________________________________
2439 void AliAnalysisTaskGammaConvCalo::CalculatePi0Candidates(){
2441 // Conversion Gammas
2442 if(fGammaCandidates->GetEntries()>0){
2445 Double_t vertex[3] = {0};
2446 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
2448 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2449 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2450 if (gamma0==NULL) continue;
2452 for(Int_t secondGammaIndex=0;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
2453 Bool_t matched = kFALSE;
2454 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2455 if (gamma1==NULL) continue;
2457 if (gamma1->GetIsCaloPhoton()){
2458 AliVCluster* cluster = fInputEvent->GetCaloCluster(gamma1->GetCaloClusterRef());
2459 matched = ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->MatchConvPhotonToCluster(gamma0,cluster, fInputEvent );
2462 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
2463 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
2467 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2469 fHistoMotherMatchedInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2471 fHistoMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2473 // fill new histograms
2475 fHistoPhotonPairAll[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2476 fHistoPhotonPairAllGam[fiCut]->Fill(pi0cand->M(),gamma0->Pt());
2478 if(pi0cand->GetAlpha()<0.1)
2479 fHistoMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
2481 if (fDoMesonQA > 0){
2482 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
2483 fHistoMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2484 fHistoMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2485 fHistoMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2486 fHistoMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
2488 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
2489 fHistoMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2490 fHistoMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2491 fHistoMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2492 fHistoMotherEtaConvPhotonEtaPhi[fiCut]->Fill(gamma0->GetPhotonPhi(), gamma0->GetPhotonEta());
2495 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
2499 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
2500 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2501 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2502 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2504 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2507 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2508 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2509 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2511 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2514 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
2515 fSparseMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2520 if(fInputEvent->IsA()==AliESDEvent::Class())
2521 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1, matched);
2522 if(fInputEvent->IsA()==AliAODEvent::Class())
2523 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1, matched);
2526 if (fDoMesonQA == 2){
2527 fInvMass = pi0cand->M();
2528 fPt = pi0cand->Pt();
2529 if (abs(gamma0->GetDCAzToPrimVtx()) < abs(gamma1->GetDCAzToPrimVtx())){
2530 fDCAzGammaMin = gamma0->GetDCAzToPrimVtx();
2531 fDCAzGammaMax = gamma1->GetDCAzToPrimVtx();
2533 fDCAzGammaMin = gamma1->GetDCAzToPrimVtx();
2534 fDCAzGammaMax = gamma0->GetDCAzToPrimVtx();
2536 fCharFlag = pi0cand->GetMesonQuality();
2537 // cout << "gamma 0: " << gamma0->GetV0Index()<< "\t" << gamma0->GetPx() << "\t" << gamma0->GetPy() << "\t" << gamma0->GetPz() << "\t" << endl;
2538 // cout << "gamma 1: " << gamma1->GetV0Index()<< "\t"<< gamma1->GetPx() << "\t" << gamma1->GetPy() << "\t" << gamma1->GetPz() << "\t" << endl;
2539 // cout << "pi0: "<<fInvMass << "\t" << fPt <<"\t" << fDCAzGammaMin << "\t" << fDCAzGammaMax << "\t" << (Int_t)fCharFlag << "\t" << (Int_t)fCharMesonMCInfo <<endl;
2540 if (fIsHeavyIon == 1 && fPt > 0.399 && fPt < 20. ) {
2541 if (fInvMass > 0.08 && fInvMass < 0.2) fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2542 if ((fInvMass > 0.45 && fInvMass < 0.6) && (fPt > 0.999 && fPt < 20.) )fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2543 } else if (fPt > 0.299 && fPt < 20. ) {
2544 if ( (fInvMass > 0.08 && fInvMass < 0.2) || (fInvMass > 0.45 && fInvMass < 0.6)) fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2547 if (fDoMesonQA == 1){
2548 fHistoMotherInvMassECalib[fiCut]->Fill(pi0cand->M(),gamma1->E());
2549 if(pi0cand->GetAlpha()<0.1)
2550 fHistoMotherInvMassECalibalpha[fiCut]->Fill(pi0cand->M(),gamma1->E());
2560 //______________________________________________________________________
2561 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2563 // Process True Mesons
2564 AliStack *MCStack = fMCEvent->Stack();
2565 fCharMesonMCInfo = 0;
2566 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2567 Bool_t isTruePi0 = kFALSE;
2568 Bool_t isTrueEta = kFALSE;
2569 Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
2570 Int_t gamma0MotherLabel = -1;
2571 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2572 // Daughters Gamma 0
2573 TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
2574 TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
2575 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
2576 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2577 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2578 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
2579 gamma0MotherLabel=gammaMC0->GetFirstMother();
2584 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
2586 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2587 Int_t gamma1MotherLabel = -1;
2590 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2591 // Daughters Gamma 1
2592 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
2593 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2594 // get mother of interest (pi0 or eta)
2595 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2596 gamma1MotherLabel=gammaMC1->GetMother(0);
2597 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2598 if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=MCStack->Particle(gammaMC1->GetMother(0))->GetMother(0);
2599 else gamma1MotherLabel=gammaMC1->GetMother(0);
2602 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2606 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2607 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
2610 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
2615 if(isTruePi0 || isTrueEta){// True Pion or Eta
2617 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2618 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2620 if (fDoMesonQA > 0){
2621 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2622 if(isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2623 if(isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2625 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched){
2626 if(isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2627 if(isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2629 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() ){
2630 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2631 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2632 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0){
2633 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2635 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta){
2636 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2639 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2640 if (isTruePi0 )fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2641 if (isTrueEta )fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2643 if (TrueGammaCandidate1->IsMergedPartConv() && !matched){
2644 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2645 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2649 if (fDoMesonQA > 0){
2651 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2652 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2653 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2654 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2655 fHistoTrueMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2657 } else if (isTrueEta){
2658 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2659 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2660 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2661 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2662 fHistoTrueMotherEtaConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2667 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
2668 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma0MotherLabel))->GetMother(0);
2669 Float_t weightedSec= 1;
2670 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
2671 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
2672 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2674 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2675 if (isTrueEta) fHistoTrueSecondaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2676 fCharMesonMCInfo = 2;
2677 if (secMotherLabel >-1){
2678 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310 && isTruePi0 ){
2679 fCharMesonMCInfo = 4;
2680 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2681 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2683 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221 && isTruePi0){
2684 fCharMesonMCInfo = 3;
2685 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2686 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2688 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==3122 && isTruePi0){
2689 fCharMesonMCInfo = 7;
2690 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2691 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2694 } else { // Only primary pi0 for efficiency calculation
2695 fCharMesonMCInfo = 6;
2696 Float_t weighted= 1;
2697 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
2698 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
2699 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
2700 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2704 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2705 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2706 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2707 } else if (isTrueEta) {
2708 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2709 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2710 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2713 if (fDoMesonQA > 0){
2714 if(isTruePi0){ // Only primary pi0 for resolution
2715 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2717 if (isTrueEta){ // Only primary eta for resolution
2718 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2723 } else if(!isTruePi0 && !isTrueEta){ // Background
2724 if (fDoMesonQA > 0){
2725 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2726 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2727 fCharMesonMCInfo = 1;
2728 } else { // No photon or without mother
2729 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2735 //______________________________________________________________________
2736 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2739 // Process True Mesons
2740 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2741 Bool_t isTruePi0 = kFALSE;
2742 Bool_t isTrueEta = kFALSE;
2744 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
2745 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
2747 fCharMesonMCInfo = 0;
2748 Int_t gamma0MCLabel = -1;
2749 Int_t gamma0MotherLabel = -1;
2750 if(!positiveMC||!negativeMC)
2753 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
2754 gamma0MCLabel = positiveMC->GetMother();
2757 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2758 // Daughters Gamma 0
2759 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2760 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2761 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
2762 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
2763 gamma0MotherLabel=gammaMC0->GetMother();
2769 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2770 Int_t gamma1MotherLabel = -1;
2773 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2774 // Daughters Gamma 1
2775 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2776 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2777 // get mother of interest (pi0 or eta)
2778 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2779 gamma1MotherLabel=gammaMC1->GetMother();
2780 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2781 if (TrueGammaCandidate1->IsConversion()){
2782 AliAODMCParticle * gammaGrandMotherMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC1->GetMother()));
2783 gamma1MotherLabel=gammaGrandMotherMC1->GetMother();
2784 } else gamma1MotherLabel=gammaMC1->GetMother();
2787 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2791 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2792 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2795 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2800 if(isTruePi0 || isTrueEta){// True Pion or Eta
2802 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2803 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2805 if (fDoMesonQA > 0){
2806 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2807 if (isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2808 if (isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2810 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched) {
2811 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2812 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2814 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()){
2815 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2816 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2817 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0)
2818 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2819 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta)
2820 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2822 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2823 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2824 if (isTrueEta) fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2826 if (TrueGammaCandidate1->IsMergedPartConv() && !matched) {
2827 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2828 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2833 if (fDoMesonQA > 0){
2835 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2836 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2837 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2838 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2839 fHistoTrueMotherPi0ConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2841 } else if (isTrueEta){
2842 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2843 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2844 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2845 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2846 fHistoTrueMotherEtaConvPhotonEtaPhi[fiCut]->Fill(TrueGammaCandidate0->GetPhotonPhi(), TrueGammaCandidate0->GetPhotonEta());
2850 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2851 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2852 Float_t weightedSec= 1;
2853 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2854 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
2855 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2857 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2858 if (isTrueEta) fHistoTrueSecondaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2860 fCharMesonMCInfo = 2;
2861 if (secMotherLabel >-1){
2862 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310 && isTruePi0){
2863 fCharMesonMCInfo = 4;
2864 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2865 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2867 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221 && isTruePi0){
2868 fCharMesonMCInfo = 3;
2869 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2870 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2872 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122 && isTruePi0){
2873 fCharMesonMCInfo = 7;
2874 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2875 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2878 } else{ // Only primary pi0 for efficiency calculation
2879 Float_t weighted= 1;
2880 fCharMesonMCInfo = 6;
2881 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2882 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2883 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2884 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2888 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2889 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2890 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2891 } else if (isTrueEta){
2892 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2893 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2894 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2896 if (fDoMesonQA > 0){
2897 if(isTruePi0){ // Only primary pi0 for resolution
2898 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2899 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2902 if (isTrueEta){ // Only primary eta for resolution
2903 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2904 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2909 } else if(!isTruePi0 && !isTrueEta) { // Background
2910 if (fDoMesonQA > 0){
2911 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2912 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2913 fCharMesonMCInfo = 1;
2914 } else { // No photon or without mother
2915 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2921 //________________________________________________________________________
2922 void AliAnalysisTaskGammaConvCalo::CalculateBackground(){
2924 Int_t zbin= fBGClusHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2927 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2928 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2930 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2933 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2934 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2935 for(Int_t nEventsInBG=0;nEventsInBG<fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2936 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2937 if(fMoveParticleAccordingToVertex == kTRUE){
2938 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2941 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2942 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2943 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2944 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2945 if(fMoveParticleAccordingToVertex == kTRUE){
2946 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2948 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2949 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2952 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2953 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2954 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2955 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2956 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2957 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2958 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2960 delete backgroundCandidate;
2961 backgroundCandidate = 0x0;
2966 for(Int_t nEventsInBG=0;nEventsInBG <fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2967 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2968 if(previousEventV0s){
2969 if(fMoveParticleAccordingToVertex == kTRUE){
2970 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2972 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2973 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2974 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2976 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2978 if(fMoveParticleAccordingToVertex == kTRUE){
2979 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2981 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2982 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2985 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2986 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2987 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2988 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2989 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2990 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2992 delete backgroundCandidate;
2993 backgroundCandidate = 0x0;
3001 //________________________________________________________________________
3002 void AliAnalysisTaskGammaConvCalo::CalculateBackgroundRP(){
3004 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
3006 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3007 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
3009 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
3014 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
3015 // Correct for the number of rotations
3016 // BG is for rotation the same, except for factor NRotations
3017 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
3019 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
3021 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
3022 if (gamma0==NULL) continue;
3023 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
3024 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
3025 if (gamma1 == NULL) continue;
3026 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
3027 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
3029 RotateParticle(gamma1);
3030 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3031 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3032 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3033 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3034 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3035 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3036 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3043 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
3045 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
3047 if(previousEventGammas){
3048 // test weighted background
3049 Double_t weight=1.0;
3050 // Correct for the number of eventmixing:
3051 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
3052 // real combinations (since you cannot combine a photon with its own)
3053 // but BG leads to N_{a}*N_{b} combinations
3054 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
3056 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3057 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3058 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
3060 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
3062 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3063 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3064 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3065 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3066 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3067 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3068 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3076 //________________________________________________________________________
3077 void AliAnalysisTaskGammaConvCalo::RotateParticle(AliAODConversionPhoton *gamma){
3078 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
3079 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
3080 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
3081 gamma->RotateZ(rotationValue);
3084 //________________________________________________________________________
3085 void AliAnalysisTaskGammaConvCalo::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
3087 previousEventEP=previousEventEP+TMath::Pi();
3088 thisEventEP=thisEventEP+TMath::Pi();
3089 Double_t rotationValue= thisEventEP-previousEventEP;
3090 gamma->RotateZ(rotationValue);
3093 //________________________________________________________________________
3094 void AliAnalysisTaskGammaConvCalo::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
3095 //see header file for documentation
3097 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
3098 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
3099 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
3101 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
3102 particle->SetConversionPoint(movedPlace);
3104 //________________________________________________________________________
3105 void AliAnalysisTaskGammaConvCalo::UpdateEventByEventData(){
3106 //see header file for documentation
3107 if(fGammaCandidates->GetEntries() >0 ){
3108 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3109 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3110 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3111 } else { // means we use #V0s for multiplicity
3112 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3113 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3119 //________________________________________________________________________
3120 void AliAnalysisTaskGammaConvCalo::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
3122 // 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
3123 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
3124 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
3125 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
3126 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
3127 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
3128 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
3129 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
3130 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
3131 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
3132 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
3133 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
3134 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
3135 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
3136 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
3137 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
3138 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
3139 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
3140 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
3141 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
3142 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
3143 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
3144 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
3145 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
3146 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
3147 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
3148 else {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
3150 //________________________________________________________________________
3151 void AliAnalysisTaskGammaConvCalo::RelabelAODPhotonCandidates(Bool_t mode){
3153 // Relabeling For AOD Event
3155 // MCLabel -> AODMCLabel
3158 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
3159 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
3160 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
3161 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
3164 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
3165 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
3166 if(!PhotonCandidate) continue;
3167 if(!mode){// Back to ESD Labels
3168 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
3169 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
3170 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
3171 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
3174 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
3175 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
3176 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
3177 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
3179 Bool_t AODLabelPos = kFALSE;
3180 Bool_t AODLabelNeg = kFALSE;
3182 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
3183 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
3185 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
3186 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
3187 PhotonCandidate->SetLabelPositive(i);
3188 AODLabelPos = kTRUE;
3192 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
3193 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
3194 PhotonCandidate->SetLabelNegative(i);
3195 AODLabelNeg = kTRUE;
3198 if(AODLabelNeg && AODLabelPos){
3202 if(!AODLabelPos || !AODLabelNeg){
3203 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
3209 delete[] fMCStackPos;
3210 delete[] fMCStackNeg;
3211 delete[] fESDArrayPos;
3212 delete[] fESDArrayNeg;
3216 void AliAnalysisTaskGammaConvCalo::SetLogBinningXTH2(TH2* histoRebin){
3217 TAxis *axisafter = histoRebin->GetXaxis();
3218 Int_t bins = axisafter->GetNbins();
3219 Double_t from = axisafter->GetXmin();
3220 Double_t to = axisafter->GetXmax();
3221 Double_t *newbins = new Double_t[bins+1];
3223 Double_t factor = TMath::Power(to/from, 1./bins);
3224 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
3225 axisafter->Set(bins, newbins);
3229 //________________________________________________________________________
3230 void AliAnalysisTaskGammaConvCalo::Terminate(const Option_t *)
3233 //fOutputContainer->Print(); // Will crash on GRID
3236 //________________________________________________________________________
3237 Int_t AliAnalysisTaskGammaConvCalo::GetSourceClassification(Int_t daughter, Int_t pdgCode){
3239 if (daughter == 111) {
3240 if (abs(pdgCode) == 310) return 1; // k0s
3241 else if (abs(pdgCode) == 3122) return 2; // Lambda
3242 else if (abs(pdgCode) == 130) return 3; // K0L
3243 else if (abs(pdgCode) == 2212) return 4; // proton
3244 else if (abs(pdgCode) == 2112) return 5; // neutron
3245 else if (abs(pdgCode) == 211) return 6; // pion
3246 else if (abs(pdgCode) == 321) return 7; // kaon
3247 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
3248 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112 ) return 9; // Sigma
3249 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114 ) return 10; // Delta
3250 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323 ) return 11; // K*
git://git.uio.no / u / mrichter / AliRoot.git / blob