HasCanonicalForm.hh

Go to the documentation of this file.

#ifndef CASM_HasCanonicalForm
#define CASM_HasCanonicalForm
 
#include <vector>
 
namespace CASM {
namespace xtal {
class Lattice;
}
 
class SymGroup;
class SymOp;
class PermuteIterator;
class Supercell;
 
template <typename Base>
class CanonicalForm : public Base {
 public:
  typedef typename Base::MostDerived MostDerived;
  using Base::derived;
 
  template <typename SymCompareType>
  bool is_canonical(const std::vector<SymOp> &g,
                    const SymCompareType &sym_compare) const;
 
  template <typename SymCompareType>
  MostDerived canonical_form(const std::vector<SymOp> &g,
                             const SymCompareType &sym_compare) const;
 
  template <typename SymCompareType>
  bool is_sym_equivalent(const MostDerived &other, const std::vector<SymOp> &g,
                         const SymCompareType &sym_compare) const;
 
  template <typename ObjIterator, typename SymCompareType>
  ObjIterator find_sym_equivalent(ObjIterator begin, ObjIterator end,
                                  const std::vector<SymOp> &g,
                                  const SymCompareType &sym_compare) const;
 
  template <typename SymCompareType>
  SymOp to_canonical(const std::vector<SymOp> &g,
                     const SymCompareType &sym_compare) const;
 
  template <typename SymCompareType>
  SymOp from_canonical(const std::vector<SymOp> &g,
                       const SymCompareType &sym_compare) const;
 
  template <typename SymCompareType>
  SymGroup invariant_subgroup(const SymGroup &super_grp,
                              const SymCompareType &sym_compare) const;
 
  bool is_canonical(const Supercell &scel) const;
 
  MostDerived canonical_form(const Supercell &scel) const;
 
  bool is_sym_equivalent(const MostDerived &B, const Supercell &scel) const;
 
  SymOp to_canonical(const Supercell &scel) const;
 
  SymOp from_canonical(const Supercell &scel) const;
 
  std::vector<PermuteIterator> invariant_subgroup(const Supercell &scel) const;
 
  template <typename PermuteIteratorIt>
  bool is_canonical(const Supercell &scel, PermuteIteratorIt begin,
                    PermuteIteratorIt end) const;
 
  template <typename PermuteIteratorIt>
  MostDerived canonical_form(const Supercell &scel, PermuteIteratorIt begin,
                             PermuteIteratorIt end) const;
 
  template <typename PermuteIteratorIt>
  bool is_sym_equivalent(const MostDerived &B, const Supercell &scel,
                         PermuteIteratorIt begin, PermuteIteratorIt end) const;
 
  template <typename ObjIterator, typename PermuteIteratorIt>
  ObjIterator find_sym_equivalent(ObjIterator obj_begin, ObjIterator obj_end,
                                  const Supercell &scel,
                                  PermuteIteratorIt begin,
                                  PermuteIteratorIt end) const;
 
  template <typename PermuteIteratorIt>
  SymOp to_canonical(const Supercell &scel, PermuteIteratorIt begin,
                     PermuteIteratorIt end) const;
 
  template <typename PermuteIteratorIt>
  SymOp from_canonical(const Supercell &scel, PermuteIteratorIt begin,
                       PermuteIteratorIt end) const;
 
  template <typename PermuteIteratorIt>
  std::vector<PermuteIterator> invariant_subgroup(const Supercell &scel,
                                                  PermuteIteratorIt begin,
                                                  PermuteIteratorIt end) const;
};
 
template <typename Base>
class ConfigCanonicalForm : public Base {
 public:
  typedef typename Base::MostDerived MostDerived;
  using Base::derived;
 
  bool is_sym_equivalent(const MostDerived &B) const;
 
  template <typename ConfigIterator>
  ConfigIterator find_sym_equivalent(const MostDerived &B,
                                     ConfigIterator obj_begin,
                                     ConfigIterator obj_end) const;
 
  bool is_canonical() const;
 
  MostDerived canonical_form() const;
 
  PermuteIterator to_canonical() const;
 
  PermuteIterator from_canonical() const;
 
  std::vector<PermuteIterator> invariant_subgroup() const;
 
  template <typename PermuteIteratorIt>
  bool is_sym_equivalent(const MostDerived &B, PermuteIteratorIt begin,
                         PermuteIteratorIt end) const;
 
  template <typename ConfigIterator, typename PermuteIteratorIt>
  ConfigIterator find_sym_equivalent(ConfigIterator obj_begin,
                                     ConfigIterator obj_end,
                                     PermuteIteratorIt begin,
                                     PermuteIteratorIt end) const;
 
  template <typename PermuteIteratorIt>
  bool is_canonical(PermuteIteratorIt begin, PermuteIteratorIt end) const;
 
  template <typename PermuteIteratorIt>
  MostDerived canonical_form(PermuteIteratorIt begin,
                             PermuteIteratorIt end) const;
 
  template <typename PermuteIteratorIt>
  PermuteIterator to_canonical(PermuteIteratorIt begin,
                               PermuteIteratorIt end) const;
 
  template <typename PermuteIteratorIt>
  PermuteIterator from_canonical(PermuteIteratorIt begin,
                                 PermuteIteratorIt end) const;
 
  template <typename PermuteIteratorIt>
  std::vector<PermuteIterator> invariant_subgroup(PermuteIteratorIt begin,
                                                  PermuteIteratorIt end) const;
 
  // --- Required in MostDerived:
 
  // Functor less() const;
  // const Supercell& supercell() const;
};
 
template <typename Base>
class SupercellCanonicalForm : public Base {
 public:
  using Base::derived;
 
  SupercellCanonicalForm() : m_canonical(nullptr) {}
 
  bool is_canonical() const;
 
  SymOp to_canonical() const;
 
  SymOp from_canonical() const;
 
  xtal::Lattice canonical_lattice() const;
 
  const Supercell &canonical_form() const;
 
  template <typename PermuteIteratorIt>
  std::vector<PermuteIterator> invariant_subgroup(const Supercell &scel_B,
                                                  PermuteIteratorIt begin,
                                                  PermuteIteratorIt end);
 
 private:
  mutable const Supercell *m_canonical;
};
 
}  // namespace CASM
 
#endif