MonteIO.hh

Go to the documentation of this file.

#ifndef CASM_MonteIO_HH
#define CASM_MonteIO_HH
 
#include <boost/filesystem/path.hpp>
#include <string>
 
#include "casm/global/definitions.hh"
#include "casm/monte_carlo/MonteCounter.hh"
#include "casm/monte_carlo/MonteSampler.hh"
 
namespace CASM {
 
class Log;
template <typename ValueType, typename DataObject>
class GenericDatumFormatter;
template <typename DataObject>
class DataFormatter;
 
}  // namespace CASM
 
namespace CASM {
namespace Monte {
 
class MonteCarloDirectoryStructure {
 public:
  MonteCarloDirectoryStructure(fs::path output_dir);
 
  fs::path output_dir() const { return m_output_dir; }
 
  fs::path results_csv() const { return m_output_dir / "results.csv"; }
 
  fs::path results_json() const { return m_output_dir / "results.json"; }
 
  fs::path conditions_dir(int cond_index) const {
    return m_output_dir /
           (std::string("conditions.") + std::to_string(cond_index));
  }
 
  fs::path conditions_json(int cond_index) const {
    return conditions_dir(cond_index) / "conditions.json";
  }
 
  fs::path observations_csv(int cond_index) const {
    return conditions_dir(cond_index) / "observations.csv";
  }
 
  fs::path observations_json(int cond_index) const {
    return conditions_dir(cond_index) / "observations.json";
  }
 
  fs::path trajectory_csv(int cond_index) const {
    return conditions_dir(cond_index) / "trajectory.csv";
  }
 
  fs::path trajectory_json(int cond_index) const {
    return conditions_dir(cond_index) / "trajectory.json";
  }
 
  fs::path trajectory_dir(int cond_index) const {
    return conditions_dir(cond_index) / "trajectory";
  }
 
  fs::path POSCAR_initial(int cond_index) {
    return trajectory_dir(cond_index) / std::string("POSCAR.initial");
  }
 
  fs::path POSCAR_final(int cond_index) {
    return trajectory_dir(cond_index) / std::string("POSCAR.final");
  }
 
  fs::path POSCAR_snapshot(int cond_index, size_type sample_index) {
    return trajectory_dir(cond_index) /
           (std::string("POSCAR.") + std::to_string(sample_index));
  }
 
  fs::path initial_state_firstruneq_json(int cond_index) const {
    return conditions_dir(cond_index) / "initial_state_firstruneq.json";
  }
 
  fs::path initial_state_runeq_json(int cond_index) const {
    return conditions_dir(cond_index) / "initial_state_runeq.json";
  }
 
  fs::path initial_state_json(int cond_index) const {
    return conditions_dir(cond_index) / "initial_state.json";
  }
 
  fs::path final_state_json(int cond_index) const {
    return conditions_dir(cond_index) / "final_state.json";
  }
 
  fs::path occupation_key_csv() const {
    return output_dir() / "occupation_key.csv";
  }
 
  fs::path occupation_key_json() const {
    return output_dir() / "occupation_key.json";
  }
 
 private:
  fs::path m_output_dir;
};
 
class MonteCarlo;
class MonteSettings;
 
typedef const MonteCarlo *ConstMonteCarloPtr;
 
GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloMeanFormatter(
    std::string prop_name);
 
GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloPrecFormatter(
    std::string prop_name);
 
struct CovEvaluator {
  CovEvaluator(std::string _prop_name1, std::string _prop_name2)
      : prop_name1(_prop_name1), prop_name2(_prop_name2) {}
 
  double operator()(const ConstMonteCarloPtr &mc);
 
  std::string prop_name1;
  std::string prop_name2;
};
 
GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloCovFormatter(
    std::string prop_name1, std::string prop_name2);
 
GenericDatumFormatter<bool, ConstMonteCarloPtr>
MonteCarloIsEquilibratedFormatter();
 
GenericDatumFormatter<bool, ConstMonteCarloPtr>
MonteCarloIsConvergedFormatter();
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloTFormatter();
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloBetaFormatter();
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr>
MonteCarloParamChemPotFormatter(const MonteType &mc, int index);
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloChemPotFormatter(
    const MonteType &mc, int index);
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloCompFormatter(
    const MonteType &mc, int index);
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloCompNFormatter(
    const MonteType &mc, int index);
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr>
MonteCarloHeatCapacityFormatter();
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloSuscXFormatter(
    std::string comp_var_i, std::string comp_var_j);
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloSuscNFormatter(
    std::string species_i, std::string species_j);
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr>
MonteCarloThermoChemSuscXFormatter(std::string comp_var_i);
 
template <typename MonteType>
GenericDatumFormatter<double, ConstMonteCarloPtr>
MonteCarloThermoChemSuscNFormatter(std::string species_i);
 
GenericDatumFormatter<size_type, ConstMonteCarloPtr>
MonteCarloNEquilSamplesFormatter();
 
GenericDatumFormatter<size_type, ConstMonteCarloPtr>
MonteCarloNAvgSamplesFormatter();
 
GenericDatumFormatter<size_type, std::pair<ConstMonteCarloPtr, size_type> >
MonteCarloPassFormatter();
 
GenericDatumFormatter<size_type, std::pair<ConstMonteCarloPtr, size_type> >
MonteCarloStepFormatter();
 
GenericDatumFormatter<double, std::pair<ConstMonteCarloPtr, size_type> >
MonteCarloObservationFormatter(std::string prop_name);
 
GenericDatumFormatter<int, std::pair<ConstMonteCarloPtr, size_type> >
MonteCarloOccFormatter(size_type occ_index);
 
DataFormatter<std::pair<ConstMonteCarloPtr, size_type> >
make_observation_formatter(const MonteCarlo &mc);
 
DataFormatter<std::pair<ConstMonteCarloPtr, size_type> >
make_trajectory_formatter(const MonteCarlo &mc);
 
template <typename MonteType>
void write_results(const MonteSettings &settings, const MonteType &mc,
                   Log &_log);
 
template <typename MonteType>
void write_conditions_json(const MonteSettings &settings, const MonteType &mc,
                           size_type cond_index, Log &_log);
 
void write_observations(const MonteSettings &settings, const MonteCarlo &mc,
                        size_type cond_index, Log &_log);
 
void write_trajectory(const MonteSettings &settings, const MonteCarlo &mc,
                      size_type cond_index, Log &_log);
 
void write_POSCAR_initial(const MonteCarlo &mc, size_type cond_index,
                          Log &_log);
 
void write_POSCAR_final(const MonteCarlo &mc, size_type cond_index, Log &_log);
 
void write_POSCAR_trajectory(const MonteCarlo &mc, size_type cond_index,
                             Log &_log);
 
}  // namespace Monte
}  // namespace CASM
 
#endif