]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - PWGGA/GammaConv/AliAnalysisTaskGammaConvV1.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge branch 'master' of https://git.cern.ch/reps/AliRoot
[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliAnalysisTaskGammaConvV1.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: Martin Wilde, Daniel Lohner, Friederike Bock *
5 * Version 1.0 *
6 * *
7 * based on: on older version (see aliroot up to v5-04-42-AN) *
8 * AliAnalysisTaskGammaConversion.cxx *
9 * Authors: Kathrin Koch, Kenneth Aamodt, Ana Marin *
10 * *
11 * Permission to use, copy, modify and distribute this software and its *
12 * documentation strictly for non-commercial purposes is hereby granted *
13 * without fee, provided that the above copyright notice appears in all *
14 * copies and that both the copyright notice and this permission notice *
15 * appear in the supporting documentation. The authors make no claims *
16 * about the suitability of this software for any purpose. It is *
17 * provided "as is" without express or implied warranty. *
18 **************************************************************************/
19
20////////////////////////////////////////////////
21//---------------------------------------------
22
23// Class used to do analysis on conversion pairs
24//---------------------------------------------
25///////////////////////////////////////////////
26#include "TChain.h"
27#include "TTree.h"
28#include "TBranch.h"
29#include "TFile.h"
30#include "TH1F.h"
31#include "TH2F.h"
32#include "TH3F.h"
33#include "THnSparse.h"
34#include "TCanvas.h"
35#include "TNtuple.h"
36#include "AliAnalysisTask.h"
37#include "AliAnalysisManager.h"
38#include "AliESDEvent.h"
39#include "AliESDInputHandler.h"
40#include "AliMCEventHandler.h"
41#include "AliMCEvent.h"
42#include "AliMCParticle.h"
43#include "AliCentrality.h"
44#include "AliESDVZERO.h"
45#include "AliESDpid.h"
46#include "AliAnalysisTaskGammaConvV1.h"
47#include "AliVParticle.h"
48#include "AliESDtrack.h"
49#include "AliESDtrackCuts.h"
50#include "AliKFVertex.h"
51#include "AliV0ReaderV1.h"
52#include "AliGenCocktailEventHeader.h"
53#include "AliConversionAODBGHandlerRP.h"
54#include "AliAODMCParticle.h"
55#include "AliAODMCHeader.h"
56#include "AliEventplane.h"
57
58ClassImp(AliAnalysisTaskGammaConvV1)
59
60//________________________________________________________________________
61AliAnalysisTaskGammaConvV1::AliAnalysisTaskGammaConvV1(): AliAnalysisTaskSE(),
62 fV0Reader(NULL),
63 fBGHandler(NULL),
64 fBGHandlerRP(NULL),
65 fInputEvent(NULL),
66 fMCEvent(NULL),
67 fMCStack(NULL),
68 fCutFolder(NULL),
69 fESDList(NULL),
70 fBackList(NULL),
71 fMotherList(NULL),
72 fPhotonDCAList(NULL),
73 fMesonDCAList(NULL),
74 fTrueList(NULL),
75 fMCList(NULL),
76 fHeaderNameList(NULL),
77 fOutputContainer(0),
78 fReaderGammas(NULL),
79 fGammaCandidates(NULL),
80 fCutArray(NULL),
81 fConversionCuts(NULL),
82 fMesonCutArray(NULL),
83 fMesonCuts(NULL),
84 hESDConvGammaPt(NULL),
85 hESDConvGammaR(NULL),
86 hESDConvGammaEta(NULL),
87 tESDConvGammaPtDcazCat(NULL),
88 fPtGamma(0),
89 fDCAzPhoton(0),
90 fRConvPhoton(0),
91 fEtaPhoton(0),
92 iCatPhoton(0),
93 iPhotonMCInfo(0),
94 hESDMotherInvMassPt(NULL),
95 sESDMotherInvMassPtZM(NULL),
96 hESDMotherBackInvMassPt(NULL),
97 sESDMotherBackInvMassPtZM(NULL),
98 hESDMotherInvMassEalpha(NULL),
99 hESDMotherPi0PtY(NULL),
100 hESDMotherEtaPtY(NULL),
101 hESDMotherPi0PtAlpha(NULL),
102 hESDMotherEtaPtAlpha(NULL),
103 hESDMotherPi0PtOpenAngle(NULL),
104 hESDMotherEtaPtOpenAngle(NULL),
105 hMCHeaders(NULL),
106 hMCAllGammaPt(NULL),
107 hMCDecayGammaPi0Pt(NULL),
108 hMCDecayGammaRhoPt(NULL),
109 hMCDecayGammaEtaPt(NULL),
110 hMCDecayGammaOmegaPt(NULL),
111 hMCDecayGammaEtapPt(NULL),
112 hMCDecayGammaPhiPt(NULL),
113 hMCDecayGammaSigmaPt(NULL),
114 hMCConvGammaPt(NULL),
115 hMCConvGammaR(NULL),
116 hMCConvGammaEta(NULL),
117 hMCPi0Pt(NULL),
118 hMCPi0WOWeightPt(NULL),
119 hMCEtaPt(NULL),
120 hMCEtaWOWeightPt(NULL),
121 hMCPi0InAccPt(NULL),
122 hMCEtaInAccPt(NULL),
123 hMCPi0PtY(NULL),
124 hMCEtaPtY(NULL),
125 hMCK0sPt(NULL),
126 hMCK0sWOWeightPt(NULL),
127 hMCK0sPtY(NULL),
128 hMCSecPi0PtvsSource(NULL),
129 hMCSecPi0Source(NULL),
130 hMCSecEtaPt(NULL),
131 hMCSecEtaSource(NULL),
132 hESDTrueMotherInvMassPt(NULL),
133 hESDTruePrimaryMotherInvMassPt(NULL),
134 hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
135 pESDTruePrimaryMotherWeightsInvMassPt(NULL),
136 hESDTruePrimaryPi0MCPtResolPt(NULL),
137 hESDTruePrimaryEtaMCPtResolPt(NULL),
138 hESDTrueSecondaryMotherInvMassPt(NULL),
139 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
140 hESDTrueK0sWithPi0DaughterMCPt(NULL),
141 hESDTrueSecondaryMotherFromEtaInvMassPt(NULL),
142 hESDTrueEtaWithPi0DaughterMCPt(NULL),
143 hESDTrueSecondaryMotherFromLambdaInvMassPt(NULL),
144 hESDTrueLambdaWithPi0DaughterMCPt(NULL),
145 hESDTrueBckGGInvMassPt(NULL),
146 hESDTrueBckContInvMassPt(NULL),
147 hESDTruePi0PtY(NULL),
148 hESDTrueEtaPtY(NULL),
149 hESDTruePi0PtAlpha(NULL),
150 hESDTrueEtaPtAlpha(NULL),
151 hESDTruePi0PtOpenAngle(NULL),
152 hESDTrueEtaPtOpenAngle(NULL),
153 hESDTrueMotherDalitzInvMassPt(NULL),
154 hESDTrueConvGammaPt(NULL),
155 hESDTrueConvGammaEta(NULL),
156 hESDCombinatorialPt(NULL),
157 hESDTruePrimaryConvGammaPt(NULL),
158 hESDTruePrimaryConvGammaESDPtMCPt(NULL),
159 hESDTrueSecondaryConvGammaPt(NULL),
160 hESDTrueSecondaryConvGammaFromXFromK0sPt(NULL),
161 hESDTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
162 hESDTrueDalitzPsiPairDeltaPhi(NULL),
163 hESDTrueGammaPsiPairDeltaPhi(NULL),
164 hNEvents(NULL),
165 hNGoodESDTracks(NULL),
166 hNGammaCandidates(NULL),
167 hNV0Tracks(NULL),
168 hEtaShift(NULL),
169 tESDMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
170 fInvMass(0),
171 fPt(0),
172 fDCAzGammaMin(0),
173 fDCAzGammaMax(0),
174 iFlag(0),
175 iMesonMCInfo(0),
176 fEventPlaneAngle(-100),
177 fRandom(0),
178 fnGammaCandidates(0),
179 fUnsmearedPx(NULL),
180 fUnsmearedPy(NULL),
181 fUnsmearedPz(NULL),
182 fUnsmearedE(NULL),
183 fMCStackPos(NULL),
184 fMCStackNeg(NULL),
185 fESDArrayPos(NULL),
186 fESDArrayNeg(NULL),
187 fnCuts(0),
188 fiCut(0),
189 fMoveParticleAccordingToVertex(kTRUE),
190 fIsHeavyIon(0),
191 fDoMesonAnalysis(kTRUE),
192 fDoMesonQA(0),
193 fDoPhotonQA(0),
194 fIsFromMBHeader(kTRUE),
195 fIsMC(kFALSE)
196{
197
198}
199
200//________________________________________________________________________
201AliAnalysisTaskGammaConvV1::AliAnalysisTaskGammaConvV1(const char *name):
202 AliAnalysisTaskSE(name),
203 fV0Reader(NULL),
204 fBGHandler(NULL),
205 fBGHandlerRP(NULL),
206 fInputEvent(NULL),
207 fMCEvent(NULL),
208 fMCStack(NULL),
209 fCutFolder(NULL),
210 fESDList(NULL),
211 fBackList(NULL),
212 fMotherList(NULL),
213 fPhotonDCAList(NULL),
214 fMesonDCAList(NULL),
215 fTrueList(NULL),
216 fMCList(NULL),
217 fHeaderNameList(NULL),
218 fOutputContainer(0),
219 fReaderGammas(NULL),
220 fGammaCandidates(NULL),
221 fCutArray(NULL),
222 fConversionCuts(NULL),
223 fMesonCutArray(NULL),
224 fMesonCuts(NULL),
225 hESDConvGammaPt(NULL),
226 hESDConvGammaR(NULL),
227 hESDConvGammaEta(NULL),
228 tESDConvGammaPtDcazCat(NULL),
229 fPtGamma(0),
230 fDCAzPhoton(0),
231 fRConvPhoton(0),
232 fEtaPhoton(0),
233 iCatPhoton(0),
234 iPhotonMCInfo(0),
235 hESDMotherInvMassPt(NULL),
236 sESDMotherInvMassPtZM(NULL),
237 hESDMotherBackInvMassPt(NULL),
238 sESDMotherBackInvMassPtZM(NULL),
239 hESDMotherInvMassEalpha(NULL),
240 hESDMotherPi0PtY(NULL),
241 hESDMotherEtaPtY(NULL),
242 hESDMotherPi0PtAlpha(NULL),
243 hESDMotherEtaPtAlpha(NULL),
244 hESDMotherPi0PtOpenAngle(NULL),
245 hESDMotherEtaPtOpenAngle(NULL),
246 hMCHeaders(NULL),
247 hMCAllGammaPt(NULL),
248 hMCDecayGammaPi0Pt(NULL),
249 hMCDecayGammaRhoPt(NULL),
250 hMCDecayGammaEtaPt(NULL),
251 hMCDecayGammaOmegaPt(NULL),
252 hMCDecayGammaEtapPt(NULL),
253 hMCDecayGammaPhiPt(NULL),
254 hMCDecayGammaSigmaPt(NULL),
255 hMCConvGammaPt(NULL),
256 hMCConvGammaR(NULL),
257 hMCConvGammaEta(NULL),
258 hMCPi0Pt(NULL),
259 hMCPi0WOWeightPt(NULL),
260 hMCEtaPt(NULL),
261 hMCEtaWOWeightPt(NULL),
262 hMCPi0InAccPt(NULL),
263 hMCEtaInAccPt(NULL),
264 hMCPi0PtY(NULL),
265 hMCEtaPtY(NULL),
266 hMCK0sPt(NULL),
267 hMCK0sWOWeightPt(NULL),
268 hMCK0sPtY(NULL),
269 hMCSecPi0PtvsSource(NULL),
270 hMCSecPi0Source(NULL),
271 hMCSecEtaPt(NULL),
272 hMCSecEtaSource(NULL),
273 hESDTrueMotherInvMassPt(NULL),
274 hESDTruePrimaryMotherInvMassPt(NULL),
275 hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
276 pESDTruePrimaryMotherWeightsInvMassPt(NULL),
277 hESDTruePrimaryPi0MCPtResolPt(NULL),
278 hESDTruePrimaryEtaMCPtResolPt(NULL),
279 hESDTrueSecondaryMotherInvMassPt(NULL),
280 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
281 hESDTrueK0sWithPi0DaughterMCPt(NULL),
282 hESDTrueSecondaryMotherFromEtaInvMassPt(NULL),
283 hESDTrueEtaWithPi0DaughterMCPt(NULL),
284 hESDTrueSecondaryMotherFromLambdaInvMassPt(NULL),
285 hESDTrueLambdaWithPi0DaughterMCPt(NULL),
286 hESDTrueBckGGInvMassPt(NULL),
287 hESDTrueBckContInvMassPt(NULL),
288 hESDTruePi0PtY(NULL),
289 hESDTrueEtaPtY(NULL),
290 hESDTruePi0PtAlpha(NULL),
291 hESDTrueEtaPtAlpha(NULL),
292 hESDTruePi0PtOpenAngle(NULL),
293 hESDTrueEtaPtOpenAngle(NULL),
294 hESDTrueMotherDalitzInvMassPt(NULL),
295 hESDTrueConvGammaPt(NULL),
296 hESDTrueConvGammaEta(NULL),
297 hESDCombinatorialPt(NULL),
298 hESDTruePrimaryConvGammaPt(NULL),
299 hESDTruePrimaryConvGammaESDPtMCPt(NULL),
300 hESDTrueSecondaryConvGammaPt(NULL),
301 hESDTrueSecondaryConvGammaFromXFromK0sPt(NULL),
302 hESDTrueSecondaryConvGammaFromXFromLambdaPt(NULL),
303 hESDTrueDalitzPsiPairDeltaPhi(NULL),
304 hESDTrueGammaPsiPairDeltaPhi(NULL),
305 hNEvents(NULL),
306 hNGoodESDTracks(NULL),
307 hNGammaCandidates(NULL),
308 hNV0Tracks(NULL),
309 hEtaShift(NULL),
310 tESDMesonsInvMassPtDcazMinDcazMaxFlag(NULL),
311 fInvMass(0),
312 fPt(0),
313 fDCAzGammaMin(0),
314 fDCAzGammaMax(0),
315 iFlag(0),
316 iMesonMCInfo(0),
317 fEventPlaneAngle(-100),
318 fRandom(0),
319 fnGammaCandidates(0),
320 fUnsmearedPx(NULL),
321 fUnsmearedPy(NULL),
322 fUnsmearedPz(NULL),
323 fUnsmearedE(NULL),
324 fMCStackPos(NULL),
325 fMCStackNeg(NULL),
326 fESDArrayPos(NULL),
327 fESDArrayNeg(NULL),
328 fnCuts(0),
329 fiCut(0),
330 fMoveParticleAccordingToVertex(kTRUE),
331 fIsHeavyIon(0),
332 fDoMesonAnalysis(kTRUE),
333 fDoMesonQA(0),
334 fDoPhotonQA(0),
335 fIsFromMBHeader(kTRUE),
336 fIsMC(kFALSE)
337{
338 // Define output slots here
339 DefineOutput(1, TList::Class());
340}
341
342AliAnalysisTaskGammaConvV1::~AliAnalysisTaskGammaConvV1()
343{
344 if(fGammaCandidates){
345 delete fGammaCandidates;
346 fGammaCandidates = 0x0;
347 }
348 if(fBGHandler){
349 delete[] fBGHandler;
350 fBGHandler = 0x0;
351 }
352 if(fBGHandlerRP){
353 delete[] fBGHandlerRP;
354 fBGHandlerRP = 0x0;
355 }
356}
357//___________________________________________________________
358void AliAnalysisTaskGammaConvV1::InitBack(){
359
360 const Int_t nDim = 4;
361 Int_t nBins[nDim] = {800,250,7,4};
362 Double_t xMin[nDim] = {0,0, 0,0};
363 Double_t xMax[nDim] = {0.8,25,7,4};
364
365 sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
366 sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
367
368 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
369 fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
370 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
371 if (((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
372 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
373 TString cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
374
375 Int_t collisionSystem = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(0,1));
376 Int_t centMin = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(1,1));
377 Int_t centMax = atoi((TString)(((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber())(2,1));
378
379 if(collisionSystem == 1 || collisionSystem == 2 ||
380 collisionSystem == 5 || collisionSystem == 8 ||
381 collisionSystem == 9){
382 centMin = centMin*10;
383 centMax = centMax*10;
384 if(centMax ==0 && centMax!=centMin) centMax=100;
385 }
386 else if(collisionSystem == 3 || collisionSystem == 6){
387 centMin = centMin*5;
388 centMax = centMax*5;
389 }
390 else if(collisionSystem == 4 || collisionSystem == 7){
391 centMin = ((centMin*5)+45);
392 centMax = ((centMax*5)+45);
393 }
394
395 fBackList[iCut] = new TList();
396 fBackList[iCut]->SetName(Form("%s_%s Back histograms",cutstring.Data(),cutstringMeson.Data()));
397 fBackList[iCut]->SetOwner(kTRUE);
398 fCutFolder[iCut]->Add(fBackList[iCut]);
399
400 sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
401 fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
402
403 fMotherList[iCut] = new TList();
404 fMotherList[iCut]->SetName(Form("%s_%s Mother histograms",cutstring.Data(),cutstringMeson.Data()));
405 fMotherList[iCut]->SetOwner(kTRUE);
406 fCutFolder[iCut]->Add(fMotherList[iCut]);
407
408 sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
409 fMotherList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
410
411 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
412 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
413 collisionSystem,centMin,centMax,
414 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents(),
415 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseTrackMultiplicity());
416 fBGHandlerRP[iCut] = NULL;
417 }
418 else{
419 fBGHandlerRP[iCut] = new AliConversionAODBGHandlerRP(
420 ((AliConversionCuts*)fCutArray->At(fiCut))->IsHeavyIon(),
421 ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity(),
422 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetNumberOfBGEvents());
423 fBGHandler[iCut] = NULL;
424 }
425 }
426 }
427}
428//________________________________________________________________________
429void AliAnalysisTaskGammaConvV1::UserCreateOutputObjects(){
430
431 // Create histograms
432 if(fOutputContainer != NULL){
433 delete fOutputContainer;
434 fOutputContainer = NULL;
435 }
436 if(fOutputContainer == NULL){
437 fOutputContainer = new TList();
438 fOutputContainer->SetOwner(kTRUE);
439 }
440
441 // Array of current cut's gammas
442 fGammaCandidates = new TList();
443
444 fCutFolder = new TList*[fnCuts];
445 fESDList = new TList*[fnCuts];
446 fBackList = new TList*[fnCuts];
447 fMotherList = new TList*[fnCuts];
448 hNEvents = new TH1I*[fnCuts];
449 hNGoodESDTracks = new TH1I*[fnCuts];
450 hNGammaCandidates = new TH1I*[fnCuts];
451 hNV0Tracks = new TH1I*[fnCuts];
452 hEtaShift = new TProfile*[fnCuts];
453 hESDConvGammaPt = new TH1F*[fnCuts];
454
455 if (fDoPhotonQA == 2){
456 fPhotonDCAList = new TList*[fnCuts];
457 tESDConvGammaPtDcazCat = new TTree*[fnCuts];
458 }
459 if (fDoPhotonQA > 0){
460 hESDConvGammaR = new TH1F*[fnCuts];
461 hESDConvGammaEta = new TH1F*[fnCuts];
462 }
463
464 if(fDoMesonAnalysis){
465 hESDMotherInvMassPt = new TH2F*[fnCuts];
466 hESDMotherBackInvMassPt = new TH2F*[fnCuts];
467 hESDMotherInvMassEalpha = new TH2F*[fnCuts];
468 if (fDoMesonQA == 2){
469 fMesonDCAList = new TList*[fnCuts];
470 tESDMesonsInvMassPtDcazMinDcazMaxFlag = new TTree*[fnCuts];
471 }
472 if (fDoMesonQA > 0){
473 hESDMotherPi0PtY = new TH2F*[fnCuts];
474 hESDMotherEtaPtY = new TH2F*[fnCuts];
475 hESDMotherPi0PtAlpha = new TH2F*[fnCuts];
476 hESDMotherEtaPtAlpha = new TH2F*[fnCuts];
477 hESDMotherPi0PtOpenAngle = new TH2F*[fnCuts];
478 hESDMotherEtaPtOpenAngle = new TH2F*[fnCuts];
479 }
480 }
481
482 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
483
484 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
485 TString cutstringMeson = "NoMesonCut";
486 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
487
488 fCutFolder[iCut] = new TList();
489 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s",cutstring.Data(),cutstringMeson.Data()));
490 fCutFolder[iCut]->SetOwner(kTRUE);
491 fOutputContainer->Add(fCutFolder[iCut]);
492 fESDList[iCut] = new TList();
493 fESDList[iCut]->SetName(Form("%s_%s ESD histograms",cutstring.Data(),cutstringMeson.Data()));
494 fESDList[iCut]->SetOwner(kTRUE);
495 fCutFolder[iCut]->Add(fESDList[iCut]);
496
497 hNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
498 hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
499 hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
500 hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
501 if (((AliConversionCuts*)fCutArray->At(iCut))->IsSpecialTrigger() == 4 ){
502 TString TriggerNames = "Not Trigger: ";
503 TriggerNames = TriggerNames+ ( (AliConversionCuts*)fCutArray->At(iCut))->GetSpecialTriggerName();
504 hNEvents[iCut]->GetXaxis()->SetBinLabel(4,TriggerNames.Data());
505 } else {
506 hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
507 }
508 hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
509 hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
510 hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
511 hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
512 hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
513 fESDList[iCut]->Add(hNEvents[iCut]);
514
515 if(fIsHeavyIon == 1) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",4000,0,4000);
516 else if(fIsHeavyIon == 2) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",400,0,400);
517 else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
518 fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
519 if(fIsHeavyIon == 1) hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",100,0,100);
520 else if(fIsHeavyIon == 2) hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
521 else hNGammaCandidates[iCut] = new TH1I("GammaCandidates","GammaCandidates",50,0,50);
522 fESDList[iCut]->Add(hNGammaCandidates[iCut]);
523 if(fIsHeavyIon == 1) hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
524 else if(fIsHeavyIon == 2) hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
525 else hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
526 fESDList[iCut]->Add(hNV0Tracks[iCut]);
527 hEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
528 fESDList[iCut]->Add(hEtaShift[iCut]);
529 hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
530 fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
531
532 if (fDoPhotonQA == 2){
533 fPhotonDCAList[iCut] = new TList();
534 fPhotonDCAList[iCut]->SetName(Form("%s_%s Photon DCA tree",cutstring.Data(),cutstringMeson.Data()));
535 fPhotonDCAList[iCut]->SetOwner(kTRUE);
536 fCutFolder[iCut]->Add(fPhotonDCAList[iCut]);
537
538 tESDConvGammaPtDcazCat[iCut] = new TTree("ESD_ConvGamma_Pt_Dcaz_R_Eta","ESD_ConvGamma_Pt_Dcaz_R_Eta_Cat");
539 tESDConvGammaPtDcazCat[iCut]->Branch("Pt",&fPtGamma,"fPtGamma/F");
540 tESDConvGammaPtDcazCat[iCut]->Branch("DcaZPhoton",&fDCAzPhoton,"fDCAzPhoton/F");
541 // tESDConvGammaPtDcazCat[iCut]->Branch("R",&fRConvPhoton,"fRConvPhoton/F");
542 // tESDConvGammaPtDcazCat[iCut]->Branch("Eta",&fEtaPhoton,"fEtaPhoton/F");
543
544 tESDConvGammaPtDcazCat[iCut]->Branch("cat",&iCatPhoton,"iCatPhoton/b");
545 if(fIsMC){
546 tESDConvGammaPtDcazCat[iCut]->Branch("photonMCInfo",&iPhotonMCInfo,"iPhotonMCInfo/b");
547 }
548 fPhotonDCAList[iCut]->Add(tESDConvGammaPtDcazCat[iCut]);
549 }
550
551 if (fDoPhotonQA > 0){
552 hESDConvGammaR[iCut] = new TH1F("ESD_ConvGamma_R","ESD_ConvGamma_R",800,0,200);
553 fESDList[iCut]->Add(hESDConvGammaR[iCut]);
554 hESDConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",2000,-2,2);
555 fESDList[iCut]->Add(hESDConvGammaEta[iCut]);
556 }
557
558 if(fDoMesonAnalysis){
559 hESDMotherInvMassPt[iCut] = new TH2F("ESD_Mother_InvMass_Pt","ESD_Mother_InvMass_Pt",800,0,0.8,250,0,25);
560 fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
561 hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_Background_InvMass_Pt","ESD_Background_InvMass_Pt",800,0,0.8,250,0,25);
562 fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
563 hESDMotherInvMassEalpha[iCut] = new TH2F("ESD_Mother_InvMass_vs_E_alpha","ESD_Mother_InvMass_vs_E_alpha",800,0,0.8,250,0,25);
564 fESDList[iCut]->Add(hESDMotherInvMassEalpha[iCut]);
565 if (fDoMesonQA == 2){
566 fMesonDCAList[iCut] = new TList();
567 fMesonDCAList[iCut]->SetName(Form("%s_%s Meson DCA tree",cutstring.Data(),cutstringMeson.Data()));
568 fMesonDCAList[iCut]->SetOwner(kTRUE);
569 fCutFolder[iCut]->Add(fMesonDCAList[iCut]);
570
571 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut] = new TTree("ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag","ESD_Mesons_InvMass_Pt_DcazMin_DcazMax_Flag");
572 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("InvMass",&fInvMass,"fInvMass/F");
573 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("Pt",&fPt,"fPt/F");
574 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMin",&fDCAzGammaMin,"fDCAzGammaMin/F");
575 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("DcaZMax",&fDCAzGammaMax,"fDCAzGammaMax/F");
576 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("kind",&iFlag,"iFlag/b");
577 if(fIsMC){
578 tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]->Branch("mesonMCInfo",&iMesonMCInfo,"iMesonMCInfo/b");
579 }
580 fMesonDCAList[iCut]->Add(tESDMesonsInvMassPtDcazMinDcazMaxFlag[iCut]);
581
582 }
583 if (fDoMesonQA > 0 ){
584 hESDMotherPi0PtY[iCut] = new TH2F("ESD_MotherPi0_Pt_Y","ESD_MotherPi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
585 SetLogBinningXTH2(hESDMotherPi0PtY[iCut]);
586 fESDList[iCut]->Add(hESDMotherPi0PtY[iCut]);
587 hESDMotherEtaPtY[iCut] = new TH2F("ESD_MotherEta_Pt_Y","ESD_MotherEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
588 SetLogBinningXTH2(hESDMotherEtaPtY[iCut]);
589 fESDList[iCut]->Add(hESDMotherEtaPtY[iCut]);
590 hESDMotherPi0PtAlpha[iCut] = new TH2F("ESD_MotherPi0_Pt_Alpha","ESD_MotherPi0_Pt_Alpha",150,0.03,15.,100,0,1);
591 SetLogBinningXTH2(hESDMotherPi0PtAlpha[iCut]);
592 fESDList[iCut]->Add(hESDMotherPi0PtAlpha[iCut]);
593 hESDMotherEtaPtAlpha[iCut] = new TH2F("ESD_MotherEta_Pt_Alpha","ESD_MotherEta_Pt_Alpha",150,0.03,15.,100,0,1);
594 SetLogBinningXTH2(hESDMotherEtaPtAlpha[iCut]);
595 fESDList[iCut]->Add(hESDMotherEtaPtAlpha[iCut]);
596 hESDMotherPi0PtOpenAngle[iCut] = new TH2F("ESD_MotherPi0_Pt_OpenAngle","ESD_MotherPi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
597 SetLogBinningXTH2(hESDMotherPi0PtOpenAngle[iCut]);
598 fESDList[iCut]->Add(hESDMotherPi0PtOpenAngle[iCut]);
599 hESDMotherEtaPtOpenAngle[iCut] = new TH2F("ESD_MotherEta_Pt_OpenAngle","ESD_MotherEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
600 SetLogBinningXTH2(hESDMotherEtaPtOpenAngle[iCut]);
601 fESDList[iCut]->Add(hESDMotherEtaPtOpenAngle[iCut]);
602 }
603
604
605 }
606
607
608 }
609 if(fDoMesonAnalysis){
610 InitBack(); // Init Background Handler
611 }
612
613 if(fIsMC){
614 // MC Histogramms
615 fMCList = new TList*[fnCuts];
616 // True Histogramms
617 fTrueList = new TList*[fnCuts];
618 // Selected Header List
619 fHeaderNameList = new TList*[fnCuts];
620 hMCHeaders = new TH1I*[fnCuts];
621 hMCAllGammaPt = new TH1F*[fnCuts];
622 hMCDecayGammaPi0Pt = new TH1F*[fnCuts];
623 hMCDecayGammaRhoPt = new TH1F*[fnCuts];
624 hMCDecayGammaEtaPt = new TH1F*[fnCuts];
625 hMCDecayGammaOmegaPt = new TH1F*[fnCuts];
626 hMCDecayGammaEtapPt = new TH1F*[fnCuts];
627 hMCDecayGammaPhiPt = new TH1F*[fnCuts];
628 hMCDecayGammaSigmaPt = new TH1F*[fnCuts];
629 hMCConvGammaPt = new TH1F*[fnCuts];
630 hESDTrueConvGammaPt = new TH1F*[fnCuts];
631
632 hESDCombinatorialPt = new TH2F*[fnCuts];
633 hESDTruePrimaryConvGammaPt = new TH1F*[fnCuts];
634 hESDTruePrimaryConvGammaESDPtMCPt = new TH2F*[fnCuts];
635 hESDTrueSecondaryConvGammaPt = new TH1F*[fnCuts];
636 hESDTrueSecondaryConvGammaFromXFromK0sPt = new TH1F*[fnCuts];
637 hESDTrueSecondaryConvGammaFromXFromLambdaPt = new TH1F*[fnCuts];
638
639 hESDTrueDalitzPsiPairDeltaPhi= new TH2F*[fnCuts];
640 hESDTrueGammaPsiPairDeltaPhi= new TH2F*[fnCuts];
641
642 if (fDoPhotonQA > 0){
643 hMCConvGammaR = new TH1F*[fnCuts];
644 hMCConvGammaEta = new TH1F*[fnCuts];
645 hESDTrueConvGammaEta = new TH1F*[fnCuts];
646 }
647
648 if(fDoMesonAnalysis){
649 hMCPi0Pt = new TH1F*[fnCuts];
650 hMCPi0WOWeightPt = new TH1F*[fnCuts];
651 hMCEtaPt = new TH1F*[fnCuts];
652 hMCEtaWOWeightPt = new TH1F*[fnCuts];
653 hMCPi0InAccPt = new TH1F*[fnCuts];
654 hMCEtaInAccPt = new TH1F*[fnCuts];
655
656 hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
657 hESDTruePrimaryMotherInvMassPt = new TH2F*[fnCuts];
658 hESDTruePrimaryMotherW0WeightingInvMassPt = new TH2F*[fnCuts];
659 pESDTruePrimaryMotherWeightsInvMassPt = new TProfile2D*[fnCuts];
660 hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
661 hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
662 hESDTrueSecondaryMotherFromEtaInvMassPt = new TH2F*[fnCuts];
663 hESDTrueSecondaryMotherFromLambdaInvMassPt = new TH2F*[fnCuts];
664 hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
665 if (fDoMesonQA > 0){
666 hMCPi0PtY = new TH2F*[fnCuts];
667 hMCEtaPtY = new TH2F*[fnCuts];
668 hMCK0sPt = new TH1F*[fnCuts];
669 hMCK0sWOWeightPt = new TH1F*[fnCuts];
670 hMCK0sPtY = new TH2F*[fnCuts];
671 hMCSecPi0PtvsSource= new TH2F*[fnCuts];
672 hMCSecPi0Source = new TH1F*[fnCuts];
673 hMCSecEtaPt = new TH1F*[fnCuts];
674 hMCSecEtaSource = new TH1F*[fnCuts];
675 hESDTruePrimaryPi0MCPtResolPt = new TH2F*[fnCuts];
676 hESDTruePrimaryEtaMCPtResolPt = new TH2F*[fnCuts];
677 hESDTrueK0sWithPi0DaughterMCPt = new TH1F*[fnCuts];
678 hESDTrueEtaWithPi0DaughterMCPt = new TH1F*[fnCuts];
679 hESDTrueLambdaWithPi0DaughterMCPt = new TH1F*[fnCuts];
680 hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
681 hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
682 hESDTruePi0PtY = new TH2F*[fnCuts];
683 hESDTrueEtaPtY = new TH2F*[fnCuts];
684 hESDTruePi0PtAlpha = new TH2F*[fnCuts];
685 hESDTrueEtaPtAlpha = new TH2F*[fnCuts];
686 hESDTruePi0PtOpenAngle = new TH2F*[fnCuts];
687 hESDTrueEtaPtOpenAngle = new TH2F*[fnCuts];
688 }
689 }
690
691 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
692 TString cutstring = ((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber();
693 TString cutstringMeson = "NoMesonCut";
694 if(fDoMesonAnalysis)cutstringMeson = ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutNumber();
695
696 fMCList[iCut] = new TList();
697 fMCList[iCut]->SetName(Form("%s_%s MC histograms",cutstring.Data(),cutstringMeson.Data()));
698 fMCList[iCut]->SetOwner(kTRUE);
699 fCutFolder[iCut]->Add(fMCList[iCut]);
700 hMCHeaders[iCut] = new TH1I("MC_Headers","MC_Headers",20,0,20);
701 fMCList[iCut]->Add(hMCHeaders[iCut]);
702 hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
703 fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
704 hMCDecayGammaPi0Pt[iCut] = new TH1F("MC_DecayGammaPi0_Pt","MC_DecayGammaPi0_Pt",250,0,25);
705 fMCList[iCut]->Add(hMCDecayGammaPi0Pt[iCut]);
706 hMCDecayGammaRhoPt[iCut] = new TH1F("MC_DecayGammaRho_Pt","MC_DecayGammaRho_Pt",250,0,25);
707 fMCList[iCut]->Add(hMCDecayGammaRhoPt[iCut]);
708 hMCDecayGammaEtaPt[iCut] = new TH1F("MC_DecayGammaEta_Pt","MC_DecayGammaEta_Pt",250,0,25);
709 fMCList[iCut]->Add(hMCDecayGammaEtaPt[iCut]);
710 hMCDecayGammaOmegaPt[iCut] = new TH1F("MC_DecayGammaOmega_Pt","MC_DecayGammaOmmega_Pt",250,0,25);
711 fMCList[iCut]->Add(hMCDecayGammaOmegaPt[iCut]);
712 hMCDecayGammaEtapPt[iCut] = new TH1F("MC_DecayGammaEtap_Pt","MC_DecayGammaEtap_Pt",250,0,25);
713 fMCList[iCut]->Add(hMCDecayGammaEtapPt[iCut]);
714 hMCDecayGammaPhiPt[iCut] = new TH1F("MC_DecayGammaPhi_Pt","MC_DecayGammaPhi_Pt",250,0,25);
715 fMCList[iCut]->Add(hMCDecayGammaPhiPt[iCut]);
716 hMCDecayGammaSigmaPt[iCut] = new TH1F("MC_DecayGammaSigma_Pt","MC_DecayGammaSigma_Pt",250,0,25);
717 fMCList[iCut]->Add(hMCDecayGammaSigmaPt[iCut]);
718 hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
719 fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
720
721 if (fDoPhotonQA > 0){
722 hMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
723 fMCList[iCut]->Add(hMCConvGammaR[iCut]);
724 hMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",2000,-2,2);
725 fMCList[iCut]->Add(hMCConvGammaEta[iCut]);
726 }
727
728 if(fDoMesonAnalysis){
729 hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
730 hMCPi0Pt[iCut]->Sumw2();
731 fMCList[iCut]->Add(hMCPi0Pt[iCut]);
732 hMCPi0WOWeightPt[iCut] = new TH1F("MC_Pi0_WOWeights_Pt","MC_Pi0_WOWeights_Pt",250,0,25);
733 hMCPi0WOWeightPt[iCut]->Sumw2();
734 fMCList[iCut]->Add(hMCPi0WOWeightPt[iCut]);
735
736 hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
737 hMCEtaPt[iCut]->Sumw2();
738 fMCList[iCut]->Add(hMCEtaPt[iCut]);
739 hMCEtaWOWeightPt[iCut] = new TH1F("MC_Eta_WOWeights_Pt","MC_Eta_WOWeights_Pt",250,0,25);
740 hMCEtaWOWeightPt[iCut]->Sumw2();
741 fMCList[iCut]->Add(hMCEtaWOWeightPt[iCut]);
742 hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0InAcc_Pt","MC_Pi0InAcc_Pt",250,0,25);
743 hMCPi0InAccPt[iCut]->Sumw2();
744 fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
745 hMCEtaInAccPt[iCut] = new TH1F("MC_EtaInAcc_Pt","MC_EtaInAcc_Pt",250,0,25);
746 hMCEtaInAccPt[iCut]->Sumw2();
747 fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
748 if (fDoMesonQA > 0){
749 hMCPi0PtY[iCut] = new TH2F("MC_Pi0_Pt_Y","MC_Pi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
750 hMCPi0PtY[iCut]->Sumw2();
751 SetLogBinningXTH2(hMCPi0PtY[iCut]);
752 fMCList[iCut]->Add(hMCPi0PtY[iCut]);
753 hMCEtaPtY[iCut] = new TH2F("MC_Eta_Pt_Y","MC_Eta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
754 hMCEtaPtY[iCut]->Sumw2();
755 SetLogBinningXTH2(hMCEtaPtY[iCut]);
756 fMCList[iCut]->Add(hMCEtaPtY[iCut]);
757 hMCK0sPt[iCut] = new TH1F("MC_K0s_Pt","MC_K0s_Pt",150,0,15);
758 hMCK0sPt[iCut]->Sumw2();
759 fMCList[iCut]->Add(hMCK0sPt[iCut]);
760 hMCK0sWOWeightPt[iCut] = new TH1F("MC_K0s_WOWeights_Pt","MC_K0s_WOWeights_Pt",150,0,15);
761 hMCK0sWOWeightPt[iCut]->Sumw2();
762 fMCList[iCut]->Add(hMCK0sWOWeightPt[iCut]);
763 hMCK0sPtY[iCut] = new TH2F("MC_K0s_Pt_Y","MC_K0s_Pt_Y",150,0.03,15.,150,-1.5,1.5);
764 hMCK0sPtY[iCut]->Sumw2();
765 SetLogBinningXTH2(hMCK0sPtY[iCut]);
766 fMCList[iCut]->Add(hMCK0sPtY[iCut]);
767
768 hMCSecPi0Source[iCut] = new TH1F("MC_SecPi0_Source","MC_SecPi0_Source",5000,0.,5000);
769 fMCList[iCut]->Add(hMCSecPi0Source[iCut]);
770 hMCSecEtaSource[iCut] = new TH1F("MC_SecEta_Source","MC_SecEta_Source",5000,0,5000);
771 fMCList[iCut]->Add(hMCSecEtaSource[iCut]);
772 hMCSecPi0PtvsSource[iCut] = new TH2F("MC_SecPi0_Pt_Source","MC_SecPi0_Pt_Source",250,0.0,25.,16,-0.5,15.5);
773 hMCSecPi0PtvsSource[iCut]->Sumw2();
774 fMCList[iCut]->Add(hMCSecPi0PtvsSource[iCut]);
775 hMCSecEtaPt[iCut] = new TH1F("MC_SecEta_Pt","MC_SecEta_Pt",250,0,25);
776 hMCSecEtaPt[iCut]->Sumw2();
777 fMCList[iCut]->Add(hMCSecEtaPt[iCut]);
778 }
779
780 }
781 fTrueList[iCut] = new TList();
782 fTrueList[iCut]->SetName(Form("%s_%s True histograms",cutstring.Data(),cutstringMeson.Data()));
783 fTrueList[iCut]->SetOwner(kTRUE);
784 fCutFolder[iCut]->Add(fTrueList[iCut]);
785
786 hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
787 fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
788
789 hESDCombinatorialPt[iCut] = new TH2F("ESD_TrueCombinatorial_Pt","ESD_TrueCombinatorial_Pt",250,0,25,16,-0.5,15.5);
790 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 1,"Elec+Elec");
791 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 2,"Elec+Pion");
792 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 3,"Elec+Kaon");
793 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 4,"Elec+Proton");
794 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 5,"Elec+Muon");
795 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 6,"Pion+Pion");
796 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 7,"Pion+Kaon");
797 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 8,"Pion+Proton");
798 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel( 9,"Pion+Muon");
799 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(10,"Kaon+Kaon");
800 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(11,"Kaon+Proton");
801 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(12,"Kaon+Muon");
802 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(13,"Proton+Proton");
803 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(14,"Proton+Muon");
804 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(15,"Muon+Muon");
805 hESDCombinatorialPt[iCut]->GetYaxis()->SetBinLabel(16,"Rest");
806 fTrueList[iCut]->Add(hESDCombinatorialPt[iCut]);
807 hESDTruePrimaryConvGammaPt[iCut] = new TH1F("ESD_TruePrimaryConvGamma_Pt","ESD_TruePrimaryConvGamma_Pt",250,0,25);
808 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaPt[iCut]);
809 hESDTrueSecondaryConvGammaPt[iCut] = new TH1F("ESD_TrueSecondaryConvGamma_Pt","ESD_TrueSecondaryConvGamma_Pt",250,0,25);
810 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaPt[iCut]);
811
812 hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]
813 = new TH1F("ESD_TrueSecondaryConvGammaFromXFromK0s_Pt", "ESD_TrueSecondaryConvGammaFromXFromK0s_Pt",250,0,25);
814 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromK0sPt[iCut]);
815 hESDTrueSecondaryConvGammaFromXFromLambdaPt[iCut]
816 = new TH1F("ESD_TrueSecondaryConvGammaFromXFromLambda_Pt", "ESD_TrueSecondaryConvGammaFromXFromLambda_Pt",250,0,25);
817 fTrueList[iCut]->Add(hESDTrueSecondaryConvGammaFromXFromLambdaPt[iCut]);
818
819 hESDTrueDalitzPsiPairDeltaPhi[iCut]
820 = new TH2F("ESD_TrueDalitzPsiPairDeltaPhi_Pt", "ESD_TrueDalitzPsiPairDeltaPhi_Pt",100,-0.5,2,100,-0.5,0.5);
821 fTrueList[iCut]->Add(hESDTrueDalitzPsiPairDeltaPhi[iCut]);
822
823 hESDTrueGammaPsiPairDeltaPhi[iCut]
824 = new TH2F("ESD_TrueGammaPsiPairDeltaPhi_Pt", "ESD_TrueGammaPsiPairDeltaPhi_Pt",100,-0.5,2,100,-0.5,0.5);
825 fTrueList[iCut]->Add(hESDTrueGammaPsiPairDeltaPhi[iCut]);
826
827 hESDTruePrimaryConvGammaESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryConvGammaESD_PtMCPt", "ESD_TruePrimaryConvGammaESD_PtMCPt",250,0,25,250,0,25);
828 fTrueList[iCut]->Add(hESDTruePrimaryConvGammaESDPtMCPt[iCut]);
829
830 if(fDoMesonAnalysis){
831 hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
832 fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
833 hESDTruePrimaryMotherInvMassPt[iCut]
834 = new TH2F("ESD_TruePrimaryMother_InvMass_Pt", "ESD_TruePrimaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
835 hESDTruePrimaryMotherInvMassPt[iCut]->Sumw2();
836 fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassPt[iCut]);
837 hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]
838 = new TH2F("ESD_TruePrimaryMotherW0Weights_InvMass_Pt", "ESD_TruePrimaryMotherW0Weights_InvMass_Pt", 800,0,0.8,250,0,25);
839 hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]->Sumw2();
840 fTrueList[iCut]->Add(hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]);
841 pESDTruePrimaryMotherWeightsInvMassPt[iCut]
842 = new TProfile2D("ESD_TruePrimaryMotherWeights_InvMass_Pt", "ESD_TruePrimaryMotherWeights_InvMass_Pt", 800,0,0.8,250,0,25);
843 pESDTruePrimaryMotherWeightsInvMassPt[iCut]->Sumw2();
844 fTrueList[iCut]->Add(pESDTruePrimaryMotherWeightsInvMassPt[iCut]);
845 hESDTrueSecondaryMotherInvMassPt[iCut]
846 = new TH2F("ESD_TrueSecondaryMother_InvMass_Pt", "ESD_TrueSecondaryMother_InvMass_Pt", 800,0,0.8,250,0,25);
847 hESDTrueSecondaryMotherInvMassPt[iCut]->Sumw2();
848 fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
849 hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]
850 = new TH2F("ESD_TrueSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueSecondaryMotherFromK0s_InvMass_Pt",800,0,0.8,250,0,25);
851 hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]->Sumw2();
852 fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
853 hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]
854 = new TH2F("ESD_TrueSecondaryMotherFromEta_InvMass_Pt","ESD_TrueSecondaryMotherFromEta_InvMass_Pt",800,0,0.8,250,0,25);
855 fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromEtaInvMassPt[iCut]);
856 hESDTrueSecondaryMotherFromLambdaInvMassPt[iCut]
857 = new TH2F("ESD_TrueSecondaryMotherFromLambda_InvMass_Pt","ESD_TrueSecondaryMotherFromLambda_InvMass_Pt",800,0,0.8,250,0,25);
858 fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromLambdaInvMassPt[iCut]);
859 hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueDalitz_InvMass_Pt","ESD_TrueDalitz_InvMass_Pt",800,0,0.8,250,0,25);
860 fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
861 if (fDoMesonQA > 0){
862 hESDTruePrimaryPi0MCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryPi0_MCPt_ResolPt","ESD_TruePrimaryPi0_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
863 hESDTruePrimaryPi0MCPtResolPt[iCut]->Sumw2();
864 SetLogBinningXTH2(hESDTruePrimaryPi0MCPtResolPt[iCut]);
865 fTrueList[iCut]->Add(hESDTruePrimaryPi0MCPtResolPt[iCut]);
866 hESDTruePrimaryEtaMCPtResolPt[iCut] = new TH2F("ESD_TruePrimaryEta_MCPt_ResolPt","ESD_TruePrimaryEta_ResolPt_MCPt",500,0.03,25,1000,-1.,1.);
867 hESDTruePrimaryEtaMCPtResolPt[iCut]->Sumw2();
868 SetLogBinningXTH2(hESDTruePrimaryEtaMCPtResolPt[iCut]);
869 fTrueList[iCut]->Add(hESDTruePrimaryEtaMCPtResolPt[iCut]);
870 hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueBckGG_InvMass_Pt","ESD_TrueBckGG_InvMass_Pt",800,0,0.8,250,0,25);
871 fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
872 hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueBckCont_InvMass_Pt","ESD_TrueBckCont_InvMass_Pt",800,0,0.8,250,0,25);
873 fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
874 hESDTrueK0sWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueK0sWithPi0Daughter_MCPt","ESD_TrueK0sWithPi0Daughter_MCPt",250,0,25);
875 fTrueList[iCut]->Add(hESDTrueK0sWithPi0DaughterMCPt[iCut]);
876 hESDTrueEtaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueEtaWithPi0Daughter_MCPt","ESD_TrueEtaWithPi0Daughter_MCPt",250,0,25);
877 fTrueList[iCut]->Add(hESDTrueEtaWithPi0DaughterMCPt[iCut]);
878 hESDTrueLambdaWithPi0DaughterMCPt[iCut] = new TH1F("ESD_TrueLambdaWithPi0Daughter_MCPt","ESD_TrueLambdaWithPi0Daughter_MCPt",250,0,25);
879 fTrueList[iCut]->Add(hESDTrueLambdaWithPi0DaughterMCPt[iCut]);
880
881 hESDTruePi0PtY[iCut] = new TH2F("ESD_TruePi0_Pt_Y","ESD_TruePi0_Pt_Y",150,0.03,15.,150,-1.5,1.5);
882 SetLogBinningXTH2(hESDTruePi0PtY[iCut]);
883 fTrueList[iCut]->Add(hESDTruePi0PtY[iCut]);
884 hESDTrueEtaPtY[iCut] = new TH2F("ESD_TrueEta_Pt_Y","ESD_TrueEta_Pt_Y",150,0.03,15.,150,-1.5,1.5);
885 SetLogBinningXTH2(hESDTrueEtaPtY[iCut]);
886 fTrueList[iCut]->Add(hESDTrueEtaPtY[iCut]);
887 hESDTruePi0PtAlpha[iCut] = new TH2F("ESD_TruePi0_Pt_Alpha","ESD_TruePi0_Pt_Alpha",150,0.03,15.,100,0,1);
888 SetLogBinningXTH2(hESDTruePi0PtAlpha[iCut]);
889 fTrueList[iCut]->Add(hESDTruePi0PtAlpha[iCut]);
890 hESDTrueEtaPtAlpha[iCut] = new TH2F("ESD_TrueEta_Pt_Alpha","ESD_TrueEta_Pt_Alpha",150,0.03,15.,100,0,1);
891 SetLogBinningXTH2(hESDTrueEtaPtAlpha[iCut]);
892 fTrueList[iCut]->Add(hESDTrueEtaPtAlpha[iCut]);
893
894 hESDTruePi0PtOpenAngle[iCut] = new TH2F("ESD_TruePi0_Pt_OpenAngle","ESD_TruePi0_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
895 SetLogBinningXTH2(hESDTruePi0PtOpenAngle[iCut]);
896 fTrueList[iCut]->Add(hESDTruePi0PtOpenAngle[iCut]);
897 hESDTrueEtaPtOpenAngle[iCut] = new TH2F("ESD_TrueEta_Pt_OpenAngle","ESD_TrueEta_Pt_OpenAngle",150,0.03,15.,200,0,2*TMath::Pi());
898 SetLogBinningXTH2(hESDTrueEtaPtOpenAngle[iCut]);
899 fTrueList[iCut]->Add(hESDTrueEtaPtOpenAngle[iCut]);
900
901 hESDTrueConvGammaEta[iCut] = new TH1F("ESD_TrueConvGamma_Eta","ESD_TrueConvGamma_Eta",2000,-2,2);
902 fTrueList[iCut]->Add(hESDTrueConvGammaEta[iCut]);
903
904 }
905 }
906 }
907 }
908
909 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
910 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
911
912 if(fV0Reader)
913 if((AliConversionCuts*)fV0Reader->GetConversionCuts())
914 if(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
915 fOutputContainer->Add(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
916
917 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
918 if(!((AliConversionCuts*)fCutArray->At(iCut))) continue;
919 if(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms()){
920 fCutFolder[iCut]->Add(((AliConversionCuts*)fCutArray->At(iCut))->GetCutHistograms());
921 }
922 if(fDoMesonAnalysis){
923 if(!((AliConversionMesonCuts*)fMesonCutArray->At(iCut))) continue;
924 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms()){
925 fCutFolder[iCut]->Add(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->GetCutHistograms());
926 }
927 }
928 }
929 PostData(1, fOutputContainer);
930}
931//_____________________________________________________________________________
932Bool_t AliAnalysisTaskGammaConvV1::Notify()
933{
934 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
935 if(!((AliConversionCuts*)fCutArray->At(iCut))->GetDoEtaShift()){
936 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
937 continue; // No Eta Shift requested, continue
938 }
939 if(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
940 ((AliConversionCuts*)fCutArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
941 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
942 ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
943 continue;
944 }
945 else{
946 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
947 (((AliConversionCuts*)fCutArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift());
948 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutArray->At(iCut))->GetEtaShift()));
949 ((AliConversionCuts*)fCutArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
950 }
951 }
952
953 return kTRUE;
954}
955//_____________________________________________________________________________
956void AliAnalysisTaskGammaConvV1::UserExec(Option_t *)
957{
958 //
959 // Called for each event
960 //
961 Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
962 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
963 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
964 hNEvents[iCut]->Fill(eventQuality);
965 }
966 return;
967 }
968
969 if(fIsMC) fMCEvent = MCEvent();
970 if(fMCEvent == NULL) fIsMC = kFALSE;
971
972 fInputEvent = InputEvent();
973
974 if(fIsMC && fInputEvent->IsA()==AliESDEvent::Class()){
975 fMCStack = fMCEvent->Stack();
976 if(fMCStack == NULL) fIsMC = kFALSE;
977 }
978
979 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
980
981 // ------------------- BeginEvent ----------------------------
982
983 AliEventplane *EventPlane = fInputEvent->GetEventplane();
984 if(fIsHeavyIon ==1)fEventPlaneAngle = EventPlane->GetEventplane("V0",fInputEvent,2);
985 else fEventPlaneAngle=0.0;
986
987 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
988 RelabelAODPhotonCandidates(kTRUE); // In case of AODMC relabeling MC
989 fV0Reader->RelabelAODs(kTRUE);
990 }
991 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
992 fiCut = iCut;
993 Int_t eventNotAccepted =
994 ((AliConversionCuts*)fCutArray->At(iCut))
995 ->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
996 if(eventNotAccepted){
997 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
998 hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
999 continue;
1000 }
1001
1002 if(eventQuality != 0){// Event Not Accepted
1003 // cout << "event rejected due to: " <<eventQuality << endl;
1004 hNEvents[iCut]->Fill(eventQuality);
1005 continue;
1006 }
1007
1008 hNEvents[iCut]->Fill(eventQuality); // Should be 0 here
1009 hNGoodESDTracks[iCut]->Fill(fV0Reader->GetNumberOfPrimaryTracks());
1010 if(((AliConversionCuts*)fCutArray->At(iCut))->IsHeavyIon() == 2) hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
1011 else hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1012
1013 if(fIsMC){
1014 // Process MC Particle
1015 if(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection() != 0){
1016 if(fInputEvent->IsA()==AliESDEvent::Class()){
1017 ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
1018 ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
1019 fMCEvent);
1020 }
1021 else if(fInputEvent->IsA()==AliAODEvent::Class()){
1022 ((AliConversionCuts*)fCutArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutArray->At(iCut))->GetSignalRejection(),
1023 ((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader(),
1024 fInputEvent);
1025 }
1026
1027 if(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader()){
1028 for(Int_t i = 0;i<(((AliConversionCuts*)fCutArray->At(iCut))->GetAcceptedHeader())->GetEntries();i++){
1029 TString nameBin= hMCHeaders[iCut]->GetXaxis()->GetBinLabel(i+1);
1030 if (nameBin.CompareTo("")== 0){
1031 TString nameHeader = ((TObjString*)((TList*)((AliConversionCuts*)fCutArray->At(iCut))
1032 ->GetAcceptedHeader())->At(i))->GetString();
1033 hMCHeaders[iCut]->GetXaxis()->SetBinLabel(i+1,nameHeader.Data());
1034 }
1035 }
1036 }
1037 }
1038 }
1039 if(fIsMC){
1040 if(fInputEvent->IsA()==AliESDEvent::Class())
1041 ProcessMCParticles();
1042 if(fInputEvent->IsA()==AliAODEvent::Class())
1043 ProcessAODMCParticles();
1044 }
1045
1046 ProcessPhotonCandidates(); // Process this cuts gammas
1047
1048 hNGammaCandidates[iCut]->Fill(fGammaCandidates->GetEntries());
1049 if(fDoMesonAnalysis){ // Meson Analysis
1050 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1051 fUnsmearedPx = new Double_t[fGammaCandidates->GetEntries()]; // Store unsmeared Momenta
1052 fUnsmearedPy = new Double_t[fGammaCandidates->GetEntries()];
1053 fUnsmearedPz = new Double_t[fGammaCandidates->GetEntries()];
1054 fUnsmearedE = new Double_t[fGammaCandidates->GetEntries()];
1055
1056 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1057 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Px();
1058 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Py();
1059 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->Pz();
1060 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->E();
1061 ((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(gamma)));
1062 }
1063 }
1064
1065 CalculatePi0Candidates(); // Combine Gammas
1066 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->DoBGCalculation()){
1067 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->BackgroundHandlerType() == 0){
1068 CalculateBackground(); // Combinatorial Background
1069 UpdateEventByEventData(); // Store Event for mixed Events
1070 }
1071 else{
1072 CalculateBackgroundRP(); // Combinatorial Background
1073 fBGHandlerRP[iCut]->AddEvent(fGammaCandidates,fInputEvent); // Store Event for mixed Events
1074 }
1075 }
1076 if(((AliConversionMesonCuts*)fMesonCutArray->At(iCut))->UseMCPSmearing() && fIsMC){
1077 for(Int_t gamma=0;gamma<fGammaCandidates->GetEntries();gamma++){ // Smear the AODPhotons in MC
1078 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1079 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1080 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1081 ((AliAODConversionPhoton*)fGammaCandidates->At(gamma))->SetE(fUnsmearedE[gamma]);
1082 }
1083 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1084 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1085 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1086 delete[] fUnsmearedE; fUnsmearedE = 0x0;
1087 }
1088 }
1089 fGammaCandidates->Clear(); // delete this cuts good gammas
1090 }
1091
1092 if(fIsMC && fInputEvent->IsA()==AliAODEvent::Class() && !(fV0Reader->AreAODsRelabeled())){
1093 RelabelAODPhotonCandidates(kFALSE); // Back to ESDMC Label
1094 fV0Reader->RelabelAODs(kFALSE);
1095 }
1096
1097 PostData(1, fOutputContainer);
1098}
1099//________________________________________________________________________
1100void AliAnalysisTaskGammaConvV1::ProcessPhotonCandidates()
1101{
1102 Int_t nV0 = 0;
1103 TList *GammaCandidatesStepOne = new TList();
1104 TList *GammaCandidatesStepTwo = new TList();
1105 // Loop over Photon Candidates allocated by ReaderV1
1106 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1107 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1108 if(!PhotonCandidate) continue;
1109 fIsFromMBHeader = kTRUE;
1110 if(fIsMC && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1111 Int_t isPosFromMBHeader
1112 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1113 if(isPosFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1114 Int_t isNegFromMBHeader
1115 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1116 if(isNegFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1117
1118 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1119 }
1120
1121 if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fInputEvent)) continue;
1122 if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(PhotonCandidate->GetPhotonPhi(),fEventPlaneAngle)) continue;
1123 if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1124 !((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1125 fGammaCandidates->Add(PhotonCandidate); // if no second loop is required add to events good gammas
1126
1127 if(fIsFromMBHeader){
1128 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1129 if (fDoPhotonQA > 0){
1130 hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1131 hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1132 }
1133 }
1134 if(fIsMC){
1135 if(fInputEvent->IsA()==AliESDEvent::Class())
1136 ProcessTruePhotonCandidates(PhotonCandidate);
1137 if(fInputEvent->IsA()==AliAODEvent::Class())
1138 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1139 }
1140 if (fIsFromMBHeader && fDoPhotonQA == 2){
1141 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1142 fPtGamma = PhotonCandidate->Pt();
1143 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1144 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1145 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1146 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1147 tESDConvGammaPtDcazCat[fiCut]->Fill();
1148 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1149 fPtGamma = PhotonCandidate->Pt();
1150 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1151 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1152 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1153 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1154 tESDConvGammaPtDcazCat[fiCut]->Fill();
1155 }
1156 }
1157 } else if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1158 ((AliConversionCuts*)fCutArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1159 nV0++;
1160 GammaCandidatesStepOne->Add(PhotonCandidate);
1161 } else if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut() &&
1162 ((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1163 GammaCandidatesStepTwo->Add(PhotonCandidate);
1164 }
1165 }
1166 if(((AliConversionCuts*)fCutArray->At(fiCut))->UseElecSharingCut()){
1167 for(Int_t i = 0;i<GammaCandidatesStepOne->GetEntries();i++){
1168 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GammaCandidatesStepOne->At(i);
1169 if(!PhotonCandidate) continue;
1170 fIsFromMBHeader = kTRUE;
1171 if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1172 Int_t isPosFromMBHeader
1173 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1174 Int_t isNegFromMBHeader
1175 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1176 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1177 }
1178 if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GammaCandidatesStepOne->GetEntries())) continue;
1179 if(!((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1180 fGammaCandidates->Add(PhotonCandidate);
1181 if(fIsFromMBHeader){
1182 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1183 if (fDoPhotonQA > 0){
1184 hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1185 hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1186 }
1187 }
1188 }
1189 if(fIsMC){
1190 if(fInputEvent->IsA()==AliESDEvent::Class())
1191 ProcessTruePhotonCandidates(PhotonCandidate);
1192 if(fInputEvent->IsA()==AliAODEvent::Class())
1193 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1194 } else GammaCandidatesStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1195
1196 if (fIsFromMBHeader && fDoPhotonQA == 2){
1197 if (fIsHeavyIon ==1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1198 fPtGamma = PhotonCandidate->Pt();
1199 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1200 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1201 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1202 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1203 tESDConvGammaPtDcazCat[fiCut]->Fill();
1204 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1205 fPtGamma = PhotonCandidate->Pt();
1206 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1207 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1208 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1209 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1210 tESDConvGammaPtDcazCat[fiCut]->Fill();
1211 }
1212 }
1213 }
1214 }
1215 if(((AliConversionCuts*)fCutArray->At(fiCut))->UseToCloseV0sCut()){
1216 for(Int_t i = 0;i<GammaCandidatesStepTwo->GetEntries();i++){
1217 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GammaCandidatesStepTwo->At(i);
1218 if(!PhotonCandidate) continue;
1219 fIsFromMBHeader = kTRUE;
1220 if(fMCStack && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1221 Int_t isPosFromMBHeader
1222 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1223 Int_t isNegFromMBHeader
1224 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack, fInputEvent);
1225 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1226 }
1227 if(!((AliConversionCuts*)fCutArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GammaCandidatesStepTwo,i)) continue;
1228 fGammaCandidates->Add(PhotonCandidate); // Add gamma to current cut TList
1229 if(fIsFromMBHeader){
1230 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1231 if (fDoPhotonQA > 0){
1232 hESDConvGammaR[fiCut]->Fill(PhotonCandidate->GetConversionRadius());
1233 hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1234 }
1235 }
1236 if(fIsMC){
1237 if(fInputEvent->IsA()==AliESDEvent::Class())
1238 ProcessTruePhotonCandidates(PhotonCandidate);
1239 if(fInputEvent->IsA()==AliAODEvent::Class())
1240 ProcessTruePhotonCandidatesAOD(PhotonCandidate);
1241 }
1242 if (fIsFromMBHeader){
1243 if (fIsHeavyIon == 1 && PhotonCandidate->Pt() > 0.399 && PhotonCandidate->Pt() < 12.){
1244 fPtGamma = PhotonCandidate->Pt();
1245 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1246 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1247 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1248 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1249 tESDConvGammaPtDcazCat[fiCut]->Fill();
1250 } else if ( PhotonCandidate->Pt() > 0.299 && PhotonCandidate->Pt() < 16.){
1251 fPtGamma = PhotonCandidate->Pt();
1252 fDCAzPhoton = PhotonCandidate->GetDCAzToPrimVtx();
1253 fRConvPhoton = PhotonCandidate->GetConversionRadius();
1254 fEtaPhoton = PhotonCandidate->GetPhotonEta();
1255 iCatPhoton = PhotonCandidate->GetPhotonQuality();
1256 tESDConvGammaPtDcazCat[fiCut]->Fill();
1257 }
1258 }
1259 }
1260 }
1261
1262 delete GammaCandidatesStepOne;
1263 GammaCandidatesStepOne = 0x0;
1264 delete GammaCandidatesStepTwo;
1265 GammaCandidatesStepTwo = 0x0;
1266
1267}
1268//________________________________________________________________________
1269void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidatesAOD(AliAODConversionPhoton *TruePhotonCandidate)
1270{
1271
1272 Double_t magField = fInputEvent->GetMagneticField();
1273 if( magField < 0.0 ){
1274 magField = 1.0;
1275 }
1276 else {
1277 magField = -1.0;
1278 }
1279
1280 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1281 AliAODMCParticle *posDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelPositive());
1282 AliAODMCParticle *negDaughter = (AliAODMCParticle*) AODMCTrackArray->At(TruePhotonCandidate->GetMCLabelNegative());
1283 iPhotonMCInfo = 0;
1284
1285 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1286 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1287
1288 if(posDaughter->GetMother() != negDaughter->GetMother()){
1289 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1290 iPhotonMCInfo = 1;
1291 return;
1292 }
1293 else if(posDaughter->GetMother() == -1){
1294 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1295 iPhotonMCInfo = 1;
1296 return;
1297 }
1298
1299 if(pdgCode[0]!=11 || pdgCode[1]!=11){
1300 iPhotonMCInfo = 1;
1301 return; //One Particle is not a electron
1302 }
1303 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()){
1304 iPhotonMCInfo = 1;
1305 return; // Same Charge
1306 }
1307
1308 AliAODMCParticle *Photon = (AliAODMCParticle*) AODMCTrackArray->At(posDaughter->GetMother());
1309 AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1310 AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1311 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1312
1313 if(Photon->GetPdgCode() != 22){
1314 hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1315 iPhotonMCInfo = 1;
1316 return; // Mother is no Photon
1317 }
1318
1319 if(((posDaughter->GetMCProcessCode())) != 5 || ((negDaughter->GetMCProcessCode())) != 5){
1320 iPhotonMCInfo = 1;
1321 return;// check if the daughters come from a conversion
1322 }
1323 // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
1324
1325
1326
1327 // True Photon
1328 if(fIsFromMBHeader){
1329 hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1330 if (fDoPhotonQA > 0) hESDTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1331 }
1332 hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1333 if(Photon->IsPrimary()){
1334 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1335 if(fIsFromMBHeader){
1336 iPhotonMCInfo = 6;
1337 hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1338 hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1339 }
1340 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1341 }
1342 else{
1343 if(fIsFromMBHeader){
1344 hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1345 iPhotonMCInfo = 2;
1346 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1347 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 3122){
1348 iPhotonMCInfo = 5;
1349 hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1350 }
1351 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1352 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 310){
1353 iPhotonMCInfo = 4;
1354 hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1355 }
1356 if(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother() > -1 &&
1357 ((AliAODMCParticle*)AODMCTrackArray->At(((AliAODMCParticle*)AODMCTrackArray->At(Photon->GetMother()))->GetMother()))->GetPdgCode() == 221){
1358 iPhotonMCInfo = 3;
1359 }
1360 }
1361 }
1362
1363}
1364//________________________________________________________________________
1365void AliAnalysisTaskGammaConvV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1366{
1367
1368 Double_t magField = fInputEvent->GetMagneticField();
1369 if( magField < 0.0 ){
1370 magField = 1.0;
1371 }
1372 else {
1373 magField = -1.0;
1374 }
1375
1376 // Process True Photons
1377 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(fMCStack);
1378 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(fMCStack);
1379
1380 iPhotonMCInfo = 0;
1381
1382 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1383 Int_t pdgCode[2] = {abs(posDaughter->GetPdgCode()),abs(negDaughter->GetPdgCode())};
1384 iPhotonMCInfo = 1;
1385 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){
1386 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1387 return;
1388 }
1389 else if(posDaughter->GetMother(0) == -1){
1390 FillPhotonCombinatorialBackgroundHist(TruePhotonCandidate, pdgCode);
1391 return;
1392 }
1393
1394 if(pdgCode[0]!=11 || pdgCode[1]!=11) return; //One Particle is not a electron
1395
1396 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1397
1398 TParticle *Photon = TruePhotonCandidate->GetMCParticle(fMCStack);
1399 AliVTrack * electronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelNegative() );
1400 AliVTrack * positronCandidate = ((AliConversionCuts*)fCutArray->At(fiCut))->GetTrack(fInputEvent,TruePhotonCandidate->GetTrackLabelPositive() );
1401 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
1402
1403 if(Photon->GetPdgCode() != 22){
1404 hESDTrueDalitzPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1405 return; // Mother is no Photon
1406 }
1407
1408 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1409
1410
1411
1412 // True Photon
1413 if(fIsFromMBHeader){
1414 hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1415 if (fDoPhotonQA > 0) hESDTrueConvGammaEta[fiCut]->Fill(TruePhotonCandidate->Eta());
1416 }
1417 hESDTrueGammaPsiPairDeltaPhi[fiCut]->Fill(deltaPhi,TruePhotonCandidate->GetPsiPair());
1418 if(posDaughter->GetMother(0) <= fMCStack->GetNprimary()){
1419 // Count just primary MC Gammas as true --> For Ratio esdtruegamma / mcconvgamma
1420 if(fIsFromMBHeader){
1421 iPhotonMCInfo = 6;
1422 hESDTruePrimaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1423 hESDTruePrimaryConvGammaESDPtMCPt[fiCut]->Fill(TruePhotonCandidate->Pt(),Photon->Pt()); // Allways Filled
1424
1425 }
1426 // (Not Filled for i6, Extra Signal Gamma (parambox) are secondary)
1427 }
1428 else{
1429 if(fIsFromMBHeader){
1430 iPhotonMCInfo = 2;
1431 hESDTrueSecondaryConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1432 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1433 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 3122){
1434 hESDTrueSecondaryConvGammaFromXFromLambdaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1435 iPhotonMCInfo = 5;
1436 }
1437 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1438 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 310){
1439 hESDTrueSecondaryConvGammaFromXFromK0sPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1440 iPhotonMCInfo = 4;
1441 }
1442 if(fMCStack->Particle(Photon->GetMother(0))->GetMother(0) > -1 &&
1443 fMCStack->Particle(fMCStack->Particle(Photon->GetMother(0))->GetMother(0))->GetPdgCode() == 221){
1444 iPhotonMCInfo = 3;
1445 }
1446 }
1447 }
1448}
1449//________________________________________________________________________
1450void AliAnalysisTaskGammaConvV1::ProcessAODMCParticles()
1451{
1452
1453 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1454
1455 // Loop over all primary MC particle
1456 for(Int_t i = 0; i < AODMCTrackArray->GetEntriesFast(); i++) {
1457
1458 AliAODMCParticle* particle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(i));
1459 if (!particle) continue;
1460 if (!particle->IsPrimary()) continue;
1461
1462 Int_t isMCFromMBHeader = -1;
1463 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1464 isMCFromMBHeader
1465 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1466 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1467 }
1468
1469 if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
1470 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kFALSE)){
1471 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1472 if(particle->GetMother() >-1){ // Meson Decay Gamma
1473 switch((static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetMother())))->GetPdgCode()){
1474 case 111: // Pi0
1475 hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1476 break;
1477 case 113: // Rho0
1478 hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1479 break;
1480 case 221: // Eta
1481 hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1482 break;
1483 case 223: // Omega
1484 hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1485 break;
1486 case 331: // Eta'
1487 hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1488 break;
1489 case 333: // Phi
1490 hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1491 break;
1492 case 3212: // Sigma
1493 hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1494 break;
1495 }
1496 }
1497 }
1498 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(particle,AODMCTrackArray,kTRUE)){
1499 Double_t rConv = 0;
1500 for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
1501 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(daughterIndex));
1502 if(!tmpDaughter) continue;
1503 if(abs(tmpDaughter->GetPdgCode()) == 11){
1504 rConv = sqrt( (tmpDaughter->Xv()*tmpDaughter->Xv()) + (tmpDaughter->Yv()*tmpDaughter->Yv()) );
1505 }
1506 }
1507 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1508 if (fDoPhotonQA > 0){
1509 hMCConvGammaR[fiCut]->Fill(rConv);
1510 hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1511 }
1512 }
1513 // Converted MC Gamma
1514 if(fDoMesonAnalysis){
1515 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1516 Double_t mesonY = 10.;
1517 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1518 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1519 } else{
1520 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1521 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1522 }
1523 Float_t weightedK0s= 1;
1524 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1525 if (particle->Pt()>0.005){
1526 weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1527 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1528 }
1529 }
1530 hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1531 hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1532 hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1533 }
1534 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1535 ->MesonIsSelectedAODMC(particle,AODMCTrackArray,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1536 AliAODMCParticle* daughter0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(0)));
1537 AliAODMCParticle* daughter1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(particle->GetDaughter(1)));
1538 Float_t weighted= 1;
1539 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1540 if (particle->Pt()>0.005){
1541 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, 0x0, fInputEvent);
1542// if(particle->GetPdgCode() == 221){
1543// cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1544// }
1545 }
1546 }
1547 Double_t mesonY = 10.;
1548 if(particle->E() - particle->Pz() == 0 || particle->E() + particle->Pz() == 0){
1549 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1550 } else{
1551 mesonY = 0.5*(TMath::Log((particle->E()+particle->Pz()) / (particle->E()-particle->Pz())))
1552 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1553 }
1554
1555 if(particle->GetPdgCode() == 111){
1556 hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1557 hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1558 if (fDoMesonQA > 0) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1559 } else if(particle->GetPdgCode() == 221){
1560 hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1561 hMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
1562 if (fDoMesonQA > 0) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1563 }
1564
1565 // Check the acceptance for both gammas
1566 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter0,AODMCTrackArray,kFALSE) &&
1567 ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedAODMC(daughter1,AODMCTrackArray,kFALSE) &&
1568 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
1569 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
1570
1571 if(particle->GetPdgCode() == 111){
1572 hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1573 } else if(particle->GetPdgCode() == 221){
1574 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1575 }
1576 }
1577 }
1578 }
1579 }
1580
1581}
1582//________________________________________________________________________
1583void AliAnalysisTaskGammaConvV1::ProcessMCParticles()
1584{
1585 // Loop over all primary MC particle
1586 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
1587 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1588 if (!particle) continue;
1589
1590 Int_t isMCFromMBHeader = -1;
1591 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1592 isMCFromMBHeader
1593 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1594 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1595 }
1596
1597 if(!((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(particle->Phi(),fEventPlaneAngle,kFALSE)) continue;
1598 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
1599 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
1600 if(particle->GetMother(0) >-1){ // Meson Decay Gamma
1601 switch(fMCStack->Particle(particle->GetMother(0))->GetPdgCode()){
1602 case 111: // Pi0
1603 hMCDecayGammaPi0Pt[fiCut]->Fill(particle->Pt());
1604 break;
1605 case 113: // Rho0
1606 hMCDecayGammaRhoPt[fiCut]->Fill(particle->Pt());
1607 break;
1608 case 221: // Eta
1609 hMCDecayGammaEtaPt[fiCut]->Fill(particle->Pt());
1610 break;
1611 case 223: // Omega
1612 hMCDecayGammaOmegaPt[fiCut]->Fill(particle->Pt());
1613 break;
1614 case 331: // Eta'
1615 hMCDecayGammaEtapPt[fiCut]->Fill(particle->Pt());
1616 break;
1617 case 333: // Phi
1618 hMCDecayGammaPhiPt[fiCut]->Fill(particle->Pt());
1619 break;
1620 case 3212: // Sigma
1621 hMCDecayGammaSigmaPt[fiCut]->Fill(particle->Pt());
1622 break;
1623 }
1624 }
1625 }
1626 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
1627 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
1628 if (fDoPhotonQA > 0){
1629 hMCConvGammaR[fiCut]->Fill(((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R());
1630 hMCConvGammaEta[fiCut]->Fill(particle->Eta());
1631 }
1632 } // Converted MC Gamma
1633 if(fDoMesonAnalysis){
1634 if(particle->GetPdgCode() == 310 && fDoMesonQA > 0){
1635 Double_t mesonY = 10.;
1636 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1637 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1638 } else{
1639 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1640 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1641 }
1642 Float_t weightedK0s= 1;
1643 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1644 if (particle->Pt()>0.005){
1645 weightedK0s= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1646 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1647 }
1648 }
1649 if (fMCStack->IsPhysicalPrimary(i)){
1650 hMCK0sPt[fiCut]->Fill(particle->Pt(),weightedK0s);
1651 hMCK0sWOWeightPt[fiCut]->Fill(particle->Pt());
1652 hMCK0sPtY[fiCut]->Fill(particle->Pt(),mesonY,weightedK0s);
1653 }
1654 }
1655 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1656 ->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1657 TParticle* daughter0 = (TParticle*)fMCStack->Particle(particle->GetFirstDaughter());
1658 TParticle* daughter1 = (TParticle*)fMCStack->Particle(particle->GetLastDaughter());
1659
1660 Float_t weighted= 1;
1661 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1662 if (particle->Pt()>0.005){
1663 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1664// if(particle->GetPdgCode() == 221){
1665// cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1666// }
1667 }
1668 }
1669 Double_t mesonY = 10.;
1670 if(particle->Energy() - particle->Pz() == 0 || particle->Energy() + particle->Pz() == 0){
1671 mesonY=10.-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1672 } else{
1673 mesonY = 0.5*(TMath::Log((particle->Energy()+particle->Pz()) / (particle->Energy()-particle->Pz())))
1674 -((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift();
1675 }
1676
1677 if(particle->GetPdgCode() == 111){
1678 hMCPi0Pt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1679 hMCPi0WOWeightPt[fiCut]->Fill(particle->Pt());
1680 if (fDoMesonQA > 0) hMCPi0PtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1681 } else if(particle->GetPdgCode() == 221){
1682 hMCEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Eta
1683 hMCEtaWOWeightPt[fiCut]->Fill(particle->Pt());
1684 if (fDoMesonQA > 0) hMCEtaPtY[fiCut]->Fill(particle->Pt(),mesonY,weighted); // All MC Pi0
1685 }
1686
1687 // Check the acceptance for both gammas
1688 if(((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter0,fMCStack,kFALSE) &&
1689 ((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelectedMC(daughter1,fMCStack,kFALSE) &&
1690 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter0->Phi(),fEventPlaneAngle,kFALSE) &&
1691 ((AliConversionCuts*)fCutArray->At(fiCut))->InPlaneOutOfPlaneCut(daughter1->Phi(),fEventPlaneAngle,kFALSE)){
1692
1693 if(particle->GetPdgCode() == 111){
1694 hMCPi0InAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Pi0 with gamma in acc
1695 } else if(particle->GetPdgCode() == 221){
1696 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(),weighted); // MC Eta with gamma in acc
1697 }
1698 }
1699 }
1700 }
1701 }
1702
1703 if (fDoMesonQA){
1704 for(Int_t i = fMCStack->GetNprimary(); i < fMCStack->GetNtrack(); i++) {
1705 TParticle* particle = (TParticle *)fMCStack->Particle(i);
1706 if (!particle) continue;
1707
1708 Int_t isMCFromMBHeader = -1;
1709 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 0){
1710 isMCFromMBHeader
1711 = ((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent);
1712 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutArray->At(fiCut))->GetSignalRejection() != 3) continue;
1713 }
1714
1715 if(fDoMesonAnalysis){
1716 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1717 ->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
1718 Float_t weighted= 1;
1719 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
1720 if (particle->Pt()>0.005){
1721 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack, fInputEvent);
1722 // if(particle->GetPdgCode() == 221){
1723 // cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1724 // }
1725 }
1726 }
1727
1728 if(particle->GetPdgCode() == 111){
1729 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
1730 Int_t source = GetSourceClassification(111,pdgCode);
1731 hMCSecPi0PtvsSource[fiCut]->Fill(particle->Pt(),source,weighted); // All MC Pi0
1732 hMCSecPi0Source[fiCut]->Fill(pdgCode);
1733 } else if(particle->GetPdgCode() == 221){
1734 Int_t pdgCode = ((TParticle*)fMCStack->Particle( particle->GetFirstMother() ))->GetPdgCode();
1735 hMCSecEtaPt[fiCut]->Fill(particle->Pt(),weighted); // All MC Pi0
1736 hMCSecEtaSource[fiCut]->Fill(pdgCode);
1737 }
1738 }
1739 }
1740 }
1741 }
1742}
1743//________________________________________________________________________
1744void AliAnalysisTaskGammaConvV1::CalculatePi0Candidates(){
1745
1746 // Conversion Gammas
1747 if(fGammaCandidates->GetEntries()>1){
1748 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries()-1;firstGammaIndex++){
1749 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
1750 if (gamma0==NULL) continue;
1751 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
1752 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
1753 //Check for same Electron ID
1754 if (gamma1==NULL) continue;
1755 if(gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelPositive() ||
1756 gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelNegative() ||
1757 gamma0->GetTrackLabelNegative() == gamma1->GetTrackLabelPositive() ||
1758 gamma0->GetTrackLabelPositive() == gamma1->GetTrackLabelNegative() ) continue;
1759
1760 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma0,gamma1);
1761 pi0cand->SetLabels(firstGammaIndex,secondGammaIndex);
1762
1763 pi0cand->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
1764 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
1765 ->MesonIsSelected(pi0cand,kTRUE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
1766 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1767 if(pi0cand->GetAlpha()<0.1)
1768 hESDMotherInvMassEalpha[fiCut]->Fill(pi0cand->M(),pi0cand->E());
1769
1770 if (fDoMesonQA > 0){
1771 if ( pi0cand->M() > 0.05 && pi0cand->M() < 0.17){
1772 hESDMotherPi0PtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1773 hESDMotherPi0PtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1774 hESDMotherPi0PtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
1775
1776 }
1777 if ( pi0cand->M() > 0.45 && pi0cand->M() < 0.65){
1778 hESDMotherEtaPtY[fiCut]->Fill(pi0cand->Pt(),pi0cand->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1779 hESDMotherEtaPtAlpha[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetAlpha());
1780 hESDMotherEtaPtOpenAngle[fiCut]->Fill(pi0cand->Pt(),pi0cand->GetOpeningAngle());
1781 }
1782 }
1783 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGCalculation()){
1784 Int_t zbin = 0;
1785 Int_t mbin = 0;
1786
1787 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->BackgroundHandlerType() == 0){
1788 zbin = fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1789 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1790 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1791 } else {
1792 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1793 }
1794 }
1795 else{
1796 zbin = fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
1797 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
1798 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
1799 } else {
1800 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
1801 }
1802 }
1803 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1804 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1805 }
1806
1807
1808 if(fIsMC){
1809 if(fInputEvent->IsA()==AliESDEvent::Class())
1810 ProcessTrueMesonCandidates(pi0cand,gamma0,gamma1);
1811 if(fInputEvent->IsA()==AliAODEvent::Class())
1812 ProcessTrueMesonCandidatesAOD(pi0cand,gamma0,gamma1);
1813 }
1814 if (fDoMesonQA == 2){
1815 fInvMass = pi0cand->M();
1816 fPt = pi0cand->Pt();
1817 if (abs(gamma0->GetDCAzToPrimVtx()) < abs(gamma1->GetDCAzToPrimVtx())){
1818 fDCAzGammaMin = gamma0->GetDCAzToPrimVtx();
1819 fDCAzGammaMax = gamma1->GetDCAzToPrimVtx();
1820 } else {
1821 fDCAzGammaMin = gamma1->GetDCAzToPrimVtx();
1822 fDCAzGammaMax = gamma0->GetDCAzToPrimVtx();
1823 }
1824 iFlag = pi0cand->GetMesonQuality();
1825// cout << "gamma 0: " << gamma0->GetV0Index()<< "\t" << gamma0->GetPx() << "\t" << gamma0->GetPy() << "\t" << gamma0->GetPz() << "\t" << endl;
1826// cout << "gamma 1: " << gamma1->GetV0Index()<< "\t"<< gamma1->GetPx() << "\t" << gamma1->GetPy() << "\t" << gamma1->GetPz() << "\t" << endl;
1827// cout << "pi0: "<<fInvMass << "\t" << fPt <<"\t" << fDCAzGammaMin << "\t" << fDCAzGammaMax << "\t" << (Int_t)iFlag << "\t" << (Int_t)iMesonMCInfo <<endl;
1828 if (fIsHeavyIon == 1 && fPt > 0.399 && fPt < 20. ) {
1829 if (fInvMass > 0.08 && fInvMass < 0.2) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1830 if ((fInvMass > 0.45 && fInvMass < 0.6) && (fPt > 0.999 && fPt < 20.) )tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1831 } else if (fPt > 0.299 && fPt < 20. ) {
1832 if ( (fInvMass > 0.08 && fInvMass < 0.2) || (fInvMass > 0.45 && fInvMass < 0.6)) tESDMesonsInvMassPtDcazMinDcazMaxFlag[fiCut]->Fill();
1833 }
1834 }
1835 }
1836 delete pi0cand;
1837 pi0cand=0x0;
1838 }
1839 }
1840 }
1841}
1842//______________________________________________________________________
1843void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
1844{
1845 // Process True Mesons
1846 AliStack *MCStack = fMCEvent->Stack();
1847 iMesonMCInfo = 0;
1848 if(TrueGammaCandidate0->GetV0Index()<fInputEvent->GetNumberOfV0s()){
1849 Bool_t isTruePi0 = kFALSE;
1850 Bool_t isTrueEta = kFALSE;
1851 Bool_t isTruePi0Dalitz = kFALSE;
1852 Bool_t isTrueEtaDalitz = kFALSE;
1853 Bool_t gamma0DalitzCand = kFALSE;
1854 Bool_t gamma1DalitzCand = kFALSE;
1855 Int_t gamma0MCLabel = TrueGammaCandidate0->GetMCParticleLabel(MCStack);
1856 Int_t gamma0MotherLabel = -1;
1857 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1858 // Daughters Gamma 0
1859 TParticle * negativeMC = (TParticle*)TrueGammaCandidate0->GetNegativeMCDaughter(MCStack);
1860 TParticle * positiveMC = (TParticle*)TrueGammaCandidate0->GetPositiveMCDaughter(MCStack);
1861 TParticle * gammaMC0 = (TParticle*)MCStack->Particle(gamma0MCLabel);
1862 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1863 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1864 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
1865 gamma0MotherLabel=gammaMC0->GetFirstMother();
1866 }
1867 }
1868 if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate
1869 gamma0DalitzCand = kTRUE;
1870 gamma0MotherLabel=-111;
1871 }
1872 if(gammaMC0->GetPdgCode() ==221){ // Dalitz candidate
1873 gamma0DalitzCand = kTRUE;
1874 gamma0MotherLabel=-221;
1875 }
1876 }
1877 }
1878 if(TrueGammaCandidate1->GetV0Index()<fInputEvent->GetNumberOfV0s()){
1879 Int_t gamma1MCLabel = TrueGammaCandidate1->GetMCParticleLabel(MCStack);
1880 Int_t gamma1MotherLabel = -1;
1881 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1882 // Daughters Gamma 1
1883 TParticle * negativeMC = (TParticle*)TrueGammaCandidate1->GetNegativeMCDaughter(MCStack);
1884 TParticle * positiveMC = (TParticle*)TrueGammaCandidate1->GetPositiveMCDaughter(MCStack);
1885 TParticle * gammaMC1 = (TParticle*)MCStack->Particle(gamma1MCLabel);
1886 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1887 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
1888 if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
1889 gamma1MotherLabel=gammaMC1->GetFirstMother();
1890 }
1891 }
1892 if(gammaMC1->GetPdgCode() ==111 ){ // Dalitz candidate
1893 gamma1DalitzCand = kTRUE;
1894 gamma1MotherLabel=-111;
1895 }
1896 if(gammaMC1->GetPdgCode() ==221){ // Dalitz candidate
1897 gamma1DalitzCand = kTRUE;
1898 gamma1MotherLabel=-221;
1899 }
1900 }
1901 }
1902 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
1903 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 111){
1904 isTruePi0=kTRUE;
1905 }
1906 if(((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetPdgCode() == 221){
1907 isTrueEta=kTRUE;
1908 }
1909 }
1910
1911 //Identify Dalitz candidate
1912 if (gamma1DalitzCand || gamma0DalitzCand){
1913 if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){
1914 if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE;
1915 if (gamma0MotherLabel == -221) isTrueEtaDalitz = kTRUE;
1916 }
1917 if (gamma1DalitzCand && gamma1MCLabel >=0 && gamma1MCLabel==gamma0MotherLabel){
1918 if (gamma1MotherLabel == -111) isTruePi0Dalitz = kTRUE;
1919 if (gamma1MotherLabel == -221) isTrueEtaDalitz = kTRUE;
1920 }
1921 }
1922
1923
1924 if(isTruePi0 || isTrueEta){// True Pion or Eta
1925 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1926 if (fDoMesonQA > 0){
1927 if (isTruePi0){
1928 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
1929 hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1930 hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
1931 hESDTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
1932 }
1933 } else if (isTrueEta){
1934 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
1935 hESDTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
1936 hESDTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
1937 hESDTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
1938 }
1939 }
1940 }
1941 if(gamma0MotherLabel >= MCStack->GetNprimary()){ // Secondary Meson
1942 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gamma1MotherLabel))->GetMother(0);
1943 Float_t weightedSec= 1;
1944 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1945 weightedSec= ((AliConversionCuts*)fCutArray->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
1946 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
1947 }
1948 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1949 iMesonMCInfo = 2;
1950 if (secMotherLabel >-1){
1951 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==310){
1952 iMesonMCInfo = 4;
1953 hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1954 if (fDoMesonQA > 0)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
1955 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1956 }
1957 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==221){
1958 iMesonMCInfo = 3;
1959 hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1960 if (fDoMesonQA > 0)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
1961 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1962 }
1963 if(MCStack->Particle(secMotherLabel)->GetPdgCode()==3122){
1964 iMesonMCInfo = 7;
1965 hESDTrueSecondaryMotherFromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
1966 if (fDoMesonQA > 0)hESDTrueLambdaWithPi0DaughterMCPt[fiCut]
1967 ->Fill(MCStack->Particle(secMotherLabel)->Pt());
1968 }
1969 }
1970 }else{ // Only primary pi0 for efficiency calculation
1971 iMesonMCInfo = 6;
1972 Float_t weighted= 1;
1973 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, fMCStack, fInputEvent)){
1974 if (((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt()>0.005){
1975 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, fMCStack, fInputEvent);
1976// cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
1977 }
1978 }
1979 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1980 hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1981 pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
1982
1983
1984 if (fDoMesonQA > 0){
1985 if(isTruePi0){ // Only primary pi0 for resolution
1986 hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1987 }
1988 if (isTrueEta){ // Only primary eta for resolution
1989 hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),(Pi0Candidate->Pt()-((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt())/((TParticle*)MCStack->Particle(gamma1MotherLabel))->Pt(),weighted);
1990 }
1991 }
1992 }
1993 } else if(!isTruePi0 && !isTrueEta){ // Background
1994 if (fDoMesonQA > 0){
1995 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
1996 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1997 iMesonMCInfo = 1;
1998 } else { // No photon or without mother
1999 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2000 }
2001 }
2002 if( isTruePi0Dalitz || isTrueEtaDalitz ){
2003 // Dalitz
2004 iMesonMCInfo = 5;
2005 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2006 } else if (gamma0DalitzCand || gamma1DalitzCand){
2007 if (fDoMesonQA > 0)hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2008 }
2009 }
2010 }
2011 }
2012}
2013//______________________________________________________________________
2014void AliAnalysisTaskGammaConvV1::ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1)
2015{
2016
2017 // Process True Mesons
2018 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2019 Bool_t isTruePi0 = kFALSE;
2020 Bool_t isTrueEta = kFALSE;
2021 Bool_t isTruePi0Dalitz = kFALSE;
2022 Bool_t isTrueEtaDalitz = kFALSE;
2023 Bool_t gamma0DalitzCand = kFALSE;
2024 Bool_t gamma1DalitzCand = kFALSE;
2025
2026 AliAODMCParticle *positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelPositive()));
2027 AliAODMCParticle *negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate0->GetMCLabelNegative()));
2028
2029 iMesonMCInfo = 0;
2030 Int_t gamma0MCLabel = -1;
2031 Int_t gamma0MotherLabel = -1;
2032 if(!positiveMC||!negativeMC)
2033 return;
2034
2035 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
2036 gamma0MCLabel = positiveMC->GetMother();
2037 }
2038
2039 if(gamma0MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2040 // Daughters Gamma 0
2041 AliAODMCParticle * gammaMC0 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MCLabel));
2042 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2043 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
2044 if(gammaMC0->GetPdgCode() == 22){ // ... with Gamma Mother
2045 gamma0MotherLabel=gammaMC0->GetMother();
2046 }
2047 }
2048 if(gammaMC0->GetPdgCode() ==111){ // Dalitz candidate
2049 gamma0DalitzCand = kTRUE;
2050 gamma0MotherLabel=-111;
2051 }
2052 if(gammaMC0->GetPdgCode() ==221){ // Dalitz candidate
2053 gamma0DalitzCand = kTRUE;
2054 gamma0MotherLabel=-221;
2055 }
2056 }
2057 }
2058 positiveMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelPositive()));
2059 negativeMC = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(TrueGammaCandidate1->GetMCLabelNegative()));
2060
2061 Int_t gamma1MCLabel = -1;
2062 Int_t gamma1MotherLabel = -1;
2063 if(!positiveMC||!negativeMC)
2064 return;
2065
2066 if(positiveMC->GetMother()>-1&&(negativeMC->GetMother() == positiveMC->GetMother())){
2067 gamma1MCLabel = positiveMC->GetMother();
2068 }
2069 if(gamma1MCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2070 // Daughters Gamma 1
2071 AliAODMCParticle * gammaMC1 = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MCLabel));
2072 if(abs(negativeMC->GetPdgCode())==11 && abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2073 if(((positiveMC->GetMCProcessCode())) == 5 && ((negativeMC->GetMCProcessCode())) == 5){ // ... From Conversion ...
2074 if(gammaMC1->GetPdgCode() == 22){ // ... with Gamma Mother
2075 gamma1MotherLabel=gammaMC1->GetMother();
2076 }
2077 }
2078 if(gammaMC1->GetPdgCode() ==111 ){ // Dalitz candidate
2079 gamma1DalitzCand = kTRUE;
2080 gamma1MotherLabel=-111;
2081 }
2082 if(gammaMC1->GetPdgCode() ==221){ // Dalitz candidate
2083 gamma1DalitzCand = kTRUE;
2084 gamma1MotherLabel=-221;
2085 }
2086 }
2087 }
2088 if(gamma0MotherLabel>=0 && gamma0MotherLabel==gamma1MotherLabel){
2089 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 111){
2090 isTruePi0=kTRUE;
2091 }
2092 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetPdgCode() == 221){
2093 isTrueEta=kTRUE;
2094 }
2095 }
2096
2097 //Identify Dalitz candidate
2098 if (gamma1DalitzCand || gamma0DalitzCand){
2099 if (gamma0DalitzCand && gamma0MCLabel >=0 && gamma0MCLabel==gamma1MotherLabel){
2100 if (gamma0MotherLabel == -111) isTruePi0Dalitz = kTRUE;
2101 if (gamma0MotherLabel == -221) isTrueEtaDalitz = kTRUE;
2102 }
2103 if (gamma1DalitzCand && gamma1MCLabel >=0 && gamma1MCLabel==gamma0MotherLabel){
2104 if (gamma1MotherLabel == -111) isTruePi0Dalitz = kTRUE;
2105 if (gamma1MotherLabel == -221) isTrueEtaDalitz = kTRUE;
2106 }
2107 }
2108
2109 if(isTruePi0 || isTrueEta){// True Pion or Eta
2110 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2111 if (fDoMesonQA > 0){
2112 if (isTruePi0){
2113 if ( Pi0Candidate->M() > 0.05 && Pi0Candidate->M() < 0.17){
2114 hESDTruePi0PtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
2115 hESDTruePi0PtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2116 hESDTruePi0PtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2117 }
2118 } else if (isTrueEta){
2119 if ( Pi0Candidate->M() > 0.45 && Pi0Candidate->M() < 0.65){
2120 hESDTrueEtaPtY[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->Rapidity()-((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift());
2121 hESDTrueEtaPtAlpha[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetAlpha());
2122 hESDTrueEtaPtOpenAngle[fiCut]->Fill(Pi0Candidate->Pt(),Pi0Candidate->GetOpeningAngle());
2123 }
2124 }
2125 }
2126 if(!(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma0MotherLabel))->IsPrimary())){ // Secondary Meson
2127 Int_t secMotherLabel = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->GetMother();
2128 Float_t weightedSec= 1;
2129 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(secMotherLabel, 0x0, fInputEvent) && static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2130 weightedSec= ((AliConversionCuts*)fCutArray->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
2131 //cout << "MC input \t"<<i << "\t" << particle->Pt()<<"\t"<<weighted << endl;
2132 }
2133 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2134 iMesonMCInfo = 2;
2135 if (secMotherLabel >-1){
2136 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==310){
2137 iMesonMCInfo = 4;
2138 hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2139 if (fDoMesonQA > 0)hESDTrueK0sWithPi0DaughterMCPt[fiCut]
2140 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2141 }
2142 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==221){
2143 iMesonMCInfo = 3;
2144 hESDTrueSecondaryMotherFromEtaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2145 if (fDoMesonQA > 0)hESDTrueEtaWithPi0DaughterMCPt[fiCut]
2146 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2147 }
2148 if(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->GetPdgCode()==3122){
2149 iMesonMCInfo = 7;
2150 hESDTrueSecondaryMotherFromLambdaInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2151 if (fDoMesonQA > 0)hESDTrueLambdaWithPi0DaughterMCPt[fiCut]
2152 ->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(secMotherLabel))->Pt());
2153 }
2154 }
2155 }else{ // Only primary pi0 for efficiency calculation
2156 Float_t weighted= 1;
2157 iMesonMCInfo = 6;
2158 if(((AliConversionCuts*)fCutArray->At(fiCut))->IsParticleFromBGEvent(gamma1MotherLabel, 0x0, fInputEvent)){
2159 if (static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt()>0.005){
2160 weighted= ((AliConversionCuts*)fCutArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gamma1MotherLabel, 0x0, fInputEvent);
2161 // cout << "rec \t " <<gamma1MotherLabel << "\t" << weighted << endl;
2162 }
2163 }
2164 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2165 hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2166 pESDTruePrimaryMotherWeightsInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2167
2168 if (fDoMesonQA > 0){
2169 if(isTruePi0){ // Only primary pi0 for resolution
2170 hESDTruePrimaryPi0MCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2171 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2172
2173 }
2174 if (isTrueEta){ // Only primary eta for resolution
2175 hESDTruePrimaryEtaMCPtResolPt[fiCut]->Fill(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),
2176 (Pi0Candidate->Pt()-static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt())/static_cast<AliAODMCParticle*>(AODMCTrackArray->At(gamma1MotherLabel))->Pt(),weighted);
2177 }
2178 }
2179 }
2180 } else if(!isTruePi0 && !isTrueEta) { // Background
2181 if (fDoMesonQA > 0){
2182 if(gamma0MotherLabel>-1 && gamma1MotherLabel>-1){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2183 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2184 iMesonMCInfo = 1;
2185 } else { // No photon or without mother
2186 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2187 }
2188 }
2189 if( isTruePi0Dalitz || isTrueEtaDalitz ){
2190 // Dalitz
2191 iMesonMCInfo = 5;
2192 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2193 } else if (gamma0DalitzCand || gamma1DalitzCand){
2194 if (fDoMesonQA > 0)hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2195 }
2196 }
2197}
2198//________________________________________________________________________
2199void AliAnalysisTaskGammaConvV1::CalculateBackground(){
2200
2201 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2202 Int_t mbin = 0;
2203
2204 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2205 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2206 } else {
2207 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2208 }
2209
2210 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2211
2212 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2213 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2214 for(Int_t iCurrent2=iCurrent+1;iCurrent2<fGammaCandidates->GetEntries();iCurrent2++){
2215 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2216 AliAODConversionPhoton currentEventGoodV02 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent2));
2217
2218 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->DoBGProbability()){
2219 AliAODConversionMother *backgroundCandidateProb = new AliAODConversionMother(&currentEventGoodV0,&currentEventGoodV02);
2220 Double_t massBGprob = backgroundCandidateProb->M();
2221 if(massBGprob>0.1 && massBGprob<0.14){
2222 if(fRandom.Rndm()>fBGHandler[fiCut]->GetBGProb(zbin,mbin)){
2223 delete backgroundCandidateProb;
2224 continue;
2225 }
2226 }
2227 delete backgroundCandidateProb;
2228 backgroundCandidateProb = 0x0;
2229 }
2230
2231 RotateParticle(&currentEventGoodV02);
2232 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&currentEventGoodV02);
2233 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2234 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2235 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2236 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2237 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2238 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2239 }
2240 delete backgroundCandidate;
2241 backgroundCandidate = 0x0;
2242 }
2243 }
2244 }
2245 }else{
2246 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
2247
2248 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2249 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2250 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2251 if(fMoveParticleAccordingToVertex == kTRUE){
2252 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2253 }
2254
2255 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2256 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2257 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2258 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2259 if(fMoveParticleAccordingToVertex == kTRUE){
2260 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2261 }
2262 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2263 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2264 }
2265
2266 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2267 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2268 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2269 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2270 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2271 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2272 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2273 }
2274 delete backgroundCandidate;
2275 backgroundCandidate = 0x0;
2276 }
2277 }
2278 }
2279 }
2280 else{
2281 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2282 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2283 if(previousEventV0s){
2284 if(fMoveParticleAccordingToVertex == kTRUE){
2285 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2286 }
2287 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2288 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2289 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2290
2291 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2292
2293 if(fMoveParticleAccordingToVertex == kTRUE){
2294 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2295 }
2296 if(((AliConversionCuts*)fCutArray->At(fiCut))->GetInPlaneOutOfPlaneCut() != 0){
2297 RotateParticleAccordingToEP(&previousGoodV0,bgEventVertex->fEP,fEventPlaneAngle);
2298 }
2299
2300
2301 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2302 backgroundCandidate->CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2303 if((((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2304 ->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift()))){
2305 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2306 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2307 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2308 }
2309 delete backgroundCandidate;
2310 backgroundCandidate = 0x0;
2311 }
2312 }
2313 }
2314 }
2315 }
2316 }
2317}
2318//________________________________________________________________________
2319void AliAnalysisTaskGammaConvV1::CalculateBackgroundRP(){
2320
2321 Int_t zbin= fBGHandlerRP[fiCut]->GetZBinIndex(fInputEvent->GetPrimaryVertex()->GetZ());
2322 Int_t mbin = 0;
2323 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2324 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fV0Reader->GetNumberOfPrimaryTracks());
2325 } else {
2326 mbin = fBGHandlerRP[fiCut]->GetMultiplicityBinIndex(fGammaCandidates->GetEntries());
2327 }
2328
2329
2330 //Rotation Method
2331 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseRotationMethod()){
2332 // Correct for the number of rotations
2333 // BG is for rotation the same, except for factor NRotations
2334 Double_t weight=1./Double_t(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents());
2335
2336 for(Int_t firstGammaIndex=0;firstGammaIndex<fGammaCandidates->GetEntries();firstGammaIndex++){
2337
2338 AliAODConversionPhoton *gamma0=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(firstGammaIndex));
2339 if (gamma0==NULL) continue;
2340 for(Int_t secondGammaIndex=firstGammaIndex+1;secondGammaIndex<fGammaCandidates->GetEntries();secondGammaIndex++){
2341 AliAODConversionPhoton *gamma1=dynamic_cast<AliAODConversionPhoton*>(fGammaCandidates->At(secondGammaIndex));
2342 if (gamma1 == NULL) continue;
2343 if(!((AliConversionCuts*)fCutArray->At(fiCut))->PhotonIsSelected(gamma1,fInputEvent))continue;
2344 for(Int_t nRandom=0;nRandom<((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->GetNumberOfBGEvents();nRandom++){
2345
2346 RotateParticle(gamma1);
2347
2348 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2349 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2350 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2351 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
2352 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2353 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2354 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2355 }
2356 }
2357 }
2358 }
2359 }
2360 else{
2361 // Do Event Mixing
2362 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandlerRP[fiCut]->GetNBGEvents(fGammaCandidates,fInputEvent);nEventsInBG++){
2363
2364 AliGammaConversionPhotonVector *previousEventGammas = fBGHandlerRP[fiCut]->GetBGGoodGammas(fGammaCandidates,fInputEvent,nEventsInBG);
2365
2366 if(previousEventGammas){
2367 // test weighted background
2368 Double_t weight=1.0;
2369 // Correct for the number of eventmixing:
2370 // N gammas -> (N-1) + (N-2) +(N-3) ...+ (N-(N-1)) using sum formula sum(i)=N*(N-1)/2 -> N*(N-1)/2
2371 // real combinations (since you cannot combine a photon with its own)
2372 // but BG leads to N_{a}*N_{b} combinations
2373 weight*=0.5*(Double_t(fGammaCandidates->GetEntries()-1))/Double_t(previousEventGammas->size());
2374
2375 for(Int_t iCurrent=0;iCurrent<fGammaCandidates->GetEntries();iCurrent++){
2376
2377 AliAODConversionPhoton *gamma0 = (AliAODConversionPhoton*)(fGammaCandidates->At(iCurrent));
2378
2379 for(UInt_t iPrevious=0;iPrevious<previousEventGammas->size();iPrevious++){
2380
2381 AliAODConversionPhoton *gamma1 = (AliAODConversionPhoton*)(previousEventGammas->at(iPrevious));
2382
2383 AliAODConversionMother backgroundCandidate(gamma0,gamma1);
2384 backgroundCandidate.CalculateDistanceOfClossetApproachToPrimVtx(fInputEvent->GetPrimaryVertex());
2385 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))
2386 ->MesonIsSelected(&backgroundCandidate,kFALSE,((AliConversionCuts*)fCutArray->At(fiCut))->GetEtaShift())){
2387 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate.M(),backgroundCandidate.Pt());
2388 Double_t sparesFill[4] = {backgroundCandidate.M(),backgroundCandidate.Pt(),(Double_t)zbin,(Double_t)mbin};
2389 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,weight);
2390 }
2391 }
2392 }
2393 }
2394 }
2395 }
2396}
2397//________________________________________________________________________
2398void AliAnalysisTaskGammaConvV1::RotateParticle(AliAODConversionPhoton *gamma){
2399 Int_t fNDegreesPMBackground= ((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->NDegreesRotation();
2400 Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
2401 Double_t rotationValue = fRandom.Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
2402 gamma->RotateZ(rotationValue);
2403}
2404
2405//________________________________________________________________________
2406void AliAnalysisTaskGammaConvV1::RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP){
2407
2408 previousEventEP=previousEventEP+TMath::Pi();
2409 thisEventEP=thisEventEP+TMath::Pi();
2410 Double_t rotationValue= thisEventEP-previousEventEP;
2411 gamma->RotateZ(rotationValue);
2412}
2413
2414//________________________________________________________________________
2415void AliAnalysisTaskGammaConvV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
2416 //see header file for documentation
2417
2418 Double_t dx = vertex->fX - fInputEvent->GetPrimaryVertex()->GetX();
2419 Double_t dy = vertex->fY - fInputEvent->GetPrimaryVertex()->GetY();
2420 Double_t dz = vertex->fZ - fInputEvent->GetPrimaryVertex()->GetZ();
2421
2422 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
2423 particle->SetConversionPoint(movedPlace);
2424}
2425//________________________________________________________________________
2426void AliAnalysisTaskGammaConvV1::UpdateEventByEventData(){
2427 //see header file for documentation
2428 if(fGammaCandidates->GetEntries() >0 ){
2429 if(((AliConversionMesonCuts*)fMesonCutArray->At(fiCut))->UseTrackMultiplicity()){
2430 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fV0Reader->GetNumberOfPrimaryTracks(),fEventPlaneAngle);
2431 }
2432 else{ // means we use #V0s for multiplicity
2433 fBGHandler[fiCut]->AddEvent(fGammaCandidates,fInputEvent->GetPrimaryVertex()->GetX(),fInputEvent->GetPrimaryVertex()->GetY(),fInputEvent->GetPrimaryVertex()->GetZ(),fGammaCandidates->GetEntries(),fEventPlaneAngle);
2434 }
2435 }
2436}
2437
2438
2439//________________________________________________________________________
2440void AliAnalysisTaskGammaConvV1::FillPhotonCombinatorialBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode[])
2441{
2442 // 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
2443 if(pdgCode[0]==11 && pdgCode[1]==11){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),0);}
2444 else if( (pdgCode[0]==11 && pdgCode[1]==211) || (pdgCode[0]==211 && pdgCode[1]==11) )
2445 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),1);}
2446 else if( (pdgCode[0]==11 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==11) )
2447 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),2);}
2448 else if( (pdgCode[0]==11 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==11) )
2449 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),3);}
2450 else if( (pdgCode[0]==11 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==11) )
2451 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),4);}
2452 else if( pdgCode[0]==211 && pdgCode[1]==211 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),5);}
2453 else if( (pdgCode[0]==211 && pdgCode[1]==321) || (pdgCode[0]==321 && pdgCode[1]==211) )
2454 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),6);}
2455 else if( (pdgCode[0]==211 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==211) )
2456 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),7);}
2457 else if( (pdgCode[0]==211 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==211) )
2458 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),8);}
2459 else if( pdgCode[0]==321 && pdgCode[1]==321 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),9);}
2460 else if( (pdgCode[0]==321 && pdgCode[1]==2212) || (pdgCode[0]==2212 && pdgCode[1]==321) )
2461 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),10);}
2462 else if( (pdgCode[0]==321 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==321) )
2463 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),11);}
2464 else if( pdgCode[0]==2212 && pdgCode[1]==2212 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),12);}
2465 else if( (pdgCode[0]==2212 && pdgCode[1]==13) || (pdgCode[0]==13 && pdgCode[1]==2212) )
2466 {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),13);}
2467 else if( pdgCode[0]==13 && pdgCode[1]==13 ){if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),14);}
2468 else {if(fIsFromMBHeader)hESDCombinatorialPt[fiCut]->Fill(TruePhotonCandidate->Pt(),15);}
2469}
2470//________________________________________________________________________
2471void AliAnalysisTaskGammaConvV1::RelabelAODPhotonCandidates(Bool_t mode){
2472
2473 // Relabeling For AOD Event
2474 // ESDiD -> AODiD
2475 // MCLabel -> AODMCLabel
2476
2477 if(mode){
2478 fMCStackPos = new Int_t[fReaderGammas->GetEntries()];
2479 fMCStackNeg = new Int_t[fReaderGammas->GetEntries()];
2480 fESDArrayPos = new Int_t[fReaderGammas->GetEntries()];
2481 fESDArrayNeg = new Int_t[fReaderGammas->GetEntries()];
2482 }
2483
2484 for(Int_t iGamma = 0;iGamma<fReaderGammas->GetEntries();iGamma++){
2485 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(iGamma);
2486 if(!PhotonCandidate) continue;
2487 if(!mode){// Back to ESD Labels
2488 PhotonCandidate->SetMCLabelPositive(fMCStackPos[iGamma]);
2489 PhotonCandidate->SetMCLabelNegative(fMCStackNeg[iGamma]);
2490 PhotonCandidate->SetLabelPositive(fESDArrayPos[iGamma]);
2491 PhotonCandidate->SetLabelNegative(fESDArrayNeg[iGamma]);
2492 continue;
2493 }
2494 fMCStackPos[iGamma] = PhotonCandidate->GetMCLabelPositive();
2495 fMCStackNeg[iGamma] = PhotonCandidate->GetMCLabelNegative();
2496 fESDArrayPos[iGamma] = PhotonCandidate->GetTrackLabelPositive();
2497 fESDArrayNeg[iGamma] = PhotonCandidate->GetTrackLabelNegative();
2498
2499 Bool_t AODLabelPos = kFALSE;
2500 Bool_t AODLabelNeg = kFALSE;
2501
2502 for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
2503 AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
2504 if(!AODLabelPos){
2505 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
2506 PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
2507 PhotonCandidate->SetLabelPositive(i);
2508 AODLabelPos = kTRUE;
2509 }
2510 }
2511 if(!AODLabelNeg){
2512 if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
2513 PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
2514 PhotonCandidate->SetLabelNegative(i);
2515 AODLabelNeg = kTRUE;
2516 }
2517 }
2518 if(AODLabelNeg && AODLabelPos){
2519 break;
2520 }
2521 }
2522 if(!AODLabelPos || !AODLabelNeg){
2523 cout<<"WARNING!!! AOD TRACKS NOT FOUND FOR"<<endl;
2524 }
2525 }
2526
2527
2528 if(!mode){
2529 delete[] fMCStackPos;
2530 delete[] fMCStackNeg;
2531 delete[] fESDArrayPos;
2532 delete[] fESDArrayNeg;
2533 }
2534}
2535
2536void AliAnalysisTaskGammaConvV1::SetLogBinningXTH2(TH2* histoRebin){
2537 TAxis *axisafter = histoRebin->GetXaxis();
2538 Int_t bins = axisafter->GetNbins();
2539 Double_t from = axisafter->GetXmin();
2540 Double_t to = axisafter->GetXmax();
2541 Double_t *newbins = new Double_t[bins+1];
2542 newbins[0] = from;
2543 Double_t factor = TMath::Power(to/from, 1./bins);
2544 for(Int_t i=1; i<=bins; ++i) newbins[i] = factor * newbins[i-1];
2545 axisafter->Set(bins, newbins);
2546 delete [] newbins;
2547
2548}
2549
2550//________________________________________________________________________
2551void AliAnalysisTaskGammaConvV1::Terminate(const Option_t *)
2552{
2553
2554 //fOutputContainer->Print(); // Will crash on GRID
2555}
2556
2557//________________________________________________________________________
2558Int_t AliAnalysisTaskGammaConvV1::GetSourceClassification(Int_t daughter, Int_t pdgCode){
2559
2560 if (daughter == 111) {
2561 if (abs(pdgCode) == 310) return 1; // k0s
2562 else if (abs(pdgCode) == 3122) return 2; // Lambda
2563 else if (abs(pdgCode) == 130) return 3; // K0L
2564 else if (abs(pdgCode) == 2212) return 4; // proton
2565 else if (abs(pdgCode) == 2112) return 5; // neutron
2566 else if (abs(pdgCode) == 211) return 6; // pion
2567 else if (abs(pdgCode) == 321) return 7; // kaon
2568 else if (abs(pdgCode) == 113 || abs(pdgCode) == 213 ) return 8; // rho 0,+,-
2569 else if (abs(pdgCode) == 3222 || abs(pdgCode) == 3212 || abs(pdgCode) == 3112 ) return 9; // Sigma
2570 else if (abs(pdgCode) == 2224 || abs(pdgCode) == 2214 || abs(pdgCode) == 2114 || abs(pdgCode) == 1114 ) return 10; // Delta
2571 else if (abs(pdgCode) == 313 || abs(pdgCode) == 323 ) return 11; // K*
2572 else return 15;
2573 }
2574 return 15;
2575
2576}