MonteIO.hh

Go to the documentation of this file.

#ifndef CASM_MonteIO_HH
#define CASM_MonteIO_HH

#include <string>
#include "casm/CASM_global_definitions.hh"
#include "casm/monte_carlo/MonteSampler.hh"
#include "casm/monte_carlo/MonteCounter.hh"

namespace CASM {

  class MonteCarloDirectoryStructure {

  public:

    MonteCarloDirectoryStructure(fs::path output_dir) :
      m_output_dir(fs::absolute(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, MonteSampler::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 Log;
  template<typename ValueType, typename DataObject> class GenericDatumFormatter;
  template<typename DataObject> class DataFormatter;

  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<MonteSampler::size_type, ConstMonteCarloPtr> MonteCarloNEquilSamplesFormatter();

  GenericDatumFormatter<MonteSampler::size_type, ConstMonteCarloPtr> MonteCarloNAvgSamplesFormatter();

  GenericDatumFormatter<MonteCounter::size_type, std::pair<ConstMonteCarloPtr, Index> > MonteCarloPassFormatter();

  GenericDatumFormatter<MonteCounter::size_type, std::pair<ConstMonteCarloPtr, Index> > MonteCarloStepFormatter();

  GenericDatumFormatter<double, std::pair<ConstMonteCarloPtr, Index> > MonteCarloObservationFormatter(std::string prop_name);

  GenericDatumFormatter<int, std::pair<ConstMonteCarloPtr, Index> > MonteCarloOccFormatter(Index occ_index);

  DataFormatter<std::pair<ConstMonteCarloPtr, Index> > make_observation_formatter(const MonteCarlo &mc);

  DataFormatter<std::pair<ConstMonteCarloPtr, Index> > 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, Index cond_index, Log &_log);

  void write_observations(const MonteSettings &settings, const MonteCarlo &mc, Index cond_index, Log &_log);

  void write_trajectory(const MonteSettings &settings, const MonteCarlo &mc, Index cond_index, Log &_log);

  void write_POSCAR_initial(const MonteCarlo &mc, Index cond_index, Log &_log);

  void write_POSCAR_final(const MonteCarlo &mc, Index cond_index, Log &_log);

  void write_POSCAR_trajectory(const MonteCarlo &mc, Index cond_index, Log &_log);

}

#endif