#include <pdgcode.h>

PdgCode stores a Particle Data Group Particle Numbering Scheme particle type number.

See also: http://pdg.lbl.gov/2014/reviews/rpp2014-rev-monte-carlo-numbering.pdf

Usage:

#include "include/pdgcode.h"
 
// initialize with an integer: make sure it is hex-encoded!
PdgCode pi_plus(0x211);
// you can also initialize from a string:
PdgCode pi_minus("-211");
// initialize a PDG Code that knows it is not set yet:
PdgCode other_particle();
// this is true:
if (other_particle == PdgCode::invalid()) {
  printf("Invalid particle! Please enter PDG Code: ");
  // fill from stringstream:
  std::cin >> other_particle;
}
// is this a Kaon?
if (other_particle.code() == 0x311) {
  printf("The particle is a K plus\n");
}
// what baryon number does the particle have?
printf("The particle has a baryon number of %d\n",
                                          other_particle.baryon_number());

This class contains a collection of smart accessors to the PDG code so that quantum numbers etc can easily be read off.

Internals

The content is stored in hexadecimal digits, i.e., the number '545' is interpreted as '0x221', i.e., an eta-meson. To check if a given particle is of a given type, make sure that you give the type in hex digits as well (see example above).

The reason for that is that the concept of PdgCodes, especially for Hadrons, is not one of wholesale numbers, but one of concatenated digits. Using hexadecimally interpreted digits makes it numerically very easy to access the separate digits (there's no arithmetic involved with successive divisions by 10 and taking the remainder etc.).

Representing nuclei

Following PDG standard, nuclei are represented by codes ±10LZZZAAAI, where L is number of Lambdas inside the nucleus, ZZZ is charge, AAA is mass number and I is used for excitations. Internally nuclei are represented in a different way from hadrons, but all accessors (charge, baryon number, etc) work in the same way.

Normally nuclei in SMASH are simulated as a collection of protons and neutrons, so there is no need in their PDG codes. However, it is interesting to study light nuclei production, considering them as single pointlike hadrons. This justifies introduction of nuclear PDG codes here.

Limitations:

The code is tuned to non-colored objects at the moment. That means that colored objects (Diquarks and Quarks) are not easily useable with this class; the behaviour of functions baryon_number, charge, is_hadron etc. is undefined. (This is mostly because these things are not well-defined, and/or because the charge and baryon number is not an integer anymore.)

Also, tetra- and pentaquarks cannot be represented; that, though, is a problem of the PDG Numbering Scheme rather than of this class.

Definition at line 108 of file pdgcode.h.

Classes
struct	InvalidPdgCode
	thrown for invalid inputs More...

Public Member Functions
	PdgCode ()
	Standard initializer. More...

	PdgCode (const std::string &codestring)
	Initialize using a string The string is interpreted as a hexadecimal number, i.e., `211` is interpreted as `0x211` = \(529_{10}\). More...

	PdgCode (std::int32_t codenumber)
	Receive a signed integer and process it into a PDG Code. More...

	PdgCode (const std::uint32_t abscode)
	Receive an unsigned integer and process it into a PDG Code. More...

template<typename T >
	PdgCode (T codenumber, typename std::enable_if_t< std::is_integral_v< T > &&4< sizeof(T), bool >=true)
	The creation of `PdgCode` instances for nuclei that have a 10-digits code cannot be done using the integer constructors above, since a 10-digits hexadecimal number like 0x1000020030 exceeds the int32_t capacity. More...

int	test_code () const
	Checks the integer for invalid hex digits. More...

void	check () const
	Do all sorts of validity checks. More...

std::uint32_t	dump () const
	Dumps the bitfield into an unsigned integer. More...

std::int32_t	code () const

std::string	string () const

PdgCode	get_antiparticle () const
	Construct the antiparticle to a given PDG code. More...

bool	is_nucleus () const

bool	is_hadron () const

bool	is_lepton () const

bool	is_neutrino () const

bool	is_charmonia () const

int	baryon_number () const

bool	is_baryon () const

bool	is_meson () const

bool	is_nucleon () const

bool	is_proton () const

bool	is_neutron () const

bool	is_Nstar1535 () const

bool	is_Delta () const

bool	is_hyperon () const

bool	is_Omega () const

bool	is_Xi () const

bool	is_Lambda () const

bool	is_Sigma () const

bool	is_Sigmastar () const

bool	is_kaon () const

bool	is_pion () const

bool	is_omega () const

bool	is_rho () const

bool	is_deuteron () const

bool	is_triton () const

bool	has_antiparticle () const

int	isospin3 () const

double	frac_strange () const

double	frac_charm () const

double	frac_bottom () const

bool	is_heavy_flavor () const

int	strangeness () const

int	charmness () const

int	bottomness () const

int	charge () const
	The charge of the particle. More...

unsigned int	spin () const

unsigned int	spin_degeneracy () const

int	antiparticle_sign () const

std::int32_t	quarks () const

std::array< int, 3 >	quark_content () const
	The return is always an array of three numbers, which are pdgcodes of quarks: 1 - d, 2 - u, 3 - s, 4 - c, 5 - b. More...

bool	contains_enough_valence_quarks (int valence_quarks_required) const

bool	operator< (const PdgCode rhs) const
	Sorts PDG Codes according to their numeric value. More...

bool	operator== (const PdgCode rhs) const

bool	operator!= (const PdgCode rhs) const

bool	is_antiparticle_of (const PdgCode rhs) const

int32_t	get_decimal () const

void	deexcite ()
	Remove all excitation, except spin. Sign and quark content remains. More...

int	net_quark_number (const int quark) const
	Returns the net number of quarks with given flavour number For public use, see strangeness(), charmness(), bottomness() and isospin3(). More...

int	nucleus_p () const
	Number of protons in nucleus. More...

int	nucleus_n () const
	Number of neutrons in nucleus. More...

int	nucleus_La () const
	Number of Lambdas in nucleus. More...

int	nucleus_ap () const
	Number of antiprotons in nucleus. More...

int	nucleus_an () const
	Number of antineutrons in nucleus. More...

int	nucleus_aLa () const
	Number of anti-Lambdas in nucleus. More...

int	nucleus_A () const
	Nucleus mass number. More...

Static Public Member Functions
static PdgCode	from_decimal (const int pdgcode_decimal)
	Construct PDG code from decimal number. More...

static PdgCode	invalid ()
	PdgCode 0x0 is guaranteed not to be valid by the PDG standard, but it passes all tests here, so we can use it to show some code is not yet set. More...

Private Member Functions
std::uint32_t	ucode () const

std::uint32_t	get_digit_from_char (const char inp) const

void	set_from_string (const std::string &codestring)
	Set the PDG code from the given string. More...

void	set_fields (std::uint32_t abscode)
	Sets the bitfield from an unsigned integer. More...

Private Attributes
union {
struct {
std::uint32_t n_J_: 4
	spin quantum number \(n_J = 2 J + 1\). More...

std::uint32_t n_q3_: 4
	third quark field More...

std::uint32_t n_q2_: 4
	second quark field More...

std::uint32_t n_q1_: 4
	first quark field. 0 for mesons. More...

std::uint32_t n_L_: 4
	"angular momentum" More...

std::uint32_t n_R_: 4
	"radial excitation" More...

std::uint32_t n_: 4
	first field: "counter" More...

std::uint32_t bool is_nucleus_: 2: 1
	1 for nuclei, 0 for the rest More...

bool antiparticle_: 1
	first bit: stores the sign. More...

} digits_
	The single digits collection of the code. More...

std::uint32_t dump_
	The bitfield dumped into a single integer. More...

struct {
std::uint32_t __pad0__: 4

std::uint32_t quarks_: 12
	The quark digits n_q{1,2,3}_. More...

std::uint32_t excitation_: 12
	The excitation digits n_, n_R_, n_L_. More...

} chunks_
	Chunk collection: here, the chunks with \(nn_Rn_L\) and \(n_{q_1}n_{q_2}n_{q_3}\) are directly accessible. More...

struct {
std::uint32_t n_Lambda_: 6

std::uint32_t Z_: 10

std::uint32_t A_: 10

std::uint32_t I_: 4

bool is_nucleus_: 1

bool antiparticle_: 1

} nucleus_
	Structure for the nuclei. More...

};
	The union holds the data; either as a single integer dump_, as a single-digit bitfield digits_ or as a multiple-digits bitfield chunks_. More...

Friends
std::istream &	operator>> (std::istream &is, PdgCode &code)
	istream >> PdgCode assigns the PDG Code from an istream. More...

Constructor & Destructor Documentation

◆ PdgCode() [1/5]

smash::PdgCode::PdgCode ( )

inline

Standard initializer.

Definition at line 125 of file pdgcode.h.

125 : dump_(0x0) {}

smash::PdgCode::dump_

std::uint32_t dump_

The bitfield dumped into a single integer.

Definition: pdgcode.h:957

◆ PdgCode() [2/5]

smash::PdgCode::PdgCode ( const std::string & codestring )

inlineexplicit

Initialize using a string The string is interpreted as a hexadecimal number, i.e., 211 is interpreted as 0x211 = \(529_{10}\).

Definition at line 131 of file pdgcode.h.

                                                 {
     set_from_string(codestring);
   }

◆ PdgCode() [3/5]

smash::PdgCode::PdgCode ( std::int32_t codenumber )

inline

Receive a signed integer and process it into a PDG Code.

The sign is taken as antiparticle boolean, while the absolute value of the integer is used as hexdigits.

Parameters

[in] codenumber a signed integer which represent the PDG code The number 0x221 is interpreted as an η meson, -0x211 is a "charged pi antiparticle", i.e., a \(\pi^-\).

Definition at line 143 of file pdgcode.h.

                                  : dump_(0x0) {  // NOLINT(runtime/explicit)
     digits_.antiparticle_ = false;
     if (codenumber < 0) {
       digits_.antiparticle_ = true;
       codenumber = -codenumber;
     }
     set_fields(codenumber);
   }

◆ PdgCode() [4/5]

smash::PdgCode::PdgCode ( const std::uint32_t abscode )

inlineexplicit

Receive an unsigned integer and process it into a PDG Code.

The first bit is taken and used as antiparticle boolean.

Definition at line 155 of file pdgcode.h.

                                               : dump_(0x0) {
     // use the first bit for the antiparticle_ boolean.
     digits_.antiparticle_ = ((abscode & 0x80000000u) != 0);
     set_fields(abscode);
   }

◆ PdgCode() [5/5]

template<typename T >

smash::PdgCode::PdgCode ( T codenumber )

inline

The creation of PdgCode instances for nuclei that have a 10-digits code cannot be done using the integer constructors above, since a 10-digits hexadecimal number like 0x1000020030 exceeds the int32_t capacity.

Nuclei instances can in principle either be created with the string constructor or via the PdgCode::from_decimal() static member, but offering a uniform interface for all cases is definitely user-friendly.

Since the string constructor works, we delegate here the construction to it. In order to execute the needed code to built the string in the member initializer list, we use a common lambda idiom (IIFE) that consists in immediately invoking a lambda function. Using std::invoke makes it more explicit than using () after the lambda braces.

Note: One might wonder why a function template has been used instead of e.g. adding a constructor taking a int64_t argument. The reason is to facilitate the class usage. Having a fixed type would have required the users of this class to exactly match the argument type (and for int64_t there is no standard literal suffix), otherwise the call would have been ambiguous and compilation would have failed. Said differently, we would like
PdgCode deuteron(0x1000010020);

smash::pdg::deuteron
constexpr int64_t deuteron
Deuteron.
Definition: pdgcode_constants.h:108

to work and not oblige the user to write
PdgCode deuteron(INT64_C(0x1000010020));

just because the constructor takes an int64_t number. The idea here is to offer a better matching to the compiler when the constructor is called with an integer type with size larger than 4 bytes. Type-traits are used to limit the template instantiation to reasonable cases, only.

Warning: In C++, it is more common to enable constructors template via a non-type template parameter, i.e.
template <typename T,

template <typename T,

typename std::enable_if_t<

std::is_integral_v<T> && 4 < sizeof(T), bool

> = true>

PdgCode(T codenumber) // ...

but this breaks Doxygen documentation, because apparently multiple "nested" template parameters are not able to be correctly handled (possibly because of the additional less-than symbol). This limitation has been detected using Doxygen 1.9.X and might be solved in future versions.

Parameters

[in] codenumber The hexadecimal PDG code

Template Parameters

T	The type of the PDG code, irrelevant for the user and deduced by the compiler

Definition at line 217 of file pdgcode.h.

       : PdgCode{std::invoke([&codenumber]() {
           std::stringstream stream;
           char sign = '+';
           if (codenumber < 0) {
             sign = '-';
             codenumber = -codenumber;
           }
           stream << sign << std::hex << codenumber;
           return stream.str();
         })} {}

Member Function Documentation

◆ test_code()

int smash::PdgCode::test_code ( ) const

inline

Checks the integer for invalid hex digits.

Usually all digits are at least <= 9. The n_q digits are even <= 6 (because there are only six quarks). The only exception is n_J, where we allow f = 15, which is the largest hexadecimal digit. If one of the hex digits is not also a valid decimal digit, something possibly went wrong - maybe some user of this class forgot to prefix the input with '0x' and thus passed 221 instead of 0x221.

Returns: a bitmask indicating the offending digits. In the above example, 221 = 0xd3, the second-to-last-digit is the offending one, to the return value is 0b10 = 0x2 = 2.

Definition at line 250 of file pdgcode.h.

                                {
     int fail = 0;
     if (digits_.n_ > 9) {
       fail |= 1 << 6;
     }
     if (digits_.n_R_ > 9) {
       fail |= 1 << 5;
     }
     if (digits_.n_L_ > 9) {
       fail |= 1 << 4;
     }
     if (digits_.n_q1_ > 6) {
       fail |= 1 << 3;
     }
     if (digits_.n_q2_ > 6) {
       fail |= 1 << 2;
     }
     if (digits_.n_q3_ > 6) {
       fail |= 1 << 1;
     }
     if (digits_.n_J_ > 15) {
       fail |= 1;
     }
     return fail;
   }

◆ check()

void smash::PdgCode::check ( ) const

inline

Do all sorts of validity checks.

Exceptions

InvalidPdgCode	if meson has even n_J_ (fermionic spin)
InvalidPdgCode	if baryon has odd n_J_ (bosonic spin)
InvalidPdgCode	if n_J_ is 0 (spin is not defined.)
InvalidPdgCode	if particle does not have antiparticle when it is supposed to do.

Definition at line 284 of file pdgcode.h.

                      {
     // n_J must be odd for mesons and even for baryons (and cannot be zero)
     if (is_hadron()) {
       if (baryon_number() == 0) {
         // mesons: special cases K0_L=0x130 and K0_S=0x310
         if ((digits_.n_J_ % 2 == 0) && dump() != 0x130 && dump() != 0x310) {
           throw InvalidPdgCode("Invalid PDG code " + string() +
                                " (meson with even n_J)");
         }
       } else {
         if ((digits_.n_J_ % 2 != 0) || digits_.n_J_ == 0) {
           throw InvalidPdgCode("Invalid PDG code " + string() +
                                " (baryon with odd n_J)");
         }
       }
     } else {
       if (digits_.n_J_ == 0 && dump() != 0x0) {
         throw InvalidPdgCode("Invalid PDG code " + string() + " (n_J==0)");
       }
     }
     /* The antiparticle flag only makes sense for particle types
      * that have an antiparticle. */
     if (digits_.antiparticle_ && !has_antiparticle()) {
       throw InvalidPdgCode("Invalid PDG code " + string() +
                            " (cannot be negative)");
     }
   }

◆ dump()

std::uint32_t smash::PdgCode::dump ( ) const

inline

Dumps the bitfield into an unsigned integer.

Definition at line 313 of file pdgcode.h.

                                   {
     // this cuts the three unused bits.
     return (dump_ & 0x8fffffff);
   }

◆ code()

std::int32_t smash::PdgCode::code ( ) const

inline

Returns: a signed integer with the PDG code in hexadecimal.

Definition at line 319 of file pdgcode.h.

319 { return antiparticle_sign() * ucode(); }

smash::PdgCode::antiparticle_sign

int antiparticle_sign() const

Definition: pdgcode.h:719

smash::PdgCode::ucode

std::uint32_t ucode() const

Definition: pdgcode.h:1002

◆ string()

std::string smash::PdgCode::string ( ) const

inline

Returns: the PDG Code as a decimal string.

Definition at line 322 of file pdgcode.h.

                                   {
     std::stringstream ss;
     ss << get_decimal();
     return ss.str();
   }

◆ get_antiparticle()

PdgCode smash::PdgCode::get_antiparticle ( ) const

inline

Construct the antiparticle to a given PDG code.

Definition at line 329 of file pdgcode.h.

                                    {
     PdgCode result = *this;
     result.digits_.antiparticle_ = !digits_.antiparticle_;
     return result;
   }

◆ from_decimal()

static PdgCode smash::PdgCode::from_decimal ( const int pdgcode_decimal )

inlinestatic

Construct PDG code from decimal number.

Parameters

[in] pdgcode_decimal decimal integer representing the PDG code

Definition at line 339 of file pdgcode.h.

                                                          {
     // Nucleus and special codes with 2J+1 > 9
     if (std::abs(pdgcode_decimal) > 1E7) {
       return PdgCode(std::to_string(pdgcode_decimal));
     }
     int a = pdgcode_decimal;
     int hex_pdg = 0, tmp = 1;
     while (a) {
       hex_pdg += (a % 10) * tmp;
       tmp *= 16;
       a = a / 10;
     }
     return PdgCode(hex_pdg);
   }

◆ is_nucleus()

bool smash::PdgCode::is_nucleus ( ) const

inline

Returns: true if this is a nucleus, false otherwise

Definition at line 361 of file pdgcode.h.

                                  {
     assert(digits_.is_nucleus_ == nucleus_.is_nucleus_);
     return nucleus_.is_nucleus_;
   }

◆ is_hadron()

bool smash::PdgCode::is_hadron ( ) const

inline

Returns: true if this is a baryon, antibaryon or meson.

Definition at line 367 of file pdgcode.h.

                                 {
     return (digits_.n_q3_ != 0 && digits_.n_q2_ != 0 && !is_nucleus());
   }

◆ is_lepton()

bool smash::PdgCode::is_lepton ( ) const

inline

Returns: true if this is a lepton.

Definition at line 372 of file pdgcode.h.

                                 {
     return (digits_.n_q1_ == 0 && digits_.n_q2_ == 0 && digits_.n_q3_ == 1 &&
             !is_nucleus());
   }

◆ is_neutrino()

bool smash::PdgCode::is_neutrino ( ) const

inline

Returns: true if this is a neutrino.

Definition at line 378 of file pdgcode.h.

                                   {
     return (is_lepton() && digits_.n_J_ % 2 == 0);
   }

◆ is_charmonia()

bool smash::PdgCode::is_charmonia ( ) const

inline

Returns: whether this is a charmonia

Definition at line 383 of file pdgcode.h.

                                    {
     return is_meson() && digits_.n_q2_ == 4 && digits_.n_q3_ == 4;
   }

◆ baryon_number()

int smash::PdgCode::baryon_number ( ) const

inline

Returns: the baryon number of the particle.

Definition at line 388 of file pdgcode.h.

                                    {
     if (is_nucleus()) {
       return static_cast<int>(nucleus_.A_) * antiparticle_sign();
     }
     if (!is_hadron() || digits_.n_q1_ == 0) {
       return 0;
     }
     return antiparticle_sign();
   }

◆ is_baryon()

bool smash::PdgCode::is_baryon ( ) const

inline

Returns: whether this PDG code identifies a baryon.

Definition at line 398 of file pdgcode.h.

398 { return is_hadron() && digits_.n_q1_ != 0; }

◆ is_meson()

bool smash::PdgCode::is_meson ( ) const

inline

Returns: whether this PDG code identifies a meson.

Definition at line 401 of file pdgcode.h.

401 { return is_hadron() && digits_.n_q1_ == 0; }

◆ is_nucleon()

bool smash::PdgCode::is_nucleon ( ) const

inline

Returns: whether this is a nucleon/anti-nucleon (p, n, -p, -n)

Definition at line 404 of file pdgcode.h.

                                  {
     const auto abs_code = std::abs(code());
     return (abs_code == pdg::p || abs_code == pdg::n);
   }

◆ is_proton()

bool smash::PdgCode::is_proton ( ) const

inline

Returns: whether this is a proton/anti-proton

Definition at line 410 of file pdgcode.h.

                                 {
     const auto abs_code = std::abs(code());
     return (abs_code == pdg::p);
   }

◆ is_neutron()

bool smash::PdgCode::is_neutron ( ) const

inline

Returns: whether this is a neutron/anti-neutron

Definition at line 416 of file pdgcode.h.

                                  {
     const auto abs_code = std::abs(code());
     return (abs_code == pdg::n);
   }

◆ is_Nstar1535()

bool smash::PdgCode::is_Nstar1535 ( ) const

inline

Returns: whether this is a N*(1535) (+/0)

Definition at line 422 of file pdgcode.h.

                                    {
     const auto abs_code = std::abs(code());
     return (abs_code == pdg::N1535_p || abs_code == pdg::N1535_z);
   }

◆ is_Delta()

bool smash::PdgCode::is_Delta ( ) const

inline

Returns: whether this is a Delta(1232) (with anti-delta)

Definition at line 428 of file pdgcode.h.

                                {
     const auto abs_code = std::abs(code());
     return (abs_code == pdg::Delta_pp || abs_code == pdg::Delta_p ||
             abs_code == pdg::Delta_z || abs_code == pdg::Delta_m);
   }

◆ is_hyperon()

bool smash::PdgCode::is_hyperon ( ) const

inline

Returns: whether this is a hyperon (Lambda, Sigma, Xi, Omega)

Definition at line 435 of file pdgcode.h.

435 { return is_hadron() && digits_.n_q1_ == 3; }

◆ is_Omega()

bool smash::PdgCode::is_Omega ( ) const

inline

Returns: whether this is a Omega baryon

Definition at line 438 of file pdgcode.h.

                                {
     return is_hyperon() && digits_.n_q2_ == 3 && digits_.n_q3_ == 3;
   }

◆ is_Xi()

bool smash::PdgCode::is_Xi ( ) const

inline

Returns: whether this is a Xi baryon

Definition at line 443 of file pdgcode.h.

                             {
     return is_hyperon() && digits_.n_q2_ == 3 && digits_.n_q3_ != 3;
   }

◆ is_Lambda()

bool smash::PdgCode::is_Lambda ( ) const

inline

Returns: whether this is a Lambda baryon

Definition at line 448 of file pdgcode.h.

                                 {
     return is_hyperon() && digits_.n_q2_ == 1 && digits_.n_q3_ == 2;
   }

◆ is_Sigma()

bool smash::PdgCode::is_Sigma ( ) const

inline

Returns: whether this is a Sigma baryon

Definition at line 453 of file pdgcode.h.

                                {
     return is_hyperon() && digits_.n_q2_ != 3 && !is_Lambda();
   }

◆ is_Sigmastar()

bool smash::PdgCode::is_Sigmastar ( ) const

inline

Returns: whether this is a Sigma* with pdgcodes 3224, 3214, 3114

Definition at line 458 of file pdgcode.h.

                                    {
     const auto abs_code = std::abs(code());
     return (abs_code == pdg::Sigma_star_m || abs_code == pdg::Sigma_star_z ||
             abs_code == pdg::Sigma_star_p);
   }

◆ is_kaon()

bool smash::PdgCode::is_kaon ( ) const

inline

Returns: whether this is a kaon (K+, K-, K0, Kbar0)

Definition at line 465 of file pdgcode.h.

                               {
     const auto abs_code = std::abs(code());
     return (abs_code == pdg::K_p) || (abs_code == pdg::K_z);
   }

◆ is_pion()

bool smash::PdgCode::is_pion ( ) const

inline

Returns: whether this is a pion (pi+/pi0/pi-)

Definition at line 471 of file pdgcode.h.

                               {
     const auto c = code();
     return (c == pdg::pi_z) || (c == pdg::pi_p) || (c == pdg::pi_m);
   }

◆ is_omega()

bool smash::PdgCode::is_omega ( ) const

inline

Returns: whether this is an omega meson

Definition at line 477 of file pdgcode.h.

                                {
     const auto c = code();
     return c == pdg::omega;
   }

◆ is_rho()

bool smash::PdgCode::is_rho ( ) const

inline

Returns: whether this is a rho meson (rho+/rho0/rho-)

Definition at line 483 of file pdgcode.h.

                              {
     const auto c = code();
     return (c == pdg::rho_z) || (c == pdg::rho_p) || (c == pdg::rho_m);
   }

◆ is_deuteron()

bool smash::PdgCode::is_deuteron ( ) const

inline

Returns: whether this is (anti-)deuteron

Definition at line 489 of file pdgcode.h.

                                   {
     return is_nucleus() && nucleus_.A_ == 2 && nucleus_.Z_ == 1 &&
            nucleus_.n_Lambda_ == 0 && nucleus_.I_ == 0;
   }

◆ is_triton()

bool smash::PdgCode::is_triton ( ) const

inline

Returns: whether this is (anti-)triton

Definition at line 495 of file pdgcode.h.

                                 {
     return is_nucleus() && nucleus_.A_ == 3 && nucleus_.Z_ == 1 &&
            nucleus_.n_Lambda_ == 0 && nucleus_.I_ == 0;
   }

◆ has_antiparticle()

bool smash::PdgCode::has_antiparticle ( ) const

inline

Returns: whether a particle has a distinct antiparticle (or whether it is its own antiparticle).

Definition at line 504 of file pdgcode.h.

                                 {
     if (is_nucleus()) {
       return true;
     }
     if (is_hadron()) {
       return (baryon_number() != 0) || (digits_.n_q2_ != digits_.n_q3_);
     } else {
       return digits_.n_q3_ == 1;  // leptons!
     }
   }

◆ isospin3()

int smash::PdgCode::isospin3 ( ) const

inline

Returns: twice the isospin-3 component \(I_3\).

This is calculated from the sum of net_quark_number of up and down.

Definition at line 520 of file pdgcode.h.

                               {
     /* net_quark_number(2) is the number of u quarks,
      * net_quark_number(1) is the number of d quarks. */
     return net_quark_number(2) - net_quark_number(1);
   }

◆ frac_strange()

double smash::PdgCode::frac_strange ( ) const

inline

Returns: the fraction number of strange quarks (strange + anti-strange) / total

This is useful for the AQM cross-section scaling, and needs to be positive definite.

Definition at line 533 of file pdgcode.h.

                                      {
     if (is_baryon()) {
       return std::abs(strangeness()) / 3.;
     } else if (is_meson()) {
       /* The quarkonium state has 0 net strangeness
        * but there are actually 2 strange quarks out of 2 total */
       if (digits_.n_q3_ == 3 && digits_.n_q2_ == 3) {
         return 1.;
       } else {
         return std::abs(strangeness()) / 2.;
       }
     } else {
       /* If not baryon or meson, this should be 0, as AQM does not
        * extend to non-hadrons */
       return 0.;
     }
   }

◆ frac_charm()

double smash::PdgCode::frac_charm ( ) const

inline

Returns: the fraction number of charm quarks (charm + anti-charm) / total

This is useful for the AQM cross-section scaling, and needs to be positive definite.

Definition at line 558 of file pdgcode.h.

                                    {
     if (is_baryon()) {
       return std::abs(charmness()) / 3.;
     } else if (is_meson()) {
       /* The charmonium state has 0 net charmness
        * but there are actually 2 charm quarks out of 2 total */
       if (digits_.n_q3_ == 4 && digits_.n_q2_ == 4) {
         return 1.;
       } else {
         return std::abs(charmness()) / 2.;
       }
     } else {
       /* If not baryon or meson, this should be 0, as AQM does not
        * extend to non-hadrons */
       return 0.;
     }
   }

◆ frac_bottom()

double smash::PdgCode::frac_bottom ( ) const

inline

Returns: the fraction number of bottom quarks (bottom + anti-bottom) / total

This is useful for the AQM cross-section scaling, and needs to be positive definite.

Definition at line 583 of file pdgcode.h.

                                     {
     if (is_baryon()) {
       return std::abs(bottomness()) / 3.;
     } else if (is_meson()) {
       /* The bottomonium state has 0 net bottomness
        * but there are actually 2 bottom quarks out of 2 total */
       if (digits_.n_q3_ == 5 && digits_.n_q2_ == 5) {
         return 1.;
       } else {
         return std::abs(bottomness()) / 2.;
       }
     } else {
       /* If not baryon or meson, this should be 0, as AQM does not
        * extend to non-hadrons */
       return 0.;
     }
   }

◆ is_heavy_flavor()

bool smash::PdgCode::is_heavy_flavor ( ) const

inline

Returns: whether the hadron contains a charm or bottom quark

Definition at line 602 of file pdgcode.h.

                                       {
     return (frac_charm() != 0) || (frac_bottom() != 0);
   }

◆ strangeness()

int smash::PdgCode::strangeness ( ) const

inline

Returns: the net number of \(\bar s\) quarks.

For particles with one strange quark, -1 is returned.

Definition at line 611 of file pdgcode.h.

611 { return -net_quark_number(3); }

◆ charmness()

int smash::PdgCode::charmness ( ) const

inline

Returns: the net number of \(c\) quarks

For particles with one charm quark, +1 is returned.

Definition at line 618 of file pdgcode.h.

618 { return +net_quark_number(4); }

◆ bottomness()

int smash::PdgCode::bottomness ( ) const

inline

Returns: the net number of \(\bar b\) quarks

For particles with one bottom quark, -1 is returned.

Definition at line 625 of file pdgcode.h.

625 { return -net_quark_number(5); }

◆ charge()

int smash::PdgCode::charge ( ) const

inline

The charge of the particle.

The charge is calculated from the quark content (for hadrons) or basically tabulated; currently leptons, neutrinos and the standard model gauge bosons are known; unknown particles return a charge of 0.

Returns: charge of the particle

Definition at line 635 of file pdgcode.h.

                      {
     if (is_hadron() || is_nucleus()) {
       // Q will accumulate 3*charge (please excuse the upper case. I
       // want to distinguish this from q which might be interpreted as
       // shorthand for "quark".)
       int Q = 0;
       /* This loops over d,u,s,c,b,t quarks (the latter can be safely ignored,
        * but I don't think this will be a bottle neck. */
       for (int i = 1; i < 7; i++) {
         /* u,c,t quarks have charge = 2/3 e, while d,s,b quarks have -1/3 e.
          * The antiparticle sign is already in net_quark_number. */
         Q += (i % 2 == 0 ? 2 : -1) * net_quark_number(i);
       }
       return Q / 3;
     }
     /* non-hadron:
      * Leptons: 11, 13, 15 are e, μ, τ and have a charge -1, while
      *          12, 14, 16 are the neutrinos that have no charge. */
     if (digits_.n_q3_ == 1) {
       return -1 * (digits_.n_J_ % 2) * antiparticle_sign();
     }
     /* Bosons: 24 is the W+, all else is uncharged.
      * we ignore the first digits so that this also finds strange gauge
      * boson "resonances" (in particular, \f$\tilde \chi_1^+\f$ with PDG
      * Code 1000024). */
     if ((dump_ & 0x0000ffff) == 0x24) {
       return antiparticle_sign();
     }
     // default (this includes all other Bosons) is 0.
     return 0;
   }

◆ spin()

unsigned int smash::PdgCode::spin ( ) const

inline

Returns: twice the spin of a particle.

The code is good for hadrons, leptons and spin-1-bosons. It returns 2 (meaning spin=1) for the Higgs, though.

Exceptions

runtime_error if a spin of a nucleus is not coded in and has to be guessed

Definition at line 676 of file pdgcode.h.

                                    {
     if (is_nucleus()) {
       // Generally spin of a nucleus cannot be simply guessed, it should be
       // provided from some table. However, here we only care about a
       // limited set of light nuclei with A <= 4.
       if (nucleus_.A_ == 2) {
         // Deuteron spin is 1
         return 2;
       } else if (nucleus_.A_ == 3) {
         // Tritium and He-3 spin are 1/2
         // Hypertriton spin is not firmly determined, but decay branching ratios
         // indicate spin 1/2
         return 1;
       } else if (nucleus_.A_ == 4) {
         // He-4 spin is 0
         return 0;
       }
       throw std::runtime_error("Unknown spin of nucleus.");
       // Alternative possibility is to guess 1/2 for fermions and 0 for bosons
       // as 2 * (nucleus_.A_ % 2).
     }
  
     if (is_hadron()) {
       if (digits_.n_J_ == 0) {
         return 0;  // special cases: K0_L=0x130 & K0_S=0x310
       } else {
         return digits_.n_J_ - 1;
       }
     }
     /* this assumes that we only have white particles (no single
      * quarks): Electroweak fermions have 11-17, so the
      * second-to-last-digit is the spin. The same for the Bosons: they
      * have 21-29 and 2spin = 2 (this fails for the Higgs). */
     return digits_.n_q3_;
   }

◆ spin_degeneracy()

unsigned int smash::PdgCode::spin_degeneracy ( ) const

inline

Returns: the spin degeneracy \(2s + 1\) of a particle.

Definition at line 712 of file pdgcode.h.

                                               {
     if (is_hadron() && digits_.n_J_ > 0) {
       return digits_.n_J_;
     }
     return spin() + 1;
   }

◆ antiparticle_sign()

int smash::PdgCode::antiparticle_sign ( ) const

inline

Returns: -1 for antiparticles and +1 for particles.

Definition at line 719 of file pdgcode.h.

                                        {
     return (digits_.antiparticle_ ? -1 : +1);
   }

◆ quarks()

std::int32_t smash::PdgCode::quarks ( ) const

inline

Returns: an integer with only the quark numbers set.

Definition at line 723 of file pdgcode.h.

                                    {
     if (!is_hadron() || is_nucleus()) {
       return 0;
     }
     return chunks_.quarks_;
   }

◆ quark_content()

std::array<int, 3> smash::PdgCode::quark_content ( ) const

inline

The return is always an array of three numbers, which are pdgcodes of quarks: 1 - d, 2 - u, 3 - s, 4 - c, 5 - b.

Antiquarks get a negative sign. For mesons the first number in array is always 0. There is a difficulty with mesons that are a superposition, for example \( \pi^0 = \frac{1}{\sqrt{2}}(u \bar{u} + d \bar{d}) \). Currently for \( \pi^0 \) just {0, 1, -1} is returned.

Returns: quark content as an array.

Definition at line 739 of file pdgcode.h.

                                          {
     std::array<int, 3> result = {static_cast<int>(digits_.n_q1_),
                                  static_cast<int>(digits_.n_q2_),
                                  static_cast<int>(digits_.n_q3_)};
     if (is_hadron()) {
       // Antibaryons
       if (digits_.n_q1_ != 0 && digits_.antiparticle_) {
         for (size_t i = 0; i < 3; i++) {
           result[i] = -result[i];
         }
       }
       // Mesons
       if (digits_.n_q1_ == 0) {
         // Own antiparticle
         if (digits_.n_q2_ == digits_.n_q3_) {
           result[2] = -result[2];
         } else {
           // Like pi-
           if (digits_.antiparticle_) {
             result[1] = -result[1];
             // Like pi+
           } else {
             result[2] = -result[2];
           }
         }
         // add extra minus sign according to the pdg convention
         if (digits_.n_q2_ != digits_.n_q3_ && digits_.n_q2_ % 2 == 1) {
           for (int i = 1; i <= 2; i++) {
             result[i] = -result[i];
           }
         }
       }
     } else {
       result = {0, 0, 0};
     }
     return result;
   }

◆ contains_enough_valence_quarks()

bool smash::PdgCode::contains_enough_valence_quarks ( int valence_quarks_required ) const

Returns: whether a particle contains at least the given number of valence quarks.

Parameters

[in] valence_quarks_required number of valence quarks that particle is supposed to contain.

Exceptions

std::runtime_error if it is not a hadron

This is necessary for string fragmentation.

Definition at line 92 of file pdgcode.cc.

                                        {
   if (is_meson()) {
     return valence_quarks_required == 1 || valence_quarks_required == -1;
   }
   if (is_baryon()) {
     if (baryon_number() == 1) {
       return valence_quarks_required == 1 || valence_quarks_required == 2;
     }
     if (baryon_number() == -1) {
       return valence_quarks_required == -1 || valence_quarks_required == -2;
     }
   }
   throw std::runtime_error("String fragment is neither baryon nor meson");
 }

◆ operator<()

bool smash::PdgCode::operator< ( const PdgCode rhs ) const

inline

Sorts PDG Codes according to their numeric value.

This is used by std::map

Definition at line 799 of file pdgcode.h.

                                                  {
     return dump_ < rhs.dump_;
     /* the complex thing to do here is to calculate:
      *   code() < rhs.code()
      * but for getting a total order that's overkill. The uint32_t value in
      * dump_ works just fine. */
   }

◆ operator==()

bool smash::PdgCode::operator== ( const PdgCode rhs ) const

inline

Returns: if the codes are equal

Definition at line 808 of file pdgcode.h.

808 { return dump_ == rhs.dump_; }

◆ operator!=()

bool smash::PdgCode::operator!= ( const PdgCode rhs ) const

inline

Returns: if the codes are not equal.

Definition at line 811 of file pdgcode.h.

811 { return !(*this == rhs); }

◆ is_antiparticle_of()

bool smash::PdgCode::is_antiparticle_of ( const PdgCode rhs ) const

inline

Returns: if the code of rhs is the inverse of this one.

Definition at line 814 of file pdgcode.h.

                                                           {
     return code() == -rhs.code();
   }

◆ invalid()

static PdgCode smash::PdgCode::invalid ( )

inlinestatic

PdgCode 0x0 is guaranteed not to be valid by the PDG standard, but it passes all tests here, so we can use it to show some code is not yet set.

Definition at line 826 of file pdgcode.h.

826 { return PdgCode(0x0); }

◆ get_decimal()

int32_t smash::PdgCode::get_decimal ( ) const

inline

Returns: an integer with decimal representation of the code. If the spin is too large for the last digit, an additional digit at the beginning will be used, so that the sum of the first and the last digit is the spin. This is used for binary and ROOT output.

Exceptions

InvalidPdgCode if the spin degeneracy is larger than 9

Definition at line 837 of file pdgcode.h.

                               {
     if (is_nucleus()) {
       // ±10LZZZAAAI
       return antiparticle_sign() *
              (nucleus_.I_ + 10 * nucleus_.A_ + 10000 * nucleus_.Z_ +
               10000000 * nucleus_.n_Lambda_ + 1000000000);
     }
     int n_J_1 = 0;
     int n_J_2 = digits_.n_J_;
     if (n_J_2 > 9) {
       n_J_1 = n_J_2 - 9;
       n_J_2 = 9;
     }
     return antiparticle_sign() *
            (n_J_2 + digits_.n_q3_ * 10 + digits_.n_q2_ * 100 +
             digits_.n_q1_ * 1000 + digits_.n_L_ * 10000 +
             digits_.n_R_ * 100000 + digits_.n_ * 1000000 + n_J_1 * 10000000);
   }

◆ deexcite()

void smash::PdgCode::deexcite ( )

inline

Remove all excitation, except spin. Sign and quark content remains.

Definition at line 857 of file pdgcode.h.

                   {
     if (!is_nucleus()) {
       chunks_.excitation_ = 0;
     } else {
       nucleus_.I_ = 0;
     }
   }

◆ net_quark_number()

int smash::PdgCode::net_quark_number ( const int quark ) const

Returns the net number of quarks with given flavour number For public use, see strangeness(), charmness(), bottomness() and isospin3().

Parameters

[in] quark PDG Code of quark: (1..6) = (d,u,s,c,b,t)

Returns: for the net number of quarks (#quarks - #antiquarks)

Exceptions

std::invalid_argument if quark is not any of d, u, s, c, b and t quarks

Definition at line 31 of file pdgcode.cc.

                                                    {
   // input sanitization: Only quark numbers 1 through 6 are allowed.
   if (quark < 1 || quark > 6) {
     throw std::invalid_argument(
         std::string("PdgCode::net_quark_number(): ") +
         std::string("Quark number must be in [1..6], received ") +
         std::to_string(quark));
   }
   if (is_nucleus()) {
     const int Np = nucleus_.Z_;
     const int Nn = nucleus_.A_ - nucleus_.Z_ - nucleus_.n_Lambda_;
     const int NL = nucleus_.n_Lambda_;
     switch (quark) {
       case 1:
         return (2 * Nn + Np + NL) * antiparticle_sign();
       case 2:
         return (Nn + 2 * Np + NL) * antiparticle_sign();
       case 3:
         return NL * antiparticle_sign();
       // Charmed nuclei may exist, but they are not foreseen by PDG standard
       default:
         return 0.0;
     }
   }
   // non-hadrons and those that have none of this quark type: 0.
   if (!is_hadron() || (digits_.n_q1_ != quark && digits_.n_q2_ != quark &&
                        digits_.n_q3_ != quark)) {
     return 0;
   }
   // baryons: count quarks.
   if (baryon_number() != 0) {
     // for anti-baryons, the sign changes:
     return antiparticle_sign() *
            ((digits_.n_q1_ == quark) + (digits_.n_q2_ == quark) +
             (digits_.n_q3_ == quark));
   }
  
   // mesons.
  
   // quarkonium state? Not open net_quark_number.
   if (digits_.n_q3_ == quark && digits_.n_q2_ == quark) {
     return 0;
   }
   /* this has covered all the easy stuff
    * get the "other" quark. (We know this must exist, since they are
    * not both the right one and one of them is the right one). */
   int otherquark = (digits_.n_q2_ == quark) ? digits_.n_q3_ : digits_.n_q2_;
   /* "our" quark is the heavier one: 1 for u,c,t; -1 for d,s,b (and of
    * course the antiparticle sign) */
   if (quark > otherquark) {
     return ((quark % 2 == 0) ? 1 : -1) * antiparticle_sign();
   }
   /* ours is the lighter: If the heavier particle is u,c,t, the lighter
    * one (ours) is an antiquark. */
   return ((otherquark % 2 == 0) ? -1 : 1) * antiparticle_sign();
 }

◆ nucleus_p()

int smash::PdgCode::nucleus_p ( ) const

inline

Number of protons in nucleus.

Definition at line 878 of file pdgcode.h.

                         {
     return (is_nucleus() && !nucleus_.antiparticle_) ? nucleus_.Z_ : 0;
   }

◆ nucleus_n()

int smash::PdgCode::nucleus_n ( ) const

inline

Number of neutrons in nucleus.

Definition at line 882 of file pdgcode.h.

                         {
     return (is_nucleus() && !nucleus_.antiparticle_)
                ? nucleus_.A_ - nucleus_.Z_ - nucleus_.n_Lambda_
                : 0;
   }

◆ nucleus_La()

int smash::PdgCode::nucleus_La ( ) const

inline

Number of Lambdas in nucleus.

Definition at line 888 of file pdgcode.h.

                          {
     return (is_nucleus() && !nucleus_.antiparticle_) ? nucleus_.n_Lambda_ : 0;
   }

◆ nucleus_ap()

int smash::PdgCode::nucleus_ap ( ) const

inline

Number of antiprotons in nucleus.

Definition at line 892 of file pdgcode.h.

                          {
     return (is_nucleus() && nucleus_.antiparticle_) ? nucleus_.Z_ : 0;
   }

◆ nucleus_an()

int smash::PdgCode::nucleus_an ( ) const

inline

Number of antineutrons in nucleus.

Definition at line 896 of file pdgcode.h.

                          {
     return (is_nucleus() && nucleus_.antiparticle_)
                ? nucleus_.A_ - nucleus_.Z_ - nucleus_.n_Lambda_
                : 0;
   }

◆ nucleus_aLa()

int smash::PdgCode::nucleus_aLa ( ) const

inline

Number of anti-Lambdas in nucleus.

Definition at line 902 of file pdgcode.h.

                           {
     return (is_nucleus() && nucleus_.antiparticle_) ? nucleus_.n_Lambda_ : 0;
   }

◆ nucleus_A()

int smash::PdgCode::nucleus_A ( ) const

inline

Nucleus mass number.

Definition at line 906 of file pdgcode.h.

906 { return is_nucleus() ? nucleus_.A_ : 0; }

◆ ucode()

std::uint32_t smash::PdgCode::ucode ( ) const

inlineprivate

Returns: an unsigned integer with the PDG code in hexadecimal (disregarding the antiparticle flag).

Definition at line 1002 of file pdgcode.h.

1002 { return (dump_ & 0x0fffffff); }

◆ get_digit_from_char()

std::uint32_t smash::PdgCode::get_digit_from_char ( const char inp ) const

inlineprivate

Returns: digits from a hexadecimal character.

Parameters

[in] inp character which is translated into digit

Exceptions

InvalidPdgCode if character does not correspond to digit

Definition at line 1010 of file pdgcode.h.

                                                                {
     // Decimal digit
     if (48 <= inp && inp <= 57) {
       return inp - 48;
     }
     // Hexdecimal digit, uppercase
     if (65 <= inp && inp <= 70) {
       return inp - 65 + 10;
     }
     // Hexdecimal digit, lowercase
     if (97 <= inp && inp <= 102) {
       return inp - 97 + 10;
     }
     throw InvalidPdgCode("PdgCode: Invalid character " + std::string(&inp, 1) +
                          " found.\n");
   }

◆ set_from_string()

void smash::PdgCode::set_from_string ( const std::string & codestring )

inlineprivate

Set the PDG code from the given string.

This supports hexdecimal digits. If the last digit is not enough to represent the spin, a digit can be added at the beginning which will be added to the total spin.

Parameters

[in] codestring string which is translated into PdgCode

Exceptions

InvalidPdgCode	if the input string is empty
InvalidPdgCode	if it is a nucleus whose PDG code does not begin with 10
InvalidPdgCode	if it is not a nucleus while number of digits is more than 8
InvalidPdgCode	if the 1st quark field is not any of d, u, s, c, b and t quarks
InvalidPdgCode	if the 2nd quark field is not any of d, u, s, c, b and t quarks
InvalidPdgCode	if the 3rd quark field is not any of d, u, s, c, b and t quarks
InvalidPdgCode	if there is nothing else but sign

Definition at line 1048 of file pdgcode.h.

                                                            {
     dump_ = 0;
     // Implicit with the above: digits_.antiparticle_ = false;
     digits_.n_ = digits_.n_R_ = digits_.n_L_ = digits_.n_q1_ = digits_.n_q2_ =
         digits_.n_q3_ = digits_.n_J_ = digits_.is_nucleus_ = 0;
     size_t length = codestring.size();
     if (length < 1) {
       throw InvalidPdgCode("Empty string does not contain PDG Code\n");
     }
     int c = 0;
     /* Look at current character; if it is a + or minus sign, read it
      * and advance to next char. */
     if (codestring[c] == '-') {
       digits_.antiparticle_ = true;
       ++c;
     } else if (codestring[c] == '+') {
       digits_.antiparticle_ = false;
       ++c;
     }
     // Save if the first character was a sign:
     unsigned int sign = c;
  
     // Nucleus
     if (length == 10 + sign) {
       nucleus_.is_nucleus_ = true;
       if (codestring[c] != '1' || codestring[c + 1] != '0') {
         throw InvalidPdgCode("Pdg code of nucleus \"" + codestring +
                              "\" should start with 10\n");
       }
       c += 2;
       // ±10LZZZAAAI is the standard for nuclei
       std::array<int, 8> digits;
       for (int i = 0; i < 8; i++) {
         digits[i] = get_digit_from_char(codestring[c + i]);
       }
       nucleus_.n_Lambda_ = digits[0];
       nucleus_.Z_ = 100 * digits[1] + 10 * digits[2] + digits[3];
       nucleus_.A_ = 100 * digits[4] + 10 * digits[5] + digits[6];
       nucleus_.I_ = digits[7];
       return;
     }
  
     // Codestring shouldn't be longer than 8 + sign, except for nuclei
     if (length > 8 + sign) {
       throw InvalidPdgCode("String \"" + codestring +
                            "\" too long for PDG Code\n");
     }
     /* Please note that in what follows, we actually need c++, not ++c.
      * first digit is used for n_J if the last digit is not enough. */
     if (length > 7 + sign) {
       digits_.n_J_ += get_digit_from_char(codestring[c++]);
     }
     // Codestring has 7 digits? 7th from last goes in n_.
     if (length > 6 + sign) {
       digits_.n_ = get_digit_from_char(codestring[c++]);
     }
     // It has 6 or 7 digits? 6th from last is n_R_.
     if (length > 5 + sign) {
       digits_.n_R_ = get_digit_from_char(codestring[c++]);
     }
     // 5th from last is n_L_.
     if (length > 4 + sign) {
       digits_.n_L_ = get_digit_from_char(codestring[c++]);
     }
     // 4th from last is n_q1_.
     if (length > 3 + sign) {
       digits_.n_q1_ = get_digit_from_char(codestring[c++]);
       if (digits_.n_q1_ > 6) {
         throw InvalidPdgCode("Invalid PDG code " + codestring + " (n_q1>6)");
       }
     }
     // 3rd from last is n_q2_.
     if (length > 2 + sign) {
       digits_.n_q2_ = get_digit_from_char(codestring[c++]);
       if (digits_.n_q2_ > 6) {
         throw InvalidPdgCode("Invalid PDG code " + codestring + " (n_q2>6)");
       }
     }
     // Next to last is n_q3_.
     if (length > 1 + sign) {
       digits_.n_q3_ = get_digit_from_char(codestring[c++]);
       if (digits_.n_q3_ > 6) {
         throw InvalidPdgCode("Invalid PDG code " + codestring + " (n_q3>6)");
       }
     }
     // Last digit is the spin degeneracy.
     if (length > sign) {
       digits_.n_J_ += get_digit_from_char(codestring[c++]);
     } else {
       throw InvalidPdgCode(
           "String \"" + codestring +
           "\" only consists of a sign, that is no valid PDG Code\n");
     }
     check();
   }

◆ set_fields()

void smash::PdgCode::set_fields ( std::uint32_t abscode )

inlineprivate

Sets the bitfield from an unsigned integer.

Usually called from the constructors.

Parameters

[in] abscode integer which replace PDG code except sign

Exceptions

InvalidPdgCode if input is not a valid PDG code

See also: PdgCode::test_code

Definition at line 1153 of file pdgcode.h.

                                               {
     /* "dump_ =" overwrites antiparticle_, but this needs to have been set
      * already, so we carry it around the assignment. */
     bool ap = digits_.antiparticle_;
     dump_ = abscode & 0x0fffffff;
     digits_.antiparticle_ = ap;
     int test = test_code();
     if (test > 0) {
       throw InvalidPdgCode("Invalid digits " + std::to_string(test) +
                            " in PDG Code " + string());
     }
     check();
   }

Friends And Related Function Documentation

◆ operator>>

std::istream& operator>>	(	std::istream &	is,
		PdgCode &	code
	)

friend

istream >> PdgCode assigns the PDG Code from an istream.

Parameters

[in]	is	input string
[out]	code	PdgCode to be set

Definition at line 14 of file pdgcode.cc.

                                                       {
   std::string codestring("");
   is >> codestring;
   if (!is) {
     code = PdgCode::invalid();
     return is;
   }
   try {
     // set the fields from the string:
     code.set_from_string(codestring);
   } catch (PdgCode::InvalidPdgCode&) {
     is.setstate(std::ios::failbit);
     code = PdgCode::invalid();
   }
   return is;
 }

Member Data Documentation

◆ n_J_

std::uint32_t smash::PdgCode::n_J_

spin quantum number \(n_J = 2 J + 1\).

Definition at line 922 of file pdgcode.h.

◆ n_q3_

std::uint32_t smash::PdgCode::n_q3_

third quark field

Definition at line 924 of file pdgcode.h.

◆ n_q2_

std::uint32_t smash::PdgCode::n_q2_

second quark field

Definition at line 926 of file pdgcode.h.

◆ n_q1_

std::uint32_t smash::PdgCode::n_q1_

first quark field. 0 for mesons.

Definition at line 928 of file pdgcode.h.

◆ n_L_

std::uint32_t smash::PdgCode::n_L_

"angular momentum"

Definition at line 930 of file pdgcode.h.

◆ n_R_

std::uint32_t smash::PdgCode::n_R_

"radial excitation"

Definition at line 932 of file pdgcode.h.

◆ n_

std::uint32_t smash::PdgCode::n_

first field: "counter"

Definition at line 934 of file pdgcode.h.

◆ is_nucleus_ [1/2]

std::uint32_t bool smash::PdgCode::is_nucleus_

1 for nuclei, 0 for the rest

Definition at line 936 of file pdgcode.h.

◆ antiparticle_

bool smash::PdgCode::antiparticle_

first bit: stores the sign.

Definition at line 938 of file pdgcode.h.

◆

struct { ... } smash::PdgCode::digits_

The single digits collection of the code.

Here, every PDG code digits is directly accessible.

◆ dump_

std::uint32_t smash::PdgCode::dump_

The bitfield dumped into a single integer.

Please note that the 2nd, 3rd and 4th highest bits are possibly undefined.

Definition at line 957 of file pdgcode.h.

◆ pad0

std::uint32_t smash::PdgCode::__pad0__

Definition at line 964 of file pdgcode.h.

◆ quarks_

std::uint32_t smash::PdgCode::quarks_

The quark digits n_q{1,2,3}_.

Definition at line 966 of file pdgcode.h.

◆ excitation_

std::uint32_t smash::PdgCode::excitation_

The excitation digits n_, n_R_, n_L_.

Definition at line 968 of file pdgcode.h.

◆

struct { ... } smash::PdgCode::chunks_

Chunk collection: here, the chunks with \(nn_Rn_L\) and \(n_{q_1}n_{q_2}n_{q_3}\) are directly accessible.

◆ n_Lambda_

std::uint32_t smash::PdgCode::n_Lambda_

Definition at line 979 of file pdgcode.h.

◆ Z_

std::uint32_t smash::PdgCode::Z_

Definition at line 980 of file pdgcode.h.

◆ A_

std::uint32_t smash::PdgCode::A_

Definition at line 981 of file pdgcode.h.

◆ I_

std::uint32_t smash::PdgCode::I_

Definition at line 982 of file pdgcode.h.

◆ is_nucleus_ [2/2]

bool smash::PdgCode::is_nucleus_

Definition at line 983 of file pdgcode.h.

◆

struct { ... } smash::PdgCode::nucleus_

Structure for the nuclei.

◆

union { ... }

The union holds the data; either as a single integer dump_, as a single-digit bitfield digits_ or as a multiple-digits bitfield chunks_.

The documentation for this class was generated from the following files:

src/include/smash/pdgcode.h
src/pdgcode.cc

Usage:

Internals

Representing nuclei

Limitations:

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Constructor & Destructor Documentation

◆ PdgCode() [1/5]

◆ PdgCode() [2/5]

◆ PdgCode() [3/5]

◆ PdgCode() [4/5]

◆ PdgCode() [5/5]

Member Function Documentation

◆ test_code()

◆ check()

◆ dump()

◆ code()

◆ string()

◆ get_antiparticle()

◆ from_decimal()

◆ is_nucleus()

◆ is_hadron()

◆ is_lepton()

◆ is_neutrino()

◆ is_charmonia()

◆ baryon_number()

◆ is_baryon()

◆ is_meson()

◆ is_nucleon()

◆ is_proton()

◆ is_neutron()

◆ is_Nstar1535()

◆ is_Delta()

◆ is_hyperon()

◆ is_Omega()

◆ is_Xi()

◆ is_Lambda()

◆ is_Sigma()

◆ is_Sigmastar()

◆ is_kaon()

◆ is_pion()

◆ is_omega()

◆ is_rho()

◆ is_deuteron()

◆ is_triton()

◆ has_antiparticle()

◆ isospin3()

◆ frac_strange()

◆ frac_charm()

◆ frac_bottom()

◆ is_heavy_flavor()

◆ strangeness()

◆ charmness()

◆ bottomness()

◆ charge()

◆ spin()

◆ spin_degeneracy()

◆ antiparticle_sign()

◆ quarks()

◆ quark_content()

◆ contains_enough_valence_quarks()

◆ operator<()

◆ operator==()

◆ operator!=()

◆ is_antiparticle_of()

◆ invalid()

◆ get_decimal()

◆ deexcite()

◆ net_quark_number()

◆ nucleus_p()

◆ nucleus_n()

◆ nucleus_La()

◆ nucleus_ap()

◆ nucleus_an()

◆ nucleus_aLa()

◆ nucleus_A()

◆ pad0