ConfigIOHull.hh

Go to the documentation of this file.

#ifndef CONFIGIOHULL_HH
#define CONFIGIOHULL_HH

#include "casm/casm_io/DataFormatter.hh"
#include "casm/hull/Hull.hh"
#include "casm/clex/ConfigIterator.hh"
#include "casm/clex/PrimClex.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);

      void 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);
      }

    };




    // --- BaseHull Definitions -------------------

    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>
    void BaseHull<ValueType>::init(const Configuration &_tmplt) const {

      ConstConfigSelection selection;
      const PrimClex &primclex = _tmplt.get_primclex();

      if(m_selection == "ALL") {
        selection = ConstConfigSelection(primclex);
        for(auto it = primclex.config_cbegin(); it != primclex.config_cend(); ++it) {
          selection.set_selected(it->name(), true);
        }
      }
      else if(m_selection == "MASTER") {
        selection = ConstConfigSelection(primclex);
      }
      else if(m_selection == "CALCULATED") {
        selection = ConstConfigSelection(primclex);
        for(auto it = primclex.config_cbegin(); it != primclex.config_cend(); ++it) {
          selection.set_selected(it->name(), is_calculated(*it));
        }

      }
      else {
        if(!fs::exists(m_selection)) {
          throw std::runtime_error(
            std::string("ERROR in $selection argument for '") + short_header(_tmplt) + "'." +
            " Expected <filename>, 'ALL', 'CALCULATED', or 'MASTER' <--default" +
            " No file named '" + m_selection + "'.");
        }
        selection = ConstConfigSelection(primclex, m_selection);
      }

      // Hull typedefs:
      //typedef std::pair<notstd::cloneable_ptr<CompCalculator>,
      //                  notstd::cloneable_ptr<EnergyCalculator> > CalculatorPair;
      //typedef std::map<std::string, CalculatorPair> CalculatorOptions;

      m_calculator_map.find(m_composition_type)->second.first->init(_tmplt);
      m_calculator_map.find(m_composition_type)->second.second->init(_tmplt);

      m_hull = std::make_shared<Hull>(selection,
                                      *m_calculator_map.find(m_composition_type)->second.first,
                                      *m_calculator_map.find(m_composition_type)->second.second,
                                      m_singular_value_tol,
                                      m_bottom_facet_tol);

    }

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



  }
}

#endif