Belle II Software  release-05-02-19
CombinedPIDPerformanceModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2010 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Jake Bennett, Todd Pedlar
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <reconstruction/modules/CombinedPIDPerformance/CombinedPIDPerformanceModule.h>
12 
13 #include <root/TObject.h>
14 
15 using namespace Belle2;
16 
17 //-----------------------------------------------------------------
18 // Register the Module
19 //-----------------------------------------------------------------
20 REG_MODULE(CombinedPIDPerformance)
21 
23 {
24  setDescription("This module evaluates the combined PID performance");
25 
26  addParam("outputFileName", m_rootFileName, "Name of output root file.",
27  std::string("CombinedPIDPerformance_output.root"));
28  addParam("mdstType", m_mdstType, "Type of mdst file (Belle/BelleII).",
29  std::string("BelleII"));
30 
31  addParam("numberOfBins", m_nbins, "Number of momentum bins.", int(100));
32  addParam("pLow", m_pLow, "Lower bound of momentum range.", double(0.0));
33  addParam("pHigh", m_pHigh, "Upper bound of momentum range.", double(5.0));
34 }
35 
37 
39 {
40 
41  B2INFO("Making PID Performance plots...");
42 
43  // required input
44  m_tracks.isRequired();
45  m_trackFitResults.isRequired();
46  m_pidLikelihoods.isRequired();
47  m_mcParticles.isRequired();
48 
49  // create list of histograms to be saved in the rootfile
50  m_histoList = new TList;
51 
52  // create the output ROOT File
53  m_rootFilePtr = new TFile(m_rootFileName.c_str(), "RECREATE");
54 
55  // determine which detectors to use
56  // cannot add more than one at a time...
57  if (m_mdstType == "BelleII") {
58  chargedSet += Const::SVD; detset.push_back(svd);
59  }
60  chargedSet += Const::CDC; detset.push_back(cdc);
61  chargedSet += Const::TOP; detset.push_back(top);
62  chargedSet += Const::ARICH; detset.push_back(arich);
63  chargedSet += Const::KLM; detset.push_back(klm);
64  detset.push_back(dedx);
65  detset.push_back(dedxtop);
66  detset.push_back(all);
67 
68  if (m_mdstType == "BelleII") {
69  electronSet += Const::SVD; edetset.push_back(svd);
70  }
71  electronSet += Const::CDC; edetset.push_back(cdc);
72  electronSet += Const::ECL; edetset.push_back(ecl);
73  edetset.push_back(dedx);
74  edetset.push_back(dedxecl);
75 
76  muonSet += Const::KLM;
77 
78  // parameters for ROCs
79  const int npbins = 18;
80  const int npidbins = 101;
81  const float pidlow = 0.;
82  const float pidhigh = 1.01;
83  const char* names[] = { "pi", "k", "e", "mu", "p" };
84 
85  // roc plots: h_ROC[Hypothesis][det](true particle id, pidvalue, momentum)
86  // pion=0, kaon=1, electron=2, muon=3, proton=4;
87  for (int Hypo = 0; Hypo < 5; Hypo++) {
88  for (int k = 0; k < 10; k++) {
89  h_ROC[Hypo][k] = new TH3F(Form("ROC_%s_%d", names[Hypo], k), Form(";PID(%s);N;p (GeV)", names[Hypo]), 5, 0, 5, npidbins, pidlow,
90  pidhigh, npbins, m_pLow, m_pHigh);
91  if (m_histoList) m_histoList->Add(h_ROC[Hypo][k]);
92  }
93  }
94 
95  // create the efficiency and fake rate objects for hadrons
96  for (unsigned int i = 0; i < chargedSet.size() + 3; ++i) {
97  m_piK_Efficiencies.push_back(createEfficiency(TString::Format("epik_%d", i), "#pi efficiency;p [GeV/c];Efficiency", m_nbins,
98  m_pLow,
100  m_Kpi_Efficiencies.push_back(createEfficiency(TString::Format("ekpi_%d", i), "K efficiency;p [GeV/c];Efficiency", m_nbins, m_pLow,
101  m_pHigh, m_histoList));
102  m_ppi_Efficiencies.push_back(createEfficiency(TString::Format("eppi_%d", i), "p efficiency;p [GeV/c];Efficiency", m_nbins, m_pLow,
103  m_pHigh, m_histoList));
104  m_pK_Efficiencies.push_back(createEfficiency(TString::Format("epk_%d", i), "p efficiency;p [GeV/c];Efficiency", m_nbins, m_pLow,
105  m_pHigh, m_histoList));
106  m_dpi_Efficiencies.push_back(createEfficiency(TString::Format("edpi_%d", i), "d efficiency;p [GeV/c];Efficiency", m_nbins, m_pLow,
107  m_pHigh, m_histoList));
108 
109  m_piK_FakeRates.push_back(createEfficiency(TString::Format("fpik_%d", i), "#pi fake rate;p [GeV/c];Fake Rate", m_nbins, m_pLow,
110  m_pHigh, m_histoList));
111  m_Kpi_FakeRates.push_back(createEfficiency(TString::Format("fkpi_%d", i), "K fake rate;p [GeV/c];Fake Rate", m_nbins, m_pLow,
112  m_pHigh,
113  m_histoList));
114  m_ppi_FakeRates.push_back(createEfficiency(TString::Format("fppi_%d", i), "p fake rate;p [GeV/c];Fake Rate", m_nbins, m_pLow,
115  m_pHigh,
116  m_histoList));
117  m_pK_FakeRates.push_back(createEfficiency(TString::Format("fpk_%d", i), "p fake rate;p [GeV/c];Fake Rate", m_nbins, m_pLow,
118  m_pHigh,
119  m_histoList));
120  m_dpi_FakeRates.push_back(createEfficiency(TString::Format("fdpi_%d", i), "d fake rate;p [GeV/c];Fake Rate", m_nbins, m_pLow,
121  m_pHigh,
122  m_histoList));
123  }
124 
125  // create the efficiency and fake rate objects for electrons
126  for (unsigned int i = 0; i < electronSet.size() + 2; ++i) {
127  m_epi_Efficiencies.push_back(createEfficiency(TString::Format("eepi_%d", i), "e efficiency;p [GeV/c];Efficiency", m_nbins, m_pLow,
128  m_pHigh, m_histoList));
129 
130  m_epi_FakeRates.push_back(createEfficiency(TString::Format("fepi_%d", i), "e fake rate;p [GeV/c];Fake Rate", m_nbins, m_pLow,
131  m_pHigh,
132  m_histoList));
133  }
134 
135  // create the efficiency and fake rate objects for muons
136  for (unsigned int i = 0; i < muonSet.size(); ++i) {
137  m_mpi_Efficiencies.push_back(createEfficiency(TString::Format("empi_%d", i), "#mu efficiency;p [GeV/c];Efficiency", m_nbins,
138  m_pLow,
139  m_pHigh, m_histoList));
140 
141  m_mpi_FakeRates.push_back(createEfficiency(TString::Format("fmpi_%d", i), "#mu fake rate;p [GeV/c];Fake Rate", m_nbins, m_pLow,
142  m_pHigh, m_histoList));
143  }
144 
145  // color the fake rate objects red here for simplicity later
146  for (unsigned int i = 0; i < chargedSet.size() + 3; ++i) {
147  m_piK_FakeRates[i]->SetMarkerColor(kRed);
148  m_piK_FakeRates[i]->SetLineColor(kRed);
149  m_Kpi_FakeRates[i]->SetMarkerColor(kRed);
150  m_Kpi_FakeRates[i]->SetLineColor(kRed);
151  m_ppi_FakeRates[i]->SetMarkerColor(kRed);
152  m_ppi_FakeRates[i]->SetLineColor(kRed);
153  m_pK_FakeRates[i]->SetMarkerColor(kRed);
154  m_pK_FakeRates[i]->SetLineColor(kRed);
155  m_dpi_FakeRates[i]->SetMarkerColor(kRed);
156  m_dpi_FakeRates[i]->SetLineColor(kRed);
157  if (i < electronSet.size() + 2) {
158  m_epi_FakeRates[i]->SetMarkerColor(kRed);
159  m_epi_FakeRates[i]->SetLineColor(kRed);
160  }
161  if (i < muonSet.size()) {
162  m_mpi_FakeRates[i]->SetMarkerColor(kRed);
163  m_mpi_FakeRates[i]->SetLineColor(kRed);
164  }
165  }
166 }
167 
169 {
170  for (const auto& track : m_tracks) {
171 
172  const TrackFitResult* trackFit = track.getTrackFitResultWithClosestMass(Const::pion);
173  if (!trackFit) {
174  B2WARNING("No track fit result... Skipping.");
175  continue;
176  }
177 
178  const PIDLikelihood* pid = track.getRelated<PIDLikelihood>();
179  if (!pid) {
180  B2WARNING("No PID information... Skipping.");
181  continue;
182  }
183 
184  const MCParticle* mcParticle = track.getRelated<MCParticle>();
185  if (!mcParticle) continue;
186  int pdg = mcParticle->getPDG();
187 
188  // apply some loose cuts on track quality and production vertex
189  if (trackFit->getPValue() < 0.001) continue;
190  if (mcParticle->getProductionVertex().Perp() > 1.0) continue;
191  if (!(mcParticle->getStatus(MCParticle::c_PrimaryParticle))) continue;
192 
193  // fill the efficiencies and fake rates
194  fillEfficiencyHistos(trackFit, pid, pdg);
195  }
196 }
197 
199 {
200 
201  // write out the objects
202  if (m_rootFilePtr != NULL) {
203  m_rootFilePtr->cd();
204 
205  TIter nextH(m_histoList);
206  TObject* obj;
207  while ((obj = nextH()))
208  obj->Write();
209 
210 
211  m_rootFilePtr->Close();
212  }
213 }
214 
216 {
217 
218  bool pass; // used to pass or fail events based on coverage
219 
220  // fill rocs, efficiencies, and fake rates for hadrons
221  for (unsigned int i = 0; i < chargedSet.size() + 3; ++i) {
222  float pidval = -1.0;
223  int detnum = detset[i];
224 
225  Const::DetectorSet det;
226  if (i < chargedSet.size()) det = chargedSet[i];
227  if (i == chargedSet.size()) { // Combined dE/dx
228  if (m_mdstType == "BelleII") det += Const::SVD;
229  det += Const::CDC;
230  }
231  if (i == chargedSet.size() + 1) { // Combined dE/dx, TOP
232  if (m_mdstType == "BelleII") det += Const::SVD;
233  det += Const::CDC;
234  det += Const::TOP;
235  }
236  if (i == chargedSet.size() + 2) { // Combined dE/dx, TOP, ARICH
237  if (m_mdstType == "BelleII") det += Const::SVD;
238  det += Const::CDC;
239  det += Const::TOP;
240  det += Const::ARICH;
241  }
242 
243  // get pid LogL values for hadrons
244  double logl_pi = 0, logl_k = 0, logl_p = 0;
245  if (pidavail(pid, det)) {
246  logl_pi = pid->getLogL(Const::pion, det);
247  logl_k = pid->getLogL(Const::kaon, det);
248  logl_p = pid->getLogL(Const::proton, det);
249  }
250 
251  // fill rocs, efficiencies, and fake rates for true pions
252  if (pidavail(pid, det) and abs(pdg) == 211) {
253  pass = (pid->getDeltaLogL(Const::pion, Const::kaon, det) > 0) ? true : false;
254  m_piK_Efficiencies[i]->Fill(pass, trackFit->getMomentum().Mag());
255 
256  pass = (pid->getDeltaLogL(Const::kaon, Const::pion, det) > 0) ? true : false;
257  m_Kpi_FakeRates[i]->Fill(pass, trackFit->getMomentum().Mag());
258 
259  pass = (pid->getDeltaLogL(Const::proton, Const::pion, det) > 0) ? true : false;
260  m_ppi_FakeRates[i]->Fill(pass, trackFit->getMomentum().Mag());
261 
262  pass = (pid->getDeltaLogL(Const::deuteron, Const::pion, det) > 0) ? true : false;
263  m_dpi_FakeRates[i]->Fill(pass, trackFit->getMomentum().Mag());
264 
265  pidval = pidvalue(logl_pi, logl_k);
266  h_ROC[0][detnum]->Fill(0.0, pidval, trackFit->getMomentum().Mag()); // pion eff
267 
268  pidval = pidvalue(logl_k, logl_pi);
269  h_ROC[1][detnum]->Fill(0.0, pidval, trackFit->getMomentum().Mag()); // pion faking k
270 
271  pidval = pidvalue(logl_p, logl_pi);
272  h_ROC[4][detnum]->Fill(0.0, pidval, trackFit->getMomentum().Mag()); // pion faking proton
273  }
274 
275  // fill rocs, efficiencies, and fake rates for true kaons
276  if (pidavail(pid, det) and abs(pdg) == 321) {
277  pass = (pid->getDeltaLogL(Const::kaon, Const::pion, det) > 0) ? true : false;
278  m_Kpi_Efficiencies[i]->Fill(pass, trackFit->getMomentum().Mag());
279 
280  pass = (pid->getDeltaLogL(Const::pion, Const::kaon, det) > 0) ? true : false;
281  m_piK_FakeRates[i]->Fill(pass, trackFit->getMomentum().Mag());
282 
283  pass = (pid->getDeltaLogL(Const::proton, Const::kaon, det) > 0) ? true : false;
284  m_pK_FakeRates[i]->Fill(pass, trackFit->getMomentum().Mag());
285 
286  pidval = pidvalue(logl_k, logl_pi);
287  h_ROC[1][detnum]->Fill(1.0, pidval, trackFit->getMomentum().Mag()); // kaon eff
288 
289  pidval = pidvalue(logl_pi, logl_k);
290  h_ROC[0][detnum]->Fill(1.0, pidval, trackFit->getMomentum().Mag()); // kaon faking pion
291 
292  pidval = pidvalue(logl_p, logl_k);
293  h_ROC[4][detnum]->Fill(1.0, pidval, trackFit->getMomentum().Mag()); // kaon faking proton
294  }
295 
296  // fill rocs and efficiencies for true protons
297  if (pidavail(pid, det) and abs(pdg) == 2212) {
298  pass = (pid->getDeltaLogL(Const::proton, Const::pion, det) > 0) ? true : false;
299  m_ppi_Efficiencies[i]->Fill(pass, trackFit->getMomentum().Mag());
300 
301  pass = (pid->getDeltaLogL(Const::proton, Const::kaon, det) > 0) ? true : false;
302  m_pK_Efficiencies[i]->Fill(pass, trackFit->getMomentum().Mag());
303 
304  pidval = pidvalue(logl_p, logl_pi + logl_k);
305  h_ROC[4][detnum]->Fill(4.0, pidval, trackFit->getMomentum().Mag()); // proton eff vs. pion and kaon
306  }
307 
308  // fill efficiencies for true deuterons
309  if (pidavail(pid, det) and abs(pdg) == 1000010020) {
310  pass = (pid->getDeltaLogL(Const::deuteron, Const::pion, det) > 0) ? true : false;
311  m_dpi_Efficiencies[i]->Fill(pass, trackFit->getMomentum().Mag());
312  }
313  } // end of loop for hadrons
314 
315  // fill rocs, efficiencies, and fake rates for electrons
316  for (unsigned int i = 0; i <= electronSet.size() + 1; ++i) {
317  float pidval = -1.0;
318  int detnum = edetset[i];
319 
320  Const::DetectorSet det;
321  if (i < electronSet.size()) det = electronSet[i];
322  if (i == electronSet.size()) { // Combined dE/dx
323  if (m_mdstType == "BelleII") det += Const::SVD;
324  det += Const::CDC;
325  }
326  if (i == electronSet.size() + 1) // Combined dE/dx, ECL
327  det = electronSet;
328 
329  // get pid LogL values for electrons and pions
330  double logl_e = 0, logl_pi_e = 0;
331  if (pidavail(pid, det)) {
332  logl_e = pid->getLogL(Const::electron, det);
333  logl_pi_e = pid->getLogL(Const::pion, det);
334  }
335 
336  // fill rocs and efficiencies for true electrons
337  if (pidavail(pid, det) and abs(pdg) == 11) {
338  pass = (pid->getDeltaLogL(Const::electron, Const::pion, det) > 0) ? true : false;
339  m_epi_Efficiencies[i]->Fill(pass, trackFit->getMomentum().Mag());
340 
341  pidval = pidvalue(logl_e, logl_pi_e);
342  h_ROC[2][detnum]->Fill(2.0, pidval, trackFit->getMomentum().Mag()); // electron eff vs pion
343  }
344 
345  // fill rocs and fake rates for true pions
346  if (pidavail(pid, det) and abs(pdg) == 211) {
347  pass = (pid->getDeltaLogL(Const::electron, Const::pion, det) > 0) ? true : false;
348  m_epi_FakeRates[i]->Fill(pass, trackFit->getMomentum().Mag());
349 
350  pidval = pidvalue(logl_pi_e, logl_e);
351  h_ROC[0][detnum]->Fill(0.0, pidval, trackFit->getMomentum().Mag()); // pion faking electron
352  }
353  } // end of loop for electrons
354 
355  // fill rocs, efficiencies, and fake rates for muons
356  for (unsigned int i = 0; i < muonSet.size(); ++i) {
357  float pidval = -1.0;
358  Const::EDetector det = muonSet[i];
359 
360  // get pid LogL values for electrons and pions
361  double logl_mu = 0, logl_pi_mu = 0;
362  if (pidavail(pid, det)) {
363  logl_mu = pid->getLogL(Const::muon, det);
364  logl_pi_mu = pid->getLogL(Const::pion, det);
365  }
366 
367  // fill rocs and efficiencies for true muons
368  if (pidavail(pid, det) and abs(pdg) == 13) {
369  pass = (pid->getDeltaLogL(Const::muon, Const::pion, det) > 0) ? true : false;
370  m_mpi_Efficiencies[i]->Fill(pass, trackFit->getMomentum().Mag());
371 
372  pidval = pidvalue(logl_mu, logl_pi_mu);
373  h_ROC[3][klm]->Fill(3.0, pidval, trackFit->getMomentum().Mag()); // muon eff vs. pion
374  }
375 
376  // fill rocs and fake ratesfor true pions
377  if (pidavail(pid, det) and abs(pdg) == 211) {
378  pass = (pid->getDeltaLogL(Const::muon, Const::pion, det) > 0) ? true : false;
379  m_mpi_FakeRates[i]->Fill(pass, trackFit->getMomentum().Mag());
380 
381  pidval = pidvalue(logl_pi_mu, logl_mu);
382  h_ROC[3][klm]->Fill(0.0, pidval, trackFit->getMomentum().Mag()); // pion faking muon
383  }
384  } // end of loop for muons
385 }
386 
387 TEfficiency* CombinedPIDPerformanceModule::createEfficiency(const char* name, const char* title,
388  Int_t nbins, Double_t min, Double_t max, TList* histoList)
389 {
390 
391  TEfficiency* h = new TEfficiency(name, title, nbins, min, max);
392 
393  if (histoList)
394  histoList->Add(h);
395 
396  return h;
397 }
398 
399 
400 double CombinedPIDPerformanceModule::pidvalue(float logl_a, float logl_b)
401 {
402  // returns likelihood ratio
403 
404  double val = -1.0;
405  float dl = logl_b - logl_a;
406 
407  if (dl < 0) {
408  val = 1 / (1 + exp(dl));
409  } else {
410  val = exp(-1 * dl) / (1 + exp(-1 * dl));
411  }
412 
413  return val;
414 }
415 
417 {
418  // returns true if at least one detector in the detectors is available.
419 
420  bool avail = false;
421  for (unsigned int i = 0; i < dets.size(); ++i) {
422  if (pidl->isAvailable(dets[i])) {
423  avail = true;
424  }
425  }
426 
427  return avail;
428 }
429 
430 
Belle2::CombinedPIDPerformanceModule::m_mdstType
std::string m_mdstType
flag for Belle/BelleII mdst files
Definition: CombinedPIDPerformanceModule.h:86
Belle2::CombinedPIDPerformanceModule::m_rootFileName
std::string m_rootFileName
root file name
Definition: CombinedPIDPerformanceModule.h:85
Belle2::CombinedPIDPerformanceModule::m_trackFitResults
StoreArray< TrackFitResult > m_trackFitResults
Required array of input TrackFitResults.
Definition: CombinedPIDPerformanceModule.h:70
Belle2::CombinedPIDPerformanceModule::fillEfficiencyHistos
void fillEfficiencyHistos(const TrackFitResult *fitResult, const PIDLikelihood *pid, int pdg)
method to fill TEfficiencies
Definition: CombinedPIDPerformanceModule.cc:215
Belle2::CombinedPIDPerformanceModule::m_epi_Efficiencies
std::vector< TEfficiency * > m_epi_Efficiencies
electron efficiencies
Definition: CombinedPIDPerformanceModule.h:101
Belle2::CombinedPIDPerformanceModule::m_ppi_FakeRates
std::vector< TEfficiency * > m_ppi_FakeRates
proton fake rates
Definition: CombinedPIDPerformanceModule.h:107
Belle2::CombinedPIDPerformanceModule::m_dpi_Efficiencies
std::vector< TEfficiency * > m_dpi_Efficiencies
deuteron efficiencies
Definition: CombinedPIDPerformanceModule.h:100
Belle2::CombinedPIDPerformanceModule::~CombinedPIDPerformanceModule
virtual ~CombinedPIDPerformanceModule()
Destructor.
Definition: CombinedPIDPerformanceModule.cc:36
Belle2::TrackFitResult::getMomentum
TVector3 getMomentum() const
Getter for vector of momentum at closest approach of track in r/phi projection.
Definition: TrackFitResult.h:116
Belle2::CombinedPIDPerformanceModule::event
virtual void event() override
This method is called for each event.
Definition: CombinedPIDPerformanceModule.cc:168
Belle2::Const::electron
static const ChargedStable electron
electron particle
Definition: Const.h:533
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::CombinedPIDPerformanceModule::m_pHigh
double m_pHigh
upper bound of momentum range
Definition: CombinedPIDPerformanceModule.h:89
Belle2::CombinedPIDPerformanceModule::initialize
virtual void initialize() override
Initialize the module.
Definition: CombinedPIDPerformanceModule.cc:38
Belle2::TrackFitResult::getPValue
double getPValue() const
Getter for Chi2 Probability of the track fit.
Definition: TrackFitResult.h:163
Belle2::CombinedPIDPerformanceModule
This module takes the MCParticles, the Tracks, and the PIDLikelihoods as input and produces a root fi...
Definition: CombinedPIDPerformanceModule.h:47
Belle2::CombinedPIDPerformanceModule::m_piK_FakeRates
std::vector< TEfficiency * > m_piK_FakeRates
pion fake rates
Definition: CombinedPIDPerformanceModule.h:105
Belle2::CombinedPIDPerformanceModule::m_histoList
TList * m_histoList
list to store TObjects
Definition: CombinedPIDPerformanceModule.h:75
Belle2::Const::DetectorSet
The DetectorSet class for sets of detector IDs in the form of EDetector values.
Definition: Const.h:66
Belle2::PIDLikelihood
Class to collect log likelihoods from TOP, ARICH, dEdx, ECL and KLM aimed for output to mdst includes...
Definition: PIDLikelihood.h:37
Belle2::CombinedPIDPerformanceModule::muonSet
Const::DetectorSet muonSet
muons
Definition: CombinedPIDPerformanceModule.h:124
Belle2::PIDLikelihood::isAvailable
bool isAvailable(Const::PIDDetectorSet set) const
Check whether PID information from a given set of detectors is available.
Definition: PIDLikelihood.h:61
Belle2::Const::EDetector
EDetector
Enum for identifying the detector components (detector and subdetector).
Definition: Const.h:44
Belle2::CombinedPIDPerformanceModule::m_epi_FakeRates
std::vector< TEfficiency * > m_epi_FakeRates
electron fake rates
Definition: CombinedPIDPerformanceModule.h:110
Belle2::CombinedPIDPerformanceModule::pidvalue
double pidvalue(float pida, float pidb)
returns the likelihood ratio for given log likelihoods
Definition: CombinedPIDPerformanceModule.cc:400
Belle2::TrackFitResult
Values of the result of a track fit with a given particle hypothesis.
Definition: TrackFitResult.h:59
Belle2::CombinedPIDPerformanceModule::h_ROC
TH3F * h_ROC[5][10]
ROC histograms.
Definition: CombinedPIDPerformanceModule.h:113
Belle2::CombinedPIDPerformanceModule::edetset
std::vector< int > edetset
set of detectors used electrons
Definition: CombinedPIDPerformanceModule.h:129
Belle2::CombinedPIDPerformanceModule::m_Kpi_FakeRates
std::vector< TEfficiency * > m_Kpi_FakeRates
kaon fake rates
Definition: CombinedPIDPerformanceModule.h:106
Belle2::CombinedPIDPerformanceModule::m_rootFilePtr
TFile * m_rootFilePtr
pointer at root file used for storing histograms
Definition: CombinedPIDPerformanceModule.h:92
Belle2::Const::kaon
static const ChargedStable kaon
charged kaon particle
Definition: Const.h:536
Belle2::Module
Base class for Modules.
Definition: Module.h:74
Belle2::CombinedPIDPerformanceModule::m_mcParticles
StoreArray< MCParticle > m_mcParticles
Required array of input MCParticles.
Definition: CombinedPIDPerformanceModule.h:72
Belle2::CombinedPIDPerformanceModule::m_ppi_Efficiencies
std::vector< TEfficiency * > m_ppi_Efficiencies
proton efficiencies
Definition: CombinedPIDPerformanceModule.h:98
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition: Const.h:535
Belle2::MCParticle::getStatus
unsigned int getStatus(unsigned short int bitmask=USHRT_MAX) const
Return status code of particle.
Definition: MCParticle.h:133
Belle2::CombinedPIDPerformanceModule::m_pLow
double m_pLow
lower bound of momentum range
Definition: CombinedPIDPerformanceModule.h:88
Belle2::CombinedPIDPerformanceModule::m_mpi_FakeRates
std::vector< TEfficiency * > m_mpi_FakeRates
muon fake rates
Definition: CombinedPIDPerformanceModule.h:111
Belle2::CombinedPIDPerformanceModule::createEfficiency
TEfficiency * createEfficiency(const char *name, const char *title, Int_t nbins, Double_t min, Double_t max, TList *histoList=NULL)
method to create TEfficiencies
Definition: CombinedPIDPerformanceModule.cc:387
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::CombinedPIDPerformanceModule::detset
std::vector< int > detset
set of detectors used for hadrons
Definition: CombinedPIDPerformanceModule.h:128
Belle2::Const::deuteron
static const ChargedStable deuteron
deuteron particle
Definition: Const.h:538
Belle2::MCParticle::getProductionVertex
TVector3 getProductionVertex() const
Return production vertex position.
Definition: MCParticle.h:200
Belle2::CombinedPIDPerformanceModule::m_mpi_Efficiencies
std::vector< TEfficiency * > m_mpi_Efficiencies
muon efficiencies
Definition: CombinedPIDPerformanceModule.h:102
Belle2::MCParticle::getPDG
int getPDG() const
Return PDG code of particle.
Definition: MCParticle.h:123
Belle2::CombinedPIDPerformanceModule::chargedSet
Const::DetectorSet chargedSet
pions, kaons, protons
Definition: CombinedPIDPerformanceModule.h:122
Belle2::CombinedPIDPerformanceModule::m_Kpi_Efficiencies
std::vector< TEfficiency * > m_Kpi_Efficiencies
kaon efficiencies
Definition: CombinedPIDPerformanceModule.h:97
Belle2::CombinedPIDPerformanceModule::terminate
virtual void terminate() override
End of the event processing.
Definition: CombinedPIDPerformanceModule.cc:198
Belle2::CombinedPIDPerformanceModule::m_dpi_FakeRates
std::vector< TEfficiency * > m_dpi_FakeRates
deuteron fake rates
Definition: CombinedPIDPerformanceModule.h:109
Belle2::CombinedPIDPerformanceModule::m_piK_Efficiencies
std::vector< TEfficiency * > m_piK_Efficiencies
pion efficiencies
Definition: CombinedPIDPerformanceModule.h:96
Belle2::Const::proton
static const ChargedStable proton
proton particle
Definition: Const.h:537
Belle2::CombinedPIDPerformanceModule::m_pidLikelihoods
StoreArray< PIDLikelihood > m_pidLikelihoods
Required array of input PIDLikelihoods.
Definition: CombinedPIDPerformanceModule.h:71
Belle2::CombinedPIDPerformanceModule::m_pK_Efficiencies
std::vector< TEfficiency * > m_pK_Efficiencies
proton efficiencies
Definition: CombinedPIDPerformanceModule.h:99
Belle2::Const::muon
static const ChargedStable muon
muon particle
Definition: Const.h:534
Belle2::CombinedPIDPerformanceModule::electronSet
Const::DetectorSet electronSet
electrons
Definition: CombinedPIDPerformanceModule.h:123
Belle2::MCParticle
A Class to store the Monte Carlo particle information.
Definition: MCParticle.h:43
Belle2::CombinedPIDPerformanceModule::m_tracks
StoreArray< Track > m_tracks
Required array of input Tracks.
Definition: CombinedPIDPerformanceModule.h:69
Belle2::Const::DetectorSet::size
size_t size() const
Getter for number of detector IDs in this set.
Definition: UnitConst.cc:243
Belle2::CombinedPIDPerformanceModule::m_nbins
int m_nbins
number of momentum bins
Definition: CombinedPIDPerformanceModule.h:87
Belle2::MCParticle::c_PrimaryParticle
@ c_PrimaryParticle
bit 0: Particle is primary particle.
Definition: MCParticle.h:58
Belle2::CombinedPIDPerformanceModule::pidavail
bool pidavail(const PIDLikelihood *pid, Const::DetectorSet dets)
determine the availability of the given detector(s)
Definition: CombinedPIDPerformanceModule.cc:416
Belle2::CombinedPIDPerformanceModule::m_pK_FakeRates
std::vector< TEfficiency * > m_pK_FakeRates
proton fake rates
Definition: CombinedPIDPerformanceModule.h:108