smash::ParticleType Class Reference

#include <particletype.h>

Particle type contains the static properties of a particle species.

Before creation of Experiment, SMASH initializes the list of particles (list_all). After construction these values are immutable.

The list of particles is stored in such a way that look up of a ParticleType object (find) for a given PDG code is as efficient as possible ( \(\mathcal O(\log N)\)). This is still not efficient enough to use PdgCode as a substitute for storing information about a particle type, though. Use ParticleTypePtr instead.

Definition at line 100 of file particletype.h.

Collaboration diagram for smash::ParticleType:

Classes
struct	LoadFailure
struct	PdgNotFoundFailure

Public Member Functions
	ParticleType (std::string n, double m, double w, Parity p, PdgCode id)
	Creates a fully initialized ParticleType object. More...
	ParticleType (const ParticleType &)=delete
	Copies are not allowed as they break intended use. More...
ParticleType &	operator= (const ParticleType &)=delete
	assignment is not allowed, see copy constructor above More...
	ParticleType (ParticleType &&)=default
	move ctors are needed for std::sort More...
ParticleType &	operator= (ParticleType &&)=default
	move ctors are needed for std::sort More...
const DecayModes &	decay_modes () const
const std::string &	name () const
double	mass () const
double	mass_sqr () const
double	width_at_pole () const
Parity	parity () const
PdgCode	pdgcode () const
bool	has_antiparticle () const
ParticleTypePtr	get_antiparticle () const
int	antiparticle_sign () const
int	isospin () const
	Returns twice the isospin vector length \(I\). More...
int	isospin3 () const
double	isospin3_rel () const
IsoParticleType *	iso_multiplet () const
int32_t	charge () const
	The charge of the particle. More...
unsigned int	spin () const
unsigned int	spin_degeneracy () const
bool	is_hadron () const
bool	is_lepton () const
bool	is_baryon () const
bool	is_meson () const
int	baryon_number () const
int	strangeness () const
bool	is_nucleon () const
bool	is_pion () const
bool	is_kaon () const
bool	is_Delta () const
bool	is_rho () const
bool	is_Nstar () const
bool	is_Nstar1535 () const
bool	is_Sigmastar () const
bool	is_Deltastar () const
bool	is_stable () const
bool	is_nucleus () const
bool	is_deuteron () const
bool	is_triton () const
bool	is_dprime () const
bool	is_charmonia () const
double	min_mass_kinematic () const
	The minimum mass of the resonance that is kinematically allowed. More...
double	min_mass_spectral () const
	The minimum mass of the resonance, where the spectral function is non-zero. More...
double	partial_width (const double m, const DecayBranch *mode) const
	Get the mass-dependent partial decay width of a particle with mass m in a particular decay mode. More...
double	total_width (const double m) const
	Get the mass-dependent total width of a particle with mass m. More...
bool	wanted_decaymode (const DecayType &t, WhichDecaymodes wh) const
	Helper Function that containes the if-statement logic that decides if a decay mode is either a hadronic and dilepton decay mode. More...
DecayBranchList	get_partial_widths (const FourVector p, const ThreeVector x, WhichDecaymodes wh) const
	Get all the mass-dependent partial decay widths of a particle with mass m. More...
double	get_partial_width (const double m, const ParticleTypePtrList dlist) const
	Get the mass-dependent partial width of a resonance with mass m, decaying into two given daughter particles. More...
double	get_partial_in_width (const double m, const ParticleData &p_a, const ParticleData &p_b) const
	Get the mass-dependent partial in-width of a resonance with mass m, decaying into two given daughter particles. More...
double	full_spectral_function (double m) const
	Full spectral function \( A(m) = \frac{2}{\pi} N \frac{m^2\Gamma(m)}{(m^2-m_0^2)^2+(m\Gamma(m))^2} \) of the resonance (relativistic Breit-Wigner distribution with mass-dependent width, where N is a normalization factor). More...
double	no_norm_spectral_function (double m) const
	Full spectral function without normalization factor. More...
double	breit_wigner_spectral_function (double m) const
	This one is the most simple form of the spectral function, using a Cauchy distribution (non-relativistic Breit-Wigner with constant width). More...
double	sample_breit_wigner_spectral_function (double energy=mass_limit_) const
	Sample mass from the simple spectral function (Breit-Wigner/Cauchy distribution). More...
double	sample_full_spectral_function (double energy=mass_limit_) const
	Sample mass from the full spectral function. More...
double	ratio_spectral_full_to_breit_wigner (double m) const
	Calculate the ratio between the full spectral function and simple one. More...
double	max_ratio_spectral_full_to_breit_wigner () const
	Getter used in the resonance mass sampling functions. More...
double	sample_resonance_mass (const double mass_stable, const double cms_energy, int L=0) const
	Resonance mass sampling for 2-particle final state with one resonance (type given by 'this') and one stable particle. More...
void	dump_width_and_spectral_function () const
	Prints out width and spectral function versus mass to the standard output. More...
bool	operator== (const ParticleType &rhs) const
bool	operator!= (const ParticleType &rhs) const
bool	operator< (const ParticleType &rhs) const
	"Less than" operator for sorting the ParticleType list (by PDG code) More...
ParticleTypePtr	operator& () const
	Returns an object that acts like a pointer, except that it requires only 2 bytes and inhibits pointer arithmetics. More...

Static Public Member Functions
static const ParticleTypeList &	list_all ()
static ParticleTypePtrList &	list_nucleons ()
static ParticleTypePtrList &	list_anti_nucleons ()
static ParticleTypePtrList &	list_Deltas ()
static ParticleTypePtrList &	list_anti_Deltas ()
static ParticleTypePtrList &	list_baryon_resonances ()
static ParticleTypePtrList &	list_light_nuclei ()
static const ParticleTypePtr	try_find (PdgCode pdgcode)
	Returns the ParticleTypePtr for the given pdgcode. More...
static const ParticleType &	find (PdgCode pdgcode)
	Returns the ParticleType object for the given pdgcode. More...
static bool	exists (PdgCode pdgcode)
static bool	exists (const std::string &name)
static void	create_type_list (const std::string &particles)
	Initialize the global ParticleType list (list_all) from the given input data. More...
static void	check_consistency ()

Static Public Attributes
static constexpr double	width_cutoff = 1e-5
	Decay width cutoff for considering a particle as stable. More...

Private Member Functions
void	calculate_max_ratio_spectral_full_to_breit_wigner () const
	Calculates the maximum ratio between full spectral function and simple one. More...

Private Attributes
std::string	name_
	name of the particle More...
double	mass_
	pole mass of the particle More...
double	width_
	width of the particle More...
Parity	parity_
	Parity of the particle. More...
PdgCode	pdgcode_
	PDG Code of the particle. More...
double	min_mass_kinematic_
	minimum kinematically allowed mass of the particle Mutable, because it is initialized at first call of minimum mass function, so it's logically const, but not physically const, which is a classical case for using mutable. More...
double	min_mass_spectral_
	minimum mass, where the spectral function is non-zero Mutable, because it is initialized at first call of minimum mass function, so it's logically const, but not physically const, which is a classical case for using mutable. More...
double	norm_factor_ = -1.
	This normalization factor ensures that the spectral function is normalized to unity, when integrated over its full domain. More...
int32_t	charge_
	Charge of the particle; filled automatically from pdgcode_. More...
int	isospin_
	Isospin of the particle; filled automatically from pdgcode_. More...
