marley::MassTable Class Reference

Singleton lookup table for particle and atomic masses. More...

#include <MassTable.hh>

Public Member Functions
	MassTable (const MassTable &)=delete
	Deleted copy constructor.
	MassTable (MassTable &&)=delete
	Deleted move constructor.
double	fragment_emission_threshold (const int Zi, const int Ai, const marley::Fragment &f) const
	Get the approximate excitation energy threshold for emission of a particular nuclear fragment.
double	get_atomic_mass (int pdg_code, bool theory_ok=true) const
	Get the mass of an atom.
double	get_atomic_mass (int Z, int A, bool theory_ok=true) const
	Get the mass of an atom.
double	get_binding_energy (int Z, int A, bool theory_ok=true) const
	Get the binding energy of a nucleus.
double	get_fragment_separation_energy (int nuc_pdg, int frag_pdg, bool theory_ok=true) const
	Get the separation energy for emission of a nuclear fragment from a nucleus.
double	get_fragment_separation_energy (int Z, int A, int pdg, bool theory_ok=true) const
	Get the separation energy for emission of a nuclear fragment from a nucleus.
double	get_mass_excess (int Z, int A, bool theory_ok=true) const
	Get the mass excess of a nucleus.
double	get_particle_mass (int pdg_code) const
	Get the mass of a particle.
double	liquid_drop_model_atomic_mass (int Z, int A) const
	Calculate a theoretical atomic mass using the liquid drop model.
double	liquid_drop_model_mass_excess (int Z, int A) const
	Calculate a theoretical mass excess for a nucleus using the liquid drop model.
MassTable &	operator= (const MassTable &)=delete
	Deleted copy assignment operator.
MassTable &	operator= (MassTable &&)=delete
	Deleted move assignment operator.
double	unbound_threshold (const int initial_nucleus_pdg) const
	Computes the lowest excitation energy at which one of the nuclear fragments considered by the HauserFeshbachDecay class may be emitted.
double	unbound_threshold (const int Zi, const int Ai) const
	Computes the lowest excitation energy at which one of the nuclear fragments considered by the HauserFeshbachDecay class may be emitted.

Static Public Member Functions
static const MassTable &	Instance ()
	Get a const reference to the singleton instance of the MassTable.

Protected Member Functions
	MassTable ()
	Create the singleton MassTable object.

Detailed Description

Singleton lookup table for particle and atomic masses.

Definition at line 30 of file MassTable.hh.

Constructor & Destructor Documentation

MassTable()

marley::MassTable::MassTable ( )

protected

Create the singleton MassTable object.

Definition at line 30 of file MassTable.cc.

                           {
 
  // Instantiate the file manager and use it to find
  // the mass table data file
  const auto& fm = marley::FileManager::Instance();
  std::string full_mt_file_name
    = fm.find_file( data_file_name_ );
 
  if ( full_mt_file_name.empty() ) {
    throw marley::Error("Could not find the MARLEY mass table"
      " data file " + data_file_name_ + ". Please ensure that"
      " the folder containing it is on the MARLEY search path."
      " If needed, the folder can be appended to the MARLEY_SEARCH_PATH"
      " environment variable.");
  }
 
  MARLEY_LOG( INFO, "init.structure" ) << "Loading particle and atomic masses from "
    << full_mt_file_name;
 
  // Read in the mass table from a JSON data file
  auto json_table = marley::JSON::load_file( full_mt_file_name );
 
  // Store the JSON entries in the relevant unordered maps
  if ( !json_table.has_key("particle_masses") ) {
    throw marley::Error("Problem reading the mass table data file "
      + data_file_name_ + ". Missing \"particle_masses\" JSON array.");
  }
  const auto& pm_json = json_table.at("particle_masses");
  assign_masses( pm_json, "particle_masses", this->particle_masses_ );
 
  if ( !json_table.has_key("atomic_masses") ) {
    throw marley::Error("Problem reading the mass table data file "
      + data_file_name_ + ". Missing \"atomic_masses\" JSON array.");
  }
  const auto& am_json = json_table.at("atomic_masses");
  assign_masses( am_json, "atomic_masses", this->atomic_masses_ );
 
}

References marley::FileManager::Instance().

Member Function Documentation

fragment_emission_threshold()

double marley::MassTable::fragment_emission_threshold	(	const int	Zi,
		const int	Ai,
		const marley::Fragment &	f ) const

Get the approximate excitation energy threshold for emission of a particular nuclear fragment.

Parameters

Zi	Proton number of the initial nucleus
Ai	Mass number of the initial nucleus
f	Fragment to be emitted

Definition at line 270 of file MassTable.cc.

{
  // Separation energy for the fragment
  double Sa = this->get_fragment_separation_energy( Zi, Ai, f.get_pid() );
  return Sa;
}

References get_fragment_separation_energy(), and marley::Fragment::get_pid().

Referenced by unbound_threshold().

get_atomic_mass() [1/2]

double marley::MassTable::get_atomic_mass	(	int	pdg_code,
		bool	theory_ok = true ) const

Get the mass of an atom.

Parameters

pdg_code	PDG code identifying the nucleus of the atom
theory_ok	Whether to calculate a theoretical mass using the liquid drop model if an experimental mass cannot be found. If theory_ok is false, then a marley::Error will be thrown if an experimental mass cannot be found.

Returns

Atomic mass (MeV)

Definition at line 95 of file MassTable.cc.

{
  bool exp;
  double mass = lookup_atomic_mass(nucleus_pid, exp,
    theory_ok);
  if (exp) mass *= micro_amu_;
  return mass;
}

Referenced by marley::NuclearReaction::NuclearReaction(), and marley::DecayScheme::do_cascade().

get_atomic_mass() [2/2]

double marley::MassTable::get_atomic_mass	(	int	Z,
		int	A,
		bool	theory_ok = true ) const

Get the mass of an atom.

Parameters

Z	Atomic number of the atom
A	Mass number of the atom
theory_ok	Whether to calculate a theoretical mass using the liquid drop model if an experimental mass cannot be found. If theory_ok is false, then a marley::Error will be thrown if an experimental mass cannot be found.

Returns

Atomic mass (MeV)

Definition at line 191 of file MassTable.cc.

                                                                          {
  bool exp;
  double mass = lookup_atomic_mass(Z, A, exp, theory_ok);
  if (exp) mass *= micro_amu_;
  return mass;
}

get_binding_energy()

double marley::MassTable::get_binding_energy	(	int	Z,
		int	A,
		bool	theory_ok = true ) const

Get the binding energy of a nucleus.

Parameters

Z	Atomic number
A	Mass number
theory_ok	Whether to use a theoretical (liquid drop model) atomic mass during the calculation if an experimental atomic mass cannot be found. If theory_ok is false, then a marley::Error will be thrown if an experimental atomic mass cannot be found.

Returns

Binding energy (MeV)

Definition at line 167 of file MassTable.cc.

{
  int N = A - Z;
  double m_hydrogen_1 = atomic_masses_.at(1000010010);
  double mn = particle_masses_.at(marley_utils::NEUTRON);
 
  bool exp;
  double mN = lookup_atomic_mass(Z, A, exp, theory_ok);
 
  // Experimental masses are given in micro-amu, while our liquid drop model
  // estimates are given in MeV, so adjust the calculation appropriately
  // depending on which unit we are using for mN.
  if (exp) return micro_amu_ * (Z*m_hydrogen_1 + N*mn - mN);
  else return micro_amu_ * (Z*m_hydrogen_1 + N*mn) - mN;
}

get_fragment_separation_energy() [1/2]

double marley::MassTable::get_fragment_separation_energy	(	int	nuc_pdg,
		int	frag_pdg,
		bool	theory_ok = true ) const

Get the separation energy for emission of a nuclear fragment from a nucleus.

Parameters

nuc_pdg	PDG code for the mother nucleus
frag_pdg	PDG code for the emitted nuclear fragment
theory_ok	Whether to calculate a theoretical mass using the liquid drop model if an experimental mass cannot be found. If theory_ok is false, then a marley::Error will be thrown if an experimental mass cannot be found.

Returns

Separation energy (MeV)

Definition at line 198 of file MassTable.cc.

{
  int Zi = marley_utils::get_particle_Z( nuc_pdg );
  int Ai = marley_utils::get_particle_A( nuc_pdg );
  return this->get_fragment_separation_energy( Zi, Ai, frag_pdg, theory_ok );
}

References get_fragment_separation_energy().

get_fragment_separation_energy() [2/2]

double marley::MassTable::get_fragment_separation_energy	(	int	Z,
		int	A,
		int	pdg,
		bool	theory_ok = true ) const

Get the separation energy for emission of a nuclear fragment from a nucleus.

Parameters

Z	Atomic number for the mother nucleus
A	Mass number for the mother nucleus
pdg	PDG code for the emitted nuclear fragment
theory_ok	Whether to calculate a theoretical mass using the liquid drop model if an experimental mass cannot be found. If theory_ok is false, then a marley::Error will be thrown if an experimental mass cannot be found.

Returns

Separation energy (MeV)

Definition at line 206 of file MassTable.cc.

{
  int Zx = marley_utils::get_particle_Z(pid);
  int Zf = Z - Zx;
  int Af = A - marley_utils::get_particle_A(pid);
 
  // This value is in micro-atomic-mass-units (micro-AMU)
  double extra_mass = Zx*particle_masses_.at(marley_utils::ELECTRON)
    + particle_masses_.at(pid);
 
  // These values may be in micro-AMU or MeV
  bool exp_i, exp_f;
  double m_atom_initial = lookup_atomic_mass(Z, A, exp_i, theory_ok);
  double m_atom_final = lookup_atomic_mass(Zf, Af, exp_f, theory_ok);
 
  // Experimental values are tabulated in micro-AMU, while theoretical
  // estimates use MeV. Adjust application of the conversion factor
  // appropriately for each case so that we always return something in MeV.
  if (exp_i) {
    if (exp_f) return micro_amu_*(m_atom_final - m_atom_initial + extra_mass);
    else return m_atom_final + micro_amu_*(extra_mass - m_atom_initial);
  }
  else if (exp_f) return micro_amu_*(m_atom_final + extra_mass)
    - m_atom_initial;
  else return micro_amu_*extra_mass + m_atom_final - m_atom_initial;
}

Referenced by marley::BackshiftedFermiGasModel::BackshiftedFermiGasModel(), fragment_emission_threshold(), and get_fragment_separation_energy().

get_mass_excess()

double marley::MassTable::get_mass_excess	(	int	Z,
		int	A,
		bool	theory_ok = true ) const

Get the mass excess of a nucleus.

Parameters

Z	Atomic number
A	Mass number
theory_ok	Whether to use a theoretical (liquid drop model) atomic mass during the calculation if an experimental atomic mass cannot be found. If theory_ok is false, then a marley::Error will be thrown if an experimental atomic mass cannot be found.

Returns

Mass excess (MeV)

Definition at line 183 of file MassTable.cc.

{
  bool exp;
  double mN = lookup_atomic_mass(Z, A, exp, theory_ok);
  if (exp) return micro_amu_*(mN - A*1e6);
  else return mN - micro_amu_*A*1e6;
}

Referenced by marley::BackshiftedFermiGasModel::BackshiftedFermiGasModel().

get_particle_mass()

double marley::MassTable::get_particle_mass

(

int

pdg_code

)

const

Get the mass of a particle.

Parameters

pdg_code

PDG code identifying the type of particle

Returns

Particle mass (MeV)

Definition at line 84 of file MassTable.cc.

                                                               {
  int id = particle_id;
  // The lookup table only includes entries for particles (as opposed to
  // antiparticles), so flip the sign of the input particle id for the
  // lookup if it represents an antiparticle.
  if (id < 0) id *= -1;
  // Find the particle's mass in the lookup table, and convert its
  // value from micro-amu to MeV
  return micro_amu_ * particle_masses_.at(id);
}

Referenced by marley::CoulombCorrector::CoulombCorrector(), marley::NuclearReaction::NuclearReaction(), marley::DecayScheme::do_cascade(), marley::Fragment::get_mass(), and marley::WeisskopfSingleParticleModel::strength_function().

Instance()

const marley::MassTable & marley::MassTable::Instance ( )

static

Get a const reference to the singleton instance of the MassTable.

Definition at line 69 of file MassTable.cc.

                                                 {
 
  // Create the mass table using a static variable. This ensures
  // that the singleton instance is only created once.
  static std::unique_ptr<marley::MassTable>
    the_instance(new marley::MassTable());
 
  // Return a reference to the singleton instance
  return *the_instance;
}

Referenced by marley::BackshiftedFermiGasModel::BackshiftedFermiGasModel(), marley::CoulombCorrector::CoulombCorrector(), marley::KoningDelarocheOpticalModel::KoningDelarocheOpticalModel(), marley::NuclearReaction::NuclearReaction(), marley::CommandHandler::cmd_decay(), marley::TabulatedXSec::compute_integral(), marley::DecayScheme::do_cascade(), marley::Fragment::get_mass(), marley::FragmentExitChannel::max_Exf(), marley::KoningDelarocheOpticalModel::optical_model_potential(), marley::ExitChannel::prepare_products(), marley::NucleusDecayer::process_event(), marley::DecayScheme::read_from_stream(), marley::ContinuumNuclearReaction::reassign_sub_continuum(), marley::WeisskopfSingleParticleModel::strength_function(), and marley::KoningDelarocheOpticalModel::total_cross_section().

liquid_drop_model_atomic_mass()

double marley::MassTable::liquid_drop_model_atomic_mass	(	int	Z,
		int	A ) const

Calculate a theoretical atomic mass using the liquid drop model.

Parameters

Z	Atomic number
A	Mass number

Returns

Atomic mass (MeV)

Definition at line 80 of file MassTable.cc.

                                                                        {
  return liquid_drop_model_mass_excess(Z, A) + micro_amu_*1e6*A;
}

References liquid_drop_model_mass_excess().

liquid_drop_model_mass_excess()

double marley::MassTable::liquid_drop_model_mass_excess	(	int	Z,
		int	A ) const

Calculate a theoretical mass excess for a nucleus using the liquid drop model.

Parameters

Z	Atomic number
A	Mass number

Returns

Mass excess (MeV)

The liquid drop model parameters used here are based on those given in A. J. Koning, et al., Nucl. Phys. A 810 (2008) pp. 13-76 for use with the back-shifted Fermi gas nuclear level density model.

Definition at line 238 of file MassTable.cc.

                                                                        {
 
  // Liquid drop model parameters (taken from paper by A. J. Koning, et al.)
  static constexpr double Mn = 8.07144; // MeV
  static constexpr double MH = 7.28899; // MeV
  static constexpr double a1 = 15.677; // MeV
  static constexpr double a2 = 18.56; // MeV
  static constexpr double kappa = 1.79;
  static constexpr double c3 = 0.717; // MeV
  static constexpr double c4 = 1.21129; // MeV
 
  int N = A - Z;
 
  double kappa_term = kappa * std::pow((N - Z) / static_cast<double>(A), 2);
  double c1 = a1 * (1 - kappa_term);
  double c2 = a2 * (1 - kappa_term);
 
  double Evol = -c1 * A;
  double Esur = c2 * std::pow(A, 2.0/3.0);
  double Ecoul = (c3 / std::pow(A, 1.0/3.0) - c4 / A) * std::pow(Z, 2);
 
  double delta_LDM = 0;
  bool z_odd = Z % 2;
  bool n_odd = N % 2;
 
  // delta_LDM will be zero if the nucleus is odd-even
  if (z_odd && n_odd) delta_LDM = 11/std::sqrt(A);
  else if (!z_odd && !n_odd) delta_LDM = -11/std::sqrt(A);
 
  return Mn * N + MH * Z + Evol + Esur + Ecoul + delta_LDM;
}

Referenced by marley::BackshiftedFermiGasModel::BackshiftedFermiGasModel(), and liquid_drop_model_atomic_mass().

unbound_threshold() [1/2]

double marley::MassTable::unbound_threshold

(

const int

initial_nucleus_pdg

)

const

Computes the lowest excitation energy at which one of the nuclear fragments considered by the HauserFeshbachDecay class may be emitted.

Parameters

initial_nucleus_pdg

PDG code of the initial nucleus

Definition at line 303 of file MassTable.cc.

{
  int Zi = marley_utils::get_particle_Z( initial_nucleus_pdg );
  int Ai = marley_utils::get_particle_A( initial_nucleus_pdg );
  return this->unbound_threshold( Zi, Ai );
}

References unbound_threshold().

unbound_threshold() [2/2]

double marley::MassTable::unbound_threshold	(	const int	Zi,
		const int	Ai ) const

Computes the lowest excitation energy at which one of the nuclear fragments considered by the HauserFeshbachDecay class may be emitted.

Parameters

Zi	Proton number of the initial nucleus
Ai	Mass number of the initial nucleus

Definition at line 281 of file MassTable.cc.

{
  // Before looking up the separation energies, start by setting the unbound
  // threshold to infinity.
  double unbound_threshold = std::numeric_limits<double>::max();
  MARLEY_LOG( TRACE, "init.structure.masstable" ) << "unbound_threshold = " << unbound_threshold << '\n';
 
  // Loop over each available nuclear fragment. If it has a smaller separation
  // energy than the current value of unbound_threshold, update the stored value
  for ( const auto& pair : marley::StructureDatabase::fragments() ) {
    const marley::Fragment& f = pair.second;
    double thresh = this->fragment_emission_threshold( Zi, Ai, f );
    MARLEY_LOG( TRACE, "init.structure.masstable" ) << f.get_pid()
      << " emission threshold = " << thresh << '\n';
    if ( thresh < unbound_threshold ) unbound_threshold = thresh;
    MARLEY_LOG( TRACE, "init.structure.masstable" ) << "unbound_threshold = "
      << unbound_threshold << '\n';
  }
 
  return unbound_threshold;
}

References fragment_emission_threshold(), marley::StructureDatabase::fragments(), marley::Fragment::get_pid(), and unbound_threshold().

Referenced by unbound_threshold(), and unbound_threshold().

---

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

• /home/sjg/Desktop/marley/include/marley/MassTable.hh
• /home/sjg/Desktop/marley/src/MassTable.cc