InvariantSubgroup_impl.hh

Go to the documentation of this file.

#ifndef CASM_InvariantSubgroup_impl
#define CASM_InvariantSubgroup_impl
 
#include "casm/symmetry/InvariantSubgroup.hh"
#include "casm/symmetry/PermuteIterator.hh"
#include "casm/symmetry/SymGroup.hh"
 
namespace CASM {
 
// using xtal::Coordinate;
 
template <typename Element, typename OpIterator, typename SymCompareType,
          typename OpOutputIterator>
OpOutputIterator make_invariant_subgroup(Element const &element,
                                         OpIterator group_begin,
                                         OpIterator group_end,
                                         SymCompareType const &sym_compare,
                                         OpOutputIterator result) {
  Element e{sym_compare.prepare(element)};
  for (auto group_it = group_begin; group_it != group_end; ++group_it) {
    if (sym_compare.equal(
            e, sym_compare.prepare(sym_compare.copy_apply(*group_it, e)))) {
      *result++ = sym_compare.spatial_transform() * (*group_it);
    }
  }
  return result;
}
 
template <typename Element, typename SymCompareType, typename OutputIterator>
OutputIterator make_invariant_subgroup(Element const &element,
                                       PermuteIterator permute_begin,
                                       PermuteIterator permute_end,
                                       SymCompareType const &sym_compare,
                                       OutputIterator result) {
  Element e{sym_compare.prepare(element)};
  for (auto permute_it = permute_begin; permute_it != permute_end;
       ++permute_it) {
    if (sym_compare.equal(e, sym_compare.prepare(sym_compare.copy_apply(
                                 permute_it->sym_op(), e)))) {
      *result++ = permute_it;
    }
  }
  return result;
}
 
template <typename Element, typename SymCompareType>
SymGroup make_invariant_subgroup(const Element &element,
                                 const SymGroup &generating_grp,
                                 const SymCompareType &sym_compare) {
  SymGroup result = generating_grp;
  result.clear();
  make_invariant_subgroup(element, generating_grp.begin(), generating_grp.end(),
                          sym_compare, std::back_inserter(result));
  if (result[0].index() != 0) {
    throw std::runtime_error(
        "Error in make_invariant_subgroup (0): First element is not identity.");
  }
  return result;
}
 
template <typename OrbitType>
SymGroup make_invariant_subgroup(const OrbitType &orbit, Index element_index) {
  SymGroup result;
  const auto &map = orbit.equivalence_map();
  result.set_lattice(map[0][0].master_group().lattice());
  for (Index i = 0; i < orbit.equivalence_map()[0].size(); ++i) {
    result.push_back(map[element_index][0] * map[0][i] *
                     map[element_index][0].inverse());
  }
  if (result[0].index() != 0) {
    throw std::runtime_error(
        "Error in make_invariant_subgroup (1): First element is not identity.");
  }
  return result;
}
 
}  // namespace CASM
 
#endif