SimpleOrbit.hh

Go to the documentation of this file.

#ifndef CASM_symmetry_SimpleOrbit
#define CASM_symmetry_SimpleOrbit
 
#include "casm/container/multivector.hh"
 
namespace CASM {
 
class SymOp;
class SymGroup;
 
template <typename _SymCompareType>
class SimpleOrbit {
 public:
  using size_type = unsigned int;
  using SymCompareType = _SymCompareType;
  using Element = typename _SymCompareType::Element;
  using InvariantsType = typename _SymCompareType::InvariantsType;
  using const_iterator = typename std::vector<Element>::const_iterator;
 
  template <typename GroupIterator>
  SimpleOrbit(typename SymCompareType::Element const &_generating_element,
              GroupIterator _group_begin, GroupIterator _group_end,
              SymCompareType const &_sym_compare);
 
  const_iterator begin() const { return m_element.cbegin(); }
 
  const_iterator end() const { return m_element.cend(); }
 
  const_iterator cbegin() const { return m_element.cbegin(); }
 
  const_iterator cend() const { return m_element.cend(); }
 
  size_type size() const { return m_element.size(); }
 
  Element const &prototype() const { return m_element[0]; }
 
  Element const &operator[](size_type index) const { return element(index); }
 
  Element const &element(size_type index) const { return m_element[index]; }
 
  std::vector<Element> const &elements() const { return m_element; }
 
  const multivector<SymOp>::X<2> &equivalence_map() const {
    throw std::runtime_error("No equivalence map for SimpleOrbit");
  }
 
  const SymGroup &generating_group() const {
    throw std::runtime_error("No generating group for SimpleOrbit");
  }
 
  SymCompareType const &sym_compare() const { return m_sym_compare; }
 
  InvariantsType const &invariants() const { return m_invariants; }
 
  bool operator<(const SimpleOrbit &B) const;
 
 private:
  SymCompareType m_sym_compare;
  InvariantsType m_invariants;
  std::vector<Element> m_element;
};
}  // namespace CASM
 
#endif