DoFSet.hh

Go to the documentation of this file.

#ifndef CASM_DoFSet
#define CASM_DoFSet
 
#include <string>
#include <unordered_set>
#include <vector>
 
#include "casm/basis_set/DoF.hh"
 
namespace CASM {
 
class AnisoValTraits;
class DoFSet;
 
struct DoFSetInfo {
  DoFSetInfo(SymGroupRepID _id, Eigen::Ref<const Eigen::MatrixXd> const &_basis)
      : m_symrep_ID(_id), m_basis(_basis) {
    if (basis().cols() > 0 && basis().rows() > 0)
      m_inv_basis = basis()
                        .transpose()
                        .colPivHouseholderQr()
                        .solve(Eigen::MatrixXd::Identity(dim(), dim()))
                        .transpose();
  }
 
  SymGroupRepID const &symrep_ID() const { return m_symrep_ID; }
 
  void set_symrep_ID(SymGroupRepID _id) { m_symrep_ID = _id; }
 
  Eigen::MatrixXd const &basis() const { return m_basis; }
 
  Eigen::MatrixXd set_basis(Eigen::Ref<const Eigen::MatrixXd> const &_basis) {
    m_basis = _basis;
    if (basis().cols() > 0 && basis().rows() > 0)
      m_inv_basis = basis()
                        .transpose()
                        .colPivHouseholderQr()
                        .solve(Eigen::MatrixXd::Identity(dim(), dim()))
                        .transpose();
    return m_basis;
  }
 
  Eigen::MatrixXd const &inv_basis() const { return m_inv_basis; }
 
  Index dim() const { return basis().cols(); }
 
 private:
  SymGroupRepID m_symrep_ID;
  Eigen::MatrixXd m_basis;
  Eigen::MatrixXd m_inv_basis;
};
 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
class DoFSet {
 public:
  using BasicTraits = AnisoValTraits;
 
  using TypeFunc = std::function<notstd::cloneable_ptr<AnisoValTraits>()>;
 
  using Container = std::vector<ContinuousDoF>;
 
  using const_iterator = std::vector<ContinuousDoF>::const_iterator;
 
  static DoFSet make_default(AnisoValTraits const &_type);
 
  DoFSet(AnisoValTraits const &_type, std::vector<std::string> components,
         DoFSetInfo _info,
         std::unordered_set<std::string> excluded_occupants = {});
 
  Index size() const { return m_components.size(); }
 
  std::string const &type_name() const { return m_traits.name(); }
 
  AnisoValTraits const &traits() const { return m_traits; }
 
  void set_ID(Index _ID) {
    for (auto &c : m_components) c.set_ID(_ID);
  }
 
  void lock_IDs();
 
  void set_sequential_IDs();
 
  DoFSetInfo const &info() const { return m_info; }
 
  ContinuousDoF const &operator[](Index i) const { return m_components[i]; }
 
  const_iterator begin() const { return m_components.cbegin(); }
 
  const_iterator end() const { return m_components.cend(); }
 
  const_iterator cbegin() const { return m_components.cbegin(); }
 
  const_iterator cend() const { return m_components.cend(); }
 
  bool is_excluded_occ(std::string const &_occ_name) const {
    return m_excluded_occs.count(_occ_name);
  }
 
  Index dim() const { return m_info.dim(); }
 
  Eigen::MatrixXd const &basis() const { return m_info.basis(); }
 
  SymGroupRepID const &symrep_ID() const { return m_info.symrep_ID(); }
 
  bool identical(DoFSet const &rhs) const;
 
  void transform_basis(Eigen::Ref<const Eigen::MatrixXd> const &trans_mat);
 
  bool update_IDs(const std::vector<Index> &before_IDs,
                  const std::vector<Index> &after_IDs);
 
 private:
  BasicTraits m_traits;
 
  std::vector<ContinuousDoF> m_components;
 
  DoFSetInfo m_info;
 
  std::unordered_set<std::string> m_excluded_occs;
};
 
//********************************************************************
 
inline bool operator==(DoFSet const &A, DoFSet const &B) {
  return A.identical(B);
}
 
//********************************************************************
 
inline bool operator!=(DoFSet const &A, DoFSet const &B) {
  return !A.identical(B);
}
 
}  // namespace CASM
 
#endif