StructureDatabase.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
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
 
#include "marley/DecayScheme.hh"
#include "marley/JSON.hh"
 
namespace marley {
 
  class GammaStrengthFunctionModel;
  class Fragment;
  class LevelDensityModel;
  class OpticalModel;

  class StructureDatabase {
 
    public:

      StructureDatabase();

      void emplace_decay_scheme(int pdg, const std::string& filename,
        DecayScheme::FileFormat format = DecayScheme::FileFormat::talys);

      void add_decay_scheme(int pdg, std::unique_ptr<marley::DecayScheme>& ds);

      std::set<int> find_all_nuclides(const std::string& filename,
        DecayScheme::FileFormat format = DecayScheme::FileFormat::talys);

      void clear();

      void remove_decay_scheme(int pdg);

      marley::DecayScheme* get_decay_scheme(const int particle_id);

      marley::DecayScheme* get_decay_scheme(const int Z, const int A);

      marley::OpticalModel& get_optical_model(int nucleus_pid);

      marley::OpticalModel& get_optical_model(const int Z,
        const int A);

      marley::LevelDensityModel& get_level_density_model(const int nucleus_pid);

      marley::LevelDensityModel& get_level_density_model(const int Z,
        const int A);

      marley::GammaStrengthFunctionModel& get_gamma_strength_function_model(
        const int Z, const int A);

      marley::GammaStrengthFunctionModel& get_gamma_strength_function_model(
        const int nuc_pdg);

      inline const std::unordered_map<int,
        std::unique_ptr<marley::DecayScheme> >& decay_schemes() const
      {
        return decay_scheme_table_;
      }

      static inline const std::map<int, marley::Fragment>& fragments() {
        if ( !initialized_gs_spin_parity_table_ ) initialize_jpi_table();
        return fragment_table_;
      }

      static const marley::Fragment* get_fragment(const int fragment_pdg);

      static const marley::Fragment* get_fragment(const int Z, const int A);

      inline int get_fragment_l_max() const { return fragment_l_max_; }

      inline int get_gamma_l_max() const { return gamma_l_max_; }

      inline void set_fragment_l_max( int ell ) { fragment_l_max_ = ell; }

      inline void set_gamma_l_max( int ell ) { gamma_l_max_ = ell; }

      static void get_gs_spin_parity(int nuc_pdg, int& twoJ,
        marley::Parity& Pi);

      static void get_gs_spin_parity(const int Z, const int A, int& twoJ,
        marley::Parity& Pi);

      void load_optical_model_params( const marley::JSON* om_config = nullptr );
 
    private:

      static std::unordered_map<int, std::unique_ptr<marley::DecayScheme> >
        decay_scheme_table_;

      std::unordered_map<int, std::unique_ptr<marley::OpticalModel> >
        optical_model_table_;

      std::unordered_map<int, std::unique_ptr<marley::LevelDensityModel> >
        level_density_table_;

      std::unordered_map<int, std::unique_ptr<
        marley::GammaStrengthFunctionModel> > gamma_strength_function_table_;

      static std::map<int, marley::Fragment> fragment_table_;

      static constexpr int DEFAULT_FRAGMENT_L_MAX = 5;

      static constexpr int DEFAULT_GAMMA_L_MAX = DEFAULT_FRAGMENT_L_MAX;

      int fragment_l_max_ = DEFAULT_FRAGMENT_L_MAX;

      int gamma_l_max_ = DEFAULT_GAMMA_L_MAX;

      static bool initialized_gs_spin_parity_table_;

      const std::string structure_index_filename_ = "nuclide_index.txt";

      bool loaded_structure_index_ = false;

      std::map< int, std::string > decay_scheme_filenames_;

      static const std::string jpi_data_file_name_;

      static std::map< int, std::pair<int, marley::Parity> > jpi_table_;

      static void initialize_jpi_table();

      void load_structure_index();

      std::map< std::string, marley::JSON > om_config_map_;
  };
 
}