MassTable.hh

//
// This file is part of MARLEY (Model of Argon Reaction Low Energy Yields)
//
// MARLEY is free software: you can redistribute it and/or modify it under the
// terms of version 3 of the GNU General Public License as published by the
// Free Software Foundation.
//
// For the full text of the license please see COPYING or
// visit http://opensource.org/licenses/GPL-3.0
//
// Please respect the MCnet academic usage guidelines. See GUIDELINES
// or visit https://www.montecarlonet.org/GUIDELINES for details.
 
#pragma once
 
// Standard library includes
#include <string>
#include <unordered_map>
 
namespace marley {
 
  // Forward-declare some classes
  class Fragment;
  class JSON;

  class MassTable {
 
    public:

      MassTable(const MassTable&) = delete;

      MassTable(MassTable&&) = delete;

      MassTable& operator=(const MassTable&) = delete;

      MassTable& operator=(MassTable&&) = delete;

      static const MassTable& Instance();

      double get_particle_mass(int pdg_code) const;

      double get_atomic_mass(int pdg_code, bool theory_ok = true) const;

      double get_atomic_mass(int Z, int A, bool theory_ok = true) const;

      double get_fragment_separation_energy(int Z, int A, int pdg,
        bool theory_ok = true) const;

      double get_fragment_separation_energy(int nuc_pdg, int frag_pdg,
        bool theory_ok = true) const;

      double get_binding_energy(int Z, int A, bool theory_ok = true) const;

      double get_mass_excess(int Z, int A, bool theory_ok = true) const;

      double liquid_drop_model_mass_excess(int Z, int A) const;

      double liquid_drop_model_atomic_mass(int Z, int A) const;

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

      double unbound_threshold(const int Zi, const int Ai) const;

      double unbound_threshold(const int initial_nucleus_pdg) const;
 
    protected:

      MassTable();
 
    private:
 
      // Helper function that converts the input JSON array into
      // (PDG code, mass) pairs and stores them in map_to_use
      void assign_masses(const marley::JSON& obj_array,
        const std::string& array_key,
        std::unordered_map<int, double>& map_to_use);
 
      // Function used internally by the mass table. Returns an atomic mass and
      // loads the boolean value exp with true if it is an experimental value
      // from the lookup table (and therefore has units of micro-amu) or false
      // if it is a theoretical value computed using the liquid drop model (and
      // has units of MeV).  This method of looking up masses is used to avoid
      // unnecessary unit conversions that can lead to losses of precision.
      double lookup_atomic_mass(int nucleus_pid, bool& exp,
        bool theory_ok = true) const;
      double lookup_atomic_mass(int Z, int A, bool& exp,
        bool theory_ok = true) const;
 
      // Lookup table for particle masses. Keys are PDG particle
      // ID numbers, values are masses in micro-amu.
      std::unordered_map<int, double> particle_masses_;
 
      // Lookup table for atomic masses. Keys are PDG particle
      // ID numbers for the nuclei, values are masses in micro-amu.
      std::unordered_map<int, double> atomic_masses_;
 
      // Factor to use when converting from micro-amu to MeV
      static constexpr double micro_amu_ = 0.000931494061; // MeV/uAMU

      static const std::string data_file_name_;
  };
 
}