SymGroupRep.hh

Go to the documentation of this file.

#ifndef SYMGROUPREP_HH
#define SYMGROUPREP_HH
 
#include <iomanip>
#include <iostream>
#include <string>
 
#include "casm/container/multivector.hh"
#include "casm/misc/algorithm.hh"
#include "casm/symmetry/SymGroup.hh"
#include "casm/symmetry/SymOp.hh"
 
namespace CASM {
class SymGroupRep;
class MasterSymGroup;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
class SymGroupRepHandle;
 
class SymGroupRep : public std::vector<SymOpRepresentation *> {
 public:
  friend class SymGroup;
 
  typedef SymGroupRepHandle RemoteHandle;
 
  enum NullInitializer { NO_HOME };
 
  // No default construction allowed
  SymGroupRep() = delete;
 
  SymGroupRep(const SymGroup &_head, SymGroupRepID _rep_ID = SymGroupRepID())
      : m_rep_ID(_rep_ID), m_master_group(&_head.master_group()) {
    if (has_valid_master())
      resize(master_group().size(), nullptr);
    else {
      std::cerr << "WARNING: SymGroupRep initialized without valid "
                   "master_group!  Bad things may happen!\n";
      assert(0);
    }
  }
 
  SymGroupRep(SymGroupRep::NullInitializer init, Index _size)
      : std::vector<SymOpRepresentation *>(_size, nullptr),
        m_master_group(nullptr) {}
 
  SymGroupRep(const SymGroupRep &RHS);
 
  ~SymGroupRep();
 
  const MasterSymGroup &master_group() const {
    assert(m_master_group);
    return *m_master_group;
  }
 
  Index dim() const { return MatrixXd(0)->cols(); }
 
  bool has_valid_master() const { return m_master_group != nullptr; }
 
  void set_master_group(const MasterSymGroup &master,
                        const SymGroupRepID &_rep_ID);
 
  void set_rep(Index op_index, const SymOpRepresentation &new_rep);
 
  void set_rep(const SymOpRepresentation &base_rep,
               const SymOpRepresentation &new_rep);
 
  void set_rep(const SymOp &base_rep, const SymOpRepresentation &new_rep);
 
  SymGroupRep &operator=(const SymGroupRep &RHS);
 
  SymGroupRep *copy() const { return new SymGroupRep(*this); }
 
  Eigen::MatrixXd const *MatrixXd(Index i) const;
 
  Eigen::MatrixXd const *MatrixXd(const SymOpRepresentation &_op) const;
 
  Permutation const *permutation(Index i) const;
 
  Permutation const *permutation(const SymOpRepresentation &_op) const;
 
  SymGroupRepID symrep_ID() const { return m_rep_ID; }
 
 private:
  void clear();
 
  mutable SymGroupRepID m_rep_ID;
 
  MasterSymGroup const *m_master_group;
 
  using std::vector<SymOpRepresentation *>::push_back;
  using std::vector<SymOpRepresentation *>::resize;
 
  SymGroupRep(const MasterSymGroup *_home) : m_master_group(_home) {}
};
 
SymGroupRep coord_transformed_copy(SymGroupRep const &_rep,
                                   const Eigen::MatrixXd &trans_mat);
 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
class SymGroupRepHandle {  // <-- typedefed as SymGroupRep::RemoteHandle
 
  SymGroupRep const *m_group_rep;
 
  std::vector<Index> m_subgroup_op_inds;
 
 public:
  SymGroupRepHandle() : m_group_rep(nullptr) {}
 
  SymGroupRepHandle(const SymGroup &head_group, SymGroupRepID symrep_ID)
      : m_group_rep(nullptr), m_subgroup_op_inds(head_group.op_indices()) {
    if (head_group.size() == 0 || !head_group[0].has_valid_master()) {
      std::cerr << "CRITICAL ERROR: Requested representation of an improperly "
                   "initialized SymGroup.\n"
                << "                Exiting...\n";
      assert(0);
    }
    assert(!symrep_ID.empty());
    m_group_rep = &(head_group[0].master_group().representation(symrep_ID));
    assert(m_group_rep);
  }
 
  Index size() const { return m_subgroup_op_inds.size(); }
 
  SymGroupRepID symrep_ID() const { return rep_ptr()->symrep_ID(); }
 
  Index dim() const {
    return (m_group_rep->MatrixXd(m_subgroup_op_inds[0]))->cols();
  }
 
  bool empty() const { return m_group_rep == nullptr; }
 
  SymGroupRep const *rep_ptr() const { return m_group_rep; }
 
  SymGroupRep const *operator->() const { return rep_ptr(); }
 
  SymOpRepresentation const *operator[](Index i) const {
    return m_group_rep->at(m_subgroup_op_inds[i]);
  }
 
  bool operator==(const SymGroupRepHandle &RHS) const {
    return m_group_rep == RHS.m_group_rep &&
           m_subgroup_op_inds == RHS.m_subgroup_op_inds;
  }
 
  void set_rep(const SymGroup &head_group, SymGroupRepID symrep_ID) {
    m_subgroup_op_inds = head_group.op_indices();
    assert(head_group.size() && !symrep_ID.empty() &&
           head_group[0].has_valid_master());
    m_group_rep = &(head_group[0].master_group().representation(symrep_ID));
    assert(m_group_rep);
  }
};
 
}  // namespace CASM
 
#endif