ConfigIO.hh

Go to the documentation of this file.

#ifndef CONFIGIO_HH
#define CONFIGIO_HH

#include "casm/casm_io/DataFormatter.hh"
#include "casm/casm_io/DataFormatterTools.hh"
#include "casm/container/ContainerTraits.hh"
#include "casm/clex/Clexulator.hh"
#include "casm/clex/ECIContainer.hh"

namespace CASM {



  class Configuration;
  template<typename DataObject>
  class Norm;

  template<bool IsConst>
  class ConfigSelection;

  namespace ConfigIO_impl {

    class MolDependent : public VectorXdAttribute<Configuration> {

    public:

      MolDependent(const std::string &_name, const std::string &_desc) :
        VectorXdAttribute<Configuration>(_name, _desc) {}


      // --- Specialized implementation -----------

      bool parse_args(const std::string &args) override;

      void init(const Configuration &_tmplt) const override;

      std::vector<std::string> col_header(const Configuration &_tmplt) const override;

    private:
      mutable std::vector<std::string> m_mol_names;

    };

  }

  namespace ConfigIO {

    class Selected;

    template<typename ValueType>
    using GenericConfigFormatter = GenericDatumFormatter<ValueType, Configuration>;


    template<typename ValueType>
    using ConstantValue = ConstantValueFormatter<ValueType, Configuration>;

    class Comp : public VectorXdAttribute<Configuration> {

    public:

      static const std::string Name;

      static const std::string Desc;


      Comp() :
        Base1DDatumFormatter(Name, Desc) {}


      // --- Required implementations -----------

      Eigen::VectorXd evaluate(const Configuration &config) const override;

      std::unique_ptr<Comp> clone() const {
        return std::unique_ptr<Comp>(this->_clone());
      }


      // --- Specialized implementation -----------

      bool validate(const Configuration &config) const override;

      bool parse_args(const std::string &args) override;

      std::vector<std::string> col_header(const Configuration &_tmplt) const override;

    private:

      Comp *_clone() const override {
        return new Comp(*this);
      }

    };


    class CompN : public ConfigIO_impl::MolDependent {

    public:

      static const std::string Name;

      static const std::string Desc;


      CompN() :
        MolDependent(Name, Desc) {}


      // --- Required implementations -----------

      Eigen::VectorXd evaluate(const Configuration &config) const override;

      std::unique_ptr<CompN> clone() const {
        return std::unique_ptr<CompN>(this->_clone());
      }

    private:

      CompN *_clone() const override {
        return new CompN(*this);
      }

    };


    class SiteFrac : public ConfigIO_impl::MolDependent {

    public:

      static const std::string Name;

      static const std::string Desc;


      SiteFrac() : MolDependent(Name, Desc) {}


      // --- Required implementations -----------

      Eigen::VectorXd evaluate(const Configuration &config) const override;

      std::unique_ptr<SiteFrac> clone() const {
        return std::unique_ptr<SiteFrac>(this->_clone());
      }

    private:

      SiteFrac *_clone() const override {
        return new SiteFrac(*this);
      }

    };


    class AtomFrac : public ConfigIO_impl::MolDependent {

    public:

      static const std::string Name;

      static const std::string Desc;


      AtomFrac() : MolDependent(Name, Desc) {}


      // --- Required implementations -----------

      Eigen::VectorXd evaluate(const Configuration &config) const override;

      std::unique_ptr<AtomFrac> clone() const {
        return std::unique_ptr<AtomFrac>(this->_clone());
      }

    private:
      AtomFrac *_clone() const override {
        return new AtomFrac(*this);
      }

    };

    typedef AtomFrac SpeciesFrac;


    class MagBase : public ConfigIO_impl::MolDependent {
    /* class MagBase : public VectorXdAttribute<Configuration> { */

    public:

      static const std::string Name;

      static const std::string Desc;


      MagBase() : MolDependent(Name, Desc) {}

      // --- Required implementations -----------

      Eigen::VectorXd evaluate(const Configuration &config) const override;

      std::unique_ptr<MagBase> clone() const {
        return std::unique_ptr<MagBase>(this->_clone());
      }

      // --- Specialized implementation -----------

      bool validate(const Configuration &config) const override;

    private:

      MagBase *_clone() const override {
        return new MagBase(*this);
      }

    };


    class Corr : public VectorXdAttribute<Configuration> {

    public:

      static const std::string Name;

      static const std::string Desc;


      Corr() : VectorXdAttribute<Configuration>(Name, Desc), m_clex_name("") {}

      Corr(const Clexulator &clexulator) :
        VectorXdAttribute<Configuration>(Name, Desc),
        m_clexulator(clexulator) {}


      // --- Required implementations -----------

      Eigen::VectorXd evaluate(const Configuration &config) const override;

      std::unique_ptr<Corr> clone() const {
        return std::unique_ptr<Corr>(this->_clone());
      }


      // --- Specialized implementation -----------

      void init(const Configuration &_tmplt) const override;

      bool parse_args(const std::string &args) override;


    private:

      Corr *_clone() const override {
        return new Corr(*this);
      }

      mutable Clexulator m_clexulator;
      mutable std::string m_clex_name;

    };

    class Clex : public ScalarAttribute<Configuration> {

    public:

      static const std::string Name;

      static const std::string Desc;


      Clex();

      Clex(const Clexulator &clexulator, const ECIContainer &eci, const Norm<Configuration> &norm);


      // --- Required implementations -----------

      double evaluate(const Configuration &config) const override;

      std::unique_ptr<Clex> clone() const;


      // --- Specialized implementation -----------

      // validate: predicted property can always be calculated if clexulator and
      // eci were obtained ok

      void init(const Configuration &_tmplt) const override;

      bool parse_args(const std::string &args) override;

      std::string short_header(const Configuration &_tmplt) const override {
        return "clex(" + m_clex_name + ")";
      }

    private:

      double _norm(const Configuration &config) const;

      Clex *_clone() const override;

      mutable std::string m_clex_name;
      mutable Clexulator m_clexulator;
      mutable ECIContainer m_eci;
      mutable notstd::cloneable_ptr<Norm<Configuration> > m_norm;
    };

  }

  namespace ConfigIO {

    //void initialize_formatting_dictionary(DataFormatterDictionary<Configuration> &dict);


    ConfigIO::GenericConfigFormatter<std::string> configname();

    ConfigIO::GenericConfigFormatter<std::string> scelname();

    ConfigIO::GenericConfigFormatter<std::string> calc_status();

    ConfigIO::GenericConfigFormatter<std::string> failure_type();

    ConfigIO::GenericConfigFormatter<Index> scel_size();

    ConfigIO::GenericConfigFormatter<Index> multiplicity();

    ConfigIO::GenericConfigFormatter<std::string> subgroup_name();

    template<bool IsConst>
    ConfigIO::Selected selected_in(const ConfigSelection<IsConst> &_selection);

    ConfigIO::Selected selected_in();

    ConfigIO::GenericConfigFormatter<bool> is_calculated();

    ConfigIO::GenericConfigFormatter<bool> is_primitive();

    ConfigIO::GenericConfigFormatter<bool> is_canonical();

    ConfigIO::GenericConfigFormatter<double> relaxed_energy();

    ConfigIO::GenericConfigFormatter<double> relaxed_energy_per_species();

    ConfigIO::GenericConfigFormatter<double> reference_energy();

    ConfigIO::GenericConfigFormatter<double> reference_energy_per_species();

    ConfigIO::GenericConfigFormatter<double> formation_energy();

    ConfigIO::GenericConfigFormatter<double> formation_energy_per_species();

    Generic1DDatumFormatter<std::vector<double>, Configuration > relaxation_strain();

    ConfigIO::GenericConfigFormatter<double> rms_force();

    ConfigIO::GenericConfigFormatter<double> basis_deformation();

    ConfigIO::GenericConfigFormatter<double> lattice_deformation();

    ConfigIO::GenericConfigFormatter<double> volume_relaxation();

    ConfigIO::GenericConfigFormatter<double> relaxed_magmom();

    ConfigIO::GenericConfigFormatter<double> relaxed_magmom_per_species();

  }

  template<>
  StringAttributeDictionary<Configuration> make_string_dictionary<Configuration>();

  template<>
  BooleanAttributeDictionary<Configuration> make_boolean_dictionary<Configuration>();

  template<>
  IntegerAttributeDictionary<Configuration> make_integer_dictionary<Configuration>();

  template<>
  ScalarAttributeDictionary<Configuration> make_scalar_dictionary<Configuration>();

  template<>
  VectorXdAttributeDictionary<Configuration> make_vectorxd_dictionary<Configuration>();

}

#endif