Belle II Software  release-05-02-19
UnitConst.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2010-2012 Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Andreas Moll, Martin Heck, Martin Ritter, Thomas Kuhr *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 /**************************************************************************
12  * This file contains the implementations for Unit.h and Const.h to avoid *
13  * problems with the order of the initialization of constants. *
14  **************************************************************************/
15 
16 #include <framework/gearbox/Unit.h>
17 #include <framework/gearbox/Const.h>
18 #include <framework/logging/Logger.h>
19 #include <framework/particledb/EvtGenDatabasePDG.h>
20 
21 #include <TMath.h>
22 
23 #include <algorithm>
24 #include <fstream>
25 
26 using namespace Belle2;
27 using namespace std;
28 
29 /*** The implementation of the Unit class defined in Unit.h starts here ***/
30 
31 namespace Belle2 {
37  map<string, double> Unit::s_conversionFactors;
38 
40 #define DEFINE_UNIT_NAME(var,value,name) const double Unit::var = Unit::registerConversion(name,value)
41 
42 #define DEFINE_UNIT(var,value) DEFINE_UNIT_NAME(var,value,#var)
43 
47  DEFINE_UNIT(cm , 1.);
48  DEFINE_UNIT(ns , 1.);
49  DEFINE_UNIT(GHz , 1.);
50  DEFINE_UNIT(rad , 1.);
51  DEFINE_UNIT(GeV , 1.);
52  DEFINE_UNIT(K , 1.);
53  DEFINE_UNIT(e , 1.);
60  DEFINE_UNIT_NAME(g_cm3 , 1., "g/cm3");
66 // length units
67  DEFINE_UNIT(km , Unit::cm * 1e5);
68  DEFINE_UNIT(m , Unit::cm * 1e2);
69  DEFINE_UNIT(mm , Unit::m * 1e-3);
70  DEFINE_UNIT(um , Unit::m * 1e-6);
71  DEFINE_UNIT(nm , Unit::m * 1e-9);
72  DEFINE_UNIT(pm , Unit::m * 1e-12);
73  DEFINE_UNIT(fm , Unit::m * 1e-15);
75 // area units
76  DEFINE_UNIT(m2 , Unit::m * Unit::m);
77  DEFINE_UNIT(cm2 , Unit::cm * Unit::cm);
78  DEFINE_UNIT(mm2 , Unit::mm * Unit::mm);
80  DEFINE_UNIT(b , Unit::m2 * 1e-28);
81  DEFINE_UNIT(mb , Unit::b * 1e-3);
82  DEFINE_UNIT(ub , Unit::b * 1e-6);
83  DEFINE_UNIT(nb , Unit::b * 1e-9);
84  DEFINE_UNIT(pb , Unit::b * 1e-12);
85  DEFINE_UNIT(fb , Unit::b * 1e-15);
86  DEFINE_UNIT(ab , Unit::b * 1e-18);
88 // volume units
89  DEFINE_UNIT(m3 , Unit::m * Unit::m * Unit::m);
90  DEFINE_UNIT(cm3 , Unit::cm * Unit::cm * Unit::cm);
91  DEFINE_UNIT(mm3 , Unit::mm * Unit::mm * Unit::mm);
93 // time units
94  DEFINE_UNIT(s , Unit::ns * 1e9);
95  DEFINE_UNIT(ms , Unit::s * 1e-3);
96  DEFINE_UNIT(us , Unit::s * 1e-6);
97  DEFINE_UNIT(ps , Unit::s * 1e-12);
98  DEFINE_UNIT(fs , Unit::s * 1e-15);
100 // frequency units
101  DEFINE_UNIT(Hz, Unit::GHz * 1e-9);
102  DEFINE_UNIT(kHz, Unit::GHz * 1e-6);
103  DEFINE_UNIT(MHz, Unit::GHz * 1e-3);
104  DEFINE_UNIT(mHz, Unit::GHz * 1e-12);
106 // angle units
107  DEFINE_UNIT(mrad , Unit::rad * 1e-3);
108  DEFINE_UNIT(deg , TMath::DegToRad());
110 // energy units
111  DEFINE_UNIT(eV , Unit::GeV * 1e-9);
112  DEFINE_UNIT(keV , Unit::eV * 1e3);
113  DEFINE_UNIT(MeV , Unit::eV * 1e6);
114  DEFINE_UNIT(TeV , Unit::eV * 1e12);
115  DEFINE_UNIT(J , 1.0 / TMath::Qe() * Unit::eV);
116  DEFINE_UNIT(V , Unit::eV / Unit::e);
118 // charge units
119  DEFINE_UNIT(C , 1.0 / TMath::Qe() * Unit::e);
120  DEFINE_UNIT(fC , Unit::C / 1.0e15);
122 // magnetic field units
123  DEFINE_UNIT(T , Unit::V * Unit::s / Unit::m2);
124  DEFINE_UNIT(mT , Unit::T * 1e-3);
125  DEFINE_UNIT(Gauss , Unit::T * 1e-4);
126  DEFINE_UNIT(kGauss , Unit::Gauss * 1e3);
128 // density units
129  DEFINE_UNIT_NAME(mg_cm3 , Unit::g_cm3 * 1e-3, "mg/cm3");
130  DEFINE_UNIT_NAME(kg_cm3 , Unit::g_cm3 * 1e3, "kg/cm3");
131  DEFINE_UNIT_NAME(g_mm3 , Unit::g_cm3 / Unit::mm3, "g/mm3");
132  DEFINE_UNIT_NAME(mg_mm3 , Unit::mg_cm3 / Unit::mm3, "mg/mm3");
133  DEFINE_UNIT_NAME(kg_mm3 , Unit::kg_cm3 / Unit::mm3, "kg/mm3");
136  double Unit::convertValue(double value, const std::string& unitString)
137  {
138  auto it = s_conversionFactors.find(unitString);
139  if (it == s_conversionFactors.end()) {
140  B2ERROR("Could not find conversion factor for unit " << unitString << ", assuming 1.0");
141  return value;
142  }
143  return it->second * value;
144  }
145 
146  double Unit::convertValueToUnit(double value, const std::string& unitString)
147  {
148  auto it = s_conversionFactors.find(unitString);
149  if (it == s_conversionFactors.end()) {
150  B2ERROR("Could not find conversion factor for unit " << unitString << ", assuming 1.0");
151  return value;
152  }
153  return value / it->second;
154  }
155 
156  double Unit::registerConversion(const string& name, double value)
157  {
158  if (!s_conversionFactors.insert(make_pair(name, value)).second) {
159  B2ERROR("Conversion factor for unit " << name << " already exists, ignoring");
160  }
161  return value;
162  }
163 
165 }
166 
167 /*** The implementation of the Const class defined in Const.h starts here ***/
168 
169 Const::DetectorSet operator + (const Const::DetectorSet& firstSet, const Const::DetectorSet& secondSet)
170 {
171  Const::DetectorSet set(firstSet);
172  set += secondSet;
173  return set;
174 }
175 
176 Const::DetectorSet operator - (const Const::DetectorSet& firstSet, const Const::DetectorSet& secondSet)
177 {
178  Const::DetectorSet set(firstSet);
179  set -= secondSet;
180  return set;
181 }
182 
183 Const::DetectorSet operator + (Const::EDetector firstDet, Const::EDetector secondDet)
184 {
185  Const::DetectorSet set(firstDet);
186  set += secondDet;
187  return set;
188 }
189 
190 unsigned short Const::DetectorSet::getBit(Const::EDetector det)
191 {
192  if (det == 0 || det > 0x100) {
193  B2ERROR("Const::DetectorSet::getBit() called for an invalid detector "
194  "identifier (possibly a subdetector):" << det);
195  return 0;
196  }
197  if (det > TEST) {
198  B2ERROR("Const::DetectorSet::getBit(): Invalid detector ID");
199  }
200  return (1 << (det - 1));
201 }
202 
203 Const::EDetector Const::DetectorSet::getDetector(unsigned short bit)
204 {
205  switch (bit) {
206  case 0x0001: return PXD;
207  case 0x0002: return SVD;
208  case 0x0004: return CDC;
209  case 0x0008: return TOP;
210  case 0x0010: return ARICH;
211  case 0x0020: return ECL;
212  case 0x0040: return KLM;
213  case 0x0080: return IR;
214  case 0x0100: return TRG;
215  case 0x0200: return DAQ;
216  case 0x0400: return BEAST;
217  case 0x0800: return TEST;
218  default: return invalidDetector;
219  }
220 }
221 
222 int Const::DetectorSet::getIndex(EDetector det) const
223 {
224  unsigned short bit = getBit(det);
225  if ((m_bits & bit) == 0) return -1;
226  int index = 0;
227  for (unsigned short setBit = 1; setBit < bit; setBit *= 2) {
228  if ((m_bits & setBit) != 0) ++index;
229  }
230  return index;
231 }
232 
233 Const::EDetector Const::DetectorSet::operator [](int index) const
234 {
235  if (index < 0) return Const::invalidDetector;
236  for (unsigned short setBit = 1; setBit < 0x1000; setBit *= 2) {
237  if ((m_bits & setBit) != 0) --index;
238  if (index < 0) return getDetector(setBit);
239  }
240  return Const::invalidDetector;
241 }
242 
243 size_t Const::DetectorSet::size() const
244 {
245  int size = 0;
246  for (unsigned short setBit = 1; setBit < 0x1000; setBit *= 2) {
247  if ((m_bits & setBit) != 0) ++size;
248  }
249  return size;
250 }
251 
252 std::string Const::DetectorSet::__repr__() const
253 {
254  std::string result = "<set: ";
255  std::string detectorNames[] = {"invalidDetector", "PXD", "SVD", "CDC", "TOP", "ARICH", "ECL", "KLM", "IR", "TRG", "DAQ", "BEAST", "TEST"};
256  for (size_t index = 1; index <= Const::TEST; index++) {
257  if (contains(EDetector(index))) {
258  if (result.size() > 6) {
259  result += ",";
260  }
261  result += detectorNames[index];
262  }
263  }
264  result += ">";
265  return result;
266 }
267 
268 
269 const Const::DetectorSet Const::VXDDetectors::c_set = Const::PXD + Const::SVD;
270 
271 const Const::DetectorSet Const::TrackingDetectors::c_set = Const::PXD + Const::SVD + Const::CDC;
272 
273 const Const::DetectorSet Const::PIDDetectors::c_set = Const::SVD + Const::CDC + Const::TOP + Const::ARICH + Const::ECL + Const::KLM;
274 
275 
276 const Const::DetectorSet Const::allDetectors = Const::IR + Const::PXD + Const::SVD + Const::CDC +
277  Const::TOP + Const::ARICH + Const::ECL + Const::KLM +
278  Const::TRG + Const::DAQ + Const::BEAST + Const::TEST;
279 
280 const Const::DetectorSet Const::ClusterDetectors::c_set = Const::ECL + Const::KLM;
281 
282 bool Const::ParticleType::operator < (const Const::ParticleType& other) const
283 {
284  return m_pdgCode < other.m_pdgCode;
285 }
286 
287 Const::ParticleType& Const::ParticleType::operator++()
288 {
289  if (!m_set) {
290  *this = invalidParticle;
291  } else {
292  m_pdgCode = m_set->at(++m_index).getPDGCode();
293  }
294 
295  return *this;
296 }
297 
298 Const::ParticleType Const::ParticleType::operator++(int)
299 {
300  Const::ParticleType p = *this;
301  ++(*this);
302  return p;
303 }
304 
305 const TParticlePDG* Const::ParticleType::getParticlePDG() const
306 {
307  return EvtGenDatabasePDG::Instance()->GetParticle(m_pdgCode);
308 }
309 
310 double Const::ParticleType::getMass() const
311 {
312  return getParticlePDG()->Mass();
313 }
314 
315 std::string Const::ParticleType::__repr__() const
316 {
317  std::string result = "<type: ";
318  result += getParticlePDG()->GetName();
319  result += ">";
320  return result;
321 }
322 
323 const Const::ParticleSet Const::chargedStableSet =
324  Const::ParticleType(11) + Const::ParticleType(13) + Const::ParticleType(211)
325  + Const::ParticleType(321) + Const::ParticleType(2212) + Const::ParticleType(1000010020);
326 
327 const Const::ParticleSet Const::clusterSet =
328  Const::ParticleType(22) + Const::ParticleType(130) + Const::ParticleType(11)
329  + Const::ParticleType(211) + Const::ParticleType(13) + Const::ParticleType(9900001);
330 
331 const Const::ChargedStable Const::electron = Const::chargedStableSet.find(11);
332 const Const::ChargedStable Const::muon = Const::chargedStableSet.find(13);
333 const Const::ChargedStable Const::pion = Const::chargedStableSet.find(211);
334 const Const::ChargedStable Const::kaon = Const::chargedStableSet.find(321);
335 const Const::ChargedStable Const::proton = Const::chargedStableSet.find(2212);
336 const Const::ChargedStable Const::deuteron = Const::chargedStableSet.find(1000010020);
337 
338 const Const::Cluster Const::clusterphoton = Const::clusterSet.find(22);
339 const Const::Cluster Const::clusterKlong = Const::clusterSet.find(130);
340 const Const::Cluster Const::clusterelectron = Const::clusterSet.find(11);
341 const Const::Cluster Const::clusterpion = Const::clusterSet.find(211);
342 const Const::Cluster Const::clustermuon = Const::clusterSet.find(13);
343 const Const::Cluster Const::clusterjunk = Const::clusterSet.find(9900001);
344 
345 const Const::ParticleType Const::photon = Const::ParticleType(22);
346 const Const::ParticleType Const::pi0 = Const::ParticleType(111);
347 const Const::ParticleType Const::neutron = Const::ParticleType(2112);
348 const Const::ParticleType Const::Kshort = Const::ParticleType(310);
349 const Const::ParticleType Const::Klong = Const::ParticleType(130);
350 const Const::ParticleType Const::Lambda = Const::ParticleType(3122);
351 const Const::ParticleType Const::antiLambda = Const::ParticleType(-3122);
352 const Const::ParticleType Const::invalidParticle = Const::ParticleType(9900000); // codes beginning with 99... are reserved
353 const Const::ParticleType Const::unspecifiedParticle = Const::ParticleType(9900001); // codes beginning with 99... are reserved
354 
355 const double Const::electronMass = Const::electron.getMass();
356 const double Const::muonMass = Const::muon.getMass();
357 const double Const::pionMass = Const::pion.getMass();
358 const double Const::kaonMass = Const::kaon.getMass();
359 const double Const::protonMass = Const::proton.getMass();
360 const double Const::deuteronMass = Const::deuteron.getMass();
361 const double Const::pi0Mass = Const::pi0.getMass();
362 const double Const::neutronMass = Const::neutron.getMass();
363 const double Const::K0Mass = Const::Kshort.getMass();
364 
365 void Const::ParticleSet::add(const Const::ParticleType& p)
366 {
367  if (contains(p))
368  return;
369  m_particles.emplace_back(p.getPDGCode(), this, m_particles.size());
370 }
371 
372 bool Const::ParticleSet::contains(const Const::ParticleType& p) const
373 {
374  return (std::find(m_particles.begin(), m_particles.end(), p) != m_particles.end());
375 }
376 
377 Const::ParticleSet operator + (const Const::ParticleSet& firstSet, const Const::ParticleSet& secondSet)
378 {
379  Const::ParticleSet result(firstSet);
380  for (Const::ParticleType pdgIter = secondSet.begin(); pdgIter != secondSet.end(); ++pdgIter) {
381  result.add(pdgIter);
382  }
383  return result;
384 }
385 
386 
387 const double Const::speedOfLight = 29.9792458;
388 const double Const::kBoltzmann = 8.617343 * 1.0e-5 * Unit::eV / Unit::K;
389 const double Const::ehEnergy = 3.65 * Unit::eV;
390 const double Const::fineStrConst = 1.0 / 137.036;
391 const double Const::permSi = 11.9 * 8.8542 * 1e-18 * Unit::C / Unit::V / Unit::um;
392 const double Const::uTherm = 0.026 * Unit::V;
393 const double Const::eMobilitySi = 1415 * Unit::cm2 / Unit::V / Unit::s;
Belle2::Const::TrackingDetectors::c_set
static const DetectorSet c_set
The set of valid tracking detectors.
Definition: Const.h:239
Belle2::Unit::s
static const double s
[second]
Definition: Unit.h:105
Belle2::Const::DetectorSet::__repr__
std::string __repr__() const
String for printing in python.
Definition: UnitConst.cc:252
Belle2::Unit::cm
static const double cm
Standard units with the value = 1.
Definition: Unit.h:57
Belle2::Const::photon
static const ParticleType photon
photon particle
Definition: Const.h:547
Belle2::Unit::ns
static const double ns
Standard of [time].
Definition: Unit.h:58
Belle2::Const::ClusterDetectors::c_set
static const DetectorSet c_set
The set of valid tracking detectors.
Definition: Const.h:264
Belle2::Const::unspecifiedParticle
static const ParticleType unspecifiedParticle
Unspecified particle, used when no other particle type fits.
Definition: Const.h:556
Belle2::Const::uTherm
static const double uTherm
Thermal Voltage at room temperature.
Definition: Const.h:573
Belle2::Const::invalidParticle
static const ParticleType invalidParticle
Invalid particle, used internally.
Definition: Const.h:554
Belle2::Const::Kshort
static const ParticleType Kshort
K^0_S particle.
Definition: Const.h:550
Belle2::Const::ParticleType::operator++
ParticleType & operator++()
Prefix increment.
Definition: UnitConst.cc:287
Belle2::Const::electron
static const ChargedStable electron
electron particle
Definition: Const.h:533
Belle2::Const::Klong
static const ParticleType Klong
K^0_L particle.
Definition: Const.h:551
Belle2::Unit::mm3
static const double mm3
[cubic millimeters]
Definition: Unit.h:102
Belle2::Const::kBoltzmann
static const double kBoltzmann
Boltzmann constant in GeV/K.
Definition: Const.h:569
Belle2::Const::clusterjunk
static const Cluster clusterjunk
junk cluster
Definition: Const.h:545
Belle2::Const::chargedStableSet
static const ParticleSet chargedStableSet
set of charged stable particles
Definition: Const.h:494
Belle2::Const::ParticleType::getPDGCode
int getPDGCode() const
PDG code.
Definition: Const.h:349
Belle2::Const::clusterelectron
static const Cluster clusterelectron
electron cluster
Definition: Const.h:542
Belle2::Const::DetectorSet
The DetectorSet class for sets of detector IDs in the form of EDetector values.
Definition: Const.h:66
Belle2::Const::DetectorSet::getBit
static unsigned short getBit(EDetector det)
Conversion of detector ID to bit pattern.
Definition: UnitConst.cc:190
Belle2::Const::VXDDetectors::c_set
static const DetectorSet c_set
The set of valid tracking detectors.
Definition: Const.h:227
Belle2::Const::eMobilitySi
static const double eMobilitySi
Electron mobility in intrinsic Silicon at room temperature.
Definition: Const.h:574
Belle2::Const::ParticleSet
A set of ParticleType objects, with defined order.
Definition: Const.h:393
Belle2::Const::deuteronMass
static const double deuteronMass
deuteron mass
Definition: Const.h:563
Belle2::Const::permSi
static const double permSi
Permittivity of Silicon.
Definition: Const.h:572
Belle2::DEFINE_UNIT_NAME
DEFINE_UNIT_NAME(g_cm3, 1., "g/cm3")
Practical units with the value = 1.
Belle2::Const::EDetector
EDetector
Enum for identifying the detector components (detector and subdetector).
Definition: Const.h:44
Belle2::Unit::GHz
static const double GHz
Standard of [frequency].
Definition: Unit.h:59
Belle2::Const::electronMass
static const double electronMass
electron mass
Definition: Const.h:558
Belle2::Unit::s_conversionFactors
static std::map< std::string, double > s_conversionFactors
Map to be able to convert between units using string representations of the unit name.
Definition: Unit.h:173
Belle2::Const::clustermuon
static const Cluster clustermuon
muon cluster
Definition: Const.h:544
Belle2::Const::kaon
static const ChargedStable kaon
charged kaon particle
Definition: Const.h:536
Belle2::Unit::rad
static const double rad
Standard of [angle].
Definition: Unit.h:60
Belle2::Unit::convertValue
static double convertValue(double value, const std::string &unitString)
Converts a floating point value to the standard framework unit.
Definition: UnitConst.cc:136
Belle2::Const::neutronMass
static const double neutronMass
neutron mass
Definition: Const.h:565
Belle2::Const::clusterKlong
static const Cluster clusterKlong
K^0_L cluster.
Definition: Const.h:541
Belle2::Const::ParticleSet::contains
bool contains(const ParticleType &p) const
Returns true if and only if the set contains 'p'.
Definition: UnitConst.cc:372
Belle2::Const::speedOfLight
static const double speedOfLight
[cm/ns]
Definition: Const.h:568
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition: Const.h:535
Belle2::Unit::T
static const double T
[tesla]
Definition: Unit.h:130
Belle2::Unit::eV
static const double eV
[electronvolt]
Definition: Unit.h:122
Belle2::Const::allDetectors
static const DetectorSet allDetectors
The set of all detectors.
Definition: Const.h:274
Belle2::DEFINE_UNIT
DEFINE_UNIT(cm, 1.)
Standard units with the value = 1.
Belle2::Const::ParticleSet::add
void add(const ParticleType &p)
Add a copy of the given ParticleType to this set.
Definition: UnitConst.cc:365
Belle2::Const::Cluster
Provides a type-safe way to pass members of the clusterSet set.
Definition: Const.h:502
Belle2::Const::ParticleSet::begin
ParticleType begin() const
Returns first particle.
Definition: Const.h:433
Belle2::Const::ParticleSet::find
const ParticleType & find(int pdg) const
Returns particle in set with given PDG code, or invalidParticle if not found.
Definition: Const.h:447
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::Unit::kg_cm3
static const double kg_cm3
[kg/cm^3]
Definition: Unit.h:141
Belle2::Const::deuteron
static const ChargedStable deuteron
deuteron particle
Definition: Const.h:538
Belle2::Const::PIDDetectors::c_set
static const DetectorSet c_set
The set of valid PID detectors.
Definition: Const.h:251
Belle2::operator-
B2Vector3< DataType > operator-(const TVector3 &a, const B2Vector3< DataType > &b)
non-memberfunction for substracting a TVector3 from a B2Vector3
Definition: B2Vector3.h:542
Belle2::Const::DetectorSet::operator[]
EDetector operator[](int index) const
Accessor for a detector ID in this set.
Definition: UnitConst.cc:233
Belle2::Const::pi0
static const ParticleType pi0
neutral pion particle
Definition: Const.h:548
Belle2::Unit::Gauss
static const double Gauss
[gauss]
Definition: Unit.h:132
Belle2::operator+
B2Vector3< DataType > operator+(const TVector3 &a, const B2Vector3< DataType > &b)
non-memberfunction for adding a TVector3 to a B2Vector3
Definition: B2Vector3.h:535
Belle2::Const::protonMass
static const double protonMass
proton mass
Definition: Const.h:562
Belle2::Const::antiLambda
static const ParticleType antiLambda
Anti-Lambda particle.
Definition: Const.h:553
Belle2::Const::neutron
static const ParticleType neutron
neutron particle
Definition: Const.h:549
Belle2::Unit::convertValueToUnit
static double convertValueToUnit(double value, const std::string &unitString)
Converts a floating point value from the standard framework unit to the given unit.
Definition: UnitConst.cc:146
Belle2::Unit::m
static const double m
[meters]
Definition: Unit.h:79
Belle2::Unit::b
static const double b
[barn]
Definition: Unit.h:91
Belle2::Const::ParticleType::m_pdgCode
int m_pdgCode
PDG code of the particle.
Definition: Const.h:363
Belle2::Const::pionMass
static const double pionMass
charged pion mass
Definition: Const.h:560
Belle2::Const::kaonMass
static const double kaonMass
charged kaon mass
Definition: Const.h:561
Belle2::TEST
TEST(TestgetDetectorRegion, TestgetDetectorRegion)
Test Constructors.
Definition: utilityFunctions.cc:18
Belle2::Unit::registerConversion
static double registerConversion(const std::string &name, double value)
registers the name and value of a conversion in s_conversionFactors.
Definition: UnitConst.cc:156
Belle2::Const::DetectorSet::getDetector
static EDetector getDetector(unsigned short bit)
Conversion of bit pattern to detector ID.
Definition: UnitConst.cc:203
Belle2::Const::ParticleSet::end
ParticleType end() const
Returns an invalid particle to check if iteration should be stopped.
Definition: Const.h:441
Belle2::Const::ParticleType::operator<
bool operator<(const ParticleType &other) const
Comparison operator to be usable in sets.
Definition: UnitConst.cc:282
Belle2::Const::K0Mass
static const double K0Mass
neutral kaon mass
Definition: Const.h:566
Belle2::Unit::mg_cm3
static const double mg_cm3
[mg/cm^3]
Definition: Unit.h:140
Belle2::Unit::mm
static const double mm
[millimeters]
Definition: Unit.h:80
Belle2::Const::clusterpion
static const Cluster clusterpion
charged hadron cluster
Definition: Const.h:543
Belle2::Const::ParticleType
The ParticleType class for identifying different particle types.
Definition: Const.h:284
Belle2::Const::proton
static const ChargedStable proton
proton particle
Definition: Const.h:537
Belle2::Const::ChargedStable
Provides a type-safe way to pass members of the chargedStableSet set.
Definition: Const.h:465
Belle2::Unit::K
static const double K
Standard of [temperature].
Definition: Unit.h:62
Belle2::Const::muonMass
static const double muonMass
muon mass
Definition: Const.h:559
Belle2::Const::muon
static const ChargedStable muon
muon particle
Definition: Const.h:534
Belle2::Const::clusterphoton
static const Cluster clusterphoton
photon cluster
Definition: Const.h:540
Belle2::Unit::C
static const double C
[coulomb]
Definition: Unit.h:136
Belle2::Unit::cm2
static const double cm2
[square centimeters]
Definition: Unit.h:88
Belle2::Const::DetectorSet::getIndex
int getIndex(EDetector det) const
Getter for the index of a given detector in this set.
Definition: UnitConst.cc:222
Belle2::Const::DetectorSet::size
size_t size() const
Getter for number of detector IDs in this set.
Definition: UnitConst.cc:243
Belle2::Const::fineStrConst
static const double fineStrConst
The fine structure constant.
Definition: Const.h:571
Belle2::Unit::GeV
static const double GeV
Standard of [energy, momentum, mass].
Definition: Unit.h:61
Belle2::Const::ParticleType::__repr__
std::string __repr__() const
String for printing in python.
Definition: UnitConst.cc:315
Belle2::Unit::m2
static const double m2
[square meters]
Definition: Unit.h:87
Belle2::Unit::e
static const double e
Standard of [electric charge].
Definition: Unit.h:63
Belle2::Unit::g_cm3
static const double g_cm3
Practical units with the value set at 1.
Definition: Unit.h:70
Belle2::EvtGenDatabasePDG::Instance
static EvtGenDatabasePDG * Instance()
Instance method that loads the EvtGen table.
Definition: EvtGenDatabasePDG.cc:27
Belle2::Const::Lambda
static const ParticleType Lambda
Lambda particle.
Definition: Const.h:552
Belle2::Const::ParticleType::getParticlePDG
const TParticlePDG * getParticlePDG() const
Accessor for ROOT TParticlePDG object.
Definition: UnitConst.cc:305
Belle2::Const::ehEnergy
static const double ehEnergy
Energy needed to create an electron-hole pair in Si at std.
Definition: Const.h:570
Belle2::Unit::um
static const double um
[micrometers]
Definition: Unit.h:81
Belle2::Unit::V
static const double V
[voltage]
Definition: Unit.h:127
Belle2::Const::clusterSet
static const ParticleSet clusterSet
set of cluster particles
Definition: Const.h:531
Belle2::Const::ParticleType::getMass
double getMass() const
Particle mass.
Definition: UnitConst.cc:310
Belle2::Const::pi0Mass
static const double pi0Mass
neutral pion mass
Definition: Const.h:564