ClusterSpecs_json_io.cc

Go to the documentation of this file.

#include "casm/clusterography/io/json/ClusterSpecs_json_io.hh"
 
#include "casm/casm_io/container/json_io.hh"
#include "casm/casm_io/json/InputParser.hh"
#include "casm/casm_io/json/InputParser_impl.hh"
#include "casm/clusterography/ClusterSpecs_impl.hh"
#include "casm/clusterography/SupercellClusterOrbits.hh"
#include "casm/clusterography/io/json/ClusterOrbits_json_io.hh"
#include "casm/clusterography/io/json/IntegralCluster_json_io.hh"
 
namespace CASM {
 
namespace ClusterSpecs_json_io_impl {
 
template <typename SpecsType>
std::vector<double> parse_orbit_branch_specs_attr(
    InputParser<SpecsType> &parser, const std::string &attrname) {
  auto specs_it = parser.self.find("orbit_branch_specs");
  if (specs_it == parser.self.end() || specs_it->is_null()) {
    return std::vector<double>({0.});
  }
  std::vector<double> result({0.});
 
  if (!specs_it->is_obj()) {
    fs::path path{"orbit_branch_specs"};
    std::stringstream msg;
    msg << "Expected a JSON object";
    parser.insert_error("orbit_branch_specs", msg.str());
    return result;
  }
 
  auto update_result = [&](int branch, double value) {
    while (branch >= result.size()) {
      result.push_back(0.0);
    }
    result[branch] = value;
  };
 
  for (auto it = specs_it->begin(); it != specs_it->end(); ++it) {
    double value = 0.;  // default is 0. if no attrname found
    if (!it->is_obj()) {
      fs::path path{"orbit_branch_specs"};
      std::stringstream msg;
      msg << "Expected JSON object containing '" << attrname
          << "' (double, default=0.).";
      parser.insert_error(path / it.name(), msg.str());
      continue;
    }
    auto attr_it = it->find(attrname);
    if (attr_it != it->end()) {
      value = attr_it->template get<double>();
    }
    update_result(std::stoi(it.name()), value);
  }
  return result;
}
 
void write_group_indices(const SymGroup &grp, jsonParser &json) {
  json.put_array();
  for (const auto &op : grp) {
    json.push_back(op.index());
  }
}
 
void write_group_indices(std::vector<PermuteIterator> const &grp,
                         jsonParser &json) {
  std::set<Index> prim_factor_group_indices;
  for (auto const &permute_it : grp) {
    prim_factor_group_indices.insert(permute_it.prim_factor_group_index());
  }
 
  json = prim_factor_group_indices;
}
 
std::vector<SymOp>::const_iterator find_by_master_group_index(
    const SymOp &op, const SymGroup &super_group) {
  auto it = super_group.begin();
  auto end = super_group.end();
  for (; it != end; ++it) {
    if (it->index() == op.index()) {
      return it;
    }
  }
  return end;
}
 
std::unique_ptr<SymGroup> group_from_indices(const SymGroup &super_group,
                                             const std::set<Index> &indices) {
  auto result = notstd::make_unique<SymGroup>();
  result->set_lattice(super_group.lattice());
  for (SymOp const &op : super_group) {
    if (indices.count(op.index())) {
      result->push_back(op);
    }
  }
  result->sort();
  if ((*result)[0].index() != 0) {
    throw std::runtime_error(
        "Error in group_from_indices: First element is not identity.");
  }
  if (!result->is_group(super_group.lattice().tol())) {
    throw std::runtime_error("Error in local_group_from_indices: Not a group.");
  }
  return result;
}
 
template <typename SymCompareType>
std::unique_ptr<SymGroup> local_group_from_indices(
    const SymGroup &super_group, const std::set<Index> &indices,
    const IntegralCluster &phenomenal,
    const SymCompareType &sym_compare) {  // TODO: check this?
 
  IntegralCluster e{sym_compare.prepare(phenomenal)};
  auto result = notstd::make_unique<SymGroup>();
  result->set_lattice(super_group.lattice());
  for (SymOp const &op : super_group) {
    if (indices.count(op.index())) {
      // get translation & check that phenomenal cluster sites remain invariant
      // - note: this is a minimum requirement check that provides the
      // translation, it does not
      //   guarantee the user input indices are correct for a particular context
      //   (i.e. DiffTrans)
      if (sym_compare.equal(
              e, sym_compare.prepare(sym_compare.copy_apply(op, e)))) {
        result->push_back(sym_compare.spatial_transform() * op);
      } else {
        throw std::runtime_error(
            "Error in local_group_from_indices: Phenomenal cluster sites are "
            "not invariant.");
      }
    }
  }
  result->sort();
  if ((*result)[0].index() != 0) {
    throw std::runtime_error(
        "Error in local_group_from_indices: First element is not identity.");
  }
  if (!result->is_group(sym_compare.tol())) {
    throw std::runtime_error("Error in local_group_from_indices: Not a group.");
  }
  return result;
}
 
std::unique_ptr<SymGroup> parse_generating_group(
    InputParser<PeriodicMaxLengthClusterSpecs> &parser,
    const std::shared_ptr<const Structure> &shared_prim,
    const SymGroup &super_group) {
  auto generating_group_indices =
      parser.optional<std::set<Index>>("generating_group");
  if (generating_group_indices) {
    try {
      return group_from_indices(super_group, *generating_group_indices);
    } catch (std::exception &e) {
      parser.error.insert(std::string("Error parsing generating_group:") +
                          e.what());
      return std::unique_ptr<SymGroup>{};
    }
  } else {
    return notstd::clone(super_group);
  }
}
 
template <typename SymCompareType>
std::unique_ptr<SymGroup> parse_local_generating_group(
    InputParser<LocalMaxLengthClusterSpecs> &parser,
    const std::shared_ptr<const Structure> &shared_prim,
    const IntegralCluster &phenomenal, const SymGroup &super_group,
    const SymCompareType &sym_compare) {
  std::set<Index> generating_group_indices;
  parser.require(generating_group_indices, "generating_group");
  if (!parser.valid()) {
    return std::unique_ptr<SymGroup>();
  }
  try {
    return local_group_from_indices(super_group, generating_group_indices,
                                    phenomenal, sym_compare);
  } catch (std::exception &e) {
    parser.error.insert(std::string("Error parsing generating_group:") +
                        e.what());
  }
  return std::unique_ptr<SymGroup>();
}
}  // namespace ClusterSpecs_json_io_impl
 
void parse(InputParser<PeriodicMaxLengthClusterSpecs> &parser,
           const std::shared_ptr<const Structure> &shared_prim,
           const SymGroup &super_group) {
  using namespace ClusterSpecs_json_io_impl;
 
  // parse generating group
  auto generating_group_ptr =
      parse_generating_group(parser, shared_prim, super_group);
  if (!generating_group_ptr) {
    generating_group_ptr = notstd::clone(super_group);
  }
 
  // parse max length
  auto max_length = parse_orbit_branch_specs_attr(parser, "max_length");
 
  // parse custom generators ("orbit_specs")
  std::vector<IntegralClusterOrbitGenerator> default_custom_generators{};
  auto custom_generators_parser =
      parser.subparse_else<std::vector<IntegralClusterOrbitGenerator>>(
          "orbit_specs", default_custom_generators, *shared_prim);
 
  if (!parser.valid()) {
    return;
  }
  parser.value = notstd::make_unique<PeriodicMaxLengthClusterSpecs>(
      shared_prim, *generating_group_ptr, dof_sites_filter(), max_length,
      *custom_generators_parser->value);
}
 
void parse(InputParser<LocalMaxLengthClusterSpecs> &parser,
           const std::shared_ptr<const Structure> &shared_prim,
           const SymGroup &super_group) {
  using namespace ClusterSpecs_json_io_impl;
 
  // parse phenomenal
  auto phenomenal_subparser_ptr =
      parser.subparse<IntegralCluster>("phenomenal", *shared_prim);
  if (!phenomenal_subparser_ptr->valid()) {
    return;
  }
  IntegralCluster phenomenal = *phenomenal_subparser_ptr->value;
 
  // parse generating group
  typedef PrimPeriodicSymCompare<IntegralCluster> SymCompareType;
  SymCompareType sym_compare{shared_prim, shared_prim->lattice().tol()};
  auto generating_group_ptr = parse_local_generating_group(
      parser, shared_prim, phenomenal, super_group, sym_compare);
 
  // parse max_length and cutoff_radius
  auto max_length = parse_orbit_branch_specs_attr(parser, "max_length");
  auto cutoff_radius = parse_orbit_branch_specs_attr(parser, "cutoff_radius");
 
  // parse custom generators ("orbit_specs")
  std::vector<IntegralClusterOrbitGenerator> default_custom_generators{};
  auto custom_generators_parser =
      parser.subparse_else<std::vector<IntegralClusterOrbitGenerator>>(
          "orbit_specs", default_custom_generators, *shared_prim);
 
  // TODO: include option in JSON?
  bool include_phenomenal_sites = false;
 
  if (!parser.valid()) {
    return;
  }
  parser.value = notstd::make_unique<LocalMaxLengthClusterSpecs>(
      shared_prim, *generating_group_ptr, phenomenal, dof_sites_filter(),
      max_length, cutoff_radius, include_phenomenal_sites,
      *custom_generators_parser->value);
}
 
void parse(InputParser<ClusterSpecs> &parser,
           const std::shared_ptr<const Structure> &shared_prim) {
  parse(parser, shared_prim, shared_prim->factor_group());
}
 
void parse(InputParser<ClusterSpecs> &parser,
           const std::shared_ptr<const Structure> &shared_prim,
           const SymGroup &super_group) {
  std::string method;
  parser.require(method, "method");
  if (method.empty()) {
    return;
  }
 
  // ** this could be a dictionary lookup **
  if (method == "periodic_max_length") {
    auto subparser = parser.subparse<PeriodicMaxLengthClusterSpecs>(
        "params", shared_prim, super_group);
    if (subparser->value) {
      parser.value = std::move(subparser->value);
    }
  } else if (method == "local_max_length") {
    auto subparser = parser.subparse<LocalMaxLengthClusterSpecs>(
        "params", shared_prim, super_group);
    if (subparser->value) {
      parser.value = std::move(subparser->value);
    }
  } else {
    parser.error.insert("Error: unknown cluster_specs method '" + method +
                        "'.");
  }
}
 
namespace ClusterSpecs_json_io_impl {
 
jsonParser &orbit_branch_specs_attr_to_json(std::vector<double> attr,
                                            const std::string &attrname,
                                            jsonParser &json) {
  jsonParser &j = json["orbit_branch_specs"];
  for (int b = 0; b < attr.size(); ++b) {
    j[std::to_string(b)][attrname] = attr[b];
  }
  return json;
}
}  // namespace ClusterSpecs_json_io_impl
 
jsonParser &to_json(const PeriodicMaxLengthClusterSpecs &cspecs,
                    jsonParser &json) {
  json["method"] = cspecs.name();
  jsonParser &json_params = json["params"];
 
  using namespace ClusterSpecs_json_io_impl;
  orbit_branch_specs_attr_to_json(cspecs.max_length, "max_length", json_params);
  write_group_indices(cspecs.generating_group, json_params["generating_group"]);
  if (cspecs.custom_generators.size()) {
    json_params["orbit_specs"] = cspecs.custom_generators;
  }
  // currently fixed: site_filter=dof_sites_filter()
  return json;
}
 
jsonParser &to_json(const LocalMaxLengthClusterSpecs &cspecs,
                    jsonParser &json) {
  json["method"] = cspecs.name();
  jsonParser &json_params = json["params"];
 
  // select based on method
  using namespace ClusterSpecs_json_io_impl;
  orbit_branch_specs_attr_to_json(cspecs.max_length, "max_length", json_params);
  orbit_branch_specs_attr_to_json(cspecs.cutoff_radius, "cutoff_radius",
                                  json_params);
  write_group_indices(cspecs.generating_group, json_params["generating_group"]);
  to_json(cspecs.phenomenal, json_params["phenomenal"]);
  if (cspecs.custom_generators.size()) {
    json_params["orbit_specs"] = cspecs.custom_generators;
  }
  // currently fixed: site_filter=dof_sites_filter()
  return json;
}
 
jsonParser &to_json(const ClusterSpecs &cspecs, jsonParser &json) {
  if (cspecs.name() == PeriodicMaxLengthClusterSpecs::method_name) {
    return to_json(static_cast<const PeriodicMaxLengthClusterSpecs &>(cspecs),
                   json);
  } else if (cspecs.name() == LocalMaxLengthClusterSpecs::method_name) {
    return to_json(static_cast<const LocalMaxLengthClusterSpecs &>(cspecs),
                   json);
  } else {
    throw std::runtime_error(
        std::string("Error converting ClusterSpecs to JSON:") +
        " cannot convert method: '" + cspecs.name() + "'");
  }
}
 
}  // namespace CASM