MonteSettings.cc

Go to the documentation of this file.

#include "casm/monte_carlo/MonteSettings.hh"
 
#include <boost/filesystem.hpp>
 
#include "casm/app/DirectoryStructure.hh"
#include "casm/casm_io/container/json_io.hh"
#include "casm/clex/io/json/ConfigDoF_json_io.hh"
#include "casm/crystallography/BasicStructure.hh"
#include "casm/crystallography/Structure.hh"
#include "casm/misc/CASM_Eigen_math.hh"
#include "casm/misc/HallOfFame.hh"
#include "casm/monte_carlo/MonteCarlo.hh"
#include "casm/monte_carlo/MonteCarloEnum.hh"
 
namespace CASM {
namespace Monte {
 
// --- MonteSettings Definitions
// -------------------------------------------------
 
MonteSettings::MonteSettings(const PrimClex &_primclex,
                             const fs::path &read_path)
    : jsonParser(read_path), m_primclex(&_primclex) {
  m_root = find_casmroot(fs::absolute(read_path));
  m_output_directory = fs::absolute(read_path).parent_path();
}
 
// --- Project root directory ---------------------------
 
fs::path MonteSettings::root() const { return m_root; }
 
const PrimClex &MonteSettings::primclex() const { return *m_primclex; }
 
// --- Type ---------------------------
 
Monte::ENSEMBLE MonteSettings::ensemble() const {
  return _get_setting<Monte::ENSEMBLE>("ensemble", help<Monte::ENSEMBLE>());
}
 
Monte::METHOD MonteSettings::method() const {
  return _get_setting<Monte::METHOD>("method", help<Monte::METHOD>());
}
 
bool MonteSettings::debug() const {
  auto it = find("debug");
  if (it == end()) {
    return false;
  }
  return it->get<bool>();
}
 
void MonteSettings::set_debug(bool _debug) { (*this)["debug"] = _debug; }
 
// --- Initialization ---------------------
 
bool MonteSettings::is_motif_configname() const {
  return _is_setting("driver", "motif", "configname");
}
 
std::string MonteSettings::motif_configname() const {
  std::string help =
      "string"
      "  The name of a configuration, of the form \"SCELV_A_B_C_D_E_F/N\"";
  return _get_setting<std::string>("driver", "motif", "configname", help);
}
 
bool MonteSettings::is_motif_configdof() const {
  return _is_setting("driver", "motif", "configdof");
}
 
ConfigDoF MonteSettings::motif_configdof(Index supercell_volume) const {
  std::string help =
      "string\n"
      "  Path to file containing DoF, such as an \"final_state.json\" file.";
  fs::path configdof_path =
      _get_setting<fs::path>("driver", "motif", "configdof", help);
  return jsonParser(configdof_path)
      .get<ConfigDoF>(primclex().prim(), supercell_volume);
}
 
fs::path MonteSettings::motif_configdof_path() const {
  std::string help = "";
  return _get_setting<fs::path>("driver", "motif", "configdof", help);
}
 
Eigen::Matrix3l MonteSettings::simulation_cell_matrix() const {
  std::string help =
      "3x3 transformation matrix, T, such that S = U*T,\n"
      "  where S, is the supercell lattice vectors,\n"
      "  and P, is the primitive cell lattice vectors.\n";
  return _get_setting<Eigen::Matrix3l>("supercell", help);
}
 
// --- Driver ---------------------
 
const Monte::DRIVE_MODE MonteSettings::drive_mode() const {
  return _get_setting<Monte::DRIVE_MODE>("driver", "mode",
                                         help<Monte::DRIVE_MODE>());
}
 
bool MonteSettings::dependent_runs() const {
  if (!_is_setting("driver", "dependent_runs")) {
    return true;
  }
  std::string help =
      "bool (default=true)\n"
      "  If true, begin the next calculation with the final DoF from the "
      "previous \n"
      "    calculation.\n"
      "  If false, begin each calculation with the DoF specified for the "
      "\"motif\".\n";
  return _get_setting<bool>("driver", "dependent_runs", help);
}
 
const fs::path MonteSettings::output_directory() const {
  return m_output_directory;
}
 
// --- MCData / Sampling ---------------------
 
double MonteSettings::confidence() const {
  std::string help = "number, range (0.0, 1.0), default 0.95)";
  if (_is_setting("data", "confidence")) {
    return _get_setting<double>("data", "confidence", help);
  } else {
    return 0.95;
  }
}
 
bool MonteSettings::write_trajectory() const {
  std::string level1 = "data";
  std::string level2 = "storage";
  std::string level3 = "write_trajectory";
  std::string help = "bool (default=false)";
  if (!_is_setting(level1, level2, level3)) {
    return false;
  }
 
  return _get_setting<bool>(level1, level2, level3, help);
}
 
bool MonteSettings::write_POSCAR_snapshots() const {
  std::string level1 = "data";
  std::string level2 = "storage";
  std::string level3 = "write_POSCAR_snapshots";
  std::string help = "(bool, default=false)";
  if (!_is_setting(level1, level2, level3)) {
    return false;
  }
 
  return _get_setting<bool>(level1, level2, level3, help);
}
 
bool MonteSettings::write_observations() const {
  std::string level1 = "data";
  std::string level2 = "storage";
  std::string level3 = "write_observations";
  std::string help = "(bool, default=false)";
  if (!_is_setting(level1, level2, level3)) {
    return false;
  }
 
  return _get_setting<bool>(level1, level2, level3, help);
}
 
bool MonteSettings::write_csv() const {
  std::string level1 = "data";
  std::string level2 = "storage";
  std::string level3 = "output_format";
  std::string help =
      "(string or JSON array of string, optional, default='csv')\n"
      "  Accepts: 'csv' or 'CSV' to write .csv files\n"
      "           'json' or 'JSON' to write .json files\n"
      "  Use an array to write in multiple formats.\n";
 
  if (!_is_setting(level1, level2, level3)) {
    return true;
  }
 
  const jsonParser &ref = (*this)[level1][level2][level3];
 
  if (ref.is_array()) {
    std::vector<std::string> formats =
        _get_setting<std::vector<std::string> >(level1, level2, level3, help);
    for (auto it = formats.begin(); it != formats.end(); ++it) {
      if (*it == "csv" || *it == "CSV") {
        return true;
      }
    }
    return false;
  } else {
    std::string input = _get_setting<std::string>(level1, level2, level3, help);
    if (input == "csv" || input == "CSV") {
      return true;
    }
    return false;
  }
}
 
bool MonteSettings::write_json() const {
  std::string level1 = "data";
  std::string level2 = "storage";
  std::string level3 = "output_format";
  std::string help =
      "(string or JSON array of string, optional, default='csv')\n"
      "  Accepts: 'csv' or 'CSV' to write .csv files\n"
      "           'json' or 'JSON' to write .json files\n"
      "  Use an array to write in multiple formats.\n";
 
  if (!_is_setting(level1, level2, level3)) {
    return false;
  }
 
  const jsonParser &ref = (*this)[level1][level2][level3];
 
  if (ref.is_array()) {
    std::vector<std::string> formats =
        _get_setting<std::vector<std::string> >(level1, level2, level3, help);
    for (auto it = formats.begin(); it != formats.end(); ++it) {
      if (*it == "json" || *it == "JSON") {
        return true;
      }
    }
    return false;
  } else {
    std::string input = _get_setting<std::string>(level1, level2, level3, help);
    if (input == "json" || input == "JSON") {
      return true;
    }
    return false;
  }
}
 
// --- Enumerating Configurations ---
 
bool MonteSettings::is_enumeration() const {
  if (!_is_setting("data", "enumeration")) {
    return false;
  }
  return true;
}
 
std::string MonteSettings::enumeration_metric_args() const {
  std::string help =
      "(string, optional, default=\"clex_hull_dist(ALL)\")\n"
      "  A 'casm query'-like string that provides a metric for \n"
      "  ranking configurations as they are encountered during \n"
      "  a Monte Carlo calculation. The resulting value is used\n"
      "  to create a hall of fame of 'best' configurations     \n"
      "  encountered during the calculation. When the          \n"
      "  calculation is complete configurations in the hall of \n"
      "  fame are added to the CASM project config list.       \n"
      "  The 'casm query'-like command should evaluate to a    \n"
      "  number.";
 
  if (!_is_setting("data", "enumeration", "metric")) {
    return "clex_hull_dist(ALL)";
  }
  return _get_setting<std::string>("data", "enumeration", "metric", help);
}
 
std::string MonteSettings::enumeration_check_args() const {
  std::string help =
      "(string, optional, default=\"eq(1,1)\")\n"
      "  A 'casm query'-like string that returns a boolean value \n"
      "  indicating if (true) a configuration should be considered\n"
      "  for the enumeration hall of fame.";
 
  if (!_is_setting("data", "enumeration", "check")) {
    return "eq(1,1)";
  }
  return _get_setting<std::string>("data", "enumeration", "check", help);
}
 
Monte::ENUM_SAMPLE_MODE MonteSettings::enumeration_sample_mode() const {
  if (!_is_setting("data", "enumeration", "sample_mode")) {
    return Monte::ENUM_SAMPLE_MODE::ON_SAMPLE;
  }
  return _get_setting<Monte::ENUM_SAMPLE_MODE>(
      "data", "enumeration", "sample_mode", help<Monte::ENUM_SAMPLE_MODE>());
}
 
bool MonteSettings::enumeration_check_existence() const {
  std::string help =
      "(bool, optional, default=true)\n"
      "  If true, only configurations that do not already exist\n"
      "  in the config list are inserted into the enumeration  \n"
      "  hall of fame.";
 
  if (!_is_setting("data", "enumeration", "check_existence")) {
    return true;
  }
  return _get_setting<bool>("data", "enumeration", "check_existence", help);
}
 
bool MonteSettings::enumeration_insert_canonical() const {
  std::string help =
      "(bool, optional, default=true)\n"
      "  If true, configurations are inserted into the         \n"
      "  enumeration hall of fame in their canonical form. If  \n"
      "  'check_existence' is true, this must be set to true.";
 
  bool val;
  if (!_is_setting("data", "enumeration", "insert_canonical")) {
    val = true;
  } else {
    val = _get_setting<bool>("data", "enumeration", "insert_canonical", help);
  }
 
  // if check_existence, insert_canonical must be true
  if (enumeration_check_existence() && !val) {
    throw std::runtime_error(
        "Error in Monte Carlo enumeration in settings: "
        "If 'check_existence' is true, then 'insert_canonical' must be true");
  }
  return val;
}
 
Index MonteSettings::enumeration_N_halloffame() const {
  std::string help =
      "(integer, optional, default=100)\n"
      "  The number of configurations that are allowed in the \n"
      "  enumeration hall of fame.";
 
  if (!_is_setting("data", "enumeration", "N_halloffame")) {
    return 100;
  }
  return _get_setting<Index>("data", "enumeration", "N_halloffame", help);
}
 
double MonteSettings::enumeration_tol() const {
  std::string help =
      "(number, optional, default=1e-8)\n"
      "  Tolerance used for floating point comparison of         \n"
      "  configuration scores in the enumeration hall of fame.";
 
  if (!_is_setting("data", "enumeration", "tolerance")) {
    return 1e-8;
  }
  return _get_setting<double>("data", "enumeration", "tolerance", help);
}
 
bool MonteSettings::_is_setting(std::string level1, std::string level2) const {
  try {
    return (*this)[level1].contains(level2);
  }
 
  catch (std::runtime_error &e) {
    Log &err_log = CASM::err_log();
    err_log.error<Log::standard>("Reading Monte Carlo settings");
    err_log << "No [\"" << level1 << "\"] setting found.\n" << std::endl;
    throw e;
  }
}
 
bool MonteSettings::_is_setting(std::string level1, std::string level2,
                                std::string level3) const {
  try {
    return (*this)[level1][level2].contains(level3);
  }
 
  catch (std::runtime_error &e) {
    Log &err_log = CASM::err_log();
    err_log.error<Log::standard>("Reading Monte Carlo settings");
    if (this->contains(level1)) {
      err_log << "No [\"" << level1 << "\"][\"" << level2 << "\"] setting found"
              << std::endl;
    } else {
      err_log << "No [\"" << level1 << "\"] setting found" << std::endl;
    }
    throw;
  }
}
 
// --- EquilibriumMonteSettings Definitions
// -------------------------------------------------
 
// --- MCData / Sampling ---------------------
 
bool EquilibriumMonteSettings::sample_by_pass() const {
  return Monte::SAMPLE_MODE::PASS ==
         _get_setting<Monte::SAMPLE_MODE>("data", "sample_by",
                                          help<Monte::SAMPLE_MODE>());
}
 
bool EquilibriumMonteSettings::sample_by_step() const {
  return Monte::SAMPLE_MODE::STEP ==
         _get_setting<Monte::SAMPLE_MODE>("data", "sample_by",
                                          help<Monte::SAMPLE_MODE>());
}
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::sample_period()
    const {
  std::string level1 = "data";
  std::string level2 = "sample_period";
  std::string help =
      "(int, default=1)\n"
      "  In conjunction with \"sample_by\", determines how often to make "
      "observations.";
  if (!_is_setting(level1, level2)) {
    return 1;
  }
 
  return _get_setting<size_type>(level1, level2, help);
}
 
bool EquilibriumMonteSettings::is_equilibration_passes_first_run() const {
  return _is_setting("data", "equilibration_passes_first_run");
}
 
EquilibriumMonteSettings::size_type
EquilibriumMonteSettings::equilibration_passes_first_run() const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "equilibration_passes_first_run",
                                 help);
}
 
bool EquilibriumMonteSettings::is_equilibration_passes_each_run() const {
  return _is_setting("data", "equilibration_passes_each_run");
}
 
EquilibriumMonteSettings::size_type
EquilibriumMonteSettings::equilibration_passes_each_run() const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "equilibration_passes_each_run", help);
}
 
bool EquilibriumMonteSettings::is_N_pass() const {
  return _is_setting("data", "N_pass");
}
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::N_pass() const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "N_pass", help);
}
 
bool EquilibriumMonteSettings::is_N_step() const {
  std::string help = "int (optional)";
  return _is_setting("data", "N_step");
}
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::N_step() const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "N_step", help);
}
 
bool EquilibriumMonteSettings::is_N_sample() const {
  return _is_setting("data", "N_sample");
}
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::N_sample() const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "N_sample", help);
}
 
bool EquilibriumMonteSettings::is_max_pass() const {
  return _is_setting("data", "max_pass");
}
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::max_pass() const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "max_pass", help);
}
 
bool EquilibriumMonteSettings::is_min_pass() const {
  return _is_setting("data", "min_pass");
}
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::min_pass() const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "min_pass", help);
}
 
bool EquilibriumMonteSettings::is_max_step() const {
  return _is_setting("data", "max_step");
}
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::max_step() const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "max_step", help);
}
 
bool EquilibriumMonteSettings::is_min_step() const {
  return _is_setting("data", "min_step");
}
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::min_step() const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "min_step", help);
}
 
bool EquilibriumMonteSettings::is_max_sample() const {
  return _is_setting("data", "max_sample");
}
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::max_sample()
    const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "max_sample", help);
}
 
bool EquilibriumMonteSettings::is_min_sample() const {
  return _is_setting("data", "min_sample");
}
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::min_sample()
    const {
  std::string help = "int (optional)";
  return _get_setting<size_type>("data", "min_sample", help);
}
 
// --- Data ---------------------
 
EquilibriumMonteSettings::size_type EquilibriumMonteSettings::max_data_length()
    const {
  if (!_is_setting("data", "sample_by")) {
    return 1024;
  } else if (sample_by_pass()) {
    if (is_max_pass()) {
      return (max_pass() / sample_period());
    } else if (is_N_pass()) {
      return (N_pass() / sample_period());
    } else if (is_N_sample()) {
      return N_sample();
    } else {
      return 1024;
    }
  } else if (sample_by_step()) {
    if (is_max_step()) {
      return (max_step() / sample_period());
    } else if (is_N_step()) {
      return (N_step() / sample_period());
    } else if (is_N_sample()) {
      return N_sample();
    } else {
      return 1024;
    }
  } else {
    Log &err_log = CASM::err_log();
    err_log.error<Log::standard>("Reading Monte Carlo settings");
    err_log << "Could not determine max data length.\n";
    err_log << "Please check 'sample_by', 'max_pass' or 'max_step', and "
               "'sample_period' in your input file.\n"
            << std::endl;
    throw std::runtime_error(std::string("Error determining max_data_length"));
  }
}
 
}  // namespace Monte
}  // namespace CASM