ConfigIOHull.hh

Go to the documentation of this file.

#ifndef CONFIGIOHULL_HH
#define CONFIGIOHULL_HH
 
#include "casm/casm_io/dataformatter/DataFormatter.hh"
#include "casm/clex/PrimClex.hh"
#include "casm/database/Selection.hh"
#include "casm/hull/Hull.hh"
 
namespace CASM {
 
class Configuration;
 
namespace ConfigIO {
 
Hull::CalculatorOptions hull_calculator_options();
 
Hull::CalculatorOptions clex_hull_calculator_options();
 
std::string default_hull_calculator();
 
template <typename ValueType>
class BaseHull : public BaseValueFormatter<ValueType, Configuration> {
 public:
  BaseHull(
      const std::string &_name, const std::string &_desc,
      const std::string &_default_selection = "MASTER",
      const std::string &_default_composition_type = default_hull_calculator(),
      const Hull::CalculatorOptions &_calculator_map =
          hull_calculator_options(),
      double _singular_value_tol = 1e-8, double _bottom_facet_tol = 1e-8);
 
  bool init(const Configuration &_tmplt) const override;
 
  std::string short_header(const Configuration &_config) const override;
 
  bool parse_args(const std::string &args) override;
 
 protected:
  const Hull &_hull() const;
 
  // for parse_args: determine energy type based on composition type
  Hull::CalculatorOptions m_calculator_map;
 
  // detect and avoid printing -0.0
  constexpr static double m_dist_to_hull_tol = 1e-14;
 
 private:
  // tol used to detect zero singular values during principal component analysis
  // preprocessing before hull calculation
  double m_singular_value_tol;
 
  // tol used to detect which facets are on the bottom of the convex hull
  double m_bottom_facet_tol;
 
  // the hull object
  mutable std::shared_ptr<Hull> m_hull;
 
  // Parsed arguments
  //  -- what selection to use for constructing the hull
  std::string m_selection;
 
  // Parsed arguments
  //  -- what composition to use for constructing the hull
  //  -- determines comp calculator and energy calculator, via m_calculator_map
  std::string m_composition_type;
 
  // Prevent re-parsing args
  bool m_initialized;
};
 
class OnHull : public BaseHull<bool> {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  OnHull();
 
  std::unique_ptr<OnHull> clone() const {
    return std::unique_ptr<OnHull>(this->_clone());
  }
 
  bool validate(const Configuration &_config) const override;
 
  bool evaluate(const Configuration &_config) const override;
 
 private:
  OnHull *_clone() const override { return new OnHull(*this); }
};
 
class HullDist : public BaseHull<double> {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  HullDist();
 
  std::unique_ptr<HullDist> clone() const {
    return std::unique_ptr<HullDist>(this->_clone());
  }
 
  bool validate(const Configuration &_config) const override;
 
  double evaluate(const Configuration &_config) const override;
 
 private:
  HullDist *_clone() const override { return new HullDist(*this); }
};
 
class OnClexHull : public BaseHull<bool> {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  OnClexHull();
 
  std::unique_ptr<OnClexHull> clone() const {
    return std::unique_ptr<OnClexHull>(this->_clone());
  }
 
  virtual bool validate(const Configuration &_config) const override;
 
  virtual bool evaluate(const Configuration &_config) const override;
 
 private:
  OnClexHull *_clone() const override { return new OnClexHull(*this); }
};
 
class ClexHullDist : public BaseHull<double> {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  ClexHullDist();
 
  std::unique_ptr<ClexHullDist> clone() const {
    return std::unique_ptr<ClexHullDist>(this->_clone());
  }
 
  virtual bool validate(const Configuration &_config) const override;
 
  virtual double evaluate(const Configuration &_config) const override;
 
 private:
  ClexHullDist *_clone() const override { return new ClexHullDist(*this); }
};
 
}  // namespace ConfigIO
}  // namespace CASM
 
#endif