1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: Pedro Gonz??lez, Pedro Ladr??n de Guevara, Ernesto L??pez Torres, *
5 * Eulogio Serradilla, Ana Marin, Friederike Bock *
8 * Permission to use, copy, modify and distribute this software and its *
9 * documentation strictly for non-commercial purposes is hereby granted *
10 * without fee, provided that the above copyright notice appears in all *
11 * copies and that both the copyright notice and this permission notice *
12 * appear in the supporting documentation. The authors make no claims *
13 * about the suitability of this software for any purpose. It is *
14 * provided "as is" without express or implied warranty. *
15 **************************************************************************/
17 // Analysis task for pi0->e+e-gamma (Dalitz decay)
18 // Analysis task for chic->JPsi+gamma
22 #include "TParticle.h"
24 #include "TMCProcess.h"
25 #include "TDatabasePDG.h"
28 #include "TDirectory.h"
32 #include "THnSparse.h"
35 #include "AliAnalysisManager.h"
36 #include "AliESDInputHandler.h"
37 #include "AliESDtrack.h"
38 #include "AliMCEvent.h"
40 #include "AliMCEventHandler.h"
43 #include "AliESDtrackCuts.h"
44 #include "AliESDpidCuts.h"
45 #include "AliMCEvent.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"
58 ClassImp( AliAnalysisTaskGammaConvDalitzV1 )
60 //-----------------------------------------------------------------------------------------------
61 AliAnalysisTaskGammaConvDalitzV1::AliAnalysisTaskGammaConvDalitzV1():
76 fSelectorElectronIndex(0),
77 fSelectorPositronIndex(0),
79 fGoodVirtualGammas(NULL),
83 fCutElectronArray(NULL),
86 fConversionCuts(NULL),
87 hESDConvGammaPt(NULL),
88 hESDDalitzElectronPt(NULL),
89 hESDDalitzPositronPt(NULL),
90 hESDDalitzElectronPhi(NULL),
91 hESDDalitzPositronPhi(NULL),
92 hESDDalitzElectronAfterPt(NULL),
93 hESDDalitzPositronAfterPt(NULL),
94 hESDDalitzElectronAfterPhi(NULL),
95 hESDDalitzPositronAfterPhi(NULL),
96 hESDDalitzElectronAfterNFindClsTPC(NULL),
97 hESDDalitzPositronAfterNFindClsTPC(NULL),
98 hESDDalitzPosEleAfterDCAxy(NULL),
99 hESDDalitzPosEleAfterDCAz(NULL),
100 hESDDalitzPosEleAfterTPCdEdx(NULL),
101 hESDDalitzPosEleAfterTPCdEdxSignal(NULL),
103 hESDEposEnegPsiPairDPhi(NULL),
104 hESDEposEnegInvMassPt(NULL),
105 hESDEposEnegLikeSignBackInvMassPt(NULL),
106 hESDMotherInvMassPt(NULL),
107 hESDPi0MotherInvMassPt(NULL),
108 hESDPi0MotherDiffInvMassPt(NULL),
109 hESDPi0MotherDiffLimInvMassPt(NULL),
110 sESDMotherInvMassPtZM(NULL),
111 hESDMotherBackInvMassPt(NULL),
112 sESDMotherBackInvMassPtZM(NULL),
114 hMCConvGammaPt(NULL),
115 hMCConvGammaRSPt(NULL),
116 hMCAllPositronsPt(NULL),
117 hMCAllElectronsPt(NULL),
118 hMCPi0DalitzGammaPt(NULL),
119 hMCPi0DalitzElectronPt(NULL),
120 hMCPi0DalitzPositronPt(NULL),
128 hMCChiCInAccPt(NULL),
129 hESDEposEnegTruePi0DalitzInvMassPt(NULL),
130 hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
131 hESDEposEnegTruePhotonInvMassPt(NULL),
132 hESDEposEnegTrueJPsiInvMassPt(NULL),
133 hESDTrueMotherChiCInvMassPt(NULL),
134 hESDTrueMotherChiCDiffInvMassPt(NULL),
135 hESDTrueMotherInvMassPt(NULL),
136 hESDTrueMotherDalitzInvMassPt(NULL),
137 hESDTrueMotherPi0GGInvMassPt(NULL),
138 hESDTruePrimaryMotherInvMassMCPt(NULL),
139 hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
140 hESDTrueSecondaryMotherInvMassPt(NULL),
141 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
142 hESDTrueBckGGInvMassPt(NULL),
143 hESDTrueBckContInvMassPt(NULL),
144 hESDTrueMotherGGInvMassPt(NULL),
145 hESDTrueConvGammaPt(NULL),
146 hESDTruePositronPt(NULL),
147 hESDTrueElectronPt(NULL),
148 hESDTrueSecConvGammaPt(NULL),
149 hESDTrueSecPositronPt(NULL),
150 hESDTrueSecElectronPt(NULL),
151 hESDTruePi0DalitzConvGammaPt(NULL),
152 hESDTruePi0DalitzPositronPt(NULL),
153 hESDTruePi0DalitzElectronPt(NULL),
154 hESDTruePi0DalitzSecConvGammaPt(NULL),
155 hESDTruePi0DalitzSecPositronPt(NULL),
156 hESDTruePi0DalitzSecElectronPt(NULL),
158 hNGoodESDTracks(NULL),
167 fNumberOfESDTracks(0),
168 fMoveParticleAccordingToVertex(kFALSE),
170 fDoMesonAnalysis(kTRUE),
171 fDoChicAnalysis(kFALSE),
173 fIsFromMBHeader(kTRUE),
179 //-----------------------------------------------------------------------------------------------
180 AliAnalysisTaskGammaConvDalitzV1::AliAnalysisTaskGammaConvDalitzV1( const char* name ):
181 AliAnalysisTaskSE(name),
196 fSelectorElectronIndex(0),
197 fSelectorPositronIndex(0),
199 fGoodVirtualGammas(NULL),
200 fGoodElectrons(NULL),
201 fGoodPositrons(NULL),
202 fCutGammaArray(NULL),
203 fCutElectronArray(NULL),
204 fCutMesonArray(NULL),
206 fConversionCuts(NULL),
207 hESDConvGammaPt(NULL),
208 hESDDalitzElectronPt(NULL),
209 hESDDalitzPositronPt(NULL),
210 hESDDalitzElectronPhi(NULL),
211 hESDDalitzPositronPhi(NULL),
212 hESDDalitzElectronAfterPt(NULL),
213 hESDDalitzPositronAfterPt(NULL),
214 hESDDalitzElectronAfterPhi(NULL),
215 hESDDalitzPositronAfterPhi(NULL),
216 hESDDalitzElectronAfterNFindClsTPC(NULL),
217 hESDDalitzPositronAfterNFindClsTPC(NULL),
218 hESDDalitzPosEleAfterDCAxy(NULL),
219 hESDDalitzPosEleAfterDCAz(NULL),
220 hESDDalitzPosEleAfterTPCdEdx(NULL),
221 hESDDalitzPosEleAfterTPCdEdxSignal(NULL),
223 hESDEposEnegPsiPairDPhi(NULL),
224 hESDEposEnegInvMassPt(NULL),
225 hESDEposEnegLikeSignBackInvMassPt(NULL),
226 hESDMotherInvMassPt(NULL),
227 hESDPi0MotherInvMassPt(NULL),
228 hESDPi0MotherDiffInvMassPt(NULL),
229 hESDPi0MotherDiffLimInvMassPt(NULL),
230 sESDMotherInvMassPtZM(NULL),
231 hESDMotherBackInvMassPt(NULL),
232 sESDMotherBackInvMassPtZM(NULL),
234 hMCConvGammaPt(NULL),
235 hMCConvGammaRSPt(NULL),
236 hMCAllPositronsPt(NULL),
237 hMCAllElectronsPt(NULL),
238 hMCPi0DalitzGammaPt(NULL),
239 hMCPi0DalitzElectronPt(NULL),
240 hMCPi0DalitzPositronPt(NULL),
248 hMCChiCInAccPt(NULL),
249 hESDEposEnegTruePi0DalitzInvMassPt(NULL),
250 hESDEposEnegTrueEtaDalitzInvMassPt(NULL),
251 hESDEposEnegTruePhotonInvMassPt(NULL),
252 hESDEposEnegTrueJPsiInvMassPt(NULL),
253 hESDTrueMotherChiCInvMassPt(NULL),
254 hESDTrueMotherChiCDiffInvMassPt(NULL),
255 hESDTrueMotherInvMassPt(NULL),
256 hESDTrueMotherDalitzInvMassPt(NULL),
257 hESDTrueMotherPi0GGInvMassPt(NULL),
258 hESDTruePrimaryMotherInvMassMCPt(NULL),
259 hESDTruePrimaryPi0DalitzESDPtMCPt(NULL),
260 hESDTrueSecondaryMotherInvMassPt(NULL),
261 hESDTrueSecondaryMotherFromK0sInvMassPt(NULL),
262 hESDTrueBckGGInvMassPt(NULL),
263 hESDTrueBckContInvMassPt(NULL),
264 hESDTrueMotherGGInvMassPt(NULL),
265 hESDTrueConvGammaPt(NULL),
266 hESDTruePositronPt(NULL),
267 hESDTrueElectronPt(NULL),
268 hESDTrueSecConvGammaPt(NULL),
269 hESDTrueSecPositronPt(NULL),
270 hESDTrueSecElectronPt(NULL),
271 hESDTruePi0DalitzConvGammaPt(NULL),
272 hESDTruePi0DalitzPositronPt(NULL),
273 hESDTruePi0DalitzElectronPt(NULL),
274 hESDTruePi0DalitzSecConvGammaPt(NULL),
275 hESDTruePi0DalitzSecPositronPt(NULL),
276 hESDTruePi0DalitzSecElectronPt(NULL),
278 hNGoodESDTracks(NULL),
287 fNumberOfESDTracks(0),
288 fMoveParticleAccordingToVertex(kFALSE),
290 fDoMesonAnalysis(kTRUE),
291 fDoChicAnalysis(kFALSE),
293 fIsFromMBHeader(kTRUE),
296 DefineOutput(1, TList::Class());
299 //-----------------------------------------------------------------------------------------------
300 AliAnalysisTaskGammaConvDalitzV1::~AliAnalysisTaskGammaConvDalitzV1()
303 // virtual destructor
305 cout<<"Destructor"<<endl;
311 if(fGoodVirtualGammas){
312 delete fGoodVirtualGammas;
328 delete[] fGammasPool;
332 //___________________________________________________________
333 void AliAnalysisTaskGammaConvDalitzV1::InitBack(){
335 const Int_t nDim = 4;
336 Int_t nBins[nDim] = {800,250,7,4};
337 Double_t xMin[nDim] = {0,0, 0,0};
338 Double_t xMax[nDim] = {0.8,25,7,4};
340 sESDMotherInvMassPtZM = new THnSparseF*[fnCuts];
341 sESDMotherBackInvMassPtZM = new THnSparseF*[fnCuts];
343 fBGHandler = new AliGammaConversionAODBGHandler*[fnCuts];
344 //fBGHandlerRP = new AliConversionAODBGHandlerRP*[fnCuts];
345 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
346 //if (((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->DoBGCalculation()){
349 TString cutstringElectron = ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
350 TString cutstringMeson = ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
351 TString cutstringGamma = ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
355 Int_t collisionSystem = atoi((TString)(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber())(0,1));
356 Int_t centMin = atoi((TString)(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber())(1,1));
357 Int_t centMax = atoi((TString)(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber())(2,1));
359 if(collisionSystem == 1 || collisionSystem == 2 ||
360 collisionSystem == 5 || collisionSystem == 8 ||
361 collisionSystem == 9){
362 centMin = centMin*10;
363 centMax = centMax*10;
365 else if(collisionSystem == 3 || collisionSystem == 6){
369 else if(collisionSystem == 4 || collisionSystem == 7){
370 centMin = ((centMin*5)+45);
371 centMax = ((centMax*5)+45);
375 fBackList[iCut] = new TList();
376 fBackList[iCut]->SetName(Form("%s_%s_%s Back histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
377 fBackList[iCut]->SetOwner(kTRUE);
378 fCutFolder[iCut]->Add(fBackList[iCut]);
380 sESDMotherBackInvMassPtZM[iCut] = new THnSparseF("Back_Back_InvMass_Pt_z_m","Back_Back_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
381 fBackList[iCut]->Add(sESDMotherBackInvMassPtZM[iCut]);
383 fMotherList[iCut] = new TList();
384 fMotherList[iCut]->SetName(Form("%s_%s_%s Mother histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
385 fMotherList[iCut]->SetOwner(kTRUE);
386 fCutFolder[iCut]->Add(fMotherList[iCut]);
388 sESDMotherInvMassPtZM[iCut] = new THnSparseF("Back_Mother_InvMass_Pt_z_m","Back_Mother_InvMass_Pt_z_m",nDim,nBins,xMin,xMax);
389 fMotherList[iCut]->Add(sESDMotherInvMassPtZM[iCut]);
392 fBGHandler[iCut] = new AliGammaConversionAODBGHandler(
393 collisionSystem,centMin,centMax,
394 ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->NumberOfRotationEvents(),
395 ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->UseTrackMultiplicity());
397 if( ( (AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetBKGMethod() == 3 ){
398 fGammasPool[iCut] = new TList();
405 //______________________________________________________________________
406 void AliAnalysisTaskGammaConvDalitzV1::UserCreateOutputObjects()
409 // Create ouput objects
412 // Create the output container
413 if(fOutputContainer != NULL){
414 delete fOutputContainer;
415 fOutputContainer = NULL;
417 if(fOutputContainer == NULL){
418 fOutputContainer = new TList();
419 fOutputContainer->SetOwner(kTRUE);
422 fGoodGammas = new TList();
423 //fGoodGammas->SetOwner(kTRUE);
426 fGoodVirtualGammas = new TList();
427 //fGoodVirtualGammas->SetOwner(kTRUE);
431 fGammasPool = new TList*[fnCuts];
432 fCutFolder = new TList*[fnCuts];
433 fESDList = new TList*[fnCuts];
434 fBackList = new TList*[fnCuts];
435 fMotherList = new TList*[fnCuts];
436 hNEvents = new TH1I*[fnCuts];
437 hNGoodESDTracks = new TH1I*[fnCuts];
438 hEtaShift = new TProfile*[fnCuts];
439 hESDConvGammaPt = new TH1F*[fnCuts];
440 hESDDalitzElectronPt = new TH1F*[fnCuts];
441 hESDDalitzPositronPt = new TH1F*[fnCuts];
442 hESDDalitzElectronPhi = new TH1F*[fnCuts];
443 hESDDalitzPositronPhi = new TH1F*[fnCuts];
446 hESDDalitzElectronAfterPt = new TH1F*[fnCuts];
447 hESDDalitzPositronAfterPt = new TH1F*[fnCuts];
448 hESDDalitzElectronAfterPhi = new TH1F*[fnCuts];
449 hESDDalitzPositronAfterPhi = new TH1F*[fnCuts];
450 hESDDalitzElectronAfterNFindClsTPC = new TH2F*[fnCuts];
451 hESDDalitzPositronAfterNFindClsTPC = new TH2F*[fnCuts];
452 hESDDalitzPosEleAfterDCAxy = new TH2F*[fnCuts];
453 hESDDalitzPosEleAfterDCAz = new TH2F*[fnCuts];
454 hESDDalitzPosEleAfterTPCdEdx = new TH2F*[fnCuts];
455 hESDDalitzPosEleAfterTPCdEdxSignal = new TH2F*[fnCuts];
456 hESDMotherPhi = new TH1F*[fnCuts];
457 hESDEposEnegPsiPairDPhi = new TH2F*[fnCuts];
458 hESDEposEnegInvMassPt = new TH2F*[fnCuts];
459 hESDEposEnegLikeSignBackInvMassPt = new TH2F*[fnCuts];
465 hESDMotherInvMassPt = new TH2F*[fnCuts];
467 if(fDoChicAnalysis) {
468 hESDPi0MotherInvMassPt = new TH2F*[fnCuts];
469 hESDPi0MotherDiffInvMassPt = new TH2F*[fnCuts];
470 hESDPi0MotherDiffLimInvMassPt = new TH2F*[fnCuts];
474 hESDMotherBackInvMassPt = new TH2F*[fnCuts];
477 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
480 TString cutstringElectron =((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
481 TString cutstringMeson= ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
482 TString cutstringGamma = ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
484 fCutFolder[iCut] = new TList();
485 fCutFolder[iCut]->SetName(Form("Cut Number %s_%s_%s",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
486 fCutFolder[iCut]->SetOwner(kTRUE);
487 fOutputContainer->Add(fCutFolder[iCut]);
489 fESDList[iCut] = new TList();
490 fESDList[iCut]->SetName(Form("%s_%s_%s ESD histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
491 fESDList[iCut]->SetOwner(kTRUE);
495 hNEvents[iCut] = new TH1I("NEvents","NEvents",9,-0.5,8.5);
496 hNEvents[iCut]->GetXaxis()->SetBinLabel(1,"Accepted");
497 hNEvents[iCut]->GetXaxis()->SetBinLabel(2,"Centrality");
498 hNEvents[iCut]->GetXaxis()->SetBinLabel(3,"Missing MC");
499 hNEvents[iCut]->GetXaxis()->SetBinLabel(4,"Trigger");
500 hNEvents[iCut]->GetXaxis()->SetBinLabel(5,"Vertex Z");
501 hNEvents[iCut]->GetXaxis()->SetBinLabel(6,"Cont. Vertex");
502 hNEvents[iCut]->GetXaxis()->SetBinLabel(7,"Pile-Up");
503 hNEvents[iCut]->GetXaxis()->SetBinLabel(8,"no SDD");
504 hNEvents[iCut]->GetXaxis()->SetBinLabel(9,"no V0AND");
505 fESDList[iCut]->Add(hNEvents[iCut]);
509 if(fIsHeavyIon) hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",3000,0,3000);
510 else hNGoodESDTracks[iCut] = new TH1I("GoodESDTracks","GoodESDTracks",200,0,200);
511 fESDList[iCut]->Add(hNGoodESDTracks[iCut]);
513 hEtaShift[iCut] = new TProfile("Eta Shift","Eta Shift",1, -0.5,0.5);
514 fESDList[iCut]->Add(hEtaShift[iCut]);
516 hESDConvGammaPt[iCut] = new TH1F("ESD_ConvGamma_Pt","ESD_ConvGamma_Pt",250,0,25);
517 fESDList[iCut]->Add(hESDConvGammaPt[iCut]);
519 hESDDalitzElectronPt[iCut] = new TH1F("ESD_DalitzElectron_Pt","ESD_DalitzElectron_Pt",1000,0,25);
520 fESDList[iCut]->Add(hESDDalitzElectronPt[iCut]);
522 hESDDalitzPositronPt[iCut] = new TH1F("ESD_DalitzPositron_Pt","ESD_DalitzPositron_Pt",1000,0,25);
523 fESDList[iCut]->Add(hESDDalitzPositronPt[iCut]);
526 hESDDalitzElectronPhi[iCut] = new TH1F("ESD_DalitzElectron_Phi","ESD_DalitzElectron_Phi",360,0,2*TMath::Pi());
527 fESDList[iCut]->Add(hESDDalitzElectronPhi[iCut]);
529 hESDDalitzPositronPhi[iCut] = new TH1F("ESD_DalitzPositron_Phi","ESD_DalitzPositron_Phi",360,0,2*TMath::Pi());
530 fESDList[iCut]->Add(hESDDalitzPositronPhi[iCut]);
538 hESDDalitzElectronAfterPt[iCut] = new TH1F("ESD_DalitzElectron_After_Pt","ESD_DalitzElectron_After_Pt",1000,0,25);
539 fESDList[iCut]->Add(hESDDalitzElectronAfterPt[iCut]);
541 hESDDalitzPositronAfterPt[iCut] = new TH1F("ESD_DalitzPositron_After_Pt","ESD_DalitzPositron_After_Pt",1000,0,25);
542 fESDList[iCut]->Add(hESDDalitzPositronAfterPt[iCut]);
544 hESDDalitzElectronAfterPhi[iCut] = new TH1F("ESD_DalitzElectron_After_Phi","ESD_DalitzElectron_After_Phi",360,0,2*TMath::Pi());
545 fESDList[iCut]->Add(hESDDalitzElectronAfterPhi[iCut]);
547 hESDDalitzPositronAfterPhi[iCut] = new TH1F("ESD_DalitzPositron_After_Phi","ESD_DalitzPositron_After_Phi",360,0,2*TMath::Pi());
548 fESDList[iCut]->Add(hESDDalitzPositronAfterPhi[iCut]);
550 hESDDalitzElectronAfterNFindClsTPC[iCut] = new TH2F("ESD_DalitzElectron_After_NFindClsTPC","ESD_DalitzElectron_After_NFindClsTPC",100,0,1,400,0.,10.);
551 fESDList[iCut]->Add(hESDDalitzElectronAfterNFindClsTPC[iCut]);
553 hESDDalitzPositronAfterNFindClsTPC[iCut] = new TH2F("ESD_DalitzPositron_After_NFindClsTPC","ESD_DalitzPositron_After_NFindClsTPC",100,0,1,400,0.,10.);
554 fESDList[iCut]->Add(hESDDalitzPositronAfterNFindClsTPC[iCut]);
556 hESDDalitzPosEleAfterDCAxy[iCut] = new TH2F("ESD_DalitzPosEle_After_DCAxy","ESD_DalitzPosEle_After_DCAxy",800,-4.0,4.0,400,0.,10.);
557 fESDList[iCut]->Add(hESDDalitzPosEleAfterDCAxy[iCut]);
559 hESDDalitzPosEleAfterDCAz[iCut] = new TH2F("ESD_DalitzPosEle_After_DCAz","ESD_DalitzPosEle_After_DCAz",800,-4.0,4.0,400,0.,10.);
560 fESDList[iCut]->Add(hESDDalitzPosEleAfterDCAz[iCut]);
562 hESDDalitzPosEleAfterTPCdEdx[iCut] = new TH2F("ESD_DalitzPosEle_After_TPCdEdx","ESD_DalitzPosEle_After_TPCdEdx",150,0.05,20,400,-10,10);
563 fESDList[iCut]->Add(hESDDalitzPosEleAfterTPCdEdx[iCut]);
565 hESDDalitzPosEleAfterTPCdEdxSignal[iCut] =new TH2F("ESD_DalitzPosEle_After_TPCdEdxSignal","ESD_DalitzPosEle_After_TPCdEdxSignal" ,150,0.05,20.0,800,0.0,200);
566 fESDList[iCut]->Add(hESDDalitzPosEleAfterTPCdEdxSignal[iCut]);
568 hESDMotherPhi[iCut] = new TH1F("ESD_DalitzMother_Phi","ESD_DalitzMother_Phi",360,0,2*TMath::Pi());
569 fESDList[iCut]->Add(hESDMotherPhi[iCut]);
571 hESDEposEnegPsiPairDPhi[iCut] = new TH2F("ESD_EposEneg_PsiPair_DPhi","ESD_EposEneg_PsiPair_DPhi", 100, -1.0,1.0,100,-1.0,1.0 );
572 fESDList[iCut]->Add(hESDEposEnegPsiPairDPhi[iCut]);
574 hESDEposEnegInvMassPt[iCut] = new TH2F("ESD_EposEneg_InvMassPt","ESD_EposEneg_InvMassPt",5000,0.,5.,100,0.,10.);
575 fESDList[iCut]->Add(hESDEposEnegInvMassPt[iCut]);
577 hESDEposEnegLikeSignBackInvMassPt[iCut] = new TH2F("ESD_EposEneg_LikeSignBack_InvMassPt","ESD_EposEneg_LikeSignBack_InvMassPt",5000,0.,5.,100,0.,10.);
578 fESDList[iCut]->Add(hESDEposEnegLikeSignBackInvMassPt[iCut]);
589 hESDMotherInvMassPt[iCut] = new TH2F("ESD_DalitzMother_InvMass_Pt","ESD_DalitzMother_InvMass_Pt",800,0,0.8,250,0,25);
590 fESDList[iCut]->Add(hESDMotherInvMassPt[iCut]);
593 if( fDoChicAnalysis) {
595 hESDPi0MotherInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_InvMass_Pt","ESD_Pi0Mother_InvMass_Pt",4000,0,4,250,0,25);
596 fESDList[iCut]->Add(hESDPi0MotherInvMassPt[iCut]);
598 hESDPi0MotherDiffInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffInvMass_Pt","ESD_Pi0Mother_DiffInvMass_Pt",2000,0,2,250,0,25);
599 fESDList[iCut]->Add(hESDPi0MotherDiffInvMassPt[iCut]);
601 hESDPi0MotherDiffLimInvMassPt[iCut] = new TH2F("ESD_Pi0Mother_DiffLimInvMass_Pt","ESD_Pi0Mother_DiffLimInvMass_Pt",2000,0,2,250,0,25);
602 fESDList[iCut]->Add(hESDPi0MotherDiffLimInvMassPt[iCut]);
607 hESDMotherBackInvMassPt[iCut] = new TH2F("ESD_DalitzBackground_InvMass_Pt","ESD_DalitzBackground_InvMass_Pt",800,0,0.8,250,0,25);
608 fESDList[iCut]->Add(hESDMotherBackInvMassPt[iCut]);
613 TAxis *AxisAfter = hESDDalitzPosEleAfterTPCdEdx[iCut]->GetXaxis();
614 Int_t bins = AxisAfter->GetNbins();
615 Double_t from = AxisAfter->GetXmin();
616 Double_t to = AxisAfter->GetXmax();
617 Double_t *newBins = new Double_t[bins+1];
619 Double_t factor = TMath::Power(to/from, 1./bins);
620 for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];
622 AxisAfter->Set(bins, newBins);
623 AxisAfter = hESDDalitzPosEleAfterTPCdEdxSignal[iCut]->GetXaxis();
624 AxisAfter->Set(bins, newBins);
632 fCutFolder[iCut]->Add(fESDList[iCut]);
637 InitBack(); // Init Background Handler
643 fMCList = new TList*[fnCuts];
645 fTrueList = new TList*[fnCuts];
646 hESDTrueConvGammaPt = new TH1F*[fnCuts];
647 hESDTruePositronPt = new TH1F*[fnCuts];
648 hESDTrueElectronPt = new TH1F*[fnCuts];
649 hESDTrueSecConvGammaPt = new TH1F*[fnCuts];
650 hESDTrueSecPositronPt = new TH1F*[fnCuts];
651 hESDTrueSecElectronPt = new TH1F*[fnCuts];
652 hESDTruePi0DalitzConvGammaPt = new TH1F*[fnCuts];
653 hESDTruePi0DalitzPositronPt = new TH1F*[fnCuts];
654 hESDTruePi0DalitzElectronPt = new TH1F*[fnCuts];
655 hESDTruePi0DalitzSecConvGammaPt = new TH1F*[fnCuts];
656 hESDTruePi0DalitzSecPositronPt = new TH1F*[fnCuts];
657 hESDTruePi0DalitzSecElectronPt = new TH1F*[fnCuts];
658 //if(fDoMesonAnalysis){
659 hMCAllGammaPt = new TH1F*[fnCuts];
660 hMCConvGammaPt = new TH1F*[fnCuts];
661 hMCConvGammaRSPt = new TH1F*[fnCuts];
662 hMCAllPositronsPt = new TH1F*[fnCuts];
663 hMCAllElectronsPt = new TH1F*[fnCuts];
664 hMCPi0DalitzGammaPt = new TH1F*[fnCuts];
665 hMCPi0DalitzElectronPt = new TH1F*[fnCuts];
666 hMCPi0DalitzPositronPt = new TH1F*[fnCuts];
668 hMCPi0Pt = new TH1F*[fnCuts];
669 hMCPi0GGPt = new TH1F*[fnCuts];
670 hMCEtaPt = new TH1F*[fnCuts];
671 hMCEtaGGPt = new TH1F*[fnCuts];
672 hMCPi0InAccPt = new TH1F*[fnCuts];
673 hMCEtaInAccPt = new TH1F*[fnCuts];
674 hMCChiCPt = new TH1F*[fnCuts];
675 hMCChiCInAccPt = new TH1F*[fnCuts];
679 hESDEposEnegTruePi0DalitzInvMassPt = new TH2F*[fnCuts];
680 hESDEposEnegTrueEtaDalitzInvMassPt = new TH2F*[fnCuts];
681 hESDEposEnegTruePhotonInvMassPt = new TH2F*[fnCuts];
682 hESDEposEnegTrueJPsiInvMassPt = new TH2F*[fnCuts];
686 if( fDoChicAnalysis ){
687 hESDTrueMotherChiCInvMassPt = new TH2F*[fnCuts];
688 hESDTrueMotherChiCDiffInvMassPt = new TH2F*[fnCuts];
692 hESDTrueMotherInvMassPt = new TH2F*[fnCuts];
693 hESDTrueMotherDalitzInvMassPt = new TH2F*[fnCuts];
694 hESDTrueMotherPi0GGInvMassPt = new TH2F*[fnCuts];
695 hESDTruePrimaryPi0DalitzESDPtMCPt = new TH2F*[fnCuts];
696 hESDTruePrimaryMotherInvMassMCPt = new TH2F*[fnCuts];
697 hESDTrueSecondaryMotherInvMassPt = new TH2F*[fnCuts];
698 hESDTrueSecondaryMotherFromK0sInvMassPt = new TH2F*[fnCuts];
699 hESDTrueBckGGInvMassPt = new TH2F*[fnCuts];
700 hESDTrueBckContInvMassPt = new TH2F*[fnCuts];
701 hESDTrueMotherGGInvMassPt = new TH2F*[fnCuts];
704 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
705 TString cutstringElectron =((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutNumber();
706 TString cutstringMeson= ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutNumber();
707 TString cutstringGamma = ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber();
709 fMCList[iCut] = new TList();
710 fMCList[iCut]->SetName(Form("%s_%s_%s MC histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
711 fMCList[iCut]->SetOwner(kTRUE);
712 fCutFolder[iCut]->Add(fMCList[iCut]);
715 hMCAllGammaPt[iCut] = new TH1F("MC_AllGamma_Pt","MC_AllGamma_Pt",250,0,25);
716 fMCList[iCut]->Add(hMCAllGammaPt[iCut]);
718 hMCConvGammaPt[iCut] = new TH1F("MC_ConvGamma_Pt","MC_ConvGamma_Pt",250,0,25);
719 fMCList[iCut]->Add(hMCConvGammaPt[iCut]);
721 hMCConvGammaRSPt[iCut] = new TH1F("MC_ConvGamma_RS_Pt","MC_ConvGamma_RS_Pt",250,0,25);
722 fMCList[iCut]->Add(hMCConvGammaRSPt[iCut]);
725 hMCAllPositronsPt[iCut] = new TH1F("MC_AllPositrons_Pt","MC_AllPositrons_Pt",1000,0,25);
726 fMCList[iCut]->Add(hMCAllPositronsPt[iCut]);
728 hMCAllElectronsPt[iCut] = new TH1F("MC_AllElectrons_Pt","MC_AllElectrons_Pt",1000,0,25);
729 fMCList[iCut]->Add(hMCAllElectronsPt[iCut]);
731 hMCPi0DalitzGammaPt[iCut] = new TH1F("MC_Pi0DalitzGamma_Pt","MC_Pi0DalitzGamma_Pt",250,0,25);
732 fMCList[iCut]->Add(hMCPi0DalitzGammaPt[iCut]);
734 hMCPi0DalitzPositronPt[iCut] = new TH1F("MC_Pi0DalitzPositron_Pt","MC_Pi0DalitzPositron_Pt",1000,0,25);
735 fMCList[iCut]->Add(hMCPi0DalitzPositronPt[iCut]);
737 hMCPi0DalitzElectronPt[iCut] = new TH1F("MC_Pi0DalitzElectron_Pt","MC_Pi0DalitzElectron_Pt",1000,0,25);
738 fMCList[iCut]->Add(hMCPi0DalitzElectronPt[iCut]);
741 hMCPi0Pt[iCut] = new TH1F("MC_Pi0_Pt","MC_Pi0_Pt",250,0,25);
742 fMCList[iCut]->Add(hMCPi0Pt[iCut]);
744 hMCPi0GGPt[iCut] = new TH1F("MC_Pi0_GG_Pt","MC_Pi0_GG_Pt",250,0,25);
745 fMCList[iCut]->Add(hMCPi0GGPt[iCut]);
747 hMCEtaPt[iCut] = new TH1F("MC_Eta_Pt","MC_Eta_Pt",250,0,25);
748 fMCList[iCut]->Add(hMCEtaPt[iCut]);
750 hMCEtaGGPt[iCut] = new TH1F("MC_Eta_GG_Pt","MC_Eta_GG_Pt",250,0,25);
751 fMCList[iCut]->Add(hMCEtaGGPt[iCut]);
753 hMCPi0InAccPt[iCut] = new TH1F("MC_Pi0DalitzInAcc_Pt","MC_Pi0DalitzInAcc_Pt",250,0,25);
754 fMCList[iCut]->Add(hMCPi0InAccPt[iCut]);
756 hMCEtaInAccPt[iCut] = new TH1F("MC_EtaDalitzInAcc_Pt","MC_EtaDalitzInAcc_Pt",250,0,25);
757 fMCList[iCut]->Add(hMCEtaInAccPt[iCut]);
759 hMCChiCPt[iCut] = new TH1F("MC_ChiC_Pt","MC_ChiC_Pt",250,0,25);
760 fMCList[iCut]->Add(hMCChiCPt[iCut]);
762 hMCChiCInAccPt[iCut] = new TH1F("MC_ChiCInAcc_Pt","MC_ChiCInAcc_Pt",250,0,25);
763 fMCList[iCut]->Add(hMCChiCInAccPt[iCut]);
765 fTrueList[iCut] = new TList();
766 fTrueList[iCut]->SetName(Form("%s_%s_%s True histograms",cutstringGamma.Data(),cutstringElectron.Data(),cutstringMeson.Data()));
767 fTrueList[iCut]->SetOwner(kTRUE);
768 fCutFolder[iCut]->Add(fTrueList[iCut]);
771 hESDEposEnegTruePi0DalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePi0Dalitz_InvMassPt","ESD_EposEneg_TruePi0Dalitz_InvMassPt",5000,0.,5.,100,0.,10.);
772 fTrueList[iCut]->Add(hESDEposEnegTruePi0DalitzInvMassPt[iCut]);
774 hESDEposEnegTrueEtaDalitzInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueEtaDalitz_InvMassPt","ESD_EposEneg_TrueEtaDalitz_InvMassPt",5000,0.,5.,100,0.,10.);
775 fTrueList[iCut]->Add(hESDEposEnegTrueEtaDalitzInvMassPt[iCut]);
777 hESDEposEnegTruePhotonInvMassPt[iCut] = new TH2F("ESD_EposEneg_TruePhoton_InvMassPt","ESD_EposEneg_TruePhoton_InvMassPt",5000,0.,5.,100,0.,10.);
778 fTrueList[iCut]->Add(hESDEposEnegTruePhotonInvMassPt[iCut]);
780 hESDEposEnegTrueJPsiInvMassPt[iCut] = new TH2F("ESD_EposEneg_TrueJPsi_InvMassPt","ESD_EposEneg_TrueJPsi_InvMassPt",5000,0.,5.,100,0.,10.);
781 fTrueList[iCut]->Add(hESDEposEnegTrueJPsiInvMassPt[iCut]);
785 hESDTruePositronPt[iCut] = new TH1F("ESD_TruePositron_Pt","ESD_TruePositron_Pt",1000,0,25);
786 fTrueList[iCut]->Add(hESDTruePositronPt[iCut]);
788 hESDTrueElectronPt[iCut] = new TH1F("ESD_TrueElectron_Pt","ESD_TrueElectron_Pt",1000,0,25);
789 fTrueList[iCut]->Add(hESDTrueElectronPt[iCut]);
791 hESDTrueSecPositronPt[iCut] = new TH1F("ESD_TrueSecPositron_Pt","ESD_TrueSecPositron_Pt",1000,0,25);
792 fTrueList[iCut]->Add(hESDTrueSecPositronPt[iCut]);
794 hESDTrueSecElectronPt[iCut] = new TH1F("ESD_TrueSecElectron_Pt","ESD_TrueSecElectron_Pt",1000,0,25);
795 fTrueList[iCut]->Add(hESDTrueSecElectronPt[iCut]);
797 hESDTrueConvGammaPt[iCut] = new TH1F("ESD_TrueConvGamma_Pt","ESD_TrueConvGamma_Pt",250,0,25);
798 fTrueList[iCut]->Add(hESDTrueConvGammaPt[iCut]);
800 hESDTrueSecConvGammaPt[iCut] = new TH1F("ESD_TrueSecConvGamma_Pt","ESD_TrueSecConvGamma_Pt",250,0,25);
801 fTrueList[iCut]->Add(hESDTrueSecConvGammaPt[iCut]);
803 hESDTruePi0DalitzConvGammaPt[iCut] = new TH1F("ESD_TruePi0DalitzConvGamma_Pt","ESD_TruePi0DalitzConvGamma_Pt",250,0,25);
804 fTrueList[iCut]->Add(hESDTruePi0DalitzConvGammaPt[iCut]);
806 hESDTruePi0DalitzElectronPt[iCut] = new TH1F("ESD_TruePi0DalitzElectron_Pt","ESD_TruePi0DalitzElectron_Pt",1000,0,25);
807 fTrueList[iCut]->Add(hESDTruePi0DalitzElectronPt[iCut]);
809 hESDTruePi0DalitzPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzPositron_Pt","ESD_TruePi0DalitzPositron_Pt",1000,0,25);
810 fTrueList[iCut]->Add(hESDTruePi0DalitzPositronPt[iCut]);
812 hESDTruePi0DalitzSecConvGammaPt[iCut] = new TH1F("ESD_TruePi0DalitzSecConvGamma_Pt","ESD_TruePi0DalitzSecConvGamma_Pt",250,0,25);
813 fTrueList[iCut]->Add(hESDTruePi0DalitzSecConvGammaPt[iCut]);
815 hESDTruePi0DalitzSecElectronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecElectron_Pt","ESD_TruePi0DalitzSecElectron_Pt",1000,0,25);
816 fTrueList[iCut]->Add(hESDTruePi0DalitzSecElectronPt[iCut]);
818 hESDTruePi0DalitzSecPositronPt[iCut] = new TH1F("ESD_TruePi0DalitzSecPositron_Pt","ESD_TruePi0DalitzSecPositron_Pt",1000,0,25);
819 fTrueList[iCut]->Add(hESDTruePi0DalitzSecPositronPt[iCut]);
821 if( fDoChicAnalysis) {
823 hESDTrueMotherChiCInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiC_InvMass_Pt","ESD_TrueMotherChiC_InvMass_Pt",4000,0,4,250,0,25);
824 fTrueList[iCut]->Add(hESDTrueMotherChiCInvMassPt[iCut]);
826 hESDTrueMotherChiCDiffInvMassPt[iCut] = new TH2F("ESD_TrueMotherChiCDiff_InvMass_Pt","ESD_TrueMotherChiCDiff_InvMass_Pt",2000,0,2,250,0,25);
827 fTrueList[iCut]->Add(hESDTrueMotherChiCDiffInvMassPt[iCut]);
831 hESDTrueMotherInvMassPt[iCut] = new TH2F("ESD_TrueMother_InvMass_Pt","ESD_TrueMother_InvMass_Pt",800,0,0.8,250,0,25);
832 fTrueList[iCut]->Add(hESDTrueMotherInvMassPt[iCut]);
834 hESDTrueMotherDalitzInvMassPt[iCut] = new TH2F("ESD_TrueMother_Dalitz_InvMass_Pt","ESD_TrueMother_Dalitz_InvMass_Pt",800,0,0.8,250,0,25);
835 fTrueList[iCut]->Add(hESDTrueMotherDalitzInvMassPt[iCut]);
841 hESDTrueMotherPi0GGInvMassPt[iCut] = new TH2F("ESD_TrueMotherPi0GG_InvMass_Pt","ESD_TrueMotherPi0GG_InvMass_Pt",800,0,0.8,250,0,25);
842 fTrueList[iCut]->Add(hESDTrueMotherPi0GGInvMassPt[iCut]);
843 hESDTruePrimaryPi0DalitzESDPtMCPt[iCut] = new TH2F("ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt","ESD_TruePrimaryPi0Dalitz_ESDPt_MCPt",250,0,25,250,0,25);
844 fTrueList[iCut]->Add(hESDTruePrimaryPi0DalitzESDPtMCPt[iCut]);
845 hESDTruePrimaryMotherInvMassMCPt[iCut] = new TH2F("ESD_TruePrimaryMother_InvMass_MCPt","ESD_TrueDalitzPrimaryMother_InvMass_MCPt",800,0,0.8,250,0,25);
846 fTrueList[iCut]->Add(hESDTruePrimaryMotherInvMassMCPt[iCut]);
847 hESDTrueSecondaryMotherInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMother_InvMass_Pt","ESD_TrueDalitzSecondaryMother_InvMass_Pt",800,0,0.8,250,0,25);
848 fTrueList[iCut]->Add(hESDTrueSecondaryMotherInvMassPt[iCut]);
849 // hESDTrueSecondaryMotherFromK0sInvMassPt[iCut] = new TH2F("ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt","ESD_TrueDalitzSecondaryMotherFromK0s_InvMass_Pt",1000,0,1,250,0,25);
850 // fTrueList[iCut]->Add(hESDTrueSecondaryMotherFromK0sInvMassPt[iCut]);
851 hESDTrueBckGGInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckGG_InvMass_Pt","ESD_TrueDalitzBckGG_InvMass_Pt",800,0,0.8,250,0,25);
852 fTrueList[iCut]->Add(hESDTrueBckGGInvMassPt[iCut]);
853 hESDTrueBckContInvMassPt[iCut] = new TH2F("ESD_TrueDalitzBckCont_InvMass_Pt","ESD_TrueDalitzBckCont_InvMass_Pt",800,0,0.8,250,0,25);
854 fTrueList[iCut]->Add(hESDTrueBckContInvMassPt[iCut]);
855 // hESDTrueMotherGGInvMassPt[iCut] = new TH2F("ESD_TrueGammaGamma_InvMass_Pt","ESD_TrueGammaGamma_InvMass_Pt",1000,0,1,250,0,25);
856 // fTrueList[iCut]->Add(hESDTrueMotherGGInvMassPt[iCut]);
861 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
862 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
865 if((AliConversionCuts*)fV0Reader->GetConversionCuts())
866 if(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms())
867 fOutputContainer->Add(((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetCutHistograms());
871 fElecSelector=(AliDalitzElectronSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("ElectronSelector");
872 if(!fElecSelector){printf("Error: No ElectronSelector");return;} // GetV0Reader
876 if ( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() ){
877 fOutputContainer->Add( ((AliDalitzElectronCuts*)fElecSelector->GetDalitzElectronCuts())->GetCutHistograms() );
881 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
883 if( fCutElectronArray ){
884 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() ) {
885 fCutFolder[iCut]->Add( ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->GetCutHistograms() );
889 if( fCutMesonArray ) {
890 if( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms() ) {
891 fCutFolder[iCut]->Add( ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->GetCutHistograms());
895 if( fCutGammaArray ) {
896 if( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() ) {
897 fCutFolder[iCut]->Add( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutHistograms() );
902 PostData(1, fOutputContainer);
906 //______________________________________________________________________
907 void AliAnalysisTaskGammaConvDalitzV1::UserExec(Option_t *)
911 // Execute analysis for current event
914 fV0Reader=(AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1");
915 if(!fV0Reader){printf("Error: No V0 Reader");return;} // GetV0Reader
918 Int_t eventQuality = ((AliConversionCuts*)fV0Reader->GetConversionCuts())->GetEventQuality();
920 if(eventQuality == 2 || eventQuality == 3){// Event Not Accepted due to MC event missing or wrong trigger for V0ReaderV1
921 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
922 hNEvents[iCut]->Fill(eventQuality);
928 fElecSelector=(AliDalitzElectronSelector*)AliAnalysisManager::GetAnalysisManager()->GetTask("ElectronSelector");
929 if(!fElecSelector){printf("Error: No ElectronSelector");return;} // GetV0Reader
932 if(fIsMC) fMCEvent = MCEvent();
933 fESDEvent = (AliESDEvent*)InputEvent();
934 fReaderGammas = fV0Reader->GetReconstructedGammas(); // Gammas from default Cut
935 fSelectorElectronIndex = fElecSelector->GetReconstructedElectronsIndex(); // Electrons from default Cut
936 fSelectorPositronIndex = fElecSelector->GetReconstructedPositronsIndex(); // Positrons from default Cut
938 //CountESDTracks(); // Estimate Event Multiplicity
939 fNumberOfESDTracks = fV0Reader->GetNumberOfPrimaryTracks();
940 //AddTaskContainers(); //Add conatiner
942 for(Int_t iCut = 0; iCut<fnCuts; iCut++){
945 Int_t eventNotAccepted =
946 ((AliConversionCuts*)fCutGammaArray->At(iCut))
947 ->IsEventAcceptedByConversionCut(fV0Reader->GetConversionCuts(),fInputEvent,fMCEvent,fIsHeavyIon);
949 if(eventNotAccepted){
950 // cout << "event rejected due to wrong trigger: " <<eventNotAccepted << endl;
951 hNEvents[iCut]->Fill(eventNotAccepted); // Check Centrality, PileUp, SDD and V0AND --> Not Accepted => eventQuality = 1
955 if(eventQuality != 0){// Event Not Accepted
956 // cout << "event rejected due to: " <<eventQuality << endl;
957 hNEvents[iCut]->Fill(eventQuality);
961 hNEvents[iCut]->Fill(eventQuality);
963 hNGoodESDTracks[iCut]->Fill(fNumberOfESDTracks);
965 if(fMCEvent){ // Process MC Particle
969 fMCStack = fMCEvent->Stack();
971 if(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetSignalRejection() != 0){
972 ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetNotRejectedParticles(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetSignalRejection(),
973 ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetAcceptedHeader(),
977 ProcessMCParticles();
980 ProcessPhotonCandidates(); // Process this cuts gammas
981 ProcessElectronCandidates(); // Process this cuts gammas
983 if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
985 fUnsmearedPx = new Double_t[fGoodGammas->GetEntries()]; // Store unsmeared Momenta
986 fUnsmearedPy = new Double_t[fGoodGammas->GetEntries()];
987 fUnsmearedPz = new Double_t[fGoodGammas->GetEntries()];
988 fUnsmearedE = new Double_t[fGoodGammas->GetEntries()];
990 for(Int_t gamma=0;gamma<fGoodGammas->GetEntries();gamma++){ // Smear the AODPhotons in MC
992 fUnsmearedPx[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Px();
993 fUnsmearedPy[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Py();
994 fUnsmearedPz[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->Pz();
995 fUnsmearedE[gamma] = ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->E();
996 ((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->SmearParticle(dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(gamma)));
1002 CalculatePi0DalitzCandidates();
1003 CalculateBackground();
1004 UpdateEventByEventData();
1007 if(((AliConversionMesonCuts*)fCutMesonArray->At(iCut))->UseMCPSmearing() && fMCEvent){
1009 for(Int_t gamma=0;gamma<fGoodGammas->GetEntries();gamma++){ // Smear the AODPhotons in MC
1010 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPx(fUnsmearedPx[gamma]); // Reset Unsmeared Momenta
1011 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPy(fUnsmearedPy[gamma]);
1012 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetPz(fUnsmearedPz[gamma]);
1013 ((AliAODConversionPhoton*)fGoodGammas->At(gamma))->SetE(fUnsmearedE[gamma]);
1015 delete[] fUnsmearedPx; fUnsmearedPx = 0x0;
1016 delete[] fUnsmearedPy; fUnsmearedPy = 0x0;
1017 delete[] fUnsmearedPz; fUnsmearedPz = 0x0;
1018 delete[] fUnsmearedE; fUnsmearedE = 0x0;
1023 fGoodGammas->Clear(); // delete this cuts good gammas
1024 fGoodVirtualGammas->Clear(); // delete this cuts good gammas
1027 fSelectorElectronIndex.clear();
1028 fSelectorPositronIndex.clear();
1030 PostData( 1, fOutputContainer );
1033 Bool_t AliAnalysisTaskGammaConvDalitzV1::Notify()
1035 for(Int_t iCut = 0; iCut<fnCuts;iCut++){
1038 if( !((AliConversionCuts*)fCutGammaArray->At(iCut))->GetDoEtaShift() ){
1040 /*if (((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() != 0.){
1041 printf("Error: Gamma Conversion Dalitz Task %s :: Eta Shift not requested but set to %f, reset to 00. \n\n",
1042 (((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift());
1043 ((AliConversionCuts*)fCutGammaArray->At(iCut))->SetEtaShift(0.);
1044 ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift(0.);
1048 hEtaShift[iCut]->Fill(0.,0.);
1049 continue; // No Eta Shift requested, continue
1053 if( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
1054 ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCorrectEtaShiftFromPeriod(fV0Reader->GetPeriodName());
1055 ((AliConversionCuts*)fCutGammaArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1056 ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() );
1057 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift()));
1061 printf(" Gamma Conversion Dalitz Task %s :: Eta Shift Manually Set to %f \n\n",
1062 (((AliConversionCuts*)fCutGammaArray->At(iCut))->GetCutNumber()).Data(),((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift());
1063 ((AliConversionCuts*)fCutGammaArray->At(iCut))->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
1064 ((AliDalitzElectronCuts*)fCutElectronArray->At(iCut))->SetEtaShift( ((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift() );
1065 hEtaShift[iCut]->Fill(0.,(((AliConversionCuts*)fCutGammaArray->At(iCut))->GetEtaShift()));
1073 void AliAnalysisTaskGammaConvDalitzV1::Terminate(const Option_t *)
1079 //________________________________________________________________________
1080 void AliAnalysisTaskGammaConvDalitzV1::ProcessPhotonCandidates()
1083 TList *GoodGammasStepOne = new TList();
1084 TList *GoodGammasStepTwo = new TList();
1085 // Loop over Photon Candidates allocated by ReaderV1
1087 for(Int_t i = 0; i < fReaderGammas->GetEntriesFast(); i++){
1088 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) fReaderGammas->At(i);
1089 if(!PhotonCandidate) continue;
1092 fIsFromMBHeader = kTRUE;
1094 if( fMCEvent && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0 ){
1096 Int_t isPosFromMBHeader
1097 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack, fInputEvent);
1098 if(isPosFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
1100 Int_t isNegFromMBHeader
1101 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1102 if(isNegFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
1105 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1108 if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelected(PhotonCandidate,fESDEvent)) continue;
1110 if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut() &&
1111 !((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // if no post reader loop is required add to events good gammas
1113 fGoodGammas->Add(PhotonCandidate);
1114 if(fIsFromMBHeader){
1115 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1118 ProcessTruePhotonCandidates(PhotonCandidate);
1121 else if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut()){ // if Shared Electron cut is enabled, Fill array, add to step one
1122 ((AliConversionCuts*)fCutGammaArray->At(fiCut))->FillElectonLabelArray(PhotonCandidate,nV0);
1124 GoodGammasStepOne->Add(PhotonCandidate);
1126 else if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut() &&
1127 ((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // shared electron is disabled, step one not needed -> step two
1128 GoodGammasStepTwo->Add(PhotonCandidate);
1131 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseElecSharingCut()){
1132 for(Int_t i = 0;i<GoodGammasStepOne->GetEntries();i++){
1133 AliAODConversionPhoton *PhotonCandidate= (AliAODConversionPhoton*) GoodGammasStepOne->At(i);
1134 if(!PhotonCandidate) continue;
1137 fIsFromMBHeader = kTRUE;
1138 if(fMCEvent && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0){
1139 Int_t isPosFromMBHeader
1140 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack,fInputEvent);
1141 Int_t isNegFromMBHeader
1142 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1143 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1147 if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->RejectSharedElectronV0s(PhotonCandidate,i,GoodGammasStepOne->GetEntries())) continue;
1148 if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){ // To Colse v0s cut diabled, step two not needed
1149 fGoodGammas->Add(PhotonCandidate);
1151 if(fIsFromMBHeader){
1152 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt());
1156 ProcessTruePhotonCandidates(PhotonCandidate);
1159 else GoodGammasStepTwo->Add(PhotonCandidate); // Close v0s cut enabled -> add to list two
1162 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->UseToCloseV0sCut()){
1163 for(Int_t i = 0;i<GoodGammasStepTwo->GetEntries();i++){
1164 AliAODConversionPhoton* PhotonCandidate = (AliAODConversionPhoton*) GoodGammasStepTwo->At(i);
1165 if(!PhotonCandidate) continue;
1167 if(fMCEvent && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0){
1168 Int_t isPosFromMBHeader
1169 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelPositive(), fMCStack,fInputEvent);
1170 Int_t isNegFromMBHeader
1171 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(PhotonCandidate->GetMCLabelNegative(), fMCStack,fInputEvent);
1172 if( (isNegFromMBHeader+isPosFromMBHeader) != 4) fIsFromMBHeader = kFALSE;
1175 if(!((AliConversionCuts*)fCutGammaArray->At(fiCut))->RejectToCloseV0s(PhotonCandidate,GoodGammasStepTwo,i)) continue;
1176 fGoodGammas->Add(PhotonCandidate); // Add gamma to current cut TList
1178 if(fIsFromMBHeader){
1179 hESDConvGammaPt[fiCut]->Fill(PhotonCandidate->Pt()); // Differences to old V0Reader in p_t due to conversion KF->TLorentzVector
1183 ProcessTruePhotonCandidates(PhotonCandidate);
1188 delete GoodGammasStepOne;
1189 GoodGammasStepOne = 0x0;
1190 delete GoodGammasStepTwo;
1191 GoodGammasStepTwo = 0x0;
1194 //________________________________________________________________________
1195 void AliAnalysisTaskGammaConvDalitzV1::ProcessTruePhotonCandidates(AliAODConversionPhoton *TruePhotonCandidate)
1197 // Process True Photons
1198 AliStack *MCStack = fMCEvent->Stack();
1199 TParticle *posDaughter = TruePhotonCandidate->GetPositiveMCDaughter(MCStack);
1200 TParticle *negDaughter = TruePhotonCandidate->GetNegativeMCDaughter(MCStack);
1202 if(posDaughter == NULL || negDaughter == NULL) return; // One particle does not exist
1203 if(posDaughter->GetMother(0) != negDaughter->GetMother(0)){ // Not Same Mother == Combinatorial Bck
1207 else if (posDaughter->GetMother(0) == -1){
1211 if(TMath::Abs(posDaughter->GetPdgCode())!=11 || TMath::Abs(negDaughter->GetPdgCode())!=11) return; //One Particle is not electron
1212 if(posDaughter->GetPdgCode()==negDaughter->GetPdgCode()) return; // Same Charge
1213 if(posDaughter->GetUniqueID() != 5 || negDaughter->GetUniqueID() !=5) return;// check if the daughters come from a conversion
1215 TParticle *Photon = TruePhotonCandidate->GetMCParticle(MCStack);
1216 if(Photon->GetPdgCode() != 22) return; // Mother is no Photon
1220 Int_t labelGamma = TruePhotonCandidate->GetMCParticleLabel(MCStack);
1222 if( labelGamma < MCStack->GetNprimary() ){
1223 if( fIsFromMBHeader ){
1224 hESDTrueConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1228 if( fIsFromMBHeader){
1229 hESDTrueSecConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1233 if( IsPi0DalitzDaughter(labelGamma) == kTRUE ) {
1234 if( labelGamma < MCStack->GetNprimary() ) {
1235 if( fIsFromMBHeader ){
1236 hESDTruePi0DalitzConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1240 if( fIsFromMBHeader ) {
1241 hESDTruePi0DalitzSecConvGammaPt[fiCut]->Fill(TruePhotonCandidate->Pt());
1249 //________________________________________________________________________
1250 void AliAnalysisTaskGammaConvDalitzV1::ProcessElectronCandidates(){
1252 Double_t magField = fInputEvent->GetMagneticField();
1255 if( magField < 0.0 ){
1263 vector<Int_t> lGoodElectronIndexPrev(0);
1264 vector<Int_t> lGoodPositronIndexPrev(0);
1269 for(UInt_t i = 0; i < fSelectorElectronIndex.size(); i++){
1270 AliESDtrack* electronCandidate = fESDEvent->GetTrack(fSelectorElectronIndex[i]);
1271 if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(electronCandidate) ) continue;
1272 lGoodElectronIndexPrev.push_back( fSelectorElectronIndex[i] );
1273 hESDDalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
1274 hESDDalitzElectronPhi[fiCut]->Fill(electronCandidate->Phi());
1276 Int_t labelelectron = TMath::Abs( electronCandidate->GetLabel() );
1277 if( labelelectron < fMCStack->GetNtrack() ){
1278 TParticle* electron = fMCStack->Particle(labelelectron);
1279 if( electron->GetPdgCode() == 11 ){
1280 if( labelelectron < fMCStack->GetNprimary() ){
1281 hESDTrueElectronPt[fiCut]->Fill(electronCandidate->Pt()); //primary electron
1284 hESDTrueSecElectronPt[fiCut]->Fill(electronCandidate->Pt()); //secondary electron
1286 if( IsPi0DalitzDaughter(labelelectron) == kTRUE ) {
1287 if( labelelectron < fMCStack->GetNprimary() ) {
1288 hESDTruePi0DalitzElectronPt[fiCut]->Fill(electronCandidate->Pt());
1291 hESDTruePi0DalitzSecElectronPt[fiCut]->Fill(electronCandidate->Pt());
1299 for(UInt_t i = 0; i < fSelectorPositronIndex.size(); i++){
1301 AliESDtrack* positronCandidate = fESDEvent->GetTrack( fSelectorPositronIndex[i] );
1302 if(! ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelected(positronCandidate) ) continue;
1303 lGoodPositronIndexPrev.push_back( fSelectorPositronIndex[i] );
1304 hESDDalitzPositronPt[fiCut]->Fill( positronCandidate->Pt() );
1305 hESDDalitzPositronPhi[fiCut]->Fill( positronCandidate->Phi() );
1308 Int_t labelpositron = TMath::Abs( positronCandidate->GetLabel() );
1309 if( labelpositron < fMCStack->GetNtrack() ) {
1310 TParticle* positron = fMCStack->Particle(labelpositron);
1311 if( positron->GetPdgCode() == -11 ){
1312 if( labelpositron < fMCStack->GetNprimary() ){
1313 hESDTruePositronPt[fiCut]->Fill(positronCandidate->Pt());
1316 hESDTrueSecPositronPt[fiCut]->Fill(positronCandidate->Pt());
1318 if( IsPi0DalitzDaughter(labelpositron) == kTRUE ) {
1319 if( labelpositron < fMCStack->GetNprimary() ){
1320 hESDTruePi0DalitzPositronPt[fiCut]->Fill(positronCandidate->Pt());
1323 hESDTruePi0DalitzSecPositronPt[fiCut]->Fill(positronCandidate->Pt());
1332 vector<Bool_t> lElectronPsiIndex(lGoodElectronIndexPrev.size(), kTRUE);
1333 vector<Bool_t> lPositronPsiIndex(lGoodPositronIndexPrev.size(), kTRUE);
1336 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->DoPsiPairCut() == kTRUE ){
1338 for( UInt_t i = 0; i < lGoodElectronIndexPrev.size(); i++ ) {
1340 AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndexPrev[i]);
1342 for(UInt_t j = 0; j < lGoodPositronIndexPrev.size(); j++){
1343 AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndexPrev[j]);
1344 Double_t psiPair = GetPsiPair(positronCandidate,electronCandidate);
1345 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->GetConstrainedParam()->Phi()-positronCandidate->GetConstrainedParam()->Phi());
1347 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->IsFromGammaConversion(psiPair,deltaPhi ) ){
1348 lElectronPsiIndex[i] = kFALSE;
1349 lPositronPsiIndex[j] = kFALSE;
1356 vector<Int_t> lGoodElectronIndex(0);
1357 vector<Int_t> lGoodPositronIndex(0);
1360 for( UInt_t i = 0; i < lGoodElectronIndexPrev.size(); i++ ) {
1362 if( lElectronPsiIndex[i] == kTRUE )
1363 lGoodElectronIndex.push_back( lGoodElectronIndexPrev[i] );
1366 for( UInt_t i = 0; i < lGoodPositronIndexPrev.size(); i++ ) {
1368 if( lPositronPsiIndex[i] == kTRUE )
1369 lGoodPositronIndex.push_back( lGoodPositronIndexPrev[i] );
1376 for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
1378 //if( lElectronPsiIndex[i] == kFALSE ) continue;
1381 AliESDtrack *electronCandidate = fESDEvent->GetTrack(lGoodElectronIndex[i]);
1383 AliKFParticle electronCandidateKF( *electronCandidate->GetConstrainedParam(), ::kElectron );
1385 for(UInt_t j = 0; j < lGoodPositronIndex.size(); j++){
1387 //if( lPositronPsiIndex[j] == kFALSE ) continue;
1389 AliESDtrack *positronCandidate = fESDEvent->GetTrack(lGoodPositronIndex[j]);
1390 AliKFParticle positronCandidateKF( *positronCandidate->GetConstrainedParam(), ::kPositron );
1391 Bool_t isPhoton = kFALSE;
1392 Bool_t isPi0Dalitz = kFALSE;
1393 Bool_t isEtaDalitz = kFALSE;
1394 Bool_t isJPsi = kFALSE;
1396 Double_t psiPair = GetPsiPair(positronCandidate,electronCandidate);
1397 Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->GetConstrainedParam()->Phi()-positronCandidate->GetConstrainedParam()->Phi());
1400 AliKFConversionPhoton* virtualPhoton = NULL;
1401 virtualPhoton = new AliKFConversionPhoton(electronCandidateKF,positronCandidateKF);
1404 AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1405 primaryVertexImproved+=*virtualPhoton;
1406 virtualPhoton->SetProductionVertex(primaryVertexImproved);
1408 virtualPhoton->SetTrackLabels( lGoodPositronIndex[j], lGoodElectronIndex[i]);
1413 Int_t labeln=TMath::Abs(electronCandidate->GetLabel());
1414 Int_t labelp=TMath::Abs(positronCandidate->GetLabel());
1415 TParticle *fNegativeMCParticle = fMCStack->Particle(labeln);
1416 TParticle *fPositiveMCParticle = fMCStack->Particle(labelp);
1418 if( fPositiveMCParticle && fNegativeMCParticle) {
1419 virtualPhoton->SetMCLabelPositive(labelp);
1420 virtualPhoton->SetMCLabelNegative(labeln);
1424 AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton); //To Apply PsiPairCut
1430 TParticle *mcVgamma=virtualPhoton->GetMCParticle(fMCStack);
1433 // Check if it is a true photon
1434 if(mcVgamma->GetPdgCode() == 22){
1436 }else if(mcVgamma->GetPdgCode() == 443){
1439 else if( IsDalitz( mcVgamma ) ){
1440 if ( mcVgamma->GetPdgCode() == 111 ) isPi0Dalitz = kTRUE;
1441 else if( mcVgamma->GetPdgCode() == 221 ) isEtaDalitz = kTRUE;
1446 if(isPhoton) hESDEposEnegTruePhotonInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1447 else if(isJPsi) hESDEposEnegTrueJPsiInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1448 else if(isPi0Dalitz)hESDEposEnegTruePi0DalitzInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1449 else if(isEtaDalitz)hESDEposEnegTrueEtaDalitzInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1458 hESDEposEnegPsiPairDPhi[fiCut]->Fill(deltaPhi,psiPair);
1459 hESDEposEnegInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1463 if( ! fDoChicAnalysis ) {
1465 if ( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
1467 Double_t MassCutMax = 1000.0;
1468 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutLowPt() >= ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutHighPt() ){
1469 MassCutMax = ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutLowPt();
1472 MassCutMax = ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetMassCutHighPt();
1475 if( vphoton->GetMass() > MassCutMax ) {
1480 delete virtualPhoton;
1481 virtualPhoton = 0x0;
1490 fGoodVirtualGammas->Add( vphoton );
1491 delete virtualPhoton;
1498 //Computing mixing event
1502 for(UInt_t i = 0; i < lGoodElectronIndex.size(); i++){
1504 //if( lElectronPsiIndex[i] == kFALSE ) continue;
1506 AliESDtrack *electronCandidate1 = fESDEvent->GetTrack(lGoodElectronIndex[i]);
1508 AliKFParticle electronCandidate1KF( *electronCandidate1->GetConstrainedParam(), ::kElectron );
1511 for(UInt_t j = i+1; j < lGoodElectronIndex.size(); j++){
1513 //if( lElectronPsiIndex[j] == kFALSE ) continue;
1516 AliESDtrack *electronCandidate2 = fESDEvent->GetTrack(lGoodElectronIndex[j]);
1518 AliKFParticle electronCandidate2KF( *electronCandidate2->GetConstrainedParam(), ::kElectron );
1520 AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(electronCandidate1KF,electronCandidate2KF);
1522 AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1523 primaryVertexImproved+=*virtualPhoton;
1524 virtualPhoton->SetProductionVertex(primaryVertexImproved);
1527 AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton);
1528 hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1530 delete virtualPhoton;
1532 virtualPhoton = 0x0;
1538 for(UInt_t i = 0; i < lGoodPositronIndex.size(); i++){
1542 //if( lPositronPsiIndex[i] == kFALSE ) continue;
1544 AliESDtrack *positronCandidate1 = fESDEvent->GetTrack(lGoodPositronIndex[i]);
1546 AliKFParticle positronCandidate1KF( *positronCandidate1->GetConstrainedParam(), ::kPositron );
1549 for(UInt_t j = i+1; j < lGoodPositronIndex.size(); j++){
1551 // if( lPositronPsiIndex[j] == kFALSE ) continue;
1553 AliESDtrack *positronCandidate2 = fESDEvent->GetTrack(lGoodPositronIndex[j]);
1555 AliKFParticle positronCandidate2KF( *positronCandidate2->GetConstrainedParam(), ::kPositron );
1557 AliKFConversionPhoton* virtualPhoton = new AliKFConversionPhoton(positronCandidate1KF,positronCandidate2KF);
1558 AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
1559 primaryVertexImproved+=*virtualPhoton;
1560 virtualPhoton->SetProductionVertex(primaryVertexImproved);
1562 AliAODConversionPhoton *vphoton = new AliAODConversionPhoton(virtualPhoton);
1563 hESDEposEnegLikeSignBackInvMassPt[fiCut]->Fill(vphoton->GetMass(),vphoton->Pt());
1567 delete virtualPhoton;
1569 virtualPhoton = 0x0;
1577 //________________________________________________________________________
1578 void AliAnalysisTaskGammaConvDalitzV1::CalculatePi0DalitzCandidates(){
1580 // Conversion Gammas
1585 if( fGoodGammas->GetEntries() > 0 && fGoodVirtualGammas->GetEntries() > 0 ){
1587 vector<Bool_t> lGoodVirtualGamma(fGoodVirtualGammas->GetEntries(), kFALSE);
1589 for(Int_t GammaIndex=0; GammaIndex<fGoodGammas->GetEntries(); GammaIndex++){
1591 AliAODConversionPhoton *gamma=dynamic_cast<AliAODConversionPhoton*>(fGoodGammas->At(GammaIndex));
1592 if (gamma==NULL) continue;
1593 for(Int_t virtualGammaIndex=0;virtualGammaIndex<fGoodVirtualGammas->GetEntries();virtualGammaIndex++){
1595 AliAODConversionPhoton *Vgamma=dynamic_cast<AliAODConversionPhoton*>(fGoodVirtualGammas->At(virtualGammaIndex));
1596 if (Vgamma==NULL) continue;
1597 //Check for same Electron ID
1598 if(gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelPositive() ||
1599 gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelNegative() ||
1600 gamma->GetTrackLabelNegative() == Vgamma->GetTrackLabelPositive() ||
1601 gamma->GetTrackLabelPositive() == Vgamma->GetTrackLabelNegative() ) continue;
1603 AliAODConversionMother *pi0cand = new AliAODConversionMother(gamma,Vgamma);
1604 pi0cand->SetLabels(GammaIndex,virtualGammaIndex);
1607 if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(pi0cand,kTRUE,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift())) ){
1609 //cout<< "Meson Accepted "<<endl;
1611 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
1613 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ){
1614 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1616 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
1619 AliESDtrack *positronVgamma = 0;
1620 AliESDtrack *electronVgamma = 0;
1622 Double_t clsToFPos = -1.0;
1623 Double_t clsToFNeg = -1.0;
1625 Float_t dcaToVertexXYPos = -1.0;
1626 Float_t dcaToVertexZPos = -1.0;
1627 Float_t dcaToVertexXYNeg = -1.0;
1628 Float_t dcaToVertexZNeg = -1.0;
1633 positronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelPositive() );
1634 electronVgamma = fESDEvent->GetTrack( Vgamma->GetTrackLabelNegative() );
1635 clsToFPos = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(positronVgamma);
1636 clsToFNeg = ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetNFindableClustersTPC(electronVgamma);
1640 positronVgamma->GetImpactParameters(bPos,bCovPos);
1641 if (bCovPos[0]<=0 || bCovPos[2]<=0) {
1642 AliDebug(1, "Estimated b resolution lower or equal zero!");
1643 bCovPos[0]=0; bCovPos[2]=0;
1648 positronVgamma->GetImpactParameters(bNeg,bCovNeg);
1649 if (bCovNeg[0]<=0 || bCovNeg[2]<=0) {
1650 AliDebug(1, "Estimated b resolution lower or equal zero!");
1651 bCovNeg[0]=0; bCovNeg[2]=0;
1654 dcaToVertexXYPos = bPos[0];
1655 dcaToVertexZPos = bPos[1];
1656 dcaToVertexXYNeg = bNeg[0];
1657 dcaToVertexZNeg = bNeg[1];
1662 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
1665 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( pi0cand->Pt() , Vgamma->GetMass() ) == kTRUE ){
1667 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1669 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1670 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1675 hESDMotherPhi[fiCut]->Fill(pi0cand->Phi());
1677 if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
1679 hESDDalitzElectronAfterPt[fiCut]->Fill( electronVgamma->Pt() );
1680 hESDDalitzPositronAfterPt[fiCut]->Fill( positronVgamma->Pt() );
1682 hESDDalitzElectronAfterPhi[fiCut]->Fill( electronVgamma->Phi() );
1683 hESDDalitzPositronAfterPhi[fiCut]->Fill( positronVgamma->Phi() );
1685 hESDDalitzElectronAfterNFindClsTPC[fiCut]->Fill(clsToFNeg,electronVgamma->Pt());
1686 hESDDalitzPositronAfterNFindClsTPC[fiCut]->Fill(clsToFPos,positronVgamma->Pt());
1689 hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYNeg, electronVgamma->Pt() );
1690 hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZNeg, electronVgamma->Pt() );
1691 hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYPos, positronVgamma->Pt() );
1692 hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZPos, positronVgamma->Pt() );
1694 hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( positronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(positronVgamma, AliPID::kElectron) );
1695 hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( electronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(electronVgamma, AliPID::kElectron) );
1697 hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( positronVgamma->P(), TMath::Abs(positronVgamma->GetTPCsignal()));
1698 hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( electronVgamma->P(), TMath::Abs(electronVgamma->GetTPCsignal()));
1700 lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
1708 hESDMotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1709 Double_t sparesFill[4] = {pi0cand->M(),pi0cand->Pt(),(Double_t)zbin,(Double_t)mbin};
1710 sESDMotherInvMassPtZM[fiCut]->Fill(sparesFill,1);
1715 hESDMotherPhi[fiCut]->Fill(pi0cand->Phi());
1717 if( lGoodVirtualGamma[virtualGammaIndex] == kFALSE ) {
1719 hESDDalitzElectronAfterPt[fiCut]->Fill( electronVgamma->Pt() );
1720 hESDDalitzPositronAfterPt[fiCut]->Fill( positronVgamma->Pt() );
1722 hESDDalitzElectronAfterPhi[fiCut]->Fill( electronVgamma->Phi() );
1723 hESDDalitzPositronAfterPhi[fiCut]->Fill( positronVgamma->Phi() );
1725 hESDDalitzElectronAfterNFindClsTPC[fiCut]->Fill(clsToFNeg,electronVgamma->Pt());
1726 hESDDalitzPositronAfterNFindClsTPC[fiCut]->Fill(clsToFPos,positronVgamma->Pt());
1728 hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYNeg, electronVgamma->Pt() );
1729 hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZNeg, electronVgamma->Pt() );
1730 hESDDalitzPosEleAfterDCAxy[fiCut]->Fill( dcaToVertexXYPos, positronVgamma->Pt() );
1731 hESDDalitzPosEleAfterDCAz[fiCut]->Fill( dcaToVertexZPos, positronVgamma->Pt() );
1733 hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( positronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(positronVgamma, AliPID::kElectron) );
1734 hESDDalitzPosEleAfterTPCdEdx[fiCut]->Fill( electronVgamma->P(),((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetPIDResponse()->NumberOfSigmasTPC(electronVgamma, AliPID::kElectron) );
1736 hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( positronVgamma->P(), TMath::Abs(positronVgamma->GetTPCsignal()));
1737 hESDDalitzPosEleAfterTPCdEdxSignal[fiCut]->Fill( electronVgamma->P(), TMath::Abs(electronVgamma->GetTPCsignal()));
1740 lGoodVirtualGamma[virtualGammaIndex] = kTRUE;
1746 if( fDoChicAnalysis) {
1748 hESDPi0MotherInvMassPt[fiCut]->Fill(pi0cand->M(),pi0cand->Pt());
1750 Double_t diffMass = pi0cand->M() - Vgamma->GetMass();
1752 hESDPi0MotherDiffInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
1754 if( Vgamma->GetMass() > 2.5 && Vgamma->GetMass() < 3.4){
1755 hESDPi0MotherDiffLimInvMassPt[fiCut]->Fill( diffMass , pi0cand->Pt() );
1760 ProcessTrueMesonCandidates(pi0cand,gamma,Vgamma);
1770 //________________________________________________________________________
1771 void AliAnalysisTaskGammaConvDalitzV1::CalculateBackground(){
1773 Int_t zbin= fBGHandler[fiCut]->GetZBinIndex(fESDEvent->GetPrimaryVertex()->GetZ());
1778 method = ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->GetBKGMethod();
1781 if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity()){
1782 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fNumberOfESDTracks);
1784 mbin = fBGHandler[fiCut]->GetMultiplicityBinIndex(fGoodGammas->GetEntries());
1787 if( method == 1 || method == 2 ) {
1789 AliGammaConversionAODBGHandler::GammaConversionVertex *bgEventVertex = NULL;
1791 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ) {
1793 for(Int_t nEventsInBG=0;nEventsInBG<fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
1795 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
1797 if(fMoveParticleAccordingToVertex == kTRUE && method == 1){
1798 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
1801 for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
1802 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
1804 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
1805 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
1807 if(fMoveParticleAccordingToVertex == kTRUE && method == 1 ){
1808 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
1811 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
1814 if( ( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE, ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()))){
1815 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
1817 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.GetMass() ) == kTRUE ){
1819 // cout<<" Mass dalitz: "<<currentEventGoodV0.GetMass()<<endl;
1820 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1821 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1822 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1826 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1827 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1828 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1831 delete backgroundCandidate;
1832 backgroundCandidate = 0x0;
1838 for(Int_t nEventsInBG=0;nEventsInBG <fBGHandler[fiCut]->GetNBGEvents();nEventsInBG++){
1839 AliGammaConversionAODVector *previousEventV0s = fBGHandler[fiCut]->GetBGGoodV0s(zbin,mbin,nEventsInBG);
1840 if(previousEventV0s){
1841 if(fMoveParticleAccordingToVertex == kTRUE && method == 1){
1842 bgEventVertex = fBGHandler[fiCut]->GetBGEventVertex(zbin,mbin,nEventsInBG);
1844 for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
1846 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
1848 for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
1850 AliAODConversionPhoton previousGoodV0 = (AliAODConversionPhoton)(*(previousEventV0s->at(iPrevious)));
1852 if(fMoveParticleAccordingToVertex == kTRUE && method ==1){
1853 MoveParticleAccordingToVertex(&previousGoodV0,bgEventVertex);
1856 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
1858 if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()))){
1860 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
1862 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.GetMass() ) == kTRUE ){
1865 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1866 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1867 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1871 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1872 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1873 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1876 delete backgroundCandidate;
1877 backgroundCandidate = 0x0;
1885 else if( method == 3 ){
1887 for(Int_t iCurrent=0;iCurrent<fGoodVirtualGammas->GetEntries();iCurrent++){
1889 AliAODConversionPhoton currentEventGoodV0 = *(AliAODConversionPhoton*)(fGoodVirtualGammas->At(iCurrent));
1891 for(Int_t iPrevious=0;iPrevious<fGammasPool[fiCut]->GetEntries();iPrevious++){
1893 AliAODConversionPhoton previousGoodV0 = *(AliAODConversionPhoton*)((fGammasPool[fiCut]->At(iPrevious) ));
1896 AliAODConversionMother *backgroundCandidate = new AliAODConversionMother(¤tEventGoodV0,&previousGoodV0);
1899 if((((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelected(backgroundCandidate,kFALSE, ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()))){
1901 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
1903 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( backgroundCandidate->Pt() , currentEventGoodV0.GetMass() ) == kTRUE ){
1906 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1907 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1908 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1914 hESDMotherBackInvMassPt[fiCut]->Fill(backgroundCandidate->M(),backgroundCandidate->Pt());
1915 Double_t sparesFill[4] = {backgroundCandidate->M(),backgroundCandidate->Pt(),(Double_t)zbin,(Double_t)mbin};
1916 sESDMotherBackInvMassPtZM[fiCut]->Fill(sparesFill,1);
1920 delete backgroundCandidate;
1921 backgroundCandidate = 0x0;
1927 //________________________________________________________________________
1928 void AliAnalysisTaskGammaConvDalitzV1::UpdateEventByEventData(){
1929 //see header file for documentation
1933 method = ( (AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->GetBKGMethod();
1940 if(fGoodGammas->GetEntries() > 0 ){
1942 if( ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity() ){
1943 fBGHandler[fiCut]->AddEvent(fGoodGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fNumberOfESDTracks);
1946 else{ // means we use #V0s for multiplicity
1947 fBGHandler[fiCut]->AddEvent(fGoodGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fGoodGammas->GetEntries());
1952 else if ( method == 2 ){
1954 if(fGoodVirtualGammas->GetEntries() > 0 ){
1955 if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->UseTrackMultiplicity()){
1956 fBGHandler[fiCut]->AddEvent(fGoodVirtualGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fNumberOfESDTracks);
1958 else{ // means we use #V0s for multiplicity
1959 fBGHandler[fiCut]->AddEvent(fGoodVirtualGammas,fESDEvent->GetPrimaryVertex()->GetX(),fESDEvent->GetPrimaryVertex()->GetY(),fESDEvent->GetPrimaryVertex()->GetZ(),fGoodVirtualGammas->GetEntries());
1963 else if ( method == 3 ) {
1967 for(Int_t index = 0; index < fGoodGammas->GetEntries(); index++){
1970 if ( fGammasPool[fiCut]->GetEntries() > ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->NumberOfRotationEvents() ){
1971 fGammasPool[fiCut]->RemoveLast();
1973 fGammasPool[fiCut]->AddFirst( new AliAODConversionPhoton(*(AliAODConversionPhoton*)(fGoodGammas->At(index)) ) );
1978 //______________________________________________________________________
1979 void AliAnalysisTaskGammaConvDalitzV1::ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate, AliAODConversionPhoton *TrueVirtualGammaCandidate)
1982 // Process True Mesons
1984 AliStack *MCStack = fMCEvent->Stack();
1986 if( TrueGammaCandidate->GetV0Index()<fESDEvent->GetNumberOfV0s() ){
1989 //cout<<"Entro True Meson"<<endl;
1992 Bool_t isTruePi0 = kFALSE;
1993 Bool_t isTrueEta = kFALSE;
1994 Bool_t massCutAccept = kFALSE;
1995 Bool_t isTrueChiC = kFALSE;
1996 Int_t gammaMCLabel = TrueGammaCandidate->GetMCParticleLabel(MCStack);
1997 Int_t gammaMotherLabel = -1;
2000 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->DoMassCut() == kTRUE ) {
2002 if( ((AliDalitzElectronCuts*) fCutElectronArray->At(fiCut))->MassCut( Pi0Candidate->Pt() , TrueVirtualGammaCandidate->GetMass() ) == kTRUE ){
2004 massCutAccept = kTRUE;
2008 massCutAccept = kTRUE;
2015 if(gammaMCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2018 // Daughters Gamma 0
2019 TParticle * negativeMC = (TParticle*)TrueGammaCandidate->GetNegativeMCDaughter(MCStack);
2020 TParticle * positiveMC = (TParticle*)TrueGammaCandidate->GetPositiveMCDaughter(MCStack);
2021 TParticle * gammaMC = (TParticle*)MCStack->Particle(gammaMCLabel);
2024 if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2026 if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2028 if(gammaMC->GetPdgCode() == 22){ // ... with Gamma Mother
2029 gammaMotherLabel=gammaMC->GetFirstMother();
2036 Int_t virtualGammaMCLabel = TrueVirtualGammaCandidate->GetMCParticleLabel(MCStack);
2037 Int_t virtualGammaMotherLabel = -1;
2038 Int_t virtualGamma = 1;
2039 Int_t virtualGammaGrandMotherLabel =-1;
2042 if(virtualGammaMCLabel != -1){ // Gamma is Combinatorial; MC Particles don't belong to the same Mother
2043 // Daughters Gamma 1
2044 TParticle * negativeMC = (TParticle*)TrueVirtualGammaCandidate->GetNegativeMCDaughter(MCStack);
2045 TParticle * positiveMC = (TParticle*)TrueVirtualGammaCandidate->GetPositiveMCDaughter(MCStack);
2046 TParticle * virtualGammaMotherMC = (TParticle*)MCStack->Particle(virtualGammaMCLabel);
2048 if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){ // Electrons ...
2050 if( virtualGammaMotherMC->GetPdgCode() != 22 ){
2051 virtualGammaMotherLabel=virtualGammaMCLabel;
2052 if(virtualGammaMotherMC->GetPdgCode() == 443){
2053 virtualGammaGrandMotherLabel=virtualGammaMotherMC->GetFirstMother();
2057 else if(negativeMC->GetUniqueID() == 5 && positiveMC->GetUniqueID() ==5){ // ... From Conversion ...
2058 virtualGammaMotherLabel=virtualGammaMotherMC->GetFirstMother();
2059 virtualGamma = 0; //no virtual gamma
2065 if(gammaMotherLabel >= 0 && ( gammaMotherLabel == virtualGammaMotherLabel) ){
2067 if(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetPdgCode() == 111){
2071 if(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetPdgCode() == 221){
2078 if( fDoChicAnalysis) {
2079 if(gammaMotherLabel>=0 && ( gammaMotherLabel == virtualGammaGrandMotherLabel) ){
2080 if(((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 445 ||
2081 ((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 10443 ||
2082 ((TParticle*)MCStack->Particle(virtualGammaGrandMotherLabel))->GetPdgCode() == 20443 ){
2084 hESDTrueMotherChiCInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2085 hESDTrueMotherChiCDiffInvMassPt[fiCut]->Fill(Pi0Candidate->M()-TrueVirtualGammaCandidate->GetMass(),Pi0Candidate->Pt());
2090 if( ( isTruePi0 || isTrueEta) && massCutAccept ){ // True Pion or Eta
2092 if ( virtualGamma == 1 ) { //True Dalitz
2094 //cout<<"True Dalitz"<<endl;
2096 hESDTrueMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2097 hESDTrueMotherDalitzInvMassPt[fiCut]->Fill( TrueVirtualGammaCandidate->GetMass(),Pi0Candidate->Pt());
2099 if(gammaMotherLabel < MCStack->GetNprimary()){ // Only primary pi0 for efficiency calculation
2101 Float_t weighted= 1;
2102 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(gammaMotherLabel, fMCStack,fInputEvent)){
2103 if (((TParticle*)MCStack->Particle(gammaMotherLabel))->Pt()>0.005){
2104 weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),gammaMotherLabel,fMCStack,fInputEvent);
2107 hESDTruePrimaryMotherInvMassMCPt[fiCut]->Fill(Pi0Candidate->M(),((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->Pt(),weighted);
2108 if(isTruePi0){ // Only primaries for unfolding
2109 hESDTruePrimaryPi0DalitzESDPtMCPt[fiCut]->Fill(Pi0Candidate->Pt(),((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->Pt(),weighted);
2112 else { // Secondary Meson
2113 hESDTrueSecondaryMotherInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2114 //if (((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetMother(0) >-1){
2115 // if(MCStack->Particle(((TParticle*)MCStack->Particle(virtualGammaMotherLabel))->GetMother(0))->GetPdgCode()==kK0Short){
2116 // hESDTrueSecondaryMotherFromK0sInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2120 else if ( virtualGamma == 0 ){
2121 hESDTrueMotherPi0GGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt()); // Pi0 from GG
2125 if(!isTruePi0 && !isTrueEta && massCutAccept ){ // Background
2126 if(gammaMotherLabel>-1 && virtualGammaMotherLabel>-1 && virtualGamma == 0){ // Both Tracks are Photons and have a mother but not Pi0 or Eta
2127 hESDTrueBckGGInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2128 } else { // No photon or without mother
2129 hESDTrueBckContInvMassPt[fiCut]->Fill(Pi0Candidate->M(),Pi0Candidate->Pt());
2136 //________________________________________________________________________
2137 void AliAnalysisTaskGammaConvDalitzV1::MoveParticleAccordingToVertex(AliAODConversionPhoton* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex){
2138 //see header file for documentation
2140 Double_t dx = vertex->fX - fESDEvent->GetPrimaryVertex()->GetX();
2141 Double_t dy = vertex->fY - fESDEvent->GetPrimaryVertex()->GetY();
2142 Double_t dz = vertex->fZ - fESDEvent->GetPrimaryVertex()->GetZ();
2144 Double_t movedPlace[3] = {particle->GetConversionX() - dx,particle->GetConversionY() - dy,particle->GetConversionZ() - dz};
2145 particle->SetConversionPoint(movedPlace);
2149 //________________________________________________________________________
2150 void AliAnalysisTaskGammaConvDalitzV1::CountESDTracks(){
2152 // Using standard function for setting Cuts
2153 Bool_t selectPrimaries=kTRUE;
2154 AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
2155 EsdTrackCuts->SetMaxDCAToVertexZ(2);
2156 EsdTrackCuts->SetEtaRange(-0.8, 0.8);
2157 EsdTrackCuts->SetPtRange(0.15);
2159 fNumberOfESDTracks = 0;
2160 for(Int_t iTracks = 0; iTracks < fESDEvent->GetNumberOfTracks(); iTracks++){
2161 AliESDtrack* curTrack = fESDEvent->GetTrack(iTracks);
2162 if(!curTrack) continue;
2163 if(EsdTrackCuts->AcceptTrack(curTrack) ) fNumberOfESDTracks++;
2165 delete EsdTrackCuts;
2171 //_____________________________________________________________________________
2172 void AliAnalysisTaskGammaConvDalitzV1::ProcessMCParticles()
2175 // Loop over all primary MC particle
2177 for(Int_t i = 0; i < fMCStack->GetNprimary(); i++) {
2180 TParticle* particle = (TParticle *)fMCStack->Particle(i);
2181 if (!particle) continue;
2184 Bool_t mcIsFromMB = kTRUE;
2185 Int_t isMCFromMBHeader = -1;
2187 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 0) {
2189 = ((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i,fMCStack,fInputEvent);
2190 if(isMCFromMBHeader == 0 && ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetSignalRejection() != 3) continue;
2191 if(isMCFromMBHeader != 2) mcIsFromMB = kFALSE;
2194 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kFALSE)){
2195 hMCAllGammaPt[fiCut]->Fill(particle->Pt()); // All MC Gamma
2198 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(particle,fMCStack,kTRUE)){
2199 hMCConvGammaPt[fiCut]->Fill(particle->Pt());
2201 hMCConvGammaRSPt[fiCut]->Fill(particle->Pt());
2203 } // Converted MC Gamma
2205 if(((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(i,fMCStack)){
2206 if( particle->GetPdgCode() == -11)hMCAllPositronsPt[fiCut]->Fill(particle->Pt()); // All positrons
2207 if( particle->GetPdgCode() == 11)hMCAllElectronsPt[fiCut]->Fill(particle->Pt()); // All electrons
2210 if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMC(particle,fMCStack,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()) ){
2212 Float_t weighted= 1;
2214 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack, fInputEvent)){
2215 if (particle->Pt()>0.005){
2216 weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
2220 if(particle->GetPdgCode() == 111)hMCPi0GGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Pi0 GG decay
2221 if(particle->GetPdgCode() == 221)hMCEtaGGPt[fiCut]->Fill( particle->Pt() , weighted); // All MC Eta GG decay
2225 Int_t labelgamma = -1;
2226 Int_t labelelectron = -1;
2227 Int_t labelpositron = -1;
2230 if( ((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMCDalitz(particle,fMCStack,labelelectron,labelpositron,labelgamma,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift()) )
2234 Float_t weighted= 1;
2236 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->IsParticleFromBGEvent(i, fMCStack,fInputEvent)){
2237 if (particle->Pt()>0.005){
2238 weighted= ((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetWeightForMeson(fV0Reader->GetPeriodName(),i, fMCStack,fInputEvent);
2242 if(particle->GetPdgCode() == 111)hMCPi0Pt[fiCut]->Fill(particle->Pt(), weighted); // All MC Pi0
2243 if(particle->GetPdgCode() == 221)hMCEtaPt[fiCut]->Fill(particle->Pt(), weighted); // All MC Eta
2245 // Check the acceptance for gamma and electrons
2248 TParticle *gamma = fMCStack->Particle(labelgamma);
2249 TParticle *electron = fMCStack->Particle(labelelectron);
2250 TParticle *positron = fMCStack->Particle(labelpositron);
2253 if(((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC(gamma,fMCStack,kFALSE) &&
2254 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelelectron,fMCStack) &&
2255 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelpositron,fMCStack) ) {
2257 if(particle->GetPdgCode() == 111){
2259 hMCPi0InAccPt[fiCut]->Fill(particle->Pt() , weighted); // MC Pi0Dalitz with gamma and e+e- in acc
2260 hMCPi0DalitzGammaPt[fiCut]->Fill( gamma->Pt() ,weighted );
2261 hMCPi0DalitzPositronPt[fiCut]->Fill( positron->Pt(),weighted );
2262 hMCPi0DalitzElectronPt[fiCut]->Fill( electron->Pt(),weighted );
2265 if(particle->GetPdgCode() == 221)hMCEtaInAccPt[fiCut]->Fill(particle->Pt(), weighted ); // MC EtaDalitz with gamma and e+e- in acc
2270 Int_t labelgammaChiC=-1;
2271 Int_t labelpositronChiC=-1;
2272 Int_t labelelectronChiC=-1;
2274 if(((AliConversionMesonCuts*)fCutMesonArray->At(fiCut))->MesonIsSelectedMCChiC(particle,fMCStack,labelelectronChiC,labelpositronChiC,labelgammaChiC,((AliConversionCuts*)fCutGammaArray->At(fiCut))->GetEtaShift())){
2276 hMCChiCPt[fiCut]->Fill(particle->Pt()); // All MC ChiC
2277 TParticle * gammaChiC =fMCStack->Particle(labelgammaChiC);
2279 if( ((AliConversionCuts*)fCutGammaArray->At(fiCut))->PhotonIsSelectedMC( gammaChiC,fMCStack,kFALSE) &&
2280 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelelectronChiC,fMCStack) &&
2281 ((AliDalitzElectronCuts*)fCutElectronArray->At(fiCut))->ElectronIsSelectedMC(labelpositronChiC,fMCStack) ){
2282 hMCChiCInAccPt[fiCut]->Fill(particle->Pt()); // All MC ChiC
2287 //_____________________________________________________________________________
2288 Bool_t AliAnalysisTaskGammaConvDalitzV1::IsDalitz(TParticle *fMCMother) const
2291 if( fMCMother->GetNDaughters() != 3 ) return kFALSE;
2292 if( fMCMother->GetPdgCode() != 111 && fMCMother->GetPdgCode() != 221 ) return kFALSE;
2295 TParticle *positron = 0x0;
2296 TParticle *electron = 0x0;
2297 TParticle *gamma = 0x0;
2299 for(Int_t index= fMCMother->GetFirstDaughter();index<= fMCMother->GetLastDaughter();index++){
2301 TParticle* temp = (TParticle*)fMCStack->Particle( index );
2303 switch( temp->GetPdgCode() ) {
2316 if( positron && electron && gamma) return kTRUE;
2320 //_____________________________________________________________________________________
2321 Bool_t AliAnalysisTaskGammaConvDalitzV1::IsPi0DalitzDaughter( Int_t label ) const
2324 // Returns true if the particle comes from Pi0 -> e+ e- gamma
2327 Int_t motherLabel = fMCStack->Particle( label )->GetMother(0);
2329 if( motherLabel < 0 || motherLabel >= fMCStack->GetNtrack() ) return kFALSE;
2331 TParticle* mother = fMCStack->Particle( motherLabel );
2333 if( mother->GetPdgCode() != 111 ) return kFALSE;
2335 if( IsDalitz( mother ) ) return kTRUE;
2344 //_____________________________________________________________________________
2345 Double_t AliAnalysisTaskGammaConvDalitzV1::GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg ) const
2348 // This angle is a measure for the contribution of the opening in polar
2349 // direction ?0 to the opening angle ? Pair
2351 // Ref. Measurement of photons via conversion pairs with the PHENIX experiment at RHIC
2352 // Master Thesis. Thorsten Dahms. 2005
2353 // https://twiki.cern.ch/twiki/pub/ALICE/GammaPhysicsPublications/tdahms_thesis.pdf
2357 if( trackPos->GetConstrainedPxPyPz(momPos) == 0 ) trackPos->GetPxPyPz( momPos );
2358 if( trackNeg->GetConstrainedPxPyPz(momNeg) == 0 ) trackNeg->GetPxPyPz( momNeg );
2360 TVector3 posDaughter;
2361 TVector3 negDaughter;
2363 posDaughter.SetXYZ( momPos[0], momPos[1], momPos[2] );
2364 negDaughter.SetXYZ( momNeg[0], momNeg[1], momNeg[2] );
2366 Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();
2367 Double_t openingAngle = posDaughter.Angle( negDaughter ); //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );
2369 if( openingAngle < 1e-20 ) return 0.;
2371 Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );