Clexulator.hh

Go to the documentation of this file.

#ifndef CLEXULATOR_HH
#define CLEXULATOR_HH
#include <boost/filesystem/path.hpp>
#include <cstddef>
 
#include "casm/clex/ConfigDoF.hh"
#include "casm/clex/NeighborList.hh"
#include "casm/crystallography/UnitCellCoord.hh"
 
namespace CASM {
class ClexParamPack;
class ClexParamKey;
 
namespace Clexulator_impl {
 
class Base {
 public:
  typedef unsigned int size_type;
 
  Base(size_type _nlist_size, size_type _corr_size, size_type _n_point_corr);
 
  virtual ~Base();
 
  size_type nlist_size() const { return m_nlist_size; }
 
  size_type corr_size() const { return m_corr_size; }
 
  size_type n_point_corr() const { return m_n_point_corr; }
 
  std::unique_ptr<Base> clone() const;
 
  virtual ClexParamPack const &param_pack() const = 0;
 
  virtual ClexParamPack &param_pack() = 0;
 
  ClexParamKey const &param_key(std::string const &_param_name) const;
 
  void set_evaluation(
      ClexParamKey const &_param_key,
      std::vector<std::function<double(ConfigDoF const &)> > const &_basis_set);
 
  void 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 set_evaluation(ClexParamKey const &_param_key,
                      std::string const &_eval_type);
 
  std::string check_evaluation(ClexParamKey const &_param_key) const;
 
  const std::set<UnitCell> &neighborhood() const { return m_neighborhood; }
 
  const std::set<UnitCell> &neighborhood(size_type linear_orbit_index) const {
    return m_orbit_neighborhood[linear_orbit_index];
  }
 
  const PrimNeighborList::Matrix3Type &weight_matrix() const {
    return m_weight_matrix;
  }
 
  void calc_global_corr_contribution(ConfigDoF const &_input_configdof,
                                     long int const *_nlist_begin,
                                     long int const *_nlist_end,
                                     double *_corr_begin,
                                     double *_corr_end) const {
    _set_configdof(_input_configdof);
    _set_nlist(_nlist_begin, _nlist_end);
    _calc_global_corr_contribution(_corr_begin);
  }
 
  void calc_global_corr_contribution(ConfigDoF const &_input_configdof,
                                     long int const *_nlist_begin,
                                     long int const *_nlist_end) const {
    _set_configdof(_input_configdof);
    _set_nlist(_nlist_begin, _nlist_end);
    _calc_global_corr_contribution();
  }
 
  void calc_restricted_global_corr_contribution(
      ConfigDoF const &_input_configdof, long int const *_nlist_begin,
      long int const *_nlist_end, double *_corr_begin, double *_corr_end,
      size_type const *_corr_ind_begin, size_type const *_corr_ind_end) const {
    _set_configdof(_input_configdof);
    _set_nlist(_nlist_begin, _nlist_end);
    _calc_restricted_global_corr_contribution(_corr_begin, _corr_ind_begin,
                                              _corr_ind_end);
  }
 
  void calc_point_corr(ConfigDoF const &_input_configdof,
                       long int const *_nlist_begin, long int const *_nlist_end,
                       int neighbor_ind, double *_corr_begin,
                       double *_corr_end) const {
    _set_configdof(_input_configdof);
    _set_nlist(_nlist_begin, _nlist_end);
    _calc_point_corr(neighbor_ind, _corr_begin);
  }
 
  void calc_restricted_point_corr(ConfigDoF const &_input_configdof,
                                  long int const *_nlist_begin,
                                  long int const *_nlist_end, int neighbor_ind,
                                  double *_corr_begin, double *_corr_end,
                                  size_type const *_corr_ind_begin,
                                  size_type const *_corr_ind_end) const {
    _set_configdof(_input_configdof);
    _set_nlist(_nlist_begin, _nlist_end);
    _calc_restricted_point_corr(neighbor_ind, _corr_begin, _corr_ind_begin,
                                _corr_ind_end);
  }
 
  void calc_delta_point_corr(ConfigDoF const &_input_configdof,
                             long int const *_nlist_begin,
                             long int const *_nlist_end, int neighbor_ind,
                             int occ_i, int occ_f, double *_corr_begin,
                             double *_corr_end) const {
    _set_configdof(_input_configdof);
    _set_nlist(_nlist_begin, _nlist_end);
    _calc_delta_point_corr(neighbor_ind, occ_i, occ_f, _corr_begin);
  }
  void calc_restricted_delta_point_corr(ConfigDoF const &_input_configdof,
                                        long int const *_nlist_begin,
                                        long int const *_nlist_end,
                                        int neighbor_ind, int occ_i, int occ_f,
                                        double *_corr_begin, double *_corr_end,
                                        size_type const *_corr_ind_begin,
                                        size_type const *_corr_ind_end) const {
    _set_configdof(_input_configdof);
    _set_nlist(_nlist_begin, _nlist_end);
    _calc_restricted_delta_point_corr(neighbor_ind, occ_i, occ_f, _corr_begin,
                                      _corr_ind_begin, _corr_ind_end);
  }
 
 private:
  virtual Base *_clone() const = 0;
 
  void _set_configdof(ConfigDoF const &_input_configdof) const {
    if (m_config_ptr != &_input_configdof) {
      m_config_ptr = &_input_configdof;
      for (auto const &dof : m_local_dof_registry) {
        m_local_dof_ptrs[dof.second] = &(_configdof().local_dof(dof.first));
      }
 
      for (auto const &dof : m_global_dof_registry) {
        m_global_dof_ptrs[dof.second] = &(_configdof().global_dof(dof.first));
      }
    }
  }
 
  size_type m_nlist_size;
 
  size_type m_corr_size;
 
  size_type m_n_point_corr;
 
  std::map<std::string, Index> m_local_dof_registry;
 
  std::map<std::string, Index> m_global_dof_registry;
 
 protected:
  virtual void _calc_global_corr_contribution() const = 0;
 
  virtual void _calc_global_corr_contribution(double *_corr_begin) const = 0;
 
  virtual void _calc_restricted_global_corr_contribution(
      size_type const *_corr_ind_begin,
      size_type const *_corr_ind_end) const = 0;
 
  virtual void _calc_restricted_global_corr_contribution(
      double *_corr_begin, size_type const *_corr_ind_begin,
      size_type const *_corr_ind_end) const = 0;
 
  virtual void _calc_point_corr(int neighbor_ind) const = 0;
 
  virtual void _calc_point_corr(int neighbor_ind,
                                double *_corr_begin) const = 0;
 
  virtual void _calc_restricted_point_corr(
      int neighbor_ind, size_type const *_corr_ind_begin,
      size_type const *_corr_ind_end) const = 0;
 
  virtual void _calc_restricted_point_corr(
      int neighbor_ind, double *_corr_begin, size_type const *_corr_ind_begin,
      size_type const *_corr_ind_end) const = 0;
 
  virtual void _calc_delta_point_corr(int neighbor_ind, int occ_i,
                                      int occ_f) const = 0;
 
  virtual void _calc_delta_point_corr(int neighbor_ind, int occ_i, int occ_f,
                                      double *_corr_begin) const = 0;
 
  virtual void _calc_restricted_delta_point_corr(
      int neighbor_ind, int occ_i, int occ_f, size_type const *_corr_ind_begin,
      size_type const *_corr_ind_end) const = 0;
 
  virtual void _calc_restricted_delta_point_corr(
      int neighbor_ind, int occ_i, int occ_f, double *_corr_begin,
      size_type const *_corr_ind_begin,
      size_type const *_corr_ind_end) const = 0;
 
  void _register_local_dof(std::string const &_type_name, Index _ind) {
    Index new_size = max(Index(_ind), Index(m_local_dof_ptrs.size())) + 1;
    m_local_dof_ptrs.resize(new_size, nullptr);
    m_global_dof_ptrs.resize(new_size, nullptr);
    m_local_dof_registry[_type_name] = _ind;
  }
 
  void _register_global_dof(std::string const &_type_name, Index _ind) {
    Index new_size = max(Index(_ind), Index(m_local_dof_ptrs.size())) + 1;
    m_local_dof_ptrs.resize(new_size, nullptr);
    m_global_dof_ptrs.resize(new_size, nullptr);
    m_global_dof_registry[_type_name] = _ind;
  }
 
  ConfigDoF const &_configdof() const { return *m_config_ptr; }
 
  Index const &_l(Index nlist_ind) const { return *(m_nlist_ptr + nlist_ind); }
 
  void _set_nlist(const long int *_nlist_begin,
                  const long int *_nlist_end) const {
    m_nlist_ptr = _nlist_begin;
    // std::cout << "setting _nlist: ";
    // for(;_nlist_begin!=_nlist_end; ++_nlist_begin)
    // std::cout << *_nlist_begin << "  ";
    // std::cout << std::endl;
    return;
  }
 
  std::set<UnitCell> m_neighborhood;
 
  std::vector<std::set<UnitCell> > m_orbit_neighborhood;
 
  PrimNeighborList::Matrix3Type m_weight_matrix;
 
  mutable std::vector<LocalContinuousConfigDoFValues const *> m_local_dof_ptrs;
 
  mutable std::vector<GlobalContinuousConfigDoFValues const *>
      m_global_dof_ptrs;
 
 private:
  mutable ConfigDoF const *m_config_ptr;
 
  mutable long int const *m_nlist_ptr;
};
}  // namespace Clexulator_impl
 
class RuntimeLibrary;
 
class Clexulator {
 public:
  typedef Clexulator_impl::Base::size_type size_type;
 
  Clexulator() {}
 
  Clexulator(std::string name, fs::path dirpath, PrimNeighborList &nlist,
             std::string compile_options, std::string so_options);
 
  Clexulator(const Clexulator &B);
 
  Clexulator(Clexulator &&B);
 
  ~Clexulator();
 
  Clexulator &operator=(Clexulator B);
 
  friend void swap(Clexulator &first, Clexulator &second) {
    using std::swap;
 
    swap(first.m_name, second.m_name);
    swap(first.m_clex, second.m_clex);
    swap(first.m_lib, second.m_lib);
  }
 
  bool initialized() const { return m_lib.get() != nullptr; }
 
  std::string name() const { return m_name; }
 
  size_type nlist_size() const { return m_clex->nlist_size(); }
 
  size_type corr_size() const { return m_clex->corr_size(); }
 
  size_type n_point_corr() const { return m_clex->n_point_corr(); }
 
  ClexParamPack const &param_pack() const { return m_clex->param_pack(); }
 
  ClexParamPack &param_pack() { return m_clex->param_pack(); }
 
  ClexParamKey const &param_key(std::string const &_param_name) const;
 
  void set_evaluation(
      ClexParamKey const _param_key,
      std::vector<std::function<double(ConfigDoF const &)> > const &_basis_set);
 
  void set_evaluation(
      ClexParamKey const _param_key,
      std::vector<std::function<double(std::vector<double> const &)> > const
          &_basis_set);
 
  void set_evaluation(ClexParamKey const _param_key, std::string _eval_type);
 
  std::string check_evaluation(ClexParamKey const _param_key) const;
 
  const std::set<UnitCell> &neighborhood() const {
    return m_clex->neighborhood();
  }
 
  const std::set<UnitCell> &neighborhood(size_type linear_orbit_index) const {
    return m_clex->neighborhood(linear_orbit_index);
  }
 
  const PrimNeighborList::Matrix3Type &weight_matrix() const {
    return m_clex->weight_matrix();
  }
 
  void calc_global_corr_contribution(ConfigDoF const &_input_configdof,
                                     long int const *_nlist_begin,
                                     long int const *_nlist_end,
                                     double *_corr_begin,
                                     double *_corr_end) const {
    m_clex->calc_global_corr_contribution(_input_configdof, _nlist_begin,
                                          _nlist_end, _corr_begin, _corr_end);
  }
 
  void calc_global_corr_contribution(ConfigDoF const &_input_configdof,
                                     long int const *_nlist_begin,
                                     long int const *_nlist_end) const {
    m_clex->calc_global_corr_contribution(_input_configdof, _nlist_begin,
                                          _nlist_end);
  }
 
  void calc_restricted_global_corr_contribution(
      ConfigDoF const &_input_configdof, long int const *_nlist_begin,
      long int const *_nlist_end, double *_corr_begin, double *_corr_end,
      size_type const *_corr_ind_begin, size_type const *_corr_ind_end) const {
    m_clex->calc_restricted_global_corr_contribution(
        _input_configdof, _nlist_begin, _nlist_end, _corr_begin, _corr_end,
        _corr_ind_begin, _corr_ind_end);
  }
 
  void calc_point_corr(ConfigDoF const &_input_configdof,
                       long int const *_nlist_begin, long int const *_nlist_end,
                       int neighbor_ind, double *_corr_begin,
                       double *_corr_end) const {
    m_clex->calc_point_corr(_input_configdof, _nlist_begin, _nlist_end,
                            neighbor_ind, _corr_begin, _corr_end);
  }
 
  void calc_restricted_point_corr(ConfigDoF const &_input_configdof,
                                  long int const *_nlist_begin,
                                  long int const *_nlist_end, int neighbor_ind,
                                  double *_corr_begin, double *_corr_end,
                                  size_type const *_corr_ind_begin,
                                  size_type const *_corr_ind_end) const {
    m_clex->calc_restricted_point_corr(
        _input_configdof, _nlist_begin, _nlist_end, neighbor_ind, _corr_begin,
        _corr_end, _corr_ind_begin, _corr_ind_end);
  }
 
  void calc_delta_point_corr(ConfigDoF const &_input_configdof,
                             long int const *_nlist_begin,
                             long int const *_nlist_end, int neighbor_ind,
                             int occ_i, int occ_f, double *_corr_begin,
                             double *_corr_end) const {
    m_clex->calc_delta_point_corr(_input_configdof, _nlist_begin, _nlist_end,
                                  neighbor_ind, occ_i, occ_f, _corr_begin,
                                  _corr_end);
  }
 
  void calc_restricted_delta_point_corr(ConfigDoF const &_input_configdof,
                                        long int const *_nlist_begin,
                                        long int const *_nlist_end,
                                        int neighbor_ind, int occ_i, int occ_f,
                                        double *_corr_begin, double *_corr_end,
                                        size_type const *_corr_ind_begin,
                                        size_type const *_corr_ind_end) const {
    m_clex->calc_restricted_delta_point_corr(
        _input_configdof, _nlist_begin, _nlist_end, neighbor_ind, occ_i, occ_f,
        _corr_begin, _corr_end, _corr_ind_begin, _corr_ind_end);
  }
 
 private:
  std::string m_name;
  std::unique_ptr<Clexulator_impl::Base> m_clex;
  std::shared_ptr<RuntimeLibrary> m_lib;
};
 
}  // namespace CASM
 
#endif