ProjectSettings.hh

Go to the documentation of this file.

#ifndef CASM_ProjectSettings
#define CASM_ProjectSettings
 
#include <map>
#include <set>
#include <string>
#include <vector>
 
#include "casm/app/ClexDescription.hh"
#include "casm/app/DirectoryStructure.hh"
#include "casm/global/eigen.hh"
#include "casm/misc/cloneable_ptr.hh"
 
namespace CASM {
 
class Configuration;
class jsonParser;
class EnumeratorHandler;
template <typename T>
class QueryHandler;
class HamiltonianModules;
 
bool is_valid_project_name(std::string project_name);
 
void throw_if_project_name_is_not_valid(std::string project_name);
 
//    considered calculated.
class ProjectSettings {
 public:
  explicit ProjectSettings(std::string project_name);
 
  explicit ProjectSettings(std::string project_name, fs::path root);
 
  ~ProjectSettings();
 
  std::string project_name() const;
 
  // --- optional: root_dir & DirectoryStructure ---
 
  bool has_dir() const;
 
  DirectoryStructure const &dir() const;
 
  bool set_root_dir(fs::path root);
 
  fs::path root_dir() const;
 
  // --- required properties settings ---
 
  typedef std::string ObjectTypeName;
  typedef std::string CalcTypeName;
 
  typedef std::map<ObjectTypeName,
                   std::map<CalcTypeName, std::vector<std::string>>>
      required_properties_map_type;
 
  required_properties_map_type const &required_properties() const;
 
  void set_required_properties(
      required_properties_map_type const &_required_properties);
 
  std::vector<std::string> const &required_properties(
      std::string type_name, std::string calctype) const;
 
  void set_required_properties(
      std::string type_name, std::string calctype,
      std::vector<std::string> const &_required_properties);
 
  // --- cluster expansion settings: ClexDescription, by ClexDescription.name
  // ---
 
  std::map<std::string, ClexDescription> const &cluster_expansions() const;
 
  bool has_clex(std::string clex_name) const;
 
  ClexDescription const &clex(std::string clex_name) const;
 
  bool insert_clex(ClexDescription const &desc);
 
  bool erase_clex(ClexDescription const &desc);
 
  std::string default_clex_name() const;
 
  bool set_default_clex_name(std::string const &clex_name);
 
  ClexDescription const &default_clex() const;
 
  bool set_default_clex(ClexDescription const &desc);
 
  // --- compiler and linker settings ---
 
  std::pair<std::string, std::string> cxx() const;
 
  std::pair<std::string, std::string> cxxflags() const;
 
  std::pair<std::string, std::string> soflags() const;
 
  std::pair<fs::path, std::string> casm_includedir() const;
 
  std::pair<fs::path, std::string> casm_libdir() const;
 
  std::pair<fs::path, std::string> boost_includedir() const;
 
  std::pair<fs::path, std::string> boost_libdir() const;
 
  std::string compile_options() const;
 
  std::string so_options() const;
 
  std::string view_command() const;
 
  std::string view_command_video() const;
 
  double crystallography_tol() const;
 
  double lin_alg_tol() const;
 
  // ** Enumerators **
 
  EnumeratorHandler &enumerator_handler();
 
  EnumeratorHandler const &enumerator_handler() const;
 
  // ** Database **
 
  void set_default_database_name(std::string _default_database_name);
 
  std::string default_database_name() const;
 
  // ** Querie aliases **
 
  typedef std::string QueryAliasName;
  typedef std::string QueryAliasValue;
 
  typedef std::map<ObjectTypeName, std::map<QueryAliasName, QueryAliasValue>>
      query_alias_map_type;
 
  query_alias_map_type const &query_alias() const;
 
  void set_query_alias(query_alias_map_type const &_query_alias);
 
  void set_query_alias(std::string type_name, std::string alias_name,
                       std::string alias_value);
 
  template <typename DataObject>
  QueryHandler<DataObject> &query_handler();
 
  template <typename DataObject>
  QueryHandler<DataObject> const &query_handler() const;
 
  // ** Hamiltonian Modules **
 
  HamiltonianModules &hamiltonian_modules();
 
