#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 98 of file particletype.h.

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_Deltastar () const

bool	is_stable () const

bool	is_nucleus () const

bool	is_deuteron () const

bool	is_triton () const

bool	is_dprime () 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	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	spectral_function_no_norm (double m) const
	Full spectral function without normalization factor. More...

double	spectral_function_const_width (double m) const

double	spectral_function_simple (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_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...

std::pair< double, double >	sample_resonance_masses (const ParticleType &t2, const double cms_energy, int L=0) const
	Resonance mass sampling for 2-particle final state with two resonances. 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 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...

double	max_factor1_ = 1.
	Maximum factor for single-res mass sampling, cf. sample_resonance_mass. More...

double	max_factor2_ = 1.
	Maximum factor for double-res mass sampling, cf. sample_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 432 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;
 }

◆ name()

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

inline

Returns: the name of the particle.

Definition at line 142 of file particletype.h.

142 { return name_; }

◆ mass()

double smash::ParticleType::mass ( ) const

inline

Returns: the particle pole mass.

Definition at line 145 of file particletype.h.

145 { return mass_; }

◆ mass_sqr()

double smash::ParticleType::mass_sqr ( ) const

inline

Returns: the squared particle mass.

Definition at line 148 of file particletype.h.

148 { 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 151 of file particletype.h.

151 { return width_; }

◆ parity()

Parity smash::ParticleType::parity ( ) const

inline

Returns: the parity of the particle.

Definition at line 154 of file particletype.h.

154 { return parity_; }

◆ pdgcode()

PdgCode smash::ParticleType::pdgcode ( ) const

inline

Returns: the PDG code of the particle.

Definition at line 157 of file particletype.h.

157 { return pdgcode_; }

◆ 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 160 of file particletype.h.

160 { return pdgcode_.has_antiparticle(); }

smash::PdgCode::has_antiparticle

bool has_antiparticle() const

Definition: pdgcode.h:490

◆ get_antiparticle()

ParticleTypePtr smash::ParticleType::get_antiparticle ( ) const

inline

Returns: a pointer to the corresponding antiparticle ParticleType object.

Definition at line 757 of file particletype.h.

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

◆ antiparticle_sign()

int smash::ParticleType::antiparticle_sign ( ) const

inline

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

Definition at line 166 of file particletype.h.

166 { return pdgcode_.antiparticle_sign(); }

smash::PdgCode::antiparticle_sign

int antiparticle_sign() const

Definition: pdgcode.h:651

◆ 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 414 of file particletype.cc.

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

◆ 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 177 of file particletype.h.

177 { return I3_; }

◆ isospin3_rel()

double smash::ParticleType::isospin3_rel ( ) const

inline

Returns: the isospin-3 component relative to the total isospin.

Definition at line 180 of file particletype.h.

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

◆ iso_multiplet()

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

inline

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

Definition at line 186 of file particletype.h.

186 { return iso_multiplet_; }

◆ 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 189 of file particletype.h.

189 { return charge_; }

◆ 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 192 of file particletype.h.

192 { return pdgcode_.spin(); }

smash::PdgCode::spin

unsigned int spin() const

Definition: pdgcode.h:608

◆ spin_degeneracy()

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

inline

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

Definition at line 195 of file particletype.h.

195 { return pdgcode_.spin_degeneracy(); }

smash::PdgCode::spin_degeneracy

unsigned int spin_degeneracy() const

Definition: pdgcode.h:644

◆ is_hadron()

bool smash::ParticleType::is_hadron ( ) const

inline

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

Definition at line 198 of file particletype.h.

198 { return pdgcode_.is_hadron(); }

◆ is_lepton()

bool smash::ParticleType::is_lepton ( ) const

inline

Returns: true if this is a lepton.

Definition at line 201 of file particletype.h.

201 { return pdgcode_.is_lepton(); }

smash::PdgCode::is_lepton

bool is_lepton() const

Definition: pdgcode.h:375

◆ is_baryon()

bool smash::ParticleType::is_baryon ( ) const

inline

Returns: whether this PDG code identifies a baryon.

Definition at line 204 of file particletype.h.

204 { return pdgcode_.is_baryon(); }

smash::PdgCode::is_baryon

bool is_baryon() const

Definition: pdgcode.h:391

◆ is_meson()

bool smash::ParticleType::is_meson ( ) const

inline

Returns: whether this PDG code identifies a meson.

Definition at line 207 of file particletype.h.

207 { return pdgcode_.is_meson(); }

smash::PdgCode::is_meson

bool is_meson() const

Definition: pdgcode.h:394

◆ baryon_number()

int smash::ParticleType::baryon_number ( ) const

inline

Returns: the baryon number of the particle.

Definition at line 210 of file particletype.h.

210 { return pdgcode_.baryon_number(); }

smash::PdgCode::baryon_number

int baryon_number() const

Definition: pdgcode.h:381

◆ 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 213 of file particletype.h.

213 { return pdgcode_.strangeness(); }

smash::PdgCode::strangeness

int strangeness() const

Definition: pdgcode.h:543

◆ is_nucleon()

bool smash::ParticleType::is_nucleon ( ) const

inline

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

Definition at line 216 of file particletype.h.

216 { return pdgcode_.is_nucleon(); }

smash::PdgCode::is_nucleon

bool is_nucleon() const

Definition: pdgcode.h:397

◆ is_pion()

bool smash::ParticleType::is_pion ( ) const

inline

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

Definition at line 219 of file particletype.h.

219 { return pdgcode_.is_pion(); }

smash::PdgCode::is_pion

bool is_pion() const

Definition: pdgcode.h:457

◆ is_kaon()

bool smash::ParticleType::is_kaon ( ) const

inline

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

Definition at line 222 of file particletype.h.

222 { return pdgcode_.is_kaon(); }

smash::PdgCode::is_kaon

bool is_kaon() const

Definition: pdgcode.h:451

◆ is_Delta()

bool smash::ParticleType::is_Delta ( ) const

inline

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

Definition at line 225 of file particletype.h.

225 { return pdgcode_.is_Delta(); }

smash::PdgCode::is_Delta

bool is_Delta() const

Definition: pdgcode.h:421

◆ is_rho()

bool smash::ParticleType::is_rho ( ) const

inline

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

Definition at line 228 of file particletype.h.

228 { return pdgcode_.is_rho(); }

smash::PdgCode::is_rho

bool is_rho() const

Definition: pdgcode.h:469

◆ is_Nstar()

bool smash::ParticleType::is_Nstar ( ) const

inline

Returns: Is this a nucleon resonance (N*)?

Definition at line 231 of file particletype.h.

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

◆ is_Nstar1535()

bool smash::ParticleType::is_Nstar1535 ( ) const

inline

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

Definition at line 237 of file particletype.h.

237 { return pdgcode_.is_Nstar1535(); }

smash::PdgCode::is_Nstar1535

bool is_Nstar1535() const

Definition: pdgcode.h:415

◆ is_Deltastar()

bool smash::ParticleType::is_Deltastar ( ) const

inline

Returns: Is this a Delta resonance (Delta*)?

Definition at line 240 of file particletype.h.

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

◆ is_stable()

bool smash::ParticleType::is_stable ( ) const

inline

Returns: whether the particle is stable

Definition at line 246 of file particletype.h.

246 { return width_ < width_cutoff; }

smash::ParticleType::width_cutoff

static constexpr double width_cutoff

Decay width cutoff for considering a particle as stable.

Definition: particletype.h:108

◆ is_nucleus()

bool smash::ParticleType::is_nucleus ( ) const

inline

Returns: whether the particle is a nucleus

Definition at line 249 of file particletype.h.

249 { return pdgcode_.is_nucleus(); }

smash::PdgCode::is_nucleus

bool is_nucleus() const

Definition: pdgcode.h:364

◆ is_deuteron()

bool smash::ParticleType::is_deuteron ( ) const

inline

Returns: whether the particle is an (anti-)deuteron

Definition at line 252 of file particletype.h.

252 { return pdgcode_.is_deuteron(); }

smash::PdgCode::is_deuteron

bool is_deuteron() const

Definition: pdgcode.h:475

◆ is_triton()

bool smash::ParticleType::is_triton ( ) const

inline

Returns: whether the particle is an (anti-)triton

Definition at line 255 of file particletype.h.

255 { return pdgcode_.is_triton(); }

smash::PdgCode::is_triton

bool is_triton() const

Definition: pdgcode.h:481

◆ is_dprime()

bool smash::ParticleType::is_dprime ( ) const

inline

Returns: whether the particle is an artificial d' resonance

Definition at line 258 of file particletype.h.

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

◆ 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 364 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_;
 }

◆ 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 378 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() &&
         this->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 (this->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 (this->spectral_function(mid) > really_small) {
           right_bound_bis = mid;
         } else {
           left_bound_bis = mid;
         }
       }
       min_mass_spectral_ = right_bound_bis;
     }
   }
   return min_mass_spectral_;
 }

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

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

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

◆ 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 489 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 sqare 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;
 }

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

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

◆ spectral_function()

double smash::ParticleType::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 569 of file particletype.cc.

                                                      {
   if (norm_factor_ < 0.) {
     /* Initialize the normalization factor
      * by integrating over the unnormalized spectral function. */
     static /*thread_local (see #3075)*/ 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 spectral_function_no_norm(m_x) * jacobian;
                    });
   }
   return norm_factor_ * spectral_function_no_norm(m);
 }

◆ spectral_function_no_norm()

double smash::ParticleType::spectral_function_no_norm ( 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 589 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);
 }

◆ spectral_function_const_width()

double smash::ParticleType::spectral_function_const_width ( double m ) const

Todo:: unused The spectral function with a constant width (= width at pole).

It is guaranteed to be normalized to 1, when integrated from 0 to inf.

Definition at line 599 of file particletype.cc.

                                                                  {
   /* The spectral function is a relativistic Breit-Wigner function.
    * This variant is using a constant width (evaluated at the pole mass). */
   const double resonance_width = width_at_pole();
   if (resonance_width < ParticleType::width_cutoff) {
     return 0.;
   }
   return breit_wigner(m, mass(), resonance_width);
 }

