LinearIndexConverter.hh

Go to the documentation of this file.

#ifndef LINEARINDEXCONVERTER_HH
#define LINEARINDEXCONVERTER_HH
 
#include <unordered_map>
#include <vector>
 
#include "casm/crystallography/IntegralCoordinateWithin.hh"
#include "casm/crystallography/UnitCellCoord.hh"
 
namespace CASM {
namespace xtal {
 
class UnitCellCoordIndexConverter {
 public:
  typedef impl::OrderedLatticePointGenerator::matrix_type matrix_type;
 
  UnitCellCoordIndexConverter(const matrix_type &transformation_matrix,
                              int basis_sites_in_prim)
      : m_linear_index_to_bijk(_make_all_ordered_bijk_values(
            impl::OrderedLatticePointGenerator(transformation_matrix),
            basis_sites_in_prim)),
        m_basis_sites_in_prim(basis_sites_in_prim),
        m_automatically_bring_bijk_within(true),
        m_bring_within_f(transformation_matrix) {
    _throw_if_bad_basis_sites_in_prim(m_basis_sites_in_prim);
 
    for (Index ix = 0; ix < m_linear_index_to_bijk.size(); ++ix) {
      const auto &bijk = m_linear_index_to_bijk[ix];
      m_bijk_to_linear_index[bijk] = ix;
    }
 
    // By default the construction will always allow receiving bijk values that
    // fall outside of the superlattice
    this->always_bring_within();
  }
 
  void never_bring_within();
 
  void always_bring_within();
 
  UnitCellCoord bring_within(const UnitCellCoord &bijk) const;
 
  const UnitCellCoord &operator()(Index ix) const;
 
  Index operator()(const UnitCellCoord &bijk) const;
 
  Index total_sites() const { return m_linear_index_to_bijk.size(); }
 
 private:
  std::vector<UnitCellCoord> m_linear_index_to_bijk;
 
  std::unordered_map<UnitCellCoord, Index> m_bijk_to_linear_index;
 
  mutable std::unordered_map<UnitCellCoord, Index>
      m_bijk_to_linear_index_outside_of_superlattice;
 
  int m_basis_sites_in_prim;
 
  bool m_automatically_bring_bijk_within;
 
  IntegralCoordinateWithin_f m_bring_within_f;
 
  void _throw_if_incompatible_index(Index ix) const;
 
  void _throw_if_incompatible_bijk(const UnitCellCoord &bijk) const;
 
  static std::vector<UnitCellCoord> _make_all_ordered_bijk_values(
      const impl::OrderedLatticePointGenerator &make_point,
      int basis_sites_in_prim);
 
  static void _throw_if_bad_basis_sites_in_prim(int basis_sites_in_prim);
};
 
class UnitCellIndexConverter : UnitCellCoordIndexConverter {
 public:
  typedef UnitCellCoordIndexConverter::matrix_type matrix_type;
  UnitCellIndexConverter(const matrix_type &transformation_matrix)
      : UnitCellCoordIndexConverter(transformation_matrix, 1) {}
 
  using UnitCellCoordIndexConverter::always_bring_within;
  using UnitCellCoordIndexConverter::never_bring_within;
  using UnitCellCoordIndexConverter::total_sites;
 
  UnitCell bring_within(const UnitCell &ijk) const {
    return UnitCellCoordIndexConverter::bring_within(UnitCellCoord(0, ijk))
        .unitcell();
  }
 
  const UnitCell &operator()(Index ix) const {
    return UnitCellCoordIndexConverter::operator()(ix).unitcell();
  }
 
  Index operator()(const UnitCell &ijk) const {
    return UnitCellCoordIndexConverter::operator()(UnitCellCoord(0, ijk));
  }
 
 private:
  // TODO:
  // Secretly cache things to "speed things up" if you're *really* that
  // concerned about the UnitCellCoord copies slowing you down. Don't implement
  // this until you've profiled it.
};
 
template <typename IntegralCoordinateType>
struct _LinearIndexConverter {};
 
template <>
struct _LinearIndexConverter<UnitCell> {
  typedef UnitCellIndexConverter type;
};
 
template <>
struct _LinearIndexConverter<UnitCellCoord> {
  typedef UnitCellCoordIndexConverter type;
};
 
template <typename IntegralCoordinateType>
using LinearIndexConverter =
    typename _LinearIndexConverter<IntegralCoordinateType>::type;
 
}  // namespace xtal
}  // namespace CASM
 
#endif