  HamiltonianModules const &hamiltonian_modules() const;
 
  // ** Clexulator names **
 
  std::string global_clexulator_name() const;
 
  bool has_m_nlist_weight_matrix() const;
 
  Eigen::Matrix3l nlist_weight_matrix() const;
 
  bool set_nlist_weight_matrix(Eigen::Matrix3l M);
 
  bool has_nlist_sublat_indices() const;
 
  std::set<int> const &nlist_sublat_indices() const;
 
  bool set_nlist_sublat_indices(std::set<int> value);
 
  bool set_cxx(std::string opt);
 
  bool set_cxxflags(std::string opt);
 
  bool set_soflags(std::string opt);
 
  bool set_casm_prefix(fs::path dir);
 
  bool set_casm_includedir(fs::path dir);
 
  bool set_casm_libdir(fs::path dir);
 
  bool set_boost_prefix(fs::path dir);
 
  bool set_boost_includedir(fs::path dir);
 
  bool set_boost_libdir(fs::path dir);
 
  bool set_view_command(std::string opt);
 
  bool set_view_command_video(std::string opt);
 
  bool set_crystallography_tol(double _tol);
 
  bool set_lin_alg_tol(double _tol);
 
 private:
  // project name
  std::string m_project_name;
 
  // directory structure (may be empty)
  notstd::cloneable_ptr<DirectoryStructure> m_dir;
 
  // EnumeratorHandler (type erased)
  notstd::cloneable_ptr<notstd::Cloneable> m_enumerator_handler;
 
  // Datatype name : QueryHandler<DataType> map (type erased)
  std::map<std::string, notstd::cloneable_ptr<notstd::Cloneable>>
      m_query_handler;
 
  // traits<ObjecType>::name -> std::pair{alias name, alias value}
  query_alias_map_type m_query_alias;
 
  // HamiltonianModules (type erased)
  mutable notstd::cloneable_ptr<notstd::Cloneable> m_hamiltonian_modules;
 
  // CASM project current settings
 
  // name : ClexDescription map
  std::map<std::string, ClexDescription> m_clex;
 
  // name of default cluster expansion
  std::string m_default_clex_name;
 
  // neighbor list parameters (may be empty)
  notstd::cloneable_ptr<Eigen::Matrix3l> m_nlist_weight_matrix;
  notstd::cloneable_ptr<std::set<int>> m_nlist_sublat_indices;
 
  // Properties required to be read from calculations
  // traits<ObjecType>::name -> calctype -> {prop1, prop2, ...}
  required_properties_map_type m_required_properties;
 
  // Runtime library compilation settings: compilation options
  std::pair<std::string, std::string> m_cxx;
  std::pair<std::string, std::string> m_cxxflags;
  std::pair<std::string, std::string> m_soflags;
  std::pair<fs::path, std::string> m_casm_includedir;
  std::pair<fs::path, std::string> m_casm_libdir;
  std::pair<fs::path, std::string> m_boost_includedir;
  std::pair<fs::path, std::string> m_boost_libdir;
 
  // Command executed by 'casm view'
  std::string m_view_command;
 
  // Command executed by 'casm view'
  std::string m_view_command_video;
 
  // Crystallography tolerance
  double m_crystallography_tol;
 
  // Linear algebra tolerance
  double m_lin_alg_tol;
 
  // Database
  std::string m_default_database_name;
};
 
bool create_all_directories(ProjectSettings const &set);
 
void print_compiler_settings_summary(ProjectSettings const &set, Log &log);
 
void print_summary(ProjectSettings const &set, Log &log);
 
jsonParser &to_json(const ProjectSettings &set, jsonParser &json);
 
template <typename T>
struct jsonConstructor;
 
template <>
struct jsonConstructor<ProjectSettings> {
  static ProjectSettings from_json(jsonParser const &json);
};
 
void write_project_settings(ProjectSettings const &set,
                            fs::path project_settings_path);
 
ProjectSettings read_project_settings(fs::path project_settings_path);
 
void commit(ProjectSettings const &set);
 
ProjectSettings open_project_settings(fs::path path_in_project);
 
}  // namespace CASM
 
#endif