]> 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
updated GammaConv software to estimate pileup
[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():
a280ac15 62fV0Reader(NULL),
2bb2434e 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 fTrueList(NULL),
72 fMCList(NULL),
73 fOutputContainer(0),
74 fReaderGammas(NULL),
75 fSelectorElectronIndex(0),
76 fSelectorPositronIndex(0),
77 fGoodGammas(NULL),
78 fGoodVirtualGammas(NULL),
79 fGoodElectrons(NULL),
80 fGoodPositrons(NULL),
81 fCutGammaArray(NULL),
82 fCutElectronArray(NULL),
83 fCutMesonArray(NULL),
84 fGammasPool(NULL),
85 fConversionCuts(NULL),
86 hESDConvGammaPt(NULL),
87 hESDDalitzElectronPt(NULL),
88 hESDDalitzPositronPt(NULL),
4803eb1f 89 hESDDalitzElectronPhi(NULL),
90 hESDDalitzPositronPhi(NULL),
91 hESDDalitzElectronAfterPt(NULL),
92 hESDDalitzPositronAfterPt(NULL),
93 hESDDalitzElectronAfterPhi(NULL),
94 hESDDalitzPositronAfterPhi(NULL),
95 hESDDalitzElectronAfterNFindClsTPC(NULL),
96 hESDDalitzPositronAfterNFindClsTPC(NULL),
97 hESDDalitzPosEleAfterDCAxy(NULL),
98 hESDDalitzPosEleAfterDCAz(NULL),
99 hESDDalitzPosEleAfterTPCdEdx(NULL),
100 hESDDalitzPosEleAfterTPCdEdxSignal(NULL),
101 hESDMotherPhi(NULL),
2bb2434e 102 hESDEposEnegPsiPairDPhi(NULL),
a280ac15 103 hESDEposEnegInvMassPt(NULL),
0a2b2b4b 104 hESDEposEnegLikeSignBackInvMassPt(NULL),
2bb2434e 105 hESDMotherInvMassPt(NULL),
a280ac15 106 hESDPi0MotherInvMassPt(NULL),
107 hESDPi0MotherDiffInvMassPt(NULL),
ae947965 108 hESDPi0MotherDiffLimInvMassPt(NULL),
2bb2434e 109 sESDMotherInvMassPtZM(NULL),
110 hESDMotherBackInvMassPt(NULL),
111 sESDMotherBackInvMassPtZM(NULL),
ccfa8c0d 112 hMCAllGammaPt(NULL),
ae947965 113 hMCConvGammaPt(NULL),
114 hMCConvGammaRSPt(NULL),
ccfa8c0d 115 hMCAllPositronsPt(NULL),
116 hMCAllElectronsPt(NULL),
117 hMCPi0DalitzGammaPt(NULL),
118 hMCPi0DalitzElectronPt(NULL),
119 hMCPi0DalitzPositronPt(NULL),
2bb2434e 120 hMCPi0Pt(NULL),
a280ac15 121 hMCPi0GGPt(NULL),
2bb2434e 122 hMCEtaPt(NULL),
a280ac15 123 hMCEtaGGPt(NULL),
2bb2434e 124 hMCPi0InAccPt(NULL),
125 hMCEtaInAccPt(NULL),
0f8c33c1 126 hMCChiCPt(NULL),
127 hMCChiCInAccPt(NULL),
ccfa8c0d 128 hESDEposEnegTruePi0DalitzInvMassPt(NULL),
129 hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
130 hESDEposEnegTruePhotonInvMassPt(NULL),
0f8c33c1 131 hESDEposEnegTrueJPsiInvMassPt(NULL),
132 hESDTrueMotherChiCInvMassPt(NULL),
ae947965 133 hESDTrueMotherChiCDiffInvMassPt(NULL),
2bb2434e 134 hESDTrueMotherInvMassPt(NULL),
4803eb1f 135 hESDTrueMotherDalitzInvMassPt(NULL),
2bb2434e 136 hESDTrueMotherPi0GGInvMassPt(NULL),
137 hESDTruePrimaryMotherInvMassMCPt(NULL),
138 hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
139 hESDTrueSecondaryMotherInvMassPt(NULL),
140 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
141 hESDTrueBckGGInvMassPt(NULL),
142 hESDTrueBckContInvMassPt(NULL),
143 hESDTrueMotherGGInvMassPt(NULL),
144 hESDTrueConvGammaPt(NULL),
ccfa8c0d 145 hESDTruePositronPt(NULL),
146 hESDTrueElectronPt(NULL),
ae947965 147 hESDTrueSecConvGammaPt(NULL),
148 hESDTrueSecPositronPt(NULL),
149 hESDTrueSecElectronPt(NULL),
ccfa8c0d 150 hESDTruePi0DalitzConvGammaPt(NULL),
151 hESDTruePi0DalitzPositronPt(NULL),
152 hESDTruePi0DalitzElectronPt(NULL),
ae947965 153 hESDTruePi0DalitzSecConvGammaPt(NULL),
154 hESDTruePi0DalitzSecPositronPt(NULL),
155 hESDTruePi0DalitzSecElectronPt(NULL),
2bb2434e 156 hNEvents(NULL),
157 hNGoodESDTracks(NULL),
158 fRandom(0),
159 fUnsmearedPx(NULL),
160 fUnsmearedPy(NULL),
161 fUnsmearedPz(NULL),
162 fUnsmearedE(NULL),
163 fnCuts(0),
164 fiCut(0),
165 fNumberOfESDTracks(0),
166 fMoveParticleAccordingToVertex(kFALSE),
167 fIsHeavyIon(kFALSE),
ae947965 168 fDoMesonAnalysis(kTRUE),
169 fIsFromMBHeader(kTRUE),
170 fIsMC(kFALSE)
2bb2434e 171{
a280ac15 172
2bb2434e 173}
174
175//-----------------------------------------------------------------------------------------------
176AliAnalysisTaskGammaConvDalitzV1::AliAnalysisTaskGammaConvDalitzV1( const char* name ):
177 AliAnalysisTaskSE(name),
178 fV0Reader(NULL),
179 fElecSelector(NULL),
180 fBGHandler(NULL),
181 fESDEvent(NULL),
182 fMCEvent(NULL),
183 fMCStack(NULL),
184 fCutFolder(NULL),
185 fESDList(NULL),
186 fBackList(NULL),
187 fTrueList(NULL),
188 fMCList(NULL),
189 fOutputContainer(0),
190 fReaderGammas(NULL),
191 fSelectorElectronIndex(0),
192 fSelectorPositronIndex(0),
193 fGoodGammas(NULL),
194 fGoodVirtualGammas(NULL),
195 fGoodElectrons(NULL),
196 fGoodPositrons(NULL),
197 fCutGammaArray(NULL),
198 fCutElectronArray(NULL),
199 fCutMesonArray(NULL),
200 fGammasPool(NULL),
201 fConversionCuts(NULL),
202 hESDConvGammaPt(NULL),
203 hESDDalitzElectronPt(NULL),
204 hESDDalitzPositronPt(NULL),
4803eb1f 205 hESDDalitzElectronPhi(NULL),
206 hESDDalitzPositronPhi(NULL),
207 hESDDalitzElectronAfterPt(NULL),
208 hESDDalitzPositronAfterPt(NULL),
209 hESDDalitzElectronAfterPhi(NULL),
210 hESDDalitzPositronAfterPhi(NULL),
211 hESDDalitzElectronAfterNFindClsTPC(NULL),
212 hESDDalitzPositronAfterNFindClsTPC(NULL),
213 hESDDalitzPosEleAfterDCAxy(NULL),
214 hESDDalitzPosEleAfterDCAz(NULL),
215 hESDDalitzPosEleAfterTPCdEdx(NULL),
216 hESDDalitzPosEleAfterTPCdEdxSignal(NULL),
217 hESDMotherPhi(NULL),
2bb2434e 218 hESDEposEnegPsiPairDPhi(NULL),
a280ac15 219 hESDEposEnegInvMassPt(NULL),
0a2b2b4b 220 hESDEposEnegLikeSignBackInvMassPt(NULL),
2bb2434e 221 hESDMotherInvMassPt(NULL),
a280ac15 222 hESDPi0MotherInvMassPt(NULL),
223 hESDPi0MotherDiffInvMassPt(NULL),
ae947965 224 hESDPi0MotherDiffLimInvMassPt(NULL),
2bb2434e 225 sESDMotherInvMassPtZM(NULL),
226 hESDMotherBackInvMassPt(NULL),
227 sESDMotherBackInvMassPtZM(NULL),
ccfa8c0d 228 hMCAllGammaPt(NULL),
ae947965 229 hMCConvGammaPt(NULL),
230 hMCConvGammaRSPt(NULL),
ccfa8c0d 231 hMCAllPositronsPt(NULL),
232 hMCAllElectronsPt(NULL),
233 hMCPi0DalitzGammaPt(NULL),
234 hMCPi0DalitzElectronPt(NULL),
235 hMCPi0DalitzPositronPt(NULL),
2bb2434e 236 hMCPi0Pt(NULL),
a280ac15 237 hMCPi0GGPt(NULL),
2bb2434e 238 hMCEtaPt(NULL),
a280ac15 239 hMCEtaGGPt(NULL),
2bb2434e 240 hMCPi0InAccPt(NULL),
241 hMCEtaInAccPt(NULL),
0f8c33c1 242 hMCChiCPt(NULL),
243 hMCChiCInAccPt(NULL),
ccfa8c0d 244 hESDEposEnegTruePi0DalitzInvMassPt(NULL),
245 hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
246 hESDEposEnegTruePhotonInvMassPt(NULL),
0f8c33c1 247 hESDEposEnegTrueJPsiInvMassPt(NULL),
248 hESDTrueMotherChiCInvMassPt(NULL),
ae947965 249 hESDTrueMotherChiCDiffInvMassPt(NULL),
2bb2434e 250 hESDTrueMotherInvMassPt(NULL),
4803eb1f 251 hESDTrueMotherDalitzInvMassPt(NULL),
2bb2434e 252 hESDTrueMotherPi0GGInvMassPt(NULL),
253 hESDTruePrimaryMotherInvMassMCPt(NULL),
254 hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
255 hESDTrueSecondaryMotherInvMassPt(NULL),
256 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
257 hESDTrueBckGGInvMassPt(NULL),
258 hESDTrueBckContInvMassPt(NULL),
259 hESDTrueMotherGGInvMassPt(NULL),
260 hESDTrueConvGammaPt(NULL),
ccfa8c0d 261 hESDTruePositronPt(NULL),
262 hESDTrueElectronPt(NULL),
ae947965 263 hESDTrueSecConvGammaPt(NULL),
264 hESDTrueSecPositronPt(NULL),
265 hESDTrueSecElectronPt(NULL),
ccfa8c0d 266 hESDTruePi0DalitzConvGammaPt(NULL),
267 hESDTruePi0DalitzPositronPt(NULL),
268 hESDTruePi0DalitzElectronPt(NULL),
ae947965 269 hESDTruePi0DalitzSecConvGammaPt(NULL),
270 hESDTruePi0DalitzSecPositronPt(NULL),
271 hESDTruePi0DalitzSecElectronPt(NULL),
2bb2434e 272 hNEvents(NULL),
273 hNGoodESDTracks(NULL),
274 fRandom(0),
275 fUnsmearedPx(NULL),
276 fUnsmearedPy(NULL),
277 fUnsmearedPz(NULL),
278 fUnsmearedE(NULL),
279 fnCuts(0),
280 fiCut(0),
281 fNumberOfESDTracks(0),
282 fMoveParticleAccordingToVertex(kFALSE),
283 fIsHeavyIon(kFALSE),
ae947965 284 fDoMesonAnalysis(kTRUE),
285 fIsFromMBHeader(kTRUE),
286 fIsMC(kFALSE)
2bb2434e 287{
a280ac15 288 DefineOutput(1, TList::Class());
2bb2434e 289}
290
291//-----------------------------------------------------------------------------------------------
292AliAnalysisTaskGammaConvDalitzV1::~AliAnalysisTaskGammaConvDalitzV1()
293{
a280ac15 294 //
295 // virtual destructor
296 //
297 cout<<"Destructor"<<endl;
2bb2434e 298
299 if(fGoodGammas){
300 delete fGoodGammas;
301 fGoodGammas = 0x0;
302 }
303 if(fGoodVirtualGammas){
304 delete fGoodVirtualGammas;
305 fGoodGammas = 0x0;
306 }
307 if(fGoodElectrons){
308 delete fGoodGammas;
309 fGoodGammas = 0x0;
310 }
311 if(fGoodPositrons){
312 delete fGoodGammas;
313 fGoodGammas = 0x0;
314 }
315 if(fBGHandler){
316 delete[] fBGHandler;
317 fBGHandler = 0x0;
318 }
a280ac15 319 if( fGammasPool ){
320 delete[] fGammasPool;
321 fGammasPool = 0x0;
322 }
2bb2434e 323}
324
325//___________________________________________________________
326void AliAnalysisTaskGammaConvDalitzV1::InitBack(){
327
0a2b2b4b 328 Double_t *zBinLimitsArray= new Double_t[9];
2bb2434e 329 zBinLimitsArray[0] = -50.00;
330 zBinLimitsArray[1] = -3.375;
331 zBinLimitsArray[2] = -1.605;
332 zBinLimitsArray[3] = -0.225;
333 zBinLimitsArray[4] = 1.065;
334 zBinLimitsArray[5] = 2.445;
335 zBinLimitsArray[6] = 4.245;
336 zBinLimitsArray[7] = 50.00;
337 zBinLimitsArray[8] = 1000.00;
338
0a2b2b4b 339 Double_t *multiplicityBinLimitsArrayTracks= new Double_t[6];
2bb2434e 340 multiplicityBinLimitsArrayTracks[0] = 0;
341 multiplicityBinLimitsArrayTracks[1] = 8.5;
342 multiplicityBinLimitsArrayTracks[2] = 16.5;
343 multiplicityBinLimitsArrayTracks[3] = 27.5;
344 multiplicityBinLimitsArrayTracks[4] = 41.5;
345 multiplicityBinLimitsArrayTracks[5] = 200.;
a280ac15 346
2bb2434e 347 if(fIsHeavyIon){
348 multiplicityBinLimitsArrayTracks[0] = 0;
349 multiplicityBinLimitsArrayTracks[1] = 200.;
350 multiplicityBinLimitsArrayTracks[2] = 500.;
351 multiplicityBinLimitsArrayTracks[3] = 1000.;
352 multiplicityBinLimitsArrayTracks[4] = 1500.;
353 multiplicityBinLimitsArrayTracks[5] = 5000.;
354 }
355
0a2b2b4b 356 Double_t *multiplicityBinLimitsArrayV0s= new Double_t[5];
a280ac15 357
2bb2434e 358 multiplicityBinLimitsArrayV0s[0] = 2;
359 multiplicityBinLimitsArrayV0s[1] = 3;
360 multiplicityBinLimitsArrayV0s[2] = 4;
361 multiplicityBinLimitsArrayV0s[3] = 5;
362 multiplicityBinLimitsArrayV0s[4] = 9999;
a280ac15 363
2bb2434e 364 if(fIsHeavyIon){
365 multiplicityBinLimitsArrayV0s[0] = 2;
366 multiplicityBinLimitsArrayV0s[1] = 10;
367 multiplicityBinLimitsArrayV0s[2] = 30;
368 multiplicityBinLimitsArrayV0s[3] = 50;
369 multiplicityBinLimitsArrayV0s[4] = 9999;
370 }
371
372 const Int_t nDim = 4;
a280ac15 373 Int_t nBins[nDim] = {1000,250,8,5};
374 Double_t xMin[nDim] = {0,0, 0,0};
375 Double_t xMax[nDim] = {1,25,8,5};
2bb2434e 376
a280ac15 377 sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
2bb2434e 378 sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
379
a280ac15 380
2bb2434e 381 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
382
383 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
384
385
a280ac15 386 TString cutstringElectron = ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
387 TString cutstringMeson = ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
388 TString cutstringGamma = ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
2bb2434e 389
390
391 fBackList[iCut] = new TList();
392 fBackList[iCut]->SetName(Form("%s_%s_%s Back histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
393 fBackList[iCut]->SetOwner(kTRUE);
394 fCutFolder[iCut]->Add(fBackList[iCut]);
395
2bb2434e 396 sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
397 sESDMotherInvMassPtZM[iCut]->Sumw2();
398 fBackList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
399 sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
400 sESDMotherBackInvMassPtZM[iCut]->Sumw2();
401 fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
402
a280ac15 403 if(((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->UseTrackMultiplicity()) {
404 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(9,6,((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->NumberOfRotationEvents());
2bb2434e 405 fBGHandler[iCut]->Initialize(zBinLimitsArray, multiplicityBinLimitsArrayTracks);
406 }
407 else{
a280ac15 408 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(9,5,((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->NumberOfRotationEvents());
2bb2434e 409 fBGHandler[iCut]->Initialize(zBinLimitsArray, multiplicityBinLimitsArrayV0s);
410 }
a280ac15 411 if( ( (AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetBKGMethod() == 3 ){
412 fGammasPool[iCut] = new TList();
413 }
2bb2434e 414 }
a280ac15 415
2bb2434e 416}
417
418//______________________________________________________________________
419void AliAnalysisTaskGammaConvDalitzV1::UserCreateOutputObjects()
420{
a280ac15 421 //
422 // Create ouput objects
423 //
424
425 // Create the output container
426 if(fOutputContainer != NULL){
427 delete fOutputContainer;
428 fOutputContainer = NULL;
429 }
430 if(fOutputContainer == NULL){
431 fOutputContainer = new TList();
432 fOutputContainer->SetOwner(kTRUE);
433 }
434
435 fGoodGammas = new TList();
436 //fGoodGammas->SetOwner(kTRUE);
437
438
439 fGoodVirtualGammas = new TList();
440 //fGoodVirtualGammas->SetOwner(kTRUE);
441
442
443
a280ac15 444 fGammasPool = new TList*[fnCuts];
445 fCutFolder = new TList*[fnCuts];
446 fESDList = new TList*[fnCuts];
447 fBackList = new TList*[fnCuts];
448 hNEvents = new TH1I*[fnCuts];
449 hNGoodESDTracks = new TH1I*[fnCuts];
450 hESDConvGammaPt = new TH1F*[fnCuts];
451 hESDDalitzElectronPt = new TH1F*[fnCuts];
452 hESDDalitzPositronPt = new TH1F*[fnCuts];
4803eb1f 453 hESDDalitzElectronPhi = new TH1F*[fnCuts];
454 hESDDalitzPositronPhi = new TH1F*[fnCuts];
455 hESDDalitzElectronAfterPt = new TH1F*[fnCuts];
456 hESDDalitzPositronAfterPt = new TH1F*[fnCuts];
457 hESDDalitzElectronAfterPhi = new TH1F*[fnCuts];
458 hESDDalitzPositronAfterPhi = new TH1F*[fnCuts];
459 hESDDalitzElectronAfterNFindClsTPC = new TH2F*[fnCuts];
460 hESDDalitzPositronAfterNFindClsTPC = new TH2F*[fnCuts];
461 hESDDalitzPosEleAfterDCAxy = new TH2F*[fnCuts];
462 hESDDalitzPosEleAfterDCAz = new TH2F*[fnCuts];
463 hESDDalitzPosEleAfterTPCdEdx = new TH2F*[fnCuts];
464 hESDDalitzPosEleAfterTPCdEdxSignal = new TH2F*[fnCuts];
465 hESDMotherPhi = new TH1F*[fnCuts];
a280ac15 466 hESDEposEnegPsiPairDPhi = new TH2F*[fnCuts];
467 hESDEposEnegInvMassPt = new TH2F*[fnCuts];
0a2b2b4b 468 hESDEposEnegLikeSignBackInvMassPt = new TH2F*[fnCuts];
a280ac15 469 hESDMotherInvMassPt = new TH2F*[fnCuts];
470 hESDPi0MotherInvMassPt = new TH2F*[fnCuts];
471 hESDPi0MotherDiffInvMassPt = new TH2F*[fnCuts];
ae947965 472 hESDPi0MotherDiffLimInvMassPt = new TH2F*[fnCuts];
a280ac15 473 hESDMotherBackInvMassPt = new TH2F*[fnCuts];
474
475
476 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
477
478
479 TString cutstringElectron =((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
480 TString cutstringMeson= ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
481 TString cutstringGamma = ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
482
483 fCutFolder[iCut] = new TList();
484 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
485 fCutFolder[iCut]->SetOwner(kTRUE);
486 fOutputContainer->Add(fCutFolder[iCut]);
487
488 fESDList[iCut] = new TList();
489 fESDList[iCut]->SetName(Form("%s_%s_%s ESD histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
490 fESDList[iCut]->SetOwner(kTRUE);
491
492
493
494 hNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
495 hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
496 hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
497 hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
498 hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
499 hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
500 hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
501 hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
502 hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
503 hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
504 fESDList[iCut]->Add(hNEvents[iCut]);
505
506
507
a280ac15 508 if(fIsHeavyIon) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",3000,0,3000);
509 else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
510 fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
511
512 hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
513 fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
514
ae947965 515 hESDDalitzElectronPt[iCut] = new TH1F("ESD_DalitzElectron_Pt","ESD_DalitzElectron_Pt",1000,0,25);
a280ac15 516 fESDList[iCut]->Add(hESDDalitzElectronPt[iCut]);
517
ae947965 518 hESDDalitzPositronPt[iCut] = new TH1F("ESD_DalitzPositron_Pt","ESD_DalitzPositron_Pt",1000,0,25);
a280ac15 519 fESDList[iCut]->Add(hESDDalitzPositronPt[iCut]);
4803eb1f 520
521
522 hESDDalitzElectronPhi[iCut] = new TH1F("ESD_DalitzElectron_Phi","ESD_DalitzElectron_Phi",360,0,2*TMath::Pi());
523 fESDList[iCut]->Add(hESDDalitzElectronPhi[iCut]);
524
525 hESDDalitzPositronPhi[iCut] = new TH1F("ESD_DalitzPositron_Phi","ESD_DalitzPositron_Phi",360,0,2*TMath::Pi());
526 fESDList[iCut]->Add(hESDDalitzPositronPhi[iCut]);
527
528
529
530 hESDDalitzElectronAfterPt[iCut] = new TH1F("ESD_DalitzElectron_After_Pt","ESD_DalitzElectron_After_Pt",1000,0,25);
531 fESDList[iCut]->Add(hESDDalitzElectronAfterPt[iCut]);
a280ac15 532
4803eb1f 533 hESDDalitzPositronAfterPt[iCut] = new TH1F("ESD_DalitzPositron_After_Pt","ESD_DalitzPositron_After_Pt",1000,0,25);
534 fESDList[iCut]->Add(hESDDalitzPositronAfterPt[iCut]);
535
536
537 hESDDalitzElectronAfterPhi[iCut] = new TH1F("ESD_DalitzElectron_After_Phi","ESD_DalitzElectron_After_Phi",360,0,2*TMath::Pi());
538 fESDList[iCut]->Add(hESDDalitzElectronAfterPhi[iCut]);
a280ac15 539
4803eb1f 540 hESDDalitzPositronAfterPhi[iCut] = new TH1F("ESD_DalitzPositron_After_Phi","ESD_DalitzPositron_After_Phi",360,0,2*TMath::Pi());
541 fESDList[iCut]->Add(hESDDalitzPositronAfterPhi[iCut]);
542
543 hESDDalitzElectronAfterNFindClsTPC[iCut] = new TH2F("ESD_DalitzElectron_After_NFindClsTPC","ESD_DalitzElectron_After_NFindClsTPC",100,0,1,400,0.,10.);
544 fESDList[iCut]->Add(hESDDalitzElectronAfterNFindClsTPC[iCut]);
545
546 hESDDalitzPositronAfterNFindClsTPC[iCut] = new TH2F("ESD_DalitzPositron_After_NFindClsTPC","ESD_DalitzPositron_After_NFindClsTPC",100,0,1,400,0.,10.);
547 fESDList[iCut]->Add(hESDDalitzPositronAfterNFindClsTPC[iCut]);
548
549 hESDDalitzPosEleAfterDCAxy[iCut] = new TH2F("ESD_DalitzPosEle_After_DCAxy","ESD_DalitzPosEle_After_DCAxy",800,-4.0,4.0,400,0.,10.);
550 fESDList[iCut]->Add(hESDDalitzPosEleAfterDCAxy[iCut]);
551
552 hESDDalitzPosEleAfterDCAz[iCut] = new TH2F("ESD_DalitzPosEle_After_DCAz","ESD_DalitzPosEle_After_DCAz",800,-4.0,4.0,400,0.,10.);
553 fESDList[iCut]->Add(hESDDalitzPosEleAfterDCAz[iCut]);
554
555 hESDDalitzPosEleAfterTPCdEdx[iCut] = new TH2F("ESD_DalitzPosEle_After_TPCdEdx","ESD_DalitzPosEle_After_TPCdEdx",150,0.05,20,400,-10,10);
556 fESDList[iCut]->Add(hESDDalitzPosEleAfterTPCdEdx[iCut]);
557
558 hESDDalitzPosEleAfterTPCdEdxSignal[iCut] =new TH2F("ESD_DalitzPosEle_After_TPCdEdxSignal","ESD_DalitzPosEle_After_TPCdEdxSignal" ,150,0.05,20.0,800,0.0,200);
559 fESDList[iCut]->Add(hESDDalitzPosEleAfterTPCdEdxSignal[iCut]);
560
a280ac15 561 hESDEposEnegPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_PsiPair_DPhi","ESD_EposEneg_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
562 fESDList[iCut]->Add(hESDEposEnegPsiPairDPhi[iCut]);
563
564 hESDEposEnegInvMassPt[iCut] = new TH2F("ESD_EposEneg_InvMassPt","ESD_EposEneg_InvMassPt",5000,0.,5.,100,0.,10.);
565 fESDList[iCut]->Add(hESDEposEnegInvMassPt[iCut]);
0a2b2b4b 566
567 hESDEposEnegLikeSignBackInvMassPt[iCut] = new TH2F("ESD_EposEneg_LikeSignBack_InvMassPt","ESD_EposEneg_LikeSignBack_InvMassPt",5000,0.,5.,100,0.,10.);
568 fESDList[iCut]->Add(hESDEposEnegLikeSignBackInvMassPt[iCut]);
a280ac15 569
a280ac15 570 hESDMotherInvMassPt[iCut] = new TH2F("ESD_DalitzMother_InvMass_Pt","ESD_DalitzMother_InvMass_Pt",1000,0,1,250,0,25);
571 fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
4803eb1f 572
573 hESDMotherPhi[iCut] = new TH1F("ESD_DalitzMother_Phi","ESD_DalitzMother_Phi",360,0,2*TMath::Pi());
574 fESDList[iCut]->Add(hESDMotherPhi[iCut]);
575
a280ac15 576 hESDPi0MotherInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_InvMass_Pt","ESD_Pi0Mother_InvMass_Pt",4000,0,4,250,0,25);
577 fESDList[iCut]->Add(hESDPi0MotherInvMassPt[iCut]);
ccfa8c0d 578
a280ac15 579 hESDPi0MotherDiffInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffInvMass_Pt","ESD_Pi0Mother_DiffInvMass_Pt",2000,0,2,250,0,25);
580 fESDList[iCut]->Add(hESDPi0MotherDiffInvMassPt[iCut]);
2bb2434e 581
ae947965 582 hESDPi0MotherDiffLimInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffLimInvMass_Pt","ESD_Pi0Mother_DiffLimInvMass_Pt",2000,0,2,250,0,25);
583 fESDList[iCut]->Add(hESDPi0MotherDiffLimInvMassPt[iCut]);
2bb2434e 584
a280ac15 585 hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_DalitzBackground_InvMass_Pt","ESD_DalitzBackground_InvMass_Pt",1000,0,1,250,0,25);
586 fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
2bb2434e 587
2bb2434e 588
2bb2434e 589
4803eb1f 590 TAxis *AxisAfter = hESDDalitzPosEleAfterTPCdEdx[iCut]->GetXaxis();
591 Int_t bins = AxisAfter->GetNbins();
592 Double_t from = AxisAfter->GetXmin();
593 Double_t to = AxisAfter->GetXmax();
594 Double_t *newBins = new Double_t[bins+1];
595 newBins[0] = from;
596 Double_t factor = TMath::Power(to/from, 1./bins);
597 for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];
598
599 AxisAfter->Set(bins, newBins);
600 AxisAfter = hESDDalitzPosEleAfterTPCdEdxSignal[iCut]->GetXaxis();
601 AxisAfter->Set(bins, newBins);
602
603 delete [] newBins;
604
605
606
607 fCutFolder[iCut]->Add(fESDList[iCut]);
2bb2434e 608
a280ac15 609 }
2bb2434e 610
a280ac15 611
612 InitBack(); // Init Background Handler
613
614
ae947965 615 //if(MCEvent()){
616 if( fIsMC ){
a280ac15 617 // MC Histogramms
618 fMCList = new TList*[fnCuts];
619 // True Histogramms
620 fTrueList = new TList*[fnCuts];
621 hESDTrueConvGammaPt = new TH1F*[fnCuts];
ccfa8c0d 622 hESDTruePositronPt = new TH1F*[fnCuts];
623 hESDTrueElectronPt = new TH1F*[fnCuts];
ae947965 624 hESDTrueSecConvGammaPt = new TH1F*[fnCuts];
625 hESDTrueSecPositronPt = new TH1F*[fnCuts];
626 hESDTrueSecElectronPt = new TH1F*[fnCuts];
ccfa8c0d 627 hESDTruePi0DalitzConvGammaPt = new TH1F*[fnCuts];
628 hESDTruePi0DalitzPositronPt = new TH1F*[fnCuts];
629 hESDTruePi0DalitzElectronPt = new TH1F*[fnCuts];
ae947965 630 hESDTruePi0DalitzSecConvGammaPt = new TH1F*[fnCuts];
631 hESDTruePi0DalitzSecPositronPt = new TH1F*[fnCuts];
632 hESDTruePi0DalitzSecElectronPt = new TH1F*[fnCuts];
a280ac15 633 //if(fDoMesonAnalysis){
ae947965 634 hMCAllGammaPt = new TH1F*[fnCuts];
635 hMCConvGammaPt = new TH1F*[fnCuts];
636 hMCConvGammaRSPt = new TH1F*[fnCuts];
ccfa8c0d 637 hMCAllPositronsPt = new TH1F*[fnCuts];
638 hMCAllElectronsPt = new TH1F*[fnCuts];
639 hMCPi0DalitzGammaPt = new TH1F*[fnCuts];
640 hMCPi0DalitzElectronPt = new TH1F*[fnCuts];
641 hMCPi0DalitzPositronPt = new TH1F*[fnCuts];
642
a280ac15 643 hMCPi0Pt = new TH1F*[fnCuts];
644 hMCPi0GGPt = new TH1F*[fnCuts];
645 hMCEtaPt = new TH1F*[fnCuts];
646 hMCEtaGGPt = new TH1F*[fnCuts];
647 hMCPi0InAccPt = new TH1F*[fnCuts];
648 hMCEtaInAccPt = new TH1F*[fnCuts];
0f8c33c1 649 hMCChiCPt = new TH1F*[fnCuts];
650 hMCChiCInAccPt = new TH1F*[fnCuts];
ccfa8c0d 651
652 hESDEposEnegTruePi0DalitzInvMassPt = new TH2F*[fnCuts];
653 hESDEposEnegTrueEtaDalitzInvMassPt = new TH2F*[fnCuts];
654 hESDEposEnegTruePhotonInvMassPt = new TH2F*[fnCuts];
0f8c33c1 655 hESDEposEnegTrueJPsiInvMassPt = new TH2F*[fnCuts];
ccfa8c0d 656
0f8c33c1 657 hESDTrueMotherChiCInvMassPt = new TH2F*[fnCuts];
ae947965 658 hESDTrueMotherChiCDiffInvMassPt = new TH2F*[fnCuts];
a280ac15 659 hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
4803eb1f 660 hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
a280ac15 661 hESDTrueMotherPi0GGInvMassPt = new TH2F*[fnCuts];
662 hESDTruePrimaryPi0DalitzESDPtMCPt = new TH2F*[fnCuts];
663 hESDTruePrimaryMotherInvMassMCPt = new TH2F*[fnCuts];
664 hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
665 hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
666 hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
667 hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
668 hESDTrueMotherGGInvMassPt = new TH2F*[fnCuts];
669 //}
670
671 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
672 TString cutstringElectron =((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
673 TString cutstringMeson= ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
674 TString cutstringGamma = ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
675
676 fMCList[iCut] = new TList();
677 fMCList[iCut]->SetName(Form("%s_%s_%s MC histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
678 fMCList[iCut]->SetOwner(kTRUE);
679 fCutFolder[iCut]->Add(fMCList[iCut]);
680
ccfa8c0d 681
ae947965 682 hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
683 fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
684
685 hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
686 fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
687
688 hMCConvGammaRSPt[iCut] = new TH1F("MC_ConvGamma_RS_Pt","MC_ConvGamma_RS_Pt",250,0,25);
689 fMCList[iCut]->Add(hMCConvGammaRSPt[iCut]);
690
0f8c33c1 691
ae947965 692 hMCAllPositronsPt[iCut] = new TH1F("MC_AllPositrons_Pt","MC_AllPositrons_Pt",1000,0,25);
693 fMCList[iCut]->Add(hMCAllPositronsPt[iCut]);
0f8c33c1 694
ae947965 695 hMCAllElectronsPt[iCut] = new TH1F("MC_AllElectrons_Pt","MC_AllElectrons_Pt",1000,0,25);
0f8c33c1 696 fMCList[iCut]->Add(hMCAllElectronsPt[iCut]);
697
698 hMCPi0DalitzGammaPt[iCut] = new TH1F("MC_Pi0DalitzGamma_Pt","MC_Pi0DalitzGamma_Pt",250,0,25);
699 fMCList[iCut]->Add(hMCPi0DalitzGammaPt[iCut]);
700
ae947965 701 hMCPi0DalitzPositronPt[iCut] = new TH1F("MC_Pi0DalitzPositron_Pt","MC_Pi0DalitzPositron_Pt",1000,0,25);
0f8c33c1 702 fMCList[iCut]->Add(hMCPi0DalitzPositronPt[iCut]);
703
ae947965 704 hMCPi0DalitzElectronPt[iCut] = new TH1F("MC_Pi0DalitzElectron_Pt","MC_Pi0DalitzElectron_Pt",1000,0,25);
0f8c33c1 705 fMCList[iCut]->Add(hMCPi0DalitzElectronPt[iCut]);
706
707
708 hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
709 fMCList[iCut]->Add(hMCPi0Pt[iCut]);
710
711 hMCPi0GGPt[iCut] = new TH1F("MC_Pi0_GG_Pt","MC_Pi0_GG_Pt",250,0,25);
712 fMCList[iCut]->Add(hMCPi0GGPt[iCut]);
713
714 hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
715 fMCList[iCut]->Add(hMCEtaPt[iCut]);
716
717 hMCEtaGGPt[iCut] = new TH1F("MC_Eta_GG_Pt","MC_Eta_GG_Pt",250,0,25);
718 fMCList[iCut]->Add(hMCEtaGGPt[iCut]);
719
720 hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0DalitzInAcc_Pt","MC_Pi0DalitzInAcc_Pt",250,0,25);
721 fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
722
723 hMCEtaInAccPt[iCut] = new TH1F("MC_EtaDalitzInAcc_Pt","MC_EtaDalitzInAcc_Pt",250,0,25);
724 fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
725
726 hMCChiCPt[iCut] = new TH1F("MC_ChiC_Pt","MC_ChiC_Pt",250,0,25);
727 fMCList[iCut]->Add(hMCChiCPt[iCut]);
728
729 hMCChiCInAccPt[iCut] = new TH1F("MC_ChiCInAcc_Pt","MC_ChiCInAcc_Pt",250,0,25);
730 fMCList[iCut]->Add(hMCChiCInAccPt[iCut]);
a280ac15 731
732 fTrueList[iCut] = new TList();
733 fTrueList[iCut]->SetName(Form("%s_%s_%s True histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
734 fTrueList[iCut]->SetOwner(kTRUE);
735 fCutFolder[iCut]->Add(fTrueList[iCut]);
736
ccfa8c0d 737
ae947965 738 hESDEposEnegTruePi0DalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_InvMassPt","ESD_EposEneg_TruePi0Dalitz_InvMassPt",5000,0.,5.,100,0.,10.);
739 fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzInvMassPt[iCut]);
ccfa8c0d 740
ae947965 741 hESDEposEnegTrueEtaDalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueEtaDalitz_InvMassPt","ESD_EposEneg_TrueEtaDalitz_InvMassPt",5000,0.,5.,100,0.,10.);
742 fTrueList[iCut]->Add(hESDEposEnegTrueEtaDalitzInvMassPt[iCut]);
ccfa8c0d 743
ae947965 744 hESDEposEnegTruePhotonInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePhoton_InvMassPt","ESD_EposEneg_TruePhoton_InvMassPt",5000,0.,5.,100,0.,10.);
745 fTrueList[iCut]->Add(hESDEposEnegTruePhotonInvMassPt[iCut]);
ccfa8c0d 746
ae947965 747 hESDEposEnegTrueJPsiInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueJPsi_InvMassPt","ESD_EposEneg_TrueJPsi_InvMassPt",5000,0.,5.,100,0.,10.);
748 fTrueList[iCut]->Add(hESDEposEnegTrueJPsiInvMassPt[iCut]);
0f8c33c1 749
ccfa8c0d 750
ae947965 751 hESDTruePositronPt[iCut] = new TH1F("ESD_TruePositron_Pt","ESD_TruePositron_Pt",1000,0,25);
ccfa8c0d 752 fTrueList[iCut]->Add(hESDTruePositronPt[iCut]);
753
ae947965 754 hESDTrueElectronPt[iCut] = new TH1F("ESD_TrueElectron_Pt","ESD_TrueElectron_Pt",1000,0,25);
ccfa8c0d 755 fTrueList[iCut]->Add(hESDTrueElectronPt[iCut]);
ae947965 756
757 hESDTrueSecPositronPt[iCut] = new TH1F("ESD_TrueSecPositron_Pt","ESD_TrueSecPositron_Pt",1000,0,25);
758 fTrueList[iCut]->Add(hESDTrueSecPositronPt[iCut]);
759
760 hESDTrueSecElectronPt[iCut] = new TH1F("ESD_TrueSecElectron_Pt","ESD_TrueSecElectron_Pt",1000,0,25);
761 fTrueList[iCut]->Add(hESDTrueSecElectronPt[iCut]);
ccfa8c0d 762
a280ac15 763 hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
764 fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
ae947965 765
766 hESDTrueSecConvGammaPt[iCut] = new TH1F("ESD_TrueSecConvGamma_Pt","ESD_TrueSecConvGamma_Pt",250,0,25);
767 fTrueList[iCut]->Add(hESDTrueSecConvGammaPt[iCut]);
a280ac15 768
ccfa8c0d 769 hESDTruePi0DalitzConvGammaPt[iCut] = new TH1F("ESD_TruePi0DalitzConvGamma_Pt","ESD_TruePi0DalitzConvGamma_Pt",250,0,25);
770 fTrueList[iCut]->Add(hESDTruePi0DalitzConvGammaPt[iCut]);
771
ae947965 772 hESDTruePi0DalitzElectronPt[iCut] = new TH1F("ESD_TruePi0DalitzElectron_Pt","ESD_TruePi0DalitzElectron_Pt",1000,0,25);
ccfa8c0d 773 fTrueList[iCut]->Add(hESDTruePi0DalitzElectronPt[iCut]);
774
ae947965 775 hESDTruePi0DalitzPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzPositron_Pt","ESD_TruePi0DalitzPositron_Pt",1000,0,25);
ccfa8c0d 776 fTrueList[iCut]->Add(hESDTruePi0DalitzPositronPt[iCut]);
ae947965 777
778 hESDTruePi0DalitzSecConvGammaPt[iCut] = new TH1F("ESD_TruePi0DalitzSecConvGamma_Pt","ESD_TruePi0DalitzSecConvGamma_Pt",250,0,25);
779 fTrueList[iCut]->Add(hESDTruePi0DalitzSecConvGammaPt[iCut]);
780
781 hESDTruePi0DalitzSecElectronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecElectron_Pt","ESD_TruePi0DalitzSecElectron_Pt",1000,0,25);
782 fTrueList[iCut]->Add(hESDTruePi0DalitzSecElectronPt[iCut]);
ccfa8c0d 783
ae947965 784 hESDTruePi0DalitzSecPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecPositron_Pt","ESD_TruePi0DalitzSecPositron_Pt",1000,0,25);
785 fTrueList[iCut]->Add(hESDTruePi0DalitzSecPositronPt[iCut]);
ccfa8c0d 786
ae947965 787 hESDTrueMotherChiCInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiC_InvMass_Pt","ESD_TrueMotherChiC_InvMass_Pt",1000,0,4,250,0,25);
0f8c33c1 788 fTrueList[iCut]->Add(hESDTrueMotherChiCInvMassPt[iCut]);
ccfa8c0d 789
ae947965 790 hESDTrueMotherChiCDiffInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiCDiff_InvMass_Pt","ESD_TrueMotherChiCDiff_InvMass_Pt",1000,0,1,250,0,25);
791 fTrueList[iCut]->Add(hESDTrueMotherChiCDiffInvMassPt[iCut]);
ccfa8c0d 792
a280ac15 793 hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",1000,0,1,250,0,25);
794 fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
4803eb1f 795
796 hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueMother_Dalitz_InvMass_Pt","ESD_TrueMother_Dalitz_InvMass_Pt",1000,0,1,250,0,25);
797 fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
798
799
800
801
a280ac15 802
803 hESDTrueMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueMotherPi0GG_InvMass_Pt","ESD_TrueMotherPi0GG_InvMass_Pt",1000,0,1,250,0,25);
804 fTrueList[iCut]->Add(hESDTrueMotherPi0GGInvMassPt[iCut]);
805 hESDTruePrimaryPi0DalitzESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt","ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt",250,0,25,250,0,25);
806 fTrueList[iCut]->Add(hESDTruePrimaryPi0DalitzESDPtMCPt[iCut]);
807 hESDTruePrimaryMotherInvMassMCPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_MCPt","ESD_TrueDalitzPrimaryMother_InvMass_MCPt",1000,0,1,250,0,25);
808 fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassMCPt[iCut]);
809 hESDTrueSecondaryMotherInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMother_InvMass_Pt","ESD_TrueDalitzSecondaryMother_InvMass_Pt",1000,0,1,250,0,25);
810 fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
811 // hESDTrueSecondaryMotherFromK0sInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt",1000,0,1,250,0,25);
812 // fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
813 hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckGG_InvMass_Pt","ESD_TrueDalitzBckGG_InvMass_Pt",1000,0,1,250,0,25);
814 fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
815 hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckCont_InvMass_Pt","ESD_TrueDalitzBckCont_InvMass_Pt",1000,0,1,250,0,25);
816 fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
817 // hESDTrueMotherGGInvMassPt[iCut] = new TH2F("ESD_TrueGammaGamma_InvMass_Pt","ESD_TrueGammaGamma_InvMass_Pt",1000,0,1,250,0,25);
818 // fTrueList[iCut]->Add(hESDTrueMotherGGInvMassPt[iCut]);
819
820 }
821 }
822
823 PostData(1, fOutputContainer);
2bb2434e 824
825}
826
827//______________________________________________________________________
828void AliAnalysisTaskGammaConvDalitzV1::UserExec(Option_t *)
829{
a280ac15 830
831 //
832 // Execute analysis for current event
833 //
834
2bb2434e 835 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
836 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
837
a280ac15 838
2bb2434e 839 Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
840
a280ac15 841 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
ae947965 842 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
843 hNEvents[iCut]->Fill(eventQuality);
844 }
2bb2434e 845 return;
846 }
847
a280ac15 848
2bb2434e 849 fElecSelector=(AliDalitzElectronSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("ElectronSelector");
850 if(!fElecSelector){printf("Error: No ElectronSelector");return;} // GetV0Reader
851
852
ae947965 853 if(fIsMC) fMCEvent = MCEvent();
a280ac15 854 fESDEvent = (AliESDEvent*)InputEvent();
855 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
2bb2434e 856 fSelectorElectronIndex = fElecSelector->GetReconstructedElectronsIndex(); // Electrons from default Cut
857 fSelectorPositronIndex = fElecSelector->GetReconstructedPositronsIndex(); // Positrons from default Cut
2bb2434e 858
a280ac15 859 CountESDTracks(); // Estimate Event Multiplicity
860 //AddTaskContainers(); //Add conatiner
2bb2434e 861
a280ac15 862 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
2bb2434e 863 fiCut = iCut;
864
a280ac15 865 Int_t eventNotAccepted =
866 ((AliConversionCuts*)fCutGammaArray->At(iCut))
867 ->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
ae947965 868
a280ac15 869 if(eventNotAccepted){
870 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
871 hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
2bb2434e 872 continue;
a280ac15 873 }
2bb2434e 874
a280ac15 875 if(eventQuality != 0){// Event Not Accepted
876 // cout << "event rejected due to: " <<eventQuality << endl;
877 hNEvents[iCut]->Fill(eventQuality);
878 continue;
2bb2434e 879 }
a280ac15 880
2bb2434e 881 hNEvents[iCut]->Fill(eventQuality);
882
883 hNGoodESDTracks[iCut]->Fill(fNumberOfESDTracks);
884
885 if(fMCEvent){ // Process MC Particle
ae947965 886
887
888
889 fMCStack = fMCEvent->Stack();
890
891 if(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetSignalRejection() != 0){
892 ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetSignalRejection(),
893 ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetAcceptedHeader(),
894 fMCEvent);
895 }
896
2bb2434e 897 ProcessMCParticles();
898 }
899
900 ProcessPhotonCandidates(); // Process this cuts gammas
901 ProcessElectronCandidates(); // Process this cuts gammas
ae947965 902
903 if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
904
905 fUnsmearedPx = new Double_t[fGoodGammas->GetEntries()]; // Store unsmeared Momenta
906 fUnsmearedPy = new Double_t[fGoodGammas->GetEntries()];
907 fUnsmearedPz = new Double_t[fGoodGammas->GetEntries()];
908 fUnsmearedE = new Double_t[fGoodGammas->GetEntries()];
909
910 for(Int_t gamma=0;gamma<fGoodGammas->GetEntries();gamma++){ // Smear the AODPhotons in MC
911
912 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Px();
913 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Py();
914 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Pz();
915 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->E();
916 ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(gamma)));
917
918 }
919 }
920
921
2bb2434e 922 CalculatePi0DalitzCandidates();
923 CalculateBackground();
924 UpdateEventByEventData();
ae947965 925
926
927 if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
928
929 for(Int_t gamma=0;gamma<fGoodGammas->GetEntries();gamma++){ // Smear the AODPhotons in MC
930 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
931 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPy(fUnsmearedPy[gamma]);
932 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPz(fUnsmearedPz[gamma]);
933 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetE(fUnsmearedE[gamma]);
934 }
935 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
936 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
937 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
938 delete[] fUnsmearedE; fUnsmearedE = 0x0;
939
940 }
a280ac15 941
942
2bb2434e 943 fGoodGammas->Clear(); // delete this cuts good gammas
944 fGoodVirtualGammas->Clear(); // delete this cuts good gammas
945 }
946
a280ac15 947 fSelectorElectronIndex.clear();
948 fSelectorPositronIndex.clear();
2bb2434e 949
a280ac15 950 PostData( 1, fOutputContainer );
2bb2434e 951}
952
ae947965 953Bool_t AliAnalysisTaskGammaConvDalitzV1::Notify()
954{
955 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
956 if(!((AliConversionCuts*)fCutGammaArray->At(iCut))->GetDoEtaShift()) continue; // No Eta Shift requested, continue
957
958 if( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
959 ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
960 ((AliConversionCuts*)fCutGammaArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
961 ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() );
962 continue;
963 }
964 else{
965 printf(" Gamma Conversion Task %s :: Eta Shift Manually Set to %f \n\n",
966 (((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift());
967 ((AliConversionCuts*)fCutGammaArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
968 ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() );
969 }
970 }
971
972 return kTRUE;
973}
974
975
2bb2434e 976void AliAnalysisTaskGammaConvDalitzV1::Terminate(const Option_t *)
977{
978
4803eb1f 979 if( fElecSelector ){
2bb2434e 980
a280ac15 981 if ( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() ){
982 fOutputContainer->Add( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() );
983 }
984 }
2bb2434e 985
ae947965 986 if ( fV0Reader ) {
2bb2434e 987
a280ac15 988 if ( ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms() ){
989 fOutputContainer->Add( ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms() );
990 }
991 }
2bb2434e 992
a280ac15 993 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
2bb2434e 994
a280ac15 995 if( fCutElectronArray ){
996 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() ) {
997 fCutFolder[iCut]->Add( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() );
998 }
999 }
2bb2434e 1000
a280ac15 1001 if( fCutMesonArray ) {
1002 if( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms() ) {
1003 fCutFolder[iCut]->Add( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms());
1004 }
1005 }
2bb2434e 1006
a280ac15 1007 if( fCutGammaArray ) {
1008 if( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() ) {
1009 fCutFolder[iCut]->Add( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() );
1010 }
1011 }
4803eb1f 1012 }
2bb2434e 1013
2bb2434e 1014}
2bb2434e 1015//________________________________________________________________________
1016void AliAnalysisTaskGammaConvDalitzV1::ProcessPhotonCandidates()
1017{
1018 Int_t nV0 = 0;
1019 TList *GoodGammasStepOne = new TList();
1020 TList *GoodGammasStepTwo = new TList();
1021 // Loop over Photon Candidates allocated by ReaderV1
ae947965 1022
2bb2434e 1023 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1024 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1025 if(!PhotonCandidate) continue;
ae947965 1026
1027
1028 fIsFromMBHeader = kTRUE;
1029
1030 if( fMCEvent && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0 ){
1031
1032 Int_t isPosFromMBHeader
1033 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1034 if(isPosFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
1035
1036 Int_t isNegFromMBHeader
1037 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1038 if(isNegFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
1039
1040
1041 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1042 }
1043
2bb2434e 1044 if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fESDEvent)) continue;
a280ac15 1045
1046 if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut() &&
2bb2434e 1047 !((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // if no post reader loop is required add to events good gammas
ae947965 1048
2bb2434e 1049 fGoodGammas->Add(PhotonCandidate);
ae947965 1050 if(fIsFromMBHeader){
1051 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1052 }
2bb2434e 1053 if(fMCEvent){
1054 ProcessTruePhotonCandidates(PhotonCandidate);
1055 }
1056 }
1057 else if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1058 ((AliConversionCuts*)fCutGammaArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1059 nV0++;
1060 GoodGammasStepOne->Add(PhotonCandidate);
1061 }
a280ac15 1062 else if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut() &&
ae947965 1063 ((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
2bb2434e 1064 GoodGammasStepTwo->Add(PhotonCandidate);
1065 }
1066 }
1067 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut()){
1068 for(Int_t i = 0;i<GoodGammasStepOne->GetEntries();i++){
1069 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GoodGammasStepOne->At(i);
1070 if(!PhotonCandidate) continue;
ae947965 1071
1072
1073 fIsFromMBHeader = kTRUE;
1074 if(fMCEvent && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0){
1075 Int_t isPosFromMBHeader
1076 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack,fInputEvent);
1077 Int_t isNegFromMBHeader
1078 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1079 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1080 }
1081
1082
2bb2434e 1083 if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GoodGammasStepOne->GetEntries())) continue;
a280ac15 1084 if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
2bb2434e 1085 fGoodGammas->Add(PhotonCandidate);
ae947965 1086
1087 if(fIsFromMBHeader){
1088 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1089 }
1090
2bb2434e 1091 if(fMCEvent){
1092 ProcessTruePhotonCandidates(PhotonCandidate);
1093 }
1094 }
1095 else GoodGammasStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1096 }
1097 }
1098 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){
1099 for(Int_t i = 0;i<GoodGammasStepTwo->GetEntries();i++){
1100 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GoodGammasStepTwo->At(i);
1101 if(!PhotonCandidate) continue;
ae947965 1102
1103 if(fMCEvent && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0){
1104 Int_t isPosFromMBHeader
1105 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack,fInputEvent);
1106 Int_t isNegFromMBHeader
1107 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1108 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1109 }
1110
2bb2434e 1111 if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GoodGammasStepTwo,i)) continue;
1112 fGoodGammas->Add(PhotonCandidate); // Add gamma to current cut TList
ae947965 1113
1114 if(fIsFromMBHeader){
1115 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt()); // Differences to old V0Reader in p_t due to conversion KF->TLorentzVector
1116 }
1117
2bb2434e 1118 if(fMCEvent){
1119 ProcessTruePhotonCandidates(PhotonCandidate);
1120 }
1121 }
1122 }
1123
1124 delete GoodGammasStepOne;
1125 GoodGammasStepOne = 0x0;
1126 delete GoodGammasStepTwo;
1127 GoodGammasStepTwo = 0x0;
1128}
1129
1130//________________________________________________________________________
1131void AliAnalysisTaskGammaConvDalitzV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1132{
1133 // Process True Photons
1134 AliStack *MCStack = fMCEvent->Stack();
1135 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(MCStack);
1136 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(MCStack);
1137
1138 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1139 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){ // Not Same Mother == Combinatorial Bck
1140 return;
1141 }
ae947965 1142
1143 else if (posDaughter->GetMother(0) == -1){
1144 return;
1145 }
1146
2bb2434e 1147 if(TMath::Abs(posDaughter->GetPdgCode())!=11 || TMath::Abs(negDaughter->GetPdgCode())!=11) return; //One Particle is not electron
1148 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1149 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1150
1151 TParticle *Photon = TruePhotonCandidate->GetMCParticle(MCStack);
1152 if(Photon->GetPdgCode() != 22) return; // Mother is no Photon
1153
1154 // True Photon
ccfa8c0d 1155
ae947965 1156 Int_t labelGamma = TruePhotonCandidate->GetMCParticleLabel(MCStack);
1157
1158 if( labelGamma < MCStack->GetNprimary() ){
1159 if( fIsFromMBHeader ){
1160 hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1161 }
1162 }
1163 else {
1164 if( fIsFromMBHeader){
1165 hESDTrueSecConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1166 }
1167 }
1168
1169 if( IsPi0DalitzDaughter(labelGamma) == kTRUE ) {
1170 if( labelGamma < MCStack->GetNprimary() ) {
1171 if( fIsFromMBHeader ){
1172 hESDTruePi0DalitzConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1173 }
1174 }
1175 else {
1176 if( fIsFromMBHeader ) {
1177 hESDTruePi0DalitzSecConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1178 }
1179 }
1180 }
ccfa8c0d 1181
1182
2bb2434e 1183}
1184
2bb2434e 1185//________________________________________________________________________
1186void AliAnalysisTaskGammaConvDalitzV1::ProcessElectronCandidates(){
1187
a280ac15 1188 Double_t magField = fInputEvent->GetMagneticField();
2bb2434e 1189
1190
1191 if( magField < 0.0 ){
a280ac15 1192 magField = 1.0;
2bb2434e 1193 }
1194 else {
a280ac15 1195 magField = -1.0;
2bb2434e 1196 }
2bb2434e 1197
2bb2434e 1198
a280ac15 1199 vector<Int_t> lGoodElectronIndex(0);
1200 vector<Int_t> lGoodPositronIndex(0);
2bb2434e 1201
2bb2434e 1202
a280ac15 1203 for(UInt_t i = 0; i < fSelectorElectronIndex.size(); i++){
ae947965 1204 AliESDtrack* electronCandidate = fESDEvent->GetTrack(fSelectorElectronIndex[i]);
1205 if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(electronCandidate) ) continue;
1206 lGoodElectronIndex.push_back( fSelectorElectronIndex[i] );
1207 hESDDalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
4803eb1f 1208 hESDDalitzElectronPhi[fiCut]->Fill(electronCandidate->Phi());
ae947965 1209 if( fMCEvent ) {
1210 Int_t labelelectron = TMath::Abs( electronCandidate->GetLabel() );
1211 if( labelelectron < fMCStack->GetNtrack() ){
1212 TParticle* electron = fMCStack->Particle(labelelectron);
1213 if( electron->GetPdgCode() == 11 ){
1214 if( labelelectron < fMCStack->GetNprimary() ){
1215 hESDTrueElectronPt[fiCut]->Fill(electronCandidate->Pt()); //primary electron
1216 }
1217 else{
1218 hESDTrueSecElectronPt[fiCut]->Fill(electronCandidate->Pt()); //secondary electron
1219 }
1220 if( IsPi0DalitzDaughter(labelelectron) == kTRUE ) {
1221 if( labelelectron < fMCStack->GetNprimary() ) {
1222 hESDTruePi0DalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
1223 }
1224 else{
1225 hESDTruePi0DalitzSecElectronPt[fiCut]->Fill(electronCandidate->Pt());
1226 }
1227 }
1228 }
1229 }
1230 }
a280ac15 1231 }
1232
1233 for(UInt_t i = 0; i < fSelectorPositronIndex.size(); i++){
1234
ccfa8c0d 1235 AliESDtrack* positronCandidate = fESDEvent->GetTrack( fSelectorPositronIndex[i] );
a280ac15 1236 if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(positronCandidate) ) continue;
ae947965 1237 lGoodPositronIndex.push_back( fSelectorPositronIndex[i] );
1238 hESDDalitzPositronPt[fiCut]->Fill( positronCandidate->Pt() );
4803eb1f 1239 hESDDalitzPositronPhi[fiCut]->Fill( positronCandidate->Phi() );
1240
ccfa8c0d 1241 if( fMCEvent ) {
ae947965 1242 Int_t labelpositron = TMath::Abs( positronCandidate->GetLabel() );
1243 if( labelpositron < fMCStack->GetNtrack() ) {
1244 TParticle* positron = fMCStack->Particle(labelpositron);
1245 if( positron->GetPdgCode() == -11 ){
1246 if( labelpositron < fMCStack->GetNprimary() ){
1247 hESDTruePositronPt[fiCut]->Fill(positronCandidate->Pt());
1248 }
1249 else{
1250 hESDTrueSecPositronPt[fiCut]->Fill(positronCandidate->Pt());
1251 }
1252 if( IsPi0DalitzDaughter(labelpositron) == kTRUE ) {
1253 if( labelpositron < fMCStack->GetNprimary() ){
1254 hESDTruePi0DalitzPositronPt[fiCut]->Fill(positronCandidate->Pt());
1255 }
1256 else{
1257 hESDTruePi0DalitzSecPositronPt[fiCut]->Fill(positronCandidate->Pt());
1258 }
1259 }
1260 }
1261 }
ccfa8c0d 1262 }
ae947965 1263 }
a280ac15 1264
1265
1266 vector<Bool_t> lElectronPsiIndex(lGoodElectronIndex.size(), kTRUE);
1267 vector<Bool_t> lPositronPsiIndex(lGoodPositronIndex.size(), kTRUE);
1268
1269
1270 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->DoPsiPairCut() == kTRUE ){
1271
1272 for( UInt_t i = 0; i < lGoodElectronIndex.size(); i++ ) {
1273
1274 AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndex[i]);
1275
1276 for(UInt_t j = 0; j < lGoodPositronIndex.size(); j++){
1277 AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndex[j]);
1278 Double_t psiPair = GetPsiPair(positronCandidate,electronCandidate);
1279 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->GetConstrainedParam()->Phi()-positronCandidate->GetConstrainedParam()->Phi());
1280
1281 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->IsFromGammaConversion(psiPair,deltaPhi ) ){
1282 lElectronPsiIndex[i] = kFALSE;
1283 lPositronPsiIndex[j] = kFALSE;
1284 }
a280ac15 1285 }
1286 }
1287 }
2bb2434e 1288
2bb2434e 1289
1290
1291
2bb2434e 1292 for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
1293
a280ac15 1294 if( lElectronPsiIndex[i] == kFALSE ) continue;
2bb2434e 1295
2bb2434e 1296
a280ac15 1297 AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndex[i]);
1298
1299 AliKFParticle electronCandidateKF( *electronCandidate->GetConstrainedParam(), ::kElectron );
1300
1301 for(UInt_t j = 0; j < lGoodPositronIndex.size(); j++){
1302
1303 if( lPositronPsiIndex[j] == kFALSE ) continue;
1304
1305 AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndex[j]);
1306 AliKFParticle positronCandidateKF( *positronCandidate->GetConstrainedParam(), ::kPositron );
0f8c33c1 1307 Bool_t isPhoton = kFALSE;
1308 Bool_t isPi0Dalitz = kFALSE;
1309 Bool_t isEtaDalitz = kFALSE;
1310 Bool_t isJPsi = kFALSE;
a280ac15 1311
1312 Double_t psiPair = GetPsiPair(positronCandidate,electronCandidate);
1313 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->GetConstrainedParam()->Phi()-positronCandidate->GetConstrainedParam()->Phi());
ccfa8c0d 1314
a280ac15 1315
1316
1317 AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(electronCandidateKF,positronCandidateKF);
1318
1319
1320 AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1321 primaryVertexImproved+=*virtualPhoton;
1322 virtualPhoton->SetProductionVertex(primaryVertexImproved);
1323
1324 virtualPhoton->SetTrackLabels( lGoodPositronIndex[j], lGoodElectronIndex[i]);
1325
1326 if(fMCEvent){
1327
1328 // AliStack *fMCStack= fMCEvent->Stack();
1329 Int_t labeln=TMath::Abs(electronCandidate->GetLabel());
1330 Int_t labelp=TMath::Abs(positronCandidate->GetLabel());
1331 TParticle *fNegativeMCParticle = fMCStack->Particle(labeln);
1332 TParticle *fPositiveMCParticle = fMCStack->Particle(labelp);
1333 if( fPositiveMCParticle && fNegativeMCParticle) {
1334 virtualPhoton->SetMCLabelPositive(labelp);
1335 virtualPhoton->SetMCLabelNegative(labeln);
ccfa8c0d 1336
0f8c33c1 1337 }
ccfa8c0d 1338
1339 TParticle *mcVgamma=virtualPhoton->GetMCParticle(fMCStack);
ae947965 1340
0f8c33c1 1341
1342 if(mcVgamma){
1343 // Check if it is a true photon
1344 if(mcVgamma->GetPdgCode() == 22){
1345 isPhoton = kTRUE;
1346 }else if(mcVgamma->GetPdgCode() == 443){
1347 isJPsi = kTRUE;
1348 }
ae947965 1349 else if( IsDalitz( mcVgamma ) ){
0f8c33c1 1350 if ( mcVgamma->GetPdgCode() == 111 ) isPi0Dalitz = kTRUE;
1351 else if( mcVgamma->GetPdgCode() == 221 ) isEtaDalitz = kTRUE;
1352 }
1353 }
1354 }
1355
1356
a280ac15 1357 AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton); //To Apply PsiPairCut
0f8c33c1 1358
ccfa8c0d 1359 hESDEposEnegPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1360 hESDEposEnegInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
0f8c33c1 1361
ae947965 1362 if( fMCEvent ) {
1363 if(isPhoton) hESDEposEnegTruePhotonInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1364 else if(isJPsi) hESDEposEnegTrueJPsiInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1365 else if(isPi0Dalitz)hESDEposEnegTruePi0DalitzInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1366 else if(isEtaDalitz)hESDEposEnegTrueEtaDalitzInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
0f8c33c1 1367
1368 }
1369
1370 fGoodVirtualGammas->Add( vphoton );
1371
a280ac15 1372 }
2bb2434e 1373 }
0a2b2b4b 1374
1375
1376 //Computing mixing event
1377
1378 for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
1379
1380 if( lElectronPsiIndex[i] == kFALSE ) continue;
1381
1382 AliESDtrack *electronCandidate1 = fESDEvent->GetTrack(lGoodElectronIndex[i]);
1383
1384 AliKFParticle electronCandidate1KF( *electronCandidate1->GetConstrainedParam(), ::kElectron );
1385
1386
1387 for(UInt_t j = i+1; j < lGoodElectronIndex.size(); j++){
1388
1389 if( lElectronPsiIndex[j] == kFALSE ) continue;
1390
1391
1392 AliESDtrack *electronCandidate2 = fESDEvent->GetTrack(lGoodElectronIndex[j]);
1393
1394 AliKFParticle electronCandidate2KF( *electronCandidate2->GetConstrainedParam(), ::kElectron );
1395
1396 AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(electronCandidate1KF,electronCandidate2KF);
1397
1398 AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1399 primaryVertexImproved+=*virtualPhoton;
1400 virtualPhoton->SetProductionVertex(primaryVertexImproved);
1401
1402
1403 AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton);
1404 hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1405 delete vphoton;
1406 delete virtualPhoton;
1407
1408
1409 }
1410 }
1411
1412
1413 for(UInt_t i = 0; i < lGoodPositronIndex.size(); i++){
1414
1415 if( lPositronPsiIndex[i] == kFALSE ) continue;
1416
1417 AliESDtrack *positronCandidate1 = fESDEvent->GetTrack(lGoodPositronIndex[i]);
1418
1419 AliKFParticle positronCandidate1KF( *positronCandidate1->GetConstrainedParam(), ::kPositron );
1420
1421
1422 for(UInt_t j = i+1; j < lGoodPositronIndex.size(); j++){
1423
1424 if( lPositronPsiIndex[j] == kFALSE ) continue;
1425
1426 AliESDtrack *positronCandidate2 = fESDEvent->GetTrack(lGoodPositronIndex[j]);
1427
1428 AliKFParticle positronCandidate2KF( *positronCandidate2->GetConstrainedParam(), ::kPositron );
1429
1430 AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(positronCandidate1KF,positronCandidate2KF);
1431 AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1432 primaryVertexImproved+=*virtualPhoton;
1433 virtualPhoton->SetProductionVertex(primaryVertexImproved);
1434
1435 AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton);
1436 hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1437
1438
1439 delete vphoton;
1440 delete virtualPhoton;
1441
1442 }
1443 }
1444
a280ac15 1445
2bb2434e 1446}
1447
1448//________________________________________________________________________
1449void AliAnalysisTaskGammaConvDalitzV1::CalculatePi0DalitzCandidates(){
1450
1451 // Conversion Gammas
1452
a280ac15 1453
2bb2434e 1454
1455
1456 if( fGoodGammas->GetEntries() > 0 && fGoodVirtualGammas->GetEntries() > 0 ){
1457
4803eb1f 1458 vector<Bool_t> lGoodVirtualGamma(fGoodVirtualGammas->GetEntries(), kFALSE);
1459
2bb2434e 1460 for(Int_t GammaIndex=0; GammaIndex<fGoodGammas->GetEntries(); GammaIndex++){
1461
1462 AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(GammaIndex));
0a2b2b4b 1463 if (gamma==NULL) continue;
2bb2434e 1464 for(Int_t virtualGammaIndex=0;virtualGammaIndex<fGoodVirtualGammas->GetEntries();virtualGammaIndex++){
1465
1466 AliAODConversionPhoton *Vgamma=dynamic_cast<AliAODConversionPhoton*>(fGoodVirtualGammas->At(virtualGammaIndex));
0a2b2b4b 1467 if (Vgamma==NULL) continue;
2bb2434e 1468 //Check for same Electron ID
1469 if(gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelPositive() ||
1470 gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelNegative() ||
1471 gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelPositive() ||
1472 gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelNegative() ) continue;
1473
1474 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma,Vgamma);
1475 pi0cand->SetLabels(GammaIndex,virtualGammaIndex);
1476
a280ac15 1477 if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE)) ){
ae947965 1478
1479 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
2bb2434e 1480 Int_t mbin = 0;
a280ac15 1481 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ){
2bb2434e 1482 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1483 } else {
1484 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
1485 }
ae947965 1486
4803eb1f 1487 AliESDtrack *positronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
1488 AliESDtrack *electronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
1489 Double_t clsToFPos = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(positronVgamma);
1490 Double_t clsToFNeg = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(electronVgamma);
1491
1492 Float_t bPos[2];
1493 Float_t bCovPos[3];
1494 positronVgamma->GetImpactParameters(bPos,bCovPos);
1495 if (bCovPos[0]<=0 || bCovPos[2]<=0) {
1496 AliDebug(1, "Estimated b resolution lower or equal zero!");
1497 bCovPos[0]=0; bCovPos[2]=0;
1498 }
1499
1500 Float_t bNeg[2];
1501 Float_t bCovNeg[3];
1502 positronVgamma->GetImpactParameters(bNeg,bCovNeg);
1503 if (bCovNeg[0]<=0 || bCovNeg[2]<=0) {
1504 AliDebug(1, "Estimated b resolution lower or equal zero!");
1505 bCovNeg[0]=0; bCovNeg[2]=0;
1506 }
ae947965 1507
4803eb1f 1508 Float_t dcaToVertexXYPos = bPos[0];
1509 Float_t dcaToVertexZPos = bPos[1];
1510 Float_t dcaToVertexXYNeg = bNeg[0];
1511 Float_t dcaToVertexZNeg = bNeg[1];
1512
ae947965 1513
1514 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
4803eb1f 1515
1516
1517 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( pi0cand->Pt() , Vgamma->GetMass() ) == kTRUE ){
1518
ae947965 1519 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
4803eb1f 1520 hESDMotherPhi[fiCut]->Fill(pi0cand->Phi());
ae947965 1521 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1522 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
4803eb1f 1523
1524 if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
1525
1526 hESDDalitzElectronAfterPt[fiCut]->Fill( electronVgamma->Pt() );
1527 hESDDalitzPositronAfterPt[fiCut]->Fill( positronVgamma->Pt() );
1528
1529 hESDDalitzElectronAfterPhi[fiCut]->Fill( electronVgamma->Phi() );
1530 hESDDalitzPositronAfterPhi[fiCut]->Fill( positronVgamma->Phi() );
1531
1532 hESDDalitzElectronAfterNFindClsTPC[fiCut]->Fill(clsToFNeg,electronVgamma->Pt());
1533 hESDDalitzPositronAfterNFindClsTPC[fiCut]->Fill(clsToFPos,positronVgamma->Pt());
1534
1535
1536 hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYNeg, electronVgamma->Pt() );
1537 hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZNeg, electronVgamma->Pt() );
1538 hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYPos, positronVgamma->Pt() );
1539 hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZPos, positronVgamma->Pt() );
1540
1541 hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( positronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(positronVgamma, AliPID::kElectron) );
1542 hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( electronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(electronVgamma, AliPID::kElectron) );
1543
1544 hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( positronVgamma->P(), TMath::Abs(positronVgamma->GetTPCsignal()));
1545 hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( electronVgamma->P(), TMath::Abs(electronVgamma->GetTPCsignal()));
1546
1547
1548 lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
1549 }
1550
1551
ae947965 1552 }
1553 }
1554 else {
1555 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1556 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1557 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
4803eb1f 1558
1559 if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
1560
1561 hESDDalitzElectronAfterPt[fiCut]->Fill( electronVgamma->Pt() );
1562 hESDDalitzPositronAfterPt[fiCut]->Fill( positronVgamma->Pt() );
1563
1564 hESDDalitzElectronAfterPhi[fiCut]->Fill( electronVgamma->Phi() );
1565 hESDDalitzPositronAfterPhi[fiCut]->Fill( positronVgamma->Phi() );
1566
1567 hESDDalitzElectronAfterNFindClsTPC[fiCut]->Fill(clsToFNeg,electronVgamma->Pt());
1568 hESDDalitzPositronAfterNFindClsTPC[fiCut]->Fill(clsToFPos,positronVgamma->Pt());
1569
1570 hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYNeg, electronVgamma->Pt() );
1571 hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZNeg, electronVgamma->Pt() );
1572 hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYPos, positronVgamma->Pt() );
1573 hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZPos, positronVgamma->Pt() );
1574
1575 hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( positronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(positronVgamma, AliPID::kElectron) );
1576 hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( electronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(electronVgamma, AliPID::kElectron) );
1577
1578 hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( positronVgamma->P(), TMath::Abs(positronVgamma->GetTPCsignal()));
1579 hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( electronVgamma->P(), TMath::Abs(electronVgamma->GetTPCsignal()));
1580
1581
1582 lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
1583
1584 }
ae947965 1585 }
1586
1587
1588
1589 hESDPi0MotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1590
1591 Double_t diffMass = pi0cand->M() - Vgamma->GetMass();
1592
1593 hESDPi0MotherDiffInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
1594
1595 if(Vgamma->GetMass() > 2.5 && Vgamma->GetMass()<3.4 ){
1596 hESDPi0MotherDiffLimInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
1597 }
1598
1599 if(fMCEvent){
2bb2434e 1600 ProcessTrueMesonCandidates(pi0cand,gamma,Vgamma);
ae947965 1601 }
a280ac15 1602 }
2bb2434e 1603 delete pi0cand;
1604 pi0cand=0x0;
1605 }
1606 }
a280ac15 1607 }
2bb2434e 1608}
1609
1610//________________________________________________________________________
1611void AliAnalysisTaskGammaConvDalitzV1::CalculateBackground(){
1612
1613 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
1614 Int_t mbin = 0;
a280ac15 1615
2bb2434e 1616 Int_t method = 0;
1617
1618 method = ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetBKGMethod();
1619
1620
1621 if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity()){
1622 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1623 } else {
1624 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
1625 }
1626
1627 if( method == 1 || method == 2 ) {
1628
1629 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
1630
1631 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ) {
1632
1633 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
1634
1635 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
1636
1637 if(fMoveParticleAccordingToVertex == kTRUE && method == 1){
1638 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
1639 }
1640
1641 for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
1642 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
a280ac15 1643
1644 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
2bb2434e 1645 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
1646
1647 if(fMoveParticleAccordingToVertex == kTRUE && method == 1 ){
1648 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
1649 }
1650
1651 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
1652 if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE) ) ){
ae947965 1653 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
4803eb1f 1654
1655 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.GetMass() ) == kTRUE ){
1656
1657 // cout<<" Mass dalitz: "<<currentEventGoodV0.GetMass()<<endl;
ae947965 1658 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1659 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1660 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1661 }
1662 }
1663 else {
1664 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1665 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1666 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1667 }
2bb2434e 1668 }
1669 delete backgroundCandidate;
1670 backgroundCandidate = 0x0;
1671 }
1672 }
1673 }
1674 }
1675 else{
1676 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
1677 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
1678 if(previousEventV0s){
1679 if(fMoveParticleAccordingToVertex == kTRUE && method == 1){
1680 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
1681 }
1682 for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
a280ac15 1683
2bb2434e 1684 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
a280ac15 1685
2bb2434e 1686 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
1687
1688 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
1689
1690 if(fMoveParticleAccordingToVertex == kTRUE && method ==1){
1691 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
1692 }
1693
1694 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
2bb2434e 1695 if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE))){
ae947965 1696
1697 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
4803eb1f 1698
1699 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.GetMass() ) == kTRUE ){
1700
ae947965 1701
1702 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1703 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1704 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1705 }
1706 }
1707 else {
1708 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1709 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1710 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1711 }
2bb2434e 1712 }
1713 delete backgroundCandidate;
1714 backgroundCandidate = 0x0;
1715 }
1716 }
1717 }
1718 }
1719 }
1720 }
1721
1722 else if( method == 3 ){
1723
a280ac15 1724 for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
2bb2434e 1725
a280ac15 1726 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
2bb2434e 1727
a280ac15 1728 for(Int_t iPrevious=0;iPrevious<fGammasPool[fiCut]->GetEntries();iPrevious++){
2bb2434e 1729
a280ac15 1730 AliAODConversionPhoton previousGoodV0 = *(AliAODConversionPhoton*)((fGammasPool[fiCut]->At(iPrevious) ));
2bb2434e 1731
2bb2434e 1732
a280ac15 1733 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(&currentEventGoodV0,&previousGoodV0);
1734
1735 if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE))){
ae947965 1736
1737 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
4803eb1f 1738
1739 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.GetMass() ) == kTRUE ){
1740
ae947965 1741
1742 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1743 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1744 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1745
1746 }
1747 }
1748 else{
1749
1750 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1751 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1752 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1753
1754 }
2bb2434e 1755 }
a280ac15 1756 delete backgroundCandidate;
1757 backgroundCandidate = 0x0;
1758 }
1759 }
2bb2434e 1760 }
1761
1762}
1763//________________________________________________________________________
1764void AliAnalysisTaskGammaConvDalitzV1::UpdateEventByEventData(){
1765 //see header file for documentation
1766
1767 Int_t method = 0;
1768
1769 method = ( (AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetBKGMethod();
a280ac15 1770
2bb2434e 1771 if( method == 1 ) {
1772
a280ac15 1773 if(fGoodGammas->GetEntries() > 0 ){
2bb2434e 1774
a280ac15 1775 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ){
1776 fBGHandler[fiCut]->AddEvent(fGoodGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fNumberOfESDTracks);
1777 }
2bb2434e 1778
a280ac15 1779 else{ // means we use #V0s for multiplicity
1780 fBGHandler[fiCut]->AddEvent(fGoodGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fGoodGammas->GetEntries());
1781 }
2bb2434e 1782 }
2bb2434e 1783 }
1784
1785 else if ( method == 2 ){
a280ac15 1786
1787 if(fGoodVirtualGammas->GetEntries() > 0 ){
1788 if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity()){
1789 fBGHandler[fiCut]->AddEvent(fGoodVirtualGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fNumberOfESDTracks);
1790 }
1791 else{ // means we use #V0s for multiplicity
1792 fBGHandler[fiCut]->AddEvent(fGoodVirtualGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fGoodVirtualGammas->GetEntries());
1793 }
2bb2434e 1794 }
2bb2434e 1795 }
a280ac15 1796 else if ( method == 3 ) {
1797
1798
1799
1800 for(Int_t index = 0; index < fGoodGammas->GetEntries(); index++){
1801
1802
1803 if ( fGammasPool[fiCut]->GetEntries() > ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->NumberOfRotationEvents() ){
1804 fGammasPool[fiCut]->RemoveLast();
1805 }
1806 fGammasPool[fiCut]->AddFirst( new AliAODConversionPhoton(*(AliAODConversionPhoton*)(fGoodGammas->At(index)) ) );
2bb2434e 1807
2bb2434e 1808 }
a280ac15 1809 }
2bb2434e 1810}
1811//______________________________________________________________________
1812void AliAnalysisTaskGammaConvDalitzV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate, AliAODConversionPhoton *TrueVirtualGammaCandidate)
1813{
1814
1815 // Process True Mesons
1816
1817 AliStack *MCStack = fMCEvent->Stack();
1818
ae947965 1819 if( TrueGammaCandidate->GetV0Index()<fESDEvent->GetNumberOfV0s() ){
2bb2434e 1820
1821
1822 Bool_t isTruePi0 = kFALSE;
1823 Bool_t isTrueEta = kFALSE;
ae947965 1824 Bool_t massCutAccept = kFALSE;
0f8c33c1 1825 Bool_t isTrueChiC = kFALSE;
2bb2434e 1826 Int_t gammaMCLabel = TrueGammaCandidate->GetMCParticleLabel(MCStack);
1827 Int_t gammaMotherLabel = -1;
1828
1829
ae947965 1830 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
1831
4803eb1f 1832 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( Pi0Candidate->Pt() , TrueVirtualGammaCandidate->GetMass() ) == kTRUE ){
1833
ae947965 1834 massCutAccept = kTRUE;
1835 }
1836 }
1837 else {
1838 massCutAccept = kTRUE;
1839 }
1840
1841
1842
2bb2434e 1843
1844
1845 if(gammaMCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1846
1847
1848 // Daughters Gamma 0
1849 TParticle * negativeMC = (TParticle*)TrueGammaCandidate->GetNegativeMCDaughter(MCStack);
1850 TParticle * positiveMC = (TParticle*)TrueGammaCandidate->GetPositiveMCDaughter(MCStack);
1851 TParticle * gammaMC = (TParticle*)MCStack->Particle(gammaMCLabel);
1852
1853
1854 if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){ // Electrons ...
1855
1856 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2bb2434e 1857
a280ac15 1858 if(gammaMC->GetPdgCode() == 22){ // ... with Gamma Mother
1859 gammaMotherLabel=gammaMC->GetFirstMother();
1860 }
2bb2434e 1861 }
1862 }
a280ac15 1863 }
1864
1865
1866 Int_t virtualGammaMCLabel = TrueVirtualGammaCandidate->GetMCParticleLabel(MCStack);
1867 Int_t virtualGammaMotherLabel = -1;
1868 Int_t virtualGamma = 1;
ae947965 1869 Int_t virtualGammaGrandMotherLabel =-1;
1870
2bb2434e 1871
a280ac15 1872 if(virtualGammaMCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
1873 // Daughters Gamma 1
1874 TParticle * negativeMC = (TParticle*)TrueVirtualGammaCandidate->GetNegativeMCDaughter(MCStack);
1875 TParticle * positiveMC = (TParticle*)TrueVirtualGammaCandidate->GetPositiveMCDaughter(MCStack);
1876 TParticle * virtualGammaMotherMC = (TParticle*)MCStack->Particle(virtualGammaMCLabel);
2bb2434e 1877
a280ac15 1878 if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2bb2434e 1879
a280ac15 1880 if( virtualGammaMotherMC->GetPdgCode() != 22 ){
1881 virtualGammaMotherLabel=virtualGammaMCLabel;
ae947965 1882 if(virtualGammaMotherMC->GetPdgCode() == 443){
1883 virtualGammaGrandMotherLabel=virtualGammaMotherMC->GetFirstMother();
1884 }
1885 }
2bb2434e 1886
a280ac15 1887 else if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
a280ac15 1888 virtualGammaMotherLabel=virtualGammaMotherMC->GetFirstMother();
1889 virtualGamma = 0; //no virtual gamma
2bb2434e 1890 }
a280ac15 1891 }
1892 }
1893
1894
ae947965 1895 if(gammaMotherLabel >= 0 && ( gammaMotherLabel == virtualGammaMotherLabel) ){
2bb2434e 1896
a280ac15 1897 if(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetPdgCode() == 111){
1898 isTruePi0=kTRUE;
2bb2434e 1899 }
1900
a280ac15 1901 if(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetPdgCode() == 221){
1902 isTrueEta=kTRUE;
1903 }
ae947965 1904
1905
1906 }
a280ac15 1907
ae947965 1908 if(gammaMotherLabel>=0 && ( gammaMotherLabel == virtualGammaGrandMotherLabel) ){
1909 if(((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 445 ||
1910 ((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 10443 ||
1911 ((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 20443 ){
1912 isTrueChiC=kTRUE;
1913 hESDTrueMotherChiCInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1914 hESDTrueMotherChiCDiffInvMassPt[fiCut]->Fill(Pi0Candidate->M()-TrueVirtualGammaCandidate->GetMass(),Pi0Candidate->Pt());
1915 }
1916 }
a280ac15 1917
ae947965 1918 if( ( isTruePi0 || isTrueEta) && massCutAccept ){ // True Pion or Eta
1919
a280ac15 1920 if ( virtualGamma == 1 ) { //True Dalitz
4803eb1f 1921
2bb2434e 1922 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
4803eb1f 1923 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill( TrueVirtualGammaCandidate->GetMass(),Pi0Candidate->Pt());
1924
ae947965 1925 if(gammaMotherLabel < MCStack->GetNprimary()){ // Only primary pi0 for efficiency calculation
1926
1927 Float_t weighted= 1;
1928 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
1929 if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
1930 weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
1931 }
1932 }
1933 hESDTruePrimaryMotherInvMassMCPt[fiCut]->Fill(Pi0Candidate->M(),((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->Pt(),weighted);
2bb2434e 1934 if(isTruePi0){ // Only primaries for unfolding
ae947965 1935 hESDTruePrimaryPi0DalitzESDPtMCPt[fiCut]->Fill(Pi0Candidate->Pt(),((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->Pt(),weighted);
2bb2434e 1936 }
1937 }
ae947965 1938 else { // Secondary Meson
2bb2434e 1939 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1940 //if (((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetMother(0) >-1){
1941 // if(MCStack->Particle(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetMother(0))->GetPdgCode()==kK0Short){
1942 // hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1943 // }
2bb2434e 1944 }
1945 }
a280ac15 1946 else if ( virtualGamma == 0 ){
1947 hESDTrueMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt()); // Pi0 from GG
1948 }
1949 }
1950
ae947965 1951 if(!isTruePi0 && !isTrueEta && massCutAccept ){ // Background
a280ac15 1952 if(gammaMotherLabel>-1 && virtualGammaMotherLabel>-1 && virtualGamma == 0){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
1953 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1954 } else { // No photon or without mother
1955 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
1956 }
1957 }
1958 }
2bb2434e 1959}
0f8c33c1 1960
1961
2bb2434e 1962//________________________________________________________________________
1963void AliAnalysisTaskGammaConvDalitzV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
1964 //see header file for documentation
1965
1966 Double_t dx = vertex->fX - fESDEvent->GetPrimaryVertex()->GetX();
1967 Double_t dy = vertex->fY - fESDEvent->GetPrimaryVertex()->GetY();
1968 Double_t dz = vertex->fZ - fESDEvent->GetPrimaryVertex()->GetZ();
1969
1970 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
1971 particle->SetConversionPoint(movedPlace);
1972}
1973
1974
1975//________________________________________________________________________
1976void AliAnalysisTaskGammaConvDalitzV1::CountESDTracks(){
1977
2bb2434e 1978 // Using standard function for setting Cuts
1979 Bool_t selectPrimaries=kTRUE;
0a2b2b4b 1980 AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
2bb2434e 1981 EsdTrackCuts->SetMaxDCAToVertexZ(2);
1982 EsdTrackCuts->SetEtaRange(-0.8, 0.8);
1983 EsdTrackCuts->SetPtRange(0.15);
1984
1985 fNumberOfESDTracks = 0;
1986 for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
1987 AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
1988 if(!curTrack) continue;
1989 if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTracks++;
1990 }
1991 delete EsdTrackCuts;
1992 EsdTrackCuts=0x0;
1993
1994 return;
1995}
1996
1997//_____________________________________________________________________________
1998void AliAnalysisTaskGammaConvDalitzV1::ProcessMCParticles()
1999{
2000
2bb2434e 2001 // Loop over all primary MC particle
ccfa8c0d 2002
ae947965 2003 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2004
2005
2006 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2007 if (!particle) continue;
2008
2009
2010 Bool_t mcIsFromMB = kTRUE;
2011 Int_t isMCFromMBHeader = -1;
2012
2013 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0) {
2014 isMCFromMBHeader
2015 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i,fMCStack,fInputEvent);
2016 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
2017 if(isMCFromMBHeader != 2) mcIsFromMB = kFALSE;
2018 }
2019
2020 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
2021 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2022 }
2023
2024 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
2025 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
2026 if(mcIsFromMB){
2027 hMCConvGammaRSPt[fiCut]->Fill(particle->Pt());
2028 }
2029 } // Converted MC Gamma
2030
2031 if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(i,fMCStack)){
0f8c33c1 2032 if( particle->GetPdgCode() == -11)hMCAllPositronsPt[fiCut]->Fill(particle->Pt()); // All positrons
2033 if( particle->GetPdgCode() == 11)hMCAllElectronsPt[fiCut]->Fill(particle->Pt()); // All electrons
ae947965 2034 }
2035
2036 if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()) ){
2037
2038 Float_t weighted= 1;
2039
2040 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2041 if (particle->Pt()>0.005){
2042 weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
2043 }
2044 }
2045
2046 if(particle->GetPdgCode() == 111)hMCPi0GGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Pi0 GG decay
2047 if(particle->GetPdgCode() == 221)hMCEtaGGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Eta GG decay
2048 }
2049
2050
2051 Int_t labelgamma = -1;
2052 Int_t labelelectron = -1;
2053 Int_t labelpositron = -1;
2054
a280ac15 2055
ae947965 2056 if( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMCDalitz(particle,fMCStack,labelelectron,labelpositron,labelgamma,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()) )
2057 {
2058
2059
2060 Float_t weighted= 1;
2061
2062 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack,fInputEvent)){
2063 if (particle->Pt()>0.005){
2064 weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
2065 }
2066 }
2067
2068 if(particle->GetPdgCode() == 111)hMCPi0Pt[fiCut]->Fill(particle->Pt(), weighted); // All MC Pi0
2069 if(particle->GetPdgCode() == 221)hMCEtaPt[fiCut]->Fill(particle->Pt(), weighted); // All MC Eta
0f8c33c1 2070
2071 // Check the acceptance for gamma and electrons
2072
0f8c33c1 2073
2074 TParticle *gamma = fMCStack->Particle(labelgamma);
2075 TParticle *electron = fMCStack->Particle(labelelectron);
2076 TParticle *positron = fMCStack->Particle(labelpositron);
2077
2078
2079 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(gamma,fMCStack,kFALSE) &&
ae947965 2080 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelelectron,fMCStack) &&
2081 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelpositron,fMCStack) ) {
2082
0f8c33c1 2083 if(particle->GetPdgCode() == 111){
ae947965 2084
2085 hMCPi0InAccPt[fiCut]->Fill(particle->Pt() , weighted); // MC Pi0Dalitz with gamma and e+e- in acc
2086 hMCPi0DalitzGammaPt[fiCut]->Fill( gamma->Pt() ,weighted );
2087 hMCPi0DalitzPositronPt[fiCut]->Fill( positron->Pt(),weighted );
2088 hMCPi0DalitzElectronPt[fiCut]->Fill( electron->Pt(),weighted );
2089
0f8c33c1 2090 }
ae947965 2091 if(particle->GetPdgCode() == 221)hMCEtaInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC EtaDalitz with gamma and e+e- in acc
0f8c33c1 2092 }
ae947965 2093
2094
2095 }
0f8c33c1 2096 Int_t labelgammaChiC=-1;
2097 Int_t labelpositronChiC=-1;
2098 Int_t labelelectronChiC=-1;
2099
ae947965 2100 if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMCChiC(particle,fMCStack,labelelectronChiC,labelpositronChiC,labelgammaChiC,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift())){
2101
0f8c33c1 2102 hMCChiCPt[fiCut]->Fill(particle->Pt()); // All MC ChiC
2103 TParticle * gammaChiC =fMCStack->Particle(labelgammaChiC);
2104
2105 if( ((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC( gammaChiC,fMCStack,kFALSE) &&
ae947965 2106 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelelectronChiC,fMCStack) &&
2107 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelpositronChiC,fMCStack) ){
0f8c33c1 2108 hMCChiCInAccPt[fiCut]->Fill(particle->Pt()); // All MC ChiC
2109 }
2110 }
2111 }
ccfa8c0d 2112}
2113//_____________________________________________________________________________
ae947965 2114Bool_t AliAnalysisTaskGammaConvDalitzV1::IsDalitz(TParticle *fMCMother) const
ccfa8c0d 2115{
2116
0f8c33c1 2117 if( fMCMother->GetNDaughters() != 3 ) return kFALSE;
2118 if( fMCMother->GetPdgCode() != 111 && fMCMother->GetPdgCode() != 221 ) return kFALSE;
2119
ae947965 2120
0f8c33c1 2121 TParticle *positron = 0x0;
2122 TParticle *electron = 0x0;
ae947965 2123 TParticle *gamma = 0x0;
0f8c33c1 2124
2125 for(Int_t index= fMCMother->GetFirstDaughter();index<= fMCMother->GetLastDaughter();index++){
2bb2434e 2126
0f8c33c1 2127 TParticle* temp = (TParticle*)fMCStack->Particle( index );
2128
2129 switch( temp->GetPdgCode() ) {
2130 case ::kPositron:
2131 positron = temp;
0f8c33c1 2132 break;
2133 case ::kElectron:
2134 electron = temp;
0f8c33c1 2135 break;
2136 case ::kGamma:
2137 gamma = temp;
0f8c33c1 2138 break;
2139 }
2140 }
2141
2142 if( positron && electron && gamma) return kTRUE;
2143
2144 return kFALSE;
a280ac15 2145}
ccfa8c0d 2146//_____________________________________________________________________________________
2147Bool_t AliAnalysisTaskGammaConvDalitzV1::IsPi0DalitzDaughter( Int_t label ) const
2148{
2149//
2150// Returns true if the particle comes from Pi0 -> e+ e- gamma
2151//
ccfa8c0d 2152
2153 Int_t motherLabel = fMCStack->Particle( label )->GetMother(0);
2154
ae947965 2155 if( motherLabel < 0 || motherLabel >= fMCStack->GetNtrack() ) return kFALSE;
ccfa8c0d 2156
2157 TParticle* mother = fMCStack->Particle( motherLabel );
ae947965 2158
2159 if( mother->GetPdgCode() != 111 ) return kFALSE;
2160
2161 if( IsDalitz( mother ) ) return kTRUE;
2162
2163
2164 return kFALSE;
ccfa8c0d 2165
ae947965 2166
ccfa8c0d 2167}
2168
2169
a280ac15 2170//_____________________________________________________________________________
2171Double_t AliAnalysisTaskGammaConvDalitzV1::GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg ) const
2172{
2173 //
2174 // This angle is a measure for the contribution of the opening in polar
ae947965 2175 // direction ?0 to the opening angle ? Pair
a280ac15 2176 //
2177 // Ref. Measurement of photons via conversion pairs with the PHENIX experiment at RHIC
2178 // Master Thesis. Thorsten Dahms. 2005
2179 // https://twiki.cern.ch/twiki/pub/ALICE/GammaPhysicsPublications/tdahms_thesis.pdf
2180 //
2181 Double_t momPos[3];
2182 Double_t momNeg[3];
2183 if( trackPos->GetConstrainedPxPyPz(momPos) == 0 ) trackPos->GetPxPyPz( momPos );
2184 if( trackNeg->GetConstrainedPxPyPz(momNeg) == 0 ) trackNeg->GetPxPyPz( momNeg );
2185
2186 TVector3 posDaughter;
2187 TVector3 negDaughter;
2188
2189 posDaughter.SetXYZ( momPos[0], momPos[1], momPos[2] );
2190 negDaughter.SetXYZ( momNeg[0], momNeg[1], momNeg[2] );
2191
2192 Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();
2193 Double_t openingAngle = posDaughter.Angle( negDaughter ); //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );
2194
2195 if( openingAngle < 1e-20 ) return 0.;
2196
2197 Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );
2198
2199 return psiAngle;
4803eb1f 2200}