int	I3_
	Isospin projection of the particle; filled automatically from pdgcode_. More...
IsoParticleType *	iso_multiplet_ = nullptr
	Container for the isospin multiplet information. More...
std::optional< double >	max_ratio_spectral_full_to_breit_wigner_
	Maximum ratio between full spectral function and the mass-independent Breit-Wigner. More...

Static Private Attributes
static constexpr double	mass_limit_ = 10.0
	Limit for sampling the resonance masses. More...

Friends
std::ostream &	operator<< (std::ostream &out, const ParticleType &type)
	Writes all information about the particle type to the output stream. More...

Constructor & Destructor Documentation

ParticleType() [1/3]

smash::ParticleType::ParticleType	(	std::string	n,
		double	m,
		double	w,
		Parity	p,
		PdgCode	id
	)

Creates a fully initialized ParticleType object.

Parameters

[in]	n	The name of the particle.
[in]	m	The mass of the particle.
[in]	w	The width of the particle.
[in]	p	The parity of the particle.
[in]	id	The PDG code of the particle.

Note

The remaining properties ParticleType provides are derived from the PDG code and therefore cannot be set explicitly (this avoids the chance of introducing inconsistencies).

Definition at line 122 of file particletype.cc.

    : name_(n),
      mass_(m),
      width_(w),
      parity_(p),
      pdgcode_(id),
      min_mass_kinematic_(-1.),
      min_mass_spectral_(-1.),
      charge_(pdgcode_.charge()),
      isospin_(-1),
      I3_(pdgcode_.isospin3()) {}

ParticleType() [2/3]

smash::ParticleType::ParticleType ( const ParticleType &  )

delete

Copies are not allowed as they break intended use.

Instead use a const-ref or ParticleTypePtr (as returned from operator&).

ParticleType() [3/3]

smash::ParticleType::ParticleType ( ParticleType &&  )

default

move ctors are needed for std::sort

Member Function Documentation

operator=() [1/2]

ParticleType& smash::ParticleType::operator= ( const ParticleType &  )

delete

assignment is not allowed, see copy constructor above

operator=() [2/2]

ParticleType& smash::ParticleType::operator= ( ParticleType &&  )

default

move ctors are needed for std::sort

decay_modes()

const DecayModes & smash::ParticleType::decay_modes

(

)

const

Returns

the DecayModes object for this particle type.

