get

corsika/detail/framework/core/ParticleProperties.inl

@@ -13,31 +13,31 @@
 
 namespace corsika {
 
-  HEPMassType constexpr mass(Code const p) {
+  HEPMassType constexpr get_mass(Code const p) {
     if (p == Code::Nucleus)
       throw std::runtime_error("Cannot GetMass() of particle::Nucleus -> unspecified");
     return particle::detail::masses[static_cast<CodeIntType>(p)];
   }
 
-  PDGCode constexpr PDG(Code const p) {
+  PDGCode constexpr get_PDG(Code const p) {
     return particle::detail::pdg_codes[static_cast<CodeIntType>(p)];
   }
 
-  int16_t constexpr charge_number(Code const code) {
+  int16_t constexpr get_charge_number(Code const code) {
     if (code == Code::Nucleus)
       throw std::runtime_error("charge of particle::Nucleus undefined");
     return particle::detail::electric_charges[static_cast<CodeIntType>(code)];
   }
 
-  ElectricChargeType constexpr charge(Code const code) {
+  ElectricChargeType constexpr get_charge(Code const code) {
     return charge_number(code) * constants::e;
   }
 
-  constexpr std::string const& name(Code const code) {
+  constexpr std::string const& get_name(Code const code) {
     return particle::detail::names[static_cast<CodeIntType>(code)];
   }
 
-  TimeType constexpr lifetime(Code const p) {
+  TimeType constexpr get_lifetime(Code const p) {
     return particle::detail::lifetime[static_cast<CodeIntType>(p)] * second;
   }
 
@@ -56,14 +56,14 @@ namespace corsika {
            c == Code::NuMuBar || c == Code::NuTauBar;
   }
 
-  int constexpr nucleus_A(Code const code) {
+  int constexpr get_nucleus_A(Code const code) {
     if (code == Code::Nucleus) {
       throw std::runtime_error("nucleus_A(Code::Nucleus) is impossible!");
     }
     return particle::detail::nucleusA[static_cast<CodeIntType>(code)];
   }
 
-  int constexpr nucleus_Z(Code const code) {
+  int constexpr get_nucleus_Z(Code const code) {
     if (code == Code::Nucleus) {
       throw std::runtime_error("nucleus_Z(Code::Nucleus) is impossible!");
     }

corsika/framework/core/ParticleProperties.hpp

@@ -39,23 +39,23 @@ namespace corsika {
   using PDGCodeType = std::underlying_type<PDGCode>::type;
 
   // forward declarations to be used in GeneratedParticleProperties
-  int16_t constexpr charge_number(Code);     //!< electric charge in units of e
-  ElectricChargeType constexpr charge(Code); //!< electric charge
-  HEPMassType constexpr mass(Code);          //!< mass
+  int16_t constexpr get_charge_number(Code);     //!< electric charge in units of e
+  ElectricChargeType constexpr get_charge(Code); //!< electric charge
+  HEPMassType constexpr get_mass(Code);          //!< mass
 
   //! Particle code according to PDG, "Monte Carlo Particle Numbering Scheme"
-  PDGCode constexpr PDG(Code);
-  constexpr std::string const& name(Code); //!< name of the particle as string
-  TimeType constexpr lifetime(Code);       //!< lifetime
+  PDGCode constexpr get_PDG(Code);
+  constexpr std::string const& get_name(Code); //!< name of the particle as string
+  TimeType constexpr get_lifetime(Code);       //!< lifetime
 
   //! true iff the particle is a hard-coded nucleus or Code::Nucleus
   bool constexpr is_nucleus(Code);
-  bool constexpr is_hadron(Code);   //!< true iff particle is hadron
-  bool constexpr is_em(Code);       //!< true iff particle is electron, positron or gamma
-  bool constexpr is_muon(Code);     //!< true iff particle is mu+ or mu-
-  bool constexpr is_neutrino(Code); //!< true iff particle is (anti-) neutrino
-  int constexpr nucleus_A(Code);    //!< returns A for hard-coded nucleus, otherwise 0
-  int constexpr nucleus_Z(Code);    //!< returns Z for hard-coded nucleus, otherwise 0
+  bool constexpr is_hadron(Code);    //!< true iff particle is hadron
+  bool constexpr is_em(Code);        //!< true iff particle is electron, positron or gamma
+  bool constexpr is_muon(Code);      //!< true iff particle is mu+ or mu-
+  bool constexpr is_neutrino(Code);  //!< true iff particle is (anti-) neutrino
+  int constexpr get_nucleus_A(Code); //!< returns A for hard-coded nucleus, otherwise 0
+  int constexpr get_nucleus_Z(Code); //!< returns Z for hard-coded nucleus, otherwise 0
 
   //! returns mass of (A,Z) nucleus, disregarding binding energy
   inline HEPMassType nucleus_mass(int, int);

tests/framework/testParticles.cpp

@@ -26,7 +26,7 @@ TEST_CASE("ParticleProperties", "[Particles]") {
 
   SECTION("Masses") {
     REQUIRE(Electron::mass / (511_keV) == Approx(1));
-    REQUIRE(Electron::mass / mass(Code::Electron) == 1.);
+    REQUIRE(Electron::mass / get_mass(Code::Electron) == 1.);
 
     REQUIRE((Proton::mass + Neutron::mass) / constants::nucleonMass == Approx(2));
   }
@@ -34,11 +34,12 @@ TEST_CASE("ParticleProperties", "[Particles]") {
   SECTION("Charges") {
     REQUIRE(Electron::charge / constants::e == Approx(-1));
     REQUIRE(Positron::charge / constants::e == Approx(+1));
-    REQUIRE(charge(Positron::anti_code) / constants::e == Approx(-1));
+    REQUIRE(get_charge(Positron::anti_code) / constants::e == Approx(-1));
   }
 
   SECTION("Names") {
     REQUIRE(Electron::name == "e-");
+    REQUIRE(get_name(Code::Electron) == "e-");
     REQUIRE(PiMinus::name == "pi-");
     REQUIRE(Iron::name == "iron");
   }
@@ -64,14 +65,14 @@ TEST_CASE("ParticleProperties", "[Particles]") {
   }
 
   SECTION("Lifetimes") {
-    REQUIRE(lifetime(Code::Electron) ==
+    REQUIRE(get_lifetime(Code::Electron) ==
             std::numeric_limits<double>::infinity() * si::second);
-    REQUIRE(lifetime(Code::DPlus) < lifetime(Code::Gamma));
-    REQUIRE(lifetime(Code::RhoPlus) / si::second ==
+    REQUIRE(get_lifetime(Code::DPlus) < lifetime(Code::Gamma));
+    REQUIRE(get_lifetime(Code::RhoPlus) / si::second ==
             (Approx(4.414566727909413e-24).epsilon(1e-3)));
-    REQUIRE(lifetime(Code::SigmaMinusBar) / si::second ==
+    REQUIRE(get_lifetime(Code::SigmaMinusBar) / si::second ==
             (Approx(8.018880848563575e-11).epsilon(1e-5)));
-    REQUIRE(lifetime(Code::MuPlus) / si::second ==
+    REQUIRE(get_lifetime(Code::MuPlus) / si::second ==
             (Approx(2.1970332555864364e-06).epsilon(1e-5)));
   }
 
@@ -131,12 +132,12 @@ TEST_CASE("ParticleProperties", "[Particles]") {
     REQUIRE(Argon::is_nucleus);
     REQUIRE_FALSE(EtaC::is_nucleus);
 
-    REQUIRE(nucleus_A(Code::Hydrogen) == 1);
-    REQUIRE(nucleus_A(Code::Tritium) == 3);
+    REQUIRE(get_nucleus_A(Code::Hydrogen) == 1);
+    REQUIRE(get_nucleus_A(Code::Tritium) == 3);
     REQUIRE(Hydrogen::nucleus_Z == 1);
     REQUIRE(Tritium::nucleus_A == 3);
 
-    REQUIRE_THROWS(nucleus_Z(Code::Nucleus));
-    REQUIRE_THROWS(nucleus_A(Code::Nucleus));
+    REQUIRE_THROWS(get_nucleus_Z(Code::Nucleus));
+    REQUIRE_THROWS(get_nucleus_A(Code::Nucleus));
   }
 }