◆ spectral_function_simple()

double smash::ParticleType::spectral_function_simple ( 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 609 of file particletype.cc.

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

◆ 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 614 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 = this->min_mass_spectral();
  
   // largest possible cm momentum (from smallest mass)
   const double pcm_max = pCM(cms_energy, mass_stable, min_mass);
   const double blw_max = pcm_max * blatt_weisskopf_sqr(pcm_max, L);
   /* 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
    * spectral_function(m) > spectral_function_simple(m). */
   const double sf_ratio_max =
       std::max(1., this->spectral_function(max_mass) /
                        this->spectral_function_simple(max_mass));
  
   double mass_res, val;
   // outer loop: repeat if maximum is too small
   do {
     const double q_max = sf_ratio_max * this->max_factor1_;
     const double max = blw_max * q_max;  // maximum value for rejection sampling
     // inner loop: rejection sampling
     do {
       // sample mass from a simple Breit-Wigner (aka Cauchy) distribution
       mass_res = random::cauchy(this->mass(), this->width_at_pole() / 2.,
                                 this->min_mass_spectral(), max_mass);
       // determine cm momentum for this case
       const double pcm = pCM(cms_energy, mass_stable, mass_res);
       const double blw = pcm * blatt_weisskopf_sqr(pcm, L);
       // determine ratio of full to simple spectral function
       const double q = this->spectral_function(mass_res) /
                        this->spectral_function_simple(mass_res);
       val = q * blw;
     } while (val < random::uniform(0., max));
  
     // check that we are using the proper maximum value
     if (val > max) {
       logg[LResonances].debug(
           "maximum is being increased in sample_resonance_mass: ",
           this->max_factor1_, " ", val / max, " ", this->pdgcode(), " ",
           mass_stable, " ", cms_energy, " ", mass_res);
       this->max_factor1_ *= val / max;
     } else {
       break;  // maximum ok, exit loop
     }
   } while (true);
  
   return mass_res;
 }

