MappedProperties.hh

Go to the documentation of this file.

#ifndef CASM_MappedProperties
#define CASM_MappedProperties
 
#include <ctime>
#include <string>
 
#include "casm/casm_io/FileData.hh"
#include "casm/casm_io/enum/io_traits.hh"
#include "casm/casm_io/enum/stream_io.hh"
#include "casm/global/eigen.hh"
 
namespace CASM {
 
struct MappedProperties {
  MappedProperties() : init_config("import") {}
 
  std::map<std::string, Eigen::MatrixXd> global;
 
  std::map<std::string, Eigen::MatrixXd> site;
 
  bool has_scalar(std::string const &_name) const;
 
  double const &scalar(std::string const &_name) const;
 
  double &scalar(std::string const &_name);
 
  // Note: In the future, the following may be moved out of MappedProperties
 
  std::string origin;
 
  std::string to;
 
  std::string init_config;
 
  FileData file_data;
};
 
jsonParser &to_json(const MappedProperties &prop, jsonParser &json);
 
jsonParser const &from_json(MappedProperties &prop, const jsonParser &json);
 
class ScoreMappedProperties {
 public:
  enum class Method { deformation_cost, minimum, maximum, direct_selection };
 
  static std::string method_name(Method m) {
    if (m == Method::minimum)
      return "minimum";
    else if (m == Method::maximum)
      return "maximum";
    else if (m == Method::direct_selection)
      return "direct_selection";
    else if (m == Method::deformation_cost)
      return "deformation_cost";
    return "unknown";
  }
 
  struct Option {
    Option(Method _method = Method::minimum, std::string _name = "energy")
        : Option(_method, _name, -1.) {}
 
    Option(Method _method, double _lattice_weight = 0.5)
        : Option(_method, "", _lattice_weight) {}
 
    Method method;
 
    std::string name;
 
    double lattice_weight;
 
   private:
    Option(Method _method, std::string _name, double _lattice_weight);
  };
 
  explicit ScoreMappedProperties(Option _opt = Option(Method::minimum,
                                                      "energy"));
 
  double operator()(const MappedProperties &obj) const;
 
  bool validate(const MappedProperties &obj) const;
 
  bool operator==(const ScoreMappedProperties &B) const;
 
  bool operator!=(const ScoreMappedProperties &B) const;
 
  const Option &option() const { return m_opt; }
 
 private:
  Option m_opt;
};
 
jsonParser &to_json(const ScoreMappedProperties &score, jsonParser &json);
 
jsonParser const &from_json(ScoreMappedProperties &score,
                            const jsonParser &json);
}  // namespace CASM
 
namespace CASM {
ENUM_IO_DECL(CASM::ScoreMappedProperties::Method)
ENUM_TRAITS(CASM::ScoreMappedProperties::Method)
}  // namespace CASM
 
#endif