#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.

Collaboration diagram for smash::PdgCode:

[legend]

Classes
struct	InvalidPdgCode

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...

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

int	baryon_number () const

bool	is_baryon () const

bool	is_meson () const

bool	is_nucleon () 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_kaon () const

bool	is_pion () const

bool	is_rho () const

bool	is_deuteron () const

bool	has_antiparticle () const

int	isospin3 () const

double	frac_strange () 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...

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/4]

smash::PdgCode::PdgCode ( )

inline

Standard initializer.

Definition at line 124 of file pdgcode.h.

125 : dump_(0x0) {}

◆ PdgCode() [2/4]

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 130 of file pdgcode.h.

131 {

132 set_from_string(codestring);

◆ PdgCode() [3/4]

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 142 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/4]

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 154 of file pdgcode.h.

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

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 178 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;
     }

◆ 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 212 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 241 of file pdgcode.h.

243 {

244 // this cuts the three unused bits.

◆ code()

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

inline

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

Definition at line 247 of file pdgcode.h.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ string()

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

inline

Returns: the PDG Code as a decimal string.

Definition at line 250 of file pdgcode.h.

                                   {
     std::stringstream ss;
     ss << get_decimal();

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_antiparticle()

PdgCode smash::PdgCode::get_antiparticle ( ) const

inline

Construct the antiparticle to a given PDG code.

Definition at line 257 of file pdgcode.h.

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

Here is the caller graph for this function:

◆ 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 267 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;
     }

Here is the caller graph for this function:

◆ is_nucleus()

bool smash::PdgCode::is_nucleus ( ) const

inline

Returns: true if this is a nucleus, false otherwise

Definition at line 288 of file pdgcode.h.

291 {

Here is the caller graph for this function:

◆ is_hadron()

bool smash::PdgCode::is_hadron ( ) const

inline

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

Definition at line 294 of file pdgcode.h.

297 {

Here is the caller graph for this function:

◆ is_lepton()

bool smash::PdgCode::is_lepton ( ) const

inline

Returns: true if this is a lepton.

Definition at line 299 of file pdgcode.h.

302 {

Here is the caller graph for this function:

◆ baryon_number()

int smash::PdgCode::baryon_number ( ) const

inline

Returns: the baryon number of the particle.

Definition at line 305 of file pdgcode.h.

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

Here is the caller graph for this function:

◆ is_baryon()

bool smash::PdgCode::is_baryon ( ) const

inline

Returns: whether this PDG code identifies a baryon.

Definition at line 315 of file pdgcode.h.

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

Here is the caller graph for this function:

◆ is_meson()

bool smash::PdgCode::is_meson ( ) const

inline

Returns: whether this PDG code identifies a meson.

Definition at line 318 of file pdgcode.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_nucleon()

bool smash::PdgCode::is_nucleon ( ) const

inline

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

Definition at line 321 of file pdgcode.h.

                                { return is_hadron() && digits_.n_q1_ == 0; }
  
   inline bool is_nucleon() const {

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_Nstar1535()

bool smash::PdgCode::is_Nstar1535 ( ) const

inline

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

Definition at line 327 of file pdgcode.h.

330 {

Here is the caller graph for this function:

◆ is_Delta()

bool smash::PdgCode::is_Delta ( ) const

inline

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

Definition at line 333 of file pdgcode.h.

336 {

337 const auto abs_code = std::abs(code());

Here is the caller graph for this function:

◆ is_hyperon()

bool smash::PdgCode::is_hyperon ( ) const

inline

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

Definition at line 340 of file pdgcode.h.

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

Here is the caller graph for this function:

◆ is_Omega()

bool smash::PdgCode::is_Omega ( ) const

inline

Returns: whether this is a Omega baryon

Definition at line 343 of file pdgcode.h.

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

344

Here is the call graph for this function:

◆ is_Xi()

bool smash::PdgCode::is_Xi ( ) const

inline

Returns: whether this is a Xi baryon

Definition at line 348 of file pdgcode.h.

351 {

◆ is_Lambda()

bool smash::PdgCode::is_Lambda ( ) const

inline

Returns: whether this is a Lambda baryon

Definition at line 353 of file pdgcode.h.

356 {

◆ is_Sigma()

bool smash::PdgCode::is_Sigma ( ) const

inline

Returns: whether this is a Sigma baryon

Definition at line 358 of file pdgcode.h.

361 {

◆ is_kaon()

bool smash::PdgCode::is_kaon ( ) const

inline

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

Definition at line 363 of file pdgcode.h.

366 {

Here is the caller graph for this function:

◆ is_pion()

bool smash::PdgCode::is_pion ( ) const

inline

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

Definition at line 369 of file pdgcode.h.

372 {

Here is the caller graph for this function:

◆ is_rho()

bool smash::PdgCode::is_rho ( ) const

inline

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

Definition at line 375 of file pdgcode.h.

378 {

Here is the caller graph for this function:

◆ is_deuteron()

bool smash::PdgCode::is_deuteron ( ) const

inline

Returns: whether this is (anti-)deuteron

Definition at line 381 of file pdgcode.h.

384 {

Here is the caller graph for this function:

◆ 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 390 of file pdgcode.h.

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

Here is the caller graph for this function:

◆ 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 406 of file pdgcode.h.

409 {

410 /* net_quark_number(2) is the number of u quarks,

◆ 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 419 of file pdgcode.h.

                                      {
     /* The quarkonium state has 0 net strangeness
      *  but there are actually 2 strange quarks out of 2 total */
     if (is_hadron() && digits_.n_q3_ == 3 && digits_.n_q2_ == 3) {
       return 1.;
     } else {
       // For all other cases, there isn't both a strange and anti-strange
       if (is_baryon()) {
         return std::abs(strangeness()) / 3.;
       } else if (is_meson()) {
         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.;

Here is the caller graph for this function:

◆ 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 443 of file pdgcode.h.

446 { return -net_quark_number(3); }

Here is the caller graph for this function:

◆ 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 450 of file pdgcode.h.

453 { return +net_quark_number(4); }

Here is the caller graph for this function:

◆ 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 457 of file pdgcode.h.

460 { 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 467 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();
     }

Here is the caller graph for this function:

◆ spin()

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

inline

Todo:: (oliiny): take care of spin for nuclei

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.

Definition at line 506 of file pdgcode.h.

                                    {
     if (is_nucleus()) {
       /* Currently the only nucleus I care about is deutron,
        * which has spin one. */
       return 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

Here is the caller graph for this function:

◆ spin_degeneracy()

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

inline

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

Definition at line 527 of file pdgcode.h.

                                               {
     if (is_hadron() && digits_.n_J_ > 0) {
       return digits_.n_J_;

◆ antiparticle_sign()

int smash::PdgCode::antiparticle_sign ( ) const

inline

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

Definition at line 534 of file pdgcode.h.

537 {

Here is the caller graph for this function:

◆ quarks()

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

inline

Returns: an integer with only the quark numbers set.

Definition at line 538 of file pdgcode.h.

                                        : +1);
   }
   inline std::int32_t quarks() const {
     if (!is_hadron() || is_nucleus()) {
       return 0;

◆ 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 554 of file pdgcode.h.

                         {0, 1, -1} is returned.
    * \return quark content as an array.
    */
   std::array<int, 3> quark_content() const {
     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};

Here is the caller graph for this function:

◆ 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");
 }

Here is the call graph for this function:

◆ 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 613 of file pdgcode.h.

                                                  {
     return dump_ < rhs.dump_;
     /* the complex thing to do here is to calculate:

◆ operator==()

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

inline

Returns: if the codes are equal

Definition at line 622 of file pdgcode.h.

626 { return dump_ == rhs.dump_; }

◆ operator!=()

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

inline

Returns: if the codes are not equal.

Definition at line 625 of file pdgcode.h.

626 { return dump_ == rhs.dump_; }

◆ 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 628 of file pdgcode.h.

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

630

Here is the caller graph for this function:

◆ 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 640 of file pdgcode.h.

644 { return PdgCode(0x0); }

Here is the caller graph for this function:

◆ 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 651 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() *

Here is the caller graph for this function:

◆ deexcite()

void smash::PdgCode::deexcite ( )

inline

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

Definition at line 671 of file pdgcode.h.

                   {
     if (!is_nucleus()) {
       chunks_.excitation_ = 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_;
     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();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 793 of file pdgcode.h.

Here is the caller graph for this function:

◆ 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 801 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;

◆ 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 839 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 +

Here is the caller graph for this function:

◆ 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 944 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) +

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 719 of file pdgcode.h.

◆ n_q3_

std::uint32_t smash::PdgCode::n_q3_

third quark field

Definition at line 721 of file pdgcode.h.

◆ n_q2_

std::uint32_t smash::PdgCode::n_q2_

second quark field

Definition at line 723 of file pdgcode.h.

◆ n_q1_

std::uint32_t smash::PdgCode::n_q1_

first quark field. 0 for mesons.

Definition at line 725 of file pdgcode.h.

◆ n_L_

std::uint32_t smash::PdgCode::n_L_

"angular momentum"

Definition at line 727 of file pdgcode.h.

◆ n_R_

std::uint32_t smash::PdgCode::n_R_

"radial excitation"

Definition at line 729 of file pdgcode.h.

◆ n_

std::uint32_t smash::PdgCode::n_

first field: "counter"

Definition at line 731 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 731 of file pdgcode.h.

◆ antiparticle_

bool smash::PdgCode::antiparticle_

first bit: stores the sign.

Definition at line 735 of file pdgcode.h.

◆ digits_

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 752 of file pdgcode.h.

◆ pad0

std::uint32_t smash::PdgCode::__pad0__

Definition at line 759 of file pdgcode.h.

◆ quarks_

std::uint32_t smash::PdgCode::quarks_

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

Definition at line 761 of file pdgcode.h.

◆ excitation_

std::uint32_t smash::PdgCode::excitation_

The excitation digits n_, n_R_, n_L_.

Definition at line 763 of file pdgcode.h.

◆ chunks_

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 772 of file pdgcode.h.

◆ Z_

std::uint32_t smash::PdgCode::Z_

Definition at line 773 of file pdgcode.h.

◆ A_

std::uint32_t smash::PdgCode::A_

Definition at line 774 of file pdgcode.h.

◆ I_

std::uint32_t smash::PdgCode::I_

Definition at line 775 of file pdgcode.h.

◆ is_nucleus_ [2/2]

bool smash::PdgCode::is_nucleus_

Definition at line 776 of file pdgcode.h.

◆ nucleus_

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

Structure for the nuclei.

◆ @1

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/4]

◆ PdgCode() [2/4]

◆ PdgCode() [3/4]

◆ PdgCode() [4/4]

Member Function Documentation

◆ test_code()

◆ check()

◆ dump()

◆ code()

◆ string()

◆ get_antiparticle()

◆ from_decimal()

◆ is_nucleus()

◆ is_hadron()

◆ is_lepton()

◆ baryon_number()

◆ is_baryon()

◆ is_meson()

◆ is_nucleon()

◆ is_Nstar1535()

◆ is_Delta()

◆ is_hyperon()

◆ is_Omega()

◆ is_Xi()

◆ is_Lambda()

◆ is_Sigma()

◆ is_kaon()

◆ is_pion()

◆ is_rho()

◆ is_deuteron()

◆ has_antiparticle()

◆ isospin3()

◆ frac_strange()

◆ 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()

◆ ucode()

◆ get_digit_from_char()

◆ set_from_string()

◆ set_fields()

Friends And Related Function Documentation

◆ operator>>

Member Data Documentation

◆ n_J_

◆ n_q3_

◆ n_q2_

◆ n_q1_

◆ n_L_

◆ n_R_

◆ n_

◆ is_nucleus_ [1/2]

◆ antiparticle_

◆ digits_

◆ dump_

◆ pad0