◆ sample_resonance_masses()

std::pair< double, double > smash::ParticleType::sample_resonance_masses	(	const ParticleType &	t2,
		const double	cms_energy,
		int	L = `0`
	)		const

Resonance mass sampling for 2-particle final state with two resonances.

Parameters

[in]	t2	Type of the second resonance (the first resonance is given by 'this').
[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 masses of the resonance particles.

Definition at line 671 of file particletype.cc.

                                                                   {
   const ParticleType &t1 = *this;
   /* Sample resonance mass from the distribution
    * used for calculating the cross section. */
   const double max_mass_1 =
       std::nextafter(cms_energy - t2.min_mass_spectral(), 0.);
   const double max_mass_2 =
       std::nextafter(cms_energy - t1.min_mass_spectral(), 0.);
   // largest possible cm momentum (from smallest mass)
   const double pcm_max =
       pCM(cms_energy, t1.min_mass_spectral(), t2.min_mass_spectral());
   const double blw_max = pcm_max * blatt_weisskopf_sqr(pcm_max, L);
  
   double mass_1, mass_2, val;
   // outer loop: repeat if maximum is too small
   do {
     // maximum value for rejection sampling (determined automatically)
     const double max = blw_max * t1.max_factor2_;
     // inner loop: rejection sampling
     do {
       // sample mass from a simple Breit-Wigner (aka Cauchy) distribution
       mass_1 = random::cauchy(t1.mass(), t1.width_at_pole() / 2.,
                               t1.min_mass_spectral(), max_mass_1);
       mass_2 = random::cauchy(t2.mass(), t2.width_at_pole() / 2.,
                               t2.min_mass_spectral(), max_mass_2);
       // determine cm momentum for this case
       const double pcm = pCM(cms_energy, mass_1, mass_2);
       const double blw = pcm * blatt_weisskopf_sqr(pcm, L);
       // determine ratios of full to simple spectral function
       const double q1 =
           t1.spectral_function(mass_1) / t1.spectral_function_simple(mass_1);
       const double q2 =
           t2.spectral_function(mass_2) / t2.spectral_function_simple(mass_2);
       val = q1 * q2 * blw;
     } while (val < random::uniform(0., max));
  
     if (val > max) {
       logg[LResonances].debug(
           "maximum is being increased in sample_resonance_masses: ",
           t1.max_factor2_, " ", val / max, " ", t1.pdgcode(), " ", t2.pdgcode(),
           " ", cms_energy, " ", mass_1, " ", mass_2);
       t1.max_factor2_ *= val / max;
     } else {
       break;  // maximum ok, exit loop
     }
   } while (true);
  
   return {mass_1, mass_2};
 }

◆ 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 722 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 = spectral_function(m);
     if (m > rightmost_pole * 2 && sf < spectral_function_threshold) {
       break;
     }
     std::cout << m << " " << w << " " << sf << std::endl;
   }
 }

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

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

69 { return nucleons_list; }

smash::anonymous_namespace{particletype.cc}::nucleons_list

ParticleTypePtrList nucleons_list

Global pointer to the Particle Type list of nucleons.

Definition: particletype.cc:38

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

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

75 { return deltas_list; }

smash::anonymous_namespace{particletype.cc}::deltas_list

ParticleTypePtrList deltas_list

Global pointer to the Particle Type list of deltas.

Definition: particletype.cc:42

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

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

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

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

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

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

◆ 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 199 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);
     }
   }
 } /*}}}*/

◆ 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 540 of file particletype.h.

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

◆ 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 547 of file particletype.h.

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

◆ 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 556 of file particletype.h.

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

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

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

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 108 of file particletype.h.

◆ name_

std::string smash::ParticleType::name_

private

name of the particle

Definition at line 619 of file particletype.h.

◆ mass_

double smash::ParticleType::mass_

private

pole mass of the particle

Definition at line 621 of file particletype.h.

◆ width_

double smash::ParticleType::width_

private

width of the particle

Definition at line 623 of file particletype.h.

◆ parity_

Parity smash::ParticleType::parity_

private

Parity of the particle.

Definition at line 625 of file particletype.h.

◆ pdgcode_

PdgCode smash::ParticleType::pdgcode_

private

PDG Code of the particle.

Definition at line 627 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 634 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 641 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 644 of file particletype.h.

◆ charge_

int32_t smash::ParticleType::charge_

private

Charge of the particle; filled automatically from pdgcode_.

Definition at line 646 of file particletype.h.

◆ isospin_

int smash::ParticleType::isospin_

mutableprivate

Isospin of the particle; filled automatically from pdgcode_.

Definition at line 648 of file particletype.h.

◆ I3_

int smash::ParticleType::I3_

private

Isospin projection of the particle; filled automatically from pdgcode_.

Definition at line 650 of file particletype.h.

◆ iso_multiplet_

IsoParticleType* smash::ParticleType::iso_multiplet_ = nullptr

private

Container for the isospin multiplet information.

Definition at line 653 of file particletype.h.

◆ max_factor1_

double smash::ParticleType::max_factor1_ = 1.

mutableprivate

Maximum factor for single-res mass sampling, cf. sample_resonance_mass.

Definition at line 656 of file particletype.h.

◆ max_factor2_

double smash::ParticleType::max_factor2_ = 1.

mutableprivate

Maximum factor for double-res mass sampling, cf. sample_resonance_masses.

Definition at line 658 of file particletype.h.

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

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

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Attributes

Friends

Constructor & Destructor Documentation

◆ ParticleType() [1/3]

◆ ParticleType() [2/3]

◆ ParticleType() [3/3]

Member Function Documentation

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ decay_modes()

◆ name()

◆ mass()

◆ mass_sqr()

◆ width_at_pole()

◆ parity()

◆ pdgcode()

◆ has_antiparticle()

◆ get_antiparticle()

◆ antiparticle_sign()

◆ isospin()

◆ isospin3()

◆ isospin3_rel()

◆ iso_multiplet()

◆ charge()

◆ spin()

◆ spin_degeneracy()

◆ is_hadron()

◆ is_lepton()

◆ is_baryon()

◆ is_meson()

◆ baryon_number()

◆ strangeness()

◆ is_nucleon()

◆ is_pion()

◆ is_kaon()

◆ is_Delta()

◆ is_rho()

◆ is_Nstar()

◆ is_Nstar1535()

◆ is_Deltastar()

◆ is_stable()

◆ is_nucleus()

◆ is_deuteron()

◆ is_triton()

◆ is_dprime()

◆ min_mass_kinematic()

◆ min_mass_spectral()

◆ partial_width()

◆ total_width()

◆ wanted_decaymode()

◆ get_partial_widths()

◆ get_partial_width()

◆ get_partial_in_width()

◆ spectral_function()

◆ spectral_function_no_norm()

◆ spectral_function_const_width()

◆ spectral_function_simple()

◆ sample_resonance_mass()

◆ sample_resonance_masses()

◆ dump_width_and_spectral_function()

◆ list_all()

◆ list_nucleons()

◆ list_anti_nucleons()

◆ list_Deltas()

◆ list_anti_Deltas()

◆ list_baryon_resonances()

◆ list_light_nuclei()

◆ try_find()

◆ find()

◆ exists() [1/2]

◆ exists() [2/2]

◆ create_type_list()

◆ operator==()

◆ operator!=()

◆ operator<()

◆ check_consistency()