SimpleStructureIO.cc

Go to the documentation of this file.

#include "casm/crystallography/io/SimpleStructureIO.hh"
 
#include "casm/casm_io/container/json_io.hh"
#include "casm/casm_io/json/jsonParser.hh"
#include "casm/crystallography/CoordinateSystems.hh"
#include "casm/crystallography/SimpleStructure.hh"
#include "casm/global/enum/json_io.hh"
#include "casm/global/errors.hh"
 
namespace {
using namespace CASM;
 
 
static void _from_json_legacy(xtal::SimpleStructure &simple_structure,
                              const jsonParser &json) {
  try {
    COORD_TYPE coordinate_mode = json["coord_mode"].get<COORD_TYPE>();
    simple_structure.lat_column_mat =
        json["relaxed_lattice"].get<Eigen::Matrix3d>().transpose();
 
    // Input coordinate type to cartesian coordinate transformation matrix:
    //   cart_coord = coord_to_cart_mat * input_type_coord
    Eigen::Matrix3d to_cartesian_matrix = Eigen::Matrix3d::Identity();
    if (coordinate_mode == FRAC) {
      to_cartesian_matrix = simple_structure.lat_column_mat;
    }
 
    if (json.contains("relaxed_energy")) {
      simple_structure.properties["energy"] =
          json["relaxed_energy"].get<Eigen::MatrixXd>();
    }
    if (json.contains("relaxed_forces")) {
      simple_structure.atom_info.properties["force"] =
          json["relaxed_forces"].get<Eigen::MatrixXd>().transpose();
    }
    // note: silently ignoring legacy "relaxed_mag_basis" & "relaxed_magmom"
 
    // Read atom types
    std::vector<Index> atoms_per_type =
        json["atoms_per_type"].get<std::vector<Index> >();
    std::vector<std::string> atom_type =
        json["atom_type"].get<std::vector<std::string> >();
    for (Index i = 0; i < atoms_per_type.size(); ++i) {
      for (Index j = 0; j < atoms_per_type[i]; ++j) {
        simple_structure.atom_info.names.push_back(atom_type[i]);
      }
    }
 
    // Read basis coordinates
    simple_structure.atom_info.coords =
        to_cartesian_matrix *
        json["relaxed_basis"].get<Eigen::MatrixXd>().transpose();
 
  } catch (const std::exception &ex) {
    std::stringstream ss;
    ss << "Error parsing SimpleStructure from (legacy) JSON object. "
       << "One or more tags were improperly specified:\n"
       << ex.what();
    throw libcasm_runtime_error(ss.str());
  }
  return;
}
 
static jsonParser &_types_to_json(std::vector<std::string> const &names,
                                  jsonParser &json, std::string field_name,
                                  std::set<std::string> const &excluded_species,
                                  std::vector<Index> &permute) {
  jsonParser &names_json = json[field_name].put_array();
  for (Index i = 0; i < names.size(); ++i) {
    if (excluded_species.count(names[i])) continue;
    names_json.push_back(names[i]);
    permute.push_back(i);
  }
  return json;
}
 
static jsonParser &_coords_to_json(
    Eigen::MatrixXd const &coords, jsonParser &json, std::string field_name,
    std::vector<Index> const &permute,
    Eigen::Matrix3d const &to_coord_mode_matrix) {
  jsonParser &tjson = json[field_name].put_array();
  for (Index i : permute) {
    tjson.push_back(to_coord_mode_matrix * coords.col(i),
                    jsonParser::as_array());
  }
  return json;
}
 
static jsonParser &_properties_to_json(
    std::map<std::string, Eigen::MatrixXd> const &properties, jsonParser &json,
    std::string field_name, std::vector<Index> const &permute) {
  for (auto const &dof : properties) {
    jsonParser &tjson = json[field_name][dof.first]["value"].put_array();
    for (Index i : permute) {
      tjson.push_back(dof.second.col(i), jsonParser::as_array());
    }
  }
  return json;
}
 
static void _types_from_json(std::vector<std::string> &names,
                             jsonParser const &json, std::string field_name) {
  if (json.contains(field_name)) {
    from_json(names, json[field_name]);
  }
}
 
static void _coords_from_json(Eigen::MatrixXd &coords, jsonParser const &json,
                              std::string field_name,
                              Eigen::Matrix3d const &to_cartesian_matrix) {
  if (json.contains(field_name)) {
    coords = to_cartesian_matrix *
             json[field_name].get<Eigen::MatrixXd>().transpose();
  }
}
 
static void _properties_from_json(
    std::map<std::string, Eigen::MatrixXd> &properties, jsonParser const &json,
    std::set<std::string> allowed_field_names) {
  for (std::string const &field : allowed_field_names) {
    auto it = json.find(field);
    if (it != json.end()) {
      for (auto it2 = it->begin(); it2 != it->end(); ++it2) {
        properties[it2.name()] =
            (*it2)["value"].get<Eigen::MatrixXd>().transpose();
      }
    }
  }
}
 
static void _from_json_current(xtal::SimpleStructure &simple_structure,
                               const jsonParser &json) {
  COORD_TYPE coordinate_mode = json["coord_mode"].get<COORD_TYPE>();
  simple_structure.lat_column_mat =
      json["lattice"].get<Eigen::Matrix3d>().transpose();
 
  // Input coordinate mode to cartesian coordinate transformation matrix:
  //   cart_coord = to_cartesian_matrix * input_mode_coord
  Eigen::Matrix3d to_cartesian_matrix;
  to_cartesian_matrix.setIdentity();
  if (coordinate_mode == FRAC) {
    to_cartesian_matrix = simple_structure.lat_column_mat;
  }
 
  // Read global properties (if exists)
  ::_properties_from_json(simple_structure.properties, json,
                          {"global_dofs", "global_vals"});
 
  // Read atom_info (if exists)
  auto &atom_info = simple_structure.atom_info;
  ::_types_from_json(atom_info.names, json, "atom_type");
  ::_coords_from_json(atom_info.coords, json, "atom_coords",
                      to_cartesian_matrix);
  ::_properties_from_json(atom_info.properties, json,
                          {"atom_dofs", "atom_vals"});
 
  // Read mol_info (if exists)
  auto &mol_info = simple_structure.mol_info;
  ::_types_from_json(mol_info.names, json, "mol_type");
  ::_coords_from_json(mol_info.coords, json, "mol_coords", to_cartesian_matrix);
  ::_properties_from_json(mol_info.properties, json, {"mol_dofs", "mol_vals"});
}
 
static void _check_sizes(xtal::SimpleStructure::Info const &info,
                         std::string info_type) {
  if (info.names.size() != info.coords.cols()) {
    std::stringstream ss;
    ss << info_type << ".coords.cols(): " << info.coords.cols()
       << " != " << info_type << ".names.size(): " << info.names.size();
    throw libcasm_runtime_error(ss.str());
  }
  // Check consistency of <atom/mol>_info.names and properties size
  for (auto const &property_pair : info.properties) {
    if (info.names.size() != property_pair.second.cols()) {
      std::stringstream ss;
      ss << info_type << ".properties[" << property_pair.first
         << "\"].cols(): " << property_pair.second.cols() << " != " << info_type
         << ".names.size(): " << info.names.size();
      throw libcasm_runtime_error(ss.str());
    }
  }
}
 
}  // namespace
 
namespace CASM {
 
jsonParser &to_json(xtal::SimpleStructure const &simple_structure,
                    jsonParser &json,
                    std::set<std::string> const &excluded_species,
                    COORD_TYPE coordinate_mode) {
  // Matrix to transform Cartesian coordinates to 'coordinate_mode' coordinates
  Eigen::Matrix3d to_coord_mode_matrix = Eigen::Matrix3d::Identity();
  if (coordinate_mode == FRAC) {
    json["coord_mode"] = "Direct";
    to_coord_mode_matrix = simple_structure.lat_column_mat.inverse();
  } else {
    json["coord_mode"] = "Cartesian";
  }
 
  json["lattice"] = simple_structure.lat_column_mat.transpose();
 
  // Output global properties
  for (auto const &dof : simple_structure.properties) {
    to_json_array(dof.second, json["global_dofs"][dof.first]["value"]);
  }
 
  // Note: _types_to_json checks excluded_species and populates
  // "atom/mol_permute" with indices of
  //   sites that are included. This is used to only output the coordinates and
  //   properties of the correct sites in _properties_to_json and
  //   _coords_to_json
 
  // Output mol_info
  auto const &atom_info = simple_structure.atom_info;
  std::vector<Index> atom_permute;
  ::_types_to_json(atom_info.names, json, "atom_type", excluded_species,
                   atom_permute);
  ::_coords_to_json(atom_info.coords, json, "atom_coords", atom_permute,
                    to_coord_mode_matrix);
  ::_properties_to_json(atom_info.properties, json, "atom_dofs", atom_permute);
 
  // Output mol_info
  auto const &mol_info = simple_structure.mol_info;
  std::vector<Index> mol_permute;
  ::_types_to_json(atom_info.names, json, "mol_type", excluded_species,
                   mol_permute);
  ::_coords_to_json(mol_info.coords, json, "mol_coords", mol_permute,
                    to_coord_mode_matrix);
  ::_properties_to_json(mol_info.properties, json, "mol_dofs", mol_permute);
 
  return json;
}
 
//***************************************************************************
 
void from_json(xtal::SimpleStructure &simple_structure,
               const jsonParser &json) {
  try {
    // For backwards read compatibility:
    if (json.contains("atoms_per_type")) {
      ::_from_json_legacy(simple_structure, json);
    } else {
      ::_from_json_current(simple_structure, json);
    }
 
    // Check consistency of <atom/mol>_info.names and coords and properties size
    ::_check_sizes(simple_structure.atom_info, "atom_info");
    ::_check_sizes(simple_structure.mol_info, "mol_info");
 
  } catch (const std::exception &ex) {
    std::stringstream ss;
    ss << "Error parsing SimpleStructure from JSON object. "
       << "One or more tags were improperly specified:\n"
       << ex.what();
    throw std::runtime_error(ss.str());
  }
}
}  // namespace CASM