SupercellIO.hh

Go to the documentation of this file.

#ifndef CASM_SupercellIO
#define CASM_SupercellIO
 
#include "casm/casm_io/dataformatter/DataFormatter.hh"
#include "casm/casm_io/dataformatter/DataFormatterTools.hh"
 
namespace CASM {
class Supercell;
class SymOp;
 
namespace ScelIO {
 
// --- BaseDatumFormatter-derived classes ---
 
template <typename Base>
class SupercellCheckBase : public Base {
 public:
  typedef std::tuple<bool, SymOp, Eigen::MatrixXi> result_type;
 
  SupercellCheckBase(std::string name, std::string desc);
 
  // --- Specialized implementation -----------
 
  bool parse_args(const std::string &args) override;
 
  bool init(const Supercell &_tmplt) const override;
 
  std::vector<std::string> col_header(const Supercell &_tmplt) const override;
 
  // --- Shared logic -----------
 
  const result_type &_evaluate(const Supercell &scel,
                               const Supercell &unit) const;
 
 protected:
  std::string m_refcell_name;
 
  Supercell const &refcell() const;
 
 private:
  mutable const Supercell *m_refcell;
 
  mutable notstd::cloneable_ptr<result_type> m_last_result;
  mutable const Supercell *m_last_scel;
  mutable const Supercell *m_last_unit;
};
 
class IsSupercellOf : public SupercellCheckBase<BooleanAttribute<Supercell> > {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  IsSupercellOf();
 
  bool evaluate(const Supercell &scel) const override;
 
  std::unique_ptr<IsSupercellOf> clone() const;
 
 private:
  IsSupercellOf *_clone() const override;
};
 
class IsUnitcellOf : public SupercellCheckBase<BooleanAttribute<Supercell> > {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  IsUnitcellOf();
 
  bool evaluate(const Supercell &unit) const override;
 
  std::unique_ptr<IsUnitcellOf> clone() const;
 
 private:
  IsUnitcellOf *_clone() const override;
};
 
class TransfMat : public SupercellCheckBase<VectorXiAttribute<Supercell> > {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  TransfMat();
 
  Eigen::VectorXi evaluate(const Supercell &scel) const override;
 
  bool validate(const Supercell &scel) const override;
 
  std::unique_ptr<TransfMat> clone() const;
 
  bool parse_args(const std::string &args) override;
 
 private:
  TransfMat *_clone() const override;
};
 
class ConfigCountBase : public IntegerAttribute<Supercell> {
 public:
  ConfigCountBase(std::string name, std::string desc);
 
  // --- Specialized implementation -----------
 
  bool parse_args(const std::string &args) override;
 
  std::vector<std::string> col_header(const Supercell &_tmplt) const override;
 
 protected:
  std::string m_type;
};
 
class Nconfig : public ConfigCountBase {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  Nconfig();
 
  Index evaluate(const Supercell &scel) const override;
 
  std::unique_ptr<Nconfig> clone() const;
 
 private:
  Nconfig *_clone() const override;
};
 
class Ncalc : public ConfigCountBase {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  Ncalc();
 
  Index evaluate(const Supercell &scel) const override;
 
  std::unique_ptr<Ncalc> clone() const;
 
 private:
  Ncalc *_clone() const override;
};
 
class Ndata : public ConfigCountBase {
 public:
  static const std::string Name;
  static const std::string Desc;
 
  Ndata();
 
  Index evaluate(const Supercell &scel) const override;
 
  std::unique_ptr<Ndata> clone() const;
 
 private:
  Ndata *_clone() const override;
};
 
// --- GenericDatumFormatter generating functions ---
 
template <typename ValueType>
using GenericScelFormatter = GenericDatumFormatter<ValueType, Supercell>;
 
typedef Generic1DDatumFormatter<Eigen::VectorXd, Supercell>
    GenericVectorXdScelFormatter;
 
GenericScelFormatter<std::string> pointgroup_name();
GenericScelFormatter<Index> scel_size();
GenericScelFormatter<Index> multiplicity();
GenericScelFormatter<Index> factorgroup_size();
GenericScelFormatter<double> volume();
GenericVectorXdScelFormatter lattice();
GenericVectorXdScelFormatter lattice_params();
 
}  // namespace ScelIO
 
template <>
StringAttributeDictionary<Supercell> make_string_dictionary<Supercell>();
 
template <>
BooleanAttributeDictionary<Supercell> make_boolean_dictionary<Supercell>();
 
template <>
IntegerAttributeDictionary<Supercell> make_integer_dictionary<Supercell>();
 
template <>
ScalarAttributeDictionary<Supercell> make_scalar_dictionary<Supercell>();
 
template <>
VectorXiAttributeDictionary<Supercell> make_vectorxi_dictionary<Supercell>();
 
template <>
VectorXdAttributeDictionary<Supercell> make_vectorxd_dictionary<Supercell>();
 
}  // namespace CASM
 
#endif