Version: SMASH-2.2
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:125
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:679

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

smash::PdgCode::PdgCode ( )
inline

Standard initializer.

Definition at line 125 of file pdgcode.h.

125 : dump_(0x0) {}
smash::PdgCode::dump_
std::uint32_t dump_
The bitfield dumped into a single integer.
Definition: pdgcode.h:810
Here is the caller graph for this function:

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

131  {
132  set_from_string(codestring);
133  }
smash::PdgCode::set_from_string
void set_from_string(const std::string &codestring)
Set the PDG code from the given string.
Definition: pdgcode.h:901
Here is the call graph for this function:

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

143  : dump_(0x0) { // NOLINT(runtime/explicit)
144  digits_.antiparticle_ = false;
145  if (codenumber < 0) {
146  digits_.antiparticle_ = true;
147  codenumber = -codenumber;
148  }
149  set_fields(codenumber);
150  }
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:1006
Here is the call graph for this function:

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

155  : dump_(0x0) {
156  // use the first bit for the antiparticle_ boolean.
157  digits_.antiparticle_ = ((abscode & 0x80000000u) != 0);
158  set_fields(abscode);
159  }
Here is the call graph for this function:

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

180  {
181  int fail = 0;
182  if (digits_.n_ > 9) {
183  fail |= 1 << 6;
184  }
185  if (digits_.n_R_ > 9) {
186  fail |= 1 << 5;
187  }
188  if (digits_.n_L_ > 9) {
189  fail |= 1 << 4;
190  }
191  if (digits_.n_q1_ > 6) {
192  fail |= 1 << 3;
193  }
194  if (digits_.n_q2_ > 6) {
195  fail |= 1 << 2;
196  }
197  if (digits_.n_q3_ > 6) {
198  fail |= 1 << 1;
199  }
200  if (digits_.n_J_ > 15) {
201  fail |= 1;
202  }
203  return fail;
204  }
Here is the caller graph for this function:

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

214  {
215  // n_J must be odd for mesons and even for baryons (and cannot be zero)
216  if (is_hadron()) {
217  if (baryon_number() == 0) {
218  // mesons: special cases K0_L=0x130 and K0_S=0x310
219  if ((digits_.n_J_ % 2 == 0) && dump() != 0x130 && dump() != 0x310) {
220  throw InvalidPdgCode("Invalid PDG code " + string() +
221  " (meson with even n_J)");
222  }
223  } else {
224  if ((digits_.n_J_ % 2 != 0) || digits_.n_J_ == 0) {
225  throw InvalidPdgCode("Invalid PDG code " + string() +
226  " (baryon with odd n_J)");
227  }
228  }
229  } else {
230  if (digits_.n_J_ == 0 && dump() != 0x0) {
231  throw InvalidPdgCode("Invalid PDG code " + string() + " (n_J==0)");
232  }
233  }
234  /* The antiparticle flag only makes sense for particle types
235  * that have an antiparticle. */
236  if (digits_.antiparticle_ && !has_antiparticle()) {
237  throw InvalidPdgCode("Invalid PDG code " + string() +
238  " (cannot be negative)");
239  }
240  }
smash::PdgCode::baryon_number
int baryon_number() const
Definition: pdgcode.h:308
smash::PdgCode::dump
std::uint32_t dump() const
Dumps the bitfield into an unsigned integer.
Definition: pdgcode.h:243
smash::PdgCode::is_hadron
bool is_hadron() const
Definition: pdgcode.h:297
smash::PdgCode::has_antiparticle
bool has_antiparticle() const
Definition: pdgcode.h:411
Here is the call graph for this function:
Here is the caller graph for this function:

◆ dump()

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

Dumps the bitfield into an unsigned integer.

Definition at line 243 of file pdgcode.h.

243  {
244  // this cuts the three unused bits.
245  return (dump_ & 0x8fffffff);
246  }
Here is the caller graph for this function:

◆ code()

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

Definition at line 249 of file pdgcode.h.

249 { return antiparticle_sign() * ucode(); }
smash::PdgCode::antiparticle_sign
int antiparticle_sign() const
Definition: pdgcode.h:572
smash::PdgCode::ucode
std::uint32_t ucode() const
Definition: pdgcode.h:855
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 252 of file pdgcode.h.

252  {
253  std::stringstream ss;
254  ss << get_decimal();
255  return ss.str();
256  }
smash::PdgCode::get_decimal
int32_t get_decimal() const
Definition: pdgcode.h:690
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 259 of file pdgcode.h.

259  {
260  PdgCode result = *this;
261  result.digits_.antiparticle_ = !digits_.antiparticle_;
262  return result;
263  }
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_decimaldecimal integer representing the PDG code

Definition at line 269 of file pdgcode.h.

269  {
270  // Nucleus and special codes with 2J+1 > 9
271  if (std::abs(pdgcode_decimal) > 1E7) {
272  return PdgCode(std::to_string(pdgcode_decimal));
273  }
274  int a = pdgcode_decimal;
275  int hex_pdg = 0, tmp = 1;
276  while (a) {
277  hex_pdg += (a % 10) * tmp;
278  tmp *= 16;
279  a = a / 10;
280  }
281  return PdgCode(hex_pdg);
282  }
Here is the call 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 291 of file pdgcode.h.

291  {
292  assert(digits_.is_nucleus_ == nucleus_.is_nucleus_);
293  return nucleus_.is_nucleus_;
294  }
smash::PdgCode::nucleus_
struct smash::PdgCode::@0::@4 nucleus_
Structure for the nuclei.
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 297 of file pdgcode.h.

297  {
298  return (digits_.n_q3_ != 0 && digits_.n_q2_ != 0 && !is_nucleus());
299  }
smash::PdgCode::is_nucleus
bool is_nucleus() const
Definition: pdgcode.h:291
Here is the call graph for this function:
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 302 of file pdgcode.h.

302  {
303  return (digits_.n_q1_ == 0 && digits_.n_q2_ == 0 && digits_.n_q3_ == 1 &&
304  !is_nucleus());
305  }
Here is the call graph for this function:
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 308 of file pdgcode.h.

308  {
309  if (is_nucleus()) {
310  return static_cast<int>(nucleus_.A_) * antiparticle_sign();
311  }
312  if (!is_hadron() || digits_.n_q1_ == 0) {
313  return 0;
314  }
315  return antiparticle_sign();
316  }
Here is the call graph for this function:
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 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_meson()

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

Definition at line 321 of file pdgcode.h.

321 { 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 324 of file pdgcode.h.

324  {
325  const auto abs_code = std::abs(code());
326  return (abs_code == pdg::p || abs_code == pdg::n);
327  }
smash::PdgCode::code
std::int32_t code() const
Definition: pdgcode.h:249
smash::pdg::p
constexpr int p
Proton.
Definition: pdgcode_constants.h:28
smash::pdg::n
constexpr int n
Neutron.
Definition: pdgcode_constants.h:30
Here is the call graph for this function:
Here is the caller graph for this function:

◆ is_proton()

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

Definition at line 330 of file pdgcode.h.

330  {
331  const auto abs_code = std::abs(code());
332  return (abs_code == pdg::p);
333  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ is_neutron()

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

Definition at line 336 of file pdgcode.h.

336  {
337  const auto abs_code = std::abs(code());
338  return (abs_code == pdg::n);
339  }
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 342 of file pdgcode.h.

342  {
343  const auto abs_code = std::abs(code());
344  return (abs_code == pdg::N1535_p || abs_code == pdg::N1535_z);
345  }
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
Here is the call graph for this function:
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 348 of file pdgcode.h.

348  {
349  const auto abs_code = std::abs(code());
350  return (abs_code == pdg::Delta_pp || abs_code == pdg::Delta_p ||
351  abs_code == pdg::Delta_z || abs_code == pdg::Delta_m);
352  }
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
Here is the call graph for this function:
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 355 of file pdgcode.h.

355 { return is_hadron() && digits_.n_q1_ == 3; }
Here is the call graph for this function:
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 358 of file pdgcode.h.

358  {
359  return is_hyperon() && digits_.n_q2_ == 3 && digits_.n_q3_ == 3;
360  }
smash::PdgCode::is_hyperon
bool is_hyperon() const
Definition: pdgcode.h:355
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 363 of file pdgcode.h.

363  {
364  return is_hyperon() && digits_.n_q2_ == 3 && digits_.n_q3_ != 3;
365  }
Here is the call graph for this function:

◆ is_Lambda()

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

Definition at line 368 of file pdgcode.h.

368  {
369  return is_hyperon() && digits_.n_q2_ == 1 && digits_.n_q3_ == 2;
370  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ is_Sigma()

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

Definition at line 373 of file pdgcode.h.

373  {
374  return is_hyperon() && digits_.n_q2_ != 3 && !is_Lambda();
375  }
smash::PdgCode::is_Lambda
bool is_Lambda() const
Definition: pdgcode.h:368
Here is the call graph for this function:

◆ is_kaon()

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

Definition at line 378 of file pdgcode.h.

378  {
379  const auto abs_code = std::abs(code());
380  return (abs_code == pdg::K_p) || (abs_code == pdg::K_z);
381  }
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
Here is the call graph for this function:
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 384 of file pdgcode.h.

384  {
385  const auto c = code();
386  return (c == pdg::pi_z) || (c == pdg::pi_p) || (c == pdg::pi_m);
387  }
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
Here is the call graph for this function:
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 390 of file pdgcode.h.

390  {
391  const auto c = code();
392  return (c == pdg::rho_z) || (c == pdg::rho_p) || (c == pdg::rho_m);
393  }
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
Here is the call graph for this function:
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 396 of file pdgcode.h.

396  {
397  return is_nucleus() && nucleus_.A_ == 2 && nucleus_.Z_ == 1 &&
398  nucleus_.n_Lambda_ == 0 && nucleus_.I_ == 0;
399  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ is_triton()

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

Definition at line 402 of file pdgcode.h.

402  {
403  return is_nucleus() && nucleus_.A_ == 3 && nucleus_.Z_ == 1 &&
404  nucleus_.n_Lambda_ == 0 && nucleus_.I_ == 0;
405  }
Here is the call graph for this function:
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 411 of file pdgcode.h.

411  {
412  if (is_nucleus()) {
413  return true;
414  }
415  if (is_hadron()) {
416  return (baryon_number() != 0) || (digits_.n_q2_ != digits_.n_q3_);
417  } else {
418  return digits_.n_q3_ == 1; // leptons!
419  }
420  }
Here is the call graph for this function:
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 427 of file pdgcode.h.

427  {
428  /* net_quark_number(2) is the number of u quarks,
429  * net_quark_number(1) is the number of d quarks. */
430  return net_quark_number(2) - net_quark_number(1);
431  }
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
Here is the call graph for this function:

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

440  {
441  /* The quarkonium state has 0 net strangeness
442  * but there are actually 2 strange quarks out of 2 total */
443  if (is_hadron() && digits_.n_q3_ == 3 && digits_.n_q2_ == 3) {
444  return 1.;
445  } else {
446  // For all other cases, there isn't both a strange and anti-strange
447  if (is_baryon()) {
448  return std::abs(strangeness()) / 3.;
449  } else if (is_meson()) {
450  return std::abs(strangeness()) / 2.;
451  } else {
452  /* If not baryon or meson, this should be 0, as AQM does not
453  * extend to non-hadrons */
454  return 0.;
455  }
456  }
457  }
smash::PdgCode::is_meson
bool is_meson() const
Definition: pdgcode.h:321
smash::PdgCode::strangeness
int strangeness() const
Definition: pdgcode.h:464
smash::PdgCode::is_baryon
bool is_baryon() const
Definition: pdgcode.h:318
Here is the call graph for this function:
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 464 of file pdgcode.h.

464 { return -net_quark_number(3); }
Here is the call graph for this function:
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 471 of file pdgcode.h.

471 { return +net_quark_number(4); }
Here is the call graph for this function:
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 478 of file pdgcode.h.

478 { return -net_quark_number(5); }
Here is the call graph for this function:

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

488  {
489  if (is_hadron() || is_nucleus()) {
490  // Q will accumulate 3*charge (please excuse the upper case. I
491  // want to distinguish this from q which might be interpreted as
492  // shorthand for "quark".)
493  int Q = 0;
494  /* This loops over d,u,s,c,b,t quarks (the latter can be safely ignored,
495  * but I don't think this will be a bottle neck. */
496  for (int i = 1; i < 7; i++) {
497  /* u,c,t quarks have charge = 2/3 e, while d,s,b quarks have -1/3 e.
498  * The antiparticle sign is already in net_quark_number. */
499  Q += (i % 2 == 0 ? 2 : -1) * net_quark_number(i);
500  }
501  return Q / 3;
502  }
503  /* non-hadron:
504  * Leptons: 11, 13, 15 are e, μ, τ and have a charge -1, while
505  * 12, 14, 16 are the neutrinos that have no charge. */
506  if (digits_.n_q3_ == 1) {
507  return -1 * (digits_.n_J_ % 2) * antiparticle_sign();
508  }
509  /* Bosons: 24 is the W+, all else is uncharged.
510  * we ignore the first digits so that this also finds strange gauge
511  * boson "resonances" (in particular, \f$\tilde \chi_1^+\f$ with PDG
512  * Code 1000024). */
513  if ((dump_ & 0x0000ffff) == 0x24) {
514  return antiparticle_sign();
515  }
516  // default (this includes all other Bosons) is 0.
517  return 0;
518  }
Here is the call graph for this function:
Here is the caller graph for this function:

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

529  {
530  if (is_nucleus()) {
531  // Generally spin of a nucleus cannot be simply guessed, it should be
532  // provided from some table. However, here we only care about a
533  // limited set of light nuclei with A <= 4.
534  if (nucleus_.A_ == 2) {
535  // Deuteron spin is 1
536  return 2;
537  } else if (nucleus_.A_ == 3) {
538  // Tritium and He-3 spin are 1/2
539  // Hypertriton spin is not firmly determined, but decay branching ratios
540  // indicate spin 1/2
541  return 1;
542  } else if (nucleus_.A_ == 4) {
543  // He-4 spin is 0
544  return 0;
545  }
546  throw std::runtime_error("Unknown spin of nucleus.");
547  // Alternative possibility is to guess 1/2 for fermions and 0 for bosons
548  // as 2 * (nucleus_.A_ % 2).
549  }
550 
551  if (is_hadron()) {
552  if (digits_.n_J_ == 0) {
553  return 0; // special cases: K0_L=0x130 & K0_S=0x310
554  } else {
555  return digits_.n_J_ - 1;
556  }
557  }
558  /* this assumes that we only have white particles (no single
559  * quarks): Electroweak fermions have 11-17, so the
560  * second-to-last-digit is the spin. The same for the Bosons: they
561  * have 21-29 and 2spin = 2 (this fails for the Higgs). */
562  return digits_.n_q3_;
563  }
Here is the call graph for this function:
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 565 of file pdgcode.h.

565  {
566  if (is_hadron() && digits_.n_J_ > 0) {
567  return digits_.n_J_;
568  }
569  return spin() + 1;
570  }
smash::PdgCode::spin
unsigned int spin() const
Definition: pdgcode.h:529
Here is the call graph for this function:
Here is the caller graph for this function:

◆ antiparticle_sign()

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

Definition at line 572 of file pdgcode.h.

572  {
573  return (digits_.antiparticle_ ? -1 : +1);
574  }
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 576 of file pdgcode.h.

576  {
577  if (!is_hadron() || is_nucleus()) {
578  return 0;
579  }
580  return chunks_.quarks_;
581  }
smash::PdgCode::chunks_
struct smash::PdgCode::@0::@3 chunks_
Chunk collection: here, the chunks with and are directly accessible.
Here is the call graph for this function:

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

592  {
593  std::array<int, 3> result = {static_cast<int>(digits_.n_q1_),
594  static_cast<int>(digits_.n_q2_),
595  static_cast<int>(digits_.n_q3_)};
596  if (is_hadron()) {
597  // Antibaryons
598  if (digits_.n_q1_ != 0 && digits_.antiparticle_) {
599  for (size_t i = 0; i < 3; i++) {
600  result[i] = -result[i];
601  }
602  }
603  // Mesons
604  if (digits_.n_q1_ == 0) {
605  // Own antiparticle
606  if (digits_.n_q2_ == digits_.n_q3_) {
607  result[2] = -result[2];
608  } else {
609  // Like pi-
610  if (digits_.antiparticle_) {
611  result[1] = -result[1];
612  // Like pi+
613  } else {
614  result[2] = -result[2];
615  }
616  }
617  // add extra minus sign according to the pdg convention
618  if (digits_.n_q2_ != digits_.n_q3_ && digits_.n_q2_ % 2 == 1) {
619  for (int i = 1; i <= 2; i++) {
620  result[i] = -result[i];
621  }
622  }
623  }
624  } else {
625  result = {0, 0, 0};
626  }
627  return result;
628  }
Here is the call graph for this function:
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_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 }
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 652 of file pdgcode.h.

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

◆ operator==()

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

Definition at line 661 of file pdgcode.h.

661 { return dump_ == rhs.dump_; }

◆ operator!=()

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

Definition at line 664 of file pdgcode.h.

664 { 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 667 of file pdgcode.h.

667  {
668  return code() == -rhs.code();
669  }
Here is the call graph for this function:
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 679 of file pdgcode.h.

679 { return PdgCode(0x0); }
Here is the call graph for this function:
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
InvalidPdgCodeif the spin degeneracy is larger than 9

Definition at line 690 of file pdgcode.h.

690  {
691  if (is_nucleus()) {
692  // ±10LZZZAAAI
693  return antiparticle_sign() *
694  (nucleus_.I_ + 10 * nucleus_.A_ + 10000 * nucleus_.Z_ +
695  10000000 * nucleus_.n_Lambda_ + 1000000000);
696  }
697  int n_J_1 = 0;
698  int n_J_2 = digits_.n_J_;
699  if (n_J_2 > 9) {
700  n_J_1 = n_J_2 - 9;
701  n_J_2 = 9;
702  }
703  return antiparticle_sign() *
704  (n_J_2 + digits_.n_q3_ * 10 + digits_.n_q2_ * 100 +
705  digits_.n_q1_ * 1000 + digits_.n_L_ * 10000 +
706  digits_.n_R_ * 100000 + digits_.n_ * 1000000 + n_J_1 * 10000000);
707  }
Here is the call graph for this function:
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 710 of file pdgcode.h.

710  {
711  if (!is_nucleus()) {
712  chunks_.excitation_ = 0;
713  } else {
714  nucleus_.I_ = 0;
715  }
716  }
Here is the call graph for this function:

◆ 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 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ nucleus_p()

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

Number of protons in nucleus.

Definition at line 731 of file pdgcode.h.

731  {
732  return (is_nucleus() && !nucleus_.antiparticle_) ? nucleus_.Z_ : 0;
733  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ nucleus_n()

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

Number of neutrons in nucleus.

Definition at line 735 of file pdgcode.h.

735  {
736  return (is_nucleus() && !nucleus_.antiparticle_)
737  ? nucleus_.A_ - nucleus_.Z_ - nucleus_.n_Lambda_
738  : 0;
739  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ nucleus_La()

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

Number of Lambdas in nucleus.

Definition at line 741 of file pdgcode.h.

741  {
742  return (is_nucleus() && !nucleus_.antiparticle_) ? nucleus_.n_Lambda_ : 0;
743  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ nucleus_ap()

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

Number of antiprotons in nucleus.

Definition at line 745 of file pdgcode.h.

745  {
746  return (is_nucleus() && nucleus_.antiparticle_) ? nucleus_.Z_ : 0;
747  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ nucleus_an()

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

Number of antineutrons in nucleus.

Definition at line 749 of file pdgcode.h.

749  {
750  return (is_nucleus() && nucleus_.antiparticle_)
751  ? nucleus_.A_ - nucleus_.Z_ - nucleus_.n_Lambda_
752  : 0;
753  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ nucleus_aLa()

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

Number of anti-Lambdas in nucleus.

Definition at line 755 of file pdgcode.h.

755  {
756  return (is_nucleus() && nucleus_.antiparticle_) ? nucleus_.n_Lambda_ : 0;
757  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ nucleus_A()

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

Nucleus mass number.

Definition at line 759 of file pdgcode.h.

759 { return is_nucleus() ? nucleus_.A_ : 0; }
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 855 of file pdgcode.h.

855 { return (dump_ & 0x0fffffff); }
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]inpcharacter which is translated into digit
Exceptions
InvalidPdgCodeif character does not correspond to digit

Definition at line 863 of file pdgcode.h.

863  {
864  // Decimal digit
865  if (48 <= inp && inp <= 57) {
866  return inp - 48;
867  }
868  // Hexdecimal digit, uppercase
869  if (65 <= inp && inp <= 70) {
870  return inp - 65 + 10;
871  }
872  // Hexdecimal digit, lowercase
873  if (97 <= inp && inp <= 102) {
874  return inp - 97 + 10;
875  }
876  throw InvalidPdgCode("PdgCode: Invalid character " + std::string(&inp, 1) +
877  " found.\n");
878  }
Here is the caller graph for this function:

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

901  {
902  dump_ = 0;
903  // Implicit with the above: digits_.antiparticle_ = false;
904  digits_.n_ = digits_.n_R_ = digits_.n_L_ = digits_.n_q1_ = digits_.n_q2_ =
905  digits_.n_q3_ = digits_.n_J_ = digits_.is_nucleus_ = 0;
906  size_t length = codestring.size();
907  if (length < 1) {
908  throw InvalidPdgCode("Empty string does not contain PDG Code\n");
909  }
910  int c = 0;
911  /* Look at current character; if it is a + or minus sign, read it
912  * and advance to next char. */
913  if (codestring[c] == '-') {
914  digits_.antiparticle_ = true;
915  ++c;
916  } else if (codestring[c] == '+') {
917  digits_.antiparticle_ = false;
918  ++c;
919  }
920  // Save if the first character was a sign:
921  unsigned int sign = c;
922 
923  // Nucleus
924  if (length == 10 + sign) {
925  nucleus_.is_nucleus_ = true;
926  if (codestring[c] != '1' || codestring[c + 1] != '0') {
927  throw InvalidPdgCode("Pdg code of nucleus \"" + codestring +
928  "\" should start with 10\n");
929  }
930  c += 2;
931  // ±10LZZZAAAI is the standard for nuclei
932  std::array<int, 8> digits;
933  for (int i = 0; i < 8; i++) {
934  digits[i] = get_digit_from_char(codestring[c + i]);
935  }
936  nucleus_.n_Lambda_ = digits[0];
937  nucleus_.Z_ = 100 * digits[1] + 10 * digits[2] + digits[3];
938  nucleus_.A_ = 100 * digits[4] + 10 * digits[5] + digits[6];
939  nucleus_.I_ = digits[7];
940  return;
941  }
942 
943  // Codestring shouldn't be longer than 8 + sign, except for nuclei
944  if (length > 8 + sign) {
945  throw InvalidPdgCode("String \"" + codestring +
946  "\" too long for PDG Code\n");
947  }
948  /* Please note that in what follows, we actually need c++, not ++c.
949  * first digit is used for n_J if the last digit is not enough. */
950  if (length > 7 + sign) {
951  digits_.n_J_ += get_digit_from_char(codestring[c++]);
952  }
953  // Codestring has 7 digits? 7th from last goes in n_.
954  if (length > 6 + sign) {
955  digits_.n_ = get_digit_from_char(codestring[c++]);
956  }
957  // It has 6 or 7 digits? 6th from last is n_R_.
958  if (length > 5 + sign) {
959  digits_.n_R_ = get_digit_from_char(codestring[c++]);
960  }
961  // 5th from last is n_L_.
962  if (length > 4 + sign) {
963  digits_.n_L_ = get_digit_from_char(codestring[c++]);
964  }
965  // 4th from last is n_q1_.
966  if (length > 3 + sign) {
967  digits_.n_q1_ = get_digit_from_char(codestring[c++]);
968  if (digits_.n_q1_ > 6) {
969  throw InvalidPdgCode("Invalid PDG code " + codestring + " (n_q1>6)");
970  }
971  }
972  // 3rd from last is n_q2_.
973  if (length > 2 + sign) {
974  digits_.n_q2_ = get_digit_from_char(codestring[c++]);
975  if (digits_.n_q2_ > 6) {
976  throw InvalidPdgCode("Invalid PDG code " + codestring + " (n_q2>6)");
977  }
978  }
979  // Next to last is n_q3_.
980  if (length > 1 + sign) {
981  digits_.n_q3_ = get_digit_from_char(codestring[c++]);
982  if (digits_.n_q3_ > 6) {
983  throw InvalidPdgCode("Invalid PDG code " + codestring + " (n_q3>6)");
984  }
985  }
986  // Last digit is the spin degeneracy.
987  if (length > sign) {
988  digits_.n_J_ += get_digit_from_char(codestring[c++]);
989  } else {
990  throw InvalidPdgCode(
991  "String \"" + codestring +
992  "\" only consists of a sign, that is no valid PDG Code\n");
993  }
994  check();
995  }
smash::PdgCode::check
void check() const
Do all sorts of validity checks.
Definition: pdgcode.h:214
smash::PdgCode::get_digit_from_char
std::uint32_t get_digit_from_char(const char inp) const
Definition: pdgcode.h:863
Here is the call graph for this function:
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]abscodeinteger which replace PDG code except sign
Exceptions
InvalidPdgCodeif input is not a valid PDG code
See also
PdgCode::test_code

Definition at line 1006 of file pdgcode.h.

1006  {
1007  /* "dump_ =" overwrites antiparticle_, but this needs to have been set
1008  * already, so we carry it around the assignment. */
1009  bool ap = digits_.antiparticle_;
1010  dump_ = abscode & 0x0fffffff;
1011  digits_.antiparticle_ = ap;
1012  int test = test_code();
1013  if (test > 0) {
1014  throw InvalidPdgCode("Invalid digits " + std::to_string(test) +
1015  " in PDG Code " + string());
1016  }
1017  check();
1018  }
smash::PdgCode::test_code
int test_code() const
Checks the integer for invalid hex digits.
Definition: pdgcode.h:180
Here is the call graph for this function:
Here is the caller graph for this function:

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

◆ n_q3_

std::uint32_t smash::PdgCode::n_q3_

third quark field

Definition at line 777 of file pdgcode.h.

◆ n_q2_

std::uint32_t smash::PdgCode::n_q2_

second quark field

Definition at line 779 of file pdgcode.h.

◆ n_q1_

std::uint32_t smash::PdgCode::n_q1_

first quark field. 0 for mesons.

Definition at line 781 of file pdgcode.h.

◆ n_L_

std::uint32_t smash::PdgCode::n_L_

"angular momentum"

Definition at line 783 of file pdgcode.h.

◆ n_R_

std::uint32_t smash::PdgCode::n_R_

"radial excitation"

Definition at line 785 of file pdgcode.h.

◆ n_

std::uint32_t smash::PdgCode::n_

first field: "counter"

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

◆ antiparticle_

bool smash::PdgCode::antiparticle_

first bit: stores the sign.

Definition at line 791 of file pdgcode.h.

◆ 

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

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

◆ __pad0__

std::uint32_t smash::PdgCode::__pad0__

Definition at line 817 of file pdgcode.h.

◆ quarks_

std::uint32_t smash::PdgCode::quarks_

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

Definition at line 819 of file pdgcode.h.

◆ excitation_

std::uint32_t smash::PdgCode::excitation_

The excitation digits n_, n_R_, n_L_.

Definition at line 821 of file pdgcode.h.

◆ 

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

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

◆ Z_

std::uint32_t smash::PdgCode::Z_

Definition at line 833 of file pdgcode.h.

◆ A_

std::uint32_t smash::PdgCode::A_

Definition at line 834 of file pdgcode.h.

◆ I_

std::uint32_t smash::PdgCode::I_

Definition at line 835 of file pdgcode.h.

◆ is_nucleus_ [2/2]

bool smash::PdgCode::is_nucleus_

Definition at line 836 of file pdgcode.h.

◆ 

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

Structure for the nuclei.

◆ 

smash::PdgCode::@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: