ConfigDoF_json_io.cc

Go to the documentation of this file.

#include "casm/clex/io/json/ConfigDoF_json_io.hh"
 
#include "casm/casm_io/Log.hh"
#include "casm/casm_io/container/json_io.hh"
#include "casm/casm_io/json/InputParser_impl.hh"
#include "casm/casm_io/json/jsonParser.hh"
#include "casm/clex/ConfigDoF.hh"
#include "casm/clex/ConfigDoFTools.hh"
#include "casm/crystallography/Structure.hh"
 
namespace CASM {
 
std::unique_ptr<ConfigDoF> jsonMake<ConfigDoF>::make_from_json(
    const jsonParser &json, Structure const &prim, Index volume) {
  auto result_ptr = make_unique_configdof(prim, volume);
  from_json(*result_ptr, json);
  return result_ptr;
}
 
ConfigDoF jsonConstructor<ConfigDoF>::from_json(const jsonParser &json,
                                                Structure const &prim,
                                                Index volume) {
  ConfigDoF result = make_configdof(prim, volume);
  CASM::from_json(result, json);
  return result;
}
 
jsonParser &to_json(const ConfigDoF &configdof, jsonParser &json) {
  json = jsonParser::object();
  if (configdof.occupation().size()) {
    to_json_array(configdof.occupation(), json["occ"]);
  }
  if (!configdof.local_dofs().empty()) {
    for (auto const &local_dof : configdof.local_dofs()) {
      to_json(local_dof.second.standard_values().transpose(),
              json["local_dofs"][local_dof.first]["values"]);
    }
  }
  if (!configdof.global_dofs().empty()) {
    for (auto const &global_dof : configdof.global_dofs()) {
      to_json_array(global_dof.second.standard_values(),
                    json["global_dofs"][global_dof.first]["values"]);
    }
  }
 
  return json;
}
 
void from_json(ConfigDoF &configdof, const jsonParser &json) {
  auto &log = CASM::log();
  ParentInputParser parser{json};
  std::runtime_error error_if_invalid{
      "Error reading ConfigDoF from JSON input"};
 
  Eigen::VectorXi occ;
  // For Backwards compatibility
  if (parser.self.contains("occupation")) {
    parser.require(occ, "occupation");
  } else {
    parser.require(occ, "occ");
    try {
      configdof.set_occupation(occ);
    } catch (std::exception const &e) {
      parser.insert_error("occ", e.what());
    }
  }
 
  for (auto const &local_dof : configdof.local_dofs()) {
    Eigen::MatrixXd tvalues;
    fs::path values_path = fs::path{"local_dofs"} / local_dof.first / "values";
    parser.require(tvalues, values_path);
    try {
      configdof.local_dof(local_dof.first)
          .from_standard_values(tvalues.transpose());
    } catch (std::exception const &e) {
      parser.insert_error(values_path, e.what());
    }
  }
 
  for (auto const &global_dof : configdof.global_dofs()) {
    Eigen::VectorXd tvalues;
    fs::path values_path =
        fs::path{"global_dofs"} / global_dof.first / "values";
    parser.require(tvalues, values_path);
    try {
      configdof.global_dof(global_dof.first).from_standard_values(tvalues);
    } catch (std::exception const &e) {
      parser.insert_error(values_path, e.what());
    }
  }
 
  report_and_throw_if_invalid(parser, log, error_if_invalid);
}
 
}  // namespace CASM