Clexulator.cc

Go to the documentation of this file.

#include "casm/clex/Clexulator.hh"
 
#include "casm/app/LogRuntimeLibrary.hh"
#include "casm/casm_io/Log.hh"
#include "casm/clex/ClexParamPack.hh"
#include "casm/system/RuntimeLibrary.hh"
 
namespace CASM {
 
Clexulator::Clexulator(std::string name, fs::path dirpath,
                       PrimNeighborList &nlist, std::string compile_options,
                       std::string so_options)
    : m_name(name) {
  // Construct the RuntimeLibrary that will store the loaded clexulator library
  try {
    m_lib = log_make_shared_runtime_lib(
        (dirpath / name).string(), compile_options, so_options,
        "compile time depends on how many basis functions are included");
  } catch (std::exception &e) {
    log() << "Clexulator construction failed: could not construct runtime "
             "library."
          << std::endl;
    throw;
  }
 
  // Get the Clexulator factory function
  std::function<Clexulator_impl::Base *(void)> factory;
  factory = m_lib->get_function<Clexulator_impl::Base *(void)>("make_" + name);
 
  // Use the factory to construct the clexulator and store it in m_clex
  m_clex.reset(factory());
 
  // Check nlist has the right weight_matrix
  if (nlist.weight_matrix() != m_clex->weight_matrix()) {
    std::cerr << "Error in Clexulator constructor: weight matrix of neighbor "
                 "list does not match the weight matrix used to print the "
                 "clexulator."
              << std::endl;
    std::cerr << "nlist weight matrix: \n"
              << nlist.weight_matrix() << std::endl;
    std::cerr << "clexulator weight matrix: \n"
              << m_clex->weight_matrix() << std::endl;
    throw std::runtime_error(
        "Error in Clexulator constructor: weight matrix of neighbor list does "
        "not match the weight matrix used to print the clexulator. Try 'casm "
        "bset -uf'.");
  }
 
  // Expand the given neighbor list as necessary
  nlist.expand(neighborhood().begin(), neighborhood().end());
}
 
Clexulator::Clexulator(const Clexulator &B) : m_name(B.name()), m_lib(B.m_lib) {
  if (B.m_clex != nullptr) {
    m_clex = B.m_clex->clone();
  }
}
 
Clexulator::Clexulator(Clexulator &&B) { swap(*this, B); }
 
Clexulator::~Clexulator() {
  // ensure Clexulator is deleted before library
  m_clex.reset();
}
 
Clexulator &Clexulator::operator=(Clexulator B) {
  swap(*this, B);
  return *this;
}
 
ClexParamKey const &Clexulator::param_key(
    std::string const &_param_name) const {
  return m_clex->param_key(_param_name);
}
 
void Clexulator::set_evaluation(
    ClexParamKey const _param_key,
    std::vector<std::function<double(ConfigDoF const &)> > const &_basis_set) {
  m_clex->set_evaluation(_param_key, _basis_set);
}
 
void Clexulator::set_evaluation(
    ClexParamKey const _param_key,
    std::vector<std::function<double(std::vector<double> const &)> > const
        &_basis_set) {
  m_clex->set_evaluation(_param_key, _basis_set);
}
 
void Clexulator::set_evaluation(ClexParamKey const _param_key,
                                std::string _eval_type) {
  m_clex->set_evaluation(_param_key, _eval_type);
}
 
std::string Clexulator::check_evaluation(ClexParamKey const _param_key) const {
  return m_clex->check_evaluation(_param_key);
}
 
namespace Clexulator_impl {
 
Base::Base(size_type _nlist_size, size_type _corr_size, size_type _n_point_corr)
    : m_nlist_size(_nlist_size),
      m_corr_size(_corr_size),
      m_n_point_corr(_n_point_corr),
      m_config_ptr(nullptr) {}
 
Base::~Base() {}
 
std::unique_ptr<Base> Base::clone() const {
  return std::unique_ptr<Base>(_clone());
}
 
void Base::set_evaluation(
    ClexParamKey const &_param_key,
    std::vector<std::function<double(ConfigDoF const &)> > const &_basis_set) {}
 
void Base::set_evaluation(
    ClexParamKey const &_param_key,
    std::vector<std::function<double(std::vector<double> const &)> > const
        &_basis_set) {}
 
// which can be at least either "READ" (i.e., read from ClexParamPack) or
// "DEFAULT" (i.e., the Clexulator's default implementation)
void Base::set_evaluation(ClexParamKey const &_param_key,
                          std::string const &_eval_type) {}
 
std::string Base::check_evaluation(ClexParamKey const &_param_key) const {
  return "";
}
 
ClexParamKey const &Base::param_key(std::string const &_param_name) const {
  return param_pack().key(_param_name);
}
 
}  // namespace Clexulator_impl
 
}  // namespace CASM