ConfigIO.hh

Go to the documentation of this file.

#ifndef CONFIGIO_HH
#define CONFIGIO_HH
 
#include "casm/casm_io/dataformatter/DataFormatter.hh"
#include "casm/casm_io/dataformatter/DataFormatterTools.hh"
#include "casm/clex/ClexParamPack.hh"
#include "casm/clex/Clexulator.hh"
#include "casm/clex/ECIContainer.hh"
#include "casm/container/ContainerTraits.hh"
 
namespace CASM {
 
 
class Configuration;
template <typename DataObject>
class Norm;
class jsonParser;
 
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;
 
  bool 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_impl
 
namespace ConfigIO {
 
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 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 -----------
 
  bool 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 CorrContribution : public VectorXdAttribute<Configuration> {
 public:
  static const std::string Name;
 
  static const std::string Desc;
 
  CorrContribution()
      : VectorXdAttribute<Configuration>(Name, Desc),
        m_linear_unitcell_index(0),
        m_clex_name("") {}
 
  CorrContribution(const Clexulator &clexulator)
      : VectorXdAttribute<Configuration>(Name, Desc),
        m_linear_unitcell_index(0),
        m_clexulator(clexulator) {}
 
  // --- Required implementations -----------
 
  Eigen::VectorXd evaluate(const Configuration &config) const override;
 
  std::unique_ptr<CorrContribution> clone() const {
    return std::unique_ptr<CorrContribution>(this->_clone());
  }
 
  // --- Specialized implementation -----------
 
  bool init(const Configuration &_tmplt) const override;
 
  bool parse_args(const std::string &args) override;
 
 private:
  CorrContribution *_clone() const override {
    return new CorrContribution(*this);
  }
 
  Index m_linear_unitcell_index;
  mutable Clexulator m_clexulator;
  mutable std::string m_clex_name;
};
 
class PointCorr : public VectorXdAttribute<Configuration> {
 public:
  static const std::string Name;
 
  static const std::string Desc;
 
  PointCorr()
      : VectorXdAttribute<Configuration>(Name, Desc),
        m_linear_unitcell_index(0),
        m_neighbor_index(0),
        m_clex_name("") {}
 
  PointCorr(const Clexulator &clexulator)
      : VectorXdAttribute<Configuration>(Name, Desc),
        m_linear_unitcell_index(0),
        m_neighbor_index(0),
        m_clexulator(clexulator) {}
 
  // --- Required implementations -----------
 
  Eigen::VectorXd evaluate(const Configuration &config) const override;
 
  std::unique_ptr<PointCorr> clone() const {
    return std::unique_ptr<PointCorr>(this->_clone());
  }
 
  // --- Specialized implementation -----------
 
  bool init(const Configuration &_tmplt) const override;
 
  bool parse_args(const std::string &args) override;
 
 private:
  PointCorr *_clone() const override { return new PointCorr(*this); }
 
  Index m_linear_unitcell_index;
  Index m_neighbor_index;
  mutable Clexulator m_clexulator;
  mutable std::string m_clex_name;
};
 
class GradCorr : public MatrixXdAttribute<Configuration> {
 public:
  static const std::string Name;
 
  static const std::string Desc;
 
  GradCorr() : MatrixXdAttribute<Configuration>(Name, Desc), m_clex_name("") {}
 
  GradCorr(const Clexulator &clexulator)
      : MatrixXdAttribute<Configuration>(Name, Desc),
        m_clexulator(clexulator) {}
 
  // --- Required implementations -----------
 
  Eigen::MatrixXd evaluate(const Configuration &config) const override;
 
  std::unique_ptr<GradCorr> clone() const {
    return std::unique_ptr<GradCorr>(this->_clone());
  }
 
  // --- Specialized implementation -----------
 
  bool init(const Configuration &_tmplt) const override;
 
  bool parse_args(const std::string &args) override;
 
 private:
  GradCorr *_clone() const override { return new GradCorr(*this); }
 
  mutable Clexulator m_clexulator;
  mutable std::string m_clex_name;
  mutable DoFKey m_key;
};
 
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
 
  bool 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
 
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<std::string> diff_trans_endpoint_of();
 
ConfigIO::GenericConfigFormatter<Index> scel_size();
 
ConfigIO::GenericConfigFormatter<Index> multiplicity();
 
ConfigIO::GenericConfigFormatter<std::string> point_group_name();
 
ConfigIO::GenericConfigFormatter<bool> is_calculated();
 
ConfigIO::GenericConfigFormatter<bool> is_primitive();
 
ConfigIO::GenericConfigFormatter<bool> is_canonical();
 
ConfigIO::GenericConfigFormatter<double> relaxed_energy();
 
ConfigIO::GenericConfigFormatter<double> energy();
 
ConfigIO::GenericConfigFormatter<double> relaxed_energy_per_species();
 
ConfigIO::GenericConfigFormatter<double> 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> atomic_deformation();
 
ConfigIO::GenericConfigFormatter<double> lattice_deformation();
 
ConfigIO::GenericConfigFormatter<double> volume_relaxation();
 
ConfigIO::GenericConfigFormatter<double> relaxed_magmom();
 
ConfigIO::GenericConfigFormatter<double> relaxed_magmom_per_species();
 
ConfigIO::GenericConfigFormatter<jsonParser> structure();
 
ConfigIO::GenericConfigFormatter<jsonParser> config();
 
ConfigIO::GenericConfigFormatter<jsonParser> properties();
 
ConfigIO::GenericConfigFormatter<std::string> poscar();
}  // namespace ConfigIO
 
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>();
 
template <>
MatrixXdAttributeDictionary<Configuration>
make_matrixxd_dictionary<Configuration>();
 
}  // namespace CASM
 
#endif