IrrepDecompositionImpl.hh

Go to the documentation of this file.

#ifndef CASM_symmetry_IrrepDecompositionImpl
#define CASM_symmetry_IrrepDecompositionImpl
 
#include "casm/symmetry/IrrepDecomposition.hh"
 
namespace CASM {
 
namespace SymRepTools_v2 {
 
namespace IrrepDecompositionImpl {
 
Eigen::MatrixXcd prettyc(const Eigen::MatrixXcd &M);
 
Eigen::MatrixXd pretty(const Eigen::MatrixXd &M);
 
// these methods are implementation details of IrrepDecomposition, they are
// included here for easier testing
 
Eigen::MatrixXd real_I(Index rows, Index cols);
 
Eigen::MatrixXd real_Zero(Index rows, Index cols);
 
Eigen::MatrixXcd complex_I(Index rows, Index cols);
 
Eigen::MatrixXcd complex_Zero(Index rows, Index cols);
 
struct CommuterParamsCounter {
  CommuterParamsCounter();
 
  void reset(Eigen::MatrixXcd const &kernel);
 
  bool valid() const;
 
  bool increment();
 
  Index kernel_column_i;
  Index kernel_column_j;
  std::complex<double> phase;
 
 private:
  bool m_valid;
  Index m_max_cols;
  Index m_phase_index;  // 0: 1+0i,  1: 0+i
};
 
Eigen::MatrixXcd make_commuter(CommuterParamsCounter const &params,
                               MatrixRep const &rep,
                               GroupIndices const &head_group,
                               Eigen::MatrixXcd const &kernel);
 
Eigen::MatrixXcd make_kernel(Eigen::MatrixXcd const &subspace);
Eigen::MatrixXd make_kernel(Eigen::MatrixXd const &subspace);
 
Index find_end_of_equal_eigenvalues(Index begin,
                                    Eigen::VectorXd const &eigenvalues);
 
Eigen::MatrixXcd make_irrep_subspace(Eigen::MatrixXcd const &KV_matrix,
                                     Index begin, Index end,
                                     bool allow_complex);
 
Eigen::VectorXcd make_characters(std::vector<Eigen::MatrixXcd> const &rep);
 
Eigen::VectorXd make_characters(std::vector<Eigen::MatrixXd> const &rep);
 
bool make_is_block_diagonal(std::vector<Eigen::MatrixXcd> const &rep,
                            Index begin, Index end, double tol);
 
Eigen::VectorXcd make_irrep_characters(std::vector<Eigen::MatrixXcd> const &rep,
                                       Index begin, Index end);
 
double make_squared_norm(Eigen::VectorXcd const &characters);
 
double make_squared_norm(Eigen::VectorXd const &characters);
 
std::complex<double> frobenius_product(Eigen::MatrixXcd const &matrix);
 
Eigen::MatrixXcd normalize_commuter(Eigen::MatrixXcd const &commuter);
 
bool is_extended_by(Eigen::MatrixXcd const &space_A,
                    Eigen::MatrixXcd const &space_B);
 
Eigen::MatrixXcd extend(Eigen::MatrixXcd const &space_A,
                        Eigen::MatrixXcd const &space_B);
 
Eigen::MatrixXd extend(Eigen::MatrixXd const &space_A,
                       Eigen::MatrixXd const &space_B);
 
struct PossibleIrrep {
  PossibleIrrep(Eigen::VectorXd const &eigenvalues,
                Eigen::MatrixXcd const &KV_matrix,
                std::vector<Eigen::MatrixXcd> const &transformed_rep,
                Index _head_group_size, double _tol, bool allow_complex,
                Index _begin, Index _end);
 
  Index head_group_size;
  double tol;
  Index begin;      
  Index end;        
  Index irrep_dim;  
  bool is_block_diagonal;
  Eigen::VectorXcd characters;
  double characters_squared_norm;
 
  bool is_irrep;
 
  Eigen::MatrixXcd subspace;
 
  bool is_identity() const;
 
  bool is_gerade() const;
 
  bool operator<(PossibleIrrep const &other) const;
};
 
std::vector<PossibleIrrep> make_possible_irreps(
    Eigen::MatrixXcd const &commuter, Eigen::MatrixXcd const &kernel,
    MatrixRep const &rep, GroupIndices const &head_group, bool allow_complex);
 
std::vector<IrrepInfo> make_irrep_info(std::set<PossibleIrrep> const &irreps);
 
IrrepInfo subspace_to_full_space(IrrepInfo const &subspace_irrep,
                                 Eigen::MatrixXd const &subspace);
 
IrrepInfo make_dummy_irrep_info(Eigen::MatrixXcd const &trans_mat);
 
bool is_irrep(MatrixRep const &rep, GroupIndices const &head_group);
 
std::vector<IrrepInfo> irrep_decomposition(MatrixRep const &rep,
                                           GroupIndices const &head_group,
                                           bool allow_complex);
 
std::vector<IrrepInfo> make_fullspace_irreps(
    std::vector<IrrepInfo> const &subspace_irreps,
    Eigen::MatrixXd const &subspace);
 
Eigen::MatrixXd make_invariant_space(MatrixRep const &rep,
                                     GroupIndices const &head_group,
                                     Eigen::MatrixXd const &subspace);
 
// Create `subspace_rep`, a transformed copy of `fullspace_rep` that acts
// on coordinates with `subspace` columns as a basis. Matrices in
// `subspace_rep` are shape (subspace.cols() x subspace.cols())
MatrixRep make_subspace_rep(MatrixRep const &fullspace_rep,
                            Eigen::MatrixXd const &subspace);
 
std::vector<IrrepInfo> symmetrize_irreps(
    MatrixRep const &subspace_rep, GroupIndices const &head_group,
    std::vector<IrrepInfo> const &irreps,
    GroupIndicesOrbitVector const &cyclic_subgroups,
    GroupIndicesOrbitVector const &all_subgroups);
 
}  // namespace IrrepDecompositionImpl
 
}  // namespace SymRepTools_v2
 
}  // namespace CASM
 
#endif