SymOpRepresentation.hh

Go to the documentation of this file.

#ifndef SYMOPREPRESENTATION_HH
#define SYMOPREPRESENTATION_HH
 
#include <cmath>
#include <iostream>
#include <memory>
 
#include "casm/container/Array.hh"
#include "casm/global/definitions.hh"
#include "casm/global/eigen.hh"
#include "casm/symmetry/SymGroupRepID.hh"
 
namespace CASM {
namespace xtal {
class UnitCellCoord;
}
class MasterSymGroup;
class Permutation;
class SymBasisPermute;
 
class SymOpRepresentation {
 public:
  SymOpRepresentation() : m_master_group(nullptr), m_op_index(-1) {
    _set_integral_tau();
  }
 
  SymOpRepresentation(const MasterSymGroup &_master_group,
                      SymGroupRepID _rep_ID, Index _op_index)
      : SymOpRepresentation(&_master_group, _rep_ID, _op_index) {}
 
  virtual ~SymOpRepresentation() {}  // = 0;
 
  virtual SymOpRepresentation *copy() const = 0;
 
  virtual double character() const { return NAN; }
 
  virtual Permutation const *permutation() const { return nullptr; }
 
  virtual Eigen::MatrixXd const *MatrixXd() const { return nullptr; }
 
  virtual SymBasisPermute const *ucc_permutation() const { return nullptr; }
 
  std::unique_ptr<SymOpRepresentation> inverse() const;
 
  SymOpRepresentation const &representation(SymGroupRepID _rep_ID) const;
 
  Eigen::MatrixXd const *get_matrix_rep(SymGroupRepID _rep_ID) const;
 
  Permutation const *get_permutation_rep(SymGroupRepID _rep_ID) const;
 
  SymBasisPermute const *get_basis_permute_rep(SymGroupRepID _rep_ID) const;
 
  Array<Eigen::MatrixXd const *> get_matrix_reps(
      Array<SymGroupRepID> _rep_IDs) const;
 
  void set_rep(SymGroupRepID _rep_ID, const SymOpRepresentation &op_rep) const;
 
  void set_identifiers(const MasterSymGroup &new_group,
                       SymGroupRepID new_rep_ID);
 
  void set_identifiers(const MasterSymGroup &new_group,
                       SymGroupRepID new_rep_ID, Index new_op_index);
 
  const MasterSymGroup &master_group() const {
    assert(m_master_group);
    return *m_master_group;
  }
 
  bool has_valid_master() const { return m_master_group != nullptr; }
 
  void invalidate_index() { m_op_index = -1; }
 
  Index index() const { return m_op_index; }
 
  Index master_group_index() const { return m_op_index; }
 
  SymGroupRepID rep_ID() const { return m_rep_ID; }
 
  Index ind_inverse() const;
 
  Index ind_prod(const SymOpRepresentation &RHS) const;
 
 protected:
  SymOpRepresentation(MasterSymGroup const *_master_group_ptr,
                      SymGroupRepID _rep_ID, Index _op_index)
      : m_master_group(_master_group_ptr),
        m_rep_ID(_rep_ID),
        m_op_index(_op_index) {
    _set_integral_tau();
  }
 
  virtual SymOpRepresentation *inverse_impl() const {
    throw std::runtime_error(
        "Attempting to use unimplemented SymOpRepresentation::inverse_impl()");
    return nullptr;
  }
 
  virtual void _set_integral_tau() { return; }
 
  MasterSymGroup const *m_master_group;
 
  SymGroupRepID m_rep_ID;
 
  Index m_op_index;
};
 
struct SymRepIndexCompare {
  SymRepIndexCompare() {}
 
  bool operator()(const SymOpRepresentation &A,
                  const SymOpRepresentation &B) const {
    return A.index() < B.index();
  }
};
 
}  // namespace CASM
#endif