SymRepTools.hh

Go to the documentation of this file.

#ifndef CASM_SymRepTools
#define CASM_SymRepTools
 
#include <set>
 
#include "casm/container/multivector.hh"
#include "casm/external/Eigen/Core"
#include "casm/global/definitions.hh"
 
namespace CASM {
class SymGroupRep;
class SymGroupRepID;
class SymGroup;
 
namespace SymRepTools {
 
using Symmetrizer =
    std::pair<Eigen::MatrixXcd, multivector<Eigen::VectorXcd>::X<2>>;
 
using SymmetrizerFunction = std::function<Symmetrizer(
    Eigen::Ref<const Eigen::MatrixXcd> const &f_subspace)>;
 
struct IrrepInfo {
  template <typename Derived>
  static IrrepInfo make_dummy(Eigen::MatrixBase<Derived> const &_trans_mat) {
    Eigen::VectorXcd tchar(1);
    tchar[0] = std::complex<double>(double(_trans_mat.rows()), 0.);
    return IrrepInfo(_trans_mat.template cast<std::complex<double>>(), tchar);
  }
 
  IrrepInfo(Eigen::MatrixXcd _trans_mat, Eigen::VectorXcd _characters);
 
  Index irrep_dim() const { return trans_mat.rows(); }
 
  // Dimension of initial vector space (greater than or equal to irrep_dim())
  Index vector_dim() const { return trans_mat.cols(); }
 
  bool complex;
 
  bool pseudo_irrep;
 
  Index index;
 
  Eigen::MatrixXcd trans_mat;
 
  Eigen::VectorXcd characters;
 
  std::vector<std::vector<Eigen::VectorXd>> directions;
};
 
struct IrrepWedge {
  IrrepWedge(IrrepInfo _irrep_info, Eigen::MatrixXd _axes)
      : irrep_info(std::move(_irrep_info)), axes(std::move(_axes)) {}
 
  IrrepInfo irrep_info;
 
  Eigen::MatrixXd axes;
 
  std::vector<Index> mult;
 
  static IrrepWedge make_dummy(const Eigen::MatrixXd &axes);
};
 
class SubWedge {
 public:
  SubWedge(std::vector<IrrepWedge> const &_iwedges)
      : m_iwedges(_iwedges), m_trans_mat(_subwedge_to_trans_mat(m_iwedges)) {}
 
  std::vector<IrrepWedge> const &irrep_wedges() const { return m_iwedges; }
 
  Eigen::MatrixXd const &trans_mat() const { return m_trans_mat; }
 
  static SubWedge make_dummy(Eigen::MatrixXd const &axes);
 
 private:
  std::vector<IrrepWedge> m_iwedges;
  Eigen::MatrixXd m_trans_mat;
 
  static Eigen::MatrixXd _subwedge_to_trans_mat(
      std::vector<IrrepWedge> const &_iwedges);
};
 
std::vector<IrrepWedge> irrep_wedges(
    SymGroup const &head_group, SymGroupRepID id,
    Eigen::Ref<const Eigen::MatrixXd> const &_subspace);
 
std::vector<IrrepWedge> irrep_wedges(
    SymGroupRep const &_rep, SymGroup const &head_group,
    Eigen::Ref<const Eigen::MatrixXd> const &_subspace);
 
std::vector<SubWedge> symrep_subwedges(SymGroup const &_group,
                                       SymGroupRepID id);
 
std::vector<SubWedge> symrep_subwedges(
    SymGroup const &_group, SymGroupRepID id,
    Eigen::Ref<const Eigen::MatrixXd> const &_subspace);
 
std::vector<SubWedge> symrep_subwedges(SymGroupRep const &_rep,
                                       SymGroup const &head_group);
 
std::vector<SubWedge> symrep_subwedges(
    SymGroupRep const &_rep, SymGroup const &head_group,
    Eigen::Ref<const Eigen::MatrixXd> const &_subspace);
 
}  // namespace SymRepTools
 
struct VectorSpaceSymReport {
  std::vector<Eigen::MatrixXd> symgroup_rep;
 
  std::vector<SymRepTools::IrrepInfo> irreps;
 
  std::vector<SymRepTools::SubWedge> irreducible_wedge;
 
  Eigen::MatrixXd symmetry_adapted_dof_subspace;
 
  std::vector<std::string> axis_glossary;
};
 
VectorSpaceSymReport vector_space_sym_report(
    SymGroupRep const &_rep, SymGroup const &head_group,
    Eigen::Ref<const Eigen::MatrixXd> const &_subspace,
    bool calc_wedges = false);
 
multivector<Eigen::VectorXcd>::X<2> special_irrep_directions(
    SymGroupRep const &_rep, SymGroup const &head_group,
    double vec_compare_tol);
 
multivector<Eigen::VectorXcd>::X<2> special_irrep_directions(
    SymGroupRep const &_rep, SymGroup const &head_group,
    Eigen::Ref<const Eigen::MatrixXcd> const &_subspace, double vec_compare_tol,
    bool all_subgroups = false);
 
SymRepTools::Symmetrizer irrep_symmetrizer(SymGroupRep const &_rep,
                                           const SymGroup &head_group,
                                           double vec_compare_tol);
 
SymRepTools::Symmetrizer irrep_symmetrizer(
    SymGroupRep const &_rep, const SymGroup &head_group,
    Eigen::Ref<const Eigen::MatrixXcd> const &_subspace,
    double vec_compare_tol);
 
Index num_blocks(SymGroupRep const &_rep, const SymGroup &head_group);
 
Eigen::MatrixXd full_trans_mat(
    std::vector<SymRepTools::IrrepInfo> const &irreps);
 
multivector<Eigen::VectorXd>::X<3> special_total_directions(
    SymGroupRep const &_rep, const SymGroup &head_group);
 
std::vector<std::vector<Eigen::MatrixXd>> special_subspaces(
    SymGroupRep const &_rep, const SymGroup &head_group);
 
std::vector<SymGroupRepID> irrep_IDs(SymGroupRep const &_rep,
                                     const SymGroup &head_group);
 
bool is_irrep(SymGroupRep const &_rep, const SymGroup &head_group);
 
Eigen::MatrixXd irrep_trans_mat(SymGroupRep const &_rep,
                                const SymGroup &head_group);
 
std::pair<Eigen::MatrixXd, std::vector<Eigen::VectorXcd>>
irrep_trans_mat_and_characters(
    SymGroupRep const &_rep, const SymGroup &head_group,
    SymRepTools::SymmetrizerFunction symmetrizer_func);
 
std::vector<SymRepTools::IrrepInfo> irrep_decomposition(
    SymGroupRep const &_rep, SymGroup const &head_group, bool allow_complex);
 
std::vector<SymRepTools::IrrepInfo> irrep_decomposition(
    SymGroupRep const &_rep, SymGroup const &head_group,
    Eigen::Ref<const Eigen::MatrixXd> const &_subspace, bool allow_complex);
 
std::vector<SymRepTools::IrrepInfo> irrep_decomposition(
    SymGroupRep const &_rep, SymGroup const &head_group,
    SymRepTools::SymmetrizerFunction const &symmetrizer_func,
    bool allow_complex);
 
std::vector<SymRepTools::IrrepInfo> irrep_decomposition(
    SymGroupRep const &_rep, SymGroup const &head_group,
    SymRepTools::SymmetrizerFunction const &symmetrizer_func,
    Eigen::MatrixXd subspace, bool allow_complex);
 
//----- Operations involving representations without consideration of
//'head_group' ----
 
SymGroupRep subset_permutation_rep(const SymGroupRep &permute_rep,
                                   const std::vector<std::set<Index>> &subsets);
 
SymGroupRep permuted_direct_sum_rep(
    const SymGroupRep &permute_rep,
    const std::vector<SymGroupRep const *> &sum_reps);
 
SymGroupRep kron_rep(const SymGroupRep &LHS, const SymGroupRep &RHS);
 
}  // namespace CASM
#endif