MonteSettings.hh

Go to the documentation of this file.

#ifndef CASM_MonteSettings_HH
#define CASM_MonteSettings_HH

#include <string>
#include "casm/CASM_global_definitions.hh"
#include "casm/misc/cloneable_ptr.hh"
#include "casm/casm_io/jsonParser.hh"
#include "casm/clex/ECIContainer.hh"
#include "casm/clex/PrimClex.hh"
#include "casm/monte_carlo/MonteDefinitions.hh"
#include "casm/monte_carlo/MonteSampler.hh"

namespace CASM {

  class MonteCarlo;
  template<typename ObjectType, typename Metric, typename ObjectCompare>
  class HallOfFame;

  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 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() const;

    fs::path motif_configdof_path() const;

    Eigen::Matrix3i 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 = default_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 = default_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 = default_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;
    }
  }

}

#endif