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 fHistoMotherInvMassECalib(NULL),
117 fHistoMotherInvMassECalibalpha(NULL),
118 fTreeMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
125 fHistoConvGammaUntagged(NULL),
126 fHistoConvGammaTagged(NULL),
127 fHistoConvGammaPi0Tagged(NULL),
128 fHistoConvGammaEtaTagged(NULL),
129 fHistoPhotonPairAll(NULL),
130 fHistoPhotonPairAllGam(NULL),
131 fHistoClusGammaPt(NULL),
132 fHistoMCHeaders(NULL),
133 fHistoMCAllGammaPt(NULL),
134 fHistoMCAllGammaEMCALAccPt(NULL),
135 fHistoMCDecayGammaPi0Pt(NULL),
136 fHistoMCDecayGammaRhoPt(NULL),
137 fHistoMCDecayGammaEtaPt(NULL),
138 fHistoMCDecayGammaOmegaPt(NULL),
139 fHistoMCDecayGammaEtapPt(NULL),
140 fHistoMCDecayGammaPhiPt(NULL),
141 fHistoMCDecayGammaSigmaPt(NULL),
142 fHistoMCConvGammaPt(NULL),
143 fHistoMCConvGammaR(NULL),
144 fHistoMCConvGammaEta(NULL),
146 fHistoMCPi0WOWeightPt(NULL),
148 fHistoMCEtaWOWeightPt(NULL),
149 fHistoMCPi0InAccPt(NULL),
150 fHistoMCEtaInAccPt(NULL),
151 fHistoMCPi0PtY(NULL),
152 fHistoMCEtaPtY(NULL),
153 fHistoMCPi0PtAlpha(NULL),
154 fHistoMCEtaPtAlpha(NULL),
156 fHistoMCK0sWOWeightPt(NULL),
157 fHistoMCK0sPtY(NULL),
158 fHistoMCSecPi0PtvsSource(NULL),
159 fHistoMCSecPi0Source(NULL),
160 fHistoMCSecEtaPt(NULL),
161 fHistoMCSecEtaSource(NULL),
162 fHistoTruePi0InvMassPt(NULL),
163 fHistoTrueEtaInvMassPt(NULL),
164 fHistoTruePi0CaloPhotonInvMassPt(NULL),
165 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
166 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
167 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
168 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
169 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
170 fHistoTruePi0CaloElectronInvMassPt(NULL),
171 fHistoTrueEtaCaloElectronInvMassPt(NULL),
172 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
173 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
174 fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
175 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
176 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
177 fHistoTruePrimaryPi0InvMassPt(NULL),
178 fHistoTruePrimaryEtaInvMassPt(NULL),
179 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
180 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
181 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
182 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
183 fHistoTruePrimaryPi0MCPtResolPt(NULL),
184 fHistoTruePrimaryEtaMCPtResolPt(NULL),
185 fHistoTrueSecondaryPi0InvMassPt(NULL),
186 fHistoTrueSecondaryEtaInvMassPt(NULL),
187 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
188 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
189 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
190 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
191 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
192 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
193 fHistoTrueBckGGInvMassPt(NULL),
194 fHistoTrueBckContInvMassPt(NULL),
195 fHistoTruePi0PtY(NULL),
196 fHistoTrueEtaPtY(NULL),
197 fHistoTruePi0PtAlpha(NULL),
198 fHistoTrueEtaPtAlpha(NULL),
199 fHistoTruePi0PtOpenAngle(NULL),
200 fHistoTrueEtaPtOpenAngle(NULL),
201 fHistoTrueConvGammaPt(NULL),
202 fHistoTrueConvPi0GammaPt(NULL),
203 fHistoTrueConvGammaEta(NULL),
204 fHistoCombinatorialPt(NULL),
205 fHistoTruePrimaryConvGammaPt(NULL),
206 fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
207 fHistoTrueSecondaryConvGammaPt(NULL),
208 fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
209 fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
210 fHistoTrueClusGammaPt(NULL),
211 fHistoTrueClusUnConvGammaPt(NULL),
212 fHistoTrueClusUnConvGammaMCPt(NULL),
213 fHistoTrueClusElectronPt(NULL),
214 fHistoTrueClusConvGammaPt(NULL),
215 fHistoTrueClusConvGammaMCPt(NULL),
216 fHistoTrueClusConvGammaFullyPt(NULL),
217 fHistoTrueClusMergedGammaPt(NULL),
218 fHistoTrueClusMergedPartConvGammaPt(NULL),
219 fHistoTrueClusDalitzPt(NULL),
220 fHistoTrueClusDalitzMergedPt(NULL),
221 fHistoTrueClusPhotonFromElecMotherPt(NULL),
222 fHistoTrueClusShowerPt(NULL),
223 fHistoTrueClusSubLeadingPt(NULL),
224 fHistoTrueClusNParticles(NULL),
225 fHistoTrueClusEMNonLeadingPt(NULL),
226 fHistoTrueNLabelsInClus(NULL),
227 fHistoTruePrimaryClusGammaPt(NULL),
228 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
230 fHistoNGoodESDTracks(NULL),
231 fHistoNGammaCandidates(NULL),
232 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
233 fHistoNV0Tracks(NULL),
234 fProfileEtaShift(NULL),
235 fEventPlaneAngle(-100),
237 fNGammaCandidates(0),
248 fMoveParticleAccordingToVertex(kTRUE),
250 fDoMesonAnalysis(kTRUE),
254 fIsFromMBHeader(kTRUE),
260 //________________________________________________________________________
261 AliAnalysisTaskGammaConvCalo::AliAnalysisTaskGammaConvCalo(const char *name):
262 AliAnalysisTaskSE(name),
266 fBGClusHandler(NULL),
267 fBGClusHandlerRP(NULL),
275 fPhotonDCAList(NULL),
279 fHeaderNameList(NULL),
280 fTagOutputList(NULL),
283 fGammaCandidates(NULL),
284 fClusterCandidates(NULL),
285 fEventCutArray(NULL),
288 fConversionCuts(NULL),
289 fClusterCutArray(NULL),
290 fCaloPhotonCuts(NULL),
291 fMesonCutArray(NULL),
293 fHistoConvGammaPt(NULL),
294 fHistoConvGammaR(NULL),
295 fHistoConvGammaEta(NULL),
296 fTreeConvGammaPtDcazCat(NULL),
302 fCharPhotonMCInfo(0),
303 fHistoMotherInvMassPt(NULL),
304 fHistoMotherMatchedInvMassPt(NULL),
305 fSparseMotherInvMassPtZM(NULL),
306 fHistoMotherBackInvMassPt(NULL),
307 fSparseMotherBackInvMassPtZM(NULL),
308 fHistoMotherInvMassEalpha(NULL),
309 fHistoMotherPi0PtY(NULL),
310 fHistoMotherEtaPtY(NULL),
311 fHistoMotherPi0PtAlpha(NULL),
312 fHistoMotherEtaPtAlpha(NULL),
313 fHistoMotherPi0PtOpenAngle(NULL),
314 fHistoMotherEtaPtOpenAngle(NULL),
315 fHistoMotherInvMassECalib(NULL),
316 fHistoMotherInvMassECalibalpha(NULL),
317 fTreeMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
324 fHistoConvGammaUntagged(NULL),
325 fHistoConvGammaTagged(NULL),
326 fHistoConvGammaPi0Tagged(NULL),
327 fHistoConvGammaEtaTagged(NULL),
328 fHistoPhotonPairAll(NULL),
329 fHistoPhotonPairAllGam(NULL),
330 fHistoClusGammaPt(NULL),
331 fHistoMCHeaders(NULL),
332 fHistoMCAllGammaPt(NULL),
333 fHistoMCAllGammaEMCALAccPt(NULL),
334 fHistoMCDecayGammaPi0Pt(NULL),
335 fHistoMCDecayGammaRhoPt(NULL),
336 fHistoMCDecayGammaEtaPt(NULL),
337 fHistoMCDecayGammaOmegaPt(NULL),
338 fHistoMCDecayGammaEtapPt(NULL),
339 fHistoMCDecayGammaPhiPt(NULL),
340 fHistoMCDecayGammaSigmaPt(NULL),
341 fHistoMCConvGammaPt(NULL),
342 fHistoMCConvGammaR(NULL),
343 fHistoMCConvGammaEta(NULL),
345 fHistoMCPi0WOWeightPt(NULL),
347 fHistoMCEtaWOWeightPt(NULL),
348 fHistoMCPi0InAccPt(NULL),
349 fHistoMCEtaInAccPt(NULL),
350 fHistoMCPi0PtY(NULL),
351 fHistoMCEtaPtY(NULL),
352 fHistoMCPi0PtAlpha(NULL),
353 fHistoMCEtaPtAlpha(NULL),
355 fHistoMCK0sWOWeightPt(NULL),
356 fHistoMCK0sPtY(NULL),
357 fHistoMCSecPi0PtvsSource(NULL),
358 fHistoMCSecPi0Source(NULL),
359 fHistoMCSecEtaPt(NULL),
360 fHistoMCSecEtaSource(NULL),
361 fHistoTruePi0InvMassPt(NULL),
362 fHistoTrueEtaInvMassPt(NULL),
363 fHistoTruePi0CaloPhotonInvMassPt(NULL),
364 fHistoTrueEtaCaloPhotonInvMassPt(NULL),
365 fHistoTruePi0CaloConvertedPhotonInvMassPt(NULL),
366 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt(NULL),
367 fHistoTrueEtaCaloConvertedPhotonInvMassPt(NULL),
368 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt(NULL),
369 fHistoTruePi0CaloElectronInvMassPt(NULL),
370 fHistoTrueEtaCaloElectronInvMassPt(NULL),
371 fHistoTruePi0CaloMergedClusterInvMassPt(NULL),
372 fHistoTrueEtaCaloMergedClusterInvMassPt(NULL),
373 fHistoTrueMotherCaloEMNonLeadingInvMassPt(NULL),
374 fHistoTruePi0CaloMergedClusterPartConvInvMassPt(NULL),
375 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt(NULL),
376 fHistoTruePrimaryPi0InvMassPt(NULL),
377 fHistoTruePrimaryEtaInvMassPt(NULL),
378 fHistoTruePrimaryPi0W0WeightingInvMassPt(NULL),
379 fHistoTruePrimaryEtaW0WeightingInvMassPt(NULL),
380 fProfileTruePrimaryPi0WeightsInvMassPt(NULL),
381 fProfileTruePrimaryEtaWeightsInvMassPt(NULL),
382 fHistoTruePrimaryPi0MCPtResolPt(NULL),
383 fHistoTruePrimaryEtaMCPtResolPt(NULL),
384 fHistoTrueSecondaryPi0InvMassPt(NULL),
385 fHistoTrueSecondaryEtaInvMassPt(NULL),
386 fHistoTrueSecondaryPi0FromK0sInvMassPt(NULL),
387 fHistoTrueK0sWithPi0DaughterMCPt(NULL),
388 fHistoTrueSecondaryPi0FromEtaInvMassPt(NULL),
389 fHistoTrueEtaWithPi0DaughterMCPt(NULL),
390 fHistoTrueSecondaryPi0FromLambdaInvMassPt(NULL),
391 fHistoTrueLambdaWithPi0DaughterMCPt(NULL),
392 fHistoTrueBckGGInvMassPt(NULL),
393 fHistoTrueBckContInvMassPt(NULL),
394 fHistoTruePi0PtY(NULL),
395 fHistoTrueEtaPtY(NULL),
396 fHistoTruePi0PtAlpha(NULL),
397 fHistoTrueEtaPtAlpha(NULL),
398 fHistoTruePi0PtOpenAngle(NULL),
399 fHistoTrueEtaPtOpenAngle(NULL),
400 fHistoTrueConvGammaPt(NULL),
401 fHistoTrueConvPi0GammaPt(NULL),
402 fHistoTrueConvGammaEta(NULL),
403 fHistoCombinatorialPt(NULL),
404 fHistoTruePrimaryConvGammaPt(NULL),
405 fHistoTruePrimaryConvGammaESDPtMCPt(NULL),
406 fHistoTrueSecondaryConvGammaPt(NULL),
407 fHistoTrueSecondaryConvGammaFromXFromK0sPt(NULL),
408 fHistoTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
409 fHistoTrueClusGammaPt(NULL),
410 fHistoTrueClusUnConvGammaPt(NULL),
411 fHistoTrueClusUnConvGammaMCPt(NULL),
412 fHistoTrueClusElectronPt(NULL),
413 fHistoTrueClusConvGammaPt(NULL),
414 fHistoTrueClusConvGammaMCPt(NULL),
415 fHistoTrueClusConvGammaFullyPt(NULL),
416 fHistoTrueClusMergedGammaPt(NULL),
417 fHistoTrueClusMergedPartConvGammaPt(NULL),
418 fHistoTrueClusDalitzPt(NULL),
419 fHistoTrueClusDalitzMergedPt(NULL),
420 fHistoTrueClusPhotonFromElecMotherPt(NULL),
421 fHistoTrueClusShowerPt(NULL),
422 fHistoTrueClusSubLeadingPt(NULL),
423 fHistoTrueClusNParticles(NULL),
424 fHistoTrueClusEMNonLeadingPt(NULL),
425 fHistoTrueNLabelsInClus(NULL),
426 fHistoTruePrimaryClusGammaPt(NULL),
427 fHistoTruePrimaryClusGammaESDPtMCPt(NULL),
429 fHistoNGoodESDTracks(NULL),
430 fHistoNGammaCandidates(NULL),
431 fHistoNGoodESDTracksVsNGammaCanditates(NULL),
432 fHistoNV0Tracks(NULL),
433 fProfileEtaShift(NULL),
434 fEventPlaneAngle(-100),
436 fNGammaCandidates(0),
447 fMoveParticleAccordingToVertex(kTRUE),
449 fDoMesonAnalysis(kTRUE),
453 fIsFromMBHeader(kTRUE),
456 // Define output slots here
457 DefineOutput(1, TList::Class());
460 AliAnalysisTaskGammaConvCalo::~AliAnalysisTaskGammaConvCalo()
462 if(fGammaCandidates){
463 delete fGammaCandidates;
464 fGammaCandidates = 0x0;
466 if(fClusterCandidates){
467 delete fClusterCandidates;
468 fClusterCandidates = 0x0;
475 delete[] fBGHandlerRP;
479 delete[] fBGClusHandler;
480 fBGClusHandler = 0x0;
482 if(fBGClusHandlerRP){
483 delete[] fBGClusHandlerRP;
484 fBGClusHandlerRP = 0x0;
487 //___________________________________________________________
488 void AliAnalysisTaskGammaConvCalo::InitBack(){
490 const Int_t nDim = 4;
491 Int_t nBins[nDim] = {800,250,7,4};
492 Double_t xMin[nDim] = {0,0, 0,0};
493 Double_t xMax[nDim] = {0.8,25,7,4};
495 fSparseMotherInvMassPtZM = new THnSparseF*[fnCuts];
496 fSparseMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
498 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
499 fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
501 fBGClusHandler = new AliGammaConversionAODBGHandler*[fnCuts];
502 fBGClusHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
504 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
505 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
506 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
507 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
508 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
509 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
511 Int_t collisionSystem = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(0,1));
512 Int_t centMin = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(1,1));
513 Int_t centMax = atoi((TString)(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber())(2,1));
515 if(collisionSystem == 1 || collisionSystem == 2 ||
516 collisionSystem == 5 || collisionSystem == 8 ||
517 collisionSystem == 9){
518 centMin = centMin*10;
519 centMax = centMax*10;
520 if(centMax ==0 && centMax!=centMin) centMax=100;
521 } else if(collisionSystem == 3 || collisionSystem == 6){
524 } else if(collisionSystem == 4 || collisionSystem == 7){
525 centMin = ((centMin*5)+45);
526 centMax = ((centMax*5)+45);
529 fBackList[iCut] = new TList();
530 fBackList[iCut]->SetName(Form("%s_%s_%s_%s Back histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(), cutstringMeson.Data()));
531 fBackList[iCut]->SetOwner(kTRUE);
532 fCutFolder[iCut]->Add(fBackList[iCut]);
534 fSparseMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
535 fBackList[iCut]->Add(fSparseMotherBackInvMassPtZM[iCut]);
537 fMotherList[iCut] = new TList();
538 fMotherList[iCut]->SetName(Form("%s_%s_%s_%s Mother histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
539 fMotherList[iCut]->SetOwner(kTRUE);
540 fCutFolder[iCut]->Add(fMotherList[iCut]);
542 fSparseMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
543 fMotherList[iCut]->Add(fSparseMotherInvMassPtZM[iCut]);
545 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
546 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
547 collisionSystem,centMin,centMax,
548 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
549 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity());
550 fBGClusHandler[iCut] = new AliGammaConversionAODBGHandler(
551 collisionSystem,centMin,centMax,
552 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
553 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity());
554 fBGHandlerRP[iCut] = NULL;
556 fBGHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
557 ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsHeavyIon(),
558 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
559 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
560 fBGClusHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
561 ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsHeavyIon(),
562 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
563 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
564 fBGHandler[iCut] = NULL;
569 //________________________________________________________________________
570 void AliAnalysisTaskGammaConvCalo::UserCreateOutputObjects(){
573 if(fOutputContainer != NULL){
574 delete fOutputContainer;
575 fOutputContainer = NULL;
577 if(fOutputContainer == NULL){
578 fOutputContainer = new TList();
579 fOutputContainer->SetOwner(kTRUE);
582 // Array of current cut's gammas
583 fGammaCandidates = new TList();
584 fClusterCandidates = new TList();
586 fCutFolder = new TList*[fnCuts];
587 fESDList = new TList*[fnCuts];
588 fBackList = new TList*[fnCuts];
589 fMotherList = new TList*[fnCuts];
590 fHistoNEvents = new TH1I*[fnCuts];
591 fHistoNGoodESDTracks = new TH1I*[fnCuts];
592 fHistoNGammaCandidates = new TH1I*[fnCuts];
593 fHistoNGoodESDTracksVsNGammaCanditates = new TH2F*[fnCuts];
594 fHistoNV0Tracks = new TH1I*[fnCuts];
595 fProfileEtaShift = new TProfile*[fnCuts];
596 fHistoConvGammaPt = new TH1F*[fnCuts];
598 if (fDoPhotonQA == 2){
599 fPhotonDCAList = new TList*[fnCuts];
600 fTreeConvGammaPtDcazCat = new TTree*[fnCuts];
602 if (fDoPhotonQA > 0){
603 fHistoConvGammaR = new TH1F*[fnCuts];
604 fHistoConvGammaEta = new TH1F*[fnCuts];
607 if(fDoMesonAnalysis){
608 fHistoMotherInvMassPt = new TH2F*[fnCuts];
609 fHistoMotherMatchedInvMassPt = new TH2F*[fnCuts];
610 fHistoMotherBackInvMassPt = new TH2F*[fnCuts];
611 fHistoMotherInvMassEalpha = new TH2F*[fnCuts];
612 if (fDoMesonQA == 2){
613 fMesonDCAList = new TList*[fnCuts];
614 fTreeMesonsInvMassPtDcazMinDcazMaxFlag = new TTree*[fnCuts];
617 fHistoMotherPi0PtY = new TH2F*[fnCuts];
618 fHistoMotherEtaPtY = new TH2F*[fnCuts];
619 fHistoMotherPi0PtAlpha = new TH2F*[fnCuts];
620 fHistoMotherEtaPtAlpha = new TH2F*[fnCuts];
621 fHistoMotherPi0PtOpenAngle = new TH2F*[fnCuts];
622 fHistoMotherEtaPtOpenAngle = new TH2F*[fnCuts];
625 fHistoMotherInvMassECalib = new TH2F*[fnCuts];
626 fHistoMotherInvMassECalibalpha = new TH2F*[fnCuts];
629 fTagOutputList = new TList*[fnCuts];
631 fHistoConvGammaUntagged = new TH1F*[fnCuts];
632 fHistoConvGammaTagged = new TH1F*[fnCuts];
633 fHistoConvGammaPi0Tagged = new TH1F*[fnCuts];
634 fHistoConvGammaEtaTagged = new TH1F*[fnCuts];
635 fHistoPhotonPairAll = new TH2F*[fnCuts];
636 fHistoPhotonPairAllGam = new TH2F*[fnCuts];
638 fHistoClusGammaPt = new TH1F*[fnCuts];
640 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
641 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
642 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
643 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
644 TString cutstringMeson = "NoMesonCut";
645 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
647 fCutFolder[iCut] = new TList();
648 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s_%s",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
649 fCutFolder[iCut]->SetOwner(kTRUE);
650 fOutputContainer->Add(fCutFolder[iCut]);
651 fESDList[iCut] = new TList();
652 fESDList[iCut]->SetName(Form("%s_%s_%s_%s ESD histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
653 fESDList[iCut]->SetOwner(kTRUE);
654 fCutFolder[iCut]->Add(fESDList[iCut]);
656 fHistoNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
657 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
658 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
659 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
660 if (((AliConvEventCuts*)fEventCutArray->At(iCut))->IsSpecialTrigger() == 4 ){
661 TString TriggerNames = "Not Trigger: ";
662 TriggerNames = TriggerNames+ ( (AliConvEventCuts*)fEventCutArray->At(iCut))->GetSpecialTriggerName();
663 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
665 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
667 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
668 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
669 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
670 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
671 fHistoNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
672 fESDList[iCut]->Add(fHistoNEvents[iCut]);
674 if(fIsHeavyIon == 1) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
675 else if(fIsHeavyIon == 2) fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",400,0,400);
676 else fHistoNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
677 fESDList[iCut]->Add(fHistoNGoodESDTracks[iCut]);
678 if(fIsHeavyIon == 1) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
679 else if(fIsHeavyIon == 2) fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
680 else fHistoNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
681 fESDList[iCut]->Add(fHistoNGammaCandidates[iCut]);
682 if(fIsHeavyIon == 1) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",4000,0,4000,100,0,100);
683 else if(fIsHeavyIon == 2) fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",400,0,400,50,0,50);
684 else fHistoNGoodESDTracksVsNGammaCanditates[iCut] = new TH2F("GoodESDTracksVsGammaCandidates","GoodESDTracksVsGammaCandidates",200,0,200,50,0,50);
685 fESDList[iCut]->Add(fHistoNGoodESDTracksVsNGammaCanditates[iCut]);
688 if(fIsHeavyIon == 1) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
689 else if(fIsHeavyIon == 2) fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
690 else fHistoNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
691 fESDList[iCut]->Add(fHistoNV0Tracks[iCut]);
692 fProfileEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
693 fESDList[iCut]->Add(fProfileEtaShift[iCut]);
694 fHistoConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
695 fESDList[iCut]->Add(fHistoConvGammaPt[iCut]);
697 if (fDoPhotonQA == 2){
698 fPhotonDCAList[iCut] = new TList();
699 fPhotonDCAList[iCut]->SetName(Form("%s_%s_%s_%s Photon DCA tree",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
700 fPhotonDCAList[iCut]->SetOwner(kTRUE);
701 fCutFolder[iCut]->Add(fPhotonDCAList[iCut]);
703 fTreeConvGammaPtDcazCat[iCut] = new TTree("ESD_ConvGamma_Pt_Dcaz_R_Eta","ESD_ConvGamma_Pt_Dcaz_R_Eta_Cat");
704 fTreeConvGammaPtDcazCat[iCut]->Branch("Pt",&fPtGamma,"fPtGamma/F");
705 fTreeConvGammaPtDcazCat[iCut]->Branch("DcaZPhoton",&fDCAzPhoton,"fDCAzPhoton/F");
706 // fTreeConvGammaPtDcazCat[iCut]->Branch("R",&fRConvPhoton,"fRConvPhoton/F");
707 // fTreeConvGammaPtDcazCat[iCut]->Branch("Eta",&fEtaPhoton,"fEtaPhoton/F");
709 fTreeConvGammaPtDcazCat[iCut]->Branch("cat",&fCharCatPhoton,"fCharCatPhoton/b");
711 fTreeConvGammaPtDcazCat[iCut]->Branch("photonMCInfo",&fCharPhotonMCInfo,"fCharPhotonMCInfo/b");
713 fPhotonDCAList[iCut]->Add(fTreeConvGammaPtDcazCat[iCut]);
716 if (fDoPhotonQA > 0){
717 fHistoConvGammaR[iCut] = new TH1F("ESD_ConvGamma_R","ESD_ConvGamma_R",800,0,200);
718 fESDList[iCut]->Add(fHistoConvGammaR[iCut]);
719 fHistoConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",2000,-2,2);
720 fESDList[iCut]->Add(fHistoConvGammaEta[iCut]);
723 fTagOutputList[iCut] = new TList();
724 fTagOutputList[iCut]->SetName(Form("%s_%s_%s_%s Tagging Output",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
725 fTagOutputList[iCut]->SetOwner(1);
726 fCutFolder[iCut]->Add(fTagOutputList[iCut]);
728 const Int_t nptbins = 200;
729 const Double_t ptmin = 0.;
730 const Double_t ptmax = 20.;
732 const Int_t nmbins = 180;
733 const Double_t mmin = 0.;
734 const Double_t mmax = 0.9;
737 // this is maybe not necessary ...
739 fHistoConvGammaUntagged[iCut] = new TH1F("ConvGammaUntagged","",nptbins,ptmin,ptmax);
740 fHistoConvGammaUntagged[iCut]->SetXTitle("p_{T} (GeV/c)");
741 fTagOutputList[iCut]->Add(fHistoConvGammaUntagged[iCut]);
743 fHistoConvGammaTagged[iCut] = new TH1F("ConvGammaTagged","",nptbins,ptmin,ptmax);
744 fHistoConvGammaTagged[iCut]->SetXTitle("p_{T} (GeV/c)");
745 fTagOutputList[iCut]->Add(fHistoConvGammaTagged[iCut]);
747 fHistoConvGammaPi0Tagged[iCut] = new TH1F("ConvGammaPi0Tagged","",nptbins,ptmin,ptmax);
748 fHistoConvGammaPi0Tagged[iCut]->SetXTitle("p_{T} (GeV/c)");
749 fTagOutputList[iCut]->Add(fHistoConvGammaPi0Tagged[iCut]);
751 fHistoConvGammaEtaTagged[iCut] = new TH1F("ConvGammaEtaTagged","",nptbins,ptmin,ptmax);
752 fHistoConvGammaEtaTagged[iCut]->SetXTitle("p_{T} (GeV/c)");
753 fTagOutputList[iCut]->Add(fHistoConvGammaEtaTagged[iCut]);
756 fHistoPhotonPairAll[iCut] = new TH2F("PhotonPairAll","",nmbins,mmin,mmax,nptbins,ptmin,ptmax);
757 fHistoPhotonPairAll[iCut]->SetXTitle("M_{inv} (GeV/cc)");
758 fHistoPhotonPairAll[iCut]->SetYTitle("p_{T} (GeV/c)");
759 fTagOutputList[iCut]->Add(fHistoPhotonPairAll[iCut]);
761 fHistoPhotonPairAllGam[iCut] = new TH2F("PhotonPairAllGammaConvPt","",nmbins,mmin,mmax,nptbins,ptmin,ptmax);
762 fHistoPhotonPairAllGam[iCut]->SetXTitle("M_{inv} (GeV/cc)");
763 fHistoPhotonPairAllGam[iCut]->SetYTitle("#gamma^{conv} p_{T} (GeV/c)");
764 fTagOutputList[iCut]->Add(fHistoPhotonPairAllGam[iCut]);
766 fHistoClusGammaPt[iCut] = new TH1F("ClusGamma_Pt","ClusGamma_Pt",250,0,25);
767 fTagOutputList[iCut]->Add(fHistoClusGammaPt[iCut]);
770 if(fDoMesonAnalysis){
771 fHistoMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
772 fESDList[iCut]->Add(fHistoMotherInvMassPt[iCut]);
773 fHistoMotherMatchedInvMassPt[iCut] = new TH2F("ESD_MotherMatched_InvMass_Pt","ESD_MotherMatched_InvMass_Pt",800,0,0.8,250,0,25);
774 fESDList[iCut]->Add(fHistoMotherMatchedInvMassPt[iCut]);
775 fHistoMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
776 fESDList[iCut]->Add(fHistoMotherBackInvMassPt[iCut]);
777 fHistoMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
778 fESDList[iCut]->Add(fHistoMotherInvMassEalpha[iCut]);
779 if (fDoMesonQA == 2){
780 fMesonDCAList[iCut] = new TList();
781 fMesonDCAList[iCut]->SetName(Form("%s_%s_%s_%s Meson DCA tree",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
782 fMesonDCAList[iCut]->SetOwner(kTRUE);
783 fCutFolder[iCut]->Add(fMesonDCAList[iCut]);
785 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut] = new TTree("ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag","ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag");
786 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("InvMass",&fInvMass,"fInvMass/F");
787 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("Pt",&fPt,"fPt/F");
788 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMin",&fDCAzGammaMin,"fDCAzGammaMin/F");
789 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMax",&fDCAzGammaMax,"fDCAzGammaMax/F");
790 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("kind",&fCharFlag,"fCharFlag/b");
792 fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("mesonMCInfo",&fCharMesonMCInfo,"fCharMesonMCInfo/b");
794 fMesonDCAList[iCut]->Add(fTreeMesonsInvMassPtDcazMinDcazMaxFlag[iCut]);
798 fHistoMotherInvMassECalib[iCut] = new TH2F("ESD_Mother_InvMass_Pt_Calib","ESD_Mother_InvMass_Pt_Calib",800,0,0.8,250,0,25);
799 fESDList[iCut]->Add(fHistoMotherInvMassECalib[iCut]);
800 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);
801 fESDList[iCut]->Add(fHistoMotherInvMassECalibalpha[iCut]);
804 if (fDoMesonQA > 0 ){
805 fHistoMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
806 SetLogBinningXTH2(fHistoMotherPi0PtY[iCut]);
807 fESDList[iCut]->Add(fHistoMotherPi0PtY[iCut]);
808 fHistoMotherEtaPtY[iCut] = new TH2F("ESD_MotherEta_Pt_Y","ESD_MotherEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
809 SetLogBinningXTH2(fHistoMotherEtaPtY[iCut]);
810 fESDList[iCut]->Add(fHistoMotherEtaPtY[iCut]);
811 fHistoMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",150,0.03,15.,100,0,1);
812 SetLogBinningXTH2(fHistoMotherPi0PtAlpha[iCut]);
813 fESDList[iCut]->Add(fHistoMotherPi0PtAlpha[iCut]);
814 fHistoMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",150,0.03,15.,100,0,1);
815 SetLogBinningXTH2(fHistoMotherEtaPtAlpha[iCut]);
816 fESDList[iCut]->Add(fHistoMotherEtaPtAlpha[iCut]);
817 fHistoMotherPi0PtOpenAngle[iCut] = new TH2F("ESD_MotherPi0_Pt_OpenAngle","ESD_MotherPi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
818 SetLogBinningXTH2(fHistoMotherPi0PtOpenAngle[iCut]);
819 fESDList[iCut]->Add(fHistoMotherPi0PtOpenAngle[iCut]);
820 fHistoMotherEtaPtOpenAngle[iCut] = new TH2F("ESD_MotherEta_Pt_OpenAngle","ESD_MotherEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
821 SetLogBinningXTH2(fHistoMotherEtaPtOpenAngle[iCut]);
822 fESDList[iCut]->Add(fHistoMotherEtaPtOpenAngle[iCut]);
826 if(fDoMesonAnalysis){
827 InitBack(); // Init Background Handler
832 fMCList = new TList*[fnCuts];
834 fTrueList = new TList*[fnCuts];
835 // Selected Header List
836 fHeaderNameList = new TList*[fnCuts];
837 fHistoMCHeaders = new TH1I*[fnCuts];
838 fHistoMCAllGammaPt = new TH1F*[fnCuts];
839 fHistoMCAllGammaEMCALAccPt = new TH1F*[fnCuts];
840 fHistoMCDecayGammaPi0Pt = new TH1F*[fnCuts];
841 fHistoMCDecayGammaRhoPt = new TH1F*[fnCuts];
842 fHistoMCDecayGammaEtaPt = new TH1F*[fnCuts];
843 fHistoMCDecayGammaOmegaPt = new TH1F*[fnCuts];
844 fHistoMCDecayGammaEtapPt = new TH1F*[fnCuts];
845 fHistoMCDecayGammaPhiPt = new TH1F*[fnCuts];
846 fHistoMCDecayGammaSigmaPt = new TH1F*[fnCuts];
847 fHistoMCConvGammaPt = new TH1F*[fnCuts];
848 fHistoTrueConvGammaPt = new TH1F*[fnCuts];
849 fHistoTrueConvPi0GammaPt = new TH1F*[fnCuts];
851 fHistoCombinatorialPt = new TH2F*[fnCuts];
852 fHistoTruePrimaryConvGammaPt = new TH1F*[fnCuts];
853 fHistoTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
854 fHistoTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
855 fHistoTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
856 fHistoTrueSecondaryConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
858 fHistoTrueClusGammaPt = new TH1F*[fnCuts];
859 fHistoTruePrimaryClusGammaPt = new TH1F*[fnCuts];
860 fHistoTruePrimaryClusGammaESDPtMCPt = new TH2F*[fnCuts];
862 if (fDoPhotonQA > 0){
863 fHistoMCConvGammaR = new TH1F*[fnCuts];
864 fHistoMCConvGammaEta = new TH1F*[fnCuts];
865 fHistoTrueConvGammaEta = new TH1F*[fnCuts];
867 if (fDoClusterQA > 0){
868 fHistoTrueClusUnConvGammaPt = new TH1F*[fnCuts];
869 fHistoTrueClusUnConvGammaMCPt = new TH1F*[fnCuts];
870 fHistoTrueClusElectronPt = new TH1F*[fnCuts];
871 fHistoTrueClusConvGammaPt = new TH1F*[fnCuts];
872 fHistoTrueClusConvGammaMCPt = new TH1F*[fnCuts];
873 fHistoTrueClusConvGammaFullyPt = new TH1F*[fnCuts];
874 fHistoTrueClusMergedGammaPt = new TH1F*[fnCuts];
875 fHistoTrueClusMergedPartConvGammaPt = new TH1F*[fnCuts];
876 fHistoTrueClusDalitzPt = new TH1F*[fnCuts];
877 fHistoTrueClusDalitzMergedPt = new TH1F*[fnCuts];
878 fHistoTrueClusPhotonFromElecMotherPt= new TH1F*[fnCuts];
879 fHistoTrueClusShowerPt = new TH1F*[fnCuts];
880 fHistoTrueClusSubLeadingPt = new TH1F*[fnCuts];
881 fHistoTrueClusNParticles = new TH1I*[fnCuts];
882 fHistoTrueClusEMNonLeadingPt = new TH1F*[fnCuts];
883 fHistoTrueNLabelsInClus = new TH1F*[fnCuts];
886 if(fDoMesonAnalysis){
887 fHistoMCPi0Pt = new TH1F*[fnCuts];
888 fHistoMCPi0WOWeightPt = new TH1F*[fnCuts];
889 fHistoMCEtaPt = new TH1F*[fnCuts];
890 fHistoMCEtaWOWeightPt = new TH1F*[fnCuts];
891 fHistoMCPi0InAccPt = new TH1F*[fnCuts];
892 fHistoMCEtaInAccPt = new TH1F*[fnCuts];
894 fHistoTruePi0InvMassPt = new TH2F*[fnCuts];
895 fHistoTrueEtaInvMassPt = new TH2F*[fnCuts];
896 fHistoTruePrimaryPi0InvMassPt = new TH2F*[fnCuts];
897 fHistoTruePrimaryEtaInvMassPt = new TH2F*[fnCuts];
898 fHistoTruePrimaryPi0W0WeightingInvMassPt = new TH2F*[fnCuts];
899 fHistoTruePrimaryEtaW0WeightingInvMassPt = new TH2F*[fnCuts];
900 fProfileTruePrimaryPi0WeightsInvMassPt = new TProfile2D*[fnCuts];
901 fProfileTruePrimaryEtaWeightsInvMassPt = new TProfile2D*[fnCuts];
902 fHistoTrueSecondaryPi0InvMassPt = new TH2F*[fnCuts];
903 fHistoTrueSecondaryEtaInvMassPt = new TH2F*[fnCuts];
904 fHistoTrueSecondaryPi0FromK0sInvMassPt = new TH2F*[fnCuts];
905 fHistoTrueSecondaryPi0FromEtaInvMassPt = new TH2F*[fnCuts];
906 fHistoTrueSecondaryPi0FromLambdaInvMassPt = new TH2F*[fnCuts];
908 fHistoMCPi0PtY = new TH2F*[fnCuts];
909 fHistoMCEtaPtY = new TH2F*[fnCuts];
910 fHistoMCPi0PtAlpha = new TH2F*[fnCuts];
911 fHistoMCEtaPtAlpha = new TH2F*[fnCuts];
912 fHistoMCK0sPt = new TH1F*[fnCuts];
913 fHistoMCK0sWOWeightPt = new TH1F*[fnCuts];
914 fHistoMCK0sPtY = new TH2F*[fnCuts];
915 fHistoMCSecPi0PtvsSource = new TH2F*[fnCuts];
916 fHistoMCSecPi0Source = new TH1F*[fnCuts];
917 fHistoMCSecEtaPt = new TH1F*[fnCuts];
918 fHistoMCSecEtaSource = new TH1F*[fnCuts];
919 fHistoTruePi0CaloPhotonInvMassPt = new TH2F*[fnCuts];
920 fHistoTrueEtaCaloPhotonInvMassPt = new TH2F*[fnCuts];
921 fHistoTruePi0CaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
922 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt = new TH2F*[fnCuts];
923 fHistoTrueEtaCaloConvertedPhotonInvMassPt = new TH2F*[fnCuts];
924 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt = new TH2F*[fnCuts];
925 fHistoTruePi0CaloElectronInvMassPt = new TH2F*[fnCuts];
926 fHistoTrueEtaCaloElectronInvMassPt = new TH2F*[fnCuts];
927 fHistoTruePi0CaloMergedClusterInvMassPt = new TH2F*[fnCuts];
928 fHistoTrueEtaCaloMergedClusterInvMassPt = new TH2F*[fnCuts];
929 fHistoTruePi0CaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
930 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt = new TH2F*[fnCuts];
931 fHistoTrueMotherCaloEMNonLeadingInvMassPt = new TH2F*[fnCuts];
932 fHistoTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
933 fHistoTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
934 fHistoTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
935 fHistoTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
936 fHistoTrueLambdaWithPi0DaughterMCPt = new TH1F*[fnCuts];
937 fHistoTrueBckGGInvMassPt = new TH2F*[fnCuts];
938 fHistoTrueBckContInvMassPt = new TH2F*[fnCuts];
939 fHistoTruePi0PtY = new TH2F*[fnCuts];
940 fHistoTrueEtaPtY = new TH2F*[fnCuts];
941 fHistoTruePi0PtAlpha = new TH2F*[fnCuts];
942 fHistoTrueEtaPtAlpha = new TH2F*[fnCuts];
943 fHistoTruePi0PtOpenAngle = new TH2F*[fnCuts];
944 fHistoTrueEtaPtOpenAngle = new TH2F*[fnCuts];
950 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
951 TString cutstringEvent = ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber();
952 TString cutstringPhoton = ((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutNumber();
953 TString cutstringCalo = ((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutNumber();
954 TString cutstringMeson = "NoMesonCut";
955 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
957 fMCList[iCut] = new TList();
958 fMCList[iCut]->SetName(Form("%s_%s_%s_%s MC histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
959 fMCList[iCut]->SetOwner(kTRUE);
960 fCutFolder[iCut]->Add(fMCList[iCut]);
961 fHistoMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
962 fMCList[iCut]->Add(fHistoMCHeaders[iCut]);
963 fHistoMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
964 fMCList[iCut]->Add(fHistoMCAllGammaPt[iCut]);
965 fHistoMCAllGammaEMCALAccPt[iCut] = new TH1F("MC_AllGammaEMCALAcc_Pt","MC_AllGammaEMCALAcc_Pt",250,0,25);
966 fMCList[iCut]->Add(fHistoMCAllGammaEMCALAccPt[iCut]);
967 fHistoMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
968 fMCList[iCut]->Add(fHistoMCDecayGammaPi0Pt[iCut]);
969 fHistoMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
970 fMCList[iCut]->Add(fHistoMCDecayGammaRhoPt[iCut]);
971 fHistoMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
972 fMCList[iCut]->Add(fHistoMCDecayGammaEtaPt[iCut]);
973 fHistoMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
974 fMCList[iCut]->Add(fHistoMCDecayGammaOmegaPt[iCut]);
975 fHistoMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
976 fMCList[iCut]->Add(fHistoMCDecayGammaEtapPt[iCut]);
977 fHistoMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
978 fMCList[iCut]->Add(fHistoMCDecayGammaPhiPt[iCut]);
979 fHistoMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
980 fMCList[iCut]->Add(fHistoMCDecayGammaSigmaPt[iCut]);
981 fHistoMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
982 fMCList[iCut]->Add(fHistoMCConvGammaPt[iCut]);
984 if (fDoPhotonQA > 0){
985 fHistoMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
986 fMCList[iCut]->Add(fHistoMCConvGammaR[iCut]);
987 fHistoMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",2000,-2,2);
988 fMCList[iCut]->Add(fHistoMCConvGammaEta[iCut]);
991 if(fDoMesonAnalysis){
992 fHistoMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
993 fHistoMCPi0Pt[iCut]->Sumw2();
994 fMCList[iCut]->Add(fHistoMCPi0Pt[iCut]);
995 fHistoMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
996 fHistoMCPi0WOWeightPt[iCut]->Sumw2();
997 fMCList[iCut]->Add(fHistoMCPi0WOWeightPt[iCut]);
999 fHistoMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
1000 fHistoMCEtaPt[iCut]->Sumw2();
1001 fMCList[iCut]->Add(fHistoMCEtaPt[iCut]);
1002 fHistoMCEtaWOWeightPt[iCut] = new TH1F("MC_Eta_WOWeights_Pt","MC_Eta_WOWeights_Pt",250,0,25);
1003 fHistoMCEtaWOWeightPt[iCut]->Sumw2();
1004 fMCList[iCut]->Add(fHistoMCEtaWOWeightPt[iCut]);
1005 fHistoMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
1006 fHistoMCPi0InAccPt[iCut]->Sumw2();
1007 fMCList[iCut]->Add(fHistoMCPi0InAccPt[iCut]);
1008 fHistoMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
1009 fHistoMCEtaInAccPt[iCut]->Sumw2();
1010 fMCList[iCut]->Add(fHistoMCEtaInAccPt[iCut]);
1011 if (fDoMesonQA > 0){
1012 fHistoMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1013 fHistoMCPi0PtY[iCut]->Sumw2();
1014 SetLogBinningXTH2(fHistoMCPi0PtY[iCut]);
1015 fMCList[iCut]->Add(fHistoMCPi0PtY[iCut]);
1016 fHistoMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1017 fHistoMCEtaPtY[iCut]->Sumw2();
1018 SetLogBinningXTH2(fHistoMCEtaPtY[iCut]);
1019 fMCList[iCut]->Add(fHistoMCEtaPtY[iCut]);
1020 fHistoMCPi0PtAlpha[iCut] = new TH2F("MC_Pi0_Pt_Alpha","MC_Pi0_Pt_Alpha",150,0.03,15.,100,0,1);
1021 SetLogBinningXTH2(fHistoMCPi0PtAlpha[iCut]);
1022 fMCList[iCut]->Add(fHistoMCPi0PtAlpha[iCut]);
1023 fHistoMCEtaPtAlpha[iCut] = new TH2F("MC_Eta_Pt_Alpha","MC_Eta_Pt_Alpha",150,0.03,15.,100,0,1);
1024 SetLogBinningXTH2(fHistoMCEtaPtAlpha[iCut]);
1025 fMCList[iCut]->Add(fHistoMCEtaPtAlpha[iCut]);
1027 fHistoMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",150,0,15);
1028 fHistoMCK0sPt[iCut]->Sumw2();
1029 fMCList[iCut]->Add(fHistoMCK0sPt[iCut]);
1030 fHistoMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",150,0,15);
1031 fHistoMCK0sWOWeightPt[iCut]->Sumw2();
1032 fMCList[iCut]->Add(fHistoMCK0sWOWeightPt[iCut]);
1033 fHistoMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1034 fHistoMCK0sPtY[iCut]->Sumw2();
1035 SetLogBinningXTH2(fHistoMCK0sPtY[iCut]);
1036 fMCList[iCut]->Add(fHistoMCK0sPtY[iCut]);
1038 fHistoMCSecPi0Source[iCut] = new TH1F("MC_SecPi0_Source","MC_SecPi0_Source",5000,0.,5000);
1039 fMCList[iCut]->Add(fHistoMCSecPi0Source[iCut]);
1040 fHistoMCSecEtaSource[iCut] = new TH1F("MC_SecEta_Source","MC_SecEta_Source",5000,0,5000);
1041 fMCList[iCut]->Add(fHistoMCSecEtaSource[iCut]);
1042 fHistoMCSecPi0PtvsSource[iCut] = new TH2F("MC_SecPi0_Pt_Source","MC_SecPi0_Pt_Source",250,0.0,25.,16,-0.5,15.5);
1043 fHistoMCSecPi0PtvsSource[iCut]->Sumw2();
1044 fMCList[iCut]->Add(fHistoMCSecPi0PtvsSource[iCut]);
1045 fHistoMCSecEtaPt[iCut] = new TH1F("MC_SecEta_Pt","MC_SecEta_Pt",250,0,25);
1046 fHistoMCSecEtaPt[iCut]->Sumw2();
1047 fMCList[iCut]->Add(fHistoMCSecEtaPt[iCut]);
1051 fTrueList[iCut] = new TList();
1052 fTrueList[iCut]->SetName(Form("%s_%s_%s_%s True histograms",cutstringEvent.Data(),cutstringPhoton.Data(),cutstringCalo.Data(),cutstringMeson.Data()));
1053 fTrueList[iCut]->SetOwner(kTRUE);
1054 fCutFolder[iCut]->Add(fTrueList[iCut]);
1056 fHistoTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
1057 fTrueList[iCut]->Add(fHistoTrueConvGammaPt[iCut]);
1059 fHistoTrueConvPi0GammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
1060 fTrueList[iCut]->Add(fHistoTrueConvPi0GammaPt[iCut]);
1062 fHistoCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
1063 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
1064 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
1065 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
1066 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
1067 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
1068 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
1069 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
1070 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
1071 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
1072 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
1073 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
1074 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
1075 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
1076 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
1077 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
1078 fHistoCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
1079 fTrueList[iCut]->Add(fHistoCombinatorialPt[iCut]);
1080 fHistoTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
1081 fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaPt[iCut]);
1082 fHistoTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
1083 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaPt[iCut]);
1085 fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
1086 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
1087 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
1088 fTrueList[iCut]->Add(fHistoTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
1090 fHistoTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
1091 fTrueList[iCut]->Add(fHistoTruePrimaryConvGammaESDPtMCPt[iCut]);
1093 fHistoTrueClusGammaPt[iCut] = new TH1F("TrueClusGamma_Pt","ESD_TrueClusGamma_Pt",250,0,25);
1094 fTagOutputList[iCut]->Add(fHistoTrueClusGammaPt[iCut]);
1095 fHistoTruePrimaryClusGammaPt[iCut] = new TH1F("TruePrimaryClusGamma_Pt","ESD_TruePrimaryClusGamma_Pt",250,0,25);
1096 fTagOutputList[iCut]->Add(fHistoTruePrimaryClusGammaPt[iCut]);
1097 fHistoTruePrimaryClusGammaESDPtMCPt[iCut] = new TH2F("TruePrimaryClusGamma_Pt_MCPt","ESD_TruePrimaryClusGamma_MCPt",250,0,25,250,0,25);
1098 fTagOutputList[iCut]->Add(fHistoTruePrimaryClusGammaESDPtMCPt[iCut]);
1100 if (fDoPhotonQA > 0){
1101 fHistoTrueConvGammaEta[iCut] = new TH1F("ESD_TrueConvGamma_Eta","ESD_TrueConvGamma_Eta",2000,-2,2);
1102 fTrueList[iCut]->Add(fHistoTrueConvGammaEta[iCut]);
1104 if (fDoClusterQA > 0){
1105 fHistoTrueClusUnConvGammaPt[iCut] = new TH1F("TrueClusUnConvGamma_Pt","TrueClusUnConvGamma_Pt",250,0,25);
1106 fTagOutputList[iCut]->Add(fHistoTrueClusUnConvGammaPt[iCut]);
1107 fHistoTrueClusUnConvGammaMCPt[iCut] = new TH1F("TrueClusUnConvGamma_MCPt","TrueClusUnConvGamma_MCPt",250,0,25);
1108 fTagOutputList[iCut]->Add(fHistoTrueClusUnConvGammaMCPt[iCut]);
1109 fHistoTrueClusElectronPt[iCut] = new TH1F("TrueClusElectron_Pt","TrueElectronGamma_Pt",250,0,25);
1110 fTagOutputList[iCut]->Add(fHistoTrueClusElectronPt[iCut]);
1111 fHistoTrueClusConvGammaPt[iCut] = new TH1F("TrueClusConvGamma_Pt","TrueClusConvGamma_Pt",250,0,25);
1112 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaPt[iCut]);
1113 fHistoTrueClusConvGammaMCPt[iCut] = new TH1F("TrueClusConvGamma_MCPt","TrueClusConvGamma_MCPt",250,0,25);
1114 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaMCPt[iCut]);
1115 fHistoTrueClusConvGammaFullyPt[iCut] = new TH1F("TrueClusConvGammaFullyContained_Pt","TrueClusConvGammaFullyContained_Pt",250,0,25);
1116 fTagOutputList[iCut]->Add(fHistoTrueClusConvGammaFullyPt[iCut]);
1117 fHistoTrueClusMergedGammaPt[iCut] = new TH1F("TrueClusMergedGamma_Pt","TrueClusMergedGamma_Pt",250,0,25);
1118 fTagOutputList[iCut]->Add(fHistoTrueClusMergedGammaPt[iCut]);
1119 fHistoTrueClusMergedPartConvGammaPt[iCut] = new TH1F("TrueClusMergedPartConvGamma_Pt","TrueClusMergedPartConvGamma_Pt",250,0,25);
1120 fTagOutputList[iCut]->Add(fHistoTrueClusMergedPartConvGammaPt[iCut]);
1121 fHistoTrueClusDalitzPt[iCut] = new TH1F("TrueClusDalitz_Pt","TrueClusDalitz_Pt",250,0,25);
1122 fTagOutputList[iCut]->Add(fHistoTrueClusDalitzPt[iCut]);
1123 fHistoTrueClusDalitzMergedPt[iCut] = new TH1F("TrueClusDalitzMerged_Pt","TrueClusDalitzMerged_Pt",250,0,25);
1124 fTagOutputList[iCut]->Add(fHistoTrueClusDalitzMergedPt[iCut]);
1125 fHistoTrueClusPhotonFromElecMotherPt[iCut] = new TH1F("TrueClusPhotonFromElecMother_Pt","TrueClusPhotonFromElecMother_Pt",250,0,25);
1126 fTagOutputList[iCut]->Add(fHistoTrueClusPhotonFromElecMotherPt[iCut]);
1127 fHistoTrueClusShowerPt[iCut] = new TH1F("TrueClusShower_Pt","TrueClusShower_Pt",250,0,25);
1128 fTagOutputList[iCut]->Add(fHistoTrueClusShowerPt[iCut]);
1129 fHistoTrueClusSubLeadingPt[iCut] = new TH1F("TrueClusSubleading_Pt","TrueClusSubleading_Pt",250,0,25);
1130 fTagOutputList[iCut]->Add(fHistoTrueClusSubLeadingPt[iCut]);
1131 fHistoTrueClusNParticles[iCut] = new TH1I("TrueClusNParticles","TrueClusNParticles",20,0,20);
1132 fTagOutputList[iCut]->Add(fHistoTrueClusNParticles[iCut]);
1133 fHistoTrueClusEMNonLeadingPt[iCut] = new TH1F("TrueClusEMNonLeading_Pt","TrueClusEMNonLeading_Pt",250,0,25);
1134 fTagOutputList[iCut]->Add(fHistoTrueClusEMNonLeadingPt[iCut]);
1135 fHistoTrueNLabelsInClus[iCut] = new TH1F("TrueNLabelsInClus","TrueNLabelsInClus",100,-0.5,99.5);
1136 fTagOutputList[iCut]->Add(fHistoTrueNLabelsInClus[iCut]);
1139 if(fDoMesonAnalysis){
1140 fHistoTruePi0InvMassPt[iCut] = new TH2F("ESD_TruePi0_InvMass_Pt","ESD_TruePi0_InvMass_Pt",800,0,0.8,250,0,25);
1141 fTrueList[iCut]->Add(fHistoTruePi0InvMassPt[iCut]);
1142 fHistoTrueEtaInvMassPt[iCut] = new TH2F("ESD_TrueEta_InvMass_Pt","ESD_TrueEta_InvMass_Pt",800,0,0.8,250,0,25);
1143 fTrueList[iCut]->Add(fHistoTrueEtaInvMassPt[iCut]);
1145 fHistoTruePrimaryPi0InvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0_InvMass_Pt", "ESD_TruePrimaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1146 fHistoTruePrimaryPi0InvMassPt[iCut]->Sumw2();
1147 fTrueList[iCut]->Add(fHistoTruePrimaryPi0InvMassPt[iCut]);
1148 fHistoTruePrimaryEtaInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEta_InvMass_Pt", "ESD_TruePrimaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
1149 fHistoTruePrimaryEtaInvMassPt[iCut]->Sumw2();
1150 fTrueList[iCut]->Add(fHistoTruePrimaryEtaInvMassPt[iCut]);
1152 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryPi0W0Weights_InvMass_Pt", "ESD_TruePrimaryPi0W0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1153 fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]->Sumw2();
1154 fTrueList[iCut]->Add(fHistoTruePrimaryPi0W0WeightingInvMassPt[iCut]);
1155 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryEtaW0Weights_InvMass_Pt", "ESD_TruePrimaryEtaW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1156 fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]->Sumw2();
1157 fTrueList[iCut]->Add(fHistoTruePrimaryEtaW0WeightingInvMassPt[iCut]);
1159 fProfileTruePrimaryPi0WeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryPi0Weights_InvMass_Pt", "ESD_TruePrimaryPi0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
1160 fProfileTruePrimaryPi0WeightsInvMassPt[iCut]->Sumw2();
1161 fTrueList[iCut]->Add(fProfileTruePrimaryPi0WeightsInvMassPt[iCut]);
1162 fProfileTruePrimaryEtaWeightsInvMassPt[iCut] = new TProfile2D("ESD_TruePrimaryEtaWeights_InvMass_Pt", "ESD_TruePrimaryEtaWeights_InvMass_Pt", 800,0,0.8,250,0,25);
1163 fProfileTruePrimaryEtaWeightsInvMassPt[iCut]->Sumw2();
1164 fTrueList[iCut]->Add(fProfileTruePrimaryEtaWeightsInvMassPt[iCut]);
1166 fHistoTrueSecondaryPi0InvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0_InvMass_Pt", "ESD_TrueSecondaryPi0_InvMass_Pt", 800,0,0.8,250,0,25);
1167 fHistoTrueSecondaryPi0InvMassPt[iCut]->Sumw2();
1168 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0InvMassPt[iCut]);
1169 fHistoTrueSecondaryEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryEta_InvMass_Pt", "ESD_TrueSecondaryEta_InvMass_Pt", 800,0,0.8,250,0,25);
1170 fHistoTrueSecondaryEtaInvMassPt[iCut]->Sumw2();
1171 fTrueList[iCut]->Add(fHistoTrueSecondaryEtaInvMassPt[iCut]);
1173 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromK0s_InvMass_Pt","ESD_TrueSecondaryPi0FromK0s_InvMass_Pt",800,0,0.8,250,0,25);
1174 fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]->Sumw2();
1175 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromK0sInvMassPt[iCut]);
1176 fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromEta_InvMass_Pt","ESD_TrueSecondaryPi0FromEta_InvMass_Pt",800,0,0.8,250,0,25);
1177 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromEtaInvMassPt[iCut]);
1178 fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryPi0FromLambda_InvMass_Pt","ESD_TrueSecondaryPi0FromLambda_InvMass_Pt",800,0,0.8,250,0,25);
1179 fTrueList[iCut]->Add(fHistoTrueSecondaryPi0FromLambdaInvMassPt[iCut]);
1180 if (fDoMesonQA > 0){
1181 fHistoTruePi0CaloPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloPhoton_InvMass_Pt","ESD_TruePi0CaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1182 fTrueList[iCut]->Add(fHistoTruePi0CaloPhotonInvMassPt[iCut]);
1183 fHistoTrueEtaCaloPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloPhoton_InvMass_Pt","ESD_TrueEtaCaloPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1184 fTrueList[iCut]->Add(fHistoTrueEtaCaloPhotonInvMassPt[iCut]);
1185 fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhoton_InvMass_Pt","ESD_TruePi0CaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1186 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonInvMassPt[iCut]);
1187 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt","ESD_TruePi0CaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1188 fTrueList[iCut]->Add(fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[iCut]);
1189 fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt","ESD_TrueEtaCaloConvertedPhoton_InvMass_Pt",800,0,0.8,250,0,25);
1190 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonInvMassPt[iCut]);
1191 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt","ESD_TrueEtaCaloConvertedPhotonMatched_InvMass_Pt",800,0,0.8,250,0,25);
1192 fTrueList[iCut]->Add(fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[iCut]);
1194 fHistoTruePi0CaloElectronInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloElectron_InvMass_Pt","ESD_TruePi0CaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1195 fTrueList[iCut]->Add(fHistoTruePi0CaloElectronInvMassPt[iCut]);
1196 fHistoTrueEtaCaloElectronInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloElectron_InvMass_Pt","ESD_TrueEtaCaloElectron_InvMass_Pt",800,0,0.8,250,0,25);
1197 fTrueList[iCut]->Add(fHistoTrueEtaCaloElectronInvMassPt[iCut]);
1199 fHistoTruePi0CaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedCluster_InvMass_Pt","ESD_TruePi0CaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1200 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterInvMassPt[iCut]);
1201 fHistoTrueEtaCaloMergedClusterInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedCluster_InvMass_Pt","ESD_TrueEtaCaloMergedCluster_InvMass_Pt",800,0,0.8,250,0,25);
1202 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterInvMassPt[iCut]);
1204 fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut] = new TH2F("ESD_TrueMotherCaloEMNonLeading_InvMass_Pt","ESD_TrueMotherCaloEMNonLeading_InvMass_Pt",800,0,0.8,250,0,25);
1205 fTrueList[iCut]->Add(fHistoTrueMotherCaloEMNonLeadingInvMassPt[iCut]);
1206 fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt","ESD_TruePi0CaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1207 fTrueList[iCut]->Add(fHistoTruePi0CaloMergedClusterPartConvInvMassPt[iCut]);
1208 fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut] = new TH2F("ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt","ESD_TrueEtaCaloMergedClusterPartConv_InvMass_Pt",800,0,0.8,250,0,25);
1209 fTrueList[iCut]->Add(fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[iCut]);
1211 fHistoTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1212 fHistoTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
1213 SetLogBinningXTH2(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1214 fTrueList[iCut]->Add(fHistoTruePrimaryPi0MCPtResolPt[iCut]);
1215 fHistoTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
1216 fHistoTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
1217 SetLogBinningXTH2(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1218 fTrueList[iCut]->Add(fHistoTruePrimaryEtaMCPtResolPt[iCut]);
1219 fHistoTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
1220 fTrueList[iCut]->Add(fHistoTrueBckGGInvMassPt[iCut]);
1221 fHistoTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
1222 fTrueList[iCut]->Add(fHistoTrueBckContInvMassPt[iCut]);
1223 fHistoTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
1224 fTrueList[iCut]->Add(fHistoTrueK0sWithPi0DaughterMCPt[iCut]);
1225 fHistoTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
1226 fTrueList[iCut]->Add(fHistoTrueEtaWithPi0DaughterMCPt[iCut]);
1227 fHistoTrueLambdaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueLambdaWithPi0Daughter_MCPt","ESD_TrueLambdaWithPi0Daughter_MCPt",250,0,25);
1228 fTrueList[iCut]->Add(fHistoTrueLambdaWithPi0DaughterMCPt[iCut]);
1230 fHistoTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1231 SetLogBinningXTH2(fHistoTruePi0PtY[iCut]);
1232 fTrueList[iCut]->Add(fHistoTruePi0PtY[iCut]);
1233 fHistoTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
1234 SetLogBinningXTH2(fHistoTrueEtaPtY[iCut]);
1235 fTrueList[iCut]->Add(fHistoTrueEtaPtY[iCut]);
1236 fHistoTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",150,0.03,15.,100,0,1);
1237 SetLogBinningXTH2(fHistoTruePi0PtAlpha[iCut]);
1238 fTrueList[iCut]->Add(fHistoTruePi0PtAlpha[iCut]);
1239 fHistoTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",150,0.03,15.,100,0,1);
1240 SetLogBinningXTH2(fHistoTrueEtaPtAlpha[iCut]);
1241 fTrueList[iCut]->Add(fHistoTrueEtaPtAlpha[iCut]);
1243 fHistoTruePi0PtOpenAngle[iCut] = new TH2F("ESD_TruePi0_Pt_OpenAngle","ESD_TruePi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1244 SetLogBinningXTH2(fHistoTruePi0PtOpenAngle[iCut]);
1245 fTrueList[iCut]->Add(fHistoTruePi0PtOpenAngle[iCut]);
1246 fHistoTrueEtaPtOpenAngle[iCut] = new TH2F("ESD_TrueEta_Pt_OpenAngle","ESD_TrueEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
1247 SetLogBinningXTH2(fHistoTrueEtaPtOpenAngle[iCut]);
1248 fTrueList[iCut]->Add(fHistoTrueEtaPtOpenAngle[iCut]);
1254 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1255 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1258 if((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())
1259 if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1260 fOutputContainer->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1262 if((AliConvEventCuts*)fV0Reader->GetEventCuts())
1263 if(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms())
1264 fOutputContainer->Add(((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetCutHistograms());
1267 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1268 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))) continue;
1269 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms()){
1270 fCutFolder[iCut]->Add(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutHistograms());
1272 if(!((AliConversionPhotonCuts*)fCutArray->At(iCut))) continue;
1273 if(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms()){
1274 fCutFolder[iCut]->Add(((AliConversionPhotonCuts*)fCutArray->At(iCut))->GetCutHistograms());
1276 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))) continue;
1277 if(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms()){
1278 fCutFolder[iCut]->Add(((AliCaloPhotonCuts*)fClusterCutArray->At(iCut))->GetCutHistograms());
1280 if(fDoMesonAnalysis){
1281 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
1282 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
1283 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
1287 PostData(1, fOutputContainer);
1289 //_____________________________________________________________________________
1290 Bool_t AliAnalysisTaskGammaConvCalo::Notify()
1292 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1293 if(!((AliConvEventCuts*)fEventCutArray->At(iCut))->GetDoEtaShift()){
1294 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1295 continue; // No Eta Shift requested, continue
1297 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1298 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
1299 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1300 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1304 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
1305 (((AliConvEventCuts*)fEventCutArray->At(iCut))->GetCutNumber()).Data(),((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift());
1306 fProfileEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetEtaShift()));
1307 ((AliConvEventCuts*)fEventCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1313 //_____________________________________________________________________________
1314 void AliAnalysisTaskGammaConvCalo::UserExec(Option_t *)
1317 // Called for each event
1319 Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
1320 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1321 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1322 fHistoNEvents[iCut]->Fill(eventQuality);
1327 if(fIsMC) fMCEvent = MCEvent();
1328 if(fMCEvent == NULL) fIsMC = kFALSE;
1330 fInputEvent = InputEvent();
1332 if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
1333 fMCStack = fMCEvent->Stack();
1334 if(fMCStack == NULL) fIsMC = kFALSE;
1337 if(fInputEvent->IsA()==AliAODEvent::Class()){
1338 fInputEvent->InitMagneticField();
1341 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
1343 // ------------------- BeginEvent ----------------------------
1345 AliEventplane *EventPlane = fInputEvent->GetEventplane();
1346 if(fIsHeavyIon ==1)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
1347 else fEventPlaneAngle=0.0;
1349 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1350 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
1351 fV0Reader->RelabelAODs(kTRUE);
1355 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1358 Int_t eventNotAccepted = ((AliConvEventCuts*)fEventCutArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
1360 if(eventNotAccepted){
1361 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1362 fHistoNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1366 if(eventQuality != 0){// Event Not Accepted
1367 //cout << "event rejected due to: " <<eventQuality << endl;
1368 fHistoNEvents[iCut]->Fill(eventQuality);
1372 fHistoNEvents[iCut]->Fill(eventQuality); // Should be 0 here
1373 fHistoNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
1374 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->IsHeavyIon() == 2) fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
1375 else fHistoNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1378 // Process MC Particle
1379 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection() != 0){
1380 if(fInputEvent->IsA()==AliESDEvent::Class()){
1381 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1382 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1385 else if(fInputEvent->IsA()==AliAODEvent::Class()){
1386 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetNotRejectedParticles(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetSignalRejection(),
1387 ((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader(),
1391 if(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader()){
1392 for(Int_t i = 0;i<(((AliConvEventCuts*)fEventCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
1393 TString nameBin= fHistoMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
1394 if (nameBin.CompareTo("")== 0){
1395 TString nameHeader = ((TObjString*)((TList*)((AliConvEventCuts*)fEventCutArray->At(iCut))
1396 ->GetAcceptedHeader())->At(i))->GetString();
1397 fHistoMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
1404 if(fInputEvent->IsA()==AliESDEvent::Class())
1405 ProcessMCParticles();
1406 if(fInputEvent->IsA()==AliAODEvent::Class())
1407 ProcessAODMCParticles();
1410 // 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)
1411 ProcessClusters(); // process calo clusters
1412 ProcessPhotonCandidates(); // Process this cuts gammas
1414 fHistoNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
1415 fHistoNGoodESDTracksVsNGammaCanditates[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks(),fGammaCandidates->GetEntries());
1416 if(fDoMesonAnalysis){ // Meson Analysis
1417 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1418 fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
1419 fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
1420 fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
1421 fUnsmearedE = new Double_t[fGammaCandidates->GetEntries()];
1423 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1424 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
1425 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
1426 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
1427 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
1428 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
1432 PhotonTagging(); // tag PCM photons with calorimeter
1434 CalculatePi0Candidates(); // Combine Gammas from conversion and from calo
1436 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1437 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1438 CalculateBackground(); // Combinatorial Background
1439 UpdateEventByEventData(); // Store Event for mixed Events
1442 CalculateBackgroundRP(); // Combinatorial Background
1443 fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
1444 fBGClusHandlerRP[iCut]->AddEvent(fClusterCandidates,fInputEvent); // Store Event for mixed Events
1447 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1448 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1449 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1450 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1451 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1452 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
1454 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1455 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1456 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1457 delete[] fUnsmearedE; fUnsmearedE = 0x0;
1461 fGammaCandidates->Clear(); // delete this cuts good gammas
1462 fClusterCandidates->Clear(); // delete cluster candidates
1465 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1466 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
1467 fV0Reader->RelabelAODs(kFALSE);
1470 PostData(1, fOutputContainer);
1473 //________________________________________________________________________
1474 void AliAnalysisTaskGammaConvCalo::ProcessClusters()
1478 nclus = fInputEvent->GetNumberOfCaloClusters();
1480 // cout << nclus << endl;
1482 if(nclus == 0) return;
1485 Double_t vertex[3] = {0};
1486 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1488 // Loop over EMCal clusters
1489 for(Long_t i = 0; i < nclus; i++){
1491 AliVCluster* clus = NULL;
1492 clus = fInputEvent->GetCaloCluster(i);
1493 if (!clus) continue;
1494 if(!((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->ClusterIsSelected(clus,fInputEvent,fIsMC)) continue;
1495 // TLorentzvector with cluster
1496 TLorentzVector clusterVector;
1497 clus->GetMomentum(clusterVector,vertex);
1499 TLorentzVector* tmpvec = new TLorentzVector();
1500 tmpvec->SetPxPyPzE(clusterVector.Px(),clusterVector.Py(),clusterVector.Pz(),clusterVector.E());
1502 // convert to AODConversionPhoton
1503 AliAODConversionPhoton *PhotonCandidate=new AliAODConversionPhoton(tmpvec);
1504 if(!PhotonCandidate) continue;
1506 // Flag Photon as CaloPhoton
1507 PhotonCandidate->SetIsCaloPhoton();
1508 PhotonCandidate->SetCaloClusterRef(i);
1511 Int_t* mclabelsCluster = clus->GetLabels();
1512 PhotonCandidate->SetNCaloPhotonMCLabels(clus->GetNLabels());
1513 // cout << clus->GetNLabels() << endl;
1514 if (clus->GetNLabels()>0){
1515 for (Int_t k =0; k< (Int_t)clus->GetNLabels(); k++){
1516 if (k< 20)PhotonCandidate->SetCaloPhotonMCLabel(k,mclabelsCluster[k]);
1517 // Int_t pdgCode = fMCStack->Particle(mclabelsCluster[k])->GetPdgCode();
1518 // cout << "label " << k << "\t" << mclabelsCluster[k] << " pdg code: " << pdgCode << endl;
1523 fIsFromMBHeader = kTRUE;
1524 // test whether largest contribution to cluster orginates in added signals
1525 if (fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetCaloPhotonMCLabel(0), fMCStack, fInputEvent) == 0) fIsFromMBHeader = kFALSE;
1527 fHistoClusGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1528 fClusterCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1531 if(fInputEvent->IsA()==AliESDEvent::Class()){
1532 ProcessTrueClusterCandidates(PhotonCandidate);
1534 ProcessTrueClusterCandidatesAOD(PhotonCandidate);
1543 //________________________________________________________________________
1544 void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1547 TParticle *Photon = NULL;
1548 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1549 fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1551 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0)Photon = fMCStack->Particle(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1555 // cout << "no photon" << endl;
1559 TruePhotonCandidate->SetCaloPhotonMCFlags(fMCStack);
1562 if(fIsFromMBHeader){
1563 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1564 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1565 if (fDoClusterQA > 0){
1566 if (TruePhotonCandidate->IsLargestComponentPhoton()){
1567 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1568 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1570 if (TruePhotonCandidate->IsLargestComponentElectron())
1571 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1572 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()){
1573 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1574 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(((TParticle*)fMCStack->Particle(Photon->GetMother(0)))->Pt());
1576 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1577 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1578 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1579 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1580 if (TruePhotonCandidate->IsMergedPartConv())
1581 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1582 if (TruePhotonCandidate->IsDalitz())
1583 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1584 if (TruePhotonCandidate->IsDalitzMerged())
1585 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1586 if (TruePhotonCandidate->IsPhotonWithElecMother())
1587 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1588 if (TruePhotonCandidate->IsShower())
1589 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1590 if (TruePhotonCandidate->IsSubLeadingEM())
1591 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1592 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1596 if(Photon->GetMother(0) <= fMCStack->GetNprimary()){
1597 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1598 if(fIsFromMBHeader){
1599 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1600 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1607 //________________________________________________________________________
1608 void AliAnalysisTaskGammaConvCalo::ProcessTrueClusterCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1610 AliAODMCParticle *Photon = NULL;
1611 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1612 if (AODMCTrackArray){
1613 if (!TruePhotonCandidate->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set task will abort");
1614 if (TruePhotonCandidate->GetNCaloPhotonMCLabels()>0) Photon = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetCaloPhotonMCLabel(0));
1617 AliInfo("AODMCTrackArray could not be loaded");
1622 // cout << "no photon" << endl;
1625 TruePhotonCandidate->SetCaloPhotonMCFlagsAOD(fInputEvent);
1626 fHistoTrueNLabelsInClus[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMCLabels());
1628 if(fIsFromMBHeader){
1629 if (TruePhotonCandidate->IsLargestComponentPhoton() || TruePhotonCandidate->IsLargestComponentElectron() )fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1630 else fHistoTrueClusEMNonLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1631 if (fDoClusterQA > 0){
1632 if (TruePhotonCandidate->IsLargestComponentPhoton()) {
1633 fHistoTrueClusUnConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1634 fHistoTrueClusUnConvGammaMCPt[fiCut]->Fill(Photon->Pt());
1636 if (TruePhotonCandidate->IsLargestComponentElectron())
1637 fHistoTrueClusElectronPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1638 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion()) {
1639 fHistoTrueClusConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1640 AliAODMCParticle *Mother = (AliAODMCParticle*) AODMCTrackArray->At(Photon->GetMother());
1641 fHistoTrueClusConvGammaMCPt[fiCut]->Fill(Mother->Pt());
1643 if (TruePhotonCandidate->IsLargestComponentElectron() && TruePhotonCandidate->IsConversion() && TruePhotonCandidate->IsConversionFullyContained())
1644 fHistoTrueClusConvGammaFullyPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1645 if (TruePhotonCandidate->IsMerged() || TruePhotonCandidate->IsMergedPartConv() || TruePhotonCandidate->IsDalitzMerged())
1646 fHistoTrueClusMergedGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1647 if (TruePhotonCandidate->IsMergedPartConv())
1648 fHistoTrueClusMergedPartConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1649 if (TruePhotonCandidate->IsDalitz())
1650 fHistoTrueClusDalitzPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1651 if (TruePhotonCandidate->IsDalitzMerged())
1652 fHistoTrueClusDalitzMergedPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1653 if (TruePhotonCandidate->IsPhotonWithElecMother())
1654 fHistoTrueClusPhotonFromElecMotherPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1655 if (TruePhotonCandidate->IsShower())
1656 fHistoTrueClusShowerPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1657 if (TruePhotonCandidate->IsSubLeadingEM())
1658 fHistoTrueClusSubLeadingPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1659 fHistoTrueClusNParticles[fiCut]->Fill(TruePhotonCandidate->GetNCaloPhotonMotherMCLabels());
1664 if(fIsFromMBHeader){
1665 fHistoTrueClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1666 // if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1669 if(Photon->IsPrimary()){
1670 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1671 if(fIsFromMBHeader){
1672 fHistoTruePrimaryClusGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1673 fHistoTruePrimaryClusGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1678 //________________________________________________________________________
1679 void AliAnalysisTaskGammaConvCalo::ProcessPhotonCandidates()
1682 TList *GammaCandidatesStepOne = new TList();
1683 TList *GammaCandidatesStepTwo = new TList();
1684 // Loop over Photon Candidates allocated by ReaderV1
1685 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1686 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1687 if(!PhotonCandidate) continue;
1688 fIsFromMBHeader = kTRUE;
1689 if(fIsMC && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1690 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1691 if(isPosFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1692 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1693 if(isNegFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1694 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1697 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
1698 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(PhotonCandidate->GetPhotonPhi(),fEventPlaneAngle)) continue;
1699 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1700 !((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1701 fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1703 if(fIsFromMBHeader){
1704 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1705 if (fDoPhotonQA > 0){
1706 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1707 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1711 if(fInputEvent->IsA()==AliESDEvent::Class())
1712 ProcessTruePhotonCandidates(PhotonCandidate);
1713 if(fInputEvent->IsA()==AliAODEvent::Class())
1714 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1716 if (fIsFromMBHeader && fDoPhotonQA == 2){
1717 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1718 fPtGamma = PhotonCandidate->Pt();
1719 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1720 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1721 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1722 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1723 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1724 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1725 fPtGamma = PhotonCandidate->Pt();
1726 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1727 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1728 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1729 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1730 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1733 } else if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1734 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1736 GammaCandidatesStepOne->Add(PhotonCandidate);
1737 } else if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1738 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1739 GammaCandidatesStepTwo->Add(PhotonCandidate);
1742 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
1743 for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1744 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1745 if(!PhotonCandidate) continue;
1746 fIsFromMBHeader = kTRUE;
1747 if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1748 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1749 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1750 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1752 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1753 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1754 fGammaCandidates->Add(PhotonCandidate);
1755 if(fIsFromMBHeader){
1756 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1757 if (fDoPhotonQA > 0){
1758 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1759 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1764 if(fInputEvent->IsA()==AliESDEvent::Class())
1765 ProcessTruePhotonCandidates(PhotonCandidate);
1766 if(fInputEvent->IsA()==AliAODEvent::Class())
1767 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1768 } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1770 if (fIsFromMBHeader && fDoPhotonQA == 2){
1771 if (fIsHeavyIon ==1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1772 fPtGamma = PhotonCandidate->Pt();
1773 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1774 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1775 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1776 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1777 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1778 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1779 fPtGamma = PhotonCandidate->Pt();
1780 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1781 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1782 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1783 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1784 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1789 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1790 for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1791 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1792 if(!PhotonCandidate) continue;
1793 fIsFromMBHeader = kTRUE;
1794 if(fMCStack && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
1795 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1796 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1797 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1799 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
1800 fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1801 if(fIsFromMBHeader){
1802 fHistoConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1803 if (fDoPhotonQA > 0){
1804 fHistoConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1805 fHistoConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1809 if(fInputEvent->IsA()==AliESDEvent::Class())
1810 ProcessTruePhotonCandidates(PhotonCandidate);
1811 if(fInputEvent->IsA()==AliAODEvent::Class())
1812 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1814 if (fIsFromMBHeader){
1815 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1816 fPtGamma = PhotonCandidate->Pt();
1817 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1818 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1819 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1820 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1821 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1822 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1823 fPtGamma = PhotonCandidate->Pt();
1824 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1825 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1826 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1827 fCharCatPhoton = PhotonCandidate->GetPhotonQuality();
1828 fTreeConvGammaPtDcazCat[fiCut]->Fill();
1834 delete GammaCandidatesStepOne;
1835 GammaCandidatesStepOne = 0x0;
1836 delete GammaCandidatesStepTwo;
1837 GammaCandidatesStepTwo = 0x0;
1840 //________________________________________________________________________
1841 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1844 Double_t magField = fInputEvent->GetMagneticField();
1845 if( magField < 0.0 ){
1852 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1853 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1854 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
1855 fCharPhotonMCInfo = 0;
1857 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1858 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1860 if(posDaughter->GetMother() != negDaughter->GetMother()){
1861 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1862 fCharPhotonMCInfo = 1;
1865 else if(posDaughter->GetMother() == -1){
1866 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1867 fCharPhotonMCInfo = 1;
1871 if(pdgCode[0]!=11 || pdgCode[1]!=11){
1872 fCharPhotonMCInfo = 1;
1873 return; //One Particle is not a electron
1876 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
1877 fCharPhotonMCInfo = 1;
1878 return; // Same Charge
1881 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
1882 if(Photon->GetPdgCode() != 22){
1883 fCharPhotonMCInfo = 1;
1884 return; // Mother is no Photon
1887 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
1888 fCharPhotonMCInfo = 1;
1889 return;// check if the daughters come from a conversion
1891 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1896 if(fIsFromMBHeader){
1897 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1898 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1900 if(Photon->IsPrimary()){
1901 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1902 if(fIsFromMBHeader){
1903 fCharPhotonMCInfo = 6;
1904 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1905 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1907 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1909 if(fIsFromMBHeader){
1910 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1911 fCharPhotonMCInfo = 2;
1912 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1913 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1914 fCharPhotonMCInfo = 5;
1915 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1917 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1918 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1919 fCharPhotonMCInfo = 4;
1920 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1922 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1923 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1924 fCharPhotonMCInfo = 3;
1930 //________________________________________________________________________
1931 void AliAnalysisTaskGammaConvCalo::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1934 Double_t magField = fInputEvent->GetMagneticField();
1935 if( magField < 0.0 ){
1942 // Process True Photons
1943 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1944 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
1945 fCharPhotonMCInfo = 0;
1947 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1948 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1949 fCharPhotonMCInfo = 1;
1950 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
1951 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1954 else if(posDaughter->GetMother(0) == -1){
1955 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1959 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1961 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1963 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
1965 if(Photon->GetPdgCode() != 22){
1966 return; // Mother is no Photon
1969 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1972 if(fIsFromMBHeader){
1973 fHistoTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1974 if (fDoPhotonQA > 0) fHistoTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1976 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
1977 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1978 if(fIsFromMBHeader){
1979 fCharPhotonMCInfo = 6;
1980 fHistoTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1981 fHistoTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1984 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1987 if(fIsFromMBHeader){
1988 fCharPhotonMCInfo = 2;
1989 fHistoTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1990 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1991 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
1992 fHistoTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1993 fCharPhotonMCInfo = 5;
1995 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1996 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
1997 fHistoTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1998 fCharPhotonMCInfo = 4;
2000 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
2001 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
2002 fCharPhotonMCInfo = 3;
2009 Int_t imother = Photon->GetMother(0);
2011 AliMCParticle* McMother = static_cast<AliMCParticle*>(fMCEvent->GetTrack(imother));
2012 //cout << fMCEvent->GetRunNumber() << " " << imother << " " << fMCEvent->GetNumberOfTracks() << endl;
2013 if(McMother->PdgCode() == 111) fHistoTrueConvPi0GammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
2017 //________________________________________________________________________
2018 void AliAnalysisTaskGammaConvCalo::ProcessAODMCParticles()
2021 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2023 // Loop over all primary MC particle
2024 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
2026 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
2027 if (!particle) continue;
2028 if (!particle->IsPrimary()) continue;
2030 Int_t isMCFromMBHeader = -1;
2031 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2032 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2033 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2036 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2037 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
2038 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2039 if (abs(particle->Eta()) < 0.66 ){
2040 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2042 if(particle->GetMother() >-1){ // Meson Decay Gamma
2043 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
2045 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2048 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2051 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2054 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2057 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2060 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2063 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2068 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
2070 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
2071 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
2072 if(!tmpDaughter) continue;
2073 if(abs(tmpDaughter->GetPdgCode()) == 11){
2074 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
2077 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2078 if (fDoPhotonQA > 0){
2079 fHistoMCConvGammaR[fiCut]->Fill(rConv);
2080 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2083 // Converted MC Gamma
2084 if(fDoMesonAnalysis){
2085 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2086 Double_t mesonY = 10.;
2087 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2088 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2090 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2092 Float_t weightedK0s= 1;
2093 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2094 if (particle->Pt()>0.005){
2095 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2096 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2099 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2100 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2101 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2103 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2104 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2105 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
2106 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
2107 Float_t weighted= 1;
2108 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2109 if (particle->Pt()>0.005){
2110 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
2111 // if(particle->GetPdgCode() == 221){
2112 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2116 Double_t mesonY = 10.;
2117 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
2118 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2120 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2123 Double_t alpha = -1;
2124 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2125 alpha = TMath::Abs((daughter0->E() - daughter1->E()))/(daughter0->E() + daughter1->E());
2129 if(particle->GetPdgCode() == 111){
2130 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2131 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2132 if (fDoMesonQA > 0){
2133 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2134 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2136 } else if(particle->GetPdgCode() == 221){
2137 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2138 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2139 if (fDoMesonQA > 0){
2140 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2141 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2145 // Check the acceptance for both gammas
2146 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
2147 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) &&
2148 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2149 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2151 if(particle->GetPdgCode() == 111){
2152 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2153 } else if(particle->GetPdgCode() == 221){
2154 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2162 //________________________________________________________________________
2163 void AliAnalysisTaskGammaConvCalo::ProcessMCParticles()
2165 // Loop over all primary MC particle
2166 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2167 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2168 if (!particle) continue;
2170 Int_t isMCFromMBHeader = -1;
2171 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2172 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2173 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2176 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
2177 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
2178 fHistoMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2179 if (abs(particle->Eta()) < 0.66 ){
2180 if (particle->Phi() > 1.39626 && particle->Phi() < 3.125) fHistoMCAllGammaEMCALAccPt[fiCut]->Fill(particle->Pt());
2183 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
2184 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
2186 fHistoMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
2189 fHistoMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
2192 fHistoMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
2195 fHistoMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
2198 fHistoMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
2201 fHistoMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
2204 fHistoMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
2209 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
2210 fHistoMCConvGammaPt[fiCut]->Fill(particle->Pt());
2211 if (fDoPhotonQA > 0){
2212 fHistoMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
2213 fHistoMCConvGammaEta[fiCut]->Fill(particle->Eta());
2215 } // Converted MC Gamma
2216 if(fDoMesonAnalysis){
2217 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
2218 Double_t mesonY = 10.;
2219 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2220 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2222 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2224 Float_t weightedK0s= 1;
2225 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2226 if (particle->Pt()>0.005){
2227 weightedK0s= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2228 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2231 if (fMCStack->IsPhysicalPrimary(i)){
2232 fHistoMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
2233 fHistoMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
2234 fHistoMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
2237 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2238 ->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2239 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
2240 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
2242 Float_t weighted= 1;
2243 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2244 if (particle->Pt()>0.005){
2245 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2246 // if(particle->GetPdgCode() == 221){
2247 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2251 Double_t mesonY = 10.;
2252 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
2253 mesonY=10.-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2255 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift();
2258 Double_t alpha = -1;
2259 if (particle->GetPdgCode() == 111 || particle->GetPdgCode() == 221){
2260 alpha = TMath::Abs((daughter0->Energy() - daughter1->Energy()))/(daughter0->Energy() + daughter1->Energy());
2263 if(particle->GetPdgCode() == 111){
2264 fHistoMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2265 fHistoMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
2266 if (fDoMesonQA > 0){
2267 fHistoMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2268 fHistoMCPi0PtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2270 } else if(particle->GetPdgCode() == 221){
2271 fHistoMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
2272 fHistoMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
2273 if (fDoMesonQA > 0){
2274 fHistoMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
2275 fHistoMCEtaPtAlpha[fiCut]->Fill(particle->Pt(),alpha); // All MC Pi0
2279 // Check the acceptance for both gammas
2280 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
2281 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) &&
2282 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
2283 ((AliConversionPhotonCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
2285 if(particle->GetPdgCode() == 111){
2286 fHistoMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
2287 } else if(particle->GetPdgCode() == 221){
2288 fHistoMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
2296 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
2297 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2298 if (!particle) continue;
2300 Int_t isMCFromMBHeader = -1;
2301 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 0){
2302 isMCFromMBHeader = ((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
2303 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
2306 if(fDoMesonAnalysis){
2307 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2308 Float_t weighted= 1;
2309 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2310 if (particle->Pt()>0.005){
2311 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
2312 // if(particle->GetPdgCode() == 221){
2313 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2318 if(particle->GetPdgCode() == 111){
2319 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2320 Int_t source = GetSourceClassification(111,pdgCode);
2321 fHistoMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
2322 fHistoMCSecPi0Source[fiCut]->Fill(pdgCode);
2323 } else if(particle->GetPdgCode() == 221){
2324 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
2325 fHistoMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
2326 fHistoMCSecEtaSource[fiCut]->Fill(pdgCode);
2334 //________________________________________________________________________
2335 void AliAnalysisTaskGammaConvCalo::PhotonTagging(){
2337 // Conversion Gammas
2338 if(fGammaCandidates->GetEntries()>0){
2340 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
2342 // get conversion photon
2343 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2344 if (gamma0==NULL) continue;
2346 TLorentzVector photonVector;
2347 photonVector.SetPxPyPzE(gamma0->GetPx(),gamma0->GetPy(),gamma0->GetPz(),gamma0->GetPhotonP());
2352 // loop over clusters
2353 for(Int_t secondGammaIndex = 0; secondGammaIndex<fClusterCandidates->GetEntries(); ++secondGammaIndex) {
2355 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2356 if (gamma1==NULL) continue;
2358 TLorentzVector clusterVector;
2359 clusterVector.SetPxPyPzE(gamma1->GetPx(),gamma1->GetPy(),gamma1->GetPz(),gamma1->GetPhotonP());
2362 TLorentzVector pairVector = photonVector+clusterVector;
2365 if((pairVector.M() > 0.11 && pairVector.M() < 0.15)){
2369 if((pairVector.M() > 0.50 && pairVector.M() < 0.6)){
2372 }// end loop over clusters
2374 if(btagpi0 && btageta)
2375 fHistoConvGammaTagged[fiCut]->Fill(photonVector.Pt());
2376 else if(btagpi0 && !btageta)
2377 fHistoConvGammaPi0Tagged[fiCut]->Fill(photonVector.Pt());
2378 else if(btageta && !btagpi0)
2379 fHistoConvGammaEtaTagged[fiCut]->Fill(photonVector.Pt());
2381 fHistoConvGammaUntagged[fiCut]->Fill(photonVector.Pt());
2383 }// end loop over gammas
2388 //________________________________________________________________________
2389 void AliAnalysisTaskGammaConvCalo::CalculatePi0Candidates(){
2391 // Conversion Gammas
2392 if(fGammaCandidates->GetEntries()>0){
2395 Double_t vertex[3] = {0};
2396 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
2398 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2399 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2400 if (gamma0==NULL) continue;
2402 for(Int_t secondGammaIndex=0;secondGammaIndex<fClusterCandidates->GetEntries();secondGammaIndex++){
2403 Bool_t matched = kFALSE;
2404 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fClusterCandidates->At(secondGammaIndex));
2405 if (gamma1==NULL) continue;
2407 if (gamma1->GetIsCaloPhoton()){
2408 AliVCluster* cluster = fInputEvent->GetCaloCluster(gamma1->GetCaloClusterRef());
2409 matched = ((AliCaloPhotonCuts*)fClusterCutArray->At(fiCut))->MatchConvPhotonToCluster(gamma0,cluster, fInputEvent );
2412 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
2413 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
2417 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2419 fHistoMotherMatchedInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2421 fHistoMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2423 // fill new histograms
2425 fHistoPhotonPairAll[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
2426 fHistoPhotonPairAllGam[fiCut]->Fill(pi0cand->M(),gamma0->Pt());
2428 if(pi0cand->GetAlpha()<0.1)
2429 fHistoMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
2431 if (fDoMesonQA > 0){
2432 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
2433 fHistoMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2434 fHistoMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2435 fHistoMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2437 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
2438 fHistoMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2439 fHistoMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
2440 fHistoMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
2443 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
2447 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
2448 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2449 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2450 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2452 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2455 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2456 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2457 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2459 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2462 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
2463 fSparseMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
2468 if(fInputEvent->IsA()==AliESDEvent::Class())
2469 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1, matched);
2470 if(fInputEvent->IsA()==AliAODEvent::Class())
2471 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1, matched);
2474 if (fDoMesonQA == 2){
2475 fInvMass = pi0cand->M();
2476 fPt = pi0cand->Pt();
2477 if (abs(gamma0->GetDCAzToPrimVtx()) < abs(gamma1->GetDCAzToPrimVtx())){
2478 fDCAzGammaMin = gamma0->GetDCAzToPrimVtx();
2479 fDCAzGammaMax = gamma1->GetDCAzToPrimVtx();
2481 fDCAzGammaMin = gamma1->GetDCAzToPrimVtx();
2482 fDCAzGammaMax = gamma0->GetDCAzToPrimVtx();
2484 fCharFlag = pi0cand->GetMesonQuality();
2485 // cout << "gamma 0: " << gamma0->GetV0Index()<< "\t" << gamma0->GetPx() << "\t" << gamma0->GetPy() << "\t" << gamma0->GetPz() << "\t" << endl;
2486 // cout << "gamma 1: " << gamma1->GetV0Index()<< "\t"<< gamma1->GetPx() << "\t" << gamma1->GetPy() << "\t" << gamma1->GetPz() << "\t" << endl;
2487 // cout << "pi0: "<<fInvMass << "\t" << fPt <<"\t" << fDCAzGammaMin << "\t" << fDCAzGammaMax << "\t" << (Int_t)fCharFlag << "\t" << (Int_t)fCharMesonMCInfo <<endl;
2488 if (fIsHeavyIon == 1 && fPt > 0.399 && fPt < 20. ) {
2489 if (fInvMass > 0.08 && fInvMass < 0.2) fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2490 if ((fInvMass > 0.45 && fInvMass < 0.6) && (fPt > 0.999 && fPt < 20.) )fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2491 } else if (fPt > 0.299 && fPt < 20. ) {
2492 if ( (fInvMass > 0.08 && fInvMass < 0.2) || (fInvMass > 0.45 && fInvMass < 0.6)) fTreeMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
2495 if (fDoMesonQA == 1){
2496 fHistoMotherInvMassECalib[fiCut]->Fill(pi0cand->M(),gamma1->E());
2497 if(pi0cand->GetAlpha()<0.1)
2498 fHistoMotherInvMassECalibalpha[fiCut]->Fill(pi0cand->M(),gamma1->E());
2508 //______________________________________________________________________
2509 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2511 // Process True Mesons
2512 AliStack *MCStack = fMCEvent->Stack();
2513 fCharMesonMCInfo = 0;
2514 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
2515 Bool_t isTruePi0 = kFALSE;
2516 Bool_t isTrueEta = kFALSE;
2517 Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
2518 Int_t gamma0MotherLabel = -1;
2519 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2520 // Daughters Gamma 0
2521 TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
2522 TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
2523 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
2524 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2525 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2526 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
2527 gamma0MotherLabel=gammaMC0->GetFirstMother();
2532 if (!TrueGammaCandidate1->GetIsCaloPhoton()) AliFatal("CaloPhotonFlag has not been set. Aborting");
2534 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2535 Int_t gamma1MotherLabel = -1;
2538 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2539 // Daughters Gamma 1
2540 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
2541 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2542 // get mother of interest (pi0 or eta)
2543 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2544 gamma1MotherLabel=gammaMC1->GetMother(0);
2545 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2546 if (TrueGammaCandidate1->IsConversion()) gamma1MotherLabel=MCStack->Particle(gammaMC1->GetMother(0))->GetMother(0);
2547 else gamma1MotherLabel=gammaMC1->GetMother(0);
2550 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2554 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2555 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
2558 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
2563 if(isTruePi0 || isTrueEta){// True Pion or Eta
2565 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2566 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2568 if (fDoMesonQA > 0){
2569 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2570 if(isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2571 if(isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2573 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched){
2574 if(isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2575 if(isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2577 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion() ){
2578 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2579 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2580 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0){
2581 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2583 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta){
2584 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2587 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2588 if (isTruePi0 )fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2589 if (isTrueEta )fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2591 if (TrueGammaCandidate1->IsMergedPartConv() && !matched){
2592 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2593 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2597 if (fDoMesonQA > 0){
2599 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2600 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2601 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2602 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2604 } else if (isTrueEta){
2605 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2606 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2607 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2608 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2613 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
2614 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma0MotherLabel))->GetMother(0);
2615 Float_t weightedSec= 1;
2616 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
2617 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
2618 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2620 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2621 if (isTrueEta) fHistoTrueSecondaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2622 fCharMesonMCInfo = 2;
2623 if (secMotherLabel >-1){
2624 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310 && isTruePi0 ){
2625 fCharMesonMCInfo = 4;
2626 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2627 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2629 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221 && isTruePi0){
2630 fCharMesonMCInfo = 3;
2631 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2632 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2634 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==3122 && isTruePi0){
2635 fCharMesonMCInfo = 7;
2636 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2637 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(MCStack->Particle(secMotherLabel)->Pt());
2640 } else { // Only primary pi0 for efficiency calculation
2641 fCharMesonMCInfo = 6;
2642 Float_t weighted= 1;
2643 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
2644 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
2645 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
2646 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2650 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2651 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2652 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2653 } else if (isTrueEta) {
2654 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2655 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2656 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2659 if (fDoMesonQA > 0){
2660 if(isTruePi0){ // Only primary pi0 for resolution
2661 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2663 if (isTrueEta){ // Only primary eta for resolution
2664 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
2669 } else if(!isTruePi0 && !isTrueEta){ // Background
2670 if (fDoMesonQA > 0){
2671 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2672 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2673 fCharMesonMCInfo = 1;
2674 } else { // No photon or without mother
2675 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2681 //______________________________________________________________________
2682 void AliAnalysisTaskGammaConvCalo::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1, Bool_t matched)
2685 // Process True Mesons
2686 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2687 Bool_t isTruePi0 = kFALSE;
2688 Bool_t isTrueEta = kFALSE;
2690 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
2691 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
2693 fCharMesonMCInfo = 0;
2694 Int_t gamma0MCLabel = -1;
2695 Int_t gamma0MotherLabel = -1;
2696 if(!positiveMC||!negativeMC)
2699 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
2700 gamma0MCLabel = positiveMC->GetMother();
2703 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2704 // Daughters Gamma 0
2705 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2706 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2707 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
2708 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
2709 gamma0MotherLabel=gammaMC0->GetMother();
2715 Int_t gamma1MCLabel = TrueGammaCandidate1->GetCaloPhotonMCLabel(0); // get most probable MC label
2716 Int_t gamma1MotherLabel = -1;
2719 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2720 // Daughters Gamma 1
2721 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2722 if (TrueGammaCandidate1->IsLargestComponentPhoton() || TrueGammaCandidate1->IsLargestComponentElectron()){ // largest component is electro magnetic
2723 // get mother of interest (pi0 or eta)
2724 if (TrueGammaCandidate1->IsLargestComponentPhoton()){ // for photons its the direct mother
2725 gamma1MotherLabel=gammaMC1->GetMother();
2726 } else if (TrueGammaCandidate1->IsLargestComponentElectron()){ // for electrons its either the direct mother or for conversions the grandmother
2727 if (TrueGammaCandidate1->IsConversion()){
2728 AliAODMCParticle * gammaGrandMotherMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gammaMC1->GetMother()));
2729 gamma1MotherLabel=gammaGrandMotherMC1->GetMother();
2730 } else gamma1MotherLabel=gammaMC1->GetMother();
2733 if (fDoMesonQA > 0) fHistoTrueMotherCaloEMNonLeadingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2737 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2738 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2741 if(((AliAODMCParticle*)AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2746 if(isTruePi0 || isTrueEta){// True Pion or Eta
2748 if (isTruePi0)fHistoTruePi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2749 if (isTrueEta)fHistoTrueEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2751 if (fDoMesonQA > 0){
2752 if (TrueGammaCandidate1->IsLargestComponentPhoton() && !matched){
2753 if (isTruePi0) fHistoTruePi0CaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2754 if (isTrueEta) fHistoTrueEtaCaloPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2756 if (TrueGammaCandidate1->IsLargestComponentElectron() && !matched) {
2757 if (isTruePi0) fHistoTruePi0CaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2758 if (isTrueEta) fHistoTrueEtaCaloElectronInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2760 if (TrueGammaCandidate1->IsLargestComponentElectron() && TrueGammaCandidate1->IsConversion()){
2761 if (isTruePi0 && !matched)fHistoTruePi0CaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2762 if (isTrueEta && !matched)fHistoTrueEtaCaloConvertedPhotonInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2763 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTruePi0)
2764 fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2765 if ((TrueGammaCandidate0->GetMCLabelPositive() == gamma1MCLabel || TrueGammaCandidate0->GetMCLabelNegative() == gamma1MCLabel) && isTrueEta)
2766 fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2768 if ((TrueGammaCandidate1->IsMerged() || TrueGammaCandidate1->IsMergedPartConv() || TrueGammaCandidate1->IsDalitzMerged()) && !matched ){
2769 if (isTruePi0) fHistoTruePi0CaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2770 if (isTrueEta) fHistoTrueEtaCaloMergedClusterInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2772 if (TrueGammaCandidate1->IsMergedPartConv() && !matched) {
2773 if (isTruePi0) fHistoTruePi0CaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2774 if (isTrueEta) fHistoTrueEtaCaloMergedClusterPartConvInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2779 if (fDoMesonQA > 0){
2781 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2782 fHistoTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2783 fHistoTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2784 fHistoTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2786 } else if (isTrueEta){
2787 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2788 fHistoTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift());
2789 fHistoTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2790 fHistoTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2794 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2795 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2796 Float_t weightedSec= 1;
2797 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2798 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
2799 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2801 if (isTruePi0) fHistoTrueSecondaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2802 if (isTrueEta) fHistoTrueSecondaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2804 fCharMesonMCInfo = 2;
2805 if (secMotherLabel >-1){
2806 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310 && isTruePi0){
2807 fCharMesonMCInfo = 4;
2808 fHistoTrueSecondaryPi0FromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2809 if (fDoMesonQA > 0)fHistoTrueK0sWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2811 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221 && isTruePi0){
2812 fCharMesonMCInfo = 3;
2813 fHistoTrueSecondaryPi0FromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2814 if (fDoMesonQA > 0)fHistoTrueEtaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2816 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122 && isTruePi0){
2817 fCharMesonMCInfo = 7;
2818 fHistoTrueSecondaryPi0FromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2819 if (fDoMesonQA > 0)fHistoTrueLambdaWithPi0DaughterMCPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2822 } else{ // Only primary pi0 for efficiency calculation
2823 Float_t weighted= 1;
2824 fCharMesonMCInfo = 6;
2825 if(((AliConvEventCuts*)fEventCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2826 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2827 weighted= ((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2828 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2832 fHistoTruePrimaryPi0InvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2833 fHistoTruePrimaryPi0W0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2834 fProfileTruePrimaryPi0WeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2835 } else if (isTrueEta){
2836 fHistoTruePrimaryEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2837 fHistoTruePrimaryEtaW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2838 fProfileTruePrimaryEtaWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2840 if (fDoMesonQA > 0){
2841 if(isTruePi0){ // Only primary pi0 for resolution
2842 fHistoTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2843 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2846 if (isTrueEta){ // Only primary eta for resolution
2847 fHistoTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2848 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2853 } else if(!isTruePi0 && !isTrueEta) { // Background
2854 if (fDoMesonQA > 0){
2855 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2856 fHistoTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2857 fCharMesonMCInfo = 1;
2858 } else { // No photon or without mother
2859 fHistoTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2865 //________________________________________________________________________
2866 void AliAnalysisTaskGammaConvCalo::CalculateBackground(){
2868 Int_t zbin= fBGClusHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2871 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2872 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2874 mbin = fBGClusHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2877 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2878 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2879 for(Int_t nEventsInBG=0;nEventsInBG<fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2880 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2881 if(fMoveParticleAccordingToVertex == kTRUE){
2882 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2885 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2886 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2887 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2888 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2889 if(fMoveParticleAccordingToVertex == kTRUE){
2890 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2892 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2893 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2896 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2897 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2898 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2899 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2900 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2901 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2902 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2904 delete backgroundCandidate;
2905 backgroundCandidate = 0x0;
2910 for(Int_t nEventsInBG=0;nEventsInBG <fBGClusHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2911 AliGammaConversionAODVector *previousEventV0s = fBGClusHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2912 if(previousEventV0s){
2913 if(fMoveParticleAccordingToVertex == kTRUE){
2914 bgEventVertex = fBGClusHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2916 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2917 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2918 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2920 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2922 if(fMoveParticleAccordingToVertex == kTRUE){
2923 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2925 if(((AliConversionPhotonCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2926 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2929 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
2930 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2931 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift()))){
2932 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2933 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2934 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2936 delete backgroundCandidate;
2937 backgroundCandidate = 0x0;
2945 //________________________________________________________________________
2946 void AliAnalysisTaskGammaConvCalo::CalculateBackgroundRP(){
2948 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2950 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2951 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2953 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2958 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2959 // Correct for the number of rotations
2960 // BG is for rotation the same, except for factor NRotations
2961 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
2963 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2965 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2966 if (gamma0==NULL) continue;
2967 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
2968 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
2969 if (gamma1 == NULL) continue;
2970 if(!((AliConversionPhotonCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
2971 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2973 RotateParticle(gamma1);
2974 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2975 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2976 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2977 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
2978 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2979 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2980 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2987 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
2989 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
2991 if(previousEventGammas){
2992 // test weighted background
2993 Double_t weight=1.0;
2994 // Correct for the number of eventmixing:
2995 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
2996 // real combinations (since you cannot combine a photon with its own)
2997 // but BG leads to N_{a}*N_{b} combinations
2998 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
3000 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
3001 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
3002 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
3004 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
3006 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
3007 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
3008 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
3009 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConvEventCuts*)fEventCutArray->At(fiCut))->GetEtaShift())){
3010 fHistoMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
3011 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
3012 fSparseMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
3020 //________________________________________________________________________
3021 void AliAnalysisTaskGammaConvCalo::RotateParticle(AliAODConversionPhoton *gamma){
3022 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
3023 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
3024 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
3025 gamma->RotateZ(rotationValue);
3028 //________________________________________________________________________
3029 void AliAnalysisTaskGammaConvCalo::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
3031 previousEventEP=previousEventEP+TMath::Pi();
3032 thisEventEP=thisEventEP+TMath::Pi();
3033 Double_t rotationValue= thisEventEP-previousEventEP;
3034 gamma->RotateZ(rotationValue);
3037 //________________________________________________________________________
3038 void AliAnalysisTaskGammaConvCalo::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
3039 //see header file for documentation
3041 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
3042 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
3043 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
3045 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
3046 particle->SetConversionPoint(movedPlace);
3048 //________________________________________________________________________
3049 void AliAnalysisTaskGammaConvCalo::UpdateEventByEventData(){
3050 //see header file for documentation
3051 if(fGammaCandidates->GetEntries() >0 ){
3052 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
3053 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3054 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
3055 } else { // means we use #V0s for multiplicity
3056 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3057 fBGClusHandler[fiCut]->AddEvent(fClusterCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
3063 //________________________________________________________________________
3064 void AliAnalysisTaskGammaConvCalo::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
3066 // 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
3067 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
3068 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
3069 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
3070 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
3071 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
3072 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
3073 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
3074 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
3075 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
3076 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
3077 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
3078 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
3079 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
3080 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
3081 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
3082 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
3083 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
3084 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
3085 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
3086 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
3087 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
3088 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
3089 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
3090 {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
3091 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
3092 else {if(fIsFromMBHeader)fHistoCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
3094 //________________________________________________________________________
3095 void AliAnalysisTaskGammaConvCalo::RelabelAODPhotonCandidates(Bool_t mode){
3097 // Relabeling For AOD Event
3099 // MCLabel -> AODMCLabel
3102 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
3103 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
3104 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
3105 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
3108 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
3109 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
3110 if(!PhotonCandidate) continue;
3111 if(!mode){// Back to ESD Labels
3112 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
3113 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
3114 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
3115 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
3118 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
3119 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
3120 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
3121 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
3123 Bool_t AODLabelPos = kFALSE;
3124 Bool_t AODLabelNeg = kFALSE;
3126 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
3127 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
3129 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
3130 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
3131 PhotonCandidate->SetLabelPositive(i);
3132 AODLabelPos = kTRUE;
3136 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
3137 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
3138 PhotonCandidate->SetLabelNegative(i);
3139 AODLabelNeg = kTRUE;
3142 if(AODLabelNeg && AODLabelPos){
3146 if(!AODLabelPos || !AODLabelNeg){
3147 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
3153 delete[] fMCStackPos;
3154 delete[] fMCStackNeg;
3155 delete[] fESDArrayPos;
3156 delete[] fESDArrayNeg;
3160 void AliAnalysisTaskGammaConvCalo::SetLogBinningXTH2(TH2* histoRebin){
3161 TAxis *axisafter = histoRebin->GetXaxis();
3162 Int_t bins = axisafter->GetNbins();
3163 Double_t from = axisafter->GetXmin();
3164 Double_t to = axisafter->GetXmax();
3165 Double_t *newbins = new Double_t[bins+1];
3167 Double_t factor = TMath::Power(to/from, 1./bins);
3168 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
3169 axisafter->Set(bins, newbins);
3173 //________________________________________________________________________
3174 void AliAnalysisTaskGammaConvCalo::Terminate(const Option_t *)
3177 //fOutputContainer->Print(); // Will crash on GRID
3180 //________________________________________________________________________
3181 Int_t AliAnalysisTaskGammaConvCalo::GetSourceClassification(Int_t daughter, Int_t pdgCode){
3183 if (daughter == 111) {
3184 if (abs(pdgCode) == 310) return 1; // k0s
3185 else if (abs(pdgCode) == 3122) return 2; // Lambda
3186 else if (abs(pdgCode) == 130) return 3; // K0L
3187 else if (abs(pdgCode) == 2212) return 4; // proton
3188 else if (abs(pdgCode) == 2112) return 5; // neutron
3189 else if (abs(pdgCode) == 211) return 6; // pion
3190 else if (abs(pdgCode) == 321) return 7; // kaon
3191 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
3192 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112 ) return 9; // Sigma
3193 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114 ) return 10; // Delta
3194 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323 ) return 11; // K*
git://git.uio.no / u / mrichter / AliRoot.git / blob