Reference.hh

Go to the documentation of this file.

#ifndef CASM_Reference
#define CASM_Reference
 
#include <functional>
#include <map>
#include <memory>
#include <string>
 
#include "casm/casm_io/dataformatter/DataFormatter.hh"
#include "casm/casm_io/dataformatter/DataFormatterTools.hh"
#include "casm/global/eigen.hh"
#include "casm/misc/cloneable_ptr.hh"
 
namespace CASM {
 
class Configuration;
 
typedef ScalarAttribute<Configuration> Reference;
 
class ConstantReference : public Reference {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  explicit ConstantReference(double _value = 0.0)
      : Reference(Name, Desc), m_value(_value) {}
 
  double value() const { return m_value; }
 
  double evaluate(const Configuration &config) const override {
    return value();
  }
 
  std::unique_ptr<ConstantReference> clone() const {
    return notstd::make_unique<ConstantReference>(*this->_clone());
  }
 
 private:
  virtual ConstantReference *_clone() const override {
    return new ConstantReference(*this);
  }
 
  double m_value;
};
 
class HyperPlaneReferenceBase : public Reference {
 public:
  typedef std::map<std::string, Eigen::VectorXd> SpecializedRef;
  typedef std::function<Eigen::VectorXd(const Configuration &)> InputFunction;
 
  HyperPlaneReferenceBase(std::string _name, std::string _desc,
                          const Eigen::VectorXd &_global_ref,
                          InputFunction _input,
                          SpecializedRef _supercell_ref = SpecializedRef(),
                          SpecializedRef _config_ref = SpecializedRef())
      : Reference(_name, _desc),
        m_input(_input),
        m_config_ref(_config_ref),
        m_supercell_ref(_supercell_ref),
        m_global_ref(_global_ref) {}
 
  virtual ~HyperPlaneReferenceBase() {}
 
  std::unique_ptr<HyperPlaneReferenceBase> clone() const {
    return notstd::make_unique<HyperPlaneReferenceBase>(*this->_clone());
  }
 
  const Eigen::VectorXd &global() const { return m_global_ref; }
 
  const std::map<std::string, Eigen::VectorXd> &supercell() const {
    return m_supercell_ref;
  }
 
  const std::map<std::string, Eigen::VectorXd> &config() const {
    return m_config_ref;
  }
 
  std::function<Eigen::VectorXd(const Configuration &)> input() const {
    return m_input;
  }
 
  Eigen::VectorXd input(const Configuration &config) const {
    return m_input(config);
  }
 
  Eigen::VectorXd hyperplane(const Configuration &config) const;
 
  double evaluate(const Configuration &config) const override {
    return hyperplane(config).dot(input(config));
  }
 
 protected:
  Eigen::VectorXd &global() { return m_global_ref; }
 
  std::map<std::string, Eigen::VectorXd> &supercell() {
    return m_supercell_ref;
  }
 
  std::map<std::string, Eigen::VectorXd> &config() { return m_config_ref; }
 
 private:
  virtual HyperPlaneReferenceBase *_clone() const override {
    return new HyperPlaneReferenceBase(*this);
  }
 
  InputFunction m_input;
 
  std::map<std::string, Eigen::VectorXd> m_config_ref;
 
  std::map<std::string, Eigen::VectorXd> m_supercell_ref;
 
  Eigen::VectorXd m_global_ref;
};
 
class HyperPlaneReference : public HyperPlaneReferenceBase {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  HyperPlaneReference(const Eigen::VectorXd &_global_ref, InputFunction _input,
                      SpecializedRef _supercell_ref = SpecializedRef(),
                      SpecializedRef _config_ref = SpecializedRef())
      : HyperPlaneReferenceBase(Name, Desc, _global_ref, _input, _config_ref,
                                _supercell_ref) {}
 
  std::unique_ptr<HyperPlaneReference> clone() const {
    return notstd::make_unique<HyperPlaneReference>(*this->_clone());
  }
 
  // --- Prevent hiding of const accessors ---
 
  using HyperPlaneReferenceBase::config;
  using HyperPlaneReferenceBase::global;
  using HyperPlaneReferenceBase::supercell;
 
  // --- Make protected inherited members public ---
 
  Eigen::VectorXd &global() { return HyperPlaneReferenceBase::global(); }
 
  std::map<std::string, Eigen::VectorXd> &supercell() {
    return HyperPlaneReferenceBase::supercell();
  }
 
  std::map<std::string, Eigen::VectorXd> &config() {
    return HyperPlaneReferenceBase::config();
  }
 
 private:
  HyperPlaneReference *_clone() const override {
    return new HyperPlaneReference(*this);
  }
};
 
}  // namespace CASM
 
#endif