ConfigIOHull.cc

Go to the documentation of this file.

#include <functional>
#include "casm/clex/ConfigIOHull.hh"
#include "casm/clex/Configuration.hh"
#include "casm/clex/PrimClex.hh"
#include "casm/clex/Norm.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";
    }

    // --- 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;
    }

  }
}