ConfigIOHull.cc

Go to the documentation of this file.

#include "casm/clex/ConfigIOHull.hh"
 
#include <functional>
 
#include "casm/clex/Configuration.hh"
#include "casm/clex/Norm.hh"
#include "casm/clex/PrimClex.hh"
#include "casm/database/ConfigDatabase.hh"
 
namespace CASM {
 
namespace ConfigIO {
 
Hull::CalculatorOptions hull_calculator_options() {
  Hull::CalculatorOptions options;
  options["atom_frac"] = Hull::CalculatorPair(
      SpeciesFrac().clone(), formation_energy_per_species().clone());
  options["comp"] =
      Hull::CalculatorPair(Comp().clone(), formation_energy().clone());
  return options;
}
 
Hull::CalculatorOptions clex_hull_calculator_options() {
  Hull::CalculatorOptions options;
  Clex clex;
  options["comp"] = Hull::CalculatorPair(Comp().clone(), clex.clone());
  clex.parse_args("formation_energy,per_species");
  options["atom_frac"] =
      Hull::CalculatorPair(SpeciesFrac().clone(), clex.clone());
  return options;
}
 
std::string default_hull_calculator() { return "atom_frac"; }
 
// --- BaseHull Template Definitions (only needed here) -------------------
 
template <typename ValueType>
BaseHull<ValueType>::BaseHull(const std::string &_name,
                              const std::string &_desc,
                              const std::string &_default_selection,
                              const std::string &_default_composition_type,
                              const Hull::CalculatorOptions &_calculator_map,
                              double _singular_value_tol,
                              double _bottom_facet_tol)
    : BaseValueFormatter<ValueType, Configuration>(_name, _desc),
      m_calculator_map(_calculator_map),
      m_singular_value_tol(_singular_value_tol),
      m_bottom_facet_tol(_bottom_facet_tol),
      m_selection(_default_selection),
      m_composition_type(_default_composition_type),
      m_initialized(false) {}
 
template <typename ValueType>
bool BaseHull<ValueType>::init(const Configuration &_tmplt) const {
  DB::Selection<Configuration> selection(_tmplt.primclex().db<Configuration>(),
                                         m_selection);
 
  // Hull typedefs:
  // typedef std::pair<notstd::cloneable_ptr<CompCalculator>,
  //                  notstd::cloneable_ptr<EnergyCalculator> > CalculatorPair;
  // typedef std::map<std::string, CalculatorPair> CalculatorOptions;
 
  auto res = m_calculator_map.find(m_composition_type)->second;
  res.first->init(_tmplt);
  res.second->init(_tmplt);
 
  m_hull = std::make_shared<Hull>(selection, *res.first, *res.second,
                                  m_singular_value_tol, m_bottom_facet_tol);
  return true;
}
 
template <typename ValueType>
std::string BaseHull<ValueType>::short_header(
    const Configuration &_config) const {
  std::stringstream t_ss;
  t_ss << this->name() << "(" << m_selection << "," << m_composition_type
       << ")";
  return t_ss.str();
}
 
template <typename ValueType>
bool BaseHull<ValueType>::parse_args(const std::string &args) {
  if (m_initialized) {
    return false;
  }
 
  std::vector<std::string> splt_vec;
  boost::split(splt_vec, args, boost::is_any_of(","), boost::token_compress_on);
 
  if (splt_vec.size() > 4) {
    throw std::runtime_error("Attempted to initialize format tag " +
                             this->name() + " with " +
                             std::to_string(splt_vec.size()) + " arguments (" +
                             args + "), but only up to 4 arguments allowed.\n");
    return false;
  }
 
  while (splt_vec.size() < 4) {
    splt_vec.push_back("");
  }
 
  m_selection = splt_vec[0].empty() ? m_selection : splt_vec[0];
  m_composition_type = splt_vec[1].empty() ? m_composition_type : splt_vec[1];
  m_singular_value_tol =
      splt_vec[2].empty() ? m_singular_value_tol : std::stod(splt_vec[2]);
  m_bottom_facet_tol =
      splt_vec[3].empty() ? m_bottom_facet_tol : std::stod(splt_vec[3]);
  m_initialized = true;
 
  auto it = m_calculator_map.find(m_composition_type);
  if (it == m_calculator_map.end()) {
    std::stringstream ss;
    ss << "Composition type '" << m_composition_type
       << "' is not recognized. Options are: ";
    for (auto it = m_calculator_map.begin(); it != m_calculator_map.end();
         ++it) {
      std::cerr << it->first << " ";
      if (it != m_calculator_map.begin()) {
        ss << ", ";
      }
      ss << "'" << it->first << "'";
    }
    throw std::runtime_error(ss.str());
  }
 
  // prevent combining formatters
  return false;
}
 
template <typename ValueType>
const Hull &BaseHull<ValueType>::_hull() const {
  return *m_hull;
}
 
// --- OnHull Definitions -------------------
 
const std::string OnHull::Name = "on_hull";
 
const std::string OnHull::Desc =
    "Whether configuration is a vertex on the formation_energy convex hull "
    "(i.e., is a groundstate)."
    " Only one Configuration out of a set that have identical or almost "
    "identical points in"
    " composition/energy space will return true."
    " Accepts arguments ($selection,$composition,$dim_tol,$bottom_tol)."
    " ($selection may be one of: <filename>, 'ALL', 'CALCULATED', 'MASTER' "
    "<--default)"
    " ($composition may be one of: 'comp', 'atom_frac' <--default)"
    " ($dim_tol: tolerance for detecting composition dimensionality, "
    "default=1e-8)"
    " ($bottom_tol: tolerance for detecting which facets form the convex hull "
    "bottom, default=1e-8)"
    " For 'comp', 'formation_energy' is used. For 'atom_frac', "
    "'formation_energy_per_atom' is used."
    " Ex: on_hull, on_hull(MASTER,comp).";
 
OnHull::OnHull() : BaseHull<bool>(Name, Desc) {}
 
bool OnHull::validate(const Configuration &_config) const {
  return has_formation_energy(_config);
}
 
bool OnHull::evaluate(const Configuration &_config) const {
  orgQhull::QhullVertexList vertices = _hull().data().vertexList();
  for (auto it = vertices.begin(); it != vertices.end(); ++it) {
    if (_hull().configuration(*it).name() == _config.name()) {
      return true;
    }
  }
  return false;
}
 
// --- HullDist Definitions -------------------
 
const std::string HullDist::Name = "hull_dist";
 
const std::string HullDist::Desc =
    "Distance, in eV, of a configuration's formation_energy_per_atom above the "
    "convex hull."
    " Accepts arguments ($selection,$composition,$dim_tol,$bottom_tol)."
    " ($selection may be one of: <filename>, 'ALL', 'CALCULATED', 'MASTER' "
    "<--default)"
    " ($composition may be one of: 'comp', 'atom_frac' <--default)."
    " ($dim_tol: tolerance for detecting composition dimensionality, "
    "default=1e-8)"
    " ($bottom_tol: tolerance for detecting which facets form the convex hull "
    "bottom, default=1e-8)"
    " For 'comp', 'formation_energy' is used. For 'atom_frac', "
    "'formation_energy_per_atom' is used."
    " Ex: hull_dist, hull_dist(MASTER,comp).";
 
HullDist::HullDist() : BaseHull<double>(Name, Desc) {}
 
bool HullDist::validate(const Configuration &_config) const {
  return has_formation_energy(_config);
}
 
double HullDist::evaluate(const Configuration &_config) const {
  double d = _hull().dist_to_hull(_config);
  d = (std::abs(d) < m_dist_to_hull_tol) ? 0.0 : d;
  return d;
}
 
// --- OnClexHull Definitions -------------------
 
const std::string OnClexHull::Name = "on_clex_hull";
 
const std::string OnClexHull::Desc =
    "Whether configuration is a vertex on the *cluster-expanded* "
    "formation_energy "
    "convex hull (i.e., is a *predicted* groundstate)."
    " Only one Configuration out of a set that have identical or almost "
    "identical points in"
    " composition/energy space will return true."
    " Accepts arguments ($selection,$composition,$dim_tol,$bottom_tol)."
    " ($selection may be one of: <filename>, 'ALL', 'CALCULATED', 'MASTER' "
    "<--default)"
    " ($composition may be one of: 'comp', 'atom_frac' <--default)"
    " ($dim_tol: tolerance for detecting composition dimensionality, "
    "default=1e-8)"
    " ($bottom_tol: tolerance for detecting which facets form the convex hull "
    "bottom, default=1e-8)"
    " For 'comp', 'clex(formation_energy)' is used. For 'atom_frac', "
    "'clex(formation_energy_per_atom)' is used."
    " Ex: clex_hull_dist, clex_hull_dist(MASTER,comp).";
 
OnClexHull::OnClexHull()
    : BaseHull<bool>(Name, Desc, "MASTER", default_hull_calculator(),
                     clex_hull_calculator_options()) {}
 
bool OnClexHull::validate(const Configuration &_config) const { return true; }
 
bool OnClexHull::evaluate(const Configuration &_config) const {
  orgQhull::QhullVertexList vertices = _hull().data().vertexList();
  for (auto it = vertices.begin(); it != vertices.end(); ++it) {
    if (_hull().configuration(*it).name() == _config.name()) {
      return true;
    }
  }
  return false;
}
 
// --- ClexHullDist Definitions -------------------
 
const std::string ClexHullDist::Name = "clex_hull_dist";
 
const std::string ClexHullDist::Desc =
    "Distance, in eV, of a configuration's *cluster-expanded* "
    "formation_energy_per_atom above the convex hull."
    " Accepts arguments ($selection,$composition,$dim_tol,$bottom_tol)."
    " ($selection may be one of: <filename>, 'ALL', 'CALCULATED', 'MASTER' "
    "<--default)"
    " ($composition may be one of: 'comp', 'atom_frac' <--default)"
    " ($dim_tol: tolerance for detecting composition dimensionality, "
    "default=1e-8)"
    " ($bottom_tol: tolerance for detecting which facets form the convex hull "
    "bottom, default=1e-8)"
    " For 'comp', 'clex(formation_energy)' is used. For 'atom_frac', "
    "'clex(formation_energy_per_atom)' is used."
    " Ex: clex_hull_dist, clex_hull_dist(MASTER,comp).";
 
ClexHullDist::ClexHullDist()
    : BaseHull<double>(Name, Desc, "MASTER", default_hull_calculator(),
                       clex_hull_calculator_options()) {}
 
bool ClexHullDist::validate(const Configuration &_config) const { return true; }
 
double ClexHullDist::evaluate(const Configuration &_config) const {
  double d = _hull().dist_to_hull(_config);
  d = (std::abs(d) < m_dist_to_hull_tol) ? 0.0 : d;
  return d;
}
 
template class BaseHull<bool>;
template class BaseHull<double>;
}  // namespace ConfigIO
}  // namespace CASM