PermuteIterator.hh

Go to the documentation of this file.

#ifndef PermuteIterator_HH
#define PermuteIterator_HH
 
#include <vector>
 
#include "casm/container/Permutation.hh"
#include "casm/misc/Comparisons.hh"
#include "casm/symmetry/SupercellSymInfo.hh"
#include "casm/symmetry/SymGroupRep.hh"
 
namespace CASM {
 
class PermuteIterator
    : public std::iterator<std::bidirectional_iterator_tag, PermuteIterator>,
      public Comparisons<CRTPBase<PermuteIterator>> {
  SupercellSymInfo const *m_sym_info;
 
  std::vector<Permutation> const *m_trans_permute;
 
  Index m_factor_group_index;
  Index m_translation_index;
 
 public:
  PermuteIterator();
 
  PermuteIterator(const PermuteIterator &iter);
 
  PermuteIterator(SupercellSymInfo const &_sym_info, Index _factor_group_index,
                  Index _translation_index);
 
  PermuteIterator &operator=(PermuteIterator iter);
 
  const PermuteIterator &operator*() const;
 
  const PermuteIterator *operator->() const;
 
  Permutation combined_permute() const;
 
  SymGroup const &factor_group() const;
 
  SupercellSymInfo const &sym_info() const;
 
  Index factor_group_index() const;
 
  Index prim_factor_group_index() const;
 
  Index translation_index() const;
 
  const Permutation &factor_group_permute() const;
 
  const Permutation &translation_permute() const;
 
  SymOpRepresentation const &occ_rep(Index b) const;
 
  SymOpRepresentation const &local_dof_rep(DoFKey const &_key, Index b) const;
 
  SymOpRepresentation const &global_dof_rep(DoFKey const &_key) const;
 
  SymOp sym_op() const;
 
  Index permute_ind(Index i) const;
 
  bool operator<(const PermuteIterator &iter) const;
 
  // prefix ++PermuteIterator
  PermuteIterator &operator++();
 
  // postfix PermuteIterator++
  PermuteIterator operator++(int);
 
  // prefix --PermuteIterator
  PermuteIterator &operator--();
 
  // postfix PermuteIterator--
  PermuteIterator operator--(int);
 
  PermuteIterator begin_next_fg_op() const;
 
  PermuteIterator inverse() const;
 
  PermuteIterator operator*(const PermuteIterator &RHS) const;
 
  friend void swap(PermuteIterator &a, PermuteIterator &b);
 
  bool is_compatible(const PermuteIterator &other_permute_iterator) const {
    return (&this->sym_info() == &other_permute_iterator->sym_info());
  }
 
 private:
  friend Comparisons<CRTPBase<PermuteIterator>>;
 
  bool eq_impl(const PermuteIterator &iter) const;
};
 
template <typename IterType>
IterType begin_next_fg_op(IterType it, IterType end) {
  Index tfg = it->factor_group_index();
  for (++it; it != end; ++it) {
    if (it->factor_group_index() != tfg) break;
  }
  return it;
}
 
template <typename PermuteIteratorContainer>
SymGroup make_point_group(const PermuteIteratorContainer &container,
                          const Lattice &supercell_lattice) {
  return make_point_group(container.begin(), container.end(),
                          supercell_lattice);
}
 
template <typename PermuteIteratorIt>
SymGroup make_point_group(PermuteIteratorIt begin, PermuteIteratorIt end,
                          const Lattice &supercell_lattice);
 
template <typename PermuteIteratorContainer>
SymGroup make_sym_group(const PermuteIteratorContainer &container,
                        const Lattice &supercell_lattice) {
  return make_sym_group(container.begin(), container.end(), supercell_lattice);
}
 
template <typename PermuteIteratorIt>
SymGroup make_sym_group(PermuteIteratorIt begin, PermuteIteratorIt end,
                        const Lattice &supercell_lattice);
 
template <typename PermuteIteratorContainer>
std::unique_ptr<SymGroup> make_unique_sym_group(
    const PermuteIteratorContainer &container,
    const Lattice &supercell_lattice) {
  return make_unique_sym_group(container.begin(), container.end(),
                               supercell_lattice);
}
 
template <typename PermuteIteratorIt>
std::unique_ptr<SymGroup> make_unique_sym_group(
    PermuteIteratorIt begin, PermuteIteratorIt end,
    const Lattice &supercell_lattice);
 
bool site_indices_are_invariant(PermuteIterator const &permute_it,
                                std::set<Index> const &site_indices);
 
jsonParser &to_json(const PermuteIterator &clust, jsonParser &json);
 
class SupercellSymInfo;
 
template <typename T>
struct jsonConstructor;
 
template <>
struct jsonConstructor<PermuteIterator> {
  static PermuteIterator from_json(const jsonParser &json,
                                   const SupercellSymInfo &scel_info);
};
 
namespace adapter {
 
template <typename ToType, typename FromType>
struct Adapter;
 
template <>
struct Adapter<SymOp, PermuteIterator> {
  SymOp operator()(PermuteIterator const &adaptable) const;
};
}  // namespace adapter
 
}  // namespace CASM
#endif