CanonicalIO.cc

Go to the documentation of this file.

#include "casm/monte_carlo/canonical/CanonicalIO.hh"
 
#include "casm/casm_io/dataformatter/DataFormatter.hh"
#include "casm/crystallography/io/VaspIO.hh"
#include "casm/global/definitions.hh"
#include "casm/monte_carlo/MonteIO_impl.hh"
#include "casm/monte_carlo/canonical/Canonical.hh"
 
namespace CASM {
namespace Monte {
 
DataFormatter<ConstMonteCarloPtr> make_results_formatter(const Canonical &mc) {
  DataFormatter<ConstMonteCarloPtr> formatter;
 
  formatter.push_back(MonteCarloIsEquilibratedFormatter());
  formatter.push_back(MonteCarloNEquilSamplesFormatter());
  formatter.push_back(MonteCarloIsConvergedFormatter());
  formatter.push_back(MonteCarloNAvgSamplesFormatter());
 
  std::set<std::string> exclude;
  std::string name;
 
  // always print temperature, Beta
  formatter.push_back(MonteCarloTFormatter<Canonical>());
  formatter.push_back(MonteCarloBetaFormatter<Canonical>());
 
  // always print comp
  for (int i = 0;
       i < mc.primclex().composition_axes().independent_compositions(); ++i) {
    name = std::string("comp(") + mc.primclex().composition_axes().comp_var(i) +
           ")";
    formatter.push_back(MonteCarloCompFormatter<Canonical>(mc, i));
    exclude.insert(name);
  }
 
  // always print comp_n
  auto struc_mol_name = xtal::struc_molecule_name(mc.primclex().prim());
  for (int i = 0; i < struc_mol_name.size(); ++i) {
    name = std::string("comp_n(") + struc_mol_name[i] + ")";
    formatter.push_back(MonteCarloCompNFormatter<Canonical>(mc, i));
    exclude.insert(name);
  }
 
  // always print potential_energy, and formation_energy, though they are the
  // same
  {
    name = "potential_energy";
    formatter.push_back(MonteCarloMeanFormatter(name));
    formatter.push_back(MonteCarloPrecFormatter(name));
    exclude.insert(name);
 
    name = "formation_energy";
    formatter.push_back(MonteCarloMeanFormatter(name));
    formatter.push_back(MonteCarloPrecFormatter(name));
    exclude.insert(name);
  }
 
  // include mean/prec of other properties
  for (auto it = mc.samplers().cbegin(); it != mc.samplers().cend(); ++it) {
    if (exclude.find(it->first) == exclude.end()) {
      formatter.push_back(MonteCarloMeanFormatter(it->first));
      formatter.push_back(MonteCarloPrecFormatter(it->first));
    }
  }
 
  // include heat_capacity
  formatter.push_back(MonteCarloHeatCapacityFormatter<Canonical>());
 
  return formatter;
}
 
jsonParser &to_json(const CanonicalConditions &conditions, jsonParser &json) {
  json.put_obj();
  json["temperature"] = conditions.temperature();
 
  json["comp"] = jsonParser::object();
  auto param_composition = conditions.param_composition();
  for (int i = 0; i < param_composition.size(); i++) {
    json["comp"][CompositionConverter::comp_var(i)] = param_composition(i);
  }
 
  json["comp_n"] = jsonParser::object();
  auto mol_composition = conditions.mol_composition();
  auto components = conditions.primclex().composition_axes().components();
  for (int i = 0; i < components.size(); ++i) {
    json["comp_n"][components[i]] = mol_composition(i);
  }
 
  json["tolerance"] = conditions.tolerance();
 
  return json;
}
 
void from_json(CanonicalConditions &conditions, const PrimClex &primclex,
               const jsonParser &json) {
  double temp = json["temperature"].get<double>();
  double tol = json["tolerance"].get<double>();
 
  Eigen::VectorXd comp;
 
  if (json.contains("comp")) {
    if (json["comp"].is_array()) {
      from_json(comp, json["comp"]);
    } else {
      int Nparam = primclex.composition_axes().independent_compositions();
      comp.resize(Nparam);
 
      for (int i = 0; i < Nparam; i++) {
        comp(i) = json["comp"][CompositionConverter::comp_var(i)].get<double>();
      }
    }
  } else if (json.contains("comp_n")) {
    Eigen::VectorXd comp_n;
 
    if (json["comp_n"].is_array()) {
      from_json(comp_n, json["comp_n"]);
    } else {
      auto components = primclex.composition_axes().components();
      comp_n.resize(components.size());
 
      for (int i = 0; i < components.size(); i++) {
        comp_n(i) = json["comp_n"][components[i]].get<double>();
      }
    }
 
    comp_n = comp_n / comp_n.sum() * primclex.prim().basis().size();
    comp = primclex.composition_axes().param_composition(comp_n);
  } else {
    throw std::runtime_error(
        "Error reading conditions: No 'comp' or 'comp_n' specified");
  }
  conditions = CanonicalConditions(primclex, temp, comp, tol);
}
 
}  // namespace Monte
}  // namespace CASM