DoFSet.hh

Go to the documentation of this file.

#ifndef CASM_XTAL_DOFSET
#define CASM_XTAL_DOFSET
 
#include <map>
#include <unordered_set>
#include <vector>
 
#include "casm/crystallography/AnisoValTraits.hh"
#include "casm/external/Eigen/Core"
 
namespace CASM {
namespace xtal {
struct SymOp;
 
class DoFSet {
 public:
  using BasicTraits = AnisoValTraits;
 
  DoFSet(const BasicTraits &init_traits,
         const std::vector<std::string> &init_component_names,
         const Eigen::MatrixXd &init_basis)
      : m_traits(init_traits),
        m_component_names(init_component_names),
        m_basis(init_basis) {
    assert(m_component_names.size() == this->dim());
    assert(m_basis.cols() == this->dim());
    assert(m_basis.rows() ==
           this->traits().dim());  // TODO: This makes sense I think?
  }
 
  DoFSet(const BasicTraits &init_traits)
      : DoFSet(
            init_traits, init_traits.standard_var_names(),
            Eigen::MatrixXd::Identity(init_traits.dim(), init_traits.dim())) {}
 
  const std::string &type_name() const { return m_traits.name(); }
 
  const std::vector<std::string> &component_names() const {
    return this->m_component_names;
  }
 
  BasicTraits const &traits() const { return m_traits; }
 
  Index dim() const { return this->basis().cols(); }
 
  Eigen::MatrixXd const &basis() const { return m_basis; }
 
 private:
  BasicTraits m_traits;
 
  std::vector<std::string> m_component_names;
 
  Eigen::MatrixXd m_basis;
};
 
std::vector<std::string> component_descriptions(DoFSet const &dofset);
 
class SiteDoFSet : public DoFSet {
 public:
  SiteDoFSet(const DoFSet &init_dofset,
             const std::unordered_set<std::string> &init_exclude_occs)
      : DoFSet(init_dofset), m_excluded_occs(init_exclude_occs) {}
 
  SiteDoFSet(const DoFSet &init_dofset) : DoFSet(init_dofset) {}
 
  SiteDoFSet(const BasicTraits &init_traits,
             const std::vector<std::string> &init_component_names,
             const Eigen::MatrixXd &init_basis,
             const std::unordered_set<std::string> &init_exclude_occs)
      : SiteDoFSet(DoFSet(init_traits, init_component_names, init_basis),
                   init_exclude_occs) {}
 
  SiteDoFSet(const BasicTraits &init_traits,
             const std::unordered_set<std::string> &init_exclude_occs = {})
      : SiteDoFSet(DoFSet(init_traits), init_exclude_occs) {}
 
  bool is_excluded_occ(std::string const &_occ_name) const {
    return m_excluded_occs.count(_occ_name);
  }
 
  const std::unordered_set<std::string> &excluded_occupants() const {
    return this->m_excluded_occs;
  }
 
 private:
  std::unordered_set<std::string> m_excluded_occs;
};
 
template <typename DoFSetType>
std::map<std::string, DoFSetType> make_dofset_map(
    std::vector<DoFSetType> const &dofset_vec) {
  std::map<std::string, DoFSetType> dofset_map;
  for (auto const &dofset : dofset_vec) {
    dofset_map.emplace(dofset.type_name(), dofset);
  }
  return dofset_map;
}
 
struct DoFSetIsEquivalent_f {
 public:
  DoFSetIsEquivalent_f(const DoFSet &reference_value, double tol)
      : m_reference_dofset(reference_value), m_tol(tol) {}
 
  bool operator()(const DoFSet &other_value) const;
 
 private:
  DoFSet m_reference_dofset;
 
  double m_tol;
 
  bool _traits_match(const DoFSet &other_value) const;
 
  bool _basis_spans_same_space(const DoFSet &other_value) const;
};
 
struct SiteDoFSetIsEquivalent_f : private DoFSetIsEquivalent_f {
  SiteDoFSetIsEquivalent_f(const SiteDoFSet &reference_value, double tol)
      : DoFSetIsEquivalent_f(reference_value, tol),
        m_reference_excluded_occs(reference_value.excluded_occupants()) {}
 
  bool operator()(const SiteDoFSet &other_value) const {
    return DoFSetIsEquivalent_f::operator()(other_value) &&
           this->_excluded_occupants_match(other_value);
  }
 
 private:
  std::unordered_set<std::string> m_reference_excluded_occs;
 
  bool _excluded_occupants_match(const SiteDoFSet &other_value) const {
    return this->m_reference_excluded_occs == other_value.excluded_occupants();
  }
};
 
Eigen::MatrixXd dofset_transformation_matrix(const Eigen::MatrixXd &from_basis,
                                             const Eigen::MatrixXd &to_basis,
                                             double tol);
 
}  // namespace xtal
}  // namespace CASM
 
namespace CASM {
// This is how it's currently organized for xtal::Lattice, but maybe we want
// something else  (see SymTools.hh)
namespace sym {
xtal::DoFSet copy_apply(const xtal::SymOp &op, const xtal::DoFSet &_dof);
}  // namespace sym
}  // namespace CASM
 
#endif