IAP GITLAB

Skip to content
Snippets Groups Projects
Commit 91fdc3e6 authored by Maximilian Reininghaus's avatar Maximilian Reininghaus :vulcan: Committed by ralfulrich
Browse files

ParticleProperties

parent 0c883651
No related branches found
No related tags found
1 merge request!280Refactory 2020
Hide whitespace changes
Inline Side-by-side
corsika/framework/core/ParticleProperties.hpp
+ 60
− 71
View file @ 91fdc3e6
......@@ -16,6 +16,7 @@
#include <array>
#include <cstdint>
#include <cmath>
#include <iosfwd>
#include <corsika/framework/core/PhysicalUnits.hpp>
......@@ -28,7 +29,6 @@
*/
namespace corsika {
/**
* @enum Code
* The Code enum is the actual place to define CORSIKA 8 particle codes.
......@@ -39,126 +39,115 @@ namespace corsika {
using PDGCodeType = std::underlying_type<PDGCode>::type;
// forward declarations to be used in GeneratedParticleProperties
int16_t constexpr GetChargeNumber(Code const);
ElectricChargeType constexpr GetCharge(Code const);
HEPMassType constexpr GetMass(Code const);
PDGCode constexpr GetPDG(Code const);
constexpr std::string const& GetName(Code const);
TimeType constexpr GetLifetime(Code const);
bool constexpr IsNucleus(Code const);
bool constexpr IsHadron(Code const);
bool constexpr IsEM(Code const);
bool constexpr IsMuon(Code const);
bool constexpr IsNeutrino(Code const);
int constexpr GetNucleusA(Code const);
int constexpr GetNucleusZ(Code const);
int16_t constexpr charge_number(Code const); //!< electric charge in units of e
ElectricChargeType constexpr charge(Code const); //!< electric charge
HEPMassType constexpr mass(Code const); //!< mass
//! Particle code according to PDG, "Monte Carlo Particle Numbering Scheme"
PDGCode constexpr PDG(Code const);
constexpr std::string const& name(Code const); //!< name of the particle as string
TimeType constexpr lifetime(Code const); //!< lifetime
//! true iff the particle is a hard-coded nucleus or Code::Nucleus
bool constexpr is_nucleus(Code const);
bool constexpr is_hadron(Code const); //!< true iff particle is hadron
bool constexpr is_em(Code const); //!< true iff particle is electron, positron or gamma
bool constexpr is_muon(Code const); //!< true iff particle is mu+ or mu-
bool constexpr is_neutrino(Code const); //!< true iff particle is (anti-) neutrino
int constexpr nucleus_A(Code const); //!< returns A for hard-coded nucleus, otherwise 0
int constexpr nucleus_Z(Code const); //!< returns Z for hard-coded nucleus, otherwise 0
} // namespace corsika
#include <corsika/framework/core/GeneratedParticleProperties.inc>
namespace corsika::particles {
namespace corsika {
/*!
* returns mass of particle in natural units
*/
HEPMassType constexpr GetMass(Code const p) {
HEPMassType constexpr 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)];
}
/*!
* returns PDG id
*/
PDGCode constexpr GetPDG(Code const p) {
PDGCode constexpr PDG(Code const p) {
return particle::detail::pdg_codes[static_cast<CodeIntType>(p)];
}
/*!
* returns electric charge number of particle return 1 for a proton.
*/
int16_t constexpr GetChargeNumber(Code const p) {
if (p == Code::Nucleus)
throw std::runtime_error(
"Cannot GetChargeNumber() of particle::Nucleus -> unspecified");
// electric_charges stores charges in units of (e/3), e.g. 3 for a proton
return particle::detail::electric_charges[static_cast<CodeIntType>(p)] / 3;
int16_t constexpr 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)];
}
/*!
* returns electric charge of particle, e.g. return 1.602e-19_C for a proton.
*/
ElectricChargeType constexpr GetCharge(Code const p) {
if (p == Code::Nucleus)
ElectricChargeType constexpr charge(Code const code) {
if (code == Code::Nucleus)
throw std::runtime_error("Cannot GetCharge() of particle::Nucleus -> unspecified");
return GetChargeNumber(p) * constants::e;
return charge_number(code) * constants::e;
}
constexpr std::string const& GetName(Code const p) {
return particle::detail::names[static_cast<CodeIntType>(p)];
constexpr std::string const& name(Code const code) {
return particle::detail::names[static_cast<CodeIntType>(code)];
}
inline TimeType constexpr GetLifetime(Code const p) {
TimeType constexpr lifetime(Code const p) {
return particle::detail::lifetime[static_cast<CodeIntType>(p)] * second;
}
inline bool constexpr IsHadron(Code const p) {
bool constexpr is_hadron(Code const p) {
return particle::detail::isHadron[static_cast<CodeIntType>(p)];
}
inline bool constexpr IsEM(Code c) {
bool constexpr is_em(Code c) {
return c == Code::Electron || c == Code::Positron || c == Code::Gamma;
}
inline bool constexpr IsMuon(Code c) { return c == Code::MuPlus || c == Code::MuMinus; }
bool constexpr is_muon(Code c) { return c == Code::MuPlus || c == Code::MuMinus; }
inline bool constexpr IsNeutrino(Code c) {
bool constexpr is_neutrino(Code c) {
return c == Code::NuE || c == Code::NuMu || c == Code::NuTau || c == Code::NuEBar ||
c == Code::NuMuBar || c == Code::NuTauBar;
}
inline int constexpr GetNucleusA(Code const p) {
if (p == Code::Nucleus) {
throw std::runtime_error("GetNucleusA(Code::Nucleus) is impossible!");
int constexpr 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>(p)];
return particle::detail::nucleusA[static_cast<CodeIntType>(code)];
}
inline int constexpr GetNucleusZ(Code const p) {
if (p == Code::Nucleus) {
throw std::runtime_error("GetNucleusZ(Code::Nucleus) is impossible!");
int constexpr nucleus_Z(Code const code) {
if (code == Code::Nucleus) {
throw std::runtime_error("nucleus_Z(Code::Nucleus) is impossible!");
}
return particle::detail::nucleusZ[static_cast<CodeIntType>(p)];
return particle::detail::nucleusZ[static_cast<CodeIntType>(code)];
}
inline bool constexpr IsNucleus(Code const p) {
return (p == Code::Nucleus) || (GetNucleusA(p) != 0);
bool constexpr is_nucleus(Code const code) {
return (code == Code::Nucleus) || (nucleus_A(code) != 0);
}
/**
* the output operator for humand-readable particle codes
**/
inline std::ostream& operator<<(std::ostream& stream, corsika::Code const p) {
return stream << corsika::GetName(p);
//! the output stream operator for human-readable particle codes
inline std::ostream& operator<<(std::ostream& stream, corsika::Code const code) {
return stream << name(code);
}
inline Code ConvertFromPDG(PDGCode p) {
//! convert PDG code to CORSIKA 8 internal code
inline Code convert_from_PDG(PDGCode p) {
static_assert(particle::detail::conversionArray.size() % 2 == 1);
// this will fail, for the strange case where the maxPDG is negative...
unsigned int constexpr maxPDG{(particle::detail::conversionArray.size() - 1) >> 1};
auto k = static_cast<PDGCodeType>(p);
if ((unsigned int)abs(k) <= maxPDG) {
int constexpr maxPDG{(particle::detail::conversionArray.size() - 1) >> 1};
auto const k = static_cast<PDGCodeType>(p);
if (std::abs(k) <= maxPDG) {
return particle::detail::conversionArray[k + maxPDG];
} else {
return particle::detail::conversionMap.at(p);
}
}
/**
* Get mass of nucleus
**/
inline HEPMassType constexpr GetNucleusMass(const int vA, const int vZ) {
return Proton::GetMass() * vZ + (vA - vZ) * Neutron::GetMass();
//! returns mass of (A,Z) nucleus, disregarding binding energy
HEPMassType constexpr nucleus_mass(const int A, const int Z) {
auto const absA = std::abs(A);
auto const absZ = std::abs(Z);
return Proton::mass() * absZ + (absA - absZ) * Neutron::mass();
}
} // namespace corsika
src/framework/core/pdxml_reader.py
+ 17
− 16
View file @ 91fdc3e6
......@@ -346,7 +346,7 @@ def gen_properties(particle_db):
# electric charges table
string += "static constexpr std::array<int16_t, size> electric_charges = {\n"
for p in particle_db.values():
string += " {charge:d},\n".format(charge = p['electric_charge'])
string += " {charge:d},\n".format(charge = p['electric_charge'] // 3)
string += "};\n"
# anti-particle table
......@@ -416,7 +416,7 @@ def gen_classes(particle_db):
string += " * Particle properties are taken from the PYTHIA8 ParticleData.xml file:<br>\n"
string += " * - pdg=" + str(particle_db[cname]['pdg']) +"\n"
string += " * - mass=" + str(particle_db[cname]['mass']) + " GeV \n"
string += " * - charge= " + str(particle_db[cname]['electric_charge']/3) + " \n"
string += " * - charge= " + str(particle_db[cname]['electric_charge'] // 3) + " \n"
string += " * - name=" + str(cname) + "\n"
string += " * - anti=" + str(antiP) + "\n"
if (particle_db[cname]['isNucleus']):
......@@ -425,19 +425,18 @@ def gen_classes(particle_db):
string += "*/\n\n"
string += "class " + cname + " {\n"
string += " public:\n"
string += " static constexpr Code GetCode() { return Type; }\n"
string += " static constexpr corsika::units::si::HEPMassType GetMass() { return corsika::GetMass(Type); }\n"
string += " static constexpr corsika::units::si::ElectricChargeType GetCharge() { return corsika::GetCharge(Type); }\n"
string += " static constexpr int16_t GetChargeNumber() { return corsika::GetChargeNumber(Type); }\n"
string += " static std::string const& GetName() { return corsika::GetName(Type); }\n"
string += " static constexpr Code GetAntiParticle() { return AntiType; }\n"
string += " static constexpr bool IsNucleus() { return corsika::IsNucleus(Type); }\n"
string += " static constexpr int16_t GetNucleusA() { return corsika::GetNucleusA(Type); }\n"
string += " static constexpr int16_t GetNucleusZ() { return corsika::GetNucleusZ(Type); }\n"
string += " static constexpr Code Type = Code::" + cname + ";\n"
string += " static constexpr Code AntiType = Code::" + antiP + ";\n"
string += " " + cname + "() = delete;\n"
string += " static constexpr Code code = Code::" + cname + ";\n"
string += " static constexpr HEPMassType mass() {return corsika::mass(code);}\n"
string += " static constexpr ElectricChargeType charge() { return corsika::charge(code); }\n"
string += " static constexpr int16_t charge_number() { return corsika::charge_number(code); }\n"
string += " static std::string const& name() { return corsika::name(code); }\n"
string += " static constexpr bool is_nucleus() { return corsika::is_nucleus(code); }\n"
string += " static constexpr int16_t nucleus_A() { return corsika::nucleus_A(code); }\n"
string += " static constexpr int16_t nucleus_Z() { return corsika::nucleus_Z(code); }\n"
string += " static constexpr Code anti_code = Code::" + antiP + ";\n"
string += " private:\n"
string += " static constexpr CodeIntType TypeIndex = static_cast<CodeIntType const>(Type);\n"
string += " static constexpr CodeIntType TypeIndex = static_cast<CodeIntType>(code);\n"
string += "};\n"
return string
......@@ -448,7 +447,9 @@ def gen_classes(particle_db):
#
def inc_start():
string = ('// generated by pdxml_reader.py\n'
'// MANUAL EDITS ON OWN RISK. THEY WILL BE OVERWRITTEN. \n')
'// MANUAL EDITS ON OWN RISK. THEY WILL BE OVERWRITTEN. \n'
'\n'
'namespace corsika {\n')
return string
......@@ -471,7 +472,7 @@ def detail_end():
#
#
def inc_end():
string = ""
string = "} // end namespace corsika"
return string
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

data privacy - impressum