]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG3/hfe/AliHFEelecbackground.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Minor fix for software triggers.
[u/mrichter/AliRoot.git] / PWG3 / hfe / AliHFEelecbackground.cxx
CommitLineData
02524e30 1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15//
16//
17// First implementation of a class
18// to reject tagged electron coming from conversion, pi0 and eta
19// by calculating the e+e- invariant mass
20// of the tagged electron with other tracks
21// after looser cuts for the partner.
22// PostProcess should extract the background yield
23// If running with MC, it can be compared to the expected background yield
24//
25// Authors:
26// Raphaelle Bailhache <rbailhache@ikf.uni-frankfurt.de > <R.Bailhache@gsi.de >
27//
28//
29
30#include <THnSparse.h>
31#include <TParticle.h>
32#include <TFile.h>
33#include <TCanvas.h>
34#include <TAxis.h>
35#include <TH1D.h>
d2af20c5 36#include <TH2D.h>
70da6c5a 37#include <TH1F.h>
38#include <TH2F.h>
39#include <TF1.h>
02524e30 40#include <TString.h>
41#include <TLegend.h>
70da6c5a 42#include <TStyle.h>
02524e30 43
44#include <AliESDEvent.h>
45#include <AliAODEvent.h>
46#include <AliESDtrack.h>
47#include <AliAODTrack.h>
48#include "AliHFEelecbackground.h"
49#include <AliMCEvent.h>
50#include <AliStack.h>
70da6c5a 51#include <AliKFParticle.h>
52#include "AliCFContainer.h"
53#include "AliHFEpid.h"
54#include "AliESDpid.h"
69ac0e6f 55#include "AliLog.h"
70da6c5a 56#include "AliITSPIDResponse.h"
57#include "AliTPCPIDResponse.h"
02524e30 58
59ClassImp(AliHFEelecbackground)
60
d2af20c5 61Bool_t AliHFEelecbackground::fgUseMCPID = kFALSE;
62const Double_t AliHFEelecbackground::fgkMe = 0.00051099892;
02524e30 63
64//___________________________________________________________________________________________
65AliHFEelecbackground::AliHFEelecbackground():
69ac0e6f 66 fhtmp(0x0)
67 ,fhtmpf(0x0)
68 ,fhtmpp(0x0)
69 ,fESD1(0x0)
02524e30 70 ,fAOD1(0x0)
71 ,fMCEvent(0x0)
72 ,fBz(0)
73 ,fkVertex(0x0)
02524e30 74 ,fPtESD(0.0)
75 ,fIndexTrack(0)
02524e30 76 ,fPdg(0)
77 ,fLabMother(-1)
78 ,fIsFrom(-1)
79 ,fMotherGamma(-1)
80 ,fMotherPi0(-1)
81 ,fMotherC(-1)
82 ,fMotherB(-1)
83 ,fMotherEta(-1)
84 ,fIsPartner(kFALSE)
d2af20c5 85 ,fIsSplittedTrack(kFALSE)
70da6c5a 86 ,fOpeningAngleCut(0.35)
87 ,fInvMassCut(140.0)
88 ,fChi2NdfCut(999999999.0)
89 ,fUseAliKFCode(kTRUE)
90 ,fSharedClusterCut(kFALSE)
91 ,fRequireITSStandalone(0)
92 ,fMinNbCls(2)
93 ,fMinITSChi2(10.0)
94 ,fMinNbClsSDDSPD(2)
95 ,fPIDPartner(kFALSE)
96 ,fPIDMethodPartner(0x0)
97 ,fPIDMethodPartnerITS(0x0)
98 ,fDebugLevel(0)
02524e30 99 ,fList(0x0)
100 ,fListPostProcess(0x0)
101{
102 //
103 // Default constructor
104 //
69ac0e6f 105 for(Int_t k =0; k < 10; k++) {
106 fCuts[k] = kFALSE;
107 }
02524e30 108
109}
110
111//_______________________________________________________________________________________________
112AliHFEelecbackground::AliHFEelecbackground(const AliHFEelecbackground &p):
113 TObject(p)
69ac0e6f 114 ,fhtmp(0x0)
115 ,fhtmpf(0x0)
116 ,fhtmpp(0x0)
02524e30 117 ,fESD1(0x0)
118 ,fAOD1(0x0)
119 ,fMCEvent(0x0)
120 ,fBz(p.fBz)
121 ,fkVertex(p.fkVertex)
02524e30 122 ,fPtESD(p.fPtESD)
123 ,fIndexTrack(0)
02524e30 124 ,fPdg(0)
125 ,fLabMother(-1)
126 ,fIsFrom(-1)
127 ,fMotherGamma(-1)
128 ,fMotherPi0(-1)
129 ,fMotherC(-1)
130 ,fMotherB(-1)
131 ,fMotherEta(-1)
132 ,fIsPartner(kFALSE)
d2af20c5 133 ,fIsSplittedTrack(kFALSE)
70da6c5a 134 ,fOpeningAngleCut(0.35)
135 ,fInvMassCut(140.0)
136 ,fChi2NdfCut(999999999.0)
137 ,fUseAliKFCode(kTRUE)
138 ,fSharedClusterCut(kFALSE)
139 ,fRequireITSStandalone(0)
140 ,fMinNbCls(2)
141 ,fMinITSChi2(10.0)
142 ,fMinNbClsSDDSPD(2)
143 ,fPIDPartner(kFALSE)
144 ,fPIDMethodPartner(0x0)
145 ,fPIDMethodPartnerITS(0x0)
146 ,fDebugLevel(0)
02524e30 147 ,fList(0x0)
148 ,fListPostProcess(0x0)
149{
150 //
151 // Copy constructor
152 //
69ac0e6f 153 for(Int_t k =0; k < 10; k++) {
154 fCuts[k] = kFALSE;
155 }
02524e30 156}
157
158//_______________________________________________________________________________________________
159AliHFEelecbackground&
160AliHFEelecbackground::operator=(const AliHFEelecbackground &)
161{
162 //
163 // Assignment operator
164 //
165
166 AliInfo("Not yet implemented.");
167 return *this;
168}
169
170//_______________________________________________________________________________________________
171AliHFEelecbackground::~AliHFEelecbackground()
172{
173 //
174 // Destructor
175 //
70da6c5a 176 if(fPIDMethodPartner) delete fPIDMethodPartner;
177 if(fPIDMethodPartnerITS) delete fPIDMethodPartnerITS;
02524e30 178
179 if(fList){
180 fList->Clear();
181 delete fList;
182 }
183
184 if(fListPostProcess){
185 fListPostProcess->Clear();
186 delete fListPostProcess;
187 }
188}
189//___________________________________________________________________________________________
70da6c5a 190Bool_t AliHFEelecbackground::Load(const Char_t * filename)
02524e30 191{
192 //
193 // Generic container loader
194 //
195
196 if(!TFile::Open(filename)){
197 return kFALSE;
198 }
199 TList *o = 0x0;
200 if(!(o = (TList*)gFile->Get("Results"))){
201 return kFALSE;
202 }
203 TList *oe = 0x0;
204 if(!(oe = (TList*)dynamic_cast<TList *>(o->FindObject("HFEelecbackground")))){
205 return kFALSE;
206 }
207 fList = (TList*)oe->Clone("HFEelecbackground");
208 gFile->Close();
209 return kTRUE;
210}
70da6c5a 211//___________________________________________________________________________________________
212Bool_t AliHFEelecbackground::Load(TList * const outputlist)
213{
214 //
215 // Generic container loader
216 //
217 if(!outputlist) return kFALSE;
218 else fList = (TList*)outputlist->Clone("HFEelecbackground");
219 return kTRUE;
220}
02524e30 221//_______________________________________________________________________________________________
d2af20c5 222void AliHFEelecbackground::Reset()
223{
224 //
225 // Reset variables
226 //
227 fPtESD = 0.0;
228 fIndexTrack = -1;
229 fPdg = -1;
230 fLabMother = -1;
231 fIsFrom = -1;
232 fMotherGamma = -1;
233 fMotherPi0 = -1;
234 fMotherC = -1;
235 fMotherB = -1;
236 fMotherEta = -1;
237 fIsPartner = kFALSE;
238 fIsSplittedTrack = kFALSE;
70da6c5a 239 for(Int_t id = 0; id < 10; id++) {
240 fCuts[id] = kFALSE;
241 }
d2af20c5 242
243}
244//_______________________________________________________________________________________________
70da6c5a 245void AliHFEelecbackground::CreateHistograms(TList * const qaList)
02524e30 246{
247 //
248 // create histograms
249 //
250 if(!qaList) return;
70da6c5a 251
02524e30 252 fList = qaList;
70da6c5a 253 fList->SetName("HFEelecbackground");
254
255 //////////
02524e30 256 // bins
70da6c5a 257 /////////
02524e30 258
67fe7bd0 259 const Int_t nBinsPt = 25;
70da6c5a 260 Double_t minPt = 0.01;
02524e30 261 Double_t maxPt = 10.0;
262
67fe7bd0 263 const Int_t nBinsPtMore = 100;
70da6c5a 264 Double_t minPtMore = 0.01;
265 Double_t maxPtMore = 10.0;
266
67fe7bd0 267 const Int_t nBinsInv = 50;
02524e30 268 Double_t minInv = 0.0;
269 Double_t maxInv = 0.2;
270
67fe7bd0 271 const Int_t nBinsOp = 50;
02524e30 272 Double_t minOp = 0.0;
273 Double_t maxOp = 2;
274
67fe7bd0 275 const Int_t nBinsCh = 4;
70da6c5a 276 Double_t minCh = 0.0;
277 Double_t maxCh = 4.0;
278
67fe7bd0 279 Double_t binLimLogPt[nBinsPt+1];
280 Double_t binLimPt[nBinsPt+1];
02524e30 281 for(Int_t i=0; i<=nBinsPt; i++) binLimLogPt[i]=(Double_t)TMath::Log10(minPt) + (TMath::Log10(maxPt)-TMath::Log10(minPt))/nBinsPt*(Double_t)i ;
282 for(Int_t i=0; i<=nBinsPt; i++) binLimPt[i]=(Double_t)TMath::Power(10,binLimLogPt[i]);
283
67fe7bd0 284 Double_t binLimLogPtMore[nBinsPtMore+1];
285 Double_t binLimPtMore[nBinsPtMore+1];
70da6c5a 286 for(Int_t i=0; i<=nBinsPtMore; i++) binLimLogPtMore[i]=(Double_t)TMath::Log10(minPtMore) + (TMath::Log10(maxPtMore)-TMath::Log10(minPtMore))/nBinsPtMore*(Double_t)i ;
287 for(Int_t i=0; i<=nBinsPtMore; i++) binLimPtMore[i]=(Double_t)TMath::Power(10,binLimLogPtMore[i]);
288
67fe7bd0 289 Double_t binLimInv[nBinsInv+1];
02524e30 290 for(Int_t i=0; i<=nBinsInv; i++) binLimInv[i]=(Double_t)minInv + (maxInv-minInv) /nBinsInv*(Double_t)i ;
291
67fe7bd0 292 Double_t binLimOp[nBinsOp+1];
02524e30 293 for(Int_t i=0; i<=nBinsOp; i++) binLimOp[i]=(Double_t)minOp + (maxOp-minOp) /nBinsOp*(Double_t)i ;
294
67fe7bd0 295 Double_t binLimCh[nBinsCh+1];
70da6c5a 296 for(Int_t i=0; i<=nBinsCh; i++) binLimCh[i]=(Double_t)minCh + (maxCh-minCh) /nBinsCh*(Double_t)i ;
02524e30 297
70da6c5a 298 const Int_t nvarData = 5;
299 // pt reconstructed tagged e
300 // pt reconstructed mother
301 // opening angle
302 // invariant mass
303 // Data: charge (0-opposite sign, 1-like sign ++, 2-like sign --, 3-rotated tracks)
02524e30 304
70da6c5a 305 Int_t iBinData[nvarData];
306 iBinData[0]=nBinsPt;
307 iBinData[1]=nBinsPt;
308 iBinData[2]=nBinsOp;
309 iBinData[3]=nBinsInv;
310 iBinData[4]=nBinsCh;
02524e30 311
02524e30 312 //
70da6c5a 313 // Opening angle and invariant mass
02524e30 314 //
315
70da6c5a 316 THnSparseF *hsSparseData = new THnSparseF("OpeningangleinvmassData","",nvarData,iBinData);
67fe7bd0 317 hsSparseData->SetBinEdges(0,&binLimPt[0]);
318 hsSparseData->SetBinEdges(1,&binLimPt[0]);
319 hsSparseData->SetBinEdges(2,&binLimOp[0]);
320 hsSparseData->SetBinEdges(3,&binLimInv[0]);
321 hsSparseData->SetBinEdges(4,&binLimCh[0]);
70da6c5a 322 hsSparseData->Sumw2();
02524e30 323
70da6c5a 324 fList->AddAt(hsSparseData,kDatai);
02524e30 325
70da6c5a 326 //
327 // Radius, DCA and Chi2Ndf
328 //
02524e30 329
70da6c5a 330 TH1F *dataRadiusHisto = new TH1F("DataRadius","", 200, 0.0, 200.0); // recontructed radius from the AliKF of the e+e- pair
331 fList->AddAt(dataRadiusHisto,kDatar);
d2af20c5 332
70da6c5a 333 TH1F *dataDcaHisto = new TH1F("DataDCA","", 100, 0.0, 6.0); // dca distribution
334 fList->AddAt(dataDcaHisto,kDatadca);
02524e30 335
70da6c5a 336 TH1F *dataChi2NdfHisto = new TH1F("DataChi2Ndf","", 100, 0.0, 5.0); // chi2Ndf distribution
337 fList->AddAt(dataChi2NdfHisto,kDatachi2Ndf);
02524e30 338
70da6c5a 339
02524e30 340 if(HasMCData()) {
70da6c5a 341
342 //
343 // Opening angle and invariant mass with MC infos
344 //
345
346 const Int_t nvarMCo = 6;
347 // pt reconstructed tagged e
348 // pt reconstructed mother
349 // opening angle
350 // invariant mass
351 // MC: 0-FromBackground, 1-FromGamma, 2-FromPi0, 3-FromEta, 4-FromC, 5-FromB
352 // MCSplitted: 0-not, 1-splittedOs, 2-ksplittedSs
02524e30 353
02524e30 354
67fe7bd0 355 const Int_t nBinsMCOrigin = 6;
70da6c5a 356 Double_t minMCOrigin = 0.0;
357 Double_t maxMCOrigin = 6.0;
358
67fe7bd0 359 Double_t binLimMCOrigin[nBinsMCOrigin+1];
70da6c5a 360 for(Int_t i=0; i<=nBinsMCOrigin; i++) binLimMCOrigin[i]=(Double_t)minMCOrigin + (maxMCOrigin-minMCOrigin) /nBinsMCOrigin*(Double_t)i ;
d2af20c5 361
67fe7bd0 362 const Int_t nBinsMCSplitted = 3;
70da6c5a 363 Double_t minMCSplitted = 0.0;
364 Double_t maxMCSplitted = 3.0;
365
67fe7bd0 366 Double_t binLimMCSplitted[nBinsMCSplitted+1];
70da6c5a 367 for(Int_t i=0; i<=nBinsMCSplitted; i++) binLimMCSplitted[i]=(Double_t)minMCSplitted + (maxMCSplitted-minMCSplitted) /nBinsMCSplitted*(Double_t)i ;
368
369 Int_t iBinMCo[nvarMCo];
370 iBinMCo[0]=nBinsPt;
371 iBinMCo[1]=nBinsPt;
372 iBinMCo[2]=nBinsOp;
373 iBinMCo[3]=nBinsInv;
374 iBinMCo[4]=nBinsMCOrigin;
375 iBinMCo[5]=nBinsMCSplitted;
376
377 THnSparseF *hsSparseMCo = new THnSparseF("OpeningangleinvmassMC","",nvarMCo,iBinMCo);
67fe7bd0 378 hsSparseMCo->SetBinEdges(0,&binLimPt[0]);
379 hsSparseMCo->SetBinEdges(1,&binLimPt[0]);
380 hsSparseMCo->SetBinEdges(2,&binLimOp[0]);
381 hsSparseMCo->SetBinEdges(3,&binLimInv[0]);
382 hsSparseMCo->SetBinEdges(4,&binLimMCOrigin[0]);
383 hsSparseMCo->SetBinEdges(5,&binLimMCSplitted[0]);
70da6c5a 384 hsSparseMCo->Sumw2();
385
386 fList->AddAt(hsSparseMCo,kMCo);
387
388 //
389 // Radius, DCA and Chi2Ndf with MC info
390 //
391
392 TH2F *mcRadiusHisto = new TH2F("MCRadius","", 200, 0.0, 200.0,6,-0.5,5.5); // recontructed radius from the AliKF of the e+e- pair
393 fList->AddAt(mcRadiusHisto,kMCr);
394
395 TH2F *mcDcaHisto = new TH2F("MCDCA","", 100, 0.0, 6.0,6,-0.5,5.5); // dca distribution
396 fList->AddAt(mcDcaHisto,kMCdca);
397
398 TH2F *mcChi2NdfHisto = new TH2F("MCChi2Ndf","", 100, 0.0, 5.0,6,-0.5,5.5); // chi2Ndf distribution
399 fList->AddAt(mcChi2NdfHisto,kMCchi2Ndf);
400
401 //////////////////////////////////////////////////////////
402 // if fDebugLevel 1: Rejection efficiencies of the cuts
403 //////////////////////////////////////////////////////////
404
405 if(fDebugLevel > 0) {
406
407 if(HasMCData()) {
408
409 const Int_t nvarMCe = 3;
410 // pt reconstructed tagged e
411 // cut passed: 0-all, 1-Partner tracked, 2-Opposite-sign, 3-SingleTrackCutPart, 4-ShareCluster, 5-PID, 6-DCA, 7-chi2Ndf AliKF, 8-Openingangle, 9-Invmass
412 // MC: 0-FromBackground, 1-FromGamma, 2-FromPi0, 3-FromEta, 4-FromC, 5-FromB
413
67fe7bd0 414 const Int_t nBinsMCCutPassed = 10;
70da6c5a 415 Double_t minMCCutPassed = -0.5;
416 Double_t maxMCCutPassed = 9.5;
417
67fe7bd0 418 Double_t binLimMCCutPassed[nBinsMCCutPassed+1];
70da6c5a 419 for(Int_t i=0; i<=nBinsMCCutPassed; i++) binLimMCCutPassed[i]=(Double_t)minMCCutPassed + (maxMCCutPassed-minMCCutPassed) /nBinsMCCutPassed*(Double_t)i ;
420
421 Int_t iBinMCe[nvarMCe];
422 iBinMCe[0]=nBinsPt;
423 iBinMCe[1]=nBinsMCCutPassed;
424 iBinMCe[2]=nBinsMCOrigin;
425
426 THnSparseF *hsSparseMCe = new THnSparseF("CutPassedMC","",nvarMCe,iBinMCe);
67fe7bd0 427 hsSparseMCe->SetBinEdges(0,&binLimPt[0]);
428 hsSparseMCe->SetBinEdges(1,&binLimMCCutPassed[0]);
429 hsSparseMCe->SetBinEdges(2,&binLimMCOrigin[0]);
70da6c5a 430 hsSparseMCe->Sumw2();
431
432 fList->AddAt(hsSparseMCe,kMCe);
433
434 }
435 }
436
437 /////////////////////////////////////////////////////////////////
438 // if fDebugLevel 1: PIDPartCut and ShareClusters
439 /////////////////////////////////////////////////////////////////
440
441 if(fDebugLevel > 1) {
442
443 if(!fRequireITSStandalone){
444
445 //
446 // TPC
447 //
448
449 TH2F *tpcPartner0 = new TH2F("TPCPartner0","", nBinsPtMore, binLimPtMore, 200, 0.0, 700.0);
450 fList->AddAt(tpcPartner0,kMCcutPart0);
451 TH2F *tpcPartner1 = new TH2F("TPCPartner1","", nBinsPtMore, binLimPtMore, 200, 0.0, 700.0);
452 fList->AddAt(tpcPartner1,kMCcutPart1);
453
454 }
455 else {
456
457 //
458 // ITS
459 //
460
461 TH2F *itsPartner0 = new TH2F("ITSPartner0","", nBinsPtMore, binLimPtMore, 200, 0.0, 700.0);
462 fList->AddAt(itsPartner0,kMCcutPart0);
463 TH2F *itsPartner1 = new TH2F("ITSPartner1","", nBinsPtMore, binLimPtMore, 200, 0.0, 700.0);
464 fList->AddAt(itsPartner1,kMCcutPart1);
465
466 /////////////////////////////////////////////////////
467 // dEdx of the four layers for the track partner
468 /////////////////////////////////////////////////////
469 const Int_t nvarITSsignal = 5;
470
67fe7bd0 471 const Int_t nBinsITSsignal = 100;
70da6c5a 472 Double_t minITSsignal = 0.0;
473 Double_t maxITSsignal = 350.0;
474
67fe7bd0 475 Double_t binLimITSsignal[nBinsITSsignal+1];
70da6c5a 476 for(Int_t i=0; i<=nBinsITSsignal; i++) binLimITSsignal[i]=(Double_t)minITSsignal + (maxITSsignal-minITSsignal) /nBinsITSsignal*(Double_t)i ;
477
478 Int_t iBinITSsignal[nvarITSsignal];
479 iBinITSsignal[0]=nBinsPt;
480 iBinITSsignal[1]=nBinsITSsignal;
481 iBinITSsignal[2]=nBinsITSsignal;
482 iBinITSsignal[3]=nBinsITSsignal;
483 iBinITSsignal[4]=nBinsITSsignal;
484
485 THnSparseF *hsSparseITSpid = new THnSparseF("SparseITSsignal","",nvarITSsignal,iBinITSsignal);
67fe7bd0 486 hsSparseITSpid->SetBinEdges(0,&binLimPt[0]);
487 hsSparseITSpid->SetBinEdges(1,&binLimITSsignal[0]);
488 hsSparseITSpid->SetBinEdges(2,&binLimITSsignal[0]);
489 hsSparseITSpid->SetBinEdges(3,&binLimITSsignal[0]);
490 hsSparseITSpid->SetBinEdges(4,&binLimITSsignal[0]);
70da6c5a 491 hsSparseITSpid->Sumw2();
492
493 fList->AddAt(hsSparseITSpid,kMCcutPart2);
494
495 ///////////////////////////////////////////////////////////////////////////////////////
496 // dEdx of the four layers for the track partner and track to reject splitted track
497 ///////////////////////////////////////////////////////////////////////////////////////
498 const Int_t nvarITSsignalSplit = 5;
499
67fe7bd0 500 const Int_t nBinsITSSplit = 2;
70da6c5a 501 Double_t minITSSplit = 0.0;
502 Double_t maxITSSplit = 2.0;
503
67fe7bd0 504 Double_t binLimITSSplit[nBinsITSSplit+1];
70da6c5a 505 for(Int_t i=0; i<=nBinsITSSplit; i++) binLimITSSplit[i]=(Double_t)minITSSplit + (maxITSSplit-minITSSplit) /nBinsITSSplit*(Double_t)i ;
506
507
67fe7bd0 508 const Int_t nBinsITSsignalSplit = 50;
70da6c5a 509 Double_t minITSsignalSplit = -25.0;
510 Double_t maxITSsignalSplit = 25.0;
511
67fe7bd0 512 Double_t binLimITSsignalSplit[nBinsITSsignalSplit+1];
70da6c5a 513 for(Int_t i=0; i<=nBinsITSsignalSplit; i++) binLimITSsignalSplit[i]=(Double_t)minITSsignalSplit + (maxITSsignalSplit-minITSsignalSplit) /nBinsITSsignalSplit*(Double_t)i ;
514
515 Int_t iBinITSsignalSplit[nvarITSsignalSplit];
516 iBinITSsignalSplit[0]=nBinsITSSplit;
517 for(Int_t k = 1; k < 5; k++){
518 iBinITSsignalSplit[k]=nBinsITSsignalSplit;
519 }
520
521 THnSparseF *hsSparseITSpidSplit = new THnSparseF("SparseITSsignalSplit","",nvarITSsignalSplit,iBinITSsignalSplit);
67fe7bd0 522 hsSparseITSpidSplit->SetBinEdges(0,&binLimITSSplit[0]);
70da6c5a 523 for(Int_t k = 1; k < 5; k++) {
67fe7bd0 524 hsSparseITSpidSplit->SetBinEdges(k,&binLimITSsignalSplit[0]);
70da6c5a 525 }
526 hsSparseITSpidSplit->Sumw2();
527
528 fList->AddAt(hsSparseITSpidSplit,kMCcutPart3);
529
530 }
531
532 }
d2af20c5 533
02524e30 534 }
535
70da6c5a 536 //qaList->Add(fList);
537
02524e30 538}
539//_______________________________________________________________________________________________
540void AliHFEelecbackground::PairAnalysis(AliESDtrack* const track, AliESDtrack* const trackPart)
541{
542 //
543 // calculate (tagged e-partner) dca, opening angle, invariant mass
544 //
02524e30 545
70da6c5a 546 /////////////////////
547 // pt tagged
548 //////////////////////
549 TVector3 v3Dtagged;
67fe7bd0 550 Double_t pxyz[3];
551 track->PxPyPz(&pxyz[0]);
70da6c5a 552 v3Dtagged.SetXYZ(pxyz[0],pxyz[1],pxyz[2]);
553 fPtESD = TMath::Sqrt(pxyz[0]*pxyz[0]+pxyz[1]*pxyz[1]);
554
02524e30 555 ////////////////////////
556 // Take label
557 ////////////////////////
558 Int_t indexTrack = TMath::Abs(track->GetLabel());
559 Int_t indexTrackPart = TMath::Abs(trackPart->GetLabel());
70da6c5a 560
02524e30 561 /////////////////////////
562 // If MC data
563 ////////////////////////
564
565 if(HasMCData()) {
566
567 // Take info track if not already done
568 if(indexTrack!= fIndexTrack) {
70da6c5a 569
570 for(Int_t id = 0; id < 10; id++) {
571 fCuts[id] = kFALSE;
572 }
d2af20c5 573
70da6c5a 574 fIsFrom = kElectronFromBackground;
d2af20c5 575
02524e30 576 fPdg = GetPdg(indexTrack);
577 fLabMother = GetLabMother(indexTrack);
578
579 fMotherGamma = IsMotherGamma(indexTrack);
580 if((fMotherGamma != -1) && ((TMath::Abs(fPdg)) == 11)) fIsFrom = kElectronFromGamma;
581 fMotherPi0 = IsMotherPi0(indexTrack);
582 if((fMotherPi0 != -1) && ((TMath::Abs(fPdg)) == 11)) fIsFrom = kElectronFromPi0;
583 fMotherC = IsMotherC(indexTrack);
584 if((fMotherC != -1) && ((TMath::Abs(fPdg)) == 11)) fIsFrom = kElectronFromC;
585 fMotherB = IsMotherB(indexTrack);
586 if((fMotherB != -1) && ((TMath::Abs(fPdg)) == 11)) fIsFrom = kElectronFromB;
587 fMotherEta = IsMotherEta(indexTrack);
588 if((fMotherEta != -1) && ((TMath::Abs(fPdg)) == 11)) fIsFrom = kElectronFromEta;
589
d2af20c5 590 fIndexTrack = indexTrack;
591
02524e30 592 }
593
d2af20c5 594 // MC PID for tagged
595 if(fgUseMCPID) {
596 if(TMath::Abs(fPdg) != 11) return;
597 }
598
02524e30 599 // Look at trackPart
d2af20c5 600 fIsPartner = kFALSE;
02524e30 601 Int_t pdgPart = GetPdg(indexTrackPart);
602 if(TMath::Abs(pdgPart) == 11) {
603 Int_t labMotherPart = GetLabMother(indexTrackPart);
d2af20c5 604 if((labMotherPart == fLabMother) && (indexTrack != indexTrackPart) && (TMath::Abs(fPdg) == 11) && (fPdg*pdgPart < 0) && (fLabMother >=0) && (fLabMother < (((AliStack *)fMCEvent->Stack())->GetNtrack()))) fIsPartner = kTRUE;
605 // special case of c and b
606 Int_t motherCPart = IsMotherC(indexTrackPart);
607 if((motherCPart != -1) && (fIsFrom == kElectronFromC) && (fPdg*pdgPart < 0)){
608 fIsPartner = kTRUE;
609 }
610 Int_t motherBPart = IsMotherB(indexTrackPart);
611 if((motherBPart != -1) && (fIsFrom == kElectronFromB) && (fPdg*pdgPart < 0)){
612 fIsPartner = kTRUE;
613 }
02524e30 614 }
d2af20c5 615
616 // Look at splitted tracks
617 fIsSplittedTrack = kFALSE;
618 if(indexTrackPart == fIndexTrack) fIsSplittedTrack = kTRUE;
619
02524e30 620 }
70da6c5a 621
02524e30 622 //////////////////////
623 // Sign
624 /////////////////////
625 Int_t sign = -1;
626 if((track->Charge() > 0.0) && (trackPart->Charge() > 0.0)) sign = kPp;
627 if((track->Charge() < 0.0) && (trackPart->Charge() < 0.0)) sign = kNn;
628 if(((track->Charge() > 0.0) && (trackPart->Charge() < 0.0)) || ((track->Charge() < 0.0) && (trackPart->Charge() > 0.0))) sign = kOs;
70da6c5a 629
630 /////////////////////////
631 // Cut effects
632 ////////////////////////
633 Double_t cuteffect[3];
634
635 if(fDebugLevel > 0) {
636 if(HasMCData()) {
637 cuteffect[0] = fPtESD;
638 cuteffect[1] = 0.0;
639 cuteffect[2] = fIsFrom;
69ac0e6f 640 if(!fCuts[0]){
641 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCe)))) fhtmp->Fill(cuteffect);
642 //if(fList->At(kMCe)) (dynamic_cast<THnSparseF *>(fList->At(kMCe)))->Fill(cuteffect);
70da6c5a 643 fCuts[0] = kTRUE;
644 }
645 }
646 }
647
648
649 ///////////////////////////////
650 // Cut effect: Partner track
651 ///////////////////////////////
652
653 if(fDebugLevel > 0) {
654 if(HasMCData() && fIsPartner) {
655 cuteffect[1] = 1.0;
656 if(!fCuts[1]) {
69ac0e6f 657 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCe)))) fhtmp->Fill(cuteffect);
658 //if(fList->At(kMCe)) (dynamic_cast<THnSparseF *>(fList->At(kMCe)))->Fill(cuteffect);
70da6c5a 659 fCuts[1] = kTRUE;
660 }
661 }
662 }
663
664 ///////////////////////////////
665 // Cut effect: Opposite sign
666 ///////////////////////////////
667
668 if(fDebugLevel > 0) {
669 if(HasMCData() && fIsPartner && (sign == kOs)) {
670 cuteffect[1] = 2.0;
671 if(!fCuts[2]) {
69ac0e6f 672 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCe)))) fhtmp->Fill(cuteffect);
673 //if(fList->At(kMCe)) (dynamic_cast<THnSparseF *>(fList->At(kMCe)))->Fill(cuteffect);
70da6c5a 674 fCuts[2] = kTRUE;
675 }
676 }
677 }
678
679 ////////////////////////
680 // Partner track cut
681 ////////////////////////
682 if(!SingleTrackCut(trackPart)) return;
683
684 if(fDebugLevel > 0) {
685 if(HasMCData() && fIsPartner && (sign==kOs)) {
686 cuteffect[1] = 3.0;
687 if(!fCuts[3]) {
69ac0e6f 688 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCe)))) fhtmp->Fill(cuteffect);
689 //if(fList->At(kMCe)) (dynamic_cast<THnSparseF *>(fList->At(kMCe)))->Fill(cuteffect);
70da6c5a 690 fCuts[3] = kTRUE;
691 }
692 }
693 }
694
695 /////////////////////////
696 // shared clusters cut
697 /////////////////////////
698 if(fSharedClusterCut && ShareCluster(track,trackPart)) return;
699
700 if(fDebugLevel > 0) {
701 if(HasMCData() && fIsPartner && (sign==kOs)) {
702 cuteffect[1] = 4.0;
703 if(!fCuts[4]) {
69ac0e6f 704 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCe)))) fhtmp->Fill(cuteffect);
705 //if(fList->At(kMCe)) (dynamic_cast<THnSparseF *>(fList->At(kMCe)))->Fill(cuteffect);
70da6c5a 706 fCuts[4] = kTRUE;
707 }
708 }
709 }
710
711 ////////////////////////
712 // PID Partner track
713 ////////////////////////
714 if(!PIDTrackCut(trackPart)) return;
715
716 if(fDebugLevel > 0) {
717 if(HasMCData() && fIsPartner && (sign==kOs)) {
718 cuteffect[1] = 5.0;
719 if(!fCuts[5]) {
69ac0e6f 720 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCe)))) fhtmp->Fill(cuteffect);
721 //if(fList->At(kMCe)) (dynamic_cast<THnSparseF *>(fList->At(kMCe)))->Fill(cuteffect);
70da6c5a 722 fCuts[5] = kTRUE;
723 }
724 }
725 }
726
727
02524e30 728 //////////////////////
729 // DCA
730 /////////////////////
731
732 Double_t xthis,xp;
733 Double_t dca = track->GetDCA(trackPart,fBz,xthis,xp);
69ac0e6f 734 if((fhtmpp = dynamic_cast<TH1F *>(fList->At(kDatadca)))) fhtmpp->Fill(dca);
70da6c5a 735 if(HasMCData()) {
736 //printf("has MC data for DCA\n");
737 //printf("IsPartner %d and isfrom %d\n",fIsPartner,fIsFrom);
69ac0e6f 738 if(fIsFrom==kElectronFromBackground) {
739 if((fhtmpf = dynamic_cast<TH2F *>(fList->At(kMCdca)))) fhtmpf->Fill(dca,fIsFrom);
740 }
70da6c5a 741 else {
69ac0e6f 742 if(fIsPartner){
743 if((fhtmpf = dynamic_cast<TH2F *>(fList->At(kMCdca)))) fhtmpf->Fill(dca,fIsFrom);
744 }
70da6c5a 745 }
746 }
69ac0e6f 747
02524e30 748 if(TMath::Abs(dca) > 3.0) return;
69ac0e6f 749
70da6c5a 750 if(fDebugLevel > 0) {
751 if(HasMCData() && fIsPartner && (sign==kOs)) {
752 cuteffect[1] = 6.0;
753 if(!fCuts[6]) {
69ac0e6f 754 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCe)))) fhtmp->Fill(cuteffect);
755 //if(fList->At(kMCe)) (dynamic_cast<THnSparseF *>(fList->At(kMCe)))->Fill(cuteffect);
70da6c5a 756 fCuts[6] = kTRUE;
757 }
758 }
759 }
760
02524e30 761 ///////////////////////////////////
762 // Calcul mother variables
763 ///////////////////////////////////
764 Double_t results[5];
765 Double_t resultsr[5];
70da6c5a 766
767
768 if(!fUseAliKFCode) {
769
770 /////////////////////////////
771 // Propagate
772 ////////////////////////////
773
774 Double_t norradius = TMath::Sqrt(fkVertex->GetX()*fkVertex->GetX()+fkVertex->GetY()*fkVertex->GetY());
775
776 AliESDtrack *trackCopy = new AliESDtrack(*track);
777 AliESDtrack *trackPartCopy = new AliESDtrack(*trackPart);
778 Bool_t propagateok = kTRUE;
779 if((!(trackPartCopy->PropagateTo(norradius,fBz))) || (!(trackCopy->PropagateTo(norradius,fBz)))) propagateok = kFALSE;
780 if(!propagateok) {
781 if(trackCopy) delete trackCopy;
782 if(trackPartCopy) delete trackPartCopy;
783 return;
784 }
785
786 CalculateMotherVariable(trackCopy,trackPartCopy,&results[0]);
787 CalculateMotherVariableR(trackCopy,trackPartCopy,&resultsr[0]);
788
789 if(trackCopy) delete trackCopy;
790 if(trackPartCopy) delete trackPartCopy;
791
792 }
793 else {
794
795 if(!CalculateMotherVariable(track,trackPart,&results[0])) return;
796 if(fDebugLevel > 0) {
797 if(HasMCData() && fIsPartner && (sign==kOs)) {
798 cuteffect[1] = 7.0;
799 if(!fCuts[7]) {
69ac0e6f 800 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCe)))) fhtmp->Fill(cuteffect);
801 //if(fList->At(kMCe)) (dynamic_cast<THnSparseF *>(fList->At(kMCe)))->Fill(cuteffect);
70da6c5a 802 fCuts[7] = kTRUE;
803 }
804 }
805 }
02524e30 806
70da6c5a 807 }
02524e30 808
809 /////////////////////////////////////
810 // Fill
811 /////////////////////////////////////
812
813 FillOutput(results, resultsr, sign);
70da6c5a 814
815 if(fDebugLevel > 0) {
816 if(HasMCData() && fIsPartner && (sign==kOs)) {
817
818 if(TMath::Abs(results[4]) < fOpeningAngleCut) {
819
820 cuteffect[1] = 8.0;
821 if(!fCuts[8]) {
69ac0e6f 822 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCe)))) fhtmp->Fill(cuteffect);
823 //if(fList->At(kMCe)) (dynamic_cast<THnSparseF *>(fList->At(kMCe)))->Fill(cuteffect);
70da6c5a 824 fCuts[8] = kTRUE;
825 }
826 if(TMath::Abs(results[1]) < fInvMassCut) {
827 cuteffect[1] = 9.0;
828 if(!fCuts[9]) {
69ac0e6f 829 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCe)))) fhtmp->Fill(cuteffect);
830 //if(fList->At(kMCe)) (dynamic_cast<THnSparseF *>(fList->At(kMCe)))->Fill(cuteffect);
70da6c5a 831 fCuts[9] = kTRUE;
832 }
833 }
834 }
835 }
836 }
02524e30 837
70da6c5a 838
02524e30 839}
840//_____________________________________________________________________________________
70da6c5a 841Bool_t AliHFEelecbackground::CalculateMotherVariable(AliESDtrack* const track, AliESDtrack* const trackpart, Double_t *results)
02524e30 842{
843 //
844 // variables mother and take the pt of the track
845 //
846 // results contain: ptmother, invmass, etamother, phimother, openingangle
847 //
70da6c5a 848 // with a chi2Ndf cut for AliKF code
849 //
02524e30 850
70da6c5a 851 if(!fUseAliKFCode) {
852
853 TVector3 v3Dtagged;
854 TVector3 v3Dpart;
855
67fe7bd0 856 Double_t pxyz[3];
857 track->PxPyPz(&pxyz[0]);
70da6c5a 858 v3Dtagged.SetXYZ(pxyz[0],pxyz[1],pxyz[2]);
859
67fe7bd0 860 Double_t pxyzpart[3];
861 trackpart->PxPyPz(&pxyzpart[0]);
70da6c5a 862 v3Dpart.SetXYZ(pxyzpart[0],pxyzpart[1],pxyzpart[2]);
863
864
865 TVector3 motherrec = v3Dtagged + v3Dpart;
866
867 Double_t etaESDmother = motherrec.Eta();
868 Double_t ptESDmother = motherrec.Pt();
869 Double_t phiESDmother = motherrec.Phi();
870 if(phiESDmother > TMath::Pi()) phiESDmother = phiESDmother - (2*TMath::Pi());
871
872
873 // openinganglepropagated
874 Double_t openingangle = v3Dtagged.Angle(v3Dpart);
875
876 // invmass
877 Double_t pESD = TMath::Sqrt(pxyz[0]*pxyz[0]+pxyz[1]*pxyz[1]+pxyz[2]*pxyz[2]);
878 Double_t pESDpart = TMath::Sqrt(pxyzpart[0]*pxyzpart[0]+pxyzpart[1]*pxyzpart[1]+pxyzpart[2]*pxyzpart[2]);
879
880 // e propagate
881 Double_t eESD = TMath::Sqrt(pESD*pESD+fgkMe*fgkMe);
882 Double_t eESDpart = TMath::Sqrt(pESDpart*pESDpart+fgkMe*fgkMe);
883
884 Double_t invmass = TMath::Sqrt((eESD+eESDpart)*(eESD+eESDpart)-(motherrec.Px()*motherrec.Px()+motherrec.Py()*motherrec.Py()+motherrec.Pz()*motherrec.Pz()));
885
886 if(!results) return kFALSE;
02524e30 887
70da6c5a 888 results[0] = ptESDmother;
889 results[1] = etaESDmother;
890 results[2] = phiESDmother;
891 results[3] = invmass;
892 results[4] = openingangle;
893
894 return kTRUE;
02524e30 895
02524e30 896 }
70da6c5a 897 else {
898
899 AliKFParticle pair;
900 pair.Initialize();
901
902 // pid
903 Int_t pid1 = -11;
904 if(track->Charge() > 0.0) pid1 = 11;
905 Int_t pid2 = -11;
906 if(trackpart->Charge() > 0.0) pid2 = 11;
907
908
909 // daughters
910 AliKFParticle kf(*track,pid1);
911 AliKFParticle kfpart(*trackpart,pid2);
912
913 pair.AddDaughter(kf);
914 pair.AddDaughter(kfpart);
915
916 // variables
917 Double_t openingangle = kf.GetAngle(kfpart);
918 Double_t chi2ndf = pair.GetChi2()/pair.GetNDF();
919 //Double_t decayLength = pair.GetDecayLength();
920 Double_t radius = pair.GetR();
921 //Double_t masserror = pair.GetErrMass()>0?pair.GetErrMass()/pair.GetMass():1000000;
922 Double_t ptpair = pair.GetPt();
923 Double_t etapair = pair.GetEta();
924 Double_t phipair = pair.GetPhi();
925 Double_t masspair = pair.GetMass();
926
927 // Put them
928 if(!results) return kFALSE;
929
930 results[0] = ptpair;
931 results[1] = etapair;
932 results[2] = phipair;
933 results[3] = masspair;
934 results[4] = openingangle;
935
936 // chi2Ndf cut
69ac0e6f 937 if((fhtmpp = dynamic_cast<TH1F *>(fList->At(kDatachi2Ndf)))) fhtmpp->Fill(chi2ndf);
938 //if(fList->At(kDatachi2Ndf)) (dynamic_cast<TH1F *>(fList->At(kDatachi2Ndf)))->Fill(chi2ndf);
70da6c5a 939 if(HasMCData()){
69ac0e6f 940 if(fIsFrom==kElectronFromBackground) {
941 if((fhtmpf = dynamic_cast<TH2F *>(fList->At(kMCchi2Ndf)))) fhtmpf->Fill(chi2ndf,fIsFrom);
942 }
70da6c5a 943 else {
69ac0e6f 944 if(fIsPartner){
945 if((fhtmpf = dynamic_cast<TH2F *>(fList->At(kMCchi2Ndf)))) fhtmpf->Fill(chi2ndf,fIsFrom);
946 }
70da6c5a 947 }
948 }
949 if(chi2ndf > fChi2NdfCut) return kFALSE;
950 else {
69ac0e6f 951 if((fhtmpp = dynamic_cast<TH1F *>(fList->At(kDatar)))) fhtmpp->Fill(radius);
952 //if(fList->At(kDatar)) (dynamic_cast<TH1F *>(fList->At(kDatar)))->Fill(radius);
70da6c5a 953 if(HasMCData()) {
69ac0e6f 954 if(fIsFrom==kElectronFromBackground) {
955 if((fhtmpf = dynamic_cast<TH2F *>(fList->At(kMCr)))) fhtmpf->Fill(radius,fIsFrom);
956 //if(fList->At(kMCr))) (dynamic_cast<TH2F *>(fList->At(kMCr)))->Fill(radius,fIsFrom);
957 }
70da6c5a 958 else {
69ac0e6f 959 if(fIsPartner) {
960 if((fhtmpf = dynamic_cast<TH2F *>(fList->At(kMCr)))) fhtmpf->Fill(radius,fIsFrom);
961 }
70da6c5a 962 }
963 }
964 return kTRUE;
965 }
966
967 }
02524e30 968
969}
970//_____________________________________________________________________________________
971void AliHFEelecbackground::CalculateMotherVariableR(AliESDtrack* const track, AliESDtrack* const trackpart, Double_t *results)
972{
973 //
974 // variables mother
975 //
976 // results contain: ptmother, invmass, etamother, phimother, openingangle
70da6c5a 977 // Implemented only for no AliKF
02524e30 978 //
02524e30 979
70da6c5a 980 if(!fUseAliKFCode) {
981
982 TVector3 v3Dtagged;
983 TVector3 v3Dpart;
984
67fe7bd0 985 Double_t pxyz[3];
986 track->PxPyPz(&pxyz[0]);
70da6c5a 987 v3Dtagged.SetXYZ(pxyz[0],pxyz[1],pxyz[2]);
67fe7bd0 988 Double_t pxyzpart[3];
989 trackpart->PxPyPz(&pxyzpart[0]);
70da6c5a 990 v3Dpart.SetXYZ(pxyzpart[0],pxyzpart[1],pxyzpart[2]);
991
992 // rotate the partner
993 v3Dpart.RotateZ(TMath::Pi());
994 v3Dpart.GetXYZ(pxyzpart);
995
996
997 TVector3 motherrec = v3Dtagged + v3Dpart;
998
999 Double_t etaESDmother = motherrec.Eta();
1000 Double_t ptESDmother = motherrec.Pt();
1001 Double_t phiESDmother = motherrec.Phi();
1002 if(phiESDmother > TMath::Pi()) phiESDmother = phiESDmother - (2*TMath::Pi());
1003
1004
1005 // openinganglepropagated
1006 Double_t openingangle = v3Dtagged.Angle(v3Dpart);
1007 //printf("Openingangle %f\n",openingangle);
1008
1009 // invmass
1010 Double_t pESD = TMath::Sqrt(pxyz[0]*pxyz[0]+pxyz[1]*pxyz[1]+pxyz[2]*pxyz[2]);
1011 Double_t pESDpart = TMath::Sqrt(pxyzpart[0]*pxyzpart[0]+pxyzpart[1]*pxyzpart[1]+pxyzpart[2]*pxyzpart[2]);
1012 // e propagate
1013 Double_t eESD = TMath::Sqrt(pESD*pESD+fgkMe*fgkMe);
1014 Double_t eESDpart = TMath::Sqrt(pESDpart*pESDpart+fgkMe*fgkMe);
1015
1016 Double_t invmass = TMath::Sqrt((eESD+eESDpart)*(eESD+eESDpart)-(motherrec.Px()*motherrec.Px()+motherrec.Py()*motherrec.Py()+motherrec.Pz()*motherrec.Pz()));
1017
1018 if(!results) return;
1019
1020 results[0] = ptESDmother;
1021 results[1] = etaESDmother;
1022 results[2] = phiESDmother;
1023 results[3] = invmass;
1024 results[4] = openingangle;
1025
02524e30 1026 }
02524e30 1027
1028}
1029//_________________________________________________________________________________
1030void AliHFEelecbackground::FillOutput(Double_t *results, Double_t *resultsr, Int_t sign)
1031{
1032 //
70da6c5a 1033 // Fill the Data and MC THnSparseF
02524e30 1034 //
70da6c5a 1035
1036 if((!results) || (!resultsr)) return;
02524e30 1037
70da6c5a 1038 Double_t co[6];
02524e30 1039 co[0] = fPtESD;
70da6c5a 1040 co[1] = results[0];
1041 co[2] = TMath::Abs(results[4]);
1042 co[3] = results[3];
1043 co[4] = sign;
1044 co[5] = 0.0;
02524e30 1045
69ac0e6f 1046 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kDatai)))) fhtmp->Fill(co);
1047 //if(fList->At(kDatai))(dynamic_cast<THnSparseF *>(fList->At(kDatai)))->Fill(co);
02524e30 1048
70da6c5a 1049 if((sign==kOs) && (!fUseAliKFCode)) {
1050
1051 co[1] = resultsr[0];
1052 co[2] = TMath::Abs(resultsr[4]);
1053 co[3] = resultsr[3];
1054 co[4] = kR;
1055 co[5] = 0.0;
02524e30 1056
69ac0e6f 1057 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kDatai)))) fhtmp->Fill(co);
1058 //if(fList->At(kDatai)) (dynamic_cast<THnSparseF *>(fList->At(kDatai)))->Fill(co);
70da6c5a 1059
1060 }
1061
1062 if(HasMCData()){
02524e30 1063
70da6c5a 1064 // Reset
1065 co[1] = results[0];
1066 co[2] = TMath::Abs(results[4]);
1067 co[3] = results[3];
02524e30 1068
70da6c5a 1069 // Origin
1070 co[4] = kElectronFromBackground;
1071 if((sign==kOs) && fIsPartner) co[4] = fIsFrom;
02524e30 1072
70da6c5a 1073 // Splitted tracks
1074 co[5] = kNotSplitted;
1075 if(fIsSplittedTrack) {
1076 if(sign==kOs){
1077 co[5] = kSplittedOs;
1078 }
1079 else {
1080 co[5] = kSplittedSs;
1081 }
1082 }
1083
69ac0e6f 1084 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCo)))) fhtmp->Fill(co);
1085 //if(fList->At(kMCo)) (dynamic_cast<THnSparseF *>(fList->At(kMCo)))->Fill(co);
70da6c5a 1086
02524e30 1087 }
70da6c5a 1088
1089}
02524e30 1090//_______________________________________________________________________________________________
70da6c5a 1091Bool_t AliHFEelecbackground::SingleTrackCut(AliESDtrack* const trackPart) const
02524e30 1092{
1093 //
1094 // Return minimum quality for the partner
1095 //
1096
70da6c5a 1097 if(trackPart->GetKinkIndex(0)>0) return kFALSE;
d2af20c5 1098
70da6c5a 1099
1100 UInt_t status = trackPart->GetStatus();
1101
1102 if(fRequireITSStandalone > 0) {
1103
1104 /////////////////////
1105 // ITS Standalone
1106 ////////////////////
1107
1108 if(fRequireITSStandalone==1) {
faee3b18 1109 if(((status & AliESDtrack::kITSin) == 0 || (trackPart->IsPureITSStandalone()) || ((status&AliESDtrack::kITSrefit)==0))) return kFALSE;
70da6c5a 1110 }
1111
1112 if(fRequireITSStandalone==2) {
1113 if(!trackPart->IsPureITSStandalone() || ((status&AliESDtrack::kITSrefit)==0)) return kFALSE;
1114 }
1115
1116 // Chi2
1117 Double_t chi2 = trackPart->GetITSchi2();
1118 if(chi2 > fMinITSChi2) return kFALSE;
1119
1120 // Min Nb of clusters
1121 Int_t nbcl = trackPart->GetITSclusters(0);
1122 if(nbcl < fMinNbCls) return kFALSE;
1123
1124 // Min Nb of points in SDD and SPD
1125 Int_t nbSDDSPD = 0;
1126 for(Int_t layer = 0; layer < 4; layer++){
1127 if(trackPart->HasPointOnITSLayer(layer)) nbSDDSPD++;
1128 }
1129 if(nbSDDSPD < fMinNbClsSDDSPD) return kFALSE;
1130
02524e30 1131
02524e30 1132 }
70da6c5a 1133 else {
1134
1135 /////////
1136 // TPC
1137 /////////
1138
1139 if((status&AliESDtrack::kTPCrefit)==0) return kFALSE;
1140
1141 // Min Nb of clusters
1142 Int_t nbcl = trackPart->GetTPCclusters(0);
1143 if(nbcl < fMinNbCls) return kFALSE;
1144
1145 }
1146
1147 return kTRUE;
1148
1149}
1150//_______________________________________________________________________________________________
1151Bool_t AliHFEelecbackground::PIDTrackCut(AliESDtrack* const trackPart)
1152{
1153 //
1154 // PID for the partner using TPC or ITS
1155 //
02524e30 1156
70da6c5a 1157 if(fRequireITSStandalone > 0) {
1158
1159 /////////////////////
1160 // ITS Standalone
1161 ////////////////////
1162
1163 // signal
1164 Double_t itsSignal = trackPart->GetITSsignal();
1165 Double_t p = trackPart->P();
1166
69ac0e6f 1167 if(fDebugLevel > 1) {
1168 if((fhtmpf = dynamic_cast<TH2F *>(fList->At(kMCcutPart0)))) fhtmpf->Fill(p,itsSignal);
1169 //if(fList->At(kMCcutPart0)) (dynamic_cast<TH2F *>(fList->At(kMCcutPart0)))->Fill(p,itsSignal);
70da6c5a 1170 }
1171
1172 ///////////
1173 // PID
1174 //////////
1175 if(fPIDPartner) {
1176
1177 // Take signal trackPart
1178 Double_t dEdxSamplesPart[4];
1179 trackPart->GetITSdEdxSamples(dEdxSamplesPart);
1180
1181 // Cut at 2 sigma
1182 if(!fPIDMethodPartnerITS) fPIDMethodPartnerITS = new AliESDpid;
1183 Float_t nsigma = fPIDMethodPartnerITS->NumberOfSigmasITS(trackPart, AliPID::kElectron);
1184 if(TMath::Abs(nsigma) > 2.0) return kFALSE;
1185
1186 // fill signal
1187 if(fDebugLevel > 1) {
1188
1189 Double_t entries[5];
1190 entries[0] = p;
1191 entries[1] = dEdxSamplesPart[0];
1192 entries[2] = dEdxSamplesPart[1];
1193 entries[3] = dEdxSamplesPart[2];
1194 entries[4] = dEdxSamplesPart[3];
1195
69ac0e6f 1196 //if(fList->At(kMCcutPart1)) (dynamic_cast<TH2F *>(fList->At(kMCcutPart1)))->Fill(p,itsSignal);
1197 if((fhtmpf = dynamic_cast<TH2F *>(fList->At(kMCcutPart1)))) fhtmpf->Fill(p,itsSignal);
1198 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCcutPart2)))) fhtmp->Fill(entries);
1199 //if(fList->At(kMCcutPart2)) (dynamic_cast<THnSparseF *>(fList->At(kMCcutPart2)))->Fill(entries);
70da6c5a 1200
1201 }
1202
1203 }
1204
1205 }
1206 else {
1207
1208 /////////
1209 // TPC
1210 /////////
1211
1212 Double_t tpcSignal = trackPart->GetTPCsignal();
1213 Double_t p = trackPart->GetInnerParam() ? trackPart->GetInnerParam()->P() : trackPart->P();
1214
1215 if(fDebugLevel > 1) {
1216 //printf("tpcSignal %f\n",tpcSignal);
69ac0e6f 1217 //if(fList->At(kMCcutPart0)) (dynamic_cast<TH2F *>(fList->At(kMCcutPart0)))->Fill(p,tpcSignal);
1218 if((fhtmpf = dynamic_cast<TH2F *>(fList->At(kMCcutPart0)))) fhtmpf->Fill(p,tpcSignal);
70da6c5a 1219 }
1220
1221 // PID
1222 if(fPIDPartner) {
1223 if(!fPIDMethodPartner) return kFALSE;
1224 AliHFEpidObject hfetrack;
1225 hfetrack.fAnalysisType = AliHFEpidObject::kESDanalysis;
1226 hfetrack.fRecTrack = trackPart;
1227 //if(HasMCData()) hfetrack.fMCtrack = mctrack;
1228 if(!fPIDMethodPartner->IsSelected(&hfetrack)) return kFALSE;
1229
1230 if(fDebugLevel > 1) {
69ac0e6f 1231 if((fhtmpf = dynamic_cast<TH2F *>(fList->At(kMCcutPart1)))) fhtmpf->Fill(p,tpcSignal);
1232 //if(fList->At(kMCcutPart1)) (dynamic_cast<TH2F *>(fList->At(kMCcutPart1)))->Fill(p,tpcSignal);
70da6c5a 1233 }
1234 }
1235
1236 }
1237
1238 return kTRUE;
1239
1240}
1241//__________________________________________________________________________________________
69ac0e6f 1242Bool_t AliHFEelecbackground::ShareCluster(AliESDtrack * const track1,AliESDtrack * const track2)
70da6c5a 1243{
1244 //
1245 // Look if the two tracks shared clusters in the TPC or in the ITS depending on the method
1246 //
1247 // For TPC:
1248 // hsfval: number of shared clusters
1249 // hsmval: quality of the tracks
1250 //
1251 // For ITS:
1252 // compare the dEdx in the ITS
1253 //
1254
1255 if(!fRequireITSStandalone) {
1256
1257 //////////
1258 // TPC
1259 //////////
1260
1261
1262 Int_t nh = 0;
1263 Int_t an = 0;
1264 Int_t ns = 0;
1265 Float_t hsmval = 0.0;
1266 Float_t hsfval = 0.0;
1267
1268 for(unsigned int imap=0;imap<track1->GetTPCClusterMap().GetNbits(); imap++) {
1269 if(track1->GetTPCClusterMap().TestBitNumber(imap) &&
1270 track2->GetTPCClusterMap().TestBitNumber(imap)) {
1271 // Do they share it ?
1272 if (track1->GetTPCSharedMap().TestBitNumber(imap) &&
1273 track2->GetTPCSharedMap().TestBitNumber(imap))
1274 {
1275 an++;
1276 nh+=2;
1277 ns+=2;
1278 }
1279 else {
1280 an--;
1281 nh+=2;
1282 }
1283 }
1284 else if (track1->GetTPCClusterMap().TestBitNumber(imap) ||
1285 track2->GetTPCClusterMap().TestBitNumber(imap)) {
1286 an++;
1287 nh++;
1288 }
1289 }
1290
1291 if (nh >0) {
1292 hsmval = an*1.0/nh;
1293 hsfval = ns*1.0/nh;
1294 }
1295
1296
1297 if((hsfval > 0.15) || (hsmval > -0.15)) return kTRUE; //they share cluster
1298 else return kFALSE;
1299
02524e30 1300
1301 }
70da6c5a 1302 else {
1303
1304
1305 //////////
1306 // ITS
1307 /////////
1308
1309 // Take signals
1310 Double_t dEdxSamples1[4];
1311 track1->GetITSdEdxSamples(dEdxSamples1);
1312 Double_t dEdxSamples2[4];
1313 track2->GetITSdEdxSamples(dEdxSamples2);
1314
1315 // If there are matching
1316 Int_t nbClusters = 0;
1317 Bool_t match[4] = {kTRUE,kTRUE,kTRUE,kTRUE};
1318 Double_t limit[4] = {1.5,1.5,1.5,1.5};
1319 for(Int_t layer = 0; layer < 4; layer++) {
1320 if(track1->HasPointOnITSLayer(layer+2) && track2->HasPointOnITSLayer(layer+2)) {
1321 if(TMath::Abs(dEdxSamples1[layer]-dEdxSamples2[layer])>limit[layer]) match[layer] = kFALSE;
1322 nbClusters++;
1323 }
1324 }
1325 //printf("nbClusters %d\n",nbClusters);
1326
1327 // fill signal
1328 if(fDebugLevel > 1) {
1329 Double_t entriesSplit[5];
1330 entriesSplit[0] = 0.0;
1331 if(fIsSplittedTrack) entriesSplit[0] = 1.0;
1332
1333 for(Int_t layer = 0; layer < 4; layer++) {
1334 if(track1->HasPointOnITSLayer(layer+2) && track2->HasPointOnITSLayer(layer+2)) {
1335 entriesSplit[layer+1] = dEdxSamples1[layer]-dEdxSamples2[layer];
1336 }
1337 else entriesSplit[layer+1] = -100.0;
1338 }
69ac0e6f 1339 if((fhtmp = dynamic_cast<THnSparseF *>(fList->At(kMCcutPart3)))) fhtmp->Fill(entriesSplit);
1340 //if(fList->At(kMCcutPart3)) (dynamic_cast<THnSparseF *>(fList->At(kMCcutPart3)))->Fill(entriesSplit);
70da6c5a 1341 }
1342
1343 // Return
1344 Int_t nbClustersNotClose = 0;
1345 for(Int_t layer = 0; layer < 4; layer++) {
1346 if(!match[layer]) nbClustersNotClose++;
1347 }
1348 if((nbClusters > 1) && (nbClustersNotClose > 0.75*nbClusters)) return kFALSE;
1349 else return kTRUE;
1350
1351 }
02524e30 1352
70da6c5a 1353}
1354//____________________________________________________________________________________________________________
1355void AliHFEelecbackground::SetPIDPartner() {
1356
1357 //
1358 // Init the stuff for PID on the partner track
1359 //
1360
1361 fPIDPartner = kTRUE;
1362
1363 if(fRequireITSStandalone == 0) {
1364
1365 if(!fPIDMethodPartner) {
1366 fPIDMethodPartner = new AliHFEpid();
1367 fPIDMethodPartner->InitializePID("Strategy1"); // 3 sigma cut in TPC
1368 }
1369
1370 }
1371 else {
1372
1373 if(!fPIDMethodPartnerITS) fPIDMethodPartnerITS = new AliESDpid;
1374
1375 }
02524e30 1376
1377}
1378//______________________________________________________________________________________________
1379void AliHFEelecbackground::SetEvent(AliESDEvent* const ESD)
1380{
1381 //
1382 // Set the AliESD Event, the magnetic field and the primary vertex
1383 //
1384
1385 fESD1=ESD;
1386 fBz=fESD1->GetMagneticField();
1387 fkVertex = fESD1->GetPrimaryVertex();
1388
1389}
1390//____________________________________________________________________________________________________________
1391Int_t AliHFEelecbackground::IsMotherGamma(Int_t tr) {
1392
1393 //
1394 // Return the lab of gamma mother or -1 if not gamma
1395 //
1396
1397 AliStack* stack = fMCEvent->Stack();
1398 if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
1399
1400 // Take mother
1401 TParticle * particle = stack->Particle(tr);
1402 if(!particle) return -1;
1403 Int_t imother = particle->GetFirstMother();
1404 if((imother < 0) || (imother >= stack->GetNtrack())) return -1;
1405 TParticle * mother = stack->Particle(imother);
1406 if(!mother) return -1;
1407
1408 // Check gamma
1409 Int_t pdg = mother->GetPdgCode();
1410 if(TMath::Abs(pdg) == 22) return imother;
1411 if(TMath::Abs(pdg) == 11) {
1412 return IsMotherGamma(imother);
1413 }
1414 return -1;
1415
1416}
1417//
1418//____________________________________________________________________________________________________________
1419Int_t AliHFEelecbackground::IsMotherPi0(Int_t tr) {
1420
1421 //
1422 // Return the lab of pi0 mother or -1 if not pi0
1423 //
1424
1425 AliStack* stack = fMCEvent->Stack();
1426 if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
1427
1428 // Take mother
1429 TParticle * particle = stack->Particle(tr);
1430 if(!particle) return -1;
1431 Int_t imother = particle->GetFirstMother();
1432 if((imother < 0) || (imother >= stack->GetNtrack())) return -1;
1433 TParticle * mother = stack->Particle(imother);
1434 if(!mother) return -1;
1435
1436 // Check gamma
1437 Int_t pdg = mother->GetPdgCode();
1438 if(TMath::Abs(pdg) == 111) return imother;
1439 if(TMath::Abs(pdg) == 11) {
1440 return IsMotherPi0(imother);
1441 }
1442 return -1;
1443
1444}
1445//____________________________________________________________________________________________________________
1446Int_t AliHFEelecbackground::IsMotherEta(Int_t tr) {
1447
1448 //
1449 // Return the lab of pi0 mother or -1 if not pi0
1450 //
1451
1452 AliStack* stack = fMCEvent->Stack();
1453 if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
1454
1455 // Take mother
1456 TParticle * particle = stack->Particle(tr);
1457 if(!particle) return -1;
1458 Int_t imother = particle->GetFirstMother();
1459 if((imother < 0) || (imother >= stack->GetNtrack())) return -1;
1460 TParticle * mother = stack->Particle(imother);
1461 if(!mother) return -1;
1462
1463 // Check gamma
1464 Int_t pdg = mother->GetPdgCode();
1465 if(TMath::Abs(pdg) == 221) return imother;
1466 if(TMath::Abs(pdg) == 11) {
1467 return IsMotherEta(imother);
1468 }
1469 return -1;
1470
1471}
1472//____________________________________________________________________________________________________________
1473Int_t AliHFEelecbackground::IsMotherC(Int_t tr) {
1474
1475 //
1476 // Return the lab of signal mother or -1 if not signal
1477 //
1478
1479 AliStack* stack = fMCEvent->Stack();
1480 if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
1481
1482 // Take mother
1483 TParticle * particle = stack->Particle(tr);
1484 if(!particle) return -1;
1485 Int_t imother = particle->GetFirstMother();
1486 if((imother < 0) || (imother >= stack->GetNtrack())) return -1;
1487 TParticle * mother = stack->Particle(imother);
1488 if(!mother) return -1;
1489
1490 // Check gamma
1491 Int_t pdg = mother->GetPdgCode();
1492 if((TMath::Abs(pdg)==411) || (TMath::Abs(pdg)==421) || (TMath::Abs(pdg)==431) || (TMath::Abs(pdg)==4122) || (TMath::Abs(pdg)==4132) || (TMath::Abs(pdg)==4232) || (TMath::Abs(pdg)==43320)) return imother;
1493 if(TMath::Abs(pdg) == 11) {
1494 return IsMotherC(imother);
1495 }
1496 return -1;
1497
1498}
1499//____________________________________________________________________________________________________________
1500Int_t AliHFEelecbackground::IsMotherB(Int_t tr) {
1501
1502 //
1503 // Return the lab of signal mother or -1 if not signal
1504 //
1505
1506 AliStack* stack = fMCEvent->Stack();
1507 if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
1508
1509 // Take mother
1510 TParticle * particle = stack->Particle(tr);
1511 if(!particle) return -1;
1512 Int_t imother = particle->GetFirstMother();
1513 if((imother < 0) || (imother >= stack->GetNtrack())) return -1;
1514 TParticle * mother = stack->Particle(imother);
1515 if(!mother) return -1;
1516
1517 // Check gamma
1518 Int_t pdg = mother->GetPdgCode();
1519 if((TMath::Abs(pdg)==511) || (TMath::Abs(pdg)==521) || (TMath::Abs(pdg)==531) || (TMath::Abs(pdg)==5122) || (TMath::Abs(pdg)==5132) || (TMath::Abs(pdg)==5232) || (TMath::Abs(pdg)==53320)) return imother;
1520 if(TMath::Abs(pdg) == 11) {
1521 return IsMotherB(imother);
1522 }
1523 return -1;
1524
1525}
1526//____________________________________________________________________________________________________________
1527Int_t AliHFEelecbackground::GetPdg(Int_t tr) {
1528
1529 //
1530 // Simply pdg code
1531 //
1532
1533 AliStack* stack = fMCEvent->Stack();
1534 if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
1535
1536 // MC Information
1537 TParticle * particle = stack->Particle(tr);
1538 if(!particle) return -1;
1539 Int_t pdg = particle->GetPdgCode();
1540
1541 return pdg;
1542
1543}
1544//____________________________________________________________________________________________________________
1545Int_t AliHFEelecbackground::GetLabMother(Int_t tr) {
1546
1547 //
1548 // Simply lab mother
1549 //
1550
1551 AliStack* stack = fMCEvent->Stack();
1552 if((tr < 0) || (tr >= stack->GetNtrack())) return -1;
1553
1554 // MC Information
1555 TParticle * particle = stack->Particle(tr);
1556 if(!particle) return -1;
1557 Int_t imother = particle->GetFirstMother();
1558
1559 return imother;
1560
1561}
1562//_______________________________________________________________________________________________
1563void AliHFEelecbackground::PostProcess()
1564{
1565 //
1566 // Post process the histos and extract the background pt spectra
1567 //
1568
1569 if(!fList) return;
1570
70da6c5a 1571 gStyle->SetPalette(1);
1572 gStyle->SetOptStat(1111);
1573 gStyle->SetPadBorderMode(0);
1574 gStyle->SetCanvasColor(10);
1575 gStyle->SetPadLeftMargin(0.13);
1576 gStyle->SetPadRightMargin(0.13);
1577
1578 /////////////////////////
1579 // Take the THnSparseF
1580 /////////////////////////
1581 THnSparseF *hsSparseData = dynamic_cast<THnSparseF *>(fList->FindObject("OpeningangleinvmassData"));
1582 THnSparseF *hsSparseMC = dynamic_cast<THnSparseF *>(fList->FindObject("OpeningangleinvmassMC"));
1583 THnSparseF *hsSparseCutPassedMC = dynamic_cast<THnSparseF *>(fList->FindObject("CutPassedMC"));
1584
1585 /////////////////////////////////
1586 // Cuts on the opening angle
1587 ////////////////////////////////
69ac0e6f 1588 if(!hsSparseData) return;
70da6c5a 1589 TAxis *axisOpeningAngleData = hsSparseData->GetAxis(2);
1590 Int_t binCutData = axisOpeningAngleData->FindBin(fOpeningAngleCut);
1591 hsSparseData->GetAxis(2)->SetRange(1,binCutData);
1592
1593 if(hsSparseMC) {
1594 TAxis *axisOpeningAngleMC = hsSparseMC->GetAxis(2);
1595 Int_t binCutMC = axisOpeningAngleMC->FindBin(fOpeningAngleCut);
1596 hsSparseMC->GetAxis(2)->SetRange(1,binCutMC);
1597 }
1598
1599 /////////////////////////
1600 // Prepare the histos
1601 ////////////////////////
1602
1603 TAxis *ptaxisinvmass = hsSparseData->GetAxis(3);
02524e30 1604 Int_t nbinsptinvmass = ptaxisinvmass->GetNbins();
1605
02524e30 1606 TH1D **invmassosptproj = new TH1D*[nbinsptinvmass];
1607 TH1D **invmassssptproj = new TH1D*[nbinsptinvmass];
1608 TH1D **invmassrptproj = new TH1D*[nbinsptinvmass];
1609 TH1D **invmassdiffptproj = new TH1D*[nbinsptinvmass];
1610 TH1D **invmassgammaptproj = new TH1D*[nbinsptinvmass];
1611 TH1D **invmasspi0ptproj = new TH1D*[nbinsptinvmass];
1612 TH1D **invmassetaptproj = new TH1D*[nbinsptinvmass];
1613 TH1D **invmassCptproj = new TH1D*[nbinsptinvmass];
1614 TH1D **invmassBptproj = new TH1D*[nbinsptinvmass];
1615
70da6c5a 1616 TH1D *yieldPtFound = (TH1D *) hsSparseData->Projection(0);
02524e30 1617 yieldPtFound->SetName("Found yield");
1618 yieldPtFound->Reset();
1619
1620 TH1D *yieldPtSourcesMC = 0x0;
70da6c5a 1621 TH1D *yieldPtSignalCutMC = 0x0;
1622 if(hsSparseMC) {
1623 yieldPtSourcesMC = (TH1D *) hsSparseMC->Projection(0);
02524e30 1624 yieldPtSourcesMC->SetName("Found yield");
1625 yieldPtSourcesMC->Reset();
70da6c5a 1626
1627 yieldPtSignalCutMC = (TH1D *) hsSparseMC->Projection(0);
02524e30 1628 yieldPtSignalCutMC->SetName("Found yield");
1629 yieldPtSignalCutMC->Reset();
1630 }
70da6c5a 1631
1632 ////////////
02524e30 1633 // canvas
70da6c5a 1634 ///////////
02524e30 1635 Int_t nbrow = (Int_t) (nbinsptinvmass/5);
70da6c5a 1636 TString namecanvas("InvMassSpectra");
02524e30 1637 TCanvas * canvas =new TCanvas(namecanvas,namecanvas,800,800);
1638 canvas->Divide(5,nbrow+1);
1639
70da6c5a 1640 /////////////////////////////
1641 // Loop on pt bins
1642 /////////////////////////////
02524e30 1643
02524e30 1644 for(Int_t k=1; k <= nbinsptinvmass; k++){
1645
1646 Double_t lowedge = ptaxisinvmass->GetBinLowEdge(k);
1647 Double_t upedge = ptaxisinvmass->GetBinUpEdge(k);
70da6c5a 1648
1649 // Pt bin
1650 hsSparseData->GetAxis(0)->SetRange(k,k);
1651 if(hsSparseMC) hsSparseMC->GetAxis(0)->SetRange(k,k);
02524e30 1652
70da6c5a 1653 //
1654 hsSparseData->GetAxis(4)->SetRange(kOs+1,kOs+1);
1655 invmassosptproj[k-1] = hsSparseData->Projection(3);
1656 hsSparseData->GetAxis(4)->SetRange(kPp+1,kNn+1);
1657 invmassssptproj[k-1] = hsSparseData->Projection(3);
1658 hsSparseData->GetAxis(4)->SetRange(kR+1,kR+1);
1659 invmassrptproj[k-1] = hsSparseData->Projection(3);
1660 hsSparseData->GetAxis(4)->SetRange(1,hsSparseData->GetAxis(4)->GetNbins());
02524e30 1661 invmassgammaptproj[k-1] = 0x0;
1662 invmasspi0ptproj[k-1] = 0x0;
1663 invmassetaptproj[k-1] = 0x0;
1664 invmassCptproj[k-1] = 0x0;
1665 invmassBptproj[k-1] = 0x0;
70da6c5a 1666 if(hsSparseMC) {
1667 hsSparseMC->GetAxis(4)->SetRange(kElectronFromGamma+1,kElectronFromGamma+1);
1668 invmassgammaptproj[k-1] = hsSparseMC->Projection(3);
1669 hsSparseMC->GetAxis(4)->SetRange(kElectronFromPi0+1,kElectronFromPi0+1);
1670 invmasspi0ptproj[k-1] = hsSparseMC->Projection(3);
1671 hsSparseMC->GetAxis(4)->SetRange(kElectronFromEta+1,kElectronFromEta+1);
1672 invmassetaptproj[k-1] = hsSparseMC->Projection(3);
1673 hsSparseMC->GetAxis(4)->SetRange(kElectronFromC+1,kElectronFromC+1);
1674 invmassCptproj[k-1] = hsSparseMC->Projection(3);
1675 hsSparseMC->GetAxis(4)->SetRange(kElectronFromB+1,kElectronFromB+1);
1676 invmassBptproj[k-1] = hsSparseMC->Projection(3);
1677 hsSparseMC->GetAxis(4)->SetRange(1,hsSparseMC->GetAxis(4)->GetNbins());
1678 }
1679
02524e30 1680 invmassdiffptproj[k-1] = (TH1D *) invmassosptproj[k-1]->Clone();
1681 TString name("Invmassdiffptbin");
1682 name += k;
1683 invmassdiffptproj[k-1]->SetName(name);
1684 invmassdiffptproj[k-1]->Add(invmassssptproj[k-1],-1.0);
1685
1686 TString namee("p_{T} tagged from ");
1687 namee += lowedge;
1688 namee += " GeV/c to ";
1689 namee += upedge;
1690 namee += " GeV/c";
1691
1692 invmassosptproj[k-1]->SetTitle((const char*)namee);
1693 invmassssptproj[k-1]->SetTitle((const char*)namee);
1694 invmassrptproj[k-1]->SetTitle((const char*)namee);
1695 invmassdiffptproj[k-1]->SetTitle((const char*)namee);
1696 if(invmassgammaptproj[k-1]) invmassgammaptproj[k-1]->SetTitle((const char*)namee);
1697 if(invmasspi0ptproj[k-1]) invmasspi0ptproj[k-1]->SetTitle((const char*)namee);
1698 if(invmassetaptproj[k-1]) invmassetaptproj[k-1]->SetTitle((const char*)namee);
1699 if(invmassCptproj[k-1]) invmassCptproj[k-1]->SetTitle((const char*)namee);
1700 if(invmassBptproj[k-1]) invmassBptproj[k-1]->SetTitle((const char*)namee);
70da6c5a 1701
02524e30 1702 invmassosptproj[k-1]->SetStats(0);
1703 invmassssptproj[k-1]->SetStats(0);
1704 invmassrptproj[k-1]->SetStats(0);
1705 invmassdiffptproj[k-1]->SetStats(0);
1706 if(invmassgammaptproj[k-1]) invmassgammaptproj[k-1]->SetStats(0);
1707 if(invmasspi0ptproj[k-1]) invmasspi0ptproj[k-1]->SetStats(0);
1708 if(invmassetaptproj[k-1]) invmassetaptproj[k-1]->SetStats(0);
1709 if(invmassCptproj[k-1]) invmassCptproj[k-1]->SetStats(0);
1710 if(invmassBptproj[k-1]) invmassBptproj[k-1]->SetStats(0);
1711
1712 Double_t yieldf = invmassdiffptproj[k-1]->Integral();
1713 if(invmassetaptproj[k-1] && invmasspi0ptproj[k-1] && invmassgammaptproj[k-1] && invmassCptproj[k-1] && invmassBptproj[k-1]) {
1714 Double_t yieldg = invmassetaptproj[k-1]->Integral() + invmasspi0ptproj[k-1]->Integral() + invmassgammaptproj[k-1]->Integral();
69ac0e6f 1715 if(yieldPtSourcesMC) yieldPtSourcesMC->SetBinContent(k,yieldg);
02524e30 1716
1717 Double_t yieldsignal = invmassCptproj[k-1]->Integral() + invmassBptproj[k-1]->Integral();
69ac0e6f 1718 if(yieldPtSignalCutMC) yieldPtSignalCutMC->SetBinContent(k,yieldsignal);
02524e30 1719 }
1720
1721 yieldPtFound->SetBinContent(k,yieldf);
1722
1723 canvas->cd(k);
1724 invmassosptproj[k-1]->Draw();
1725 invmassssptproj[k-1]->Draw("same");
1726 invmassdiffptproj[k-1]->Draw("same");
1727 invmassrptproj[k-1]->Draw("same");
1728 TLegend *legiv = new TLegend(0.4,0.6,0.89,0.89);
1729 legiv->AddEntry(invmassosptproj[k-1],"Opposite signs","p");
1730 legiv->AddEntry(invmassssptproj[k-1],"Same signs","p");
1731 legiv->AddEntry(invmassdiffptproj[k-1],"(Opposite - Same) signs","p");
1732 legiv->AddEntry(invmassrptproj[k-1],"rotated","p");
1733 if(invmassgammaptproj[k-1]) legiv->AddEntry(invmassgammaptproj[k-1],"e^{+}e^{-} from #gamma","p");
1734 if(invmasspi0ptproj[k-1]) legiv->AddEntry(invmasspi0ptproj[k-1],"e^{+}e^{-} from #pi^{0}","p");
1735 if(invmassetaptproj[k-1]) legiv->AddEntry(invmassetaptproj[k-1],"e^{+}e^{-} from #eta","p");
1736 legiv->Draw("same");
1737
70da6c5a 1738 hsSparseData->GetAxis(0)->SetRange(1,hsSparseData->GetAxis(0)->GetNbins());
1739 if(hsSparseMC) hsSparseMC->GetAxis(0)->SetRange(1,hsSparseMC->GetAxis(0)->GetNbins());
1740
02524e30 1741 }
1742
70da6c5a 1743 ////////////////////////////////////////////////////
1744 // End of plotting: do subtraction of background
1745 ///////////////////////////////////////////////////
1746
02524e30 1747 yieldPtFound->SetStats(0);
1748 if(yieldPtSourcesMC) yieldPtSourcesMC->SetStats(0);
1749 if(yieldPtSignalCutMC) yieldPtSignalCutMC->SetStats(0);
1750
70da6c5a 1751 TCanvas * canvasfin =new TCanvas("ResultsElecBackGround","ResultsElecBackGround",800,800);
02524e30 1752 canvasfin->cd(1);
1753 yieldPtFound->Draw();
1754 if(yieldPtSourcesMC && yieldPtSignalCutMC) {
1755 yieldPtSourcesMC->Draw("same");
1756 yieldPtSignalCutMC->Draw("same");
1757 TLegend *lega = new TLegend(0.4,0.6,0.89,0.89);
70da6c5a 1758 lega->AddEntry(yieldPtFound,"Contributions found","l");
1759 lega->AddEntry(yieldPtSourcesMC,"Contributions of e^{+}e^{-} from #gamma, #pi^{0} and #eta","l");
1760 lega->AddEntry(yieldPtSignalCutMC,"Contributions of e^{+}e^{-} from C and B","l");
02524e30 1761 lega->Draw("same");
1762 }
1763
70da6c5a 1764 if(hsSparseCutPassedMC){
1765 hsSparseCutPassedMC->GetAxis(1)->SetRange(1,1);
1766 hsSparseCutPassedMC->GetAxis(2)->SetRange(1,4);
1767 TH1D *hsSparseCutPassedMCproj = hsSparseCutPassedMC->Projection(0);
02524e30 1768
70da6c5a 1769 TH1D *cYieldPtFound = (TH1D*)yieldPtFound->Clone("RatioEfficiency");
1770 if(hsSparseCutPassedMCproj->Integral() > 0.0) cYieldPtFound->Divide(hsSparseCutPassedMCproj);
1771
1772 TCanvas * canvasfratio =new TCanvas("RatioEfficiency","RatioEfficiency",800,800);
1773 canvasfratio->cd(1);
1774 cYieldPtFound->Draw();
1775 }
1776
1777 //////////////////////////
1778 // fListPostProcess
1779 /////////////////////////
02524e30 1780
1781 if(!fListPostProcess) fListPostProcess = new TList();
1782 fListPostProcess->SetName("ListPostProcess");
1783
1784 for(Int_t k=0; k < nbinsptinvmass; k++){
1785 fListPostProcess->AddAt(invmassosptproj[k],kOos+kNOutput*k);
1786 fListPostProcess->AddAt(invmassssptproj[k],kOss+kNOutput*k);
1787 fListPostProcess->AddAt(invmassrptproj[k],kOr+kNOutput*k);
1788 fListPostProcess->AddAt(invmassdiffptproj[k],kOdiff+kNOutput*k);
1789 if(invmassgammaptproj[k]) fListPostProcess->AddAt(invmassgammaptproj[k],kNOutput*nbinsptinvmass+kNMCInfo*k+kElectronFromGamma);
1790 if(invmasspi0ptproj[k]) fListPostProcess->AddAt(invmasspi0ptproj[k],kNOutput*nbinsptinvmass+kNMCInfo*k+kElectronFromPi0);
1791 if(invmassetaptproj[k]) fListPostProcess->AddAt(invmassetaptproj[k],kNOutput*nbinsptinvmass+kNMCInfo*k+kElectronFromEta);
1792 if(invmassCptproj[k]) fListPostProcess->AddAt(invmassCptproj[k],kNOutput*nbinsptinvmass+kNMCInfo*k+kElectronFromC);
1793 if(invmassBptproj[k]) fListPostProcess->AddAt(invmassBptproj[k],kNOutput*nbinsptinvmass+kNMCInfo*k+kElectronFromB);
1794 }
1795
1796 fListPostProcess->AddAt(yieldPtFound,kNOutput*nbinsptinvmass+kNMCInfo*nbinsptinvmass);
1797 if(yieldPtSourcesMC) fListPostProcess->AddAt(yieldPtSourcesMC,kNOutput*nbinsptinvmass+kNMCInfo*nbinsptinvmass+1);
1798 if(yieldPtSignalCutMC) fListPostProcess->AddAt(yieldPtSignalCutMC,kNOutput*nbinsptinvmass+kNMCInfo*nbinsptinvmass+2);
1799
1800 // delete dynamic array
1801 delete[] invmassosptproj;
1802 delete[] invmassssptproj;
1803 delete[] invmassrptproj;
1804 delete[] invmassdiffptproj;
1805 delete[] invmassgammaptproj;
1806 delete[] invmasspi0ptproj;
1807 delete[] invmassetaptproj;
1808 delete[] invmassCptproj;
1809 delete[] invmassBptproj;
1810
1811}
1812//_______________________________________________________________________________________________
1813void AliHFEelecbackground::Plot() const
1814{
1815 //
1816 // Plot the output
1817 //
1818
1819 if(!fList) return;
70da6c5a 1820
1821 gStyle->SetPalette(1);
1822 gStyle->SetOptStat(1111);
1823 gStyle->SetPadBorderMode(0);
1824 gStyle->SetCanvasColor(10);
1825 gStyle->SetPadLeftMargin(0.13);
1826 gStyle->SetPadRightMargin(0.13);
1827
1828
1829 /////////////////////////
1830 // Take the THnSparseF
1831 /////////////////////////
1832 THnSparseF *hsSparseData = dynamic_cast<THnSparseF *>(fList->FindObject("OpeningangleinvmassData"));
1833 THnSparseF *hsSparseMC = dynamic_cast<THnSparseF *>(fList->FindObject("OpeningangleinvmassMC"));
69ac0e6f 1834 if(!hsSparseData) return;
70da6c5a 1835
1836 ////////////////////
1837 // Opening angle
1838 ////////////////////
1839
1840 // Opening angle one direction
1841 hsSparseData->GetAxis(4)->SetRange(kPp+1,kPp+1);
1842 TH1D *openingangleppproj = hsSparseData->Projection(2);
1843 hsSparseData->GetAxis(4)->SetRange(kNn+1,kNn+1);
1844 TH1D *openinganglennproj = hsSparseData->Projection(2);
1845 hsSparseData->GetAxis(4)->SetRange(kPp+1,kNn+1);
1846 TH1D *openinganglessproj = hsSparseData->Projection(2);
1847 hsSparseData->GetAxis(4)->SetRange(kR+1,kR+1);
1848 TH1D *openinganglerproj = hsSparseData->Projection(2);
1849 hsSparseData->GetAxis(4)->SetRange(kOs+1,kOs+1);
1850 TH1D *openingangleosproj = hsSparseData->Projection(2);
1851 hsSparseData->GetAxis(4)->SetRange(1,hsSparseData->GetAxis(4)->GetNbins());
02524e30 1852
1853 TH1D *openinganglegammaproj = 0x0;
1854 TH1D *openinganglepi0proj = 0x0;
1855 TH1D *openingangleCproj = 0x0;
1856 TH1D *openingangleBproj = 0x0;
1857 TH1D *openingangleetaproj = 0x0;
d2af20c5 1858 TH1D *openingangleSplittedTrackssproj = 0x0;
1859 TH1D *openingangleSplittedTrackosproj = 0x0;
70da6c5a 1860 if(hsSparseMC) {
1861 hsSparseMC->GetAxis(4)->SetRange(kElectronFromGamma+1,kElectronFromGamma+1);
1862 openinganglegammaproj = hsSparseMC->Projection(2);
1863 hsSparseMC->GetAxis(4)->SetRange(kElectronFromPi0+1,kElectronFromPi0+1);
1864 openinganglepi0proj = hsSparseMC->Projection(2);
1865 hsSparseMC->GetAxis(4)->SetRange(kElectronFromEta+1,kElectronFromEta+1);
1866 openingangleetaproj = hsSparseMC->Projection(2);
1867 hsSparseMC->GetAxis(4)->SetRange(kElectronFromC+1,kElectronFromC+1);
1868 openingangleCproj = hsSparseMC->Projection(2);
1869 hsSparseMC->GetAxis(4)->SetRange(kElectronFromB+1,kElectronFromB+1);
1870 openingangleBproj = hsSparseMC->Projection(2);
1871 hsSparseMC->GetAxis(4)->SetRange(1,hsSparseMC->GetAxis(4)->GetNbins());
1872 hsSparseMC->GetAxis(5)->SetRange(kSplittedSs+1,kSplittedSs+1);
1873 openingangleSplittedTrackssproj = hsSparseMC->Projection(2);
1874 hsSparseMC->GetAxis(5)->SetRange(kSplittedOs+1,kSplittedOs+1);
1875 openingangleSplittedTrackosproj = hsSparseMC->Projection(2);
1876 hsSparseMC->GetAxis(5)->SetRange(1,hsSparseMC->GetAxis(5)->GetNbins());
1877 }
1878
1879 // Projection pt-opening angle
1880 hsSparseData->GetAxis(4)->SetRange(kPp+1,kPp+1);
1881 TH2D *openingangleppproj2D = hsSparseData->Projection(0,2);
1882 hsSparseData->GetAxis(4)->SetRange(kNn+1,kNn+1);
1883 TH2D *openinganglennproj2D = hsSparseData->Projection(0,2);
1884 hsSparseData->GetAxis(4)->SetRange(kPp+1,kNn+1);
1885 TH2D *openinganglessproj2D = hsSparseData->Projection(0,2);
1886 hsSparseData->GetAxis(4)->SetRange(kR+1,kR+1);
1887 TH2D *openinganglerproj2D = hsSparseData->Projection(0,2);
1888 hsSparseData->GetAxis(4)->SetRange(kOs+1,kOs+1);
1889 TH2D *openingangleosproj2D = hsSparseData->Projection(0,2);
1890 hsSparseData->GetAxis(4)->SetRange(1,hsSparseData->GetAxis(4)->GetNbins());
02524e30 1891
70da6c5a 1892 TH2D *openinganglegammaproj2D = 0x0;
1893 TH2D *openinganglepi0proj2D = 0x0;
1894 TH2D *openingangleCproj2D = 0x0;
1895 TH2D *openingangleBproj2D = 0x0;
1896 TH2D *openingangleetaproj2D = 0x0;
1897 TH2D *openingangleSplittedTrackssproj2D = 0x0;
1898 TH2D *openingangleSplittedTrackosproj2D = 0x0;
1899 if(hsSparseMC) {
1900 hsSparseMC->GetAxis(4)->SetRange(kElectronFromGamma+1,kElectronFromGamma+1);
1901 openinganglegammaproj2D = hsSparseMC->Projection(0,2);
1902 hsSparseMC->GetAxis(4)->SetRange(kElectronFromPi0+1,kElectronFromPi0+1);
1903 openinganglepi0proj2D = hsSparseMC->Projection(0,2);
1904 hsSparseMC->GetAxis(4)->SetRange(kElectronFromEta+1,kElectronFromEta+1);
1905 openingangleetaproj2D = hsSparseMC->Projection(0,2);
1906 hsSparseMC->GetAxis(4)->SetRange(kElectronFromC+1,kElectronFromC+1);
1907 openingangleCproj2D = hsSparseMC->Projection(0,2);
1908 hsSparseMC->GetAxis(4)->SetRange(kElectronFromB+1,kElectronFromB+1);
1909 openingangleBproj2D = hsSparseMC->Projection(0,2);
1910 hsSparseMC->GetAxis(4)->SetRange(1, hsSparseMC->GetAxis(4)->GetNbins());
1911 hsSparseMC->GetAxis(5)->SetRange(kSplittedSs+1,kSplittedSs+1);
1912 openingangleSplittedTrackssproj2D = hsSparseMC->Projection(0,2);
1913 hsSparseMC->GetAxis(5)->SetRange(kSplittedOs+1,kSplittedOs+1);
1914 openingangleSplittedTrackosproj2D = hsSparseMC->Projection(0,2);
1915 hsSparseMC->GetAxis(5)->SetRange(1,hsSparseMC->GetAxis(5)->GetNbins());
1916 }
02524e30 1917
70da6c5a 1918 openingangleppproj2D->SetStats(0);
1919 openinganglennproj2D->SetStats(0);
1920 openinganglessproj2D->SetStats(0);
1921 openinganglerproj2D->SetStats(0);
1922 openingangleosproj2D->SetStats(0);
1923 if(openinganglegammaproj2D) openinganglegammaproj2D->SetStats(0);
1924 if(openinganglepi0proj2D) openinganglepi0proj2D->SetStats(0);
1925 if(openingangleCproj2D) openingangleCproj2D->SetStats(0);
1926 if(openingangleBproj2D) openingangleBproj2D->SetStats(0);
1927 if(openingangleetaproj2D) openingangleetaproj2D->SetStats(0);
1928 if(openingangleSplittedTrackssproj2D) openingangleSplittedTrackssproj2D->SetStats(0);
1929 if(openingangleSplittedTrackosproj2D) openingangleSplittedTrackosproj2D->SetStats(0);
1930
1931 openingangleppproj2D->SetTitle("openingangleppproj2D");
1932 openinganglennproj2D->SetTitle("openinganglennproj2D");
1933 openinganglessproj2D->SetTitle("openinganglessproj2D");
1934 openinganglerproj2D->SetTitle("openinganglerproj2D");
1935 openingangleosproj2D->SetTitle("openingangleosproj2D");
1936 if(openinganglegammaproj2D) openinganglegammaproj2D->SetTitle("openinganglegammaproj2D");
1937 if(openinganglepi0proj2D) openinganglepi0proj2D->SetTitle("openinganglepi0proj2D");
1938 if(openingangleCproj2D) openingangleCproj2D->SetTitle("openingangleCproj2D");
1939 if(openingangleBproj2D) openingangleBproj2D->SetTitle("openingangleBproj2D");
1940 if(openingangleetaproj2D) openingangleetaproj2D->SetTitle("openingangleetaproj2D");
1941 if(openingangleSplittedTrackssproj2D) openingangleSplittedTrackssproj2D->SetTitle("openingangleSplittedTrackssproj2D");
1942 if(openingangleSplittedTrackosproj2D) openingangleSplittedTrackosproj2D->SetTitle("openingangleSplittedTrackosproj2D");
02524e30 1943
02524e30 1944 openingangleppproj->SetStats(0);
1945 openinganglennproj->SetStats(0);
1946 openinganglessproj->SetStats(0);
1947 openinganglerproj->SetStats(0);
1948 openingangleosproj->SetStats(0);
1949 if(openinganglegammaproj) openinganglegammaproj->SetStats(0);
1950 if(openinganglepi0proj) openinganglepi0proj->SetStats(0);
1951 if(openingangleCproj) openingangleCproj->SetStats(0);
1952 if(openingangleBproj) openingangleBproj->SetStats(0);
1953 if(openingangleetaproj) openingangleetaproj->SetStats(0);
d2af20c5 1954 if(openingangleSplittedTrackssproj) openingangleSplittedTrackssproj->SetStats(0);
1955 if(openingangleSplittedTrackosproj) openingangleSplittedTrackosproj->SetStats(0);
02524e30 1956
1957 openingangleppproj->SetTitle("");
1958 openinganglennproj->SetTitle("");
1959 openinganglessproj->SetTitle("");
1960 openinganglerproj->SetTitle("");
1961 openingangleosproj->SetTitle("");
1962 if(openinganglegammaproj) openinganglegammaproj->SetTitle("");
1963 if(openinganglepi0proj) openinganglepi0proj->SetTitle("");
1964 if(openingangleCproj) openingangleCproj->SetTitle("");
1965 if(openingangleBproj) openingangleBproj->SetTitle("");
1966 if(openingangleetaproj) openingangleetaproj->SetTitle("");
d2af20c5 1967 if(openingangleSplittedTrackssproj) openingangleSplittedTrackssproj->SetTitle("");
1968 if(openingangleSplittedTrackosproj) openingangleSplittedTrackosproj->SetTitle("");
02524e30 1969
70da6c5a 1970 ////////////////////////////
1971 // Invariant mass
1972 ///////////////////////////
1973
1974 // Cuts on the opening angle
1975 TAxis *axisOpeningAngleData = hsSparseData->GetAxis(2);
1976 Int_t binCutData = axisOpeningAngleData->FindBin(fOpeningAngleCut);
1977 hsSparseData->GetAxis(2)->SetRange(1,binCutData);
1978
1979 // Debug
1980 //printf("Get Bin low edge %f, Get Bin Up edge %f for hsSparseData\n",axisOpeningAngleData->GetBinLowEdge(binCutData),axisOpeningAngleData->GetBinUpEdge(binCutData));
1981
1982 // Invariant mass
1983 hsSparseData->GetAxis(4)->SetRange(kPp+1,kPp+1);
1984 TH1D *invmassppproj = hsSparseData->Projection(3);
1985 hsSparseData->GetAxis(4)->SetRange(kNn+1,kNn+1);
1986 TH1D *invmassnnproj = hsSparseData->Projection(3);
1987 hsSparseData->GetAxis(4)->SetRange(kPp+1,kNn+1);
1988 TH1D *invmassssproj = hsSparseData->Projection(3);
1989 hsSparseData->GetAxis(4)->SetRange(kR+1,kR+1);
1990 TH1D *invmassrproj = hsSparseData->Projection(3);
1991 hsSparseData->GetAxis(4)->SetRange(kOs+1,kOs+1);
1992 TH1D *invmassosproj = hsSparseData->Projection(3);
1993 hsSparseData->GetAxis(4)->SetRange(1,hsSparseData->GetAxis(4)->GetNbins());
1994
1995 TH1D *invmassgammaproj = 0x0;
1996 TH1D *invmasspi0proj = 0x0;
1997 TH1D *invmassCproj = 0x0;
1998 TH1D *invmassBproj = 0x0;
1999 TH1D *invmassetaproj = 0x0;
2000 TH1D *invmassSplittedTrackssproj = 0x0;
2001 TH1D *invmassSplittedTrackosproj = 0x0;
2002 if(hsSparseMC) {
2003 TAxis *axisOpeningAngleMC = hsSparseMC->GetAxis(2);
2004 Int_t binCutMC = axisOpeningAngleMC->FindBin(fOpeningAngleCut);
2005 hsSparseMC->GetAxis(2)->SetRange(1,binCutMC);
2006
2007 // Debug
2008 //printf("Get Bin low edge %f, Get Bin Up edge %f for hsSparseMC\n",axisOpeningAngleMC->GetBinLowEdge(binCutMC),axisOpeningAngleMC->GetBinUpEdge(binCutMC));
2009
2010 hsSparseMC->GetAxis(4)->SetRange(kElectronFromGamma+1,kElectronFromGamma+1);
2011 invmassgammaproj = hsSparseMC->Projection(3);
2012 hsSparseMC->GetAxis(4)->SetRange(kElectronFromPi0+1,kElectronFromPi0+1);
2013 invmasspi0proj = hsSparseMC->Projection(3);
2014 hsSparseMC->GetAxis(4)->SetRange(kElectronFromEta+1,kElectronFromEta+1);
2015 invmassetaproj = hsSparseMC->Projection(3);
2016 hsSparseMC->GetAxis(4)->SetRange(kElectronFromC+1,kElectronFromC+1);
2017 invmassCproj = hsSparseMC->Projection(3);
2018 hsSparseMC->GetAxis(4)->SetRange(kElectronFromB+1,kElectronFromB+1);
2019 invmassBproj = hsSparseMC->Projection(3);
2020 hsSparseMC->GetAxis(4)->SetRange(1,hsSparseMC->GetAxis(4)->GetNbins());
2021 hsSparseMC->GetAxis(5)->SetRange(kSplittedSs+1,kSplittedSs+1);
2022 invmassSplittedTrackssproj = hsSparseMC->Projection(3);
2023 hsSparseMC->GetAxis(5)->SetRange(kSplittedOs+1,kSplittedOs+1);
2024 invmassSplittedTrackosproj = hsSparseMC->Projection(3);
2025 hsSparseMC->GetAxis(5)->SetRange(1,hsSparseMC->GetAxis(5)->GetNbins());
2026 }
2027
2028 invmassppproj->SetStats(0);
2029 invmassnnproj->SetStats(0);
2030 invmassssproj->SetStats(0);
2031 invmassrproj->SetStats(0);
2032 invmassosproj->SetStats(0);
2033 if(invmassgammaproj) invmassgammaproj->SetStats(0);
2034 if(invmasspi0proj) invmasspi0proj->SetStats(0);
2035 if(invmassCproj) invmassCproj->SetStats(0);
2036 if(invmassBproj) invmassBproj->SetStats(0);
2037 if(invmassetaproj) invmassetaproj->SetStats(0);
2038 if(invmassSplittedTrackssproj) invmassSplittedTrackssproj->SetStats(0);
2039 if(invmassSplittedTrackosproj) invmassSplittedTrackosproj->SetStats(0);
2040
02524e30 2041 invmassppproj->SetTitle("");
2042 invmassnnproj->SetTitle("");
2043 invmassssproj->SetTitle("");
2044 invmassrproj->SetTitle("");
2045 invmassosproj->SetTitle("");
2046 if(invmassgammaproj) invmassgammaproj->SetTitle("");
2047 if(invmasspi0proj) invmasspi0proj->SetTitle("");
2048 if(invmassCproj) invmassCproj->SetTitle("");
2049 if(invmassBproj) invmassBproj->SetTitle("");
2050 if(invmassetaproj) invmassetaproj->SetTitle("");
d2af20c5 2051 if(invmassSplittedTrackssproj) invmassSplittedTrackssproj->SetTitle("");
2052 if(invmassSplittedTrackosproj) invmassSplittedTrackosproj->SetTitle("");
2053
70da6c5a 2054 // Projection pt-invariant mass angle
2055 hsSparseData->GetAxis(4)->SetRange(kPp+1,kPp+1);
2056 TH2D *invmassppproj2D = hsSparseData->Projection(0,3);
2057 hsSparseData->GetAxis(4)->SetRange(kNn+1,kNn+1);
2058 TH2D *invmassnnproj2D = hsSparseData->Projection(0,3);
2059 hsSparseData->GetAxis(4)->SetRange(kPp+1,kNn+1);
2060 TH2D *invmassssproj2D = hsSparseData->Projection(0,3);
2061 hsSparseData->GetAxis(4)->SetRange(kR+1,kR+1);
2062 TH2D *invmassrproj2D = hsSparseData->Projection(0,3);
2063 hsSparseData->GetAxis(4)->SetRange(kOs+1,kOs+1);
2064 TH2D *invmassosproj2D = hsSparseData->Projection(0,3);
2065 hsSparseData->GetAxis(4)->SetRange(1,hsSparseData->GetAxis(4)->GetNbins());
d2af20c5 2066
2067 TH2D *invmassgammaproj2D = 0x0;
2068 TH2D *invmasspi0proj2D = 0x0;
2069 TH2D *invmassCproj2D = 0x0;
2070 TH2D *invmassBproj2D = 0x0;
2071 TH2D *invmassetaproj2D = 0x0;
2072 TH2D *invmassSplittedTrackssproj2D = 0x0;
2073 TH2D *invmassSplittedTrackosproj2D = 0x0;
70da6c5a 2074 if(hsSparseMC) {
2075 hsSparseMC->GetAxis(4)->SetRange(kElectronFromGamma+1,kElectronFromGamma+1);
2076 invmassgammaproj2D = hsSparseMC->Projection(0,3);
2077 hsSparseMC->GetAxis(4)->SetRange(kElectronFromPi0+1,kElectronFromPi0+1);
2078 invmasspi0proj2D = hsSparseMC->Projection(0,3);
2079 hsSparseMC->GetAxis(4)->SetRange(kElectronFromEta+1,kElectronFromEta+1);
2080 invmassetaproj2D = hsSparseMC->Projection(0,3);
2081 hsSparseMC->GetAxis(4)->SetRange(kElectronFromC+1,kElectronFromC+1);
2082 invmassCproj2D = hsSparseMC->Projection(0,3);
2083 hsSparseMC->GetAxis(4)->SetRange(kElectronFromB+1,kElectronFromB+1);
2084 invmassBproj2D = hsSparseMC->Projection(0,3);
2085 hsSparseMC->GetAxis(4)->SetRange(1,hsSparseMC->GetAxis(4)->GetNbins());
2086 hsSparseMC->GetAxis(5)->SetRange(kSplittedSs+1,kSplittedSs+1);
2087 invmassSplittedTrackssproj2D = hsSparseMC->Projection(0,3);
2088 hsSparseMC->GetAxis(5)->SetRange(kSplittedOs+1,kSplittedOs+1);
2089 invmassSplittedTrackosproj2D = hsSparseMC->Projection(0,3);
2090 hsSparseMC->GetAxis(5)->SetRange(1,hsSparseMC->GetAxis(5)->GetNbins());
2091 }
2092
d2af20c5 2093
2094 invmassppproj2D->SetStats(0);
2095 invmassnnproj2D->SetStats(0);
2096 invmassssproj2D->SetStats(0);
2097 invmassrproj2D->SetStats(0);
2098 invmassosproj2D->SetStats(0);
2099 if(invmassgammaproj2D) invmassgammaproj2D->SetStats(0);
2100 if(invmasspi0proj2D) invmasspi0proj2D->SetStats(0);
2101 if(invmassCproj2D) invmassCproj2D->SetStats(0);
2102 if(invmassBproj2D) invmassBproj2D->SetStats(0);
2103 if(invmassetaproj2D) invmassetaproj2D->SetStats(0);
2104 if(invmassSplittedTrackssproj2D) invmassSplittedTrackssproj2D->SetStats(0);
2105 if(invmassSplittedTrackosproj2D) invmassSplittedTrackosproj2D->SetStats(0);
70da6c5a 2106
d2af20c5 2107 invmassppproj2D->SetTitle("invmassppproj2D");
2108 invmassnnproj2D->SetTitle("invmassnnproj2D");
2109 invmassssproj2D->SetTitle("invmassssproj2D");
2110 invmassrproj2D->SetTitle("invmassrproj2D");
2111 invmassosproj2D->SetTitle("invmassosproj2D");
2112 if(invmassgammaproj2D) invmassgammaproj2D->SetTitle("invmassgammaproj2D");
2113 if(invmasspi0proj2D) invmasspi0proj2D->SetTitle("invmasspi0proj2D");
2114 if(invmassCproj2D) invmassCproj2D->SetTitle("invmassCproj2D");
2115 if(invmassBproj2D) invmassBproj2D->SetTitle("invmassBproj2D");
2116 if(invmassetaproj2D) invmassetaproj2D->SetTitle("invmassetaproj2D");
2117 if(invmassSplittedTrackssproj2D) invmassSplittedTrackssproj2D->SetTitle("invmassSplittedTrackssproj2D");
2118 if(invmassSplittedTrackosproj2D) invmassSplittedTrackosproj2D->SetTitle("invmassSplittedTrackosproj2D");
2119
02524e30 2120
70da6c5a 2121 /////////////
2122 // Plot
2123 ////////////
2124
02524e30 2125 // Draw histograms for opening angle
2126 TCanvas * copeningangle =new TCanvas("openingangle","Openingangle",800,800);
2127 copeningangle->cd();
70da6c5a 2128 //openingangleppproj->Draw();
2129 //openinganglennproj->Draw("same");
2130 openinganglessproj->Draw();
2131 //openinganglerproj->Draw("same");
02524e30 2132 openingangleosproj->Draw("same");
2133 if(openinganglegammaproj) openinganglegammaproj->Draw("same");
2134 if(openinganglepi0proj) openinganglepi0proj->Draw("same");
70da6c5a 2135 //if(openingangleCproj) openingangleCproj->Draw("same");
2136 //if(openingangleBproj) openingangleBproj->Draw("same");
02524e30 2137 if(openingangleetaproj) openingangleetaproj->Draw("same");
d2af20c5 2138 if(openingangleSplittedTrackssproj) openingangleSplittedTrackssproj->Draw("same");
2139 if(openingangleSplittedTrackosproj) openingangleSplittedTrackosproj->Draw("same");
02524e30 2140 TLegend *lego = new TLegend(0.4,0.6,0.89,0.89);
70da6c5a 2141 //lego->AddEntry(openingangleppproj,"positive-positive","p");
2142 //lego->AddEntry(openinganglennproj,"negative-negative","p");
02524e30 2143 lego->AddEntry(openinganglessproj,"same-sign","p");
70da6c5a 2144 //lego->AddEntry(openinganglerproj,"rotated","p");
02524e30 2145 lego->AddEntry(openingangleosproj,"positive-negative","p");
2146 if(openinganglegammaproj) lego->AddEntry(openinganglegammaproj,"e^{+}e^{-} from #gamma","p");
2147 if(openinganglepi0proj) lego->AddEntry(openinganglepi0proj,"e^{+}e^{-} from #pi^{0}","p");
70da6c5a 2148 //if(openingangleCproj) lego->AddEntry(openingangleCproj,"e^{+}e^{-} from c","p");
2149 //if(openingangleBproj) lego->AddEntry(openingangleBproj,"e^{+}e^{-} from b","p");
02524e30 2150 if(openingangleetaproj) lego->AddEntry(openingangleetaproj,"e^{+}e^{-} from #eta","p");
d2af20c5 2151 if(openingangleSplittedTrackssproj) lego->AddEntry(openingangleSplittedTrackssproj,"Splitted tracks same sign","p");
2152 if(openingangleSplittedTrackosproj) lego->AddEntry(openingangleSplittedTrackosproj,"Splitted tracks opposite sign","p");
02524e30 2153 lego->Draw("same");
70da6c5a 2154
d2af20c5 2155 // Draw histograms for invariant mass
02524e30 2156 TCanvas * cinvmass =new TCanvas("invmass","Invmass",800,800);
2157 cinvmass->cd();
70da6c5a 2158 //invmassppproj->Draw();
2159 //invmassnnproj->Draw("same");
2160 invmassssproj->Draw();
2161 //invmassrproj->Draw("same");
02524e30 2162 invmassosproj->Draw("same");
2163 if(invmassgammaproj) invmassgammaproj->Draw("same");
2164 if(invmasspi0proj) invmasspi0proj->Draw("same");
70da6c5a 2165 //if(invmassCproj) invmassCproj->Draw("same");
2166 //if(invmassBproj) invmassBproj->Draw("same");
02524e30 2167 if(invmassetaproj) invmassetaproj->Draw("same");
d2af20c5 2168 if(invmassSplittedTrackssproj) invmassSplittedTrackssproj->Draw("same");
2169 if(invmassSplittedTrackosproj) invmassSplittedTrackosproj->Draw("same");
02524e30 2170 TLegend *legi = new TLegend(0.4,0.6,0.89,0.89);
70da6c5a 2171 //legi->AddEntry(invmassppproj,"positive-positive","p");
2172 //legi->AddEntry(invmassnnproj,"negative-negative","p");
02524e30 2173 legi->AddEntry(invmassssproj,"same-sign","p");
70da6c5a 2174 //legi->AddEntry(invmassrproj,"rotated","p");
02524e30 2175 legi->AddEntry(invmassosproj,"positive-negative","p");
2176 if(invmassgammaproj) legi->AddEntry(invmassgammaproj,"e^{+}e^{-} from #gamma","p");
2177 if(invmasspi0proj) legi->AddEntry(invmasspi0proj,"e^{+}e^{-} from #pi^{0}","p");
70da6c5a 2178 //if(invmassCproj) legi->AddEntry(invmassCproj,"e^{+}e^{-} from c","p");
2179 //if(invmassBproj) legi->AddEntry(invmassBproj,"e^{+}e^{-} from b","p");
02524e30 2180 if(invmassetaproj) legi->AddEntry(invmassetaproj,"e^{+}e^{-} from #eta","p");
d2af20c5 2181 if(invmassSplittedTrackssproj) legi->AddEntry(invmassSplittedTrackssproj,"Splitted tracks same sign","p");
2182 if(invmassSplittedTrackosproj) legi->AddEntry(invmassSplittedTrackosproj,"Splitted tracks opposite sign","p");
02524e30 2183 legi->Draw("same");
2184
70da6c5a 2185
2186
d2af20c5 2187 // Draw histograms for opening angle 2D
2188 TCanvas * copeningangle2D =new TCanvas("openingangle2D","Openingangle2D",800,800);
2189 copeningangle2D->Divide(6,2);
2190 copeningangle2D->cd(1);
2191 openingangleppproj2D->Draw("lego");
2192 copeningangle2D->cd(2);
2193 openinganglennproj2D->Draw("lego");
2194 copeningangle2D->cd(3);
2195 openinganglessproj2D->Draw("lego");
2196 copeningangle2D->cd(4);
2197 openinganglerproj2D->Draw("lego");
2198 copeningangle2D->cd(5);
2199 openingangleosproj2D->Draw("lego");
2200 copeningangle2D->cd(6);
2201 if(openinganglegammaproj2D) openinganglegammaproj2D->Draw("lego");
2202 copeningangle2D->cd(7);
2203 if(openinganglepi0proj2D) openinganglepi0proj2D->Draw("lego");
2204 copeningangle2D->cd(8);
2205 if(openingangleCproj2D) openingangleCproj2D->Draw("lego");
2206 copeningangle2D->cd(9);
2207 if(openingangleBproj2D) openingangleBproj2D->Draw("lego");
2208 copeningangle2D->cd(10);
2209 if(openingangleetaproj2D) openingangleetaproj2D->Draw("lego");
2210 copeningangle2D->cd(11);
2211 if(openingangleSplittedTrackssproj2D) openingangleSplittedTrackssproj2D->Draw("lego");
2212 copeningangle2D->cd(12);
2213 if(openingangleSplittedTrackosproj2D) openingangleSplittedTrackosproj2D->Draw("lego");
2214
2215 // Draw histograms for invariant mass 2D
2216 TCanvas * cinvmass2D =new TCanvas("invmass2D","Invmass2D",800,800);
2217 cinvmass2D->Divide(6,2);
2218 cinvmass2D->cd(1);
2219 invmassppproj2D->Draw("lego");
2220 cinvmass2D->cd(2);
2221 invmassnnproj2D->Draw("lego");
2222 cinvmass2D->cd(3);
2223 invmassssproj2D->Draw("lego");
2224 cinvmass2D->cd(4);
2225 invmassrproj2D->Draw("lego");
2226 cinvmass2D->cd(5);
2227 invmassosproj2D->Draw("lego");
2228 cinvmass2D->cd(6);
2229 if(invmassgammaproj2D) invmassgammaproj2D->Draw("lego");
2230 cinvmass2D->cd(7);
2231 if(invmasspi0proj2D) invmasspi0proj2D->Draw("lego");
2232 cinvmass2D->cd(8);
2233 if(invmassCproj2D) invmassCproj2D->Draw("lego");
2234 cinvmass2D->cd(9);
2235 if(invmassBproj2D) invmassBproj2D->Draw("lego");
2236 cinvmass2D->cd(10);
2237 if(invmassetaproj2D) invmassetaproj2D->Draw("lego");
2238 cinvmass2D->cd(11);
2239 if(invmassSplittedTrackssproj2D) invmassSplittedTrackssproj2D->Draw("lego");
2240 cinvmass2D->cd(12);
2241 if(invmassSplittedTrackosproj2D) invmassSplittedTrackosproj2D->Draw("lego");
70da6c5a 2242
2243
2244 ////////////////////////
2245 // Cut efficiencies
2246 ////////////////////////
2247
2248 THnSparseF *hsSparseMCe = dynamic_cast<THnSparseF *>(fList->FindObject("CutPassedMC"));
2249
2250 if(hsSparseMCe) {
2251
2252 // init histos
2253 TAxis *axissources = hsSparseMCe->GetAxis(2);
2254 Int_t nbsources = axissources->GetNbins();
2255 TAxis *axiscuts = hsSparseMCe->GetAxis(1);
2256 Int_t nbcuts = axiscuts->GetNbins();
2257 TH1D **histopassedcuts = new TH1D*[nbsources*nbcuts];
2258 Double_t *nbEntriesCuts = new Double_t[nbsources*nbcuts];
2259
2260 //printf("Number of cuts %d\n",nbcuts);
2261
2262 // canvas
2263 TCanvas * chsSparseMCeeff =new TCanvas("hsSparseMCeeffDebug","hsSparseMCeeffDebug",800,800);
2264 chsSparseMCeeff->Divide(3,1);
2265
2266 // histos
2267 for(Int_t sourceid = 0; sourceid < nbsources; sourceid++) {
2268 hsSparseMCe->GetAxis(2)->SetRange(sourceid+1,sourceid+1);
2269 for(Int_t cut = 0; cut < nbcuts; cut++){
2270 hsSparseMCe->GetAxis(1)->SetRange(cut+1,cut+1);
2271 histopassedcuts[sourceid*nbcuts+cut] = hsSparseMCe->Projection(0);
2272 hsSparseMCe->GetAxis(1)->SetRange(1,hsSparseMCe->GetAxis(1)->GetNbins());
2273 }
2274 hsSparseMCe->GetAxis(2)->SetRange(1,hsSparseMCe->GetAxis(2)->GetNbins());
2275 }
2276
2277 // calcul efficiencies
2278 ///////////////////////
2279 // histos
2280 for(Int_t sourceid = 0; sourceid < nbsources; sourceid++) {
2281 // Next is compared to the partner tracked
2282 for(Int_t cut = 2; cut < nbcuts; cut++){
2283 nbEntriesCuts[sourceid*nbcuts+cut] = histopassedcuts[sourceid*nbcuts+cut]->GetEntries();
2284 if(histopassedcuts[sourceid*nbcuts+1]->GetEntries() > 0.0) histopassedcuts[sourceid*nbcuts+cut]->Divide(histopassedcuts[sourceid*nbcuts+1]);
2285 }
2286 // First one is if the partner is tracked.
2287 nbEntriesCuts[sourceid*nbcuts+1] = histopassedcuts[sourceid*nbcuts+1]->GetEntries();
2288 if(histopassedcuts[sourceid*nbcuts]->GetEntries() > 0.0) histopassedcuts[sourceid*nbcuts+1]->Divide(histopassedcuts[sourceid*nbcuts]);
2289 // First one is input
2290 nbEntriesCuts[sourceid*nbcuts] = histopassedcuts[sourceid*nbcuts]->GetEntries();
2291 }
2292
2293 /////////////
2294 // ratios
2295 ////////////
2296 for(Int_t sourceid = 0; sourceid < nbsources; sourceid++) {
2297 for(Int_t cut = 1; cut < nbcuts; cut++){
2298 if(nbEntriesCuts[sourceid*nbcuts] > 0.0) nbEntriesCuts[sourceid*nbcuts+cut] = nbEntriesCuts[sourceid*nbcuts+cut]/nbEntriesCuts[sourceid*nbcuts];
2299 }
2300 }
2301 TH1F *ratioHistoEntriesGamma = new TH1F("ratioHistoEntriesGamma","", nbcuts-1, 0.0, nbcuts-1.0);
2302 TH1F *ratioHistoEntriesPi0 = new TH1F("ratioHistoEntriesPi0","", nbcuts-1, 0.0, nbcuts-1.0);
2303 TH1F *ratioHistoEntriesC = new TH1F("ratioHistoEntriesC","", nbcuts-1, 0.0, nbcuts-1.0);
2304 for(Int_t k = 1; k < nbcuts; k++){
2305 ratioHistoEntriesGamma->SetBinContent(k,nbEntriesCuts[nbcuts+k]);
2306 ratioHistoEntriesPi0->SetBinContent(k,nbEntriesCuts[2*nbcuts+k]);
2307 ratioHistoEntriesC->SetBinContent(k,nbEntriesCuts[4*nbcuts+k]);
2308 }
2309 //
2310 TAxis *xAxisGamma = ratioHistoEntriesGamma->GetXaxis();
2311 xAxisGamma->SetBinLabel(1,"Partner tracked");
2312 xAxisGamma->SetBinLabel(2,"Opposite sign");
2313 xAxisGamma->SetBinLabel(3,"Single Track Cut");
2314 xAxisGamma->SetBinLabel(4,"Shared Clusters");
2315 xAxisGamma->SetBinLabel(5,"PID");
2316 xAxisGamma->SetBinLabel(6,"DCA");
2317 xAxisGamma->SetBinLabel(7,"Chi^{2}/Ndf");
2318 xAxisGamma->SetBinLabel(8,"Opening angle");
2319 xAxisGamma->SetBinLabel(9,"Invariant mass");
2320 //
2321 TAxis *xAxisPi0 = ratioHistoEntriesPi0->GetXaxis();
2322 xAxisPi0->SetBinLabel(1,"Partner tracked");
2323 xAxisPi0->SetBinLabel(2,"Opposite sign");
2324 xAxisPi0->SetBinLabel(3,"Single Track Cut");
2325 xAxisPi0->SetBinLabel(4,"Shared Clusters");
2326 xAxisPi0->SetBinLabel(5,"PID");
2327 xAxisPi0->SetBinLabel(6,"DCA");
2328 xAxisPi0->SetBinLabel(7,"Chi^{2}/Ndf");
2329 xAxisPi0->SetBinLabel(8,"Opening angle");
2330 xAxisPi0->SetBinLabel(9,"Invariant mass");
2331 //
2332 TAxis *xAxisC = ratioHistoEntriesC->GetXaxis();
2333 xAxisC->SetBinLabel(1,"Partner tracked");
2334 xAxisC->SetBinLabel(2,"Opposite sign");
2335 xAxisC->SetBinLabel(3,"Single Track Cut");
2336 xAxisC->SetBinLabel(4,"Shared Clusters");
2337 xAxisC->SetBinLabel(5,"PID");
2338 xAxisC->SetBinLabel(6,"DCA");
2339 xAxisC->SetBinLabel(7,"Chi^{2}/Ndf");
2340 xAxisC->SetBinLabel(8,"Opening angle");
2341 xAxisC->SetBinLabel(9,"Invariant mass");
2342 //
2343 TCanvas * cRatioHistoEntries =new TCanvas("cRatioHistoEntries","cRatioHistoEntries",800,800);
2344 cRatioHistoEntries->cd(1);
2345 ratioHistoEntriesGamma->SetStats(0);
2346 ratioHistoEntriesGamma->Draw();
2347 ratioHistoEntriesPi0->SetStats(0);
2348 ratioHistoEntriesPi0->Draw("same");
2349 ratioHistoEntriesC->SetStats(0);
2350 //ratioHistoEntriesC->Draw("same");
2351 TLegend *legEntries = new TLegend(0.4,0.6,0.89,0.89);
2352 legEntries->AddEntry(ratioHistoEntriesGamma,"#gamma","l");
2353 legEntries->AddEntry(ratioHistoEntriesPi0,"#pi^{0}","l");
2354 //legEntries->AddEntry(ratioHistoEntriesC,"c","p");
2355 legEntries->Draw("same");
2356
2357 ////////////////////
2358 // plot Debug
2359 ///////////////////
2360 Int_t source = 1;
2361 chsSparseMCeeff->cd(1);
2362 histopassedcuts[source*nbcuts+0]->SetTitle("#gamma");
2363 histopassedcuts[source*nbcuts+1]->SetTitle("#gamma");
2364 histopassedcuts[source*nbcuts+2]->SetTitle("#gamma");
2365 histopassedcuts[source*nbcuts+3]->SetTitle("#gamma");
2366 histopassedcuts[source*nbcuts+4]->SetTitle("#gamma");
2367 histopassedcuts[source*nbcuts+5]->SetTitle("#gamma");
2368 histopassedcuts[source*nbcuts+6]->SetTitle("#gamma");
2369 histopassedcuts[source*nbcuts+7]->SetTitle("#gamma");
2370 histopassedcuts[source*nbcuts+8]->SetTitle("#gamma");
2371 histopassedcuts[source*nbcuts+9]->SetTitle("#gamma");
2372 //histopassedcuts[source*nbcuts+0]->SetStats(0);
2373 histopassedcuts[source*nbcuts+1]->SetStats(0);
2374 histopassedcuts[source*nbcuts+2]->SetStats(0);
2375 histopassedcuts[source*nbcuts+3]->SetStats(0);
2376 histopassedcuts[source*nbcuts+4]->SetStats(0);
2377 histopassedcuts[source*nbcuts+5]->SetStats(0);
2378 histopassedcuts[source*nbcuts+6]->SetStats(0);
2379 histopassedcuts[source*nbcuts+7]->SetStats(0);
2380 histopassedcuts[source*nbcuts+8]->SetStats(0);
2381 histopassedcuts[source*nbcuts+9]->SetStats(0);
2382 //histopassedcuts[source*nbcuts+0]->Draw();
2383 //histopassedcuts[source*nbcuts+1]->Draw("");
2384 histopassedcuts[source*nbcuts+2]->Draw();
2385 histopassedcuts[source*nbcuts+3]->Draw("same");
2386 //histopassedcuts[source*nbcuts+4]->Draw("same");
2387 histopassedcuts[source*nbcuts+5]->Draw("same");
2388 histopassedcuts[source*nbcuts+6]->Draw("same");
2389 //histopassedcuts[source*nbcuts+7]->Draw("same");
2390 histopassedcuts[source*nbcuts+8]->Draw("same");
2391 histopassedcuts[source*nbcuts+9]->Draw("same");
2392 TLegend *legb = new TLegend(0.4,0.6,0.89,0.89);
2393 //legb->AddEntry(histopassedcuts[source*nbcuts+0],"all","p");
2394 //legb->AddEntry(histopassedcuts[source*nbcuts+1],"Partner tracked","p");
2395 legb->AddEntry(histopassedcuts[source*nbcuts+2],"Opposite sign","p");
2396 legb->AddEntry(histopassedcuts[source*nbcuts+3],"SingleTrackPart","p");
2397 //legb->AddEntry(histopassedcuts[source*nbcuts+4],"SharedCluster","p");
2398 legb->AddEntry(histopassedcuts[source*nbcuts+5],"PID","p");
2399 legb->AddEntry(histopassedcuts[source*nbcuts+6],"DCA","p");
2400 //legb->AddEntry(histopassedcuts[source*nbcuts+7],"Chi2Ndf","p");
2401 legb->AddEntry(histopassedcuts[source*nbcuts+8],"OpeningAngle","p");
2402 legb->AddEntry(histopassedcuts[source*nbcuts+9],"InvMass","p");
2403 legb->Draw("same");
2404
2405 source = 2;
2406 chsSparseMCeeff->cd(2);
2407 histopassedcuts[source*nbcuts+0]->SetTitle("#pi^{0}");
2408 histopassedcuts[source*nbcuts+1]->SetTitle("#pi^{0}");
2409 histopassedcuts[source*nbcuts+2]->SetTitle("#pi^{0}");
2410 histopassedcuts[source*nbcuts+3]->SetTitle("#pi^{0}");
2411 histopassedcuts[source*nbcuts+4]->SetTitle("#pi^{0}");
2412 histopassedcuts[source*nbcuts+5]->SetTitle("#pi^{0}");
2413 histopassedcuts[source*nbcuts+6]->SetTitle("#pi^{0}");
2414 histopassedcuts[source*nbcuts+7]->SetTitle("#pi^{0}");
2415 histopassedcuts[source*nbcuts+8]->SetTitle("#pi^{0}");
2416 histopassedcuts[source*nbcuts+9]->SetTitle("#pi^{0}");
2417 //histopassedcuts[source*nbcuts+0]->SetStats(0);
2418 histopassedcuts[source*nbcuts+1]->SetStats(0);
2419 histopassedcuts[source*nbcuts+2]->SetStats(0);
2420 histopassedcuts[source*nbcuts+3]->SetStats(0);
2421 histopassedcuts[source*nbcuts+4]->SetStats(0);
2422 histopassedcuts[source*nbcuts+5]->SetStats(0);
2423 histopassedcuts[source*nbcuts+6]->SetStats(0);
2424 histopassedcuts[source*nbcuts+7]->SetStats(0);
2425 histopassedcuts[source*nbcuts+8]->SetStats(0);
2426 histopassedcuts[source*nbcuts+9]->SetStats(0);
2427 //histopassedcuts[source*nbcuts+0]->Draw();
2428 //histopassedcuts[source*nbcuts+1]->Draw();
2429 histopassedcuts[source*nbcuts+2]->Draw();
2430 histopassedcuts[source*nbcuts+3]->Draw("same");
2431 //histopassedcuts[source*nbcuts+4]->Draw("same");
2432 histopassedcuts[source*nbcuts+5]->Draw("same");
2433 histopassedcuts[source*nbcuts+6]->Draw("same");
2434 //histopassedcuts[source*nbcuts+7]->Draw("same");
2435 histopassedcuts[source*nbcuts+8]->Draw("same");
2436 histopassedcuts[source*nbcuts+9]->Draw("same");
2437 TLegend *legc = new TLegend(0.4,0.6,0.89,0.89);
2438 //legc->AddEntry(histopassedcuts[source*nbcuts+0],"all","p");
2439 //legc->AddEntry(histopassedcuts[source*nbcuts+1],"Partner tracked","p");
2440 legc->AddEntry(histopassedcuts[source*nbcuts+2],"Opposite sign","p");
2441 legc->AddEntry(histopassedcuts[source*nbcuts+3],"SingleTrackPart","p");
2442 //legc->AddEntry(histopassedcuts[source*nbcuts+4],"SharedCluster","p");
2443 legc->AddEntry(histopassedcuts[source*nbcuts+5],"PID","p");
2444 legc->AddEntry(histopassedcuts[source*nbcuts+6],"DCA","p");
2445 //legc->AddEntry(histopassedcuts[source*nbcuts+7],"Chi2Ndf","p");
2446 legc->AddEntry(histopassedcuts[source*nbcuts+8],"OpeningAngle","p");
2447 legc->AddEntry(histopassedcuts[source*nbcuts+9],"InvMass","p");
2448 legc->Draw("same");
2449
2450 source = 4;
2451 chsSparseMCeeff->cd(3);
2452 histopassedcuts[source*nbcuts+0]->SetTitle("C");
2453 histopassedcuts[source*nbcuts+1]->SetTitle("C");
2454 histopassedcuts[source*nbcuts+2]->SetTitle("C");
2455 histopassedcuts[source*nbcuts+3]->SetTitle("C");
2456 histopassedcuts[source*nbcuts+4]->SetTitle("C");
2457 histopassedcuts[source*nbcuts+5]->SetTitle("C");
2458 histopassedcuts[source*nbcuts+6]->SetTitle("C");
2459 histopassedcuts[source*nbcuts+7]->SetTitle("C");
2460 histopassedcuts[source*nbcuts+8]->SetTitle("C");
2461 histopassedcuts[source*nbcuts+9]->SetTitle("C");
2462 //histopassedcuts[source*nbcuts+0]->SetStats(0);
2463 histopassedcuts[source*nbcuts+1]->SetStats(0);
2464 histopassedcuts[source*nbcuts+2]->SetStats(0);
2465 histopassedcuts[source*nbcuts+3]->SetStats(0);
2466 histopassedcuts[source*nbcuts+4]->SetStats(0);
2467 histopassedcuts[source*nbcuts+5]->SetStats(0);
2468 histopassedcuts[source*nbcuts+6]->SetStats(0);
2469 histopassedcuts[source*nbcuts+7]->SetStats(0);
2470 histopassedcuts[source*nbcuts+8]->SetStats(0);
2471 histopassedcuts[source*nbcuts+9]->SetStats(0);
2472 //histopassedcuts[source*nbcuts+0]->Draw();
2473 //histopassedcuts[source*nbcuts+1]->Draw();
2474 histopassedcuts[source*nbcuts+2]->Draw();
2475 histopassedcuts[source*nbcuts+3]->Draw("same");
2476 //histopassedcuts[source*nbcuts+4]->Draw("same");
2477 histopassedcuts[source*nbcuts+5]->Draw("same");
2478 histopassedcuts[source*nbcuts+6]->Draw("same");
2479 //histopassedcuts[source*nbcuts+7]->Draw("same");
2480 histopassedcuts[source*nbcuts+8]->Draw("same");
2481 histopassedcuts[source*nbcuts+9]->Draw("same");
2482 TLegend *lege = new TLegend(0.4,0.6,0.89,0.89);
2483 //lege->AddEntry(histopassedcuts[source*nbcuts+0],"all","p");
2484 //lege->AddEntry(histopassedcuts[source*nbcuts+1],"Partner tracked","p");
2485 lege->AddEntry(histopassedcuts[source*nbcuts+2],"Opposite sign","p");
2486 lege->AddEntry(histopassedcuts[source*nbcuts+3],"SingleTrackPart","p");
2487 //lege->AddEntry(histopassedcuts[source*nbcuts+4],"SharedCluster","p");
2488 lege->AddEntry(histopassedcuts[source*nbcuts+5],"PID","p");
2489 lege->AddEntry(histopassedcuts[source*nbcuts+6],"DCA","p");
2490 //lege->AddEntry(histopassedcuts[source*nbcuts+7],"Chi2Ndf","p");
2491 lege->AddEntry(histopassedcuts[source*nbcuts+8],"OpeningAngle","p");
2492 lege->AddEntry(histopassedcuts[source*nbcuts+9],"InvMass","p");
2493 lege->Draw("same");
2494
2495 //////////////////////
2496 // Input
2497 //////////////////////
2498
2499 TCanvas * chsSparseMCein =new TCanvas("hsSparseMCeinput","hsSparseMCeinput",800,800);
2500 chsSparseMCein->cd(1);
2501 Double_t nbGamma = 0.0;
2502 source = 1;
2503 nbGamma = histopassedcuts[source*nbcuts+0]->GetEntries();
2504 histopassedcuts[source*nbcuts+0]->SetStats(0);
2505 histopassedcuts[source*nbcuts+0]->Draw();
2506 TLegend *leginput = new TLegend(0.4,0.6,0.89,0.89);
2507 leginput->AddEntry(histopassedcuts[source*nbcuts+0],"#gamma","p");
2508 Double_t nbPi0 = 0.0;
2509 source = 2;
2510 nbPi0 = histopassedcuts[source*nbcuts+0]->GetEntries();
2511 histopassedcuts[source*nbcuts+0]->SetStats(0);
2512 histopassedcuts[source*nbcuts+0]->Draw("same");
2513 leginput->AddEntry(histopassedcuts[source*nbcuts+0],"#pi^{0}","p");
2514 Double_t nbEta = 0.0;
2515 source = 3;
2516 nbEta = histopassedcuts[source*nbcuts+0]->GetEntries();
2517 histopassedcuts[source*nbcuts+0]->SetStats(0);
2518 histopassedcuts[source*nbcuts+0]->Draw("same");
2519 leginput->AddEntry(histopassedcuts[source*nbcuts+0],"#eta","p");
2520 Double_t nbC = 0.0;
2521 source = 4;
2522 nbC = histopassedcuts[source*nbcuts+0]->GetEntries();
2523 histopassedcuts[source*nbcuts+0]->SetStats(0);
2524 histopassedcuts[source*nbcuts+0]->Draw("same");
2525 leginput->AddEntry(histopassedcuts[source*nbcuts+0],"c","p");
2526 leginput->Draw("same");
2527
2528 //printf("Gamma %f, pi^{0} %f and #eta %f, c %f\n",nbGamma,nbPi0,nbEta,nbC);
2529
2530 //////////////////////
2531 // Tracked
2532 //////////////////////
2533
2534 TCanvas * cTracked = new TCanvas("cTracked","cTracked",800,800);
2535 cTracked->cd(1);
2536 source = 1;
2537 histopassedcuts[source*nbcuts+1]->Draw();
2538 TLegend *legTracked = new TLegend(0.4,0.6,0.89,0.89);
2539 legTracked->AddEntry(histopassedcuts[source*nbcuts+1],"#gamma","p");
2540 source = 2;
2541 histopassedcuts[source*nbcuts+1]->Draw("same");
2542 legTracked->AddEntry(histopassedcuts[source*nbcuts+1],"#pi^{0}","p");
2543 legTracked->Draw("same");
2544
2545 }
2546
2547 /////////////////////////////////////
2548 // Data Radius and chi2Ndf if AliKF
2549 ////////////////////////////////////
2550
2551 TH1F *hDataRadius = dynamic_cast<TH1F *>(fList->FindObject("DataRadius"));
2552 TH1F *hDataChi2Ndf = dynamic_cast<TH1F *>(fList->FindObject("DataChi2Ndf"));
2553
2554 if(hDataRadius || hDataChi2Ndf) {
2555 TCanvas * cDataRadiusChi2Ndf =new TCanvas("CanvasDataRadiusChi2Ndf","CanvasDataRadiusChi2Ndf",800,800);
2556 cDataRadiusChi2Ndf->Divide(2,1);
2557 cDataRadiusChi2Ndf->cd(1);
2558 if(hDataRadius) hDataRadius->Draw();
2559 cDataRadiusChi2Ndf->cd(2);
2560 if(hDataChi2Ndf) hDataChi2Ndf->Draw();
2561 }
2562
2563 ///////////////////////
2564 // Data DCA
2565 //////////////////////
d2af20c5 2566
70da6c5a 2567 TH1F *hDataDCA = dynamic_cast<TH1F *>(fList->FindObject("DataDCA"));
2568
2569 if(hDataDCA) {
2570 TCanvas * cDataDCA =new TCanvas("CanvasDataDCA","CanvasDataDCA",800,800);
2571 cDataDCA->cd(1);
2572 hDataDCA->Draw();
2573 }
2574
2575 /////////////////////////////////////
2576 // MC Radius and chi2Ndf if AliKF
2577 ////////////////////////////////////
2578
2579 TH2F *hMCRadius = dynamic_cast<TH2F *>(fList->FindObject("MCRadius"));
2580 TH2F *hMCChi2Ndf = dynamic_cast<TH2F *>(fList->FindObject("MCChi2Ndf"));
2581
2582 if(hMCRadius || hMCChi2Ndf) {
2583 TCanvas * cMCRadiusChi2Ndf =new TCanvas("CanvasMCRadiusChi2Ndf","CanvasMCRadiusChi2Ndf",800,800);
2584 cMCRadiusChi2Ndf->Divide(2,1);
2585 cMCRadiusChi2Ndf->cd(1);
2586 //TH1D *hMCRadiusBackground = hMCRadius->ProjectionX("MCRadiusBackGround",1,1,"e");
2587 TH1D *hMCRadiusGamma = hMCRadius->ProjectionX("MCRadiusGamma",2,2,"e");
2588 TH1D *hMCRadiusPi0 = hMCRadius->ProjectionX("MCRadiusPi0",3,3,"e");
2589 TH1D *hMCRadiusEta = hMCRadius->ProjectionX("MCRadiusEta",4,4,"e");
2590 TH1D *hMCRadiusC = hMCRadius->ProjectionX("MCRadiusC",5,5,"e");
2591 TH1D *hMCRadiusB = hMCRadius->ProjectionX("MCRadiusB",6,6,"e");
2592 //hMCRadiusBackground->Draw();
2593 hMCRadiusGamma->Draw();
2594 hMCRadiusPi0->Draw("same");
2595 hMCRadiusEta->Draw("same");
2596 hMCRadiusC->Draw("same");
2597 hMCRadiusB->Draw("same");
2598 TLegend *legRadius = new TLegend(0.4,0.6,0.89,0.89);
2599 //legRadius->AddEntry(hMCRadiusBackground,"Background","p");
2600 legRadius->AddEntry(hMCRadiusGamma,"#gamma","p");
2601 legRadius->AddEntry(hMCRadiusPi0,"#pi^{0}","p");
2602 legRadius->AddEntry(hMCRadiusEta,"#eta","p");
2603 legRadius->AddEntry(hMCRadiusC,"c","p");
2604 legRadius->AddEntry(hMCRadiusB,"b","p");
2605 legRadius->Draw("same");
2606 cMCRadiusChi2Ndf->cd(2);
2607 //TH1D *hMCChi2NdfBackground = hMCChi2Ndf->ProjectionX("MCChi2NdfBackGround",1,1,"e");
2608 TH1D *hMCChi2NdfGamma = hMCChi2Ndf->ProjectionX("MCChi2NdfGamma",2,2,"e");
2609 TH1D *hMCChi2NdfPi0 = hMCChi2Ndf->ProjectionX("MCChi2NdfPi0",3,3,"e");
2610 TH1D *hMCChi2NdfEta = hMCChi2Ndf->ProjectionX("MCChi2NdfEta",4,4,"e");
2611 TH1D *hMCChi2NdfC = hMCChi2Ndf->ProjectionX("MCChi2NdfC",5,5,"e");
2612 TH1D *hMCChi2NdfB = hMCChi2Ndf->ProjectionX("MCChi2NdfB",6,6,"e");
2613 //hMCChi2NdfBackground->Draw();
2614 hMCChi2NdfGamma->Draw();
2615 hMCChi2NdfPi0->Draw("same");
2616 hMCChi2NdfEta->Draw("same");
2617 hMCChi2NdfC->Draw("same");
2618 hMCChi2NdfB->Draw("same");
2619 TLegend *legChi2Ndf = new TLegend(0.4,0.6,0.89,0.89);
2620 //legChi2Ndf->AddEntry(hMCChi2NdfBackground,"Background","p");
2621 legChi2Ndf->AddEntry(hMCChi2NdfGamma,"#gamma","p");
2622 legChi2Ndf->AddEntry(hMCChi2NdfPi0,"#pi^{0}","p");
2623 legChi2Ndf->AddEntry(hMCChi2NdfEta,"#eta","p");
2624 legChi2Ndf->AddEntry(hMCChi2NdfC,"c","p");
2625 legChi2Ndf->AddEntry(hMCChi2NdfB,"b","p");
2626 legChi2Ndf->Draw("same");
2627 }
2628
2629 ///////////////////////
2630 // MC DCA
2631 //////////////////////
2632
2633 TH2F *hMCDCA = dynamic_cast<TH2F *>(fList->FindObject("MCDCA"));
2634
2635 if(hMCDCA) {
2636 TCanvas * cMCDCA =new TCanvas("CanvasMCDCA","CanvasMCDCA",800,800);
2637 cMCDCA->cd(1);
2638 //TH1D *hMCDCABackground = hMCDCA->ProjectionX("MCDCABackGround",1,1,"e");
2639 TH1D *hMCDCAGamma = hMCDCA->ProjectionX("MCDCAGamma",2,2,"e");
2640 TH1D *hMCDCAPi0 = hMCDCA->ProjectionX("MCDCAPi0",3,3,"e");
2641 TH1D *hMCDCAEta = hMCDCA->ProjectionX("MCDCAEta",4,4,"e");
2642 TH1D *hMCDCAC = hMCDCA->ProjectionX("MCDCAC",5,5,"e");
2643 TH1D *hMCDCAB = hMCDCA->ProjectionX("MCDCAB",6,6,"e");
2644 //hMCDCABackground->Draw();
2645 hMCDCAGamma->Draw();
2646 hMCDCAPi0->Draw("same");
2647 hMCDCAEta->Draw("same");
2648 hMCDCAC->Draw("same");
2649 hMCDCAB->Draw("same");
2650 TLegend *legDCA = new TLegend(0.4,0.6,0.89,0.89);
2651 //legDCA->AddEntry(hMCDCABackground,"Background","p");
2652 legDCA->AddEntry(hMCDCAGamma,"#gamma","p");
2653 legDCA->AddEntry(hMCDCAPi0,"#pi^{0}","p");
2654 legDCA->AddEntry(hMCDCAEta,"#eta","p");
2655 legDCA->AddEntry(hMCDCAC,"c","p");
2656 legDCA->AddEntry(hMCDCAB,"b","p");
2657 legDCA->Draw("same");
2658 }
2659
2660
2661 /////////////////////////
2662 // PID Partner Signal
2663 /////////////////////////
2664 TF1 *betheBlochElectron = 0x0;
2665 TF1 *betheBlochMuon = 0x0;
2666 TF1 *betheBlochPion = 0x0;
2667 TF1 *betheBlochKaon = 0x0;
2668 TF1 *betheBlochProton = 0x0;
2669
2670 TH2F *hsignalPidPartner0 = dynamic_cast<TH2F *>(fList->FindObject("TPCPartner0"));
2671 TH2F *hsignalPidPartner1 = dynamic_cast<TH2F *>(fList->FindObject("TPCPartner1"));
2672 if((!hsignalPidPartner0) && (!hsignalPidPartner1)) {
2673 hsignalPidPartner0 = dynamic_cast<TH2F *>(fList->FindObject("ITSPartner0"));
2674 hsignalPidPartner1 = dynamic_cast<TH2F *>(fList->FindObject("ITSPartner1"));
2675
2676 betheBlochElectron = new TF1("betheBlochElectron",BetheBlochElectronITS,0.1,10.0,0);
2677 betheBlochMuon = new TF1("betheBlochMuon",BetheBlochMuonITS,0.1,10.0,0);
2678 betheBlochPion = new TF1("betheBlochPion",BetheBlochPionITS,0.1,10.0,0);
2679 betheBlochKaon = new TF1("betheBlochKaon",BetheBlochKaonITS,0.1,10.0,0);
2680 betheBlochProton = new TF1("betheBlochProton",BetheBlochProtonITS,0.1,10.0,0);
2681
2682 }
2683 else {
2684
2685 betheBlochElectron = new TF1("betheBlochElectron",BetheBlochElectronTPC,0.1,10.0,0);
2686 betheBlochMuon = new TF1("betheBlochMuon",BetheBlochMuonTPC,0.1,10.0,0);
2687 betheBlochPion = new TF1("betheBlochPion",BetheBlochPionTPC,0.1,10.0,0);
2688 betheBlochKaon = new TF1("betheBlochKaon",BetheBlochKaonTPC,0.1,10.0,0);
2689 betheBlochProton = new TF1("betheBlochProton",BetheBlochProtonTPC,0.1,10.0,0);
2690
2691 }
2692
2693
2694 if((hsignalPidPartner0) || (hsignalPidPartner1)) {
2695 TCanvas * cPidSignal =new TCanvas("cPidSignal","cPidSignal",800,800);
2696 cPidSignal->Divide(2,1);
2697 cPidSignal->cd(1);
2698 if(hsignalPidPartner0) hsignalPidPartner0->Draw("colz");
2699 if(betheBlochElectron) betheBlochElectron->Draw("same");
2700 if(betheBlochMuon) betheBlochMuon->Draw("same");
2701 if(betheBlochPion) betheBlochPion->Draw("same");
2702 if(betheBlochKaon) betheBlochKaon->Draw("same");
2703 if(betheBlochProton) betheBlochProton->Draw("same");
2704 cPidSignal->cd(2);
2705 if(hsignalPidPartner1) hsignalPidPartner1->Draw("colz");
2706 if(betheBlochElectron) betheBlochElectron->Draw("same");
2707 if(betheBlochMuon) betheBlochMuon->Draw("same");
2708 if(betheBlochPion) betheBlochPion->Draw("same");
2709 if(betheBlochKaon) betheBlochKaon->Draw("same");
2710 if(betheBlochProton) betheBlochProton->Draw("same");
2711 }
2712
2713 THnSparseF *hsSparseITSsignal = dynamic_cast<THnSparseF *>(fList->FindObject("SparseITSsignal"));
2714 if(hsSparseITSsignal) {
2715
2716
2717 TH2D *sddsdd = hsSparseITSsignal->Projection(1,2);
2718 TH2D *ssdssd = hsSparseITSsignal->Projection(3,4);
2719 TH2D *sddssda = hsSparseITSsignal->Projection(1,3);
2720 TH2D *sddssdb = hsSparseITSsignal->Projection(2,4);
2721 TH2D *sddssdc = hsSparseITSsignal->Projection(1,4);
2722 TH2D *sddssdd = hsSparseITSsignal->Projection(2,3);
2723
2724 TCanvas * cITSSignal =new TCanvas("cITSSignal","cITSSignal",800,800);
2725 cITSSignal->Divide(2,3);
2726 cITSSignal->cd(1);
2727 sddsdd->Draw("colz");
2728 cITSSignal->cd(2);
2729 ssdssd->Draw("colz");
2730 cITSSignal->cd(3);
2731 sddssda->Draw("colz");
2732 cITSSignal->cd(4);
2733 sddssdb->Draw("colz");
2734 cITSSignal->cd(5);
2735 sddssdc->Draw("colz");
2736 cITSSignal->cd(6);
2737 sddssdd->Draw("colz");
2738
2739 }
2740
2741 THnSparseF *hsSparseITSsignalSplit = dynamic_cast<THnSparseF *>(fList->FindObject("SparseITSsignalSplit"));
2742 if(hsSparseITSsignalSplit) {
2743
2744 // no splitted
2745 hsSparseITSsignalSplit->GetAxis(0)->SetRange(1,1);
2746
2747 TH1D *layerITS2 = hsSparseITSsignalSplit->Projection(1);
2748 TH1D *layerITS3 = hsSparseITSsignalSplit->Projection(2);
2749 TH1D *layerITS4 = hsSparseITSsignalSplit->Projection(3);
2750 TH1D *layerITS5 = hsSparseITSsignalSplit->Projection(4);
2751
2752 // splitted
2753 hsSparseITSsignalSplit->GetAxis(0)->SetRange(2,2);
2754
2755 TH1D *layerITS2s = hsSparseITSsignalSplit->Projection(1);
2756 TH1D *layerITS3s = hsSparseITSsignalSplit->Projection(2);
2757 TH1D *layerITS4s = hsSparseITSsignalSplit->Projection(3);
2758 TH1D *layerITS5s = hsSparseITSsignalSplit->Projection(4);
2759
2760 TCanvas * cITSSignalSplit =new TCanvas("cITSSignalSplit","cITSSignalSplit",800,800);
2761 cITSSignalSplit->Divide(2,2);
2762 cITSSignalSplit->cd(1);
2763 layerITS2->Draw();
2764 layerITS2s->Draw("same");
2765 TLegend *legITS2 = new TLegend(0.4,0.6,0.89,0.89);
2766 legITS2->AddEntry(layerITS2,"No splitted","p");
2767 legITS2->AddEntry(layerITS2s,"Splitted","p");
2768 legITS2->Draw("same");
2769 cITSSignalSplit->cd(2);
2770 layerITS3->Draw();
2771 layerITS3s->Draw("same");
2772 TLegend *legITS3 = new TLegend(0.4,0.6,0.89,0.89);
2773 legITS3->AddEntry(layerITS3,"No splitted","p");
2774 legITS3->AddEntry(layerITS3s,"Splitted","p");
2775 legITS3->Draw("same");
2776 cITSSignalSplit->cd(3);
2777 layerITS4->Draw();
2778 layerITS4s->Draw("same");
2779 TLegend *legITS4 = new TLegend(0.4,0.6,0.89,0.89);
2780 legITS4->AddEntry(layerITS4,"No splitted","p");
2781 legITS4->AddEntry(layerITS4s,"Splitted","p");
2782 legITS4->Draw("same");
2783 cITSSignalSplit->cd(4);
2784 layerITS5->Draw();
2785 layerITS5s->Draw("same");
2786 TLegend *legITS5 = new TLegend(0.4,0.6,0.89,0.89);
2787 legITS5->AddEntry(layerITS5,"No splitted","p");
2788 legITS5->AddEntry(layerITS5s,"Splitted","p");
2789 legITS5->Draw("same");
2790
2791
2792 }
2793
2794}
2795//_____________________________________________________________________________
2796Double_t AliHFEelecbackground::BetheBlochElectronITS(const Double_t *x, const Double_t * /*par*/)
2797{
2798 //
2799 // Bethe Bloch for ITS
2800 //
2801 static AliITSPIDResponse itsPidResponse;
2802 return itsPidResponse.Bethe(x[0],AliPID::ParticleMass(0));
2803}
2804//_____________________________________________________________________________
2805Double_t AliHFEelecbackground::BetheBlochMuonITS(const Double_t *x, const Double_t * /*par*/)
2806{
2807 //
2808 // Bethe Bloch for ITS
2809 //
2810 static AliITSPIDResponse itsPidResponse;
2811 return itsPidResponse.Bethe(x[0],AliPID::ParticleMass(1));
2812}
2813//_____________________________________________________________________________
2814Double_t AliHFEelecbackground::BetheBlochPionITS(const Double_t *x, const Double_t * /*par*/)
2815{
2816 //
2817 // Bethe Bloch for ITS
2818 //
2819 static AliITSPIDResponse itsPidResponse;
2820 return itsPidResponse.Bethe(x[0],AliPID::ParticleMass(2));
2821}
2822//_____________________________________________________________________________
2823Double_t AliHFEelecbackground::BetheBlochKaonITS(const Double_t *x, const Double_t * /*par*/)
2824{
2825 //
2826 // Bethe Bloch for ITS
2827 //
2828 static AliITSPIDResponse itsPidResponse;
2829 return itsPidResponse.Bethe(x[0],AliPID::ParticleMass(3));
2830}
2831//_____________________________________________________________________________
2832Double_t AliHFEelecbackground::BetheBlochProtonITS(const Double_t *x, const Double_t * /*par*/)
2833{
2834 //
2835 // Bethe Bloch for ITS
2836 //
2837 static AliITSPIDResponse itsPidResponse;
2838 return itsPidResponse.Bethe(x[0],AliPID::ParticleMass(4));
2839}
2840//_____________________________________________________________________________
2841Double_t AliHFEelecbackground::BetheBlochElectronTPC(const Double_t *x, const Double_t * /*par*/)
2842{
2843 //
2844 // Bethe Bloch for TPC
2845 //
2846 static AliTPCPIDResponse tpcPidResponse;
2847 return tpcPidResponse.GetExpectedSignal(x[0],AliPID::kElectron);
2848}
2849//_____________________________________________________________________________
2850Double_t AliHFEelecbackground::BetheBlochMuonTPC(const Double_t *x, const Double_t * /*par*/)
2851{
2852 //
2853 // Bethe Bloch for TPC
2854 //
2855 static AliTPCPIDResponse tpcPidResponse;
2856 return tpcPidResponse.GetExpectedSignal(x[0],AliPID::kMuon);
2857}
2858//_____________________________________________________________________________
2859Double_t AliHFEelecbackground::BetheBlochPionTPC(const Double_t *x, const Double_t * /*par*/)
2860{
2861 //
2862 // Bethe Bloch for TPC
2863 //
2864 static AliTPCPIDResponse tpcPidResponse;
2865 return tpcPidResponse.GetExpectedSignal(x[0],AliPID::kPion);
2866}
2867//_____________________________________________________________________________
2868Double_t AliHFEelecbackground::BetheBlochKaonTPC(const Double_t *x, const Double_t * /*par*/)
2869{
2870 //
2871 // Bethe Bloch for TPC
2872 //
2873 static AliTPCPIDResponse tpcPidResponse;
2874 return tpcPidResponse.GetExpectedSignal(x[0],AliPID::kKaon);
2875}
2876//_____________________________________________________________________________
2877Double_t AliHFEelecbackground::BetheBlochProtonTPC(const Double_t *x, const Double_t * /*par*/)
2878{
2879 //
2880 // Bethe Bloch for TPC
2881 //
2882 static AliTPCPIDResponse tpcPidResponse;
2883 return tpcPidResponse.GetExpectedSignal(x[0],AliPID::kProton);
02524e30 2884}
70da6c5a 2885
2886
2887