Version: SMASH-3.1
Classes | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
smash::PdgCode Class Reference
Abstractions for data (particles, branches)

#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());
smash::PdgCode::PdgCode
PdgCode()
Standard initializer.
Definition: pdgcode.h:128
smash::PdgCode::invalid
static PdgCode invalid()
PdgCode 0x0 is guaranteed not to be valid by the PDG standard, but it passes all tests here,...
Definition: pdgcode.h:758

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 111 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
 
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_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
 
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 128 of file pdgcode.h.

128 : dump_(0x0) {}
smash::PdgCode::dump_
std::uint32_t dump_
The bitfield dumped into a single integer.
Definition: pdgcode.h:889

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

134  {
135  set_from_string(codestring);
136  }
smash::PdgCode::set_from_string
void set_from_string(const std::string &codestring)
Set the PDG code from the given string.
Definition: pdgcode.h:980

◆ 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]codenumbera 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 146 of file pdgcode.h.

146  : dump_(0x0) { // NOLINT(runtime/explicit)
147  digits_.antiparticle_ = false;
148  if (codenumber < 0) {
149  digits_.antiparticle_ = true;
150  codenumber = -codenumber;
151  }
152  set_fields(codenumber);
153  }
smash::PdgCode::digits_
struct smash::PdgCode::@0::@2 digits_
The single digits collection of the code.
smash::PdgCode::set_fields
void set_fields(std::uint32_t abscode)
Sets the bitfield from an unsigned integer.
Definition: pdgcode.h:1085

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

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

◆ 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:102
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]codenumberThe hexadecimal PDG code
Template Parameters
TThe type of the PDG code, irrelevant for the user and deduced by the compiler

Definition at line 220 of file pdgcode.h.

223  : PdgCode{std::invoke([&codenumber]() {
224  std::stringstream stream;
225  char sign = '+';
226  if (codenumber < 0) {
227  sign = '-';
228  codenumber = -codenumber;
229  }
230  stream << sign << std::hex << codenumber;
231  return stream.str();
232  })} {}

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

253  {
254  int fail = 0;
255  if (digits_.n_ > 9) {
256  fail |= 1 << 6;
257  }
258  if (digits_.n_R_ > 9) {
259  fail |= 1 << 5;
260  }
261  if (digits_.n_L_ > 9) {
262  fail |= 1 << 4;
263  }
264  if (digits_.n_q1_ > 6) {
265  fail |= 1 << 3;
266  }
267  if (digits_.n_q2_ > 6) {
268  fail |= 1 << 2;
269  }
270  if (digits_.n_q3_ > 6) {
271  fail |= 1 << 1;
272  }
273  if (digits_.n_J_ > 15) {
274  fail |= 1;
275  }
276  return fail;
277  }

◆ check()

void smash::PdgCode::check ( ) const
inline

Do all sorts of validity checks.

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

Definition at line 287 of file pdgcode.h.

287  {
288  // n_J must be odd for mesons and even for baryons (and cannot be zero)
289  if (is_hadron()) {
290  if (baryon_number() == 0) {
291  // mesons: special cases K0_L=0x130 and K0_S=0x310
292  if ((digits_.n_J_ % 2 == 0) && dump() != 0x130 && dump() != 0x310) {
293  throw InvalidPdgCode("Invalid PDG code " + string() +
294  " (meson with even n_J)");
295  }
296  } else {
297  if ((digits_.n_J_ % 2 != 0) || digits_.n_J_ == 0) {
298  throw InvalidPdgCode("Invalid PDG code " + string() +
299  " (baryon with odd n_J)");
300  }
301  }
302  } else {
303  if (digits_.n_J_ == 0 && dump() != 0x0) {
304  throw InvalidPdgCode("Invalid PDG code " + string() + " (n_J==0)");
305  }
306  }
307  /* The antiparticle flag only makes sense for particle types
308  * that have an antiparticle. */
309  if (digits_.antiparticle_ && !has_antiparticle()) {
310  throw InvalidPdgCode("Invalid PDG code " + string() +
311  " (cannot be negative)");
312  }
313  }
smash::PdgCode::baryon_number
int baryon_number() const
Definition: pdgcode.h:381
smash::PdgCode::dump
std::uint32_t dump() const
Dumps the bitfield into an unsigned integer.
Definition: pdgcode.h:316
smash::PdgCode::is_hadron
bool is_hadron() const
Definition: pdgcode.h:370
smash::PdgCode::has_antiparticle
bool has_antiparticle() const
Definition: pdgcode.h:490

◆ dump()

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

