MonteSettings.hh

Go to the documentation of this file.

#ifndef CASM_MonteSettings_HH
#define CASM_MonteSettings_HH
 
#include <string>
 
#include "casm/casm_io/Log.hh"
#include "casm/casm_io/json/jsonParser.hh"
#include "casm/clex/ECIContainer.hh"
#include "casm/clex/PrimClex.hh"
#include "casm/global/definitions.hh"
#include "casm/misc/cloneable_ptr.hh"
#include "casm/monte_carlo/MonteDefinitions.hh"
#include "casm/monte_carlo/MonteSampler.hh"
 
namespace CASM {
namespace Monte {
 
class MonteCarlo;
class MonteCarloEnumMetric;
class MonteCarloEnumCheck;
 
/*
 * MonteSettings is nothing more than a jsonParser that you can expect
 * to contain a set of values. It's a class meant to hold all the
 * members of the base MonteCarlo class so you can write out all the
 * relevant data and then also use it to reconstruct MonteCarlo.
 *
 * The point of the class is mostly to ensure that when you reconstruct
 * your MonteCarlo you're not giving it some willy nilly jsonParser
 * you came up with. It MUST be something that MonteCarlo itself
 * spit out.
 *
 * Inheritance is private, so you can't use [] as an access operator.
 * Instead use the prescribed accessing routines. This will keep the
 * structure of the settings file consistent and changes will
 * only have to occur through this class.
 *
 * To avoid having millions of access routines, there are jsonParser
 * pointers internally that point to a "current state" of subtrees
 * that may involve the same access routines. For example, instead
 * of having different access routines for initial conditions and
 * final conditions, you just set the current conditions mode, and
 * then the same access routines can be used. From the outside, it
 * looks like you're just requesting a subset of your MonteSettings routine.
 */
 
class MonteSettings : protected CASM::jsonParser {
 public:
  using jsonParser::print;
  using jsonParser::write;
  using jsonParser::operator==;
  using jsonParser::operator!=;
 
  typedef Index size_type;
 
  MonteSettings() {}
 
  MonteSettings(const PrimClex &_primclex, const fs::path &read_path);
 
  // --- Project root directory ---------------------------
 
  fs::path root() const;
 
  const PrimClex &primclex() const;
 
  // --- Type ---------------------------
 
  Monte::ENSEMBLE ensemble() const;
 
  Monte::METHOD method() const;
 
  bool debug() const;
 
  void set_debug(bool _debug);
 
  // --- Initialization ---------------------
 
  bool is_motif_configname() const;
 
  std::string motif_configname() const;
 
  bool is_motif_configdof() const;
 
  ConfigDoF motif_configdof(Index supercell_volume) const;
 
  fs::path motif_configdof_path() const;
 
  Eigen::Matrix3l simulation_cell_matrix() const;
 
  // --- Driver ---------------------
 
  virtual const Monte::DRIVE_MODE drive_mode() const;
 
  bool dependent_runs() const;
 
  // --- Sampling -------------------
 
  // double tolerance() const;
 
  double confidence() const;
 
  bool write_trajectory() const;
 
  bool write_POSCAR_snapshots() const;
 
  bool write_observations() const;
 
  bool write_csv() const;
 
  bool write_json() const;
 
  const fs::path output_directory() const;
 
  // --- Enumerating Configurations ---
 
  bool is_enumeration() const;
 
  std::string enumeration_metric_args() const;
 
  std::string enumeration_check_args() const;
 
  Monte::ENUM_SAMPLE_MODE enumeration_sample_mode() const;
 
  bool enumeration_insert_canonical() const;
 
  bool enumeration_check_existence() const;
 
  Index enumeration_N_halloffame() const;
 
  double enumeration_tol() const;
 
 protected:
  bool _is_setting(std::string level1, std::string level2) const;
 
  bool _is_setting(std::string level1, std::string level2,
                   std::string level3) const;
 
  template <typename T>
  T _get_setting(std::string level1, std::string msg) const;
 
  template <typename T>
  T _get_setting(std::string level1, std::string level2, std::string msg) const;
 
  template <typename T>
  T _get_setting(std::string level1, std::string level2, std::string level3,
                 std::string msg) const;
 
  jsonParser _json() const { return *this; }
 
 private:
  fs::path m_root;
  fs::path m_output_directory;
  const PrimClex *m_primclex;
};
 
inline bool operator==(const jsonParser &json, const MonteSettings &settings) {
  return settings == json;
}
 
inline bool operator!=(const jsonParser &json, const MonteSettings &settings) {
  return settings != json;
}
 
class EquilibriumMonteSettings : public MonteSettings {
 public:
  EquilibriumMonteSettings() {}
 
  EquilibriumMonteSettings(const PrimClex &_primclex, const fs::path &read_path)
      : MonteSettings(_primclex, read_path) {}
 
  // --- MCData / Sampling ---------------------
 
  bool sample_by_pass() const;
 
  bool sample_by_step() const;
 
  size_type sample_period() const;
 
  bool is_equilibration_passes_first_run() const;
 
  size_type equilibration_passes_first_run() const;
 
  bool is_equilibration_passes_each_run() const;
 
  size_type equilibration_passes_each_run() const;
 
  bool is_N_pass() const;
 
  size_type N_pass() const;
 
  bool is_N_step() const;
 
  size_type N_step() const;
 
  bool is_N_sample() const;
 
  size_type N_sample() const;
 
  bool is_max_pass() const;
 
  size_type max_pass() const;
 
  bool is_min_pass() const;
 
  size_type min_pass() const;
 
  bool is_max_step() const;
 
  size_type max_step() const;
 
  bool is_min_step() const;
 
  size_type min_step() const;
 
  bool is_max_sample() const;
 
  size_type max_sample() const;
 
  bool is_min_sample() const;
 
  size_type min_sample() const;
 
  // --- Data ---------------------
 
  size_type max_data_length() const;
};
 
template <typename T>
T MonteSettings::_get_setting(std::string level1, std::string msg) const {
  try {
    return (*this)[level1].get<T>();
  }
 
  catch (std::runtime_error &e) {
    Log &err_log = CASM::err_log();
    std::stringstream ss;
    ss << "Monte Carlo setting "
       << "[\"" << level1 << "\"]";
 
    err_log.error<Log::standard>(ss.str());
 
    err_log << "Expected " << ss.str() << std::endl;
    err_log << "  Either this was not found, or the type is wrong."
            << std::endl;
    if (!msg.empty()) {
      err_log << "[\"" << level1 << "\"]: ";
      err_log << msg << std::endl;
    }
    throw;
  }
}
 
template <typename T>
T MonteSettings::_get_setting(std::string level1, std::string level2,
                              std::string msg) const {
  try {
    return (*this)[level1][level2].get<T>();
  }
 
  catch (std::runtime_error &e) {
    Log &err_log = CASM::err_log();
    std::stringstream ss;
    ss << "Monte Carlo setting [\"" << level1 << "\"][\"" << level2 << "\"]";
 
    err_log.error<Log::standard>(ss.str());
 
    err_log << "ERROR in MonteSettings::" << level2 << std::endl;
    err_log << "Expected " << ss.str() << std::endl;
    err_log << "  Either this was not found, or the type is wrong."
            << std::endl;
    if (this->contains(level1)) {
      err_log << "Found Settings[\"" << level1 << "\"], but not [\"" << level1
              << "\"][\"" << level2 << "\"]" << std::endl;
      err_log << "Settings[\"" << level1 << "\"]:\n"
              << (*this)[level1] << std::endl;
    } else {
      err_log << "No Settings[\"" << level1 << "\"] found" << std::endl;
      err_log << "Settings:\n"
              << static_cast<const jsonParser &>(*this) << std::endl;
    }
    if (!msg.empty()) {
      err_log << "[\"" << level1 << "\"][\"" << level2 << "\"]: ";
      err_log << msg << std::endl;
    }
    throw;
  }
}
 
template <typename T>
T MonteSettings::_get_setting(std::string level1, std::string level2,
                              std::string level3, std::string msg) const {
  try {
    return (*this)[level1][level2][level3].get<T>();
  }
 
  catch (std::runtime_error &e) {
    Log &err_log = CASM::err_log();
    std::stringstream ss;
    ss << "Monte Carlo setting [\"" << level1 << "\"][\"" << level2 << "\"][\""
       << level3 << "\"]";
 
    err_log.error<Log::standard>(ss.str());
 
    err_log << "Expected " << ss.str() << std::endl;
    err_log << "  Either this was not found, or the type is wrong."
            << std::endl;
    if (this->contains(level1)) {
      if (this->contains(level2)) {
        err_log << "Found Settings[\"" << level1 << "\"][\"" << level2
                << "\"], \n"
                   "but not [\""
                << level1 << "\"][\"" << level2 << "\"][\"" << level3 << "\"]"
                << std::endl;
        err_log << "Settings[\"" << level1 << "\"][\"" << level2 << "\"]:\n"
                << (*this)[level1][level2] << std::endl;
      } else {
        err_log << "No Settings[\"" << level1 << "\"][\"" << level2
                << "\"] found" << std::endl;
        err_log << "Settings:\n" << (*this)[level1] << std::endl;
      }
    } else {
      err_log << "No Settings[\"" << level1 << "\"] found" << std::endl;
      err_log << "Settings:\n"
              << static_cast<const jsonParser &>(*this) << std::endl;
    }
    if (!msg.empty()) {
      err_log << "[\"" << level1 << "\"][\"" << level2 << "\"][\"" << level3
              << "\"]: ";
      err_log << msg << std::endl;
    }
    throw;
  }
}
 
}  // namespace Monte
}  // namespace CASM
 
#endif