]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/GammaConv/AliAnalysisTaskGammaConvDalitzV1.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- added additional event selection for LHC11a EMCAL analysis, due to hardware problem...
[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliAnalysisTaskGammaConvDalitzV1.cxx
CommitLineData
2bb2434e 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4803eb1f 4 * Author: Pedro Gonz??lez, Pedro Ladr??n de Guevara, Ernesto L??pez Torres, *
0f8c33c1 5 * Eulogio Serradilla, Ana Marin, Friederike Bock *
6 * Version 2 *
2bb2434e 7 * *
8 * Permission to use, copy, modify and distribute this software and its *
9 * documentation strictly for non-commercial purposes is hereby granted *
10 * without fee, provided that the above copyright notice appears in all *
11 * copies and that both the copyright notice and this permission notice *
12 * appear in the supporting documentation. The authors make no claims *
13 * about the suitability of this software for any purpose. It is *
14 * provided "as is" without express or implied warranty. *
15 **************************************************************************/
16
17// Analysis task for pi0->e+e-gamma (Dalitz decay)
0f8c33c1 18// Analysis task for chic->JPsi+gamma
2bb2434e 19
20#include <vector>
21
22#include "TParticle.h"
23#include "TPDGCode.h"
24#include "TMCProcess.h"
25#include "TDatabasePDG.h"
26#include "TList.h"
27#include "TChain.h"
28#include "TDirectory.h"
0a2b2b4b 29#include "TTree.h"
30#include "TH1.h"
31#include "TH1F.h"
32#include "THnSparse.h"
33#include "TH2F.h"
2bb2434e 34#include "AliStack.h"
35#include "AliAnalysisManager.h"
36#include "AliESDInputHandler.h"
37#include "AliESDtrack.h"
38#include "AliMCEvent.h"
39#include "AliStack.h"
40#include "AliMCEventHandler.h"
41#include "AliPID.h"
42#include "AliLog.h"
43#include "AliESDtrackCuts.h"
44#include "AliESDpidCuts.h"
45#include "AliMCEvent.h"
46#include "AliESDv0.h"
47#include "AliESDEvent.h"
48#include "AliESDpid.h"
49#include "AliKFParticle.h"
50#include "AliMCEventHandler.h"
51#include "AliKFVertex.h"
52#include "AliTriggerAnalysis.h"
53#include "AliCentrality.h"
54#include "AliMultiplicity.h"
55#include "AliAnalysisTaskGammaConvDalitzV1.h"
0a2b2b4b 56
2bb2434e 57
58ClassImp( AliAnalysisTaskGammaConvDalitzV1 )
59
60//-----------------------------------------------------------------------------------------------
61AliAnalysisTaskGammaConvDalitzV1::AliAnalysisTaskGammaConvDalitzV1():
344100c4 62 fV0Reader(NULL),
63 fElecSelector(NULL),
64 fBGHandler(NULL),
65 fESDEvent(NULL),
66 fMCEvent(NULL),
67 fMCStack(NULL),
68 fCutFolder(NULL),
69 fESDList(NULL),
70 fBackList(NULL),
71 fMotherList(NULL),
72 fTrueList(NULL),
73 fMCList(NULL),
74 fQAFolder(NULL),
75 fOutputContainer(0),
76 fReaderGammas(NULL),
77 fSelectorElectronIndex(0),
78 fSelectorPositronIndex(0),
79 fGoodGammas(NULL),
80 fGoodVirtualGammas(NULL),
81 fGoodElectrons(NULL),
82 fGoodPositrons(NULL),
83 fCutEventArray(NULL),
84 fCutGammaArray(NULL),
85 fCutElectronArray(NULL),
86 fCutMesonArray(NULL),
87 fGammasPool(NULL),
88 fEventCuts(NULL),
89 fConversionCuts(NULL),
90 hESDConvGammaPt(NULL),
91 hESDConvGammaEta(NULL),
92 hESDConvGammaZR(NULL),
93 hESDDalitzElectronPt(NULL),
94 hESDDalitzPositronPt(NULL),
95 hESDDalitzElectronPhi(NULL),
96 hESDDalitzPositronPhi(NULL),
97 hESDDalitzElectronAfterPt(NULL),
98 hESDDalitzPositronAfterPt(NULL),
99 hESDDalitzElectronAfterEta(NULL),
100 hESDDalitzElectronAfterEtaPCut(NULL),
101 hESDDalitzPositronAfterEta(NULL),
102 hESDDalitzPositronAfterEtaPCut(NULL),
103 hESDDalitzElectronAfterPhi(NULL),
104 hESDDalitzPositronAfterPhi(NULL),
105 hESDDalitzElectronAfterNClsITS(NULL),
106 hESDDalitzPositronAfterNClsITS(NULL),
107 hESDDalitzElectronAfterNFindClsTPC(NULL),
108 hESDDalitzPositronAfterNFindClsTPC(NULL),
109 hESDDalitzElectronAfterNClsTPC(NULL),
110 hESDDalitzPositronAfterNClsTPC(NULL),
111 hESDDalitzElectronAfterNCrossedRowsTPC(NULL),
112 hESDDalitzPositronAfterNCrossedRowsTPC(NULL),
113 hESDDalitzPosEleAfterDCAxy(NULL),
114 hESDDalitzPosEleAfterDCAz(NULL),
115 hESDDalitzElectronAfterTPCdEdxVsP(NULL),
116 hESDDalitzPositronAfterTPCdEdxVsP(NULL),
117 hESDDalitzElectronAfterTPCdEdxSignalVsP(NULL),
118 hESDDalitzPositronAfterTPCdEdxSignalVsP(NULL),
119 hESDDalitzElectronAfterTPCdEdxVsEta(NULL),
120 hESDDalitzPositronAfterTPCdEdxVsEta(NULL),
121 hESDDalitzElectronAfterTPCdEdxVsPhi(NULL),
122 hESDDalitzPositronAfterTPCdEdxVsPhi(NULL),
123 hESDMotherPhi(NULL),
124 hESDEposEnegPsiPairDPhi(NULL),
125 hESDEposEnegInvMassPt(NULL),
126 hESDEposEnegAfterMassCutInvMassPi0Pt(NULL),
127 hESDEposEnegInvMassPi0Pt(NULL),
128 hESDEposEnegLikeSignBackInvMassPt(NULL),
129 hESDMotherInvMassPt(NULL),
130 hESDPi0MotherInvMassPt(NULL),
131 hESDPi0MotherDiffInvMassPt(NULL),
132 hESDPi0MotherDiffLimInvMassPt(NULL),
133 sESDMotherInvMassPtZM(NULL),
134 hESDMotherBackInvMassPt(NULL),
135 sESDMotherBackInvMassPtZM(NULL),
136 hMCAllGammaPt(NULL),
137 hMCConvGammaPt(NULL),
138 hMCConvGammaRSPt(NULL),
139 hMCAllPositronsPt(NULL),
140 hMCAllElectronsPt(NULL),
141 hMCConvGammaEta(NULL),
5950ee43 142 hMCConvGammaR(NULL),
344100c4 143 hMCAllPositronsEta(NULL),
144 hMCAllElectronsEta(NULL),
145 hMCPi0DalitzGammaPt(NULL),
146 hMCPi0DalitzElectronPt(NULL),
147 hMCPi0DalitzPositronPt(NULL),
148 hMCPi0Pt(NULL),
149 hMCPi0GGPt(NULL),
150 hMCEtaPt(NULL),
151 hMCEtaGGPt(NULL),
152 hMCPi0InAccPt(NULL),
153 hMCEtaInAccPt(NULL),
154 hMCChiCPt(NULL),
155 hMCChiCInAccPt(NULL),
156 hMCPi0EposEnegInvMassPt(NULL),
157 hMCEtaEposEnegInvMassPt(NULL),
158 hESDEposEnegTruePi0DalitzInvMassPt(NULL),
159 hESDEposEnegTruePrimPi0DalitzInvMass(NULL),
160 hESDEposEnegTruePi0DalitzPsiPairDPhi(NULL),
161 hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
162 hESDEposEnegTruePrimEtaDalitzInvMass(NULL),
163 hESDEposEnegTrueEtaDalitzPsiPairDPhi(NULL),
164 hESDEposEnegTruePhotonInvMassPt(NULL),
165 hESDEposEnegTrueInvMassPt(NULL),
166 hESDEposEnegTruePhotonPsiPairDPhi(NULL),
167 hESDEposEnegTruePhotonPsiPairDPhiPtCut(NULL),
168 hESDEposEnegTrueJPsiInvMassPt(NULL),
169 hESDTrueMotherChiCInvMassPt(NULL),
170 hESDTrueMotherChiCDiffInvMassPt(NULL),
171 hESDTrueMotherInvMassPt(NULL),
172 hESDTrueMotherDalitzInvMassPt(NULL),
173 hESDTrueMotherPi0GGInvMassPt(NULL),
174 hESDTruePrimaryMotherPi0GGInvMassPt(NULL),
175 hESDTrueSecondaryMotherPi0GGInvMassPt(NULL),
176 hESDTruePrimaryMotherInvMassMCPt(NULL),
177 hESDTruePrimaryMotherInvMassPt(NULL),
178 hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
179 hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
180 hESDTrueSecondaryMotherInvMassPt(NULL),
181 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
182 hESDTrueBckGGInvMassPt(NULL),
183 hESDTrueBckContInvMassPt(NULL),
184 hESDTrueMotherGGInvMassPt(NULL),
185 hESDTrueConvGammaPt(NULL),
5950ee43 186 hESDTrueConvGammaR(NULL),
344100c4 187 hESDTruePositronPt(NULL),
188 hESDTrueElectronPt(NULL),
189 hESDTrueSecConvGammaPt(NULL),
190 hESDTrueSecPositronPt(NULL),
191 hESDTrueSecElectronPt(NULL),
192 hESDTruePi0DalitzConvGammaPt(NULL),
193 hESDTruePi0DalitzPositronPt(NULL),
194 hESDTruePi0DalitzElectronPt(NULL),
195 hESDTruePi0DalitzSecConvGammaPt(NULL),
196 hESDTruePi0DalitzSecPositronPt(NULL),
197 hESDTruePi0DalitzSecElectronPt(NULL),
198 hNEvents(NULL),
199 hNGoodESDTracks(NULL),
200 hNGoodESDTracksVsNGoodGammas(NULL),
201 hNGoodESDTracksVsNGoodVGammas(NULL),
202 hNV0Tracks(NULL),
203 hEtaShift(NULL),
204 fRandom(0),
205 fUnsmearedPx(NULL),
206 fUnsmearedPy(NULL),
207 fUnsmearedPz(NULL),
208 fUnsmearedE(NULL),
209 fUnsmearedVPx(NULL),
210 fUnsmearedVPy(NULL),
211 fUnsmearedVPz(NULL),
212 fUnsmearedVE(NULL),
213 fnCuts(0),
214 fiCut(0),
215 fNumberOfESDTracks(0),
216 fNumberOfESDTrackskBoth(0),
217 fNVirtualGammas(0),
218 fMoveParticleAccordingToVertex(kFALSE),
d964fbfc 219 fIsHeavyIon(0),
344100c4 220 fDoMesonAnalysis(kTRUE),
221 fDoChicAnalysis(kFALSE),
222 fDoMesonQA(kFALSE),
223 fSetProductionVertextoVGamma(kTRUE),
224 fIsFromMBHeader(kTRUE),
225 fIsMC(kFALSE)
2bb2434e 226{
a280ac15 227
2bb2434e 228}
229
230//-----------------------------------------------------------------------------------------------
231AliAnalysisTaskGammaConvDalitzV1::AliAnalysisTaskGammaConvDalitzV1( const char* name ):
344100c4 232 AliAnalysisTaskSE(name),
233 fV0Reader(NULL),
234 fElecSelector(NULL),
235 fBGHandler(NULL),
236 fESDEvent(NULL),
237 fMCEvent(NULL),
238 fMCStack(NULL),
239 fCutFolder(NULL),
240 fESDList(NULL),
241 fBackList(NULL),
242 fMotherList(NULL),
243 fTrueList(NULL),
244 fMCList(NULL),
245 fQAFolder(NULL),
246 fOutputContainer(0),
247 fReaderGammas(NULL),
248 fSelectorElectronIndex(0),
249 fSelectorPositronIndex(0),
250 fGoodGammas(NULL),
251 fGoodVirtualGammas(NULL),
252 fGoodElectrons(NULL),
253 fGoodPositrons(NULL),
254 fCutEventArray(NULL),
255 fCutGammaArray(NULL),
256 fCutElectronArray(NULL),
257 fCutMesonArray(NULL),
258 fGammasPool(NULL),
259 fEventCuts(NULL),
260 fConversionCuts(NULL),
261 hESDConvGammaPt(NULL),
262 hESDConvGammaEta(NULL),
263 hESDConvGammaZR(NULL),
264 hESDDalitzElectronPt(NULL),
265 hESDDalitzPositronPt(NULL),
266 hESDDalitzElectronPhi(NULL),
267 hESDDalitzPositronPhi(NULL),
268 hESDDalitzElectronAfterPt(NULL),
269 hESDDalitzPositronAfterPt(NULL),
270 hESDDalitzElectronAfterEta(NULL),
271 hESDDalitzElectronAfterEtaPCut(NULL),
272 hESDDalitzPositronAfterEta(NULL),
273 hESDDalitzPositronAfterEtaPCut(NULL),
274 hESDDalitzElectronAfterPhi(NULL),
275 hESDDalitzPositronAfterPhi(NULL),
276 hESDDalitzElectronAfterNClsITS(NULL),
277 hESDDalitzPositronAfterNClsITS(NULL),
278 hESDDalitzElectronAfterNFindClsTPC(NULL),
279 hESDDalitzPositronAfterNFindClsTPC(NULL),
280 hESDDalitzElectronAfterNClsTPC(NULL),
281 hESDDalitzPositronAfterNClsTPC(NULL),
282 hESDDalitzElectronAfterNCrossedRowsTPC(NULL),
283 hESDDalitzPositronAfterNCrossedRowsTPC(NULL),
284 hESDDalitzPosEleAfterDCAxy(NULL),
285 hESDDalitzPosEleAfterDCAz(NULL),
286 hESDDalitzElectronAfterTPCdEdxVsP(NULL),
287 hESDDalitzPositronAfterTPCdEdxVsP(NULL),
288 hESDDalitzElectronAfterTPCdEdxSignalVsP(NULL),
289 hESDDalitzPositronAfterTPCdEdxSignalVsP(NULL),
290 hESDDalitzElectronAfterTPCdEdxVsEta(NULL),
291 hESDDalitzPositronAfterTPCdEdxVsEta(NULL),
292 hESDDalitzElectronAfterTPCdEdxVsPhi(NULL),
293 hESDDalitzPositronAfterTPCdEdxVsPhi(NULL),
294 hESDMotherPhi(NULL),
295 hESDEposEnegPsiPairDPhi(NULL),
296 hESDEposEnegInvMassPt(NULL),
297 hESDEposEnegAfterMassCutInvMassPi0Pt(NULL),
298 hESDEposEnegInvMassPi0Pt(NULL),
299 hESDEposEnegLikeSignBackInvMassPt(NULL),
300 hESDMotherInvMassPt(NULL),
301 hESDPi0MotherInvMassPt(NULL),
302 hESDPi0MotherDiffInvMassPt(NULL),
303 hESDPi0MotherDiffLimInvMassPt(NULL),
304 sESDMotherInvMassPtZM(NULL),
305 hESDMotherBackInvMassPt(NULL),
306 sESDMotherBackInvMassPtZM(NULL),
307 hMCAllGammaPt(NULL),
308 hMCConvGammaPt(NULL),
309 hMCConvGammaRSPt(NULL),
310 hMCAllPositronsPt(NULL),
311 hMCAllElectronsPt(NULL),
312 hMCConvGammaEta(NULL),
5950ee43 313 hMCConvGammaR(NULL),
344100c4 314 hMCAllPositronsEta(NULL),
315 hMCAllElectronsEta(NULL),
316 hMCPi0DalitzGammaPt(NULL),
317 hMCPi0DalitzElectronPt(NULL),
318 hMCPi0DalitzPositronPt(NULL),
319 hMCPi0Pt(NULL),
320 hMCPi0GGPt(NULL),
321 hMCEtaPt(NULL),
322 hMCEtaGGPt(NULL),
323 hMCPi0InAccPt(NULL),
324 hMCEtaInAccPt(NULL),
325 hMCChiCPt(NULL),
326 hMCChiCInAccPt(NULL),
327 hMCPi0EposEnegInvMassPt(NULL),
328 hMCEtaEposEnegInvMassPt(NULL),
329 hESDEposEnegTruePi0DalitzInvMassPt(NULL),
330 hESDEposEnegTruePrimPi0DalitzInvMass(NULL),
331 hESDEposEnegTruePi0DalitzPsiPairDPhi(NULL),
332 hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
333 hESDEposEnegTruePrimEtaDalitzInvMass(NULL),
334 hESDEposEnegTrueEtaDalitzPsiPairDPhi(NULL),
335 hESDEposEnegTruePhotonInvMassPt(NULL),
336 hESDEposEnegTrueInvMassPt(NULL),
337 hESDEposEnegTruePhotonPsiPairDPhi(NULL),
338 hESDEposEnegTruePhotonPsiPairDPhiPtCut(NULL),
339 hESDEposEnegTrueJPsiInvMassPt(NULL),
340 hESDTrueMotherChiCInvMassPt(NULL),
341 hESDTrueMotherChiCDiffInvMassPt(NULL),
342 hESDTrueMotherInvMassPt(NULL),
343 hESDTrueMotherDalitzInvMassPt(NULL),
344 hESDTrueMotherPi0GGInvMassPt(NULL),
345 hESDTruePrimaryMotherPi0GGInvMassPt(NULL),
346 hESDTrueSecondaryMotherPi0GGInvMassPt(NULL),
347 hESDTruePrimaryMotherInvMassMCPt(NULL),
348 hESDTruePrimaryMotherInvMassPt(NULL),
349 hESDTruePrimaryMotherW0WeightingInvMassPt(NULL),
350 hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
351 hESDTrueSecondaryMotherInvMassPt(NULL),
352 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
353 hESDTrueBckGGInvMassPt(NULL),
354 hESDTrueBckContInvMassPt(NULL),
355 hESDTrueMotherGGInvMassPt(NULL),
356 hESDTrueConvGammaPt(NULL),
5950ee43 357 hESDTrueConvGammaR(NULL),
344100c4 358 hESDTruePositronPt(NULL),
359 hESDTrueElectronPt(NULL),
360 hESDTrueSecConvGammaPt(NULL),
361 hESDTrueSecPositronPt(NULL),
362 hESDTrueSecElectronPt(NULL),
363 hESDTruePi0DalitzConvGammaPt(NULL),
364 hESDTruePi0DalitzPositronPt(NULL),
365 hESDTruePi0DalitzElectronPt(NULL),
366 hESDTruePi0DalitzSecConvGammaPt(NULL),
367 hESDTruePi0DalitzSecPositronPt(NULL),
368 hESDTruePi0DalitzSecElectronPt(NULL),
369 hNEvents(NULL),
370 hNGoodESDTracks(NULL),
371 hNGoodESDTracksVsNGoodGammas(NULL),
372 hNGoodESDTracksVsNGoodVGammas(NULL),
373 hNV0Tracks(NULL),
374 hEtaShift(NULL),
375 fRandom(0),
376 fUnsmearedPx(NULL),
377 fUnsmearedPy(NULL),
378 fUnsmearedPz(NULL),
379 fUnsmearedE(NULL),
380 fUnsmearedVPx(NULL),
381 fUnsmearedVPy(NULL),
382 fUnsmearedVPz(NULL),
383 fUnsmearedVE(NULL),
384 fnCuts(0),
385 fiCut(0),
386 fNumberOfESDTracks(0),
387 fNumberOfESDTrackskBoth(0),
388 fNVirtualGammas(0),
389 fMoveParticleAccordingToVertex(kFALSE),
d964fbfc 390 fIsHeavyIon(0),
344100c4 391 fDoMesonAnalysis(kTRUE),
392 fDoChicAnalysis(kFALSE),
393 fDoMesonQA(kFALSE),
394 fSetProductionVertextoVGamma(kTRUE),
395 fIsFromMBHeader(kTRUE),
396 fIsMC(kFALSE)
2bb2434e 397{
344100c4 398 DefineOutput(1, TList::Class());
2bb2434e 399}
400
401//-----------------------------------------------------------------------------------------------
402AliAnalysisTaskGammaConvDalitzV1::~AliAnalysisTaskGammaConvDalitzV1()
403{
344100c4 404 //
405 // virtual destructor
406 //
407
408 cout<<"Destructor"<<endl;
409
410 if(fGoodGammas){
411 delete fGoodGammas;
412 fGoodGammas = 0x0;
413 }
414 if(fGoodVirtualGammas){
415 delete fGoodVirtualGammas;
416 fGoodVirtualGammas = 0x0;
417 }
418 if(fGoodElectrons){
419 delete fGoodElectrons;
420 fGoodElectrons = 0x0;
421 }
422 if(fGoodPositrons){
423 delete fGoodPositrons;
424 fGoodPositrons = 0x0;
425 }
426 if(fBGHandler){
427 delete[] fBGHandler;
428 fBGHandler = 0x0;
429 }
430 if( fGammasPool ){
431 delete[] fGammasPool;
432 fGammasPool = 0x0;
433 }
2bb2434e 434}
344100c4 435
2bb2434e 436//___________________________________________________________
437void AliAnalysisTaskGammaConvDalitzV1::InitBack(){
438
344100c4 439 const Int_t nDim = 4;
440 Int_t nBins[nDim] = {800,250,7,4};
441 Double_t xMin[nDim] = {0,0, 0,0};
442 Double_t xMax[nDim] = {0.8,25,7,4};
443
444 sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
445 sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
2bb2434e 446
344100c4 447 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
448
449 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
450
451 TString cutstringEvent = ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber();
452 TString cutstringElectron = ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
453 TString cutstringMeson = ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
454 TString cutstringGamma = ((AliConversionPhotonCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
455
456 Int_t collisionSystem = atoi((TString)(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber())(0,1));
457 Int_t centMin = atoi((TString)(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber())(1,1));
458 Int_t centMax = atoi((TString)(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber())(2,1));
459
460 if(collisionSystem == 1 || collisionSystem == 2 ||
461 collisionSystem == 5 || collisionSystem == 8 ||
462 collisionSystem == 9){
463 centMin = centMin*10;
464 centMax = centMax*10;
465 }
466 else if(collisionSystem == 3 || collisionSystem == 6){
467 centMin = centMin*5;
468 centMax = centMax*5;
469 }
470 else if(collisionSystem == 4 || collisionSystem == 7){
471 centMin = ((centMin*5)+45);
472 centMax = ((centMax*5)+45);
473 }
474
475
476 fBackList[iCut] = new TList();
477 fBackList[iCut]->SetName(Form("%s_%s_%s_%s Back histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
478 fBackList[iCut]->SetOwner(kTRUE);
479 fCutFolder[iCut]->Add(fBackList[iCut]);
480
481 sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
482 fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
483
484 fMotherList[iCut] = new TList();
485 fMotherList[iCut]->SetName(Form("%s_%s_%s_%s Mother histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
486 fMotherList[iCut]->SetOwner(kTRUE);
487 fCutFolder[iCut]->Add(fMotherList[iCut]);
488
489 sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
490 fMotherList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
491
492
493 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
494 collisionSystem,centMin,centMax,
495 ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->NumberOfRotationEvents(),
cfd87ccd 496 ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->UseTrackMultiplicity(),
497 1,8,5);
344100c4 498
499 if( ( (AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetBKGMethod() == 3 ){
500 fGammasPool[iCut] = new TList();
501 }
502
503 }
2bb2434e 504}
505
506//______________________________________________________________________
507void AliAnalysisTaskGammaConvDalitzV1::UserCreateOutputObjects()
508{
344100c4 509 //
510 // Create ouput objects
511 //
512
513 // Create the output container
514 if(fOutputContainer != NULL){
515 delete fOutputContainer;
516 fOutputContainer = NULL;
517 }
518 if(fOutputContainer == NULL){
519 fOutputContainer = new TList();
520 fOutputContainer->SetOwner(kTRUE);
521 }
522
523 fGoodGammas = new TList();
524 //fGoodGammas->SetOwner(kTRUE);
525
526 fGoodVirtualGammas = new TList();
527 fGoodVirtualGammas->SetOwner(kTRUE);
528
529 fGammasPool = new TList*[fnCuts];
530 fCutFolder = new TList*[fnCuts];
531 fESDList = new TList*[fnCuts];
532 fBackList = new TList*[fnCuts];
533 fMotherList = new TList*[fnCuts];
534 hNEvents = new TH1I*[fnCuts];
535 hNGoodESDTracks = new TH1I*[fnCuts];
536 hNV0Tracks = new TH1I*[fnCuts];
537 hEtaShift = new TProfile*[fnCuts];
538 hESDConvGammaPt = new TH1F*[fnCuts];
539 hESDConvGammaEta = new TH1F*[fnCuts];
fcc79cf5 540
344100c4 541 hESDDalitzElectronPt = new TH1F*[fnCuts];
542 hESDDalitzPositronPt = new TH1F*[fnCuts];
543 hESDDalitzElectronPhi = new TH1F*[fnCuts];
544 hESDDalitzPositronPhi = new TH1F*[fnCuts];
545
546 if( fDoMesonQA ) {
547 fQAFolder = new TList*[fnCuts];
548 hNGoodESDTracksVsNGoodGammas = new TH2F*[fnCuts];
549 hNGoodESDTracksVsNGoodVGammas = new TH2F*[fnCuts];
550 hESDDalitzElectronAfterPt = new TH1F*[fnCuts];
551 hESDDalitzPositronAfterPt = new TH1F*[fnCuts];
552 hESDDalitzElectronAfterEta = new TH1F*[fnCuts];
553 hESDDalitzElectronAfterEtaPCut = new TH1F*[fnCuts];
554 hESDDalitzPositronAfterEta = new TH1F*[fnCuts];
555 hESDDalitzPositronAfterEtaPCut = new TH1F*[fnCuts];
556 hESDDalitzElectronAfterPhi = new TH1F*[fnCuts];
557 hESDDalitzPositronAfterPhi = new TH1F*[fnCuts];
558 hESDDalitzElectronAfterNClsITS = new TH1F*[fnCuts];
559 hESDDalitzPositronAfterNClsITS = new TH1F*[fnCuts];
560 hESDDalitzElectronAfterNFindClsTPC = new TH2F*[fnCuts];
561 hESDDalitzPositronAfterNFindClsTPC = new TH2F*[fnCuts];
562 hESDDalitzElectronAfterNClsTPC = new TH2F*[fnCuts];
563 hESDDalitzPositronAfterNClsTPC = new TH2F*[fnCuts];
564 hESDDalitzElectronAfterNCrossedRowsTPC = new TH2F*[fnCuts];
565 hESDDalitzPositronAfterNCrossedRowsTPC = new TH2F*[fnCuts];
566 hESDDalitzPosEleAfterDCAxy = new TH2F*[fnCuts];
567 hESDDalitzPosEleAfterDCAz = new TH2F*[fnCuts];
568 hESDDalitzElectronAfterTPCdEdxVsP = new TH2F*[fnCuts];
569 hESDDalitzPositronAfterTPCdEdxVsP = new TH2F*[fnCuts];
570 hESDDalitzElectronAfterTPCdEdxSignalVsP = new TH2F*[fnCuts];
571 hESDDalitzPositronAfterTPCdEdxSignalVsP = new TH2F*[fnCuts];
572 hESDDalitzElectronAfterTPCdEdxVsEta = new TH2F*[fnCuts];
573 hESDDalitzPositronAfterTPCdEdxVsEta = new TH2F*[fnCuts];
574 hESDDalitzElectronAfterTPCdEdxVsPhi = new TH2F*[fnCuts];
575 hESDDalitzPositronAfterTPCdEdxVsPhi = new TH2F*[fnCuts];
576 hESDMotherPhi = new TH1F*[fnCuts];
577 hESDEposEnegPsiPairDPhi = new TH2F*[fnCuts];
578 hESDEposEnegInvMassPt = new TH2F*[fnCuts];
579 hESDEposEnegAfterMassCutInvMassPi0Pt = new TH2F*[fnCuts];
580 hESDEposEnegInvMassPi0Pt = new TH2F*[fnCuts];
581 hESDEposEnegLikeSignBackInvMassPt = new TH2F*[fnCuts];
582 hESDConvGammaZR = new TH2F*[fnCuts];
583 }
584
585
586
587 hESDMotherInvMassPt = new TH2F*[fnCuts];
588 if(fDoChicAnalysis) {
589 hESDPi0MotherInvMassPt = new TH2F*[fnCuts];
590 hESDPi0MotherDiffInvMassPt = new TH2F*[fnCuts];
591 hESDPi0MotherDiffLimInvMassPt = new TH2F*[fnCuts];
592 }
593 hESDMotherBackInvMassPt = new TH2F*[fnCuts];
594
595
596 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
597
598 TString cutstringEvent = ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber();
599 TString cutstringElectron = ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
600 TString cutstringMeson = ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
601 TString cutstringGamma = ((AliConversionPhotonCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
602
603 fCutFolder[iCut] = new TList();
604 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s_%s",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
605 fCutFolder[iCut]->SetOwner(kTRUE);
606 fOutputContainer->Add(fCutFolder[iCut]);
607
608 fESDList[iCut] = new TList();
609 fESDList[iCut]->SetName(Form("%s_%s_%s_%s ESD histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
610 fESDList[iCut]->SetOwner(kTRUE);
611
7f070437 612 hNEvents[iCut] = new TH1I("NEvents","NEvents",10,-0.5,9.5);
344100c4 613 hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
614 hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
615 hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
616 hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
617 hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
618 hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
619 hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
620 hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
621 hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
7f070437 622 hNEvents[iCut]->GetXaxis()->SetBinLabel(10,"EMCAL problem");
344100c4 623 fESDList[iCut]->Add(hNEvents[iCut]);
624
d964fbfc 625 if(fIsHeavyIon == 1 || fIsHeavyIon == 2) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",3000,0,3000);
344100c4 626 else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
627 fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
628
629
630 if(fIsHeavyIon == 1) hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",30000,0,30000);
631 else if(fIsHeavyIon == 2) hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",2500,0,2500);
632 else hNV0Tracks[iCut] = new TH1I("V0 Multiplicity","V0 Multiplicity",1500,0,1500);
633 fESDList[iCut]->Add(hNV0Tracks[iCut]);
634
635 hEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
636 fESDList[iCut]->Add(hEtaShift[iCut]);
637
638 hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
639 fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
640
641 hESDConvGammaEta[iCut] = new TH1F("ESD_ConvGamma_Eta","ESD_ConvGamma_Eta",600,-1.5,1.5);
642 fESDList[iCut]->Add(hESDConvGammaEta[iCut]);
643
644 hESDDalitzElectronPt[iCut] = new TH1F("ESD_DalitzElectron_Pt","ESD_DalitzElectron_Pt",1000,0,25);
645 fESDList[iCut]->Add(hESDDalitzElectronPt[iCut]);
646
647 hESDDalitzPositronPt[iCut] = new TH1F("ESD_DalitzPositron_Pt","ESD_DalitzPositron_Pt",1000,0,25);
648 fESDList[iCut]->Add(hESDDalitzPositronPt[iCut]);
d9d6352b 649
344100c4 650
651 hESDDalitzElectronPhi[iCut] = new TH1F("ESD_DalitzElectron_Phi","ESD_DalitzElectron_Phi",360,0,2*TMath::Pi());
652 fESDList[iCut]->Add(hESDDalitzElectronPhi[iCut]);
653
654 hESDDalitzPositronPhi[iCut] = new TH1F("ESD_DalitzPositron_Phi","ESD_DalitzPositron_Phi",360,0,2*TMath::Pi());
655 fESDList[iCut]->Add(hESDDalitzPositronPhi[iCut]);
656
657
658
659 if ( fDoMesonQA ) {
660
661 fQAFolder[iCut] = new TList();
662 fQAFolder[iCut]->SetName(Form("%s_%s_%s_%s QA histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
663 fQAFolder[iCut]->SetOwner(kTRUE);
664
665 const Int_t kPtBins=110;
666 Double_t binsPtDummy[kPtBins+1];
667 const Int_t kPBins = 109;
668 Double_t binsPDummy[kPBins+1];
669 binsPtDummy[0]=0.0;
670 binsPDummy[0]=0.05;
671
672 for(Int_t i=1;i<kPtBins+1;i++){
673 if(binsPtDummy[i-1]+0.05<1.01)
674 binsPtDummy[i]=binsPtDummy[i-1]+0.05;
675 else
676 binsPtDummy[i]=binsPtDummy[i-1]+0.1;
677 }
678 for(Int_t i=1; i<kPBins+1;i++){
679 if( binsPDummy[i-1]+0.05<1.01)
680 binsPDummy[i] = binsPDummy[i-1]+0.05;
681 else
682 binsPDummy[i] = binsPDummy[i-1]+0.1;
683 }
684
685 hNGoodESDTracksVsNGoodGammas[iCut] = new TH2F("hNGoodESDTracksVsNGoodGammas","hNGoodESDTracksVsNGoodGammas",200,-0.5,199.5,100,-0.5,99.5);
686 fQAFolder[iCut]->Add(hNGoodESDTracksVsNGoodGammas[iCut]);
687
688 hNGoodESDTracksVsNGoodVGammas[iCut] = new TH2F("hNGoodESDTracksVsNVGoodVGammas","hNGoodESDTracksVsNGoodVGammas",200,-0.5,199.5,100,-0.5,99.5);
689 fQAFolder[iCut]->Add(hNGoodESDTracksVsNGoodVGammas[iCut]);
690
691 hESDConvGammaZR[iCut]= new TH2F("ESD_ConvGamma_ConversionPoint_ZR","ESD_ConvGamma_ConversionPoint_ZR",1200,-150,150,480,0,120);
692 fQAFolder[iCut]->Add(hESDConvGammaZR[iCut]);
693
694 hESDDalitzElectronAfterPt[iCut] = new TH1F("ESD_DalitzElectron_After_Pt","ESD_DalitzElectron_After_Pt",1000,0,25);
695 fQAFolder[iCut]->Add(hESDDalitzElectronAfterPt[iCut]);
696
697 hESDDalitzPositronAfterPt[iCut] = new TH1F("ESD_DalitzPositron_After_Pt","ESD_DalitzPositron_After_Pt",1000,0,25);
698 fQAFolder[iCut]->Add(hESDDalitzPositronAfterPt[iCut]);
699
700 hESDDalitzElectronAfterEta[iCut] = new TH1F("ESD_DalitzElectron_After_Eta","ESD_DalitzElectron_After_Eta",600,-1.5,1.5);
701 fQAFolder[iCut]->Add(hESDDalitzElectronAfterEta[iCut]);
702
703 hESDDalitzElectronAfterEtaPCut[iCut] = new TH1F("ESD_DalitzElectron_After_Eta_PCut","ESD_DalitzElectron_After_Eta_PCut",600,-1.5,1.5);
704 fQAFolder[iCut]->Add(hESDDalitzElectronAfterEtaPCut[iCut]);
705
706 hESDDalitzPositronAfterEta[iCut] = new TH1F("ESD_DalitzPositron_After_Eta","ESD_DalitzElectron_After_Eta",600,-1.5,1.5);
707 fQAFolder[iCut]->Add(hESDDalitzPositronAfterEta[iCut]);
708
709 hESDDalitzPositronAfterEtaPCut[iCut] = new TH1F("ESD_DalitzPositron_After_Eta_PCut","ESD_DalitzElectron_After_Eta_PCut",600,-1.5,1.5);
710 fQAFolder[iCut]->Add(hESDDalitzPositronAfterEtaPCut[iCut]);
711
712 hESDDalitzElectronAfterPhi[iCut] = new TH1F("ESD_DalitzElectron_After_Phi","ESD_DalitzElectron_After_Phi",360,0,2*TMath::Pi());
713 fQAFolder[iCut]->Add(hESDDalitzElectronAfterPhi[iCut]);
714
715 hESDDalitzPositronAfterPhi[iCut] = new TH1F("ESD_DalitzPositron_After_Phi","ESD_DalitzPositron_After_Phi",360,0,2*TMath::Pi());
716 fQAFolder[iCut]->Add(hESDDalitzPositronAfterPhi[iCut]);
717
718 hESDDalitzElectronAfterNClsITS[iCut] = new TH1F("ESD_DalitzElectron_After_NClsITS","ESD_DalitzElectron_After_NClsITS",7,0.,7.);
719 fQAFolder[iCut]->Add(hESDDalitzElectronAfterNClsITS[iCut]);
720
721 hESDDalitzPositronAfterNClsITS[iCut] = new TH1F("ESD_DalitzPositron_After_NClsITS","ESD_DalitzPositron_After_NClsITS",7,0.,7.);
722 fQAFolder[iCut]->Add(hESDDalitzPositronAfterNClsITS[iCut]);
723
724 hESDDalitzElectronAfterNFindClsTPC[iCut] = new TH2F("ESD_DalitzElectron_After_NFindClsTPC","ESD_DalitzElectron_After_NFindClsTPC",60,0,1.5,kPtBins,binsPtDummy);
725 fQAFolder[iCut]->Add(hESDDalitzElectronAfterNFindClsTPC[iCut]);
726
727 hESDDalitzPositronAfterNFindClsTPC[iCut] = new TH2F("ESD_DalitzPositron_After_NFindClsTPC","ESD_DalitzPositron_After_NFindClsTPC",60,0,1.5,kPtBins,binsPtDummy);
728 fQAFolder[iCut]->Add(hESDDalitzPositronAfterNFindClsTPC[iCut]);
729
730 hESDDalitzElectronAfterNClsTPC[iCut] = new TH2F("ESD_DalitzElectron_After_NClsTPC","ESD_DalitzElectron_After_NClsTPC",200,0,200,kPtBins,binsPtDummy);
731 fQAFolder[iCut]->Add(hESDDalitzElectronAfterNClsTPC[iCut]);
732
733 hESDDalitzPositronAfterNClsTPC[iCut] = new TH2F("ESD_DalitzPositron_After_NClsTPC","ESD_DalitzPositron_After_NClsTPC",200,0,200,kPtBins,binsPtDummy);
734 fQAFolder[iCut]->Add(hESDDalitzPositronAfterNClsTPC[iCut]);
735
736 hESDDalitzPositronAfterNCrossedRowsTPC[iCut] = new TH2F("ESD_DalitzPositron_After_NCrossedRowsTPC","ESD_DalitzPositron_After_NCrossedRowsTPC",165,-0.5,164.5,kPtBins,binsPtDummy);
737 fQAFolder[iCut]->Add(hESDDalitzPositronAfterNCrossedRowsTPC[iCut]);
738
739 hESDDalitzElectronAfterNCrossedRowsTPC[iCut] = new TH2F("ESD_DalitzElectron_After_NCrossedRowsTPC","ESD_DalitzElectron_After_NCrossedRowsTPC",165,-0.5,164.5,kPtBins,binsPtDummy);
740 fQAFolder[iCut]->Add(hESDDalitzElectronAfterNCrossedRowsTPC[iCut]);
741
742 hESDDalitzPosEleAfterDCAxy[iCut] = new TH2F("ESD_DalitzPosEle_After_DCAxy","ESD_DalitzPosEle_After_DCAxy",124,-0.62,0.62,kPtBins,binsPtDummy);
743 fQAFolder[iCut]->Add(hESDDalitzPosEleAfterDCAxy[iCut]);
744
745 hESDDalitzPosEleAfterDCAz[iCut] = new TH2F("ESD_DalitzPosEle_After_DCAz","ESD_DalitzPosEle_After_DCAz",200,-1.0,1.0,kPtBins,binsPtDummy);
746 fQAFolder[iCut]->Add(hESDDalitzPosEleAfterDCAz[iCut]);
747
748 hESDDalitzElectronAfterTPCdEdxVsP[iCut] = new TH2F("ESD_DalitzElectron_After_TPCdEdxVsP","ESD_DalitzElectron_After_TPCdEdxVsP_After_TPCdEdx",kPBins,binsPDummy,200,-10,10);
749 fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxVsP[iCut]);
750
751 hESDDalitzPositronAfterTPCdEdxVsP[iCut] = new TH2F("ESD_DalitzPositron_After_TPCdEdxVsP","ESD_DalitzPositron_After_TPCdEdxVsP",kPBins,binsPDummy,200,-10,10);
752 fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxVsP[iCut]);
753
754 hESDDalitzElectronAfterTPCdEdxSignalVsP[iCut] =new TH2F("ESD_DalitzElectron_After_TPCdEdxSignalVsP","ESD_DalitzElectron_After_TPCdEdxSignalVsP" ,kPBins,binsPDummy,200,0.0,200);
755 fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxSignalVsP[iCut]);
756
757 hESDDalitzPositronAfterTPCdEdxSignalVsP[iCut] =new TH2F("ESD_DalitzPositron_After_TPCdEdxSignalVsP","ESD_DalitzPositron_After_TPCdEdxSignalVsP" ,kPBins,binsPDummy,200,0.0,200);
758 fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxSignalVsP[iCut]);
759
760 hESDDalitzElectronAfterTPCdEdxVsEta[iCut] = new TH2F("ESD_DalitzElectron_After_TPCdEdxVsEta","ESD_DalitzElectron_After_TPCdEdxVsEta",140,-1.4,1.4,200,-10,10);
761 fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxVsEta[iCut]);
762
763 hESDDalitzPositronAfterTPCdEdxVsEta[iCut] = new TH2F("ESD_DalitzPositron_After_TPCdEdxVsEta","ESD_DalitzPositron_After_TPCdEdxVsEta",140,-1.4,1.4,200,-10,10);
764 fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxVsEta[iCut]);
765
766 hESDDalitzElectronAfterTPCdEdxVsPhi[iCut] = new TH2F("ESD_DalitzElectron_After_TPCdEdxVsPhi","ESD_DalitzElectron_After_TPCdEdxVsPhi",180,0,2*TMath::Pi(),200,-10,10);
767 fQAFolder[iCut]->Add(hESDDalitzElectronAfterTPCdEdxVsPhi[iCut]);
768
769 hESDDalitzPositronAfterTPCdEdxVsPhi[iCut] = new TH2F("ESD_DalitzPositron_After_TPCdEdxVsPhi","ESD_DalitzPositron_After_TPCdEdxVsPhi",180,0,2*TMath::Pi(),200,-10,10);
770 fQAFolder[iCut]->Add(hESDDalitzPositronAfterTPCdEdxVsPhi[iCut]);
771
772 hESDMotherPhi[iCut] = new TH1F("ESD_DalitzMother_Phi","ESD_DalitzMother_Phi",360,0,2*TMath::Pi());
773 fQAFolder[iCut]->Add(hESDMotherPhi[iCut]);
774
775 hESDEposEnegPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_PsiPair_DPhi","ESD_EposEneg_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
776 fQAFolder[iCut]->Add(hESDEposEnegPsiPairDPhi[iCut]);
777
778 hESDEposEnegInvMassPt[iCut] = new TH2F("ESD_EposEneg_InvMassPt","ESD_EposEneg_InvMassPt",4000,0.0,2.0,100,0.,10.);
779 fQAFolder[iCut]->Add(hESDEposEnegInvMassPt[iCut]);
780
781 hESDEposEnegAfterMassCutInvMassPi0Pt[iCut] = new TH2F("ESD_EposEneg_AfterMassCut_InvMassPi0Pt","ESD_EposEneg_AfterMassCut_InvMassPi0Pt",4000,0.0,2.0,100,0.,10.);
782 fQAFolder[iCut]->Add(hESDEposEnegAfterMassCutInvMassPi0Pt[iCut]);
783
784 hESDEposEnegInvMassPi0Pt[iCut] = new TH2F("ESD_EposEneg_InvMassPi0Pt","ESD_EposEneg_InvMassPi0Pt",1000,0.0,0.5,100,0.,10.);
785 fQAFolder[iCut]->Add(hESDEposEnegInvMassPi0Pt[iCut]);
786
787 hESDEposEnegLikeSignBackInvMassPt[iCut] = new TH2F("ESD_EposEneg_LikeSignBack_InvMassPt","ESD_EposEneg_LikeSignBack_InvMassPt",4000,0.0,2.,100,0.,10.);
788 fQAFolder[iCut]->Add(hESDEposEnegLikeSignBackInvMassPt[iCut]);
789
790 TAxis *AxisAfter = hESDDalitzElectronAfterTPCdEdxVsP[iCut]->GetXaxis();
791 Int_t bins = AxisAfter->GetNbins();
792 Double_t from = AxisAfter->GetXmin();
793 Double_t to = AxisAfter->GetXmax();
794 Double_t *newBins = new Double_t[bins+1];
795 newBins[0] = from;
796 Double_t factor = TMath::Power(to/from, 1./bins);
797 for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];
798
799 AxisAfter->Set(bins, newBins);
800 AxisAfter = hESDDalitzElectronAfterTPCdEdxSignalVsP[iCut]->GetXaxis();
801 AxisAfter->Set(bins, newBins);
802
803 AxisAfter = hESDDalitzPositronAfterTPCdEdxVsP[iCut]->GetXaxis();
804 AxisAfter->Set(bins, newBins);
805
806 AxisAfter = hESDDalitzPositronAfterTPCdEdxSignalVsP[iCut]->GetXaxis();
807 AxisAfter->Set(bins,newBins);
808
809 delete [] newBins;
810
811 fCutFolder[iCut]->Add(fQAFolder[iCut]);
812 }
813
814 hESDMotherInvMassPt[iCut] = new TH2F("ESD_DalitzMother_InvMass_Pt","ESD_DalitzMother_InvMass_Pt",800,0,0.8,250,0,25);
815 fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
816
817
818 if( fDoChicAnalysis) {
819 hESDPi0MotherInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_InvMass_Pt","ESD_Pi0Mother_InvMass_Pt",4000,0,4,250,0,25);
820 fESDList[iCut]->Add(hESDPi0MotherInvMassPt[iCut]);
821 hESDPi0MotherDiffInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffInvMass_Pt","ESD_Pi0Mother_DiffInvMass_Pt",2000,0,2,250,0,25);
822 fESDList[iCut]->Add(hESDPi0MotherDiffInvMassPt[iCut]);
823 hESDPi0MotherDiffLimInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffLimInvMass_Pt","ESD_Pi0Mother_DiffLimInvMass_Pt",2000,0,2,250,0,25);
824 fESDList[iCut]->Add(hESDPi0MotherDiffLimInvMassPt[iCut]);
825 }
826
827 hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_DalitzBackground_InvMass_Pt","ESD_DalitzBackground_InvMass_Pt",800,0,0.8,250,0,25);
828 fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
829
830 fCutFolder[iCut]->Add(fESDList[iCut]);
d9d6352b 831 }
344100c4 832
833
834 InitBack(); // Init Background Handler
835
836
837 if( fIsMC ){
838 // MC Histogramms
839 fMCList = new TList*[fnCuts];
840 // True Histogramms
841 fTrueList = new TList*[fnCuts];
842 hESDTrueConvGammaPt = new TH1F*[fnCuts];
843 hESDTruePositronPt = new TH1F*[fnCuts];
844 hESDTrueElectronPt = new TH1F*[fnCuts];
845 hESDTrueSecConvGammaPt = new TH1F*[fnCuts];
846 hESDTrueSecPositronPt = new TH1F*[fnCuts];
847 hESDTrueSecElectronPt = new TH1F*[fnCuts];
848 hESDTruePi0DalitzConvGammaPt = new TH1F*[fnCuts];
849 hESDTruePi0DalitzPositronPt = new TH1F*[fnCuts];
850 hESDTruePi0DalitzElectronPt = new TH1F*[fnCuts];
851 hESDTruePi0DalitzSecConvGammaPt = new TH1F*[fnCuts];
852 hESDTruePi0DalitzSecPositronPt = new TH1F*[fnCuts];
853 hESDTruePi0DalitzSecElectronPt = new TH1F*[fnCuts];
854 //if(fDoMesonAnalysis){
855 hMCAllGammaPt = new TH1F*[fnCuts];
856 hMCConvGammaPt = new TH1F*[fnCuts];
857 hMCConvGammaRSPt = new TH1F*[fnCuts];
858 hMCAllPositronsPt = new TH1F*[fnCuts];
859 hMCAllElectronsPt = new TH1F*[fnCuts];
860
861 if( fDoMesonQA ) {
862
863 hMCConvGammaEta = new TH1F*[fnCuts];
5950ee43 864 hMCConvGammaR = new TH1F*[fnCuts];
344100c4 865 hMCAllPositronsEta = new TH1F*[fnCuts];
866 hMCAllElectronsEta = new TH1F*[fnCuts];
867
5950ee43 868
344100c4 869 }
870 hMCPi0DalitzGammaPt = new TH1F*[fnCuts];
871 hMCPi0DalitzElectronPt = new TH1F*[fnCuts];
872 hMCPi0DalitzPositronPt = new TH1F*[fnCuts];
873
874 hMCPi0Pt = new TH1F*[fnCuts];
875 hMCPi0GGPt = new TH1F*[fnCuts];
876 hMCEtaPt = new TH1F*[fnCuts];
877 hMCEtaGGPt = new TH1F*[fnCuts];
878 hMCPi0InAccPt = new TH1F*[fnCuts];
879 hMCEtaInAccPt = new TH1F*[fnCuts];
5950ee43 880 hMCChiCPt = new TH1F*[fnCuts];
881 hMCChiCInAccPt = new TH1F*[fnCuts];
344100c4 882
f4d5bd23 883
344100c4 884 if ( fDoMesonQA ) {
885
886 hMCPi0EposEnegInvMassPt = new TH2F*[fnCuts];
5950ee43 887 hMCEtaEposEnegInvMassPt = new TH2F*[fnCuts];
344100c4 888 hESDEposEnegTruePi0DalitzInvMassPt = new TH2F*[fnCuts];
889 hESDEposEnegTruePrimPi0DalitzInvMass = new TH1F*[fnCuts];
5950ee43 890 hESDEposEnegTruePi0DalitzPsiPairDPhi = new TH2F*[fnCuts];
344100c4 891 hESDEposEnegTrueEtaDalitzInvMassPt = new TH2F*[fnCuts];
892 hESDEposEnegTruePrimEtaDalitzInvMass = new TH1F*[fnCuts];
5950ee43 893 hESDEposEnegTrueEtaDalitzPsiPairDPhi = new TH2F*[fnCuts];
344100c4 894 hESDEposEnegTruePhotonInvMassPt = new TH2F*[fnCuts];
895 hESDEposEnegTrueInvMassPt = new TH2F*[fnCuts];
5950ee43 896 hESDEposEnegTruePhotonPsiPairDPhi = new TH2F*[fnCuts];
344100c4 897 hESDEposEnegTruePhotonPsiPairDPhiPtCut = new TH2F*[fnCuts];
898 hESDEposEnegTrueJPsiInvMassPt = new TH2F*[fnCuts];
5950ee43 899 hESDTrueConvGammaR = new TH1F*[fnCuts];
344100c4 900 }
901
902
903 if( fDoChicAnalysis ){
904 hESDTrueMotherChiCInvMassPt = new TH2F*[fnCuts];
905 hESDTrueMotherChiCDiffInvMassPt = new TH2F*[fnCuts];
906 }
907
908
909 hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
910 hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
911 hESDTrueMotherPi0GGInvMassPt = new TH2F*[fnCuts];
912 hESDTruePrimaryMotherPi0GGInvMassPt = new TH2F*[fnCuts];
913 hESDTrueSecondaryMotherPi0GGInvMassPt = new TH2F*[fnCuts];
914 hESDTruePrimaryPi0DalitzESDPtMCPt = new TH2F*[fnCuts];
915 hESDTruePrimaryMotherInvMassMCPt = new TH2F*[fnCuts];
916 hESDTruePrimaryMotherInvMassPt = new TH2F*[fnCuts];
917 hESDTruePrimaryMotherW0WeightingInvMassPt = new TH2F*[fnCuts];
918 hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
919 hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
920 hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
921 hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
922 hESDTrueMotherGGInvMassPt = new TH2F*[fnCuts];
923 //}
924
925 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
926 TString cutstringEvent = ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber();
927 TString cutstringElectron = ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
928 TString cutstringMeson = ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
929 TString cutstringGamma = ((AliConversionPhotonCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
930
931 fMCList[iCut] = new TList();
932 fMCList[iCut]->SetName(Form("%s_%s_%s_%s MC histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
933 fMCList[iCut]->SetOwner(kTRUE);
934 fCutFolder[iCut]->Add(fMCList[iCut]);
935
936 hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
937 fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
938
939 hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
940 fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
941
942 hMCConvGammaRSPt[iCut] = new TH1F("MC_ConvGamma_RS_Pt","MC_ConvGamma_RS_Pt",250,0,25);
943 fMCList[iCut]->Add(hMCConvGammaRSPt[iCut]);
944
945 hMCAllPositronsPt[iCut] = new TH1F("MC_AllPositrons_Pt","MC_AllPositrons_Pt",1000,0,25);
946 fMCList[iCut]->Add(hMCAllPositronsPt[iCut]);
947
948 hMCAllElectronsPt[iCut] = new TH1F("MC_AllElectrons_Pt","MC_AllElectrons_Pt",1000,0,25);
949 fMCList[iCut]->Add(hMCAllElectronsPt[iCut]);
950
951 hMCPi0DalitzGammaPt[iCut] = new TH1F("MC_Pi0DalitzGamma_Pt","MC_Pi0DalitzGamma_Pt",250,0,25);
952 hMCPi0DalitzGammaPt[iCut]->Sumw2();
953 fMCList[iCut]->Add(hMCPi0DalitzGammaPt[iCut]);
954
955 if ( fDoMesonQA ){
956 hMCConvGammaEta[iCut] = new TH1F("MC_ConvGamma_Eta","MC_ConvGamma_Eta",600,-1.5,1.5);
957 fMCList[iCut]->Add(hMCConvGammaEta[iCut]);
5950ee43 958 hMCConvGammaR[iCut] = new TH1F("MC_ConvGamma_R","MC_ConvGamma_R",800,0,200);
959 fMCList[iCut]->Add(hMCConvGammaR[iCut]);
344100c4 960 hMCAllPositronsEta[iCut] = new TH1F("MC_AllPositrons_Eta","MC_AllPositrons_Eta",600,-1.5,1.5);
961 fMCList[iCut]->Add(hMCAllPositronsEta[iCut]);
962 hMCAllElectronsEta[iCut] = new TH1F("MC_AllElectrons_Eta","MC_AllElectrons_Eta",600,-1.5,1.5);
963 fMCList[iCut]->Add(hMCAllElectronsEta[iCut]);
964 }
965
966 hMCPi0DalitzPositronPt[iCut] = new TH1F("MC_Pi0DalitzPositron_Pt","MC_Pi0DalitzPositron_Pt",1000,0,25);
967 hMCPi0DalitzPositronPt[iCut]->Sumw2();
968 fMCList[iCut]->Add(hMCPi0DalitzPositronPt[iCut]);
969
970 hMCPi0DalitzElectronPt[iCut] = new TH1F("MC_Pi0DalitzElectron_Pt","MC_Pi0DalitzElectron_Pt",1000,0,25);
971 hMCPi0DalitzElectronPt[iCut]->Sumw2();
972 fMCList[iCut]->Add(hMCPi0DalitzElectronPt[iCut]);
973
974 hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
975 hMCPi0Pt[iCut]->Sumw2();
976 fMCList[iCut]->Add(hMCPi0Pt[iCut]);
977
978 hMCPi0GGPt[iCut] = new TH1F("MC_Pi0_GG_Pt","MC_Pi0_GG_Pt",250,0,25);
979 hMCPi0GGPt[iCut]->Sumw2();
980 fMCList[iCut]->Add(hMCPi0GGPt[iCut]);
981
982 hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
983 hMCEtaPt[iCut]->Sumw2();
984 fMCList[iCut]->Add(hMCEtaPt[iCut]);
0f8c33c1 985
344100c4 986 hMCEtaGGPt[iCut] = new TH1F("MC_Eta_GG_Pt","MC_Eta_GG_Pt",250,0,25);
987 hMCEtaGGPt[iCut]->Sumw2();
988 fMCList[iCut]->Add(hMCEtaGGPt[iCut]);
989
990 hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0DalitzInAcc_Pt","MC_Pi0DalitzInAcc_Pt",250,0,25);
991 hMCPi0InAccPt[iCut]->Sumw2();
992 fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
993
994 hMCEtaInAccPt[iCut] = new TH1F("MC_EtaDalitzInAcc_Pt","MC_EtaDalitzInAcc_Pt",250,0,25);
995 hMCEtaInAccPt[iCut]->Sumw2();
996 fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
997
998 hMCChiCPt[iCut] = new TH1F("MC_ChiC_Pt","MC_ChiC_Pt",250,0,25);
999 fMCList[iCut]->Add(hMCChiCPt[iCut]);
1000
1001 hMCChiCInAccPt[iCut] = new TH1F("MC_ChiCInAcc_Pt","MC_ChiCInAcc_Pt",250,0,25);
1002 fMCList[iCut]->Add(hMCChiCInAccPt[iCut]);
1003
1004 if ( fDoMesonQA ) {
1005 hMCPi0EposEnegInvMassPt[iCut] = new TH2F("MC_Pi0EposEneg_InvMassPt","MC_Pi0EposEneg_InvMassPt",1000,0.0,0.5,100,0.,10.);
1006 fMCList[iCut]->Add(hMCPi0EposEnegInvMassPt[iCut]);
1007 hMCEtaEposEnegInvMassPt[iCut] = new TH2F("MC_EtaEposEneg_InvMassPt","MC_EtaEposEneg_InvMassPt",1400,0.,0.7,100,0.,10.);
1008 fMCList[iCut]->Add(hMCEtaEposEnegInvMassPt[iCut]);
1009 }
1010
1011 fTrueList[iCut] = new TList();
1012 fTrueList[iCut]->SetName(Form("%s_%s_%s_%s True histograms",cutstringEvent.Data(),cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
1013 fTrueList[iCut]->SetOwner(kTRUE);
1014 fCutFolder[iCut]->Add(fTrueList[iCut]);
1015
1016 if ( fDoMesonQA ) {
1017 hESDEposEnegTruePi0DalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_InvMassPt","ESD_EposEneg_TruePi0Dalitz_InvMassPt",1000,0.0,0.5,100,0.,10.);
1018 fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzInvMassPt[iCut]);
1019
1020 hESDEposEnegTruePrimPi0DalitzInvMass[iCut] = new TH1F("ESD_EposEneg_TruePrimPi0Dalitz_InvMass","ESD_EposEneg_TruePrimPi0Dalitz_InvMass",500,0.,0.5);
1021 fTrueList[iCut]->Add(hESDEposEnegTruePrimPi0DalitzInvMass[iCut]);
1022
1023 hESDEposEnegTruePi0DalitzPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_PsiPair_DPhi","ESD_EposEneg_TruePi0Dalitz_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
1024 fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzPsiPairDPhi[iCut]);
1025
1026 hESDEposEnegTrueEtaDalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueEtaDalitz_InvMassPt","ESD_EposEneg_TrueEtaDalitz_InvMassPt",700,0.,0.7,100,0.,10.);
1027 fTrueList[iCut]->Add(hESDEposEnegTrueEtaDalitzInvMassPt[iCut]);
1028
1029 hESDEposEnegTruePrimEtaDalitzInvMass[iCut] = new TH1F("ESD_EposEneg_TruePrimEtaDalitz_InvMass","ESD_EposEneg_TruePrimEtaDalitz_InvMass",700,0.,0.7);
1030 fTrueList[iCut]->Add(hESDEposEnegTruePrimEtaDalitzInvMass[iCut]);
1031
1032 hESDEposEnegTrueEtaDalitzPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TrueEtaDalitz_PsiPair_DPhi","ESD_EposEneg_TrueEtaDalitz_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
1033 fTrueList[iCut]->Add(hESDEposEnegTrueEtaDalitzPsiPairDPhi[iCut]);
1034
1035 hESDEposEnegTruePhotonInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePhoton_InvMassPt","ESD_EposEneg_TruePhoton_InvMassPt",500,0.,0.5,100,0.,10.);
1036 fTrueList[iCut]->Add(hESDEposEnegTruePhotonInvMassPt[iCut]);
1037
1038 hESDEposEnegTrueInvMassPt[iCut] = new TH2F("ESD_EposEneg_True_InvMassPt","ESD_EposEneg_True_InvMassPt",5000,0.,5.,100,0.,10.);
1039 fTrueList[iCut]->Add(hESDEposEnegTrueInvMassPt[iCut]);
1040
1041 hESDEposEnegTruePhotonPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_TruePhoton_PsiPair_DPhi","ESD_EposEneg_TruePhoton_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
1042 fTrueList[iCut]->Add(hESDEposEnegTruePhotonPsiPairDPhi[iCut]);
1043
1044 hESDEposEnegTruePhotonPsiPairDPhiPtCut[iCut] = new TH2F("ESD_EposEneg_TruePhoton_PsiPair_DPhi_PtCut","ESD_EposEneg_TruePhoton_PsiPair_DPhi_PtCut", 100, -1.0,1.0,100,-1.0,1.0 );
1045 fTrueList[iCut]->Add(hESDEposEnegTruePhotonPsiPairDPhiPtCut[iCut]);
1046
1047 hESDEposEnegTrueJPsiInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueJPsi_InvMassPt","ESD_EposEneg_TrueJPsi_InvMassPt",5000,0.,5.,100,0.,10.);
1048 fTrueList[iCut]->Add(hESDEposEnegTrueJPsiInvMassPt[iCut]);
5950ee43 1049
1050 hESDTrueConvGammaR[iCut] = new TH1F("ESD_TrueConvGamma_R","ESD_TrueConvGamma_R",800,0,200);
1051 fTrueList[iCut]->Add(hESDTrueConvGammaR[iCut]);
344100c4 1052 }
1053
1054 hESDTruePositronPt[iCut] = new TH1F("ESD_TruePositron_Pt","ESD_TruePositron_Pt",1000,0,25);
1055 fTrueList[iCut]->Add(hESDTruePositronPt[iCut]);
1056
1057 hESDTrueElectronPt[iCut] = new TH1F("ESD_TrueElectron_Pt","ESD_TrueElectron_Pt",1000,0,25);
1058 fTrueList[iCut]->Add(hESDTrueElectronPt[iCut]);
1059
1060 hESDTrueSecPositronPt[iCut] = new TH1F("ESD_TrueSecPositron_Pt","ESD_TrueSecPositron_Pt",1000,0,25);
1061 fTrueList[iCut]->Add(hESDTrueSecPositronPt[iCut]);
1062
1063 hESDTrueSecElectronPt[iCut] = new TH1F("ESD_TrueSecElectron_Pt","ESD_TrueSecElectron_Pt",1000,0,25);
1064 fTrueList[iCut]->Add(hESDTrueSecElectronPt[iCut]);
1065
1066 hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
1067 fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
1068
1069 hESDTrueSecConvGammaPt[iCut] = new TH1F("ESD_TrueSecConvGamma_Pt","ESD_TrueSecConvGamma_Pt",250,0,25);
1070 fTrueList[iCut]->Add(hESDTrueSecConvGammaPt[iCut]);
1071
1072 hESDTruePi0DalitzConvGammaPt[iCut] = new TH1F("ESD_TruePi0DalitzConvGamma_Pt","ESD_TruePi0DalitzConvGamma_Pt",250,0,25);
1073 fTrueList[iCut]->Add(hESDTruePi0DalitzConvGammaPt[iCut]);
1074
1075 hESDTruePi0DalitzElectronPt[iCut] = new TH1F("ESD_TruePi0DalitzElectron_Pt","ESD_TruePi0DalitzElectron_Pt",1000,0,25);
1076 fTrueList[iCut]->Add(hESDTruePi0DalitzElectronPt[iCut]);
1077
1078 hESDTruePi0DalitzPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzPositron_Pt","ESD_TruePi0DalitzPositron_Pt",1000,0,25);
1079 fTrueList[iCut]->Add(hESDTruePi0DalitzPositronPt[iCut]);
1080
1081 hESDTruePi0DalitzSecConvGammaPt[iCut] = new TH1F("ESD_TruePi0DalitzSecConvGamma_Pt","ESD_TruePi0DalitzSecConvGamma_Pt",250,0,25);
1082 fTrueList[iCut]->Add(hESDTruePi0DalitzSecConvGammaPt[iCut]);
1083
1084 hESDTruePi0DalitzSecElectronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecElectron_Pt","ESD_TruePi0DalitzSecElectron_Pt",1000,0,25);
1085 fTrueList[iCut]->Add(hESDTruePi0DalitzSecElectronPt[iCut]);
1086
1087 hESDTruePi0DalitzSecPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecPositron_Pt","ESD_TruePi0DalitzSecPositron_Pt",1000,0,25);
1088 fTrueList[iCut]->Add(hESDTruePi0DalitzSecPositronPt[iCut]);
1089
1090 if( fDoChicAnalysis) {
1091 hESDTrueMotherChiCInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiC_InvMass_Pt","ESD_TrueMotherChiC_InvMass_Pt",4000,0,4,250,0,25);
1092 fTrueList[iCut]->Add(hESDTrueMotherChiCInvMassPt[iCut]);
1093 hESDTrueMotherChiCDiffInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiCDiff_InvMass_Pt","ESD_TrueMotherChiCDiff_InvMass_Pt",2000,0,2,250,0,25);
1094 fTrueList[iCut]->Add(hESDTrueMotherChiCDiffInvMassPt[iCut]);
1095 }
1096
1097 hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
1098 hESDTrueMotherInvMassPt[iCut]->Sumw2();
1099 fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
1100
1101 hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueMother_Dalitz_InvMass_Pt","ESD_TrueMother_Dalitz_InvMass_Pt",800,0,0.8,250,0,25);
1102 hESDTrueMotherDalitzInvMassPt[iCut]->Sumw2();
1103 fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
1104
1105
1106
1107
1108
1109 hESDTrueMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueMotherPi0GG_InvMass_Pt","ESD_TrueMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
1110 hESDTrueMotherPi0GGInvMassPt[iCut]->Sumw2();
1111 fTrueList[iCut]->Add(hESDTrueMotherPi0GGInvMassPt[iCut]);
1112
1113 hESDTruePrimaryMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMotherPi0GG_InvMass_Pt","ESD_TruePrimaryMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
1114 hESDTruePrimaryMotherPi0GGInvMassPt[iCut]->Sumw2();
1115 fTrueList[iCut]->Add(hESDTruePrimaryMotherPi0GGInvMassPt[iCut]);
1116
1117 hESDTrueSecondaryMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueSecondaryMotherPi0GG_InvMass_Pt","ESD_TrueSecondaryMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
1118 hESDTrueSecondaryMotherPi0GGInvMassPt[iCut]->Sumw2();
1119 fTrueList[iCut]->Add(hESDTrueSecondaryMotherPi0GGInvMassPt[iCut]);
1120
1121 hESDTruePrimaryPi0DalitzESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt","ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt",250,0,25,250,0,25);
1122 hESDTruePrimaryPi0DalitzESDPtMCPt[iCut]->Sumw2();
1123 fTrueList[iCut]->Add(hESDTruePrimaryPi0DalitzESDPtMCPt[iCut]);
1124 hESDTruePrimaryMotherInvMassMCPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_MCPt","ESD_TrueDalitzPrimaryMother_InvMass_MCPt",800,0,0.8,250,0,25);
1125 hESDTruePrimaryMotherInvMassMCPt[iCut]->Sumw2();
1126 fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassMCPt[iCut]);
1127 hESDTruePrimaryMotherInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_Pt","ESD_TruePrimaryMother_InvMass_Pt",800,0,0.8,250,0,25);
1128 hESDTruePrimaryMotherInvMassPt[iCut]->Sumw2();
1129 fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassPt[iCut]);
1130 hESDTruePrimaryMotherW0WeightingInvMassPt[iCut] = new TH2F("ESD_TruePrimaryMotherW0Weighting_InvMass_Pt","ESD_TruePrimaryMotherW0Weighting_InvMass_Pt",800,0,0.8,250,0,25);
1131 hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]->Sumw2();
1132 fTrueList[iCut]->Add(hESDTruePrimaryMotherW0WeightingInvMassPt[iCut]);
1133
1134 hESDTrueSecondaryMotherInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMother_InvMass_Pt","ESD_TrueDalitzSecondaryMother_InvMass_Pt",800,0,0.8,250,0,25);
1135 hESDTrueSecondaryMotherInvMassPt[iCut]->Sumw2();
1136 fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
1137 // hESDTrueSecondaryMotherFromK0sInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt",1000,0,1,250,0,25);
1138 // fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
1139 hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckGG_InvMass_Pt","ESD_TrueDalitzBckGG_InvMass_Pt",800,0,0.8,250,0,25);
1140 fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
1141 hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckCont_InvMass_Pt","ESD_TrueDalitzBckCont_InvMass_Pt",800,0,0.8,250,0,25);
1142 fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
1143 // hESDTrueMotherGGInvMassPt[iCut] = new TH2F("ESD_TrueGammaGamma_InvMass_Pt","ESD_TrueGammaGamma_InvMass_Pt",1000,0,1,250,0,25);
1144 // fTrueList[iCut]->Add(hESDTrueMotherGGInvMassPt[iCut]);
1145
1146 }
1147 }
1148
1149 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1150 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1151
1152 if(fV0Reader)
1153 if((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())
1154 if(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
1155 fOutputContainer->Add(((AliConversionPhotonCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
1156
1157
1158
1159 fElecSelector=(AliDalitzElectronSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("ElectronSelector");
1160 if(!fElecSelector){printf("Error: No ElectronSelector");return;} // GetV0Reader
1161
1162 if( fElecSelector ){
1163 if ( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() ){
1164 fOutputContainer->Add( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() );
1165 }
1166 }
1167
1168 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1169
1170 if( fCutElectronArray ){
1171 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() ) {
1172 fCutFolder[iCut]->Add( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() );
1173 }
1174 }
1175
1176 if( fCutMesonArray ) {
1177 if( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms() ) {
1178 fCutFolder[iCut]->Add( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms());
1179 }
1180 }
1181
1182 if( fCutGammaArray ) {
1183 if( ((AliConversionPhotonCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() ) {
1184 fCutFolder[iCut]->Add( ((AliConversionPhotonCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() );
1185 }
1186 }
4fac3e9a 1187
1188 if( fCutEventArray )
1189 if( ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutHistograms()){
1190 fCutFolder[iCut]->Add(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutHistograms());
1191 }
344100c4 1192 }
1193
1194 PostData(1, fOutputContainer);
2bb2434e 1195
1196}
1197
1198//______________________________________________________________________
1199void AliAnalysisTaskGammaConvDalitzV1::UserExec(Option_t *)
1200{
a280ac15 1201
344100c4 1202 //
1203 // Execute analysis for current event
1204 //
1205
1206 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
1207 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
1208
1209
1210 Int_t eventQuality = ((AliConvEventCuts*)fV0Reader->GetEventCuts())->GetEventQuality();
1211
1212 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
1213 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1214 hNEvents[iCut]->Fill(eventQuality);
1215 }
1216 return;
1217 }
1218
1219 fElecSelector=(AliDalitzElectronSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("ElectronSelector");
1220 if(!fElecSelector){printf("Error: No ElectronSelector");return;} // GetV0Reader
1221
1222
1223 if(fIsMC) fMCEvent = MCEvent();
1224 fESDEvent = (AliESDEvent*)InputEvent();
1225 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
1226 fSelectorElectronIndex = fElecSelector->GetReconstructedElectronsIndex(); // Electrons from default Cut
1227 fSelectorPositronIndex = fElecSelector->GetReconstructedPositronsIndex(); // Positrons from default Cut
1228
1229 CountESDTracks(); // Estimate Event Multiplicity
1230 fNumberOfESDTracks = fV0Reader->GetNumberOfPrimaryTracks();
1231 //AddTaskContainers(); //Add conatiner
1232
1233 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
1234 fiCut = iCut;
1235 fNVirtualGammas = 0;
1236
4fac3e9a 1237 Int_t eventNotAccepted =
1238 ((AliConvEventCuts*)fCutEventArray->At(iCut))
7f070437 1239 ->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon,kFALSE);
4fac3e9a 1240
1241
7f070437 1242 //Int_t eventNotAccepted = ((AliConvEventCuts*)fCutGammaArray->At(iCut))->IsEventAcceptedByCut(fV0Reader->GetEventCuts(),fInputEvent,fMCEvent,fIsHeavyIon,kFALSE);
344100c4 1243
1244 if(eventNotAccepted){
1245 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
1246 hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
1247 continue;
1248 }
1249
1250 if(eventQuality != 0){// Event Not Accepted
1251 // cout << "event rejected due to: " <<eventQuality << endl;
1252 hNEvents[iCut]->Fill(eventQuality);
1253 continue;
1254 }
1255
1256 hNEvents[iCut]->Fill(eventQuality);
1257 hNGoodESDTracks[iCut]->Fill(fNumberOfESDTracks);
1258
1259 if(((AliConvEventCuts*)fCutEventArray->At(iCut))->IsHeavyIon() == 2) hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A());
1260 else hNV0Tracks[iCut]->Fill(fInputEvent->GetVZEROData()->GetMTotV0A()+fInputEvent->GetVZEROData()->GetMTotV0C());
1261
1262 if(fMCEvent){ // Process MC Particle
1263 fMCStack = fMCEvent->Stack();
1264 if(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetSignalRejection() != 0){
1265 ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetNotRejectedParticles( ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetSignalRejection(),
1266 ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetAcceptedHeader(),
1267 fMCEvent);
1268 }
1269 ProcessMCParticles();
1270 }
1271
1272 ProcessPhotonCandidates(); // Process this cuts gammas
1273 ProcessElectronCandidates(); // Process this cuts gammas
1274
1275 if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1276
1277 fUnsmearedPx = new Double_t[fGoodGammas->GetEntries()]; // Store unsmeared Momenta
1278 fUnsmearedPy = new Double_t[fGoodGammas->GetEntries()];
1279 fUnsmearedPz = new Double_t[fGoodGammas->GetEntries()];
1280 fUnsmearedE = new Double_t[fGoodGammas->GetEntries()];
1281
1282 for(Int_t gamma=0;gamma<fGoodGammas->GetEntries();gamma++){ // Smear the AODPhotons in MC
1283 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Px();
1284 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Py();
1285 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Pz();
1286 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->E();
1287 ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(gamma)));
1288 }
1289 }
1290
1291 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetUseVPhotonMCPmearing() && ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1292 // cout<<"Entro virtual photon smearing"<<endl;
1293 fUnsmearedVPx = new Double_t[fGoodVirtualGammas->GetEntries()]; // Store unsmeared Momenta
1294 fUnsmearedVPy = new Double_t[fGoodVirtualGammas->GetEntries()];
1295 fUnsmearedVPz = new Double_t[fGoodVirtualGammas->GetEntries()];
1296 fUnsmearedVE = new Double_t[fGoodVirtualGammas->GetEntries()];
1297
1298 for(Int_t Vgamma=0;Vgamma<fGoodVirtualGammas->GetEntries();Vgamma++){ // Smear the AODPhotons in MC
1299 fUnsmearedVPx[Vgamma] = ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->Px();
1300 fUnsmearedVPy[Vgamma] = ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->Py();
1301 fUnsmearedVPz[Vgamma] = ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->Pz();
1302 fUnsmearedVE[Vgamma] = ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->E();
1303 ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->SmearVirtualPhoton(dynamic_cast<AliAODConversionPhoton*>(fGoodVirtualGammas->At(Vgamma)));
1304 }
1305 }
1306
1307 ProcessVirtualGammasCandidates();
1308 CalculatePi0DalitzCandidates();
1309 CalculateBackground();
1310 UpdateEventByEventData();
1311
1312 if ( fDoMesonQA ) {
1313 hNGoodESDTracksVsNGoodGammas[iCut]->Fill(fNumberOfESDTrackskBoth,fGoodGammas->GetEntries());
1314 hNGoodESDTracksVsNGoodVGammas[iCut]->Fill(fNumberOfESDTrackskBoth,fNVirtualGammas);
1315 }
1316
1317
1318 if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1319
1320 for(Int_t gamma=0;gamma<fGoodGammas->GetEntries();gamma++){ // Smear the AODPhotons in MC
1321 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1322 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1323 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1324 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetE(fUnsmearedE[gamma]);
1325 }
1326 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1327 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1328 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1329 delete[] fUnsmearedE; fUnsmearedE = 0x0;
1330 }
1331
1332 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetUseVPhotonMCPmearing() && ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1333
1334 for(Int_t Vgamma=0;Vgamma<fGoodVirtualGammas->GetEntries();Vgamma++){ // Smear the AODPhotons in MC
1335 ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->SetPx(fUnsmearedVPx[Vgamma]); // Reset Unsmeared Momenta
1336 ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->SetPy(fUnsmearedVPy[Vgamma]);
1337 ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->SetPz(fUnsmearedVPz[Vgamma]);
1338 ((AliAODConversionPhoton*)fGoodVirtualGammas->At(Vgamma))->SetE(fUnsmearedVE[Vgamma]);
1339 }
1340 delete[] fUnsmearedVPx; fUnsmearedVPx = 0x0;
1341 delete[] fUnsmearedVPy; fUnsmearedVPy = 0x0;
1342 delete[] fUnsmearedVPz; fUnsmearedVPz = 0x0;
1343 delete[] fUnsmearedVE; fUnsmearedVE = 0x0;
1344 }
1345 fGoodGammas->Clear(); // delete this cuts good gammas
1346 fGoodVirtualGammas->Clear(); // delete this cuts good gammas
1347 }
1348
1349 fSelectorElectronIndex.clear();
1350 fSelectorPositronIndex.clear();
1351
1352 PostData( 1, fOutputContainer );
2bb2434e 1353}
1354
ae947965 1355Bool_t AliAnalysisTaskGammaConvDalitzV1::Notify()
1356{
344100c4 1357 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
e3dbd03c 1358
344100c4 1359 if( !((AliConvEventCuts*)fCutEventArray->At(iCut))->GetDoEtaShift() ){
1360
344100c4 1361 hEtaShift[iCut]->Fill(0.,0.);
1362 continue; // No Eta Shift requested, continue
1363 }
1364
1365
1366 if( ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1367 ((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
1368 ((AliConvEventCuts*)fCutEventArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
e3dbd03c 1369 hEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetEtaShift()));
344100c4 1370 continue;
1371 } else {
1372 printf(" Gamma Conversion Dalitz Task %s :: Eta Shift Manually Set to %f \n\n",
1373 (((AliConvEventCuts*)fCutEventArray->At(iCut))->GetCutNumber()).Data(),((AliConvEventCuts*)fCutEventArray->At(iCut))->GetEtaShift());
1374 ((AliConvEventCuts*)fCutEventArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
344100c4 1375 hEtaShift[iCut]->Fill(0.,(((AliConvEventCuts*)fCutEventArray->At(iCut))->GetEtaShift()));
1376 }
1377 }
1378
1379 return kTRUE;
ae947965 1380}
1381
344100c4 1382//________________________________________________________________________
2bb2434e 1383void AliAnalysisTaskGammaConvDalitzV1::Terminate(const Option_t *)
1384{
344100c4 1385 ///Grid
2bb2434e 1386}
344100c4 1387
2bb2434e 1388//________________________________________________________________________
1389void AliAnalysisTaskGammaConvDalitzV1::ProcessPhotonCandidates()
1390{
344100c4 1391 Int_t nV0 = 0;
1392 TList *GoodGammasStepOne = new TList();
1393 TList *GoodGammasStepTwo = new TList();
1394 // Loop over Photon Candidates allocated by ReaderV1
1395
1396 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1397 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1398 if(!PhotonCandidate) continue;
1399 fIsFromMBHeader = kTRUE;
1400 if( fMCEvent && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0 ){
1401 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1402 if(isPosFromMBHeader == 0 && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 3) continue;
1403 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1404 if(isNegFromMBHeader == 0 && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 3) continue;
1405 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1406 }
1407
1408 if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fESDEvent)) continue;
1409
1410 if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut() &&
1411 !((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // if no post reader loop is required add to events good gammas
1412
1413 fGoodGammas->Add(PhotonCandidate);
1414 if(fIsFromMBHeader){
1415 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1416 hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1417 if( fDoMesonQA ) hESDConvGammaZR[fiCut]->Fill(PhotonCandidate->GetConversionZ(),PhotonCandidate->GetConversionRadius());
1418 }
1419 if(fMCEvent){
1420 ProcessTruePhotonCandidates(PhotonCandidate);
1421 }
1422 } else if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1423 ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1424 nV0++;
1425 GoodGammasStepOne->Add(PhotonCandidate);
1426 } else if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut() &&
1427 ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1428 GoodGammasStepTwo->Add(PhotonCandidate);
1429 }
1430 }
1431
1432
1433 if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut()){
1434 for(Int_t i = 0;i<GoodGammasStepOne->GetEntries();i++){
1435 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GoodGammasStepOne->At(i);
1436 if(!PhotonCandidate) continue;
1437 fIsFromMBHeader = kTRUE;
1438 if(fMCEvent && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0){
1439 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack,fInputEvent);
1440 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1441 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1442 }
1443
1444 if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GoodGammasStepOne->GetEntries())) continue;
1445 if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1446 fGoodGammas->Add(PhotonCandidate);
1447
1448 if(fIsFromMBHeader){
1449 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1450 hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1451 if( fDoMesonQA )hESDConvGammaZR[fiCut]->Fill(PhotonCandidate->GetConversionZ(),PhotonCandidate->GetConversionRadius());
1452 }
1453
1454 if(fMCEvent){
1455 ProcessTruePhotonCandidates(PhotonCandidate);
1456 }
1457 } else GoodGammasStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1458 }
1459 }
1460 if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){
1461 for(Int_t i = 0;i<GoodGammasStepTwo->GetEntries();i++){
1462 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GoodGammasStepTwo->At(i);
1463 if(!PhotonCandidate) continue;
1464 if(fMCEvent && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0){
1465 Int_t isPosFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack,fInputEvent);
1466 Int_t isNegFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1467 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1468 }
1469 if(!((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GoodGammasStepTwo,i)) continue;
1470 fGoodGammas->Add(PhotonCandidate); // Add gamma to current cut TList
1471
1472 if(fIsFromMBHeader){
1473 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt()); // Differences to old V0Reader in p_t due to conversion KF->TLorentzVector
1474 hESDConvGammaEta[fiCut]->Fill(PhotonCandidate->Eta());
1475 if(fDoMesonQA)hESDConvGammaZR[fiCut]->Fill(PhotonCandidate->GetConversionZ(),PhotonCandidate->GetConversionRadius());
1476 }
1477
1478 if(fMCEvent){
1479 ProcessTruePhotonCandidates(PhotonCandidate);
1480 }
1481 }
1482 }
1483
1484 delete GoodGammasStepOne;
1485 GoodGammasStepOne = 0x0;
1486 delete GoodGammasStepTwo;
1487 GoodGammasStepTwo = 0x0;
2bb2434e 1488}
1489
1490//________________________________________________________________________
1491void AliAnalysisTaskGammaConvDalitzV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1492{
344100c4 1493 // Process True Photons
1494 AliStack *MCStack = fMCEvent->Stack();
1495 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(MCStack);
1496 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(MCStack);
1497
1498 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1499 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){ // Not Same Mother == Combinatorial Bck
1500 return;
1501 } else if (posDaughter->GetMother(0) == -1){
1502 return;
1503 }
1504
1505 if(TMath::Abs(posDaughter->GetPdgCode())!=11 || TMath::Abs(negDaughter->GetPdgCode())!=11) return; //One Particle is not electron
1506 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1507 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
2bb2434e 1508
344100c4 1509 TParticle *Photon = TruePhotonCandidate->GetMCParticle(MCStack);
1510 if(Photon->GetPdgCode() != 22) return; // Mother is no Photon
2bb2434e 1511
344100c4 1512 // True Photon
1513
1514 Int_t labelGamma = TruePhotonCandidate->GetMCParticleLabel(MCStack);
1515
1516 if( labelGamma < MCStack->GetNprimary() ){
1517 if( fIsFromMBHeader ){
1518 hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
5950ee43 1519 hESDTrueConvGammaR[fiCut]->Fill(TruePhotonCandidate->GetConversionRadius());
344100c4 1520 }
1521 } else {
1522 if( fIsFromMBHeader){
1523 hESDTrueSecConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1524 }
ae947965 1525 }
344100c4 1526
1527 if( IsPi0DalitzDaughter(labelGamma) == kTRUE ) {
1528 if( labelGamma < MCStack->GetNprimary() ) {
1529 if( fIsFromMBHeader ){
1530 hESDTruePi0DalitzConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1531 }
1532 } else {
1533 if( fIsFromMBHeader ) {
1534 hESDTruePi0DalitzSecConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1535 }
1536 }
ae947965 1537 }
ccfa8c0d 1538
1539
2bb2434e 1540}
30b9a400 1541//________________________________________________________________________
1542void AliAnalysisTaskGammaConvDalitzV1::ProcessVirtualGammasCandidates(){
344100c4 1543
1544 Double_t magField = fInputEvent->GetMagneticField();
30b9a400 1545
1546
344100c4 1547 if( magField < 0.0 ){
1548 magField = 1.0;
1549 }
1550 else {
1551 magField = -1.0;
1552 }
1553
1554 AliStack *MCStack = 0x0;
1555
1556 if( fMCEvent ){
1557 MCStack = fMCEvent->Stack();
1558 }
1559
1560
1561 for(Int_t virtualGammaIndex=0; virtualGammaIndex < fGoodVirtualGammas->GetEntries(); virtualGammaIndex++ ){
1562 AliAODConversionPhoton *Vgamma=dynamic_cast<AliAODConversionPhoton*>(fGoodVirtualGammas->At(virtualGammaIndex));
1563
1564 AliESDtrack* positronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
1565 AliESDtrack* electronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
1566
1567 Bool_t isPhoton = kFALSE;
1568 Bool_t isPi0Dalitz = kFALSE;
1569 Bool_t isEtaDalitz = kFALSE;
1570 Bool_t isJPsi = kFALSE;
1571 Bool_t isTrueEposENeg = kFALSE;
1572 Bool_t isMotherPrimary = kFALSE;
1573
1574 Double_t psiPair = GetPsiPair(positronVgamma,electronVgamma);
1575 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronVgamma->GetConstrainedParam()->Phi()-positronVgamma->GetConstrainedParam()->Phi());
1576
1577 if ( fDoMesonQA ) {
1578
1579 hESDEposEnegPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1580 hESDEposEnegInvMassPt[fiCut]->Fill(Vgamma->M(),Vgamma->Pt());
1581
1582 //cout<<"GetMass() "<<Vgamma->GetMass()<<" M "<<Vgamma->M()<<endl;
1583 if( fMCEvent ) {
1584
1585 Int_t virtualGammaMCLabel = Vgamma->GetMCParticleLabel(MCStack);
1586
1587 TParticle * negativeMC = 0x0;
1588 TParticle * positiveMC = 0x0;
1589 TParticle * mcVgamma = 0x0;
1590
1591 if( virtualGammaMCLabel != -1 ){
1592 mcVgamma = (TParticle*)MCStack->Particle(virtualGammaMCLabel);
1593 }
1594
1595 negativeMC = (TParticle*)Vgamma->GetNegativeMCDaughter(MCStack);
1596 positiveMC = (TParticle*)Vgamma->GetPositiveMCDaughter(MCStack);
1597
1598
1599 if( negativeMC && positiveMC ) {
1600 if( positiveMC->GetPdgCode() == ::kPositron && negativeMC->GetPdgCode() == ::kElectron )
1601 isTrueEposENeg = kTRUE;
1602 if( positiveMC->GetMother(0) > -1 && positiveMC->GetMother(0) < fMCStack->GetNprimary() )
1603 isMotherPrimary = kTRUE;
1604 }
1605 if(mcVgamma){
1606 // Check if it is a true photon
1607 if(mcVgamma->GetPdgCode() == 22){
1608 isPhoton = kTRUE;
1609 } else if(mcVgamma->GetPdgCode() == 443){
1610 isJPsi = kTRUE;
1611 } else if( IsDalitz( mcVgamma ) ){
1612 if ( mcVgamma->GetPdgCode() == 111 ) isPi0Dalitz = kTRUE;
1613 else if( mcVgamma->GetPdgCode() == 221 ) isEtaDalitz = kTRUE;
1614 }
1615 }
1616
1617 if(isPhoton){
1618 hESDEposEnegTruePhotonInvMassPt[fiCut]->Fill(Vgamma->M(),Vgamma->Pt());
1619 hESDEposEnegTruePhotonPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1620 if( Vgamma->Pt() > 1.5 ){
1621 hESDEposEnegTruePhotonPsiPairDPhiPtCut[fiCut]->Fill(deltaPhi,psiPair);
1622 }
1623 } else if(isJPsi){
1624 hESDEposEnegTrueJPsiInvMassPt[fiCut]->Fill(Vgamma->M(),Vgamma->Pt());
1625 } else if(isPi0Dalitz){
1626 hESDEposEnegTruePi0DalitzInvMassPt[fiCut]->Fill(Vgamma->M(),Vgamma->Pt());
1627 hESDEposEnegTruePi0DalitzPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1628 if( isMotherPrimary ) hESDEposEnegTruePrimPi0DalitzInvMass[fiCut]->Fill( Vgamma->M() );
1629 } else if(isEtaDalitz){
1630 hESDEposEnegTrueEtaDalitzInvMassPt[fiCut]->Fill(Vgamma->M(),Vgamma->Pt());
1631 hESDEposEnegTrueEtaDalitzPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1632 if( isMotherPrimary ) hESDEposEnegTruePrimEtaDalitzInvMass[fiCut]->Fill( Vgamma->M() );
1633 }
1634
1635 if( isTrueEposENeg ) hESDEposEnegTrueInvMassPt[fiCut]->Fill(Vgamma->M(), Vgamma->Pt());
1636
1637 }
1638 }
1639 }
30b9a400 1640}
1641
2bb2434e 1642//________________________________________________________________________
1643void AliAnalysisTaskGammaConvDalitzV1::ProcessElectronCandidates(){
1644
344100c4 1645 Double_t magField = fInputEvent->GetMagneticField();
2bb2434e 1646
344100c4 1647 if( magField < 0.0 ){
1648 magField = 1.0;
1649 } else {
1650 magField = -1.0;
ae947965 1651 }
a280ac15 1652
344100c4 1653 vector<Int_t> lGoodElectronIndexPrev(0);
1654 vector<Int_t> lGoodPositronIndexPrev(0);
78cea1d2 1655
344100c4 1656 for(UInt_t i = 0; i < fSelectorElectronIndex.size(); i++){
1657
1658 AliESDtrack* electronCandidate = fESDEvent->GetTrack(fSelectorElectronIndex[i]);
1659
1660 if( fMCEvent ) {
1661 Int_t labelelectron = TMath::Abs( electronCandidate->GetLabel() );
1662 Int_t isMCFromMBHeader = -1;
1663 if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0) {
1664 isMCFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(labelelectron,fMCStack,fInputEvent);
1665 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 3) continue;
1666 }
ae947965 1667 }
344100c4 1668
1669 if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(electronCandidate) ) continue;
1670
1671 lGoodElectronIndexPrev.push_back( fSelectorElectronIndex[i] );
1672 hESDDalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
1673 hESDDalitzElectronPhi[fiCut]->Fill(electronCandidate->Phi());
1674
1675
1676 if( fMCEvent ) {
1677
1678 Int_t labelelectron = TMath::Abs( electronCandidate->GetLabel() );
1679 if( labelelectron < fMCStack->GetNtrack() ){
1680 TParticle* electron = fMCStack->Particle(labelelectron);
1681 if( electron->GetPdgCode() == 11 ){
1682 if( labelelectron < fMCStack->GetNprimary() ){
1683 hESDTrueElectronPt[fiCut]->Fill(electronCandidate->Pt()); //primary electron
1684 } else {
1685 hESDTrueSecElectronPt[fiCut]->Fill(electronCandidate->Pt()); //secondary electron
1686 }
1687 if( IsPi0DalitzDaughter(labelelectron) == kTRUE ) {
1688 if( labelelectron < fMCStack->GetNprimary() ) {
1689 hESDTruePi0DalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
1690 } else {
1691 hESDTruePi0DalitzSecElectronPt[fiCut]->Fill(electronCandidate->Pt());
1692 }
1693 }
1694 }
1695 }
ae947965 1696 }
344100c4 1697 }
2bb2434e 1698
344100c4 1699 for(UInt_t i = 0; i < fSelectorPositronIndex.size(); i++){
2bb2434e 1700
344100c4 1701 AliESDtrack* positronCandidate = fESDEvent->GetTrack( fSelectorPositronIndex[i] );
1702
1703 if( fMCEvent ) {
1704
1705 Int_t labelpositron = TMath::Abs( positronCandidate->GetLabel() );
1706 Int_t isMCFromMBHeader = -1;
1707
1708 if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0) {
1709 isMCFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(labelpositron,fMCStack,fInputEvent);
1710 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 3) continue;
1711 }
1712 }
1713
1714 if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(positronCandidate) ) continue;
1715
1716 lGoodPositronIndexPrev.push_back( fSelectorPositronIndex[i] );
1717 hESDDalitzPositronPt[fiCut]->Fill( positronCandidate->Pt() );
1718 hESDDalitzPositronPhi[fiCut]->Fill( positronCandidate->Phi() );
1719
1720 if( fMCEvent ) {
1721 Int_t labelpositron = TMath::Abs( positronCandidate->GetLabel() );
1722
1723 if( labelpositron < fMCStack->GetNtrack() ) {
1724 TParticle* positron = fMCStack->Particle(labelpositron);
1725 if( positron->GetPdgCode() == -11 ){
1726 if( labelpositron < fMCStack->GetNprimary() ){
1727 hESDTruePositronPt[fiCut]->Fill(positronCandidate->Pt());
1728 } else {
1729 hESDTrueSecPositronPt[fiCut]->Fill(positronCandidate->Pt());
1730 }
1731 if( IsPi0DalitzDaughter(labelpositron) == kTRUE ) {
1732 if( labelpositron < fMCStack->GetNprimary() ){
1733 hESDTruePi0DalitzPositronPt[fiCut]->Fill(positronCandidate->Pt());
1734 } else {
1735 hESDTruePi0DalitzSecPositronPt[fiCut]->Fill(positronCandidate->Pt());
1736 }
1737 }
1738 }
1739 }
1740 }
1741 }
fcc79cf5 1742
344100c4 1743 vector<Bool_t> lElectronPsiIndex(lGoodElectronIndexPrev.size(), kTRUE);
1744 vector<Bool_t> lPositronPsiIndex(lGoodPositronIndexPrev.size(), kTRUE);
fcc79cf5 1745
344100c4 1746 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->DoPsiPairCut() == kTRUE ){
1747 for( UInt_t i = 0; i < lGoodElectronIndexPrev.size(); i++ ) {
1748 AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndexPrev[i]);
1749 for(UInt_t j = 0; j < lGoodPositronIndexPrev.size(); j++){
1750 AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndexPrev[j]);
1751 Double_t psiPair = GetPsiPair(positronCandidate,electronCandidate);
1752 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->GetConstrainedParam()->Phi()-positronCandidate->GetConstrainedParam()->Phi());
fcc79cf5 1753
344100c4 1754 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->IsFromGammaConversion(psiPair,deltaPhi ) ){
1755 lElectronPsiIndex[i] = kFALSE;
1756 lPositronPsiIndex[j] = kFALSE;
1757 }
1758 }
1759 }
1760 }
fcc79cf5 1761
344100c4 1762 vector<Int_t> lGoodElectronIndex(0);
1763 vector<Int_t> lGoodPositronIndex(0);
1764
1765 for( UInt_t i = 0; i < lGoodElectronIndexPrev.size(); i++ ) {
1766 if( lElectronPsiIndex[i] == kTRUE )
1767 lGoodElectronIndex.push_back( lGoodElectronIndexPrev[i] );
1768 }
2bb2434e 1769
344100c4 1770 for( UInt_t i = 0; i < lGoodPositronIndexPrev.size(); i++ ) {
1771 if( lPositronPsiIndex[i] == kTRUE )
1772 lGoodPositronIndex.push_back( lGoodPositronIndexPrev[i] );
1773 }
2bb2434e 1774
344100c4 1775 for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
1776 AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndex[i]);
1777 AliKFParticle electronCandidateKF( *electronCandidate->GetConstrainedParam(), ::kElectron );
1778 TLorentzVector electronCandidateTLV;
1779 electronCandidateTLV.SetXYZM(electronCandidate->GetConstrainedParam()->Px(),electronCandidate->GetConstrainedParam()->Py(),electronCandidate->GetConstrainedParam()->Pz(),TDatabasePDG::Instance()->GetParticle( ::kElectron )->Mass());
1780
2bb2434e 1781
344100c4 1782 for(UInt_t j = 0; j < lGoodPositronIndex.size(); j++){
2bb2434e 1783
344100c4 1784 AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndex[j]);
1785 AliKFParticle positronCandidateKF( *positronCandidate->GetConstrainedParam(), ::kPositron );
1786 TLorentzVector positronCandidateTLV;
1787
1788 positronCandidateTLV.SetXYZM(positronCandidate->GetConstrainedParam()->Px(),positronCandidate->GetConstrainedParam()->Py(),positronCandidate->GetConstrainedParam()->Pz(),TDatabasePDG::Instance()->GetParticle( ::kPositron )->Mass());
1789 TLorentzVector *virtualPhotonTLV = 0;
1790 AliKFConversionPhoton* virtualPhoton = NULL;
1791 AliAODConversionPhoton *vphoton;
1792
1793 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetUseElectronMCSmearing() && ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->UseMCPSmearing() && fMCEvent){
1794 TLorentzVector smearelectronCandidateTLV = ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->SmearElectron(electronCandidateTLV);
1795 TLorentzVector smearpositronCandidateTLV = ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->SmearElectron(positronCandidateTLV);
1796 virtualPhotonTLV = new TLorentzVector( smearelectronCandidateTLV + smearpositronCandidateTLV );
1797 //TLorentzVector temp = electronCandidateTLV + positronCandidateTLV;
1798 //cout<<"Mass: "<<"NoSmearElectrons "<<temp.M() <<" SmearElectrons "<<virtualPhotonTLV->M()<<endl;
1799 vphoton= new AliAODConversionPhoton(virtualPhotonTLV);
1800 vphoton->SetMass(virtualPhotonTLV->M());
1801 } else {
1802 virtualPhoton = new AliKFConversionPhoton(electronCandidateKF,positronCandidateKF);
1803 if( fSetProductionVertextoVGamma == kTRUE ){
1804 AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1805 primaryVertexImproved+=*virtualPhoton;
1806 virtualPhoton->SetProductionVertex(primaryVertexImproved);
1807 }
7ab8e97e 1808
344100c4 1809 vphoton= new AliAODConversionPhoton(virtualPhoton);
1810 }
1811 //virtualPhoton->SetTrackLabels( lGoodPositronIndex[j], lGoodElectronIndex[i]);
1812 vphoton->SetTrackLabels( lGoodPositronIndex[j], lGoodElectronIndex[i]);
1813
1814 if( fMCEvent ) {
1815 Int_t labeln=TMath::Abs(electronCandidate->GetLabel());
1816 Int_t labelp=TMath::Abs(positronCandidate->GetLabel());
1817 TParticle *fNegativeMCParticle = fMCStack->Particle(labeln);
1818 TParticle *fPositiveMCParticle = fMCStack->Particle(labelp);
1819 if( fPositiveMCParticle && fNegativeMCParticle) {
1820 //virtualPhoton->SetMCLabelPositive(labelp);
1821 //virtualPhoton->SetMCLabelNegative(labeln);
1822 vphoton->SetMCLabelPositive(labelp);
1823 vphoton->SetMCLabelNegative(labeln);
1824
1825 }
1826 }
1827
1828
1829 fGoodVirtualGammas->Add( vphoton );
1830
1831 if( virtualPhoton ){
1832 delete virtualPhoton;
1833 virtualPhoton=NULL;
1834 }
1835 if ( virtualPhotonTLV ){
1836 delete virtualPhotonTLV;
1837 virtualPhotonTLV=NULL;
1838 }
1839
7ab8e97e 1840 }
344100c4 1841 }
1842
1843 //Computing mixing event
1844 if( fDoMesonQA ) {
1845 for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
1846 AliESDtrack *electronCandidate1 = fESDEvent->GetTrack(lGoodElectronIndex[i]);
1847 AliKFParticle electronCandidate1KF( *electronCandidate1->GetConstrainedParam(), ::kElectron );
1848
1849 for(UInt_t j = i+1; j < lGoodElectronIndex.size(); j++){
1850
1851 AliESDtrack *electronCandidate2 = fESDEvent->GetTrack(lGoodElectronIndex[j]);
1852 AliKFParticle electronCandidate2KF( *electronCandidate2->GetConstrainedParam(), ::kElectron );
1853 AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(electronCandidate1KF,electronCandidate2KF);
1854
1855 //AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1856 //primaryVertexImproved+=*virtualPhoton;
1857 //virtualPhoton->SetProductionVertex(primaryVertexImproved);
1858
1859 AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton);
1860 hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->M(),vphoton->Pt());
1861 delete vphoton;
1862 delete virtualPhoton;
1863 vphoton = 0x0;
1864 virtualPhoton = 0x0;
1865 }
1866 }
1867
1868
1869 for(UInt_t i = 0; i < lGoodPositronIndex.size(); i++){
1870 AliESDtrack *positronCandidate1 = fESDEvent->GetTrack(lGoodPositronIndex[i]);
1871 AliKFParticle positronCandidate1KF( *positronCandidate1->GetConstrainedParam(), ::kPositron );
1872
1873 for(UInt_t j = i+1; j < lGoodPositronIndex.size(); j++){
1874
1875 AliESDtrack *positronCandidate2 = fESDEvent->GetTrack(lGoodPositronIndex[j]);
1876 AliKFParticle positronCandidate2KF( *positronCandidate2->GetConstrainedParam(), ::kPositron );
1877 AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(positronCandidate1KF,positronCandidate2KF);
1878 //AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1879 //primaryVertexImproved+=*virtualPhoton;
1880 //virtualPhoton->SetProductionVertex(primaryVertexImproved);
1881
1882 AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton);
1883 hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->M(),vphoton->Pt());
1884 delete vphoton;
1885 delete virtualPhoton;
1886 vphoton = 0x0;
1887 virtualPhoton = 0x0;
1888
1889 }
1890 }
1891 }
2bb2434e 1892}
1893
1894//________________________________________________________________________
1895void AliAnalysisTaskGammaConvDalitzV1::CalculatePi0DalitzCandidates(){
1896
344100c4 1897 // Conversion Gammas
1898 if( fGoodGammas->GetEntries() > 0 && fGoodVirtualGammas->GetEntries() > 0 ){
1899 vector<Bool_t> lGoodVirtualGamma(fGoodVirtualGammas->GetEntries(), kFALSE);
1900
1901 for(Int_t GammaIndex=0; GammaIndex<fGoodGammas->GetEntries(); GammaIndex++){
1902 AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(GammaIndex));
1903 if (gamma==NULL) continue;
1904 for(Int_t virtualGammaIndex=0;virtualGammaIndex<fGoodVirtualGammas->GetEntries();virtualGammaIndex++){
1905 AliAODConversionPhoton *Vgamma=dynamic_cast<AliAODConversionPhoton*>(fGoodVirtualGammas->At(virtualGammaIndex));
1906 if (Vgamma==NULL) continue;
1907 //Check for same Electron ID
d734058d 1908 if(gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelPositive() ||
1909 gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelNegative() ||
1910 gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelPositive() ||
1911 gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelNegative() ) continue;
344100c4 1912
1913 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma,Vgamma);
1914 pi0cand->SetLabels(GammaIndex,virtualGammaIndex);
1915
1916
1917 if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift())) ){
1918
1919 //cout<< "Meson Accepted "<<endl;
1920
1921 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
1922 Int_t mbin = 0;
1923 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ){
1924 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1925 } else {
1926 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
1927 }
1928
1929 if ( fDoMesonQA ) {
1930 hESDEposEnegInvMassPi0Pt[fiCut]->Fill( Vgamma->M(), pi0cand->Pt() );
1931 if( pi0cand->M() > 0.1 && pi0cand->M() < 0.145 ){
1932 hESDEposEnegAfterMassCutInvMassPi0Pt[fiCut]->Fill(Vgamma->M(),pi0cand->Pt());
1933 }
1934 }
1935
1936 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
1937 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( pi0cand->Pt() , Vgamma->M() ) == kTRUE ){
1938
1939 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1940 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1941 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
d734058d 1942
1943 if(fMCEvent){
1944 ProcessTrueMesonCandidates(pi0cand,gamma,Vgamma);
1945 }
344100c4 1946
1947 if ( fDoMesonQA ) {
1948 hESDMotherPhi[fiCut]->Fill(pi0cand->Phi());
1949 if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
1950
1951 FillElectronQAHistos(Vgamma);
1952
1953 lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
1954 fNVirtualGammas++;
1955 }
1956 }
1957 }
1958 } else {
1959 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1960 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1961 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1962
d734058d 1963 if(fMCEvent){
1964 ProcessTrueMesonCandidates(pi0cand,gamma,Vgamma);
1965 }
1966
344100c4 1967 if ( fDoMesonQA ) {
1968 hESDMotherPhi[fiCut]->Fill(pi0cand->Phi());
1969 if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
1970 FillElectronQAHistos(Vgamma);
1971 lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
1972 fNVirtualGammas++;
1973 }
1974 }
1975 }
1976
1977 if( fDoChicAnalysis) {
1978
1979 hESDPi0MotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1980 Double_t diffMass = pi0cand->M() - Vgamma->M();
1981 hESDPi0MotherDiffInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
1982
1983 if( Vgamma->M() > 2.5 && Vgamma->M() < 3.4){
1984 hESDPi0MotherDiffLimInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
1985 }
d734058d 1986
1987 if(fMCEvent){
1988 ProcessTrueChicCandidates(pi0cand,gamma,Vgamma);
1989 }
1990
1991
344100c4 1992 }
1993
d734058d 1994
344100c4 1995 }
1996 delete pi0cand;
1997 pi0cand=0x0;
1998 }
fcc79cf5 1999 }
344100c4 2000 }
2bb2434e 2001}
2002
2003//________________________________________________________________________
2004void AliAnalysisTaskGammaConvDalitzV1::CalculateBackground(){
2005
344100c4 2006 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
2007 Int_t mbin = 0;
2bb2434e 2008
344100c4 2009 Int_t method = 0;
2bb2434e 2010
344100c4 2011 method = ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetBKGMethod();
2bb2434e 2012
344100c4 2013 if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity()){
2014 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
2015 } else {
2016 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
2017 }
2bb2434e 2018
344100c4 2019 if( method == 1 || method == 2 ) {
2bb2434e 2020
344100c4 2021 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
8a52eed5 2022
344100c4 2023 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ) {
2024 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
a280ac15 2025
344100c4 2026 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2027 if(fMoveParticleAccordingToVertex == kTRUE && method == 1){
2028 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2029 }
a280ac15 2030
344100c4 2031 for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
2032 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
2bb2434e 2033
344100c4 2034 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2035 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2bb2434e 2036
344100c4 2037 if(fMoveParticleAccordingToVertex == kTRUE && method == 1 ){
2038 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2039 }
2bb2434e 2040
344100c4 2041 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2042
2043 if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE, ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift()))){
2044 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2045
2046 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.M() ) == kTRUE ){
2047
2048 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2049 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2050 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2051 }
2052 } else {
2053 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2054 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2055 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2056 }
2057 }
2058 delete backgroundCandidate;
2059 backgroundCandidate = 0x0;
2060 }
2061 }
2062 }
2063 } else {
2064 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
2065 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
2066 if(previousEventV0s){
2067 if(fMoveParticleAccordingToVertex == kTRUE && method == 1){
2068 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
2069 }
2070 for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
2071 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
2072 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2073 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
2074 if(fMoveParticleAccordingToVertex == kTRUE && method ==1){
2075 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
2076 }
2077
2078 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2079 if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift()))){
2080 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2081 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.M() ) == kTRUE ){
2082 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2083 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2084 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2085 }
2086 } else {
2087 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2088 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2089 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2090 }
2091 }
2092 delete backgroundCandidate;
2093 backgroundCandidate = 0x0;
2094 }
2095 }
2096 }
ae947965 2097 }
344100c4 2098 }
2099 } else if( method == 3 ){
2100 for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
2101 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
2bb2434e 2102
344100c4 2103 for(Int_t iPrevious=0;iPrevious<fGammasPool[fiCut]->GetEntries();iPrevious++){
2104 AliAODConversionPhoton previousGoodV0 = *(AliAODConversionPhoton*)((fGammasPool[fiCut]->At(iPrevious) ));
2105 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2106
2107 if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE, ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift()))){
2108 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2109 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.M() ) == kTRUE ){
2110 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2111 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2112 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2113 }
2114 } else {
2115 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
2116 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
2117 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
2118 }
2119 }
2120 delete backgroundCandidate;
2121 backgroundCandidate = 0x0;
2122 }
2123 }
2124 }
2bb2434e 2125}
344100c4 2126
2bb2434e 2127//________________________________________________________________________
2128void AliAnalysisTaskGammaConvDalitzV1::UpdateEventByEventData(){
344100c4 2129 //see header file for documentation
a280ac15 2130
344100c4 2131 Int_t method = 0;
a280ac15 2132
344100c4 2133 method = ( (AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetBKGMethod();
2134
2135 if( method == 1 ) {
2136 if(fGoodGammas->GetEntries() > 0 ){
2137 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ){
2138 fBGHandler[fiCut]->AddEvent(fGoodGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fNumberOfESDTracks);
2139 } else { // means we use #V0s for multiplicity
2140 fBGHandler[fiCut]->AddEvent(fGoodGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fGoodGammas->GetEntries());
2141 }
2142 }
2143 } else if ( method == 2 ){
2144 if(fGoodVirtualGammas->GetEntries() > 0 ){
2145 if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity()){
2146 fBGHandler[fiCut]->AddEvent(fGoodVirtualGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fNumberOfESDTracks);
2147 } else { // means we use #V0s for multiplicity
2148 fBGHandler[fiCut]->AddEvent(fGoodVirtualGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fGoodVirtualGammas->GetEntries());
2149 }
2150 }
2151 } else if ( method == 3 ) {
2152 for(Int_t index = 0; index < fGoodGammas->GetEntries(); index++){
2153 if ( fGammasPool[fiCut]->GetEntries() > ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->NumberOfRotationEvents() ){
2154 fGammasPool[fiCut]->RemoveLast();
2155 }
2156 fGammasPool[fiCut]->AddFirst( new AliAODConversionPhoton(*(AliAODConversionPhoton*)(fGoodGammas->At(index)) ) );
2157 }
2158 }
2bb2434e 2159}
344100c4 2160
2bb2434e 2161//______________________________________________________________________
2162void AliAnalysisTaskGammaConvDalitzV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate, AliAODConversionPhoton *TrueVirtualGammaCandidate)
2163{
2164
344100c4 2165 // Process True Mesons
2166 AliStack *MCStack = fMCEvent->Stack();
d734058d 2167
2168 if( TrueGammaCandidate->GetV0Index() < fESDEvent->GetNumberOfV0s() ){
2169
2170
344100c4 2171
2172 Bool_t isTruePi0 = kFALSE;
2173 Bool_t isTrueEta = kFALSE;
d734058d 2174
2175 Int_t gammaMCLabel = TrueGammaCandidate->GetMCParticleLabel(MCStack);
344100c4 2176 Int_t gammaMotherLabel = -1;
d734058d 2177
2178
344100c4 2179
d734058d 2180
2181
2182 //Checking if the gamma candidate is a real gamma
2183
344100c4 2184
2185 if(gammaMCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2186 // Daughters Gamma 0
2187 TParticle * negativeMC = (TParticle*)TrueGammaCandidate->GetNegativeMCDaughter(MCStack);
2188 TParticle * positiveMC = (TParticle*)TrueGammaCandidate->GetPositiveMCDaughter(MCStack);
2189 TParticle * gammaMC = (TParticle*)MCStack->Particle(gammaMCLabel);
2190
2191 if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2192 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2193 if(gammaMC->GetPdgCode() == 22){ // ... with Gamma Mother
2194 gammaMotherLabel=gammaMC->GetFirstMother();
2195 }
2196 }
2197 }
2198 }
2bb2434e 2199
2bb2434e 2200
d734058d 2201
2202 //Checking if the virtual gamma is a real virtual gamma
2203
344100c4 2204 Int_t virtualGammaMCLabel = TrueVirtualGammaCandidate->GetMCParticleLabel(MCStack);
2205 Int_t virtualGammaMotherLabel = -1;
d734058d 2206 Int_t virtualGamma = -1;
2207
a280ac15 2208
2209
d734058d 2210 if( virtualGammaMCLabel != -1 ){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
344100c4 2211 // Daughters Gamma 1
2212 TParticle * negativeMC = (TParticle*)TrueVirtualGammaCandidate->GetNegativeMCDaughter(MCStack);
2213 TParticle * positiveMC = (TParticle*)TrueVirtualGammaCandidate->GetPositiveMCDaughter(MCStack);
2214 TParticle * virtualGammaMotherMC = (TParticle*)MCStack->Particle(virtualGammaMCLabel);
ae947965 2215
344100c4 2216 if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2bb2434e 2217
344100c4 2218 if( virtualGammaMotherMC->GetPdgCode() != 22 ){
2219 virtualGammaMotherLabel=virtualGammaMCLabel;
d734058d 2220 virtualGamma = 1;
2221
344100c4 2222 } else if (negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2223 virtualGammaMotherLabel=virtualGammaMotherMC->GetFirstMother();
2224 virtualGamma = 0; //no virtual gamma
2225 }
2226 }
2227 }
2bb2434e 2228
d734058d 2229
2230 //Checking if both gamma and virtual gamma comming from Pi0 or Eta
2231
2bb2434e 2232
d734058d 2233 if( gammaMotherLabel >= 0 && ( gammaMotherLabel == virtualGammaMotherLabel) ){
344100c4 2234 if(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetPdgCode() == 111){
2235 isTruePi0=kTRUE;
2236 }
2237 if(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetPdgCode() == 221){
2238 isTrueEta=kTRUE;
2239 }
2240 }
2bb2434e 2241
d734058d 2242
a280ac15 2243
d734058d 2244 if( isTruePi0 || isTrueEta ){ // True Pion or Eta
344100c4 2245 if ( virtualGamma == 1 ) { //True Dalitz
2246 Float_t weighted= 1;
2247
2248 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2249 if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
2250 if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
2251 weighted= ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
2252 }
2253 }
2254 }
a280ac15 2255
344100c4 2256 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2257 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill( TrueVirtualGammaCandidate->M(),Pi0Candidate->Pt(),weighted);
2bb2434e 2258
344100c4 2259 if(gammaMotherLabel < MCStack->GetNprimary()){ // Only primary pi0 for efficiency calculation
2260 hESDTruePrimaryMotherInvMassPt[fiCut]->Fill( Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2261 hESDTruePrimaryMotherW0WeightingInvMassPt[fiCut]->Fill( Pi0Candidate->M(), Pi0Candidate->Pt() );
2262
2263 hESDTruePrimaryMotherInvMassMCPt[fiCut]->Fill(Pi0Candidate->M(),((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->Pt(),weighted);
2264 if(isTruePi0){ // Only primaries for unfolding
2265 hESDTruePrimaryPi0DalitzESDPtMCPt[fiCut]->Fill(Pi0Candidate->Pt(),((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->Pt(),weighted);
2266 }
2267 } else { // Secondary Meson
2268 Float_t weightedSec= 1;
2269 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2270 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gammaMotherLabel))->GetMother(0);
2271 if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(gammaMotherLabel)->GetPdgCode()==310){
2272 weightedSec= ((AliConvEventCuts*)fCutEventArray->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
2273 }
2274 }
2275 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2276 }
2277 } else if ( virtualGamma == 0 ){
2278 Float_t weighted= 1;
2279 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2280 if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
2281 if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
2282 weighted= ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
2283 }
2284 }
2285 }
2286 hESDTrueMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted); // Pi0 from GG
2287 if( gammaMotherLabel < MCStack->GetNprimary() ){
2288 hESDTruePrimaryMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weighted);
2289 } else {
2290 Float_t weightedSec= 1;
2291 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2292 Int_t secMotherLabel = ((TParticle*)MCStack->Particle(gammaMotherLabel))->GetMother(0);
2293 if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack, fInputEvent) && MCStack->Particle(gammaMotherLabel)->GetPdgCode()==310){
2294 weightedSec= ((AliConvEventCuts*)fCutEventArray->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
2295 }
2296 }
2297 hESDTrueSecondaryMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt(),weightedSec);
2298 }
2299 }
2300 }
2bb2434e 2301
d734058d 2302 if( !isTruePi0 && !isTrueEta ){ // Background
2303 if( gammaMotherLabel > -1 && virtualGammaMotherLabel > -1 && virtualGamma == 0 ){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
344100c4 2304 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2305 } else { // No photon or without mother
2306 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2307 }
2308 }
ae947965 2309 }
2bb2434e 2310}
0f8c33c1 2311
d734058d 2312//______________________________________________________________________
2313void AliAnalysisTaskGammaConvDalitzV1::ProcessTrueChicCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate, AliAODConversionPhoton *TruejpsiCandidate)
2314{
2315
2316
2317 AliStack *MCStack = fMCEvent->Stack();
2318
2319
2320 if( TrueGammaCandidate->GetV0Index() < fESDEvent->GetNumberOfV0s() ){
2321
2322
2323
2324 //Checking gamma
2325
2326 Int_t gammaMCLabel = TrueGammaCandidate->GetMCParticleLabel(MCStack);
2327 Int_t gammaMotherLabel = -1;
2328
2329
2330
2331 if( gammaMCLabel != -1){// Gamma is Combinatorial; MC Particles don't belong to the same Mother
2332 // Daughters Gamma 0
2333
2334 TParticle * negativeMC = (TParticle*)TrueGammaCandidate->GetNegativeMCDaughter(MCStack);
2335 TParticle * positiveMC = (TParticle*)TrueGammaCandidate->GetPositiveMCDaughter(MCStack);
2336 TParticle * gammaMC = (TParticle*)MCStack->Particle(gammaMCLabel);
2337
2338 if( TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11 ){ // Electrons ...
2339 if( negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() == 5 ){ // ... From Conversion ...
2340 if(gammaMC->GetPdgCode() == 22){ // ... with Gamma Mother
2341 gammaMotherLabel=gammaMC->GetFirstMother();
2342 }
2343 }
2344 }
2345 }
2346
2347
2348
2349 //Checking jpsi
2350
2351 Int_t jpsiMCLabel = TruejpsiCandidate->GetMCParticleLabel(MCStack);
2352 Int_t jpsiMotherLabel = -1;
2353
2354
2355
2356 if( jpsiMCLabel != -1 ){
2357
2358 TParticle * negativeMC = (TParticle*)TruejpsiCandidate->GetNegativeMCDaughter(MCStack);
2359 TParticle * positiveMC = (TParticle*)TruejpsiCandidate->GetPositiveMCDaughter(MCStack);
2360 TParticle * jpsiMC = (TParticle*)MCStack->Particle(jpsiMCLabel);
2361
2362 if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2363
2364
2365 if(jpsiMC->GetPdgCode() == 443){
2366
2367 jpsiMotherLabel=jpsiMC->GetFirstMother();
2368
2369 }
2370
2371
2372 }
2373 }
2374
2375
2376 if( gammaMotherLabel>=0 && ( gammaMotherLabel == jpsiMotherLabel) ){
2377 if( ((TParticle*)MCStack->Particle(jpsiMotherLabel))->GetPdgCode() == 445 ||
2378 ((TParticle*)MCStack->Particle(jpsiMotherLabel))->GetPdgCode() == 10443 ||
2379 ((TParticle*)MCStack->Particle(jpsiMotherLabel))->GetPdgCode() == 20443 ){
2380
2381 hESDTrueMotherChiCInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2382 hESDTrueMotherChiCDiffInvMassPt[fiCut]->Fill(Pi0Candidate->M()-TruejpsiCandidate->M(),Pi0Candidate->Pt());
2383 }
2384 }
2385
2386 }
2387}
2388
2389
2390
2391
0f8c33c1 2392
2bb2434e 2393//________________________________________________________________________
2394void AliAnalysisTaskGammaConvDalitzV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
2395 //see header file for documentation
2396
344100c4 2397 Double_t dx = vertex->fX - fESDEvent->GetPrimaryVertex()->GetX();
2398 Double_t dy = vertex->fY - fESDEvent->GetPrimaryVertex()->GetY();
2399 Double_t dz = vertex->fZ - fESDEvent->GetPrimaryVertex()->GetZ();
2bb2434e 2400
344100c4 2401 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
2402 particle->SetConversionPoint(movedPlace);
2bb2434e 2403}
2404
2405
2406//________________________________________________________________________
2407void AliAnalysisTaskGammaConvDalitzV1::CountESDTracks(){
2408
344100c4 2409 // Using standard function for setting Cuts
2410 Bool_t selectPrimaries=kTRUE;
2411 AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
2412 EsdTrackCuts->SetMaxDCAToVertexZ(2);
2413 EsdTrackCuts->SetEtaRange(-0.8, 0.8);
2414 EsdTrackCuts->SetPtRange(0.15);
2415 EsdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kBoth);
2416
2417 fNumberOfESDTrackskBoth = 0;
2418 for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
2419 AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
2420 if(!curTrack) continue;
2421 if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTrackskBoth++;
2422 }
2423 delete EsdTrackCuts;
2424 EsdTrackCuts=0x0;
2425
2426 return;
2bb2434e 2427}
2428
2429//_____________________________________________________________________________
2430void AliAnalysisTaskGammaConvDalitzV1::ProcessMCParticles()
2431{
2432
344100c4 2433// Loop over all primary MC particle
2434
2435 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2436
2437 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2438 if (!particle) continue;
2439
2440 Bool_t mcIsFromMB = kTRUE;
2441 Int_t isMCFromMBHeader = -1;
2442
2443 if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 0) {
2444 isMCFromMBHeader = ((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(i,fMCStack,fInputEvent);
2445 if(isMCFromMBHeader == 0 && ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetSignalRejection() != 3) continue;
2446 if(isMCFromMBHeader != 2) mcIsFromMB = kFALSE;
2447 }
2448
2449 if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
2450 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2451 }
2452
2453 if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
5950ee43 2454
344100c4 2455 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
5950ee43 2456
2457 if(fDoMesonQA) {
2458 hMCConvGammaEta[fiCut]->Fill( particle->Eta());
2459 hMCConvGammaR[fiCut]->Fill( ((TParticle*)fMCStack->Particle(particle->GetFirstDaughter()))->R() );
2460 }
344100c4 2461
2462 if(mcIsFromMB){
2463 hMCConvGammaRSPt[fiCut]->Fill(particle->Pt());
2464 }
2465 } // Converted MC Gamma
2466
2467 if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(i,fMCStack)){
2d49ea4c 2468 if( particle->GetPdgCode() == -11) {
344100c4 2469 hMCAllPositronsPt[fiCut]->Fill(particle->Pt()); // All positrons
2470 if(fDoMesonQA) hMCAllPositronsEta[fiCut]->Fill( particle->Eta() );
2d49ea4c 2471 }
2472 if( particle->GetPdgCode() == 11){
344100c4 2473 hMCAllElectronsPt[fiCut]->Fill(particle->Pt()); // All electrons
2474 if (fDoMesonQA) hMCAllElectronsEta[fiCut]->Fill(particle->Eta()); // All electrons
2475 }
2476 }
2477
2478 if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMC( particle,fMCStack,((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift() ) ){
2479 Float_t weighted= 1;
2480 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2481 if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2482 if (particle->Pt()>0.005){
2483 weighted= ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
2484 }
2485 }
ae947965 2486 }
ae947965 2487 if(particle->GetPdgCode() == 111)hMCPi0GGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Pi0 GG decay
2488 if(particle->GetPdgCode() == 221)hMCEtaGGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Eta GG decay
344100c4 2489 }
2490
2491
2492 Int_t labelgamma = -1;
2493 Int_t labelelectron = -1;
2494 Int_t labelpositron = -1;
ae947965 2495
a280ac15 2496
344100c4 2497 if( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMCDalitz(particle,fMCStack,labelelectron,labelpositron,labelgamma,((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift())){
2498 Float_t weighted= 1;
2499 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoWeights() ) {
2500 if(((AliConvEventCuts*)fCutEventArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack,fInputEvent)){
2501 if (particle->Pt()>0.005){
2502 weighted= ((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
2503 }
2504 }
ae947965 2505 }
ae947965 2506 if(particle->GetPdgCode() == 111)hMCPi0Pt[fiCut]->Fill(particle->Pt(), weighted); // All MC Pi0
2507 if(particle->GetPdgCode() == 221)hMCEtaPt[fiCut]->Fill(particle->Pt(), weighted); // All MC Eta
0f8c33c1 2508
2509 // Check the acceptance for gamma and electrons
2510
344100c4 2511 TParticle *gamma = fMCStack->Particle(labelgamma);
2512 TParticle *electron = fMCStack->Particle(labelelectron);
2513 TParticle *positron = fMCStack->Particle(labelpositron);
2514
2515
2516 if(((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(gamma,fMCStack,kFALSE) &&
2517 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelelectron,fMCStack) &&
2518 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelpositron,fMCStack) ) {
0f8c33c1 2519
344100c4 2520 Double_t massDalitz = -1;
2521 if( fDoMesonQA){
2522 TLorentzVector TLVEpos,TLVEneg,TLVDalitz;
2523 Double_t electronMass = TDatabasePDG::Instance()->GetParticle( ::kElectron )->Mass();
f4d5bd23 2524 TLVEpos.SetXYZM(positron->Px(),positron->Py(),positron->Pz(),electronMass);
2525 TLVEneg.SetXYZM(electron->Px(),electron->Py(),electron->Pz(),electronMass);
2526 TLVDalitz = TLVEpos + TLVEneg ;
2527 massDalitz = TLVDalitz.M();
0f8c33c1 2528 }
ae947965 2529
344100c4 2530 if(particle->GetPdgCode() == 111){
2531 hMCPi0InAccPt[fiCut]->Fill(particle->Pt() , weighted); // MC Pi0Dalitz with gamma and e+e- in acc
2532 hMCPi0DalitzGammaPt[fiCut]->Fill( gamma->Pt() );
2533 hMCPi0DalitzPositronPt[fiCut]->Fill( positron->Pt() );
2534 hMCPi0DalitzElectronPt[fiCut]->Fill( electron->Pt() );
2535 if ( fDoMesonQA )hMCPi0EposEnegInvMassPt[fiCut]->Fill(massDalitz,particle->Pt());
2536 }
2537 if(particle->GetPdgCode() == 221){
2538 hMCEtaInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC EtaDalitz with gamma and e+e- in acc
2539 if( fDoMesonQA ) hMCEtaEposEnegInvMassPt[fiCut]->Fill( massDalitz, particle->Pt());
2540 }
2541 }
2542 }
2543
0f8c33c1 2544 Int_t labelgammaChiC=-1;
2545 Int_t labelpositronChiC=-1;
2546 Int_t labelelectronChiC=-1;
2547
344100c4 2548 if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMCChiC(particle,fMCStack,labelelectronChiC,labelpositronChiC,labelgammaChiC,((AliConvEventCuts*)fCutEventArray->At(fiCut))->GetEtaShift())){
2549
0f8c33c1 2550 hMCChiCPt[fiCut]->Fill(particle->Pt()); // All MC ChiC
2551 TParticle * gammaChiC =fMCStack->Particle(labelgammaChiC);
2552
344100c4 2553 if( ((AliConversionPhotonCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC( gammaChiC,fMCStack,kFALSE) &&
2554 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelelectronChiC,fMCStack) &&
2555 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelpositronChiC,fMCStack) ){
0f8c33c1 2556 hMCChiCInAccPt[fiCut]->Fill(particle->Pt()); // All MC ChiC
2557 }
2558 }
2559 }
ccfa8c0d 2560}
344100c4 2561
ccfa8c0d 2562//_____________________________________________________________________________
ae947965 2563Bool_t AliAnalysisTaskGammaConvDalitzV1::IsDalitz(TParticle *fMCMother) const
ccfa8c0d 2564{
2565
0f8c33c1 2566 if( fMCMother->GetNDaughters() != 3 ) return kFALSE;
2567 if( fMCMother->GetPdgCode() != 111 && fMCMother->GetPdgCode() != 221 ) return kFALSE;
2568
ae947965 2569
0f8c33c1 2570 TParticle *positron = 0x0;
2571 TParticle *electron = 0x0;
ae947965 2572 TParticle *gamma = 0x0;
0f8c33c1 2573
2574 for(Int_t index= fMCMother->GetFirstDaughter();index<= fMCMother->GetLastDaughter();index++){
0f8c33c1 2575 TParticle* temp = (TParticle*)fMCStack->Particle( index );
0f8c33c1 2576 switch( temp->GetPdgCode() ) {
344100c4 2577 case ::kPositron:
2578 positron = temp;
2579 break;
2580 case ::kElectron:
2581 electron = temp;
2582 break;
2583 case ::kGamma:
2584 gamma = temp;
2585 break;
0f8c33c1 2586 }
2587 }
2588
2589 if( positron && electron && gamma) return kTRUE;
2590
2591 return kFALSE;
a280ac15 2592}
344100c4 2593
ccfa8c0d 2594//_____________________________________________________________________________________
2595Bool_t AliAnalysisTaskGammaConvDalitzV1::IsPi0DalitzDaughter( Int_t label ) const
2596{
2597//
2598// Returns true if the particle comes from Pi0 -> e+ e- gamma
344100c4 2599//
2600 Int_t motherLabel = fMCStack->Particle( label )->GetMother(0);
2601
2602 if( motherLabel < 0 || motherLabel >= fMCStack->GetNtrack() ) return kFALSE;
ae947965 2603
344100c4 2604 TParticle* mother = fMCStack->Particle( motherLabel );
2605
ae947965 2606 if( mother->GetPdgCode() != 111 ) return kFALSE;
2607
2608 if( IsDalitz( mother ) ) return kTRUE;
344100c4 2609
ae947965 2610 return kFALSE;
344100c4 2611
d9d6352b 2612}
2613
a1c2f90c 2614void AliAnalysisTaskGammaConvDalitzV1::FillElectronQAHistos(AliAODConversionPhoton *Vgamma) const
d9d6352b 2615{
d9d6352b 2616
344100c4 2617 AliESDtrack *positronVgamma = 0;
2618 AliESDtrack *electronVgamma = 0;
2619
2620 Double_t clsToFPos = -1.0;
2621 Double_t clsToFNeg = -1.0;
2622
2623 Double_t NumClsITSPos = -1.0;
2624 Double_t NumClsITSNeg = -1.0;
2625 Double_t NumClsTPCPos = -1.0;
2626 Double_t NumClsTPCNeg = -1.0;
2627 Double_t nCrossedRowsTPCPos = -1.0;
2628 Double_t nCrossedRowsTPCNeg = -1.0;
2629
2630 Float_t dcaToVertexXYPos = -1.0;
2631 Float_t dcaToVertexZPos = -1.0;
2632 Float_t dcaToVertexXYNeg = -1.0;
2633 Float_t dcaToVertexZNeg = -1.0;
2634
2635 Double_t nSigmaPosTPC = -999.;
2636 Double_t nSigmaNegTPC = -999.;
2637
2638 positronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
2639 electronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
2640 clsToFPos = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(positronVgamma);
2641 clsToFNeg = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(electronVgamma);
2642
2643 nSigmaPosTPC = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(positronVgamma, AliPID::kElectron) ;
2644 nSigmaNegTPC = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(electronVgamma, AliPID::kElectron) ;
2645
2646 NumClsITSPos = positronVgamma->GetNcls(0); //Get number of ITS clusters
2647 NumClsITSNeg = electronVgamma->GetNcls(0);
2648 NumClsTPCPos = positronVgamma->GetNcls(1); //Get number of TPC clusters
2649 NumClsTPCNeg = electronVgamma->GetNcls(1);
2650
2651 nCrossedRowsTPCPos = positronVgamma->GetTPCCrossedRows();
2652 nCrossedRowsTPCNeg = electronVgamma->GetTPCCrossedRows();
2653
2654 Float_t bPos[2];
2655 Float_t bCovPos[3];
2656 positronVgamma->GetImpactParameters(bPos,bCovPos);
2657
2658 if (bCovPos[0]<=0 || bCovPos[2]<=0) {
2659 AliDebug(1, "Estimated b resolution lower or equal zero!");
2660 bCovPos[0]=0; bCovPos[2]=0;
2661 }
2662
2663 Float_t bNeg[2];
2664 Float_t bCovNeg[3];
2665 positronVgamma->GetImpactParameters(bNeg,bCovNeg);
2666
2667 if (bCovNeg[0]<=0 || bCovNeg[2]<=0) {
2668 AliDebug(1, "Estimated b resolution lower or equal zero!");
2669 bCovNeg[0]=0; bCovNeg[2]=0;
2670 }
2671
2672 dcaToVertexXYPos = bPos[0];
2673 dcaToVertexZPos = bPos[1];
2674 dcaToVertexXYNeg = bNeg[0];
2675 dcaToVertexZNeg = bNeg[1];
2676
2677 if( electronVgamma->P() > 0.3 && electronVgamma->P() < 0.45 ){
2678 hESDDalitzElectronAfterEtaPCut[fiCut]->Fill( electronVgamma->Eta() );
2679 }
2680 if( positronVgamma->P() > 0.3 && positronVgamma->P() < 0.45 ){
2681 hESDDalitzPositronAfterEtaPCut[fiCut]->Fill( positronVgamma->Eta() );
2682 }
2683
2684 hESDDalitzElectronAfterPt[fiCut]->Fill( electronVgamma->Pt() );
2685 hESDDalitzPositronAfterPt[fiCut]->Fill( positronVgamma->Pt() );
2686
2687 hESDDalitzElectronAfterEta[fiCut]->Fill( electronVgamma->Eta() );
2688 hESDDalitzPositronAfterEta[fiCut]->Fill( positronVgamma->Eta() );
2689
2690 hESDDalitzElectronAfterPhi[fiCut]->Fill( electronVgamma->Phi() );
2691 hESDDalitzPositronAfterPhi[fiCut]->Fill( positronVgamma->Phi() );
2692
2693 hESDDalitzElectronAfterNFindClsTPC[fiCut]->Fill(clsToFNeg,electronVgamma->Pt());
2694 hESDDalitzPositronAfterNFindClsTPC[fiCut]->Fill(clsToFPos,positronVgamma->Pt());
2695
2696 hESDDalitzElectronAfterNClsTPC[fiCut]->Fill( NumClsTPCNeg,electronVgamma->Pt());
2697 hESDDalitzPositronAfterNClsTPC[fiCut]->Fill( NumClsTPCPos,positronVgamma->Pt());
2698
2699 hESDDalitzElectronAfterNCrossedRowsTPC[fiCut]->Fill( nCrossedRowsTPCNeg, electronVgamma->Pt() );
2700 hESDDalitzPositronAfterNCrossedRowsTPC[fiCut]->Fill( nCrossedRowsTPCPos, positronVgamma->Pt() );
2701
2702 hESDDalitzElectronAfterNClsITS[fiCut]->Fill( NumClsITSNeg);
2703 hESDDalitzPositronAfterNClsITS[fiCut]->Fill( NumClsITSPos);
2704
2705 hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYNeg, electronVgamma->Pt() );
2706 hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZNeg, electronVgamma->Pt() );
2707 hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYPos, positronVgamma->Pt() );
2708 hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZPos, positronVgamma->Pt() );
2709
2710 hESDDalitzElectronAfterTPCdEdxVsP[fiCut]->Fill( electronVgamma->P(),nSigmaNegTPC);
2711 hESDDalitzPositronAfterTPCdEdxVsP[fiCut]->Fill( positronVgamma->P(), nSigmaPosTPC);
2712
2713 hESDDalitzElectronAfterTPCdEdxVsEta[fiCut]->Fill( electronVgamma->Eta(),nSigmaNegTPC);
2714 hESDDalitzPositronAfterTPCdEdxVsEta[fiCut]->Fill( positronVgamma->Eta(),nSigmaPosTPC);
2715
2716 hESDDalitzElectronAfterTPCdEdxVsPhi[fiCut]->Fill( electronVgamma->Phi(),nSigmaNegTPC);
2717 hESDDalitzPositronAfterTPCdEdxVsPhi[fiCut]->Fill( positronVgamma->Phi(),nSigmaPosTPC);
2718
2719 hESDDalitzElectronAfterTPCdEdxSignalVsP[fiCut]->Fill( electronVgamma->P(), TMath::Abs(electronVgamma->GetTPCsignal()));
2720 hESDDalitzPositronAfterTPCdEdxSignalVsP[fiCut]->Fill( positronVgamma->P(), TMath::Abs(positronVgamma->GetTPCsignal()));
2721
ccfa8c0d 2722}
2723
2724
a280ac15 2725//_____________________________________________________________________________
2726Double_t AliAnalysisTaskGammaConvDalitzV1::GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg ) const
2727{
344100c4 2728 //
2729 // This angle is a measure for the contribution of the opening in polar
2730 // direction ?0 to the opening angle ? Pair
2731 //
2732 // Ref. Measurement of photons via conversion pairs with the PHENIX experiment at RHIC
2733 // Mas ter Thesis. Thorsten Dahms. 2005
2734 // https://twiki.cern.ch/twiki/pub/ALICE/GammaPhysicsPublications/tdahms_thesis.pdf
2735 //
2736 Double_t momPos[3];
2737 Double_t momNeg[3];
2738 if( trackPos->GetConstrainedPxPyPz(momPos) == 0 ) trackPos->GetPxPyPz( momPos );
2739 if( trackNeg->GetConstrainedPxPyPz(momNeg) == 0 ) trackNeg->GetPxPyPz( momNeg );
a280ac15 2740
344100c4 2741 TVector3 posDaughter;
2742 TVector3 negDaughter;
a280ac15 2743
344100c4 2744 posDaughter.SetXYZ( momPos[0], momPos[1], momPos[2] );
2745 negDaughter.SetXYZ( momNeg[0], momNeg[1], momNeg[2] );
a280ac15 2746
344100c4 2747 Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();
2748 Double_t openingAngle = posDaughter.Angle( negDaughter ); //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );
a280ac15 2749
344100c4 2750 if( openingAngle < 1e-20 ) return 0.;
a280ac15 2751
344100c4 2752 Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );
a280ac15 2753
344100c4 2754 return psiAngle;
4803eb1f 2755}