Dumps the bitfield into an unsigned integer.

Definition at line 316 of file pdgcode.h.

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

◆ code()

std::int32_t smash::PdgCode::code ( ) const
inline
Returns
a signed integer with the PDG code in hexadecimal.

Definition at line 322 of file pdgcode.h.

322 { return antiparticle_sign() * ucode(); }
smash::PdgCode::antiparticle_sign
int antiparticle_sign() const
Definition: pdgcode.h:651
smash::PdgCode::ucode
std::uint32_t ucode() const
Definition: pdgcode.h:934

◆ string()

std::string smash::PdgCode::string ( ) const
inline
Returns
the PDG Code as a decimal string.

Definition at line 325 of file pdgcode.h.

325  {
326  std::stringstream ss;
327  ss << get_decimal();
328  return ss.str();
329  }
smash::PdgCode::get_decimal
int32_t get_decimal() const
Definition: pdgcode.h:769

◆ get_antiparticle()

PdgCode smash::PdgCode::get_antiparticle ( ) const
inline

Construct the antiparticle to a given PDG code.

Definition at line 332 of file pdgcode.h.

332  {
333  PdgCode result = *this;
334  result.digits_.antiparticle_ = !digits_.antiparticle_;
335  return result;
336  }

◆ from_decimal()

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

Construct PDG code from decimal number.

Parameters
[in]pdgcode_decimaldecimal integer representing the PDG code

Definition at line 342 of file pdgcode.h.

342  {
343  // Nucleus and special codes with 2J+1 > 9
344  if (std::abs(pdgcode_decimal) > 1E7) {
345  return PdgCode(std::to_string(pdgcode_decimal));
346  }
347  int a = pdgcode_decimal;
348  int hex_pdg = 0, tmp = 1;
349  while (a) {
350  hex_pdg += (a % 10) * tmp;
351  tmp *= 16;
352  a = a / 10;
353  }
354  return PdgCode(hex_pdg);
355  }

◆ is_nucleus()

bool smash::PdgCode::is_nucleus ( ) const
inline
Returns
true if this is a nucleus, false otherwise

Definition at line 364 of file pdgcode.h.

364  {
365  assert(digits_.is_nucleus_ == nucleus_.is_nucleus_);
366  return nucleus_.is_nucleus_;
367  }
smash::PdgCode::nucleus_
struct smash::PdgCode::@0::@4 nucleus_
Structure for the nuclei.

◆ is_hadron()

bool smash::PdgCode::is_hadron ( ) const
inline
Returns
true if this is a baryon, antibaryon or meson.

Definition at line 370 of file pdgcode.h.

370  {
371  return (digits_.n_q3_ != 0 && digits_.n_q2_ != 0 && !is_nucleus());
372  }
smash::PdgCode::is_nucleus
bool is_nucleus() const
Definition: pdgcode.h:364

◆ is_lepton()

bool smash::PdgCode::is_lepton ( ) const
inline
Returns
true if this is a lepton.

Definition at line 375 of file pdgcode.h.

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

◆ baryon_number()

int smash::PdgCode::baryon_number ( ) const
inline
Returns
the baryon number of the particle.

Definition at line 381 of file pdgcode.h.

381  {
382  if (is_nucleus()) {
383  return static_cast<int>(nucleus_.A_) * antiparticle_sign();
384  }
385  if (!is_hadron() || digits_.n_q1_ == 0) {
386  return 0;
387  }
388  return antiparticle_sign();
389  }

◆ is_baryon()

bool smash::PdgCode::is_baryon ( ) const
inline
Returns
whether this PDG code identifies a baryon.

Definition at line 391 of file pdgcode.h.

