ClexParamPack.hh

Go to the documentation of this file.

#ifndef CLEXPARAMPACK_HH
#define CLEXPARAMPACK_HH
#include <cstddef>
#include <map>
#include <vector>
 
#include "casm/misc/cloneable_ptr.hh"
 
namespace CASM {
// ClexParamPack is an abstract data structure for storing and retrieving 2D and
// 1D Arrays of real values The data stored in a ClexParamPack is used to
// perform calculations within a Clexulator. Values stores within a
// ClexParamPack represent independent variables, intermediate computations, and
// final evaluated functions. ClexParamPack allows the underlying Scalar value
// type to be obscured, in order to implement special functionality, such as
// automatic differentiation Clexulators may implement their own ClexParamPack,
// or utilitize a pre-defined ClexParamPack specialization
class ClexParamPack;
 
// ClexParamKey is used externally to Clexulator and ClexParamPack to access
// stored and derived values from ClexParamPack. ClexParamKey holds a pointer to
// ClexParamPack_impl::BaseKey, which implements read and write functionality.
// Keys are allocated and registered by ClexParamPack.
class ClexParamKey;
 
// Struct for templated read/write access of parameter values
template <typename Scalar>
struct ValAccess {};
 
namespace ClexParamPack_impl {
class BaseKey {
 public:
  BaseKey(std::string const &_name, bool _standalone,
          std::vector<Index> const &_offset = {},
          std::vector<Index> const &_stride = {})
      : m_offset(_offset),
        m_stride(_stride),
        m_identifiers(_offset.size(), 0),
        m_name(_name),
        m_standalone(_standalone) {}
 
  virtual ~BaseKey() {}
 
  std::string const &name() const { return m_name; }
 
  template <typename... Args>
  void set_identifiers(Args const &... args) {
    _set_identifiers(0, args...);
  }
 
  std::unique_ptr<BaseKey> clone() const {
    return std::unique_ptr<BaseKey>(_clone());
  }
 
  bool standalone() const { return m_standalone; }
 
 protected:
  Index _l(Index i) const { return m_identifiers[i]; }
 
  template <typename T, typename... Args>
  void _set_identifiers(Index i, T const &_val, Args const &... args) {
    _set_identifiers(i, _val);
    _set_identifiers(++i, args...);
  }
 
  void _set_identifiers(Index i, Index _ind) {
    m_identifiers[i] = m_offset[i] + _ind;
  }
 
  void _set_identifiers(Index i, std::pair<Index, Index> _inds) {
    _set_identifiers(i, m_stride[i] * _inds.first + _inds.second);
  }
 
  virtual BaseKey *_clone() const = 0;
 
  std::vector<Index> m_offset;
  std::vector<Index> m_stride;
  std::vector<Index> m_identifiers;
 
 private:
  std::string m_name;
  bool m_standalone;
};
}  // namespace ClexParamPack_impl
 
class ParamPackMixIn {
 public:
  static ParamPackMixIn basic_mix_in() {
    return ParamPackMixIn("BasicClexParamPack",
                          {{"ParamPack::DEFAULT", "double"}});
  }
 
  static ParamPackMixIn diff_mix_in() {
    return ParamPackMixIn("DiffClexParamPack",
                          {{"ParamPack::DEFAULT", "double"},
                           {"ParamPack::DIFF", "ParamPack::DiffScalar"}});
  }
 
  ParamPackMixIn(std::string const &_name,
                 std::map<std::string, std::string> const &_specializations)
      : m_name(_name), m_scalar_specializations(_specializations) {}
 
  virtual ~ParamPackMixIn() {}
 
  std::string const &name() const { return m_name; }
 
  std::map<std::string, std::string> const &scalar_specializations() const {
    return m_scalar_specializations;
  }
 
  virtual std::string cpp_includes_string() const {
    return "#include \"casm/clex/" + name() + ".hh\"\n";
  }
 
  virtual std::string cpp_definitions_string(std::string const &_indent) const {
    return "";
  }
 
  std::unique_ptr<ParamPackMixIn> clone() const {
    return std::unique_ptr<ParamPackMixIn>(_clone());
  }
 
 private:
  virtual ParamPackMixIn *_clone() const { return new ParamPackMixIn(*this); }
 
  std::string m_name;
  std::map<std::string, std::string> m_scalar_specializations;
};
 
class ClexParamKey {
 public:
  ClexParamKey() {}
 
  ClexParamKey(ClexParamPack_impl::BaseKey const &_key)
      : m_key_ptr(_key.clone()) {}
 
  std::string const &name() const { return m_key_ptr->name(); }
 
  ClexParamPack_impl::BaseKey const *ptr() const {
    return m_key_ptr.unique().get();
  }
 
  template <typename... Args>
  ClexParamKey &operator()(Args const &... args) {
    m_key_ptr->set_identifiers(args...);
    return *this;
  }
 
 private:
  notstd::cloneable_ptr<ClexParamPack_impl::BaseKey> m_key_ptr;
};
 
class ClexParamPack {
 public:
  typedef unsigned int size_type;
 
  virtual ~ClexParamPack() {}
 
  std::map<std::string, ClexParamKey> const &keys() const { return m_keys; }
 
  ClexParamKey const &key(std::string const &_name) const {
    auto it = keys().find(_name);
    if (it == keys().end()) {
      std::stringstream ss;
      for (it = keys().begin(); it != keys().end(); ++it)
        ss << "  " << it->first << "\n";
      throw std::runtime_error(
          "In ClexParamPack::key(), ClexParamPack does not contain parameters "
          "corresponding to name " +
          _name + ". Options are:\n" + ss.str());
    }
    return it->second;
  }
 
  virtual size_type size(ClexParamKey const &_key) const = 0;
 
  virtual size_type dim(ClexParamKey const &_key) const = 0;
 
  virtual std::string eval_mode(ClexParamKey const &_key) const = 0;
 
  virtual Eigen::MatrixXd const &read(ClexParamKey const &_key) const = 0;
 
  virtual double const &read(ClexParamKey const &_key, size_type _i) const = 0;
 
  virtual double const &read(ClexParamKey const &_key, size_type _i,
                             size_type _j) const = 0;
 
  virtual void set_eval_mode(ClexParamKey const &_key,
                             std::string const &_mode) = 0;
 
  virtual void write(ClexParamKey const &_key,
                     Eigen::Ref<const Eigen::MatrixXd> const &_val) = 0;
 
  virtual void write(ClexParamKey const &_key, size_type _i, double val) = 0;
 
  virtual void write(ClexParamKey const &_key, size_type _i, size_type _j,
                     double val) = 0;
 
  void pre_eval() {}
 
  void post_eval() {}
 
 protected:
  std::map<std::string, ClexParamKey> m_keys;
 
 private:
  // possible implementation:
  // std::vector<Eigen::MatrixXd> m_data;
};
 
}  // namespace CASM
 
#endif