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 97 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
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_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_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 ParticleType &t_a, const ParticleType &t_b) 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

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 126 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()) {}

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

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

default

move ctors are needed for std::sort

Member Function Documentation

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

delete

assignment is not allowed, see copy constructor above

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

default

move ctors are needed for std::sort

const DecayModes & smash::ParticleType::decay_modes

(

)

const

Returns

the DecayModes object for this particle type.

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

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

inline

Returns

the name of the particle.

Definition at line 141 of file particletype.h.

{ return name_; }

Here is the caller graph for this function:

double smash::ParticleType::mass ( ) const

inline

Returns

the particle pole mass.

Definition at line 144 of file particletype.h.

{ return mass_; }

Here is the caller graph for this function:

double smash::ParticleType::mass_sqr ( ) const

inline

Returns

the squared particle mass.

Definition at line 147 of file particletype.h.

{ return mass_ * mass_; }

double smash::ParticleType::width_at_pole ( ) const

inline

Returns

the particle width (at the mass pole).

Definition at line 150 of file particletype.h.

{ return width_; }

Here is the caller graph for this function:

Parity smash::ParticleType::parity ( ) const

inline

Returns

the parity of the particle.

Definition at line 153 of file particletype.h.

{ return parity_; }

Here is the caller graph for this function:

PdgCode smash::ParticleType::pdgcode ( ) const

inline

Returns

the PDG code of the particle.

Definition at line 156 of file particletype.h.

{ return pdgcode_; }

Here is the caller graph for this function:

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

{ return pdgcode_.has_antiparticle(); }

Here is the caller graph for this function:

ParticleTypePtr smash::ParticleType::get_antiparticle ( ) const

inline

Returns

a pointer to the corresponding antiparticle ParticleType object.

Definition at line 735 of file particletype.h.

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

Here is the caller graph for this function:

int smash::ParticleType::antiparticle_sign ( ) const

inline

Returns

-1 for antiparticles and +1 for particles.

Definition at line 165 of file particletype.h.

{ return pdgcode_.antiparticle_sign(); }

Here is the caller graph for this function:

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 407 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:

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

{ return I3_; }

Here is the caller graph for this function:

double smash::ParticleType::isospin3_rel ( ) const

inline

Returns

the isospin-3 component relative to the total isospin.

Definition at line 179 of file particletype.h.

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

Here is the caller graph for this function:

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

inline

Returns

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

Definition at line 185 of file particletype.h.

{ return iso_multiplet_; }

Here is the caller graph for this function:

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

{ return charge_; }

Here is the caller graph for this function:

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

inline

Todo:

(oliiny): take care of spin for nuclei

Returns

twice the spin of a particle.

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

Definition at line 191 of file particletype.h.

{ return pdgcode_.spin(); }

Here is the caller graph for this function:

bool smash::ParticleType::is_hadron ( ) const

inline

Returns

true if this is a baryon, antibaryon or meson.

Definition at line 194 of file particletype.h.

{ return pdgcode_.is_hadron(); }

Here is the caller graph for this function:

bool smash::ParticleType::is_lepton ( ) const

inline

Returns

true if this is a lepton.

Definition at line 197 of file particletype.h.

{ return pdgcode_.is_lepton(); }

bool smash::ParticleType::is_baryon ( ) const

inline

Returns

whether this PDG code identifies a baryon.

Definition at line 200 of file particletype.h.

{ return pdgcode_.is_baryon(); }

Here is the caller graph for this function:

bool smash::ParticleType::is_meson ( ) const

inline

Returns

whether this PDG code identifies a meson.

Definition at line 203 of file particletype.h.

{ return pdgcode_.is_meson(); }

Here is the caller graph for this function:

int smash::ParticleType::baryon_number ( ) const

inline

Returns

the baryon number of the particle.

Definition at line 206 of file particletype.h.

{ return pdgcode_.baryon_number(); }

Here is the caller graph for this function:

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

{ return pdgcode_.strangeness(); }

Here is the caller graph for this function:

bool smash::ParticleType::is_nucleon ( ) const

inline

Returns

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

Definition at line 212 of file particletype.h.

{ return pdgcode_.is_nucleon(); }

Here is the caller graph for this function:

bool smash::ParticleType::is_Delta ( ) const

inline

Returns

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

Definition at line 215 of file particletype.h.

{ return pdgcode_.is_Delta(); }

Here is the caller graph for this function:

bool smash::ParticleType::is_rho ( ) const

inline

Returns

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

Definition at line 218 of file particletype.h.

{ return pdgcode_.is_rho(); }

bool smash::ParticleType::is_Nstar ( ) const

inline

Returns

Is this a nucleon resonance (N*)?

Definition at line 221 of file particletype.h.

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

Here is the caller graph for this function:

bool smash::ParticleType::is_Nstar1535 ( ) const

inline

Returns

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

Definition at line 227 of file particletype.h.

{ return pdgcode_.is_Nstar1535(); }

Here is the caller graph for this function:

bool smash::ParticleType::is_Deltastar ( ) const

inline

Returns

Is this a Delta resonance (Delta*)?

Definition at line 230 of file particletype.h.

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

Here is the caller graph for this function:

bool smash::ParticleType::is_stable ( ) const

inline

Returns

whether the particle is stable

Definition at line 236 of file particletype.h.

{ return width_ < width_cutoff; }

Here is the caller graph for this function:

bool smash::ParticleType::is_nucleus ( ) const

inline

Returns

whether the particle is a nucleus

Definition at line 239 of file particletype.h.

{ return pdgcode_.is_nucleus(); }

Here is the caller graph for this function:

bool smash::ParticleType::is_deuteron ( ) const

inline

Returns

whether the particle is an (anti-)deuteron

Definition at line 242 of file particletype.h.

{ return pdgcode_.is_deuteron(); }

Here is the caller graph for this function:

bool smash::ParticleType::is_dprime ( ) const

inline

Returns

whether the particle is an artificial d' resonance

Definition at line 245 of file particletype.h.

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

Here is the caller graph for this function:

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 357 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:

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.

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 371 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_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 416 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:

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 432 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:

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

                                                              {
  const auto FinalTypes = t.particle_types();
  switch (wh) {
    case WhichDecaymodes::All: {
      return true;
    }
    case WhichDecaymodes::Hadronic: {
      // No dileptons in final state particles for 2 or 3-body decays
      return (
          (t.particle_number() == 2 &&
           !(is_dilepton(FinalTypes[0]->pdgcode(),
                         FinalTypes[1]->pdgcode()))) ||
          (t.particle_number() == 3 &&
           !(has_lepton_pair(FinalTypes[0]->pdgcode(), FinalTypes[1]->pdgcode(),
                             FinalTypes[2]->pdgcode()))));
    }
    case WhichDecaymodes::Dileptons: {
      // Lepton pair in final state particles for 2 or 3-body decays
      return (
          (t.particle_number() == 2 &&
           is_dilepton(FinalTypes[0]->pdgcode(), FinalTypes[1]->pdgcode())) ||
          (t.particle_number() == 3 &&
           has_lepton_pair(FinalTypes[0]->pdgcode(), FinalTypes[1]->pdgcode(),
                           FinalTypes[2]->pdgcode())));
    }
    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:

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();
  if (decay_mode_list.size() == 0 ||
      (wh == WhichDecaymodes::Hadronic && is_stable())) {
    return {};
  }
  /* 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(
            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:

double smash::ParticleType::get_partial_width	(	const double	m,
		const ParticleType &	t_a,
		const ParticleType &	t_b
	)		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]	t_a	Type of first daughter particle.
[in]	t_b	Type of second daughter particle.

Returns

the partial width for this mass and this specific decay channel

Definition at line 538 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 = {&t_a, &t_b};
    if (mode->type().has_particles(l)) {
      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:

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 555 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:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 594 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:

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

Here is the call graph for this function:

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 614 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:

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 619 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();
  assert(min_mass < max_mass);

  // 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) {
      const auto &log = logger<LogArea::Resonances>();
      log.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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 677 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) {
      const auto &log = logger<LogArea::Resonances>();
      log.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};
}

Here is the call graph for this function:

Here is the caller graph for this 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 728 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;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

                                               {
  assert(all_particle_types);
  return *all_particle_types;
}

Here is the caller graph for this function:

ParticleTypePtrList & smash::ParticleType::list_nucleons ( )

static

Returns

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

Definition at line 73 of file particletype.cc.

{ return nucleons_list; }

Here is the caller graph for this function:

ParticleTypePtrList & smash::ParticleType::list_anti_nucleons ( )

static

Returns

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

Definition at line 75 of file particletype.cc.

                                                      {
  return anti_nucs_list;
}

Here is the caller graph for this function:

ParticleTypePtrList & smash::ParticleType::list_Deltas ( )

static

Returns

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

Definition at line 79 of file particletype.cc.

{ return deltas_list; }

Here is the caller graph for this function:

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

                                                    {
  return anti_deltas_list;
}

Here is the caller graph for this function:

ParticleTypePtrList & smash::ParticleType::list_baryon_resonances ( )

static

Returns

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

Definition at line 85 of file particletype.cc.

                                                          {
  return baryon_resonances_list;
}

Here is the caller graph for this function:

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

                                                     {
  return light_nuclei_list;
}

Here is the caller graph for this function:

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 93 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:

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 103 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:

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 111 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:

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

Here is the call graph for this function:

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

                                                          {  // {{{
  const auto &log = logger<LogArea::ParticleType>();
  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 nucleon, kaon, and delta 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 0.938");
    }
    if (pdgcode[0].is_kaon() && !almost_equal(mass, kaon_mass)) {
      throw std::runtime_error("Kaon mass in input file different from 0.494");
    }
    if (pdgcode[0].is_Delta() && !almost_equal(mass, delta_mass)) {
      throw std::runtime_error("Delta mass in input file different from 1.232");
    }
    if (pdgcode[0].is_deuteron() && !almost_equal(mass, deuteron_mass)) {
      throw std::runtime_error("d mass in input file different from 1.8756");
    }

    // 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]);
      log.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);
        log.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:

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

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

Here is the call graph for this function:

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

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

Here is the call graph for this function:

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

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

Here is the call graph for this function:

void smash::ParticleType::check_consistency ( )

static

Exceptions

runtime_error

if unstable particles have no decay modes

Definition at line 448 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!");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 61 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:

Here is the caller graph for this function:

Member Data Documentation

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

static

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

std::string smash::ParticleType::name_

private

name of the particle

Definition at line 597 of file particletype.h.

double smash::ParticleType::mass_

private

pole mass of the particle

Definition at line 599 of file particletype.h.

double smash::ParticleType::width_

private

width of the particle

Definition at line 601 of file particletype.h.

Parity smash::ParticleType::parity_

private

Parity of the particle.

Definition at line 603 of file particletype.h.

PdgCode smash::ParticleType::pdgcode_

private

PDG Code of the particle.

Definition at line 605 of file particletype.h.

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

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

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

int32_t smash::ParticleType::charge_

private

Charge of the particle; filled automatically from pdgcode_.

Definition at line 624 of file particletype.h.

int smash::ParticleType::isospin_

mutableprivate

Isospin of the particle; filled automatically from pdgcode_.

Definition at line 626 of file particletype.h.

int smash::ParticleType::I3_

private

Isospin projection of the particle; filled automatically from pdgcode_.

Definition at line 628 of file particletype.h.

IsoParticleType* smash::ParticleType::iso_multiplet_ = nullptr

private

Container for the isospin multiplet information.

Definition at line 631 of file particletype.h.

double smash::ParticleType::max_factor1_ = 1.

mutableprivate

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

Definition at line 634 of file particletype.h.

double smash::ParticleType::max_factor2_ = 1.

mutableprivate

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

Definition at line 636 of file particletype.h.

---

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

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