391 { 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 394 of file pdgcode.h.

394 { 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 397 of file pdgcode.h.

397  {
398  const auto abs_code = std::abs(code());
399  return (abs_code == pdg::p || abs_code == pdg::n);
400  }
smash::PdgCode::code
std::int32_t code() const
Definition: pdgcode.h:322
smash::pdg::p
constexpr int p
Proton.
Definition: pdgcode_constants.h:28
smash::pdg::n
constexpr int n
Neutron.
Definition: pdgcode_constants.h:30

◆ is_proton()

bool smash::PdgCode::is_proton ( ) const
inline
Returns
whether this is a proton/anti-proton

Definition at line 403 of file pdgcode.h.

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

◆ is_neutron()

bool smash::PdgCode::is_neutron ( ) const
inline
Returns
whether this is a neutron/anti-neutron

Definition at line 409 of file pdgcode.h.

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

◆ is_Nstar1535()

bool smash::PdgCode::is_Nstar1535 ( ) const
inline
Returns
whether this is a N*(1535) (+/0)

Definition at line 415 of file pdgcode.h.

415  {
416  const auto abs_code = std::abs(code());
417  return (abs_code == pdg::N1535_p || abs_code == pdg::N1535_z);
418  }
smash::pdg::N1535_z
constexpr int N1535_z
N(1535)⁰.
Definition: pdgcode_constants.h:40
smash::pdg::N1535_p
constexpr int N1535_p
N(1535)⁺.
Definition: pdgcode_constants.h:38

◆ is_Delta()

bool smash::PdgCode::is_Delta ( ) const
inline
Returns
whether this is a Delta(1232) (with anti-delta)

Definition at line 421 of file pdgcode.h.

421  {
422  const auto abs_code = std::abs(code());
423  return (abs_code == pdg::Delta_pp || abs_code == pdg::Delta_p ||
424  abs_code == pdg::Delta_z || abs_code == pdg::Delta_m);
425  }
smash::pdg::Delta_p
constexpr int Delta_p
Δ⁺.
Definition: pdgcode_constants.h:45
smash::pdg::Delta_pp
constexpr int Delta_pp
Δ⁺⁺.
Definition: pdgcode_constants.h:43
smash::pdg::Delta_m
constexpr int Delta_m
Δ⁻.
Definition: pdgcode_constants.h:49
smash::pdg::Delta_z
constexpr int Delta_z
Δ⁰.
Definition: pdgcode_constants.h:47

◆ is_hyperon()

bool smash::PdgCode::is_hyperon ( ) const
inline
Returns
whether this is a hyperon (Lambda, Sigma, Xi, Omega)

Definition at line 428 of file pdgcode.h.

428 { 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 431 of file pdgcode.h.

431  {
432  return is_hyperon() && digits_.n_q2_ == 3 && digits_.n_q3_ == 3;
433  }
smash::PdgCode::is_hyperon
bool is_hyperon() const
Definition: pdgcode.h:428

◆ is_Xi()

bool smash::PdgCode::is_Xi ( ) const
inline
Returns
whether this is a Xi baryon

Definition at line 436 of file pdgcode.h.

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

◆ is_Lambda()

bool smash::PdgCode::is_Lambda ( ) const
inline
Returns
whether this is a Lambda baryon

Definition at line 441 of file pdgcode.h.

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

◆ is_Sigma()

bool smash::PdgCode::is_Sigma ( ) const
inline
Returns
whether this is a Sigma baryon

Definition at line 446 of file pdgcode.h.

446  {
447  return is_hyperon() && digits_.n_q2_ != 3 && !is_Lambda();
448  }
smash::PdgCode::is_Lambda
bool is_Lambda() const
Definition: pdgcode.h:441

◆ is_kaon()

bool smash::PdgCode::is_kaon ( ) const
inline
Returns
whether this is a kaon (K+, K-, K0, Kbar0)

Definition at line 451 of file pdgcode.h.

451  {
452  const auto abs_code = std::abs(code());
453  return (abs_code == pdg::K_p) || (abs_code == pdg::K_z);
454  }
smash::pdg::K_p
constexpr int K_p
K⁺.
Definition: pdgcode_constants.h:74
smash::pdg::K_z
constexpr int K_z
K⁰.
Definition: pdgcode_constants.h:76

◆ is_pion()

bool smash::PdgCode::is_pion ( ) const
inline
Returns
whether this is a pion (pi+/pi0/pi-)

Definition at line 457 of file pdgcode.h.

457  {
458  const auto c = code();
459  return (c == pdg::pi_z) || (c == pdg::pi_p) || (c == pdg::pi_m);
460  }
smash::pdg::pi_p
constexpr int pi_p
π⁺.
Definition: pdgcode_constants.h:67
smash::pdg::pi_z
constexpr int pi_z
π⁰.
Definition: pdgcode_constants.h:69
smash::pdg::pi_m
constexpr int pi_m
π⁻.
Definition: pdgcode_constants.h:71

◆ is_omega()

bool smash::PdgCode::is_omega ( ) const
inline
Returns
whether this is an omega meson

Definition at line 463 of file pdgcode.h.

463  {
464  const auto c = code();
465  return c == pdg::omega;
466  }
smash::pdg::omega
constexpr int omega
ω.
Definition: pdgcode_constants.h:85

◆ is_rho()

bool smash::PdgCode::is_rho ( ) const
inline
Returns
whether this is a rho meson (rho+/rho0/rho-)

Definition at line 469 of file pdgcode.h.

469  {
470  const auto c = code();
471  return (c == pdg::rho_z) || (c == pdg::rho_p) || (c == pdg::rho_m);
472  }
smash::pdg::rho_p
constexpr int rho_p
ρ⁺.
Definition: pdgcode_constants.h:88
smash::pdg::rho_m
constexpr int rho_m
ρ⁻.
Definition: pdgcode_constants.h:92
smash::pdg::rho_z
constexpr int rho_z
ρ⁰.
Definition: pdgcode_constants.h:90

◆ is_deuteron()

bool smash::PdgCode::is_deuteron ( ) const
inline
Returns
whether this is (anti-)deuteron

Definition at line 475 of file pdgcode.h.

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

◆ is_triton()

bool smash::PdgCode::is_triton ( ) const
inline
Returns
whether this is (anti-)triton

Definition at line 481 of file pdgcode.h.

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

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

490  {
491  if (is_nucleus()) {
492  return true;
493  }
494  if (is_hadron()) {
495  return (baryon_number() != 0) || (digits_.n_q2_ != digits_.n_q3_);
496  } else {
497  return digits_.n_q3_ == 1; // leptons!
498  }
499  }

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

506  {
507  /* net_quark_number(2) is the number of u quarks,
508  * net_quark_number(1) is the number of d quarks. */
509  return net_quark_number(2) - net_quark_number(1);
510  }
smash::PdgCode::net_quark_number
int net_quark_number(const int quark) const
Returns the net number of quarks with given flavour number For public use, see strangeness(),...
Definition: pdgcode.cc:31

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

519  {
520  /* The quarkonium state has 0 net strangeness
521  * but there are actually 2 strange quarks out of 2 total */
522  if (is_hadron() && digits_.n_q3_ == 3 && digits_.n_q2_ == 3) {
523  return 1.;
524  } else {
525  // For all other cases, there isn't both a strange and anti-strange
526  if (is_baryon()) {
527  return std::abs(strangeness()) / 3.;
528  } else if (is_meson()) {
529  return std::abs(strangeness()) / 2.;
530  } else {
531  /* If not baryon or meson, this should be 0, as AQM does not
532  * extend to non-hadrons */
533  return 0.;
534  }
535  }
536  }
smash::PdgCode::is_meson
bool is_meson() const
Definition: pdgcode.h:394
smash::PdgCode::strangeness
int strangeness() const
Definition: pdgcode.h:543
smash::PdgCode::is_baryon
bool is_baryon() const
Definition: pdgcode.h:391

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

543 { 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 550 of file pdgcode.h.

550 { 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 557 of file pdgcode.h.

557 { 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 567 of file pdgcode.h.

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

◆ 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_errorif a spin of a nucleus is not coded in and has to be guessed

Definition at line 608 of file pdgcode.h.

608  {
609  if (is_nucleus()) {
610  // Generally spin of a nucleus cannot be simply guessed, it should be
611  // provided from some table. However, here we only care about a
612  // limited set of light nuclei with A <= 4.
613  if (nucleus_.A_ == 2) {
614  // Deuteron spin is 1
615  return 2;
616  } else if (nucleus_.A_ == 3) {
617  // Tritium and He-3 spin are 1/2
618  // Hypertriton spin is not firmly determined, but decay branching ratios
619  // indicate spin 1/2
620  return 1;
621  } else if (nucleus_.A_ == 4) {
622  // He-4 spin is 0
623  return 0;
624  }
625  throw std::runtime_error("Unknown spin of nucleus.");
626  // Alternative possibility is to guess 1/2 for fermions and 0 for bosons
627  // as 2 * (nucleus_.A_ % 2).
628  }
629 
630  if (is_hadron()) {
631  if (digits_.n_J_ == 0) {
632  return 0; // special cases: K0_L=0x130 & K0_S=0x310
633  } else {
634  return digits_.n_J_ - 1;
635  }
636  }
637  /* this assumes that we only have white particles (no single
638  * quarks): Electroweak fermions have 11-17, so the
639  * second-to-last-digit is the spin. The same for the Bosons: they
640  * have 21-29 and 2spin = 2 (this fails for the Higgs). */
641  return digits_.n_q3_;
642  }

◆ spin_degeneracy()

unsigned int smash::PdgCode::spin_degeneracy ( ) const
inline
Returns
the spin degeneracy \(2s + 1\) of a particle.

Definition at line 644 of file pdgcode.h.

644  {
645  if (is_hadron() && digits_.n_J_ > 0) {
646  return digits_.n_J_;
647  }
648  return spin() + 1;
649  }
smash::PdgCode::spin
unsigned int spin() const
Definition: pdgcode.h:608

◆ antiparticle_sign()

int smash::PdgCode::antiparticle_sign ( ) const
inline
Returns
-1 for antiparticles and +1 for particles.

Definition at line 651 of file pdgcode.h.

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

◆ quarks()

std::int32_t smash::PdgCode::quarks ( ) const
inline
Returns
an integer with only the quark numbers set.

Definition at line 655 of file pdgcode.h.

655  {
656  if (!is_hadron() || is_nucleus()) {
657  return 0;
658  }
659  return chunks_.quarks_;
660  }
smash::PdgCode::chunks_
struct smash::PdgCode::@0::@3 chunks_
Chunk collection: here, the chunks with and are directly accessible.

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

671  {
672  std::array<int, 3> result = {static_cast<int>(digits_.n_q1_),
673  static_cast<int>(digits_.n_q2_),
674  static_cast<int>(digits_.n_q3_)};
675  if (is_hadron()) {
676  // Antibaryons
677  if (digits_.n_q1_ != 0 && digits_.antiparticle_) {
678  for (size_t i = 0; i < 3; i++) {
679  result[i] = -result[i];
680  }
681  }
682  // Mesons
683  if (digits_.n_q1_ == 0) {
684  // Own antiparticle
685  if (digits_.n_q2_ == digits_.n_q3_) {
686  result[2] = -result[2];
687  } else {
688  // Like pi-
689  if (digits_.antiparticle_) {
690  result[1] = -result[1];
691  // Like pi+
692  } else {
693  result[2] = -result[2];
694  }
695  }
696  // add extra minus sign according to the pdg convention
697  if (digits_.n_q2_ != digits_.n_q3_ && digits_.n_q2_ % 2 == 1) {
698  for (int i = 1; i <= 2; i++) {
699  result[i] = -result[i];
700  }
701  }
702  }
703  } else {
704  result = {0, 0, 0};
705  }
706  return result;
707  }

◆ 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_requirednumber of valence quarks that particle is supposed to contain.
Exceptions
std::runtime_errorif it is not a hadron

This is necessary for string fragmentation.

Definition at line 92 of file pdgcode.cc.

93  {
94  if (is_meson()) {
95  return valence_quarks_required == 1 || valence_quarks_required == -1;
96  }
97  if (is_baryon()) {
98  if (baryon_number() == 1) {
99  return valence_quarks_required == 1 || valence_quarks_required == 2;
100  }
101  if (baryon_number() == -1) {
102  return valence_quarks_required == -1 || valence_quarks_required == -2;
103  }
104  }
105  throw std::runtime_error("String fragment is neither baryon nor meson");
106 }

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

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

◆ operator==()

bool smash::PdgCode::operator== ( const PdgCode  rhs) const
inline
Returns
if the codes are equal

Definition at line 740 of file pdgcode.h.

740 { return dump_ == rhs.dump_; }

◆ operator!=()

bool smash::PdgCode::operator!= ( const PdgCode  rhs) const
inline
Returns
if the codes are not equal.

Definition at line 743 of file pdgcode.h.

743 { 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 746 of file pdgcode.h.

746  {
747  return code() == -rhs.code();
748  }

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

758 { 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
InvalidPdgCodeif the spin degeneracy is larger than 9

Definition at line 769 of file pdgcode.h.

769  {
770  if (is_nucleus()) {
771  // ±10LZZZAAAI
772  return antiparticle_sign() *
773  (nucleus_.I_ + 10 * nucleus_.A_ + 10000 * nucleus_.Z_ +
774  10000000 * nucleus_.n_Lambda_ + 1000000000);
775  }
776  int n_J_1 = 0;
777  int n_J_2 = digits_.n_J_;
778  if (n_J_2 > 9) {
779  n_J_1 = n_J_2 - 9;
780  n_J_2 = 9;
781  }
782  return antiparticle_sign() *
783  (n_J_2 + digits_.n_q3_ * 10 + digits_.n_q2_ * 100 +
784  digits_.n_q1_ * 1000 + digits_.n_L_ * 10000 +
785  digits_.n_R_ * 100000 + digits_.n_ * 1000000 + n_J_1 * 10000000);
786  }

◆ deexcite()

void smash::PdgCode::deexcite ( )
inline

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

Definition at line 789 of file pdgcode.h.

789  {
790  if (!is_nucleus()) {
791  chunks_.excitation_ = 0;
792  } else {
793  nucleus_.I_ = 0;
794  }
795  }

◆ 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]quarkPDG Code of quark: (1..6) = (d,u,s,c,b,t)
Returns
for the net number of quarks (#quarks - #antiquarks)
Exceptions
std::invalid_argumentif quark is not any of d, u, s, c, b and t quarks

Definition at line 31 of file pdgcode.cc.

31  {
32  // input sanitization: Only quark numbers 1 through 6 are allowed.
33  if (quark < 1 || quark > 6) {
34  throw std::invalid_argument(
35  std::string("PdgCode::net_quark_number(): ") +
36  std::string("Quark number must be in [1..6], received ") +
37  std::to_string(quark));
38  }
39  if (is_nucleus()) {
40  const int Np = nucleus_.Z_;
41  const int Nn = nucleus_.A_ - nucleus_.Z_ - nucleus_.n_Lambda_;
42  const int NL = nucleus_.n_Lambda_;
43  switch (quark) {
44  case 1:
45  return (2 * Nn + Np + NL) * antiparticle_sign();
46  case 2:
47  return (Nn + 2 * Np + NL) * antiparticle_sign();
48  case 3:
49  return NL * antiparticle_sign();
50  // Charmed nuclei may exist, but they are not foreseen by PDG standard
51  default:
52  return 0.0;
53  }
54  }
55  // non-hadrons and those that have none of this quark type: 0.
56  if (!is_hadron() || (digits_.n_q1_ != quark && digits_.n_q2_ != quark &&
57  digits_.n_q3_ != quark)) {
58  return 0;
59  }
60  // baryons: count quarks.
61  if (baryon_number() != 0) {
62  // for anti-baryons, the sign changes:
63  return antiparticle_sign() *
64  ((digits_.n_q1_ == quark) + (digits_.n_q2_ == quark) +
65  (digits_.n_q3_ == quark));
66  }
67 
68  // mesons.
69 
70  // quarkonium state? Not open net_quark_number.
71  if (digits_.n_q3_ == quark && digits_.n_q2_ == quark) {
72  return 0;
73  }
74  /* this has covered all the easy stuff
75  * get the "other" quark. (We know this must exist, since they are
76  * not both the right one and one of them is the right one). */
77  int otherquark = (digits_.n_q2_ == quark) ? digits_.n_q3_ : digits_.n_q2_;
78  /* "our" quark is the heavier one: 1 for u,c,t; -1 for d,s,b (and of
79  * course the antiparticle sign) */
80  if (quark > otherquark) {
81  return ((quark % 2 == 0) ? 1 : -1) * antiparticle_sign();
82  }
83  /* ours is the lighter: If the heavier particle is u,c,t, the lighter
84  * one (ours) is an antiquark. */
85  return ((otherquark % 2 == 0) ? -1 : 1) * antiparticle_sign();
86 }

◆ nucleus_p()

int smash::PdgCode::nucleus_p ( ) const
inline

Number of protons in nucleus.

Definition at line 810 of file pdgcode.h.

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

◆ nucleus_n()

int smash::PdgCode::nucleus_n ( ) const
inline

Number of neutrons in nucleus.

Definition at line 814 of file pdgcode.h.

814  {
815  return (is_nucleus() && !nucleus_.antiparticle_)
816  ? nucleus_.A_ - nucleus_.Z_ - nucleus_.n_Lambda_
817  : 0;
818  }

◆ nucleus_La()

int smash::PdgCode::nucleus_La ( ) const
inline

Number of Lambdas in nucleus.

Definition at line 820 of file pdgcode.h.

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

◆ nucleus_ap()

int smash::PdgCode::nucleus_ap ( ) const
inline

Number of antiprotons in nucleus.

Definition at line 824 of file pdgcode.h.

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

◆ nucleus_an()

int smash::PdgCode::nucleus_an ( ) const
inline

Number of antineutrons in nucleus.

Definition at line 828 of file pdgcode.h.

828  {
829  return (is_nucleus() && nucleus_.antiparticle_)
830  ? nucleus_.A_ - nucleus_.Z_ - nucleus_.n_Lambda_
831  : 0;
832  }

◆ nucleus_aLa()

int smash::PdgCode::nucleus_aLa ( ) const
inline

Number of anti-Lambdas in nucleus.

Definition at line 834 of file pdgcode.h.

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

◆ nucleus_A()

int smash::PdgCode::nucleus_A ( ) const
inline

Nucleus mass number.

Definition at line 838 of file pdgcode.h.

838 { 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 934 of file pdgcode.h.

934 { 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]inpcharacter which is translated into digit
Exceptions
InvalidPdgCodeif character does not correspond to digit

Definition at line 942 of file pdgcode.h.

942  {
943  // Decimal digit
944  if (48 <= inp && inp <= 57) {
945  return inp - 48;
946  }
947  // Hexdecimal digit, uppercase
948  if (65 <= inp && inp <= 70) {
949  return inp - 65 + 10;
950  }
951  // Hexdecimal digit, lowercase
952  if (97 <= inp && inp <= 102) {
953  return inp - 97 + 10;
954  }
955  throw InvalidPdgCode("PdgCode: Invalid character " + std::string(&inp, 1) +
956  " found.\n");
957  }

◆ 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]codestringstring which is translated into PdgCode
Exceptions
InvalidPdgCodeif the input string is empty
InvalidPdgCodeif it is a nucleus whose PDG code does not begin with 10
InvalidPdgCodeif it is not a nucleus while number of digits is more than 8
InvalidPdgCodeif the 1st quark field is not any of d, u, s, c, b and t quarks
InvalidPdgCodeif the 2nd quark field is not any of d, u, s, c, b and t quarks
InvalidPdgCodeif the 3rd quark field is not any of d, u, s, c, b and t quarks
InvalidPdgCodeif there is nothing else but sign

Definition at line 980 of file pdgcode.h.

980  {
981  dump_ = 0;
982  // Implicit with the above: digits_.antiparticle_ = false;
983  digits_.n_ = digits_.n_R_ = digits_.n_L_ = digits_.n_q1_ = digits_.n_q2_ =
984  digits_.n_q3_ = digits_.n_J_ = digits_.is_nucleus_ = 0;
985  size_t length = codestring.size();
986  if (length < 1) {
987  throw InvalidPdgCode("Empty string does not contain PDG Code\n");
988  }
989  int c = 0;
990  /* Look at current character; if it is a + or minus sign, read it
991  * and advance to next char. */
992  if (codestring[c] == '-') {
993  digits_.antiparticle_ = true;
994  ++c;
995  } else if (codestring[c] == '+') {
996  digits_.antiparticle_ = false;
997  ++c;
998  }
999  // Save if the first character was a sign:
1000  unsigned int sign = c;
1001 
1002  // Nucleus
1003  if (length == 10 + sign) {
1004  nucleus_.is_nucleus_ = true;
1005  if (codestring[c] != '1' || codestring[c + 1] != '0') {
1006  throw InvalidPdgCode("Pdg code of nucleus \"" + codestring +
1007  "\" should start with 10\n");
1008  }
1009  c += 2;
1010  // ±10LZZZAAAI is the standard for nuclei
1011  std::array<int, 8> digits;
1012  for (int i = 0; i < 8; i++) {
1013  digits[i] = get_digit_from_char(codestring[c + i]);
1014  }
1015  nucleus_.n_Lambda_ = digits[0];
1016  nucleus_.Z_ = 100 * digits[1] + 10 * digits[2] + digits[3];
1017  nucleus_.A_ = 100 * digits[4] + 10 * digits[5] + digits[6];
1018  nucleus_.I_ = digits[7];
1019  return;
1020  }
1021 
1022  // Codestring shouldn't be longer than 8 + sign, except for nuclei
1023  if (length > 8 + sign) {
1024  throw InvalidPdgCode("String \"" + codestring +
1025  "\" too long for PDG Code\n");
1026  }
1027  /* Please note that in what follows, we actually need c++, not ++c.
1028  * first digit is used for n_J if the last digit is not enough. */
1029  if (length > 7 + sign) {
1030  digits_.n_J_ += get_digit_from_char(codestring[c++]);
1031  }
1032  // Codestring has 7 digits? 7th from last goes in n_.
1033  if (length > 6 + sign) {
1034  digits_.n_ = get_digit_from_char(codestring[c++]);
1035  }
1036  // It has 6 or 7 digits? 6th from last is n_R_.
1037  if (length > 5 + sign) {
1038  digits_.n_R_ = get_digit_from_char(codestring[c++]);
1039  }
1040  // 5th from last is n_L_.
1041  if (length > 4 + sign) {
1042  digits_.n_L_ = get_digit_from_char(codestring[c++]);
1043  }
1044  // 4th from last is n_q1_.
1045  if (length > 3 + sign) {
1046  digits_.n_q1_ = get_digit_from_char(codestring[c++]);
1047  if (digits_.n_q1_ > 6) {
1048  throw InvalidPdgCode("Invalid PDG code " + codestring + " (n_q1>6)");
1049  }
1050  }
1051  // 3rd from last is n_q2_.
1052  if (length > 2 + sign) {
1053  digits_.n_q2_ = get_digit_from_char(codestring[c++]);
1054  if (digits_.n_q2_ > 6) {
1055  throw InvalidPdgCode("Invalid PDG code " + codestring + " (n_q2>6)");
1056  }
1057  }
1058  // Next to last is n_q3_.
1059  if (length > 1 + sign) {
1060  digits_.n_q3_ = get_digit_from_char(codestring[c++]);
1061  if (digits_.n_q3_ > 6) {
1062  throw InvalidPdgCode("Invalid PDG code " + codestring + " (n_q3>6)");
1063  }
1064  }
1065  // Last digit is the spin degeneracy.
1066  if (length > sign) {
1067  digits_.n_J_ += get_digit_from_char(codestring[c++]);
1068  } else {
1069  throw InvalidPdgCode(
1070  "String \"" + codestring +
1071  "\" only consists of a sign, that is no valid PDG Code\n");
1072  }
1073  check();
1074  }
smash::PdgCode::check
void check() const
Do all sorts of validity checks.
Definition: pdgcode.h:287
smash::PdgCode::get_digit_from_char
std::uint32_t get_digit_from_char(const char inp) const
Definition: pdgcode.h:942

◆ 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]abscodeinteger which replace PDG code except sign
Exceptions
InvalidPdgCodeif input is not a valid PDG code
See also
PdgCode::test_code

Definition at line 1085 of file pdgcode.h.

1085  {
1086  /* "dump_ =" overwrites antiparticle_, but this needs to have been set
1087  * already, so we carry it around the assignment. */
1088  bool ap = digits_.antiparticle_;
1089  dump_ = abscode & 0x0fffffff;
1090  digits_.antiparticle_ = ap;
1091  int test = test_code();
1092  if (test > 0) {
1093  throw InvalidPdgCode("Invalid digits " + std::to_string(test) +
1094  " in PDG Code " + string());
1095  }
1096  check();
1097  }
smash::PdgCode::test_code
int test_code() const
Checks the integer for invalid hex digits.
Definition: pdgcode.h:253

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]isinput string
[out]codePdgCode to be set

Definition at line 14 of file pdgcode.cc.

14  {
15  std::string codestring("");
16  is >> codestring;
17  if (!is) {
18  code = PdgCode::invalid();
19  return is;
20  }
21  try {
22  // set the fields from the string:
23  code.set_from_string(codestring);
24  } catch (PdgCode::InvalidPdgCode&) {
25  is.setstate(std::ios::failbit);
26  code = PdgCode::invalid();
27  }
28  return is;
29 }

Member Data Documentation

◆ n_J_

std::uint32_t smash::PdgCode::n_J_

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

Definition at line 854 of file pdgcode.h.

◆ n_q3_

std::uint32_t smash::PdgCode::n_q3_

third quark field

Definition at line 856 of file pdgcode.h.

◆ n_q2_

std::uint32_t smash::PdgCode::n_q2_

second quark field

Definition at line 858 of file pdgcode.h.

◆ n_q1_

std::uint32_t smash::PdgCode::n_q1_

first quark field. 0 for mesons.

Definition at line 860 of file pdgcode.h.

◆ n_L_

std::uint32_t smash::PdgCode::n_L_

"angular momentum"

Definition at line 862 of file pdgcode.h.

◆ n_R_

std::uint32_t smash::PdgCode::n_R_

"radial excitation"

Definition at line 864 of file pdgcode.h.

◆ n_

std::uint32_t smash::PdgCode::n_

first field: "counter"

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

◆ antiparticle_

bool smash::PdgCode::antiparticle_

first bit: stores the sign.

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

◆ __pad0__

std::uint32_t smash::PdgCode::__pad0__

Definition at line 896 of file pdgcode.h.

◆ quarks_

std::uint32_t smash::PdgCode::quarks_

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

Definition at line 898 of file pdgcode.h.

◆ excitation_

std::uint32_t smash::PdgCode::excitation_

The excitation digits n_, n_R_, n_L_.

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

◆ Z_

std::uint32_t smash::PdgCode::Z_

Definition at line 912 of file pdgcode.h.

◆ A_

std::uint32_t smash::PdgCode::A_

Definition at line 913 of file pdgcode.h.

◆ I_

std::uint32_t smash::PdgCode::I_

Definition at line 914 of file pdgcode.h.

◆ is_nucleus_ [2/2]

bool smash::PdgCode::is_nucleus_

Definition at line 915 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: