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