Reference.hh

Go to the documentation of this file.

#ifndef CASM_Reference
#define CASM_Reference

#include <map>
#include <functional>
#include <memory>
#include <string>

#include "casm/external/Eigen/Dense"
#include "casm/misc/cloneable_ptr.hh"
#include "casm/casm_io/DataFormatter.hh"
#include "casm/casm_io/DataFormatterTools.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::global;
    using HyperPlaneReferenceBase::supercell;
    using HyperPlaneReferenceBase::config;


    // --- 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);
    }

  };

}

#endif