AnisoValTraits.hh

Go to the documentation of this file.

#ifndef CASM_AnisoValTraits
#define CASM_AnisoValTraits
 
#include <memory>
#include <set>
#include <string>
#include <vector>
 
#include "casm/crystallography/SymRepBuilder.hh"
#include "casm/global/definitions.hh"
#include "casm/global/eigen.hh"
 
// Defines notstd::make_unique<>()
#include "casm/misc/ParsingDictionary.hh"
#include "casm/misc/cloneable_ptr.hh"
 
namespace CASM {
 
class AnisoValTraits;
 
template <>
ParsingDictionary<AnisoValTraits> make_parsing_dictionary<AnisoValTraits>();
 
class AnisoValTraits {
 public:
  static const unsigned char LOCAL = 0;
  static const unsigned char GLOBAL = (1u << 0);
  static const unsigned char UNIT_LENGTH = (1u << 1);
  static const unsigned char DESCRIBES_ORIENTATION = (1u << 2);
  static const unsigned char EXTENSIVE = (1u << 3);
 
  static AnisoValTraits null();
 
  static AnisoValTraits occ();
 
  static AnisoValTraits energy();
 
  static AnisoValTraits cost();
 
  static AnisoValTraits selective_dynamics();
 
  static AnisoValTraits disp();
 
  static AnisoValTraits coordinate();
 
  static AnisoValTraits latvec();
 
  static AnisoValTraits force();
 
  static AnisoValTraits isometry();
 
  static AnisoValTraits strain(std::string const &_metric);
 
  static AnisoValTraits SOmagspin();
 
  static AnisoValTraits SOunitmagspin();
 
  static AnisoValTraits NCmagspin();
 
  static AnisoValTraits NCunitmagspin();
 
  static AnisoValTraits Cmagspin();
 
  static AnisoValTraits Cunitmagspin();
 
  static AnisoValTraits d_orbital_occupation();
 
  static AnisoValTraits d_orbital_occupation_spin_polarized();
 
  static std::string name_suffix(std::string const &_name, char delim = '_') {
    std::string result;
    for (char c : _name) {
      if (c == delim)
        result.clear();
      else
        result.push_back(c);
    }
    return result;
  }
 
  AnisoValTraits(
      std::string const &_name, std::vector<std::string> const &_std_var_names,
      unsigned char _options,
      SymRepBuilderInterface const &_symrep_builder = NullSymRepBuilder(),
      std::set<std::string> const &_incompatible = {},
      std::set<std::string> const &_must_apply_before = {},
      std::set<std::string> const &_must_apply_after = {},
      std::vector<std::string> const &_variable_descriptions = {},
      bool _default = false);
 
  AnisoValTraits(std::string const &_name);
 
  static std::string class_desc() { return "AnisoValTraits"; }
 
  Eigen::MatrixXd symop_to_matrix(
      Eigen::Ref<const Eigen::Matrix3d> const &_matrix,
      Eigen::Ref<const Eigen::Vector3d> const &_tau, bool time_reversal) const {
    if (m_symrep_builder != nullptr) {
      return m_symrep_builder->symop_to_matrix(_matrix, _tau, time_reversal,
                                               dim());
    }
    // else
    return Eigen::MatrixXd::Identity(dim(), dim());
  }
 
  std::string const &name() const { return m_name; }
 
  bool is_default() const { return m_default; }
 
  unsigned char options() const { return m_opt; }
 
  bool extensive() const { return m_opt & EXTENSIVE; }
 
  // Please use !AnisoValTraits::global() instead of implementing
  // AnisoValTraits::local()
  // bool local()const {
  //  return !global();
  //}
 
  bool global() const { return m_opt & GLOBAL; }
 
  bool unit_length() const { return m_opt & UNIT_LENGTH; }
 
  bool time_reversal_active() const {
    return m_symrep_builder->time_reversal_active();
  }
 
  bool describes_occupant_orientation() const {
    return m_opt & DESCRIBES_ORIENTATION;
  }
 
  Index dim() const { return standard_var_names().size(); }
 
  bool operator==(std::string const &other_name) const {
    return name() == other_name;
  }
 
  bool operator<(std::string const &other_name) const {
    return name() < other_name;
  }
 
  operator std::string const &() const { return name(); }
 
  std::vector<std::string> const &standard_var_names() const {
    return m_standard_var_names;
  }
 
  std::vector<std::string> const &variable_descriptions() const {
    return m_variable_descriptions;
  }
 
  std::set<std::string> const &incompatible() const { return m_incompatible; }
 
  std::set<std::string> const &must_apply_before() const {
    return m_apply_before;
  }
 
  std::set<std::string> const &must_apply_after() const {
    return m_apply_after;
  }
 
  std::unique_ptr<AnisoValTraits> clone() const {
    return notstd::make_unique<AnisoValTraits>(*this);
  }
 
  std::string symrep_builder_name() const {
    if (m_symrep_builder)
      return m_symrep_builder->name();
    else
      return "NULL";
  }
 
 protected:
  std::string m_name;
  bool m_default;
  std::vector<std::string> m_standard_var_names;
  std::vector<std::string> m_variable_descriptions;
  unsigned char m_opt;
  notstd::cloneable_ptr<const SymRepBuilderInterface> m_symrep_builder;
  std::set<std::string> m_incompatible;
  std::set<std::string> m_apply_before;
  std::set<std::string> m_apply_after;
};
 
inline bool identical(AnisoValTraits const &A, AnisoValTraits const &B) {
  return (A.name() == B.name() && A.is_default() == B.is_default() &&
          A.symrep_builder_name() == B.symrep_builder_name() &&
          A.standard_var_names() == B.standard_var_names() &&
          A.options() == B.options() &&
          A.must_apply_before() == B.must_apply_before() &&
          A.must_apply_after() == B.must_apply_after() &&
          A.incompatible() == B.incompatible());
}
 
}  // namespace CASM
 
#endif