ProjectSettings.hh

Go to the documentation of this file.

#ifndef CASM_ProjectSettings
#define CASM_ProjectSettings

#include <string>
#include <vector>

#include "casm/casm_io/SafeOfstream.hh"
#include "casm/system/RuntimeLibrary.hh"
#include "casm/app/DirectoryStructure.hh"
#include "casm/app/EnumeratorHandler.hh"
#include "casm/app/QueryHandler.hh"

#include "casm/casm_io/DataFormatter.hh"
#include "casm/casm_io/Log.hh"
#include "casm/casm_io/jsonParser.hh"
#include "casm/casm_io/json_io/container.hh"

namespace CASM {

  class Configuration;

  template <bool IsConst>
  class ConfigSelection;
  typedef ConfigSelection<true> ConstConfigSelection;

  namespace ConfigIO {
    class Selected;
  }

  struct ClexDescription {
    ClexDescription() {}

    ClexDescription(std::string _name,
                    std::string _property,
                    std::string _calctype,
                    std::string _ref,
                    std::string _bset,
                    std::string _eci) :
      name(_name), property(_property), calctype(_calctype), ref(_ref), bset(_bset), eci(_eci) {}

    void print(std::ostream &sout, bool is_default, int indent = 0) const;

    std::string name;
    std::string property;
    std::string calctype;
    std::string ref;
    std::string bset;
    std::string eci;
  };

  bool operator<(const ClexDescription &A, const ClexDescription &B);

  jsonParser &to_json(const ClexDescription &desc, jsonParser &json);

  void from_json(ClexDescription &desc, const jsonParser &json);

  bool clex_exists(const DirectoryStructure &dir, const ClexDescription &desc);


  class ProjectSettings : public Logging {

  public:

    ProjectSettings() {}

    explicit ProjectSettings(fs::path root, std::string name, const Logging &logging = Logging());

    explicit ProjectSettings(fs::path root, const Logging &logging = Logging());


    std::string name() const;

    const DirectoryStructure &dir() const {
      return m_dir;
    }

    const std::vector<std::string> &properties() const;


    const std::map<std::string, ClexDescription> &cluster_expansions() const;

    bool has_clex(std::string name) const;

    const ClexDescription &clex(std::string name) const;

    const ClexDescription &default_clex() const;

    bool new_clex(const ClexDescription &desc);

    bool erase_clex(const ClexDescription &desc);

    bool set_default_clex(const std::string &clex_name);

    bool set_default_clex(const ClexDescription &desc);


    Eigen::Matrix3l nlist_weight_matrix() const;

    const std::set<int> &nlist_sublat_indices() const;

    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;

    double crystallography_tol() const;

    double lin_alg_tol() const;


    // ** Enumerators **

    EnumeratorHandler &enumerator_handler() {
      if(!m_enumerator_handler) {
        m_enumerator_handler = notstd::make_cloneable<EnumeratorHandler>(*this);
      }
      return *m_enumerator_handler;
    }

    const EnumeratorHandler &enumerator_handler() const {
      return const_cast<ProjectSettings &>(*this).enumerator_handler();
    }

    // ** Queries **

    template<typename DataObject>
    QueryHandler<DataObject> &query_handler() {
      auto res = m_query_handler.find(QueryTraits<DataObject>::name);
      if(res == m_query_handler.end()) {
        res = m_query_handler.insert(
                std::make_pair(
                  QueryTraits<DataObject>::name,
                  notstd::cloneable_ptr<notstd::Cloneable>(new QueryHandler<DataObject>(*this))
                )
              ).first;
      }
      return static_cast<QueryHandler<DataObject>& >(*res->second);
    }

    template<typename DataObject>
    const QueryHandler<DataObject> &query_handler() const {
      return const_cast<ProjectSettings &>(*this).query_handler<DataObject>();
    }


    // ** Clexulator names **

    std::string clexulator() const;


    // ** Add directories for additional project data **

    bool new_casm_dir() const;

    bool new_symmetry_dir() const;

    bool new_bset_dir(std::string bset) const;

    bool new_clex_dir(std::string clex) const;


    bool new_calc_settings_dir(std::string calctype) const;

    bool new_supercell_calc_settings_dir(std::string scelname, std::string calctype) const;

    bool new_configuration_calc_settings_dir(std::string configname, std::string calctype) const;


    bool new_ref_dir(std::string calctype, std::string ref) const;


    bool new_eci_dir(std::string clex, std::string calctype, std::string ref, std::string bset, std::string eci) const;


    // ** Change current settings **

    std::vector<std::string> &properties();


    bool set_nlist_weight_matrix(Eigen::Matrix3l M);

    template<typename SublatIterator>
    bool set_nlist_sublat_indices(SublatIterator begin, SublatIterator end);


    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_crystallography_tol(double _tol);

    bool set_lin_alg_tol(double _tol);


    void commit() const;

    jsonParser &to_json(jsonParser &json) const;

    void print_compiler_settings_summary(Log &log) const;

    void print_summary(Log &log) const;

    bool set_compile_options(std::string opt);

    bool set_so_options(std::string opt);



  private:

    void _reset_clexulators();

    void _load_default_options();


    DirectoryStructure m_dir;

    std::string m_name;

    notstd::cloneable_ptr<EnumeratorHandler> m_enumerator_handler;
    std::map<std::string, notstd::cloneable_ptr<notstd::Cloneable> > m_query_handler;

    // CASM project current settings

    // name : ClexDescription map
    std::map<std::string, ClexDescription> m_clex;

    // name of default cluster expansion
    std::string m_default_clex;

    // neighbor list settings
    Eigen::Matrix3l m_nlist_weight_matrix;
    std::set<int> m_nlist_sublat_indices;

    // Properties to read from calculations
    std::vector<std::string> m_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;

    // deprecated reading exactly from settings file
    std::string m_depr_compile_options;
    // deprecated reading exactly from settings file
    std::string m_depr_so_options;

    // Command executed by 'casm view'
    std::string m_view_command;

    // Crystallography tolerance
    double m_crystallography_tol;

    // Linear algebra tolerance
    double m_lin_alg_tol;

  };

  jsonParser &to_json(const ProjectSettings &set, jsonParser &json);


  template<typename SublatIterator>
  bool ProjectSettings::set_nlist_sublat_indices(SublatIterator begin, SublatIterator end) {
    _reset_clexulators();
    m_nlist_sublat_indices = std::set<int>(begin, end);
    return true;
  }

}

#endif