Definition at line 433 of file particletype.cc.

                                                  {
  const auto offset = this - std::addressof(list_all()[0]);
  const auto &modes = (*DecayModes::all_decay_modes)[offset];
  assert(is_stable() || !modes.is_empty());
  return modes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

name()

const std::string& smash::ParticleType::name ( ) const

inline

Returns

the name of the particle.

Definition at line 144 of file particletype.h.

{ return name_; }

Here is the caller graph for this function:

mass()

double smash::ParticleType::mass ( ) const

inline

Returns

the particle pole mass.

Definition at line 147 of file particletype.h.

{ return mass_; }

Here is the caller graph for this function:

mass_sqr()

double smash::ParticleType::mass_sqr ( ) const

inline

Returns

the squared particle mass.

Definition at line 150 of file particletype.h.

{ return mass_ * mass_; }

width_at_pole()

double smash::ParticleType::width_at_pole ( ) const

inline

Returns

the particle width (at the mass pole).

Definition at line 153 of file particletype.h.

{ return width_; }

Here is the caller graph for this function:

parity()

Parity smash::ParticleType::parity ( ) const

inline

Returns

the parity of the particle.

Definition at line 156 of file particletype.h.

{ return parity_; }

Here is the caller graph for this function:

pdgcode()

PdgCode smash::ParticleType::pdgcode ( ) const

inline

Returns

the PDG code of the particle.

Definition at line 159 of file particletype.h.

{ return pdgcode_; }

Here is the caller graph for this function:

has_antiparticle()

bool smash::ParticleType::has_antiparticle ( ) const

inline

Returns

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

Definition at line 162 of file particletype.h.

{ return pdgcode_.has_antiparticle(); }

Here is the call graph for this function:

Here is the caller graph for this function:

get_antiparticle()

ParticleTypePtr smash::ParticleType::get_antiparticle ( ) const

inline

Returns

a pointer to the corresponding antiparticle ParticleType object.

Definition at line 812 of file particletype.h.

                                                            {
  assert(has_antiparticle());
  return &find(pdgcode_.get_antiparticle());
}

Here is the call graph for this function:

antiparticle_sign()

int smash::ParticleType::antiparticle_sign ( ) const

inline

Returns

-1 for antiparticles and +1 for particles.

Definition at line 168 of file particletype.h.

{ return pdgcode_.antiparticle_sign(); }

Here is the call graph for this function:

Here is the caller graph for this function:

isospin()

int smash::ParticleType::isospin

(

)

const

Returns twice the isospin vector length \(I\).

This returns e.g. 1 for nucleons, 2 for pions and 3 for Deltas. It is always positive.

Definition at line 415 of file particletype.cc.

                                {
  if (isospin_ < 0) {
    isospin_ = (pdgcode_.is_hadron() && iso_multiplet_)
                   ? iso_multiplet_->isospin()
                   : 0;
  }
  return isospin_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isospin3()

int smash::ParticleType::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 179 of file particletype.h.

{ return I3_; }

Here is the caller graph for this function:

isospin3_rel()

double smash::ParticleType::isospin3_rel ( ) const

inline

Returns

the isospin-3 component relative to the total isospin.

Definition at line 182 of file particletype.h.

                              {
    unsigned int I = isospin();
    return (I == 0) ? 0 : static_cast<double>(isospin3()) / I;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

iso_multiplet()

IsoParticleType* smash::ParticleType::iso_multiplet ( ) const

inline

Returns

a pointer to the Isospin-multiplet of this PDG Code.

Definition at line 188 of file particletype.h.

{ return iso_multiplet_; }

Here is the caller graph for this function:

charge()

int32_t smash::ParticleType::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 191 of file particletype.h.

{ return charge_; }

Here is the caller graph for this function:

spin()

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

inline

Returns

twice the spin of a particle.

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

Exceptions

runtime_error

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

Definition at line 194 of file particletype.h.

{ return pdgcode_.spin(); }

Here is the call graph for this function:

Here is the caller graph for this function:

spin_degeneracy()

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

inline

Returns

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

Definition at line 197 of file particletype.h.

{ return pdgcode_.spin_degeneracy(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_hadron()

bool smash::ParticleType::is_hadron ( ) const

inline

Returns

true if this is a baryon, antibaryon or meson.

Definition at line 200 of file particletype.h.

{ return pdgcode_.is_hadron(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_lepton()

bool smash::ParticleType::is_lepton ( ) const

inline

Returns

true if this is a lepton.

Definition at line 203 of file particletype.h.

{ return pdgcode_.is_lepton(); }

Here is the call graph for this function:

is_baryon()

bool smash::ParticleType::is_baryon ( ) const

inline

Returns

whether this PDG code identifies a baryon.

Definition at line 206 of file particletype.h.

{ return pdgcode_.is_baryon(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_meson()

bool smash::ParticleType::is_meson ( ) const

inline

Returns

whether this PDG code identifies a meson.

Definition at line 209 of file particletype.h.

{ return pdgcode_.is_meson(); }

Here is the call graph for this function:

Here is the caller graph for this function:

baryon_number()

int smash::ParticleType::baryon_number ( ) const

inline

Returns

the baryon number of the particle.

Definition at line 212 of file particletype.h.

{ return pdgcode_.baryon_number(); }

Here is the call graph for this function:

Here is the caller graph for this function:

strangeness()

int smash::ParticleType::strangeness ( ) const

inline

Returns

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

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

Definition at line 215 of file particletype.h.

{ return pdgcode_.strangeness(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_nucleon()

bool smash::ParticleType::is_nucleon ( ) const

inline

Returns

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

Definition at line 218 of file particletype.h.

{ return pdgcode_.is_nucleon(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_pion()

bool smash::ParticleType::is_pion ( ) const

inline

Returns

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

Definition at line 221 of file particletype.h.

{ return pdgcode_.is_pion(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_kaon()

bool smash::ParticleType::is_kaon ( ) const

inline

Returns

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

Definition at line 224 of file particletype.h.

{ return pdgcode_.is_kaon(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_Delta()

bool smash::ParticleType::is_Delta ( ) const

inline

Returns

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

Definition at line 227 of file particletype.h.

{ return pdgcode_.is_Delta(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_rho()

bool smash::ParticleType::is_rho ( ) const

inline

Returns

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

Definition at line 230 of file particletype.h.

{ return pdgcode_.is_rho(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_Nstar()

bool smash::ParticleType::is_Nstar ( ) const

inline

Returns

Is this a nucleon resonance (N*)?

Definition at line 233 of file particletype.h.

                               {
    return is_baryon() && isospin() == 1 && !pdgcode_.is_nucleon() &&
           pdgcode_.strangeness() == 0 && pdgcode_.charmness() == 0;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

is_Nstar1535()

bool smash::ParticleType::is_Nstar1535 ( ) const

inline

Returns

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

Definition at line 239 of file particletype.h.

{ return pdgcode_.is_Nstar1535(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_Sigmastar()

bool smash::ParticleType::is_Sigmastar ( ) const

inline

Returns

Is this a Sigma resonance (Sigma*)?

Definition at line 242 of file particletype.h.

{ return pdgcode_.is_Sigmastar(); }

Here is the call graph for this function:

is_Deltastar()

bool smash::ParticleType::is_Deltastar ( ) const

inline

Returns

Is this a Delta resonance (Delta*)?

Definition at line 245 of file particletype.h.

                                   {
    return is_baryon() && isospin() == 3 && !pdgcode_.is_Delta() &&
           pdgcode_.strangeness() == 0 && pdgcode_.charmness() == 0;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

is_stable()

bool smash::ParticleType::is_stable ( ) const

inline

Returns

whether the particle is stable

Definition at line 251 of file particletype.h.

{ return width_ < width_cutoff; }

Here is the caller graph for this function:

is_nucleus()

bool smash::ParticleType::is_nucleus ( ) const

inline

Returns

whether the particle is a nucleus

Definition at line 254 of file particletype.h.

{ return pdgcode_.is_nucleus(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_deuteron()

bool smash::ParticleType::is_deuteron ( ) const

inline

Returns

whether the particle is an (anti-)deuteron

Definition at line 257 of file particletype.h.

{ return pdgcode_.is_deuteron(); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_triton()

bool smash::ParticleType::is_triton ( ) const

inline

Returns

whether the particle is an (anti-)triton

Definition at line 260 of file particletype.h.

{ return pdgcode_.is_triton(); }

Here is the call graph for this function:

is_dprime()

bool smash::ParticleType::is_dprime ( ) const

inline

Returns

whether the particle is an artificial d' resonance

Definition at line 263 of file particletype.h.

                                {
    return is_nucleus() && std::abs(pdgcode_.get_decimal()) == 1000010021;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

is_charmonia()

bool smash::ParticleType::is_charmonia ( ) const

inline

Returns

whether the particle is a cc̅ state

Definition at line 268 of file particletype.h.

{ return pdgcode_.is_charmonia(); }

Here is the call graph for this function:

min_mass_kinematic()

double smash::ParticleType::min_mass_kinematic

(

)

const

The minimum mass of the resonance that is kinematically allowed.

Calculate the minimum rest energy the resonance must have for any decay channel to be kinematically available. (In other words, find the smallest sum of final-state particle masses.)

Returns

The minimum mass that a particle of this type can assume, where at least one decay is possible.

Definition at line 365 of file particletype.cc.

                                              {
  if (unlikely(min_mass_kinematic_ < 0.)) {
    /* If the particle is stable, min. mass is just the mass. */
    min_mass_kinematic_ = mass_;
    /* Otherwise, find the lowest mass value needed in any decay mode */
    if (!is_stable()) {
      for (const auto &mode : decay_modes().decay_mode_list()) {
        min_mass_kinematic_ = std::min(min_mass_kinematic_, mode->threshold());
      }
    }
  }
  return min_mass_kinematic_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

min_mass_spectral()

double smash::ParticleType::min_mass_spectral

(

)

const

The minimum mass of the resonance, where the spectral function is non-zero.

Calculate the the smallest mass where the spectral function still has a contribution. This value can be different from min_mass_kinematic, if the spectral function becomes zero at masses higher than min_mass_kinematic, since the width is put to zero due to the width_cutoff.

The distinction between it and min_mass_kinematic() might be necessary in edge cases, where a reaction is very close to the kinematic threshold or for optimizations.

Returns

The minimum mass that a particle of this type can assume, where the spectral function still has a non-zero value.

Definition at line 379 of file particletype.cc.

                                             {
  if (unlikely(min_mass_spectral_ < 0.)) {
    /* If the particle is stable or it has a non-zero spectral function value at
     * the minimum mass that is allowed by kinematics, min_mass_spectral is just
     * the min_mass_kinetic. */
    min_mass_spectral_ = min_mass_kinematic();
    /* Otherwise, find the lowest mass value where spectral function has a
     * non-zero value by bisection.*/
    if (!is_stable() &&
        full_spectral_function(min_mass_kinematic()) < really_small) {
      // find a right bound that has non-zero spectral function for bisection
      const double m_step = 0.01;
      double right_bound_bis;
      for (unsigned int i = 0;; i++) {
        right_bound_bis = min_mass_kinematic() + m_step * i;
        if (full_spectral_function(right_bound_bis) > really_small) {
          break;
        }
      }
      // bisection
      const double precision = 1E-6;
      double left_bound_bis = right_bound_bis - m_step;
      while (right_bound_bis - left_bound_bis > precision) {
        const double mid = (left_bound_bis + right_bound_bis) / 2.0;
        if (full_spectral_function(mid) > really_small) {
          right_bound_bis = mid;
        } else {
          left_bound_bis = mid;
        }
      }
      min_mass_spectral_ = right_bound_bis;
    }
  }
  return min_mass_spectral_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

partial_width()

double smash::ParticleType::partial_width	(	const double	m,
		const DecayBranch *	mode
	)		const

Get the mass-dependent partial decay width of a particle with mass m in a particular decay mode.

Parameters

[in]	m	Invariant mass of the decaying particle.
[in]	mode	Decay mode to consider.

Returns

the partial width of this specific mode for this mass

Definition at line 424 of file particletype.cc.

                                                                  {
  if (m < mode->threshold()) {
    return 0.;
  }
  double partial_width_at_pole = width_at_pole() * mode->weight();
  return mode->type().width(mass(), partial_width_at_pole, m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

total_width()

double smash::ParticleType::total_width

(

const double

m

)

const

Get the mass-dependent total width of a particle with mass m.

Parameters

[in]

m

Invariant mass of the decaying particle.

Returns

the total width for all modes for this mass

Definition at line 440 of file particletype.cc.

                                                     {
  double w = 0.;
  if (is_stable()) {
    return w;
  }
  /* Loop over decay modes and sum up all partial widths. */
  const auto &modes = decay_modes().decay_mode_list();
  for (unsigned int i = 0; i < modes.size(); i++) {
    w = w + partial_width(m, modes[i].get());
  }
  if (w < width_cutoff) {
    return 0.;
  }
  return w;
}

Here is the call graph for this function:

Here is the caller graph for this function:

wanted_decaymode()

bool smash::ParticleType::wanted_decaymode	(	const DecayType &	t,
		WhichDecaymodes	wh
	)		const

Helper Function that containes the if-statement logic that decides if a decay mode is either a hadronic and dilepton decay mode.

Parameters

[in]	t	type of decay.
[in]	wh	enum that decides which decay modes are wanted.

Returns

true if a decay branch is wanted and false if not.

Definition at line 472 of file particletype.cc.

                                                              {
  switch (wh) {
    case WhichDecaymodes::All: {
      return true;
    }
    case WhichDecaymodes::Hadronic: {
      return !t.is_dilepton_decay();
    }
    case WhichDecaymodes::Dileptons: {
      return t.is_dilepton_decay();
    }
    default:
      throw std::runtime_error(
          "Problem in selecting decaymodes in wanted_decaymode()");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_partial_widths()

DecayBranchList smash::ParticleType::get_partial_widths	(	const FourVector	p,
		const ThreeVector	x,
		WhichDecaymodes	wh
	)		const

Get all the mass-dependent partial decay widths of a particle with mass m.

This function needs to know the 4-momentum and the position of the decaying particle to calculate the square root of s of the final state particles and mass

Parameters

[in]	p	4-momentum of the decaying particle.
[in]	x	position of the decaying particle.
[in]	wh	enum that decides which decaymodes are returned.

Returns

a list of process branches, whose weights correspond to the actual partial widths.

Definition at line 490 of file particletype.cc.

                                                                           {
  const auto &decay_mode_list = decay_modes().decay_mode_list();
  /* Determine whether the decay is affected by the potentials. If it's
   * affected, read the values of the potentials at the position of the
   * particle */
  FourVector UB = FourVector();
  FourVector UI3 = FourVector();
  if (UB_lat_pointer != nullptr) {
    UB_lat_pointer->value_at(x, UB);
  }
  if (UI3_lat_pointer != nullptr) {
    UI3_lat_pointer->value_at(x, UI3);
  }
  /* Loop over decay modes and calculate all partial widths. */
  DecayBranchList partial;
  partial.reserve(decay_mode_list.size());
  for (unsigned int i = 0; i < decay_mode_list.size(); i++) {
    /* Calculate the square root s of the final state particles. */
    const auto FinalTypes = decay_mode_list[i]->type().particle_types();
    double scale_B = 0.0;
    double scale_I3 = 0.0;
    if (pot_pointer != nullptr) {
      scale_B += pot_pointer->force_scale(*this).first;
      scale_I3 += pot_pointer->force_scale(*this).second * isospin3_rel();
      for (const auto &finaltype : FinalTypes) {
        scale_B -= pot_pointer->force_scale(*finaltype).first;
        scale_I3 -= pot_pointer->force_scale(*finaltype).second *
                    finaltype->isospin3_rel();
      }
    }
    double sqrt_s = (p + UB * scale_B + UI3 * scale_I3).abs();
 
    const double w = partial_width(sqrt_s, decay_mode_list[i].get());
    if (w > 0.) {
      if (wanted_decaymode(decay_mode_list[i]->type(), wh)) {
        partial.push_back(
            std::make_unique<DecayBranch>(decay_mode_list[i]->type(), w));
      }
    }
  }
  return partial;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_partial_width()

double smash::ParticleType::get_partial_width	(	const double	m,
		const ParticleTypePtrList	dlist
	)		const

Get the mass-dependent partial width of a resonance with mass m, decaying into two given daughter particles.

Parameters

[in]	m	Invariant mass of the decaying resonance.
[in]	dlist	List of daughter particles.

Returns

the partial width for this mass and this specific decay channel

Definition at line 535 of file particletype.cc.

                                                                              {
  /* Get all decay modes. */
  const auto &decaymodes = decay_modes().decay_mode_list();
 
  /* Find the right one(s) and add up corresponding widths. */
  double w = 0.;
  for (const auto &mode : decaymodes) {
    double partial_width_at_pole = width_at_pole() * mode->weight();
    if (mode->type().has_particles(dlist)) {
      w += mode->type().width(mass(), partial_width_at_pole, m);
    }
  }
  return w;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_partial_in_width()

double smash::ParticleType::get_partial_in_width	(	const double	m,
		const ParticleData &	p_a,
		const ParticleData &	p_b
	)		const

Get the mass-dependent partial in-width of a resonance with mass m, decaying into two given daughter particles.

For stable daughter particles, the in-width equals the 'normal' partial decay width (i.e. the 'out-width').

Parameters

[in]	m	Invariant mass of the decaying resonance.
[in]	p_a	First daughter particle.
[in]	p_b	Second daughter particle.

Returns

the partial in-width for this mass and this specific decay channel

Definition at line 551 of file particletype.cc.

                                                                         {
  /* Get all decay modes. */
  const auto &decaymodes = decay_modes().decay_mode_list();
 
  /* Find the right one(s) and add up corresponding widths. */
  double w = 0.;
  for (const auto &mode : decaymodes) {
    double partial_width_at_pole = width_at_pole() * mode->weight();
    const ParticleTypePtrList l = {&p_a.type(), &p_b.type()};
    if (mode->type().has_particles(l)) {
      w += mode->type().in_width(mass(), partial_width_at_pole, m,
                                 p_a.effective_mass(), p_b.effective_mass());
    }
  }
  return w;
}

Here is the call graph for this function:

Here is the caller graph for this function:

full_spectral_function()

double smash::ParticleType::full_spectral_function

(

double

m

)

const

Full spectral function \( A(m) = \frac{2}{\pi} N \frac{m^2\Gamma(m)}{(m^2-m_0^2)^2+(m\Gamma(m))^2} \) of the resonance (relativistic Breit-Wigner distribution with mass-dependent width, where N is a normalization factor).

Parameters

[in]

m

Actual off-shell mass of the resonance, where the spectral function is to be evaluated.

Returns

the value of the spectral function for this mass

Note

The normalization factor N ensures that the spectral function is normalized to unity.

Definition at line 570 of file particletype.cc.

                                                          {
  if (norm_factor_ < 0.) {
    /* Initialize the normalization factor
     * by integrating over the unnormalized spectral function. */
    static /*thread_local (see commit 897d0b8)*/ Integrator integrate;
    const double width = width_at_pole();
    const double m_pole = mass();
    // We transform the integral using m = m_min + width_pole * tan(x), to
    // make it definite and to avoid numerical issues.
    const double x_min = std::atan((min_mass_kinematic() - m_pole) / width);
    norm_factor_ = 1. / integrate(x_min, M_PI / 2., [&](double x) {
                     const double tanx = std::tan(x);
                     const double m_x = m_pole + width * tanx;
                     const double jacobian = width * (1.0 + tanx * tanx);
                     return no_norm_spectral_function(m_x) * jacobian;
                   });
  }
  return norm_factor_ * no_norm_spectral_function(m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

no_norm_spectral_function()

double smash::ParticleType::no_norm_spectral_function

(

double

m

)

const

Full spectral function without normalization factor.

See also

spectral_function

Parameters

[in]

m

Actual off-shell mass of the resonance, where the spectral function is to be evaluated.

Returns

the value of the non-normalized spectral function for this mass

Definition at line 590 of file particletype.cc.

                                                             {
  /* The spectral function is a relativistic Breit-Wigner function
   * with mass-dependent width. Here: without normalization factor. */
  const double resonance_width = total_width(m);
  if (resonance_width < ParticleType::width_cutoff) {
    return 0.;
  }
  return breit_wigner(m, mass(), resonance_width);
}

Here is the call graph for this function:

Here is the caller graph for this function:

breit_wigner_spectral_function()

double smash::ParticleType::breit_wigner_spectral_function

(

double

m

)

const

This one is the most simple form of the spectral function, using a Cauchy distribution (non-relativistic Breit-Wigner with constant width).

It can be integrated analytically, and is normalized to 1 when integrated from -inf to inf.

Parameters

[in]

m

Actual off-shell mass of the resonance, where the spectral function is to be evaluated.

Returns

the Cauchy spectral function at mass m

Definition at line 627 of file particletype.cc.

                                                                  {
  return breit_wigner_nonrel(m, mass(), width_at_pole());
}

Here is the call graph for this function:

Here is the caller graph for this function:

sample_breit_wigner_spectral_function()

double smash::ParticleType::sample_breit_wigner_spectral_function

(

double

energy = mass_limit_

)

const

Sample mass from the simple spectral function (Breit-Wigner/Cauchy distribution).

Parameters

[in]

energy

Maximum energy from which the mass should be sampled. If not given, the mass is sampled from the relevant range of the Breit-Wigner distribution, truncating it at mass_limit_.

Returns

sampled mass

Note

The energy can be larger than mass_limit_, which is set to a high enough value such that the spectral functions are negligible above it.

Definition at line 631 of file particletype.cc.

                         {
  return random::cauchy(mass(), width_at_pole() / 2., min_mass_spectral(),
                        energy);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sample_full_spectral_function()

double smash::ParticleType::sample_full_spectral_function

(

double

energy = mass_limit_

)

const

Sample mass from the full spectral function.

Parameters

[in]

energy

Maximum energy from which the mass should be sampled. If not given, the mass is sampled from the relevant range of the spectral function, truncating it at mass_limit_.

Returns

sampled mass

Definition at line 637 of file particletype.cc.

                                                                      {
  if (is_stable()) {
    return mass();
  }
  double mass, acceptance = 0;
  double sf_ratio_max = std::max(max_ratio_spectral_full_to_breit_wigner(),
                                 ratio_spectral_full_to_breit_wigner(energy));
  while (true) {
    do {
      mass = sample_breit_wigner_spectral_function(energy);
      acceptance = ratio_spectral_full_to_breit_wigner(mass);
    } while (acceptance < random::uniform(0., sf_ratio_max));
    if (unlikely(acceptance - sf_ratio_max > really_small)) {
      logg[LResonances].debug(
          "Warning: maximum ratio between full spectral function and Breit-",
          "Wigner increased in sample_full_spectral_function: ", sf_ratio_max,
          " to ", acceptance, " for ", name(), ". Sampled mass is ", mass,
          " GeV with ", energy,
          " GeV available.\n This might happen rarely at"
          " the edges of the spectral function.");
      // increase fudge factor
      sf_ratio_max *= acceptance / sf_ratio_max;
      max_ratio_spectral_full_to_breit_wigner_ = sf_ratio_max;
    } else {
      break;
    }
  }
  return mass;
}

Here is the call graph for this function:

ratio_spectral_full_to_breit_wigner()

double smash::ParticleType::ratio_spectral_full_to_breit_wigner

(

double

m

)

const

Calculate the ratio between the full spectral function and simple one.

Parameters

[in]

m

Mass of the resonance where the ratio is to be evaluated.

Returns

ratio between spectral functions

Definition at line 600 of file particletype.cc.

                                                                       {
  return full_spectral_function(m) / breit_wigner_spectral_function(m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

max_ratio_spectral_full_to_breit_wigner()

double smash::ParticleType::max_ratio_spectral_full_to_breit_wigner ( ) const

inline

Getter used in the resonance mass sampling functions.

If the member is not yet initialized, it runs the algorithm to find the value.

Returns

maximum ratio between full spectral function and simple

Definition at line 442 of file particletype.h.

                                                         {
    if (!max_ratio_spectral_full_to_breit_wigner_) {
      calculate_max_ratio_spectral_full_to_breit_wigner();
    }
    return *max_ratio_spectral_full_to_breit_wigner_;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

sample_resonance_mass()

double smash::ParticleType::sample_resonance_mass	(	const double	mass_stable,
		const double	cms_energy,
		int	L = 0
	)		const

Resonance mass sampling for 2-particle final state with one resonance (type given by 'this') and one stable particle.

Parameters

[in]	mass_stable	Mass of the stable particle.
[in]	cms_energy	center-of-mass energy of the 2-particle final state.
[in]	L	relative angular momentum of the final-state particles

Returns

The mass of the resonance particle.

Definition at line 668 of file particletype.cc.

                                                        {
  /* largest possible mass: Use 'nextafter' to make sure it is not above the
   * physical limit by numerical error. */
  const double max_mass = std::nextafter(cms_energy - mass_stable, 0.);
 
  // smallest possible mass to find non-zero spectral function contributions
  const double min_mass = min_mass_spectral();
 
  // largest possible cm momentum (from smallest mass)
  const double pcm_max = pCM(cms_energy, mass_stable, min_mass);
  /* The maximum of the spectral-function ratio 'usually' happens at the
   * largest mass. However, this is not always the case, therefore we need
   * and additional fudge factor (determined automatically). Additionally,
   * a heuristic knowledge is used that usually such mass exist that
   * full_spectral_function(m) > breit_wigner_spectral_function(m). */
  const double sf_ratio_max =
      std::max(max_ratio_spectral_full_to_breit_wigner(),
               ratio_spectral_full_to_breit_wigner(max_mass));
 
  int max_trials = 10;
  double mass_res, acceptance, fudge_factor = 1;
  double max = sf_ratio_max * pcm_max * blatt_weisskopf_sqr(pcm_max, L);
  do {
    max *= fudge_factor;
    do {
      // sample mass from a simple Breit-Wigner (aka Cauchy) distribution
      mass_res = sample_breit_wigner_spectral_function(max_mass);
      // determine cm momentum for this case
      const double pcm = pCM(cms_energy, mass_stable, mass_res);
      acceptance = ratio_spectral_full_to_breit_wigner(mass_res) * pcm *
                   blatt_weisskopf_sqr(pcm, L);
    } while (acceptance < random::uniform(0., max));
    fudge_factor *= acceptance / max;
    --max_trials;
  } while (acceptance > max && max_trials > 0);
 
  if (acceptance > max && max_trials == 0) {
    logg[LResonances].fatal(
        "Maximum acceptance should be increased in sample_resonance_mass: ",
        sf_ratio_max, " ", acceptance / max, " ", pdgcode(), " ", mass_stable,
        " ", cms_energy, " ", mass_res);
    throw std::runtime_error(
        "Precomputation of maximum spectral function is not working properly. "
        "Please contact the developers.");
  }
  return mass_res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dump_width_and_spectral_function()

void smash::ParticleType::dump_width_and_spectral_function

(

)

const

Prints out width and spectral function versus mass to the standard output.

This is useful for debugging and analysis.

Exceptions

if	the particle type is stable

Definition at line 789 of file particletype.cc.

                                                          {
  if (is_stable()) {
    std::stringstream err;
    err << "Particle " << *this << " is stable, so it makes no"
        << " sense to print its spectral function, etc.";
    throw std::runtime_error(err.str());
  }
 
  double rightmost_pole = 0.0;
  const auto &decaymodes = decay_modes().decay_mode_list();
  for (const auto &mode : decaymodes) {
    double pole_mass_sum = 0.0;
    for (const ParticleTypePtr p : mode->type().particle_types()) {
      pole_mass_sum += p->mass();
    }
    if (pole_mass_sum > rightmost_pole) {
      rightmost_pole = pole_mass_sum;
    }
  }
 
  std::cout << "# mass m[GeV], width w(m) [GeV],"
            << " spectral function(m^2)*m [GeV^-1] of " << *this << std::endl;
  constexpr double m_step = 0.02;
  const double m_min = min_mass_spectral();
  // An empirical value used to stop the printout. Assumes that spectral
  // function decays at high mass, which is true for all known resonances.
  constexpr double spectral_function_threshold = 8.e-3;
  std::cout << std::fixed << std::setprecision(5);
  for (unsigned int i = 0;; i++) {
    const double m = m_min + m_step * i;
    const double w = total_width(m), sf = full_spectral_function(m);
    if (m > rightmost_pole * 2 && sf < spectral_function_threshold) {
      break;
    }
    std::cout << m << " " << w << " " << sf << std::endl;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

list_all()

const ParticleTypeList & smash::ParticleType::list_all ( )

static

Returns

a list of all ParticleType objects.

Note

This list is currently sorted, but do not rely on it.

It might make sense to inline this function to optimize runtime performance.

Definition at line 51 of file particletype.cc.

                                               {
  assert(all_particle_types);
  return *all_particle_types;
}

Here is the caller graph for this function:

list_nucleons()

ParticleTypePtrList & smash::ParticleType::list_nucleons ( )

static

Returns

a list of all nucleons (i.e. proton and neutron).

Definition at line 69 of file particletype.cc.

{ return nucleons_list; }

Here is the caller graph for this function:

list_anti_nucleons()

ParticleTypePtrList & smash::ParticleType::list_anti_nucleons ( )

static

Returns

a list of all anti-nucleons (i.e. anti-proton and anti-neutron).

Definition at line 71 of file particletype.cc.

                                                      {
  return anti_nucs_list;
}

Here is the caller graph for this function:

list_Deltas()

ParticleTypePtrList & smash::ParticleType::list_Deltas ( )

static

Returns

a list of the Delta(1232) baryons (i.e. all four charge states).

Definition at line 75 of file particletype.cc.

{ return deltas_list; }

Here is the caller graph for this function:

list_anti_Deltas()

ParticleTypePtrList & smash::ParticleType::list_anti_Deltas ( )

static

Returns

a list of the anti-Delta(1232) baryons (i.e. all four charge states).

Definition at line 77 of file particletype.cc.

                                                    {
  return anti_deltas_list;
}

Here is the caller graph for this function:

list_baryon_resonances()

ParticleTypePtrList & smash::ParticleType::list_baryon_resonances ( )

static

Returns

a list of all baryon resonances, i.e. unstable baryons (not including antibaryons).

Definition at line 81 of file particletype.cc.

                                                          {
  return baryon_resonances_list;
}

Here is the caller graph for this function:

list_light_nuclei()

ParticleTypePtrList & smash::ParticleType::list_light_nuclei ( )

static

Returns

a list of all light nuclei from SMASH particle list. Nucleons are not included into light nuclei by convention.

Definition at line 85 of file particletype.cc.

                                                     {
  return light_nuclei_list;
}

Here is the caller graph for this function:

try_find()

const ParticleTypePtr smash::ParticleType::try_find ( PdgCode  pdgcode )

static

Returns the ParticleTypePtr for the given pdgcode.

If the particle type is not found, an invalid ParticleTypePtr is returned. You can convert a ParticleTypePtr to a bool to check whether it is valid.

Note

The complexity of the search is \(\mathcal O(\log N)\). Therefore, do not use this function except for user input that selects a particle type. All other internal references for a particle type should use ParticleTypePtr instead.

Parameters

[in]

pdgcode

the unique pdg code to try to find

Returns

the ParticleTypePtr that corresponds to this pdg code, or an invalid pointer

Definition at line 89 of file particletype.cc.

                                                            {
  const auto found = std::lower_bound(
      all_particle_types->begin(), all_particle_types->end(), pdgcode,
      [](const ParticleType &l, const PdgCode &r) { return l.pdgcode() < r; });
  if (found == all_particle_types->end() || found->pdgcode() != pdgcode) {
    return {};  // The default constructor creates an invalid pointer.
  }
  return &*found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find()

const ParticleType & smash::ParticleType::find ( PdgCode  pdgcode )

static

Returns the ParticleType object for the given pdgcode.

If the particle is not found, a PdgNotFoundFailure is thrown.

Note

The complexity of the search is \(\mathcal O(\log N)\). Therefore, do not use this function except for user input that selects a particle type. All other internal references for a particle type should use ParticleTypePtr instead.

Parameters

[in]

pdgcode

the unique pdg code to try to find

Returns

the ParticleTypePtr that corresponds to this pdg code

Exceptions

PdgNotFoundFailure

pdgcode not found in available particle types

Definition at line 99 of file particletype.cc.

                                                      {
  const auto found = ParticleType::try_find(pdgcode);
  if (!found) {
    throw PdgNotFoundFailure("PDG code " + pdgcode.string() + " not found!");
  }
  return *found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

exists() [1/2]

bool smash::ParticleType::exists ( PdgCode  pdgcode )

static

Parameters

[in]

pdgcode

the PdgCode to look for

Returns

whether the ParticleType with the given pdgcode exists.

Note

The complexity of the search is \(\mathcal O(\log N)\).

Definition at line 107 of file particletype.cc.

                                         {
  const auto found = ParticleType::try_find(pdgcode);
  return found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

exists() [2/2]

bool smash::ParticleType::exists ( const std::string &  name )

static

Parameters

[in]

name

the name to look for

Returns

whether the ParticleType with the given name exists.

Note

The complexity of the search is \(\mathcal O(N)\).

Definition at line 112 of file particletype.cc.

                                               {
  const auto found =
      std::find_if(all_particle_types->begin(), all_particle_types->end(),
                   [&](const ParticleType &p) { return p.name() == name; });
  if (found == all_particle_types->end()) {
    return false;
  }
  return true;
}

create_type_list()

void smash::ParticleType::create_type_list ( const std::string &  particles )

static

Initialize the global ParticleType list (list_all) from the given input data.

This function must only be called once (will fail on second invocation).

Parameters

[in]

particles

A string that contains the definition of ParticleTypes to be created.

Exceptions

LoadFailure	if a line in the particle file could not be read, or if there are duplicates in it
runtime_error	if the mass of of nucleons, kaons and deltas are different from the hardcoded masses, or if this function is called more than once

Definition at line 200 of file particletype.cc.

                                                          {  // {{{
  static ParticleTypeList type_list;
  type_list.clear();  // in case LoadFailure was thrown and caught and we should
                      // try again
  for (const Line &line : line_parser(input)) {
    std::istringstream lineinput(line.text);
    std::string name;
    double mass, width;
    std::string parity_string;
    std::vector<std::string> pdgcode_strings;
    // We expect at most 4 PDG codes per multiplet.
    pdgcode_strings.reserve(4);
    lineinput >> name >> mass >> width >> parity_string;
    Parity parity;
    bool fail = false;
    if (parity_string == "+") {
      parity = Parity::Pos;
    } else if (parity_string == "-") {
      parity = Parity::Neg;
    } else {
      fail = true;
    }
    if (lineinput.fail() || fail) {
      throw ParticleType::LoadFailure(build_error_string(
          "While loading the ParticleType data:\nFailed to convert the input "
          "string to the expected data types.",
          line));
    }
    // read additional PDG codes (if present)
    while (!lineinput.eof()) {
      pdgcode_strings.push_back("");
      lineinput >> pdgcode_strings.back();
      if (lineinput.fail()) {
        throw ParticleType::LoadFailure(build_error_string(
            "While loading the ParticleType data:\nFailed to convert the input "
            "string to the expected data types.",
            line));
      }
    }
    if (pdgcode_strings.size() < 1) {
      throw ParticleType::LoadFailure(build_error_string(
          "While loading the ParticleType data:\nFailed to convert the input "
          "string due to missing PDG code.",
          line));
    }
    std::vector<PdgCode> pdgcode;
    pdgcode.resize(pdgcode_strings.size());
    std::transform(pdgcode_strings.begin(), pdgcode_strings.end(),
                   pdgcode.begin(),
                   [](const std::string &s) { return PdgCode(s); });
    ensure_all_read(lineinput, line);
 
    // Check if provided masses are the same as hardcoded ones, if present
    if (pdgcode[0].is_nucleon() && !almost_equal(mass, nucleon_mass)) {
      throw std::runtime_error("Nucleon mass in input file different from " +
                               std::to_string(nucleon_mass));
    }
    if (pdgcode[0].is_pion() && !almost_equal(mass, pion_mass)) {
      throw std::runtime_error("Pion mass in input file different from " +
                               std::to_string(pion_mass));
    }
    if (pdgcode[0].is_kaon() && !almost_equal(mass, kaon_mass)) {
      throw std::runtime_error("Kaon mass in input file different from " +
                               std::to_string(kaon_mass));
    }
    if (pdgcode[0].is_omega() && !almost_equal(mass, omega_mass)) {
      throw std::runtime_error("Omega mass in input file different from " +
                               std::to_string(omega_mass));
    }
    if (pdgcode[0].is_Delta() && !almost_equal(mass, delta_mass)) {
      throw std::runtime_error("Delta mass in input file different from " +
                               std::to_string(delta_mass));
    }
    if (pdgcode[0].is_deuteron() && !almost_equal(mass, deuteron_mass)) {
      throw std::runtime_error("Deuteron mass in input file different from " +
                               std::to_string(deuteron_mass));
    }
 
    // add all states to type list
    for (size_t i = 0; i < pdgcode.size(); i++) {
      std::string full_name = name;
      if (pdgcode.size() > 1) {
        // for multiplets: add charge string to name
        full_name += chargestr(pdgcode[i].charge());
      }
      type_list.emplace_back(full_name, mass, width, parity, pdgcode[i]);
      logg[LParticleType].debug()
          << "Setting     particle type: " << type_list.back();
      if (pdgcode[i].has_antiparticle()) {
        /* add corresponding antiparticle */
        PdgCode anti = pdgcode[i].get_antiparticle();
        // For bosons the parity does not change, for fermions it gets inverted.
        const auto anti_parity = (anti.spin() % 2 == 0) ? parity : -parity;
        full_name = antiname(full_name, pdgcode[i]);
        type_list.emplace_back(full_name, mass, width, anti_parity, anti);
        logg[LParticleType].debug()
            << "Setting antiparticle type: " << type_list.back();
      }
    }
  }
  type_list.shrink_to_fit();
 
  /* Sort the type list by PDG code. */
  std::sort(type_list.begin(), type_list.end());
 
  /* Look for duplicates. */
  PdgCode prev_pdg = 0;
  for (const auto &t : type_list) {
    if (t.pdgcode() == prev_pdg) {
      throw ParticleType::LoadFailure("Duplicate PdgCode in particles.txt: " +
                                      t.pdgcode().string());
    }
    prev_pdg = t.pdgcode();
  }
 
  if (all_particle_types != nullptr) {
    throw std::runtime_error("Error: Type list was already built!");
  }
  all_particle_types = &type_list;  // note that type_list is a function-local
                                    // static and thus will live on until after
                                    // main().
 
  // create all isospin multiplets
  for (const auto &t : type_list) {
    IsoParticleType::create_multiplet(t);
  }
  // link the multiplets to the types
  for (auto &t : type_list) {
    t.iso_multiplet_ = IsoParticleType::find(t);
  }
 
  // Create nucleons/anti-nucleons list
  if (IsoParticleType::exists("N")) {
    for (const auto &state : IsoParticleType::find("N").get_states()) {
      nucleons_list.push_back(state);
      anti_nucs_list.push_back(state->get_antiparticle());
    }
  }
 
  // Create deltas list
  if (IsoParticleType::exists("Δ")) {
    for (const auto &state : IsoParticleType::find("Δ").get_states()) {
      deltas_list.push_back(state);
      anti_deltas_list.push_back(state->get_antiparticle());
    }
  }
 
  // Create baryon resonances list
  for (const ParticleType &type_resonance : ParticleType::list_all()) {
    /* Only loop over baryon resonances. */
    if (type_resonance.is_stable() ||
        type_resonance.pdgcode().baryon_number() != 1) {
      continue;
    }
    baryon_resonances_list.push_back(&type_resonance);
    baryon_resonances_list.push_back(type_resonance.get_antiparticle());
  }
 
  for (const ParticleType &type : ParticleType::list_all()) {
    if (type.is_nucleus()) {
      light_nuclei_list.push_back(&type);
    }
  }
} /*}}}*/

Here is the call graph for this function:

Here is the caller graph for this function:

operator==()

bool smash::ParticleType::operator== ( const ParticleType &  rhs ) const

inline

Parameters

[in]

rhs

another ParticleType to compare to

Returns

whether the two ParticleType objects have the same PDG code.

Definition at line 575 of file particletype.h.

                                                 {
    return pdgcode() == rhs.pdgcode();
  }

Here is the call graph for this function:

operator!=()

bool smash::ParticleType::operator!= ( const ParticleType &  rhs ) const

inline

Parameters

[in]

rhs

another ParticleType to compare to

Returns

whether the two ParticleType objects have different PDG codes.

Definition at line 582 of file particletype.h.

                                                 {
    return pdgcode() != rhs.pdgcode();
  }

Here is the call graph for this function:

operator<()

bool smash::ParticleType::operator< ( const ParticleType &  rhs ) const

inline

"Less than" operator for sorting the ParticleType list (by PDG code)

Parameters

[in]

rhs

another ParticleType to compare to

Returns

whether the PDG code of rhs is larger than the one from *this

Definition at line 591 of file particletype.h.

                                                {
    return pdgcode() < rhs.pdgcode();
  }

Here is the call graph for this function:

check_consistency()

void smash::ParticleType::check_consistency ( )

static

Exceptions

runtime_error	if unstable particles have no decay modes
runtime_error	if fake dibaryon d' is present without d

Note that the particles and decay modes have to be initialized, otherwise calling this is undefined behavior.

Definition at line 456 of file particletype.cc.

                                     {
  for (const ParticleType &ptype : ParticleType::list_all()) {
    if (!ptype.is_stable() && ptype.decay_modes().is_empty()) {
      throw std::runtime_error(
          "Unstable particle " + ptype.name() +
          " has no decay chanels! Either add one to it in decaymodes file or "
          "set it's width to 0 in particles file.");
    }
    if (ptype.is_dprime() && !ParticleType::try_find(pdg::deuteron)) {
      throw std::runtime_error(
          "d' cannot be used without deuteron. Modify input particles file "
          "accordingly.");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator&()

ParticleTypePtr smash::ParticleType::operator&

(

)

const

Returns an object that acts like a pointer, except that it requires only 2 bytes and inhibits pointer arithmetics.

This is an optimization for creating references to ParticleType objects. With a normal pointer you would require the original object to stay in its place in memory, as otherwise the pointer would dangle. The ParticleTypePtr does not have this problem as it only stores the index of the ParticleType in the global vector of ParticleType objects.

In addition to returning a more efficient reference type, the overload of operator& effectively inhibits passing ParticleType objects by pointer. This is an intended restriction since ParticleType objects should only be passed by const-ref. (You can now pass by ParticleTypePtr instead, but please prefer not to. It might be useful when you want to store a reference inside the function anyway, but that can just as well be done with a const-ref parameter. A ParticleTypePtr can be invalid, a const-ref is always a valid reference semantically.)

Pre-condition:

The operator expects that the ParticleType object is stored in the vector returned by ParticleType::list_all. Therefore, never create new ParticleType objects (that includes copies and moves)!

Note on distributed execution:

At some point we might want to have several copies of the ParticleType vector - on different machines or NUMA nodes. In that case ParticleType::list_all will return the local vector. This operator will continue to work as expected as long as the ParticleType object is an entry of this local vector. The ParticleTypePtr can then be used to communicate a ParticleType over node / NUMA boundaries (an actual pointer would not work, though).

Note

It might make sense to inline this function to optimize runtime performance.

Returns

A pointer-like object referencing this ParticleType object.

See also

ParticleTypePtr

Definition at line 57 of file particletype.cc.

                                              {
  // Calculate the offset via pointer subtraction:
  const auto offset = this - std::addressof(list_all()[0]);
  // Since we're using uint16_t for storing the index better be safe than sorry:
  // The offset must fit into the data type. If this ever fails we got a lot
  // more particle types than initially expected and you have to increase the
  // ParticleTypePtr storage to uint32_t.
  assert(offset >= 0 && offset < 0xffff);
  // After the assertion above the down-cast to uint16_t is safe:
  return ParticleTypePtr(static_cast<uint16_t>(offset));
}

Here is the call graph for this function:

calculate_max_ratio_spectral_full_to_breit_wigner()

void smash::ParticleType::calculate_max_ratio_spectral_full_to_breit_wigner ( ) const

private

Calculates the maximum ratio between full spectral function and simple one.

Usually it will be at the right edge of a mass range, but numerically this might be a problem since at very large masses both spectral functions go to zero, so we take a fixed maximal value. For some resonances the full spectral function has peaks beyond the pole mass, which will give the largest ratio, so this algorithm scans for this case from the right, until the regular pole mass peak. The actual value is the maximum between the ratio at the last found peak, the ratio at the mass limit, and 1 as a fallback.

Definition at line 604 of file particletype.cc.

                                                                           {
  if (is_stable()) {
    max_ratio_spectral_full_to_breit_wigner_ = 1.0;
    return;
  }
  /*
   * These values are arbitrary but sufficed at the time of writing. Since
   * the performance cost of making this more precise is (probably) not large,
   * the resolution can in principle be increased without significant impact.
   */
  constexpr double step_size = 0.02;
  constexpr double safety_factor = 1.01;
  double max_ratio = ratio_spectral_full_to_breit_wigner(mass_limit_);
  for (double m = mass_limit_; m > mass_ - width_; m -= step_size) {
    double current_value = ratio_spectral_full_to_breit_wigner(m);
    if (current_value > max_ratio) {
      max_ratio = current_value;
    }
  }
  max_ratio_spectral_full_to_breit_wigner_ =
      std::max(1.0, safety_factor * max_ratio);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

width_cutoff

constexpr double smash::ParticleType::width_cutoff = 1e-5

staticconstexpr

Decay width cutoff for considering a particle as stable.

We currently regard a particle type as stable if its on-shell width is less than 10 keV. The cutoff is chosen such that the η and the η' are stable.

Definition at line 110 of file particletype.h.

mass_limit_

constexpr double smash::ParticleType::mass_limit_ = 10.0

staticconstexprprivate

Limit for sampling the resonance masses.

Implicitly, this assumes that the spectral functions of all resonances are negligible at this value.

Definition at line 657 of file particletype.h.

name_

std::string smash::ParticleType::name_

private

name of the particle

Definition at line 659 of file particletype.h.

mass_

double smash::ParticleType::mass_

private

pole mass of the particle

Definition at line 661 of file particletype.h.

width_

double smash::ParticleType::width_

private

width of the particle

Definition at line 663 of file particletype.h.

parity_

Parity smash::ParticleType::parity_

private

Parity of the particle.

Definition at line 665 of file particletype.h.

pdgcode_

PdgCode smash::ParticleType::pdgcode_

private

PDG Code of the particle.

Definition at line 667 of file particletype.h.

min_mass_kinematic_

double smash::ParticleType::min_mass_kinematic_

mutableprivate

minimum kinematically allowed mass of the particle Mutable, because it is initialized at first call of minimum mass function, so it's logically const, but not physically const, which is a classical case for using mutable.

Definition at line 674 of file particletype.h.

min_mass_spectral_

double smash::ParticleType::min_mass_spectral_

mutableprivate

minimum mass, where the spectral function is non-zero Mutable, because it is initialized at first call of minimum mass function, so it's logically const, but not physically const, which is a classical case for using mutable.

Definition at line 681 of file particletype.h.

norm_factor_

double smash::ParticleType::norm_factor_ = -1.

mutableprivate

This normalization factor ensures that the spectral function is normalized to unity, when integrated over its full domain.

Definition at line 684 of file particletype.h.

charge_

int32_t smash::ParticleType::charge_

private

Charge of the particle; filled automatically from pdgcode_.

Definition at line 686 of file particletype.h.

isospin_

int smash::ParticleType::isospin_

mutableprivate

Isospin of the particle; filled automatically from pdgcode_.

Definition at line 688 of file particletype.h.

I3_

int smash::ParticleType::I3_

private

Isospin projection of the particle; filled automatically from pdgcode_.

Definition at line 690 of file particletype.h.

iso_multiplet_

IsoParticleType* smash::ParticleType::iso_multiplet_ = nullptr

private

Container for the isospin multiplet information.

Definition at line 693 of file particletype.h.

max_ratio_spectral_full_to_breit_wigner_

std::optional<double> smash::ParticleType::max_ratio_spectral_full_to_breit_wigner_

mutableprivate

Initial value:

=
      std::nullopt

Maximum ratio between full spectral function and the mass-independent Breit-Wigner.

This is used for sampling the resonance mass.

Definition at line 699 of file particletype.h.

---

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

• src/include/smash/particletype.h
• src/particletype.cc