Orbit.hh

Go to the documentation of this file.

#ifndef CASM_Orbit
#define CASM_Orbit
 
#include <boost/iterator/transform_iterator.hpp>
#include <vector>
 
#include "casm/container/multivector.hh"
#include "casm/misc/CASM_math.hh"
#include "casm/misc/Comparisons.hh"
#include "casm/symmetry/OrbitDecl.hh"
#include "casm/symmetry/SymGroup.hh"
#include "casm/symmetry/SymOp.hh"
 
namespace CASM {
class SymGroup;
 
// -- Orbit -------------------------------------
 
template <typename _SymCompareType>
class Orbit : public Comparisons<CRTPBase<Orbit<_SymCompareType>>> {
 public:
  using size_type = unsigned int;
  using Element = typename _SymCompareType::Element;
  using InvariantsType = typename _SymCompareType::InvariantsType;
  using SymCompareType = _SymCompareType;
  using const_iterator = typename std::vector<Element>::const_iterator;
  using const_symop_iterator = typename std::vector<SymOp>::const_iterator;
 
  Orbit(Element generating_element, SymGroup const &generating_group,
        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(); }
 
  const Element &prototype() const { return m_element[0]; }
 
  const Element &operator[](size_type index) const { return element(index); }
 
  const Element &element(size_type index) const { return m_element[index]; }
 
  const std::vector<Element> &elements() const { return m_element; }
 
  const multivector<SymOp>::X<2> &equivalence_map() const {
    return m_equivalence_map;
  }
 
  std::pair<const_symop_iterator, const_symop_iterator> equivalence_map(
      size_type index) const {
    return std::make_pair(m_equivalence_map[index].begin(),
                          m_equivalence_map[index].end());
  }
 
  SymGroupRepID canonization_rep_ID() const {
    if (m_canonization_rep_ID.empty()) _construct_canonization_rep();
    return m_canonization_rep_ID;
  }
 
  const_iterator find(const Element &e) const {
    return std::find_if(begin(), end(), [&](const Element &B) {
      return m_sym_compare.equal(e, m_sym_compare.prepare(B));
    });
  }
 
  bool contains(const Element &e) const { return this->find(e) != end(); }
 
  const SymGroup &generating_group() const { return m_generating_group; }
 
  const SymCompareType &sym_compare() const { return m_sym_compare; }
 
  InvariantsType const &invariants() const { return m_invariants; }
 
  Orbit &apply_sym(const SymOp &op);
 
  bool operator<(const Orbit &B) const;
 
 private:
  void _construct_canonization_rep() const;
 
  template <typename SymOpIterator>
  void _construct(Element generating_element, SymOpIterator begin,
                  SymOpIterator end);
 
  std::vector<Element> m_element;
 
  multivector<SymOp>::X<2> m_equivalence_map;
 
  SymGroup m_generating_group;
 
  mutable SymGroupRepID m_canonization_rep_ID;
 
  SymCompareType m_sym_compare;
 
  InvariantsType m_invariants;
};
 
template <typename GeneratorIterator, typename SymCompareType,
          typename OrbitOutputIterator>
OrbitOutputIterator make_orbits(GeneratorIterator gen_begin,
                                GeneratorIterator gen_end,
                                const SymGroup &generating_group,
                                const SymCompareType &sym_compare,
                                OrbitOutputIterator result) {
  using OrbitType = typename OrbitOutputIterator::container_type::value_type;
  for (; gen_begin != gen_end; ++gen_begin) {
    *(result++) = OrbitType(*gen_begin, generating_group, sym_compare);
  }
  return result;
}
 
// -- Orbit Helpers --------------------
 
template <typename OrbitIterator, typename Element>
OrbitIterator find_orbit(OrbitIterator begin, OrbitIterator end, Element e);
 
struct GetPrototype {
  template <typename OrbitType>
  typename OrbitType::Element const &operator()(const OrbitType &orbit) const {
    return orbit.prototype();
  }
};
 
template <typename OrbitIterator>
using PrototypeIterator =
    boost::transform_iterator<GetPrototype, OrbitIterator>;
 
template <typename OrbitIterator>
PrototypeIterator<OrbitIterator> prototype_iterator(OrbitIterator orbit_it) {
  return boost::make_transform_iterator(orbit_it, GetPrototype());
}
 
struct GetInvariants {
  template <typename OrbitType>
  typename OrbitType::InvariantsType const &operator()(
      const OrbitType &orbit) const {
    return orbit.invariants();
  }
};
 
template <typename OrbitIterator>
using InvariantsIterator =
    boost::transform_iterator<GetInvariants, OrbitIterator>;
 
template <typename OrbitIterator>
InvariantsIterator<OrbitIterator> invariants_iterator(OrbitIterator orbit_it) {
  return boost::make_transform_iterator(orbit_it, GetInvariants());
}
}  // namespace CASM
 
#endif