SuperlatticeEnumerator.hh

Go to the documentation of this file.

#ifndef SuperlatticeEnumerator_HH
#define SuperlatticeEnumerator_HH
 
#include "casm/crystallography/HermiteCounter.hh"
#include "casm/crystallography/Lattice.hh"
#include "casm/crystallography/SymType.hh"
#include "casm/external/Eigen/Dense"
#include "casm/misc/cloneable_ptr.hh"
 
// Including this file allows passing arbitrary
// symmetry types from the outside without requiring
// conversion.
#include "casm/crystallography/Adapter.hh"
 
namespace CASM {
namespace xtal {
 
class ScelEnumProps {
 public:
  typedef long size_type;
 
  ScelEnumProps(size_type begin_volume, size_type end_volume,
                std::string dirs = "abc",
                Eigen::Matrix3i generating_matrix = Eigen::Matrix3i::Identity())
      : m_begin_volume(begin_volume),
        m_end_volume(end_volume),
        m_dims(dirs.size()),
        m_dirs(dirs) {
    if (begin_volume < 1) {
      std::string msg = "Error constructing ScelEnumProps: begin_volume < 1";
      throw std::invalid_argument(msg);
    }
 
    for (int i = 0; i < m_dirs.size(); i++) {
      if (m_dirs[i] != 'a' && m_dirs[i] != 'b' && m_dirs[i] != 'c') {
        std::string msg =
            "Error constructing ScelEnumProps: an element of dirs != 'a', 'b', "
            "or 'c'";
        throw std::invalid_argument(msg);
      }
    }
 
    // add missing directions to 'dirs',
    // then permute 'G' so that the specified 'dirs' are first
    while (m_dirs.size() != 3) {
      if (std::find(m_dirs.begin(), m_dirs.end(), 'a') == m_dirs.end()) {
        m_dirs.push_back('a');
      }
      if (std::find(m_dirs.begin(), m_dirs.end(), 'b') == m_dirs.end()) {
        m_dirs.push_back('b');
      }
      if (std::find(m_dirs.begin(), m_dirs.end(), 'c') == m_dirs.end()) {
        m_dirs.push_back('c');
      }
    }
    Eigen::Matrix3i P = Eigen::Matrix3i::Zero();
    P(m_dirs[0] - 'a', 0) = 1;
    P(m_dirs[1] - 'a', 1) = 1;
    P(m_dirs[2] - 'a', 2) = 1;
 
    m_gen_mat = generating_matrix * P;
  }
 
  size_type begin_volume() const { return m_begin_volume; }
 
  size_type end_volume() const { return m_end_volume; }
 
  int dims() const { return m_dims; }
 
  std::string dirs() const { return m_dirs; }
 
  Eigen::Matrix3i generating_matrix() const { return m_gen_mat; }
 
 private:
  size_type m_begin_volume;
  size_type m_end_volume;
  int m_dims;
  std::string m_dirs;
  Eigen::Matrix3i m_gen_mat;
};
 
//******************************************************************************************************************//
 
class SuperlatticeEnumerator;
 
 
class SuperlatticeIterator {
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef std::forward_iterator_tag iterator_category;
  typedef int difference_type;
  typedef Lattice value_type;
  typedef const Lattice &reference;
  typedef const Lattice *pointer;
 
  SuperlatticeIterator() {}
 
  SuperlatticeIterator(const SuperlatticeEnumerator &enumerator, int volume,
                       int dims);
 
  // required for all iterators
  // SuperlatticeIterator<UnitType>(const SuperlatticeIterator<UnitType> &B);
 
  // required for all iterators?
  SuperlatticeIterator &operator=(const SuperlatticeIterator &B);
 
  bool operator==(const SuperlatticeIterator &B) const;
 
  bool operator!=(const SuperlatticeIterator &B) const;
 
  reference operator*() const;
 
  pointer operator->() const;
 
  Eigen::Matrix3i matrix() const;
 
  HermiteCounter::value_type volume() const;
 
  const SuperlatticeEnumerator &enumerator() const;
 
  SuperlatticeIterator &operator++();
 
  // SuperlatticeIterator<UnitType> operator++(int);  TODO
 
 private:
  void _increment();
 
  // bool _is_canonical() const;
 
  void _try_increment();
 
  void _update_super();
 
  mutable bool m_super_updated;
 
  const SuperlatticeEnumerator *m_enum;
 
  notstd::cloneable_ptr<HermiteCounter> m_current;
 
  mutable Lattice m_super;
 
  std::vector<Eigen::Matrix3i> m_canon_hist;
};
 
 
class SuperlatticeEnumerator {
 public:
  typedef long int size_type;
 
  typedef SuperlatticeIterator const_iterator;
 
  SuperlatticeEnumerator(const Lattice &unit, const SymOpVector &point_grp,
                         const ScelEnumProps &enum_props);
 
  template <typename ExternSymGroupTypeIt>
  SuperlatticeEnumerator(ExternSymGroupTypeIt begin, ExternSymGroupTypeIt end,
                         const Lattice &unit, const ScelEnumProps &enum_props)
      : SuperlatticeEnumerator(
            unit,
            adapter::Adapter<SymOpVector, ExternSymGroupTypeIt>()(begin, end),
            enum_props) {}
 
  const Lattice &unit() const;
 
  const SymOpVector &point_group() const;
 
  void begin_volume(size_type _begin_volume);
 
  size_type begin_volume() const;
 
  void end_volume(size_type _end_volume);
 
  size_type end_volume() const;
 
  const Eigen::Matrix3i &gen_mat() const;
 
  int dimension() const;
 
  const_iterator begin() const;
 
  const_iterator end() const;
 
  const_iterator cbegin() const;
 
  const_iterator cend() const;
 
  const_iterator citerator(size_type volume) const;
 
 private:
  const Lattice m_unit;
 
  /* Lattice m_lat; */
 
  SymOpVector m_point_group;
 
  const int m_begin_volume;
 
  const int m_end_volume;
 
  const Eigen::Matrix3i m_gen_mat;
 
  const int m_dims;
};
 
//********************************************************************************************************//
 
Eigen::Matrix3i enforce_min_volume(const Lattice &unit,
                                   const Eigen::Matrix3i &T,
                                   const SymOpVector &point_grp, Index volume,
                                   bool fix_shape = false);
 
template <typename ExternSymGroupTypeIt>
Eigen::Matrix3i enforce_min_volume(ExternSymGroupTypeIt begin,
                                   ExternSymGroupTypeIt end,
                                   const Lattice &unit,
                                   const Eigen::Matrix3i &T, Index volume,
                                   bool fix_shape = false) {
  return enforce_min_volume(
      unit, T,
      adapter::Adapter<SymOpVector, ExternSymGroupTypeIt>()(begin, end), volume,
      fix_shape);
}
 
//         that has a lattice ref_lat (not to be confused with the point group
//         of ref_lat itself).
Eigen::Matrix3i canonical_hnf(const Eigen::Matrix3i &T,
                              const SymOpVector &effective_pg,
                              const Lattice &ref_lattice);
template <typename ExternSymGroupTypeIt>
Eigen::Matrix3i canonical_hnf(ExternSymGroupTypeIt begin,
                              ExternSymGroupTypeIt end,
                              const Eigen::Matrix3i &T,
                              const Lattice &ref_lattice) {
  return canonical_hnf(
      T, adapter::Adapter<SymOpVector, ExternSymGroupTypeIt>()(begin, end),
      ref_lattice);
}
 
}  // namespace xtal
}  // namespace CASM
 
#endif