Lattice.hh

Go to the documentation of this file.

#ifndef LATTICE_HH
#define LATTICE_HH
 
#include <cmath>
#include <iostream>
#include <type_traits>
#include <vector>
 
#include "casm/global/definitions.hh"
#include "casm/global/eigen.hh"
#include "casm/misc/Comparisons.hh"
 
namespace CASM {
 
namespace xtal {
 
class Lattice : public Comparisons<CRTPBase<Lattice>> {
 public:
  typedef Eigen::Matrix3d::ColXpr LatVec;
  typedef Eigen::Matrix3d::ConstColXpr ConstLatVec;
 
  Lattice(Eigen::Ref<const Eigen::Vector3d> const &vec1,
          Eigen::Ref<const Eigen::Vector3d> const &vec2,
          Eigen::Ref<const Eigen::Vector3d> const &vec3, double xtal_tol = TOL,
          bool force = false);
 
  Lattice(Eigen::Ref<const Eigen::Matrix3d> const &lat_mat =
              Eigen::Matrix3d::Identity(),
          double xtal_tol = TOL, bool force = false);
 
  static Lattice fcc(double tol = TOL);
 
  static Lattice bcc(double tol = TOL);
 
  static Lattice cubic(double tol = TOL);
 
  static Lattice hexagonal(double tol = TOL);
 
  static std::vector<Eigen::Matrix3d> const &skew_transforms();
 
  LatVec operator[](Index i) { return m_lat_mat.col(i); }
 
  ConstLatVec operator[](Index i) const { return m_lat_mat.col(i); }
 
  std::tuple<LatVec, LatVec, LatVec> vectors() {
    return std::make_tuple(m_lat_mat.col(0), m_lat_mat.col(1),
                           m_lat_mat.col(2));
  }
 
  std::tuple<ConstLatVec, ConstLatVec, ConstLatVec> vectors() const {
    return std::make_tuple(m_lat_mat.col(0), m_lat_mat.col(1),
                           m_lat_mat.col(2));
  }
 
  Lattice scaled_lattice(double scale) const;
 
  double angle(Index i) const;
 
  double length(Index i) const;
 
  double volume() const { return lat_column_mat().determinant(); }
 
  Eigen::MatrixXd const &voronoi_table() const {
    if (!m_voronoi_table.size()) {
      _generate_voronoi_table();
    }
    return m_voronoi_table;
  }
 
  double inner_voronoi_radius() const {
    voronoi_table();
    return m_inner_voronoi_radius;
  }
 
  const Eigen::Matrix3d &lat_column_mat() const { return m_lat_mat; }
 
  const Eigen::Matrix3d &inv_lat_column_mat() const { return m_inv_lat_mat; }
 
  std::vector<int> calc_kpoints(std::vector<int> prim_kpoints,
                                Lattice prim_lat);
 
  Lattice reciprocal() const;
 
  double boxiness() const;
 
  Lattice reduced_cell() const;
 
  Lattice reduced_cell2() const;
 
  void print_voronoi_table(std::ostream &stream) const;
 
  double min_voronoi_radius() const;
 
  double max_voronoi_measure(const Eigen::Vector3d &pos,
                             Eigen::Vector3d &lattice_trans) const;
 
  int voronoi_number(const Eigen::Vector3d &pos) const;
 
  Eigen::Vector3i enclose_sphere(double radius) const;
 
  // TODO: Extract
  void read(std::istream &stream);
  // TODO: Extract
  void print(std::ostream &stream, int _prec = 8) const;
 
  bool operator<(const Lattice &RHS) const;
 
  Lattice box(const Lattice &prim, const Lattice &scel,
              bool verbose = false) const;
 
  Lattice &make_right_handed();
 
  bool is_right_handed() const;
 
  Eigen::Vector3i millers(Eigen::Vector3d plane_normal) const;
 
  Lattice lattice_in_plane(Eigen::Vector3i millers,
                           int max_vol = 0) const;  // John G 121030
 
  double tol() const { return m_tol; }
 
  void set_tol(double _tol) { m_tol = _tol; }
 
 private:
  friend Comparisons<Lattice>;
 
  bool _eq(const Lattice &RHS) const;
 
  void _generate_voronoi_table() const;
 
  mutable double m_inner_voronoi_radius;
  mutable Eigen::MatrixXd m_voronoi_table;
 
  // Coordinate Conversion Matrices
  // 0 is fractional to cartesion; 1 is cartesian to fractional
  // use FRAC and CART globals to index
  // e.g., coord[CART]=coord_trans[FRAC]*coord[FRAC]; //converts frac to cart
  // Word to the wise: coord_trans[FRAC] is the matrix with columns equal to the
  // lattice vectors
  Eigen::Matrix3d m_lat_mat, m_inv_lat_mat;
 
  double m_tol;
};
 
double volume(const Lattice &lat);
 
std::pair<bool, Eigen::Matrix3d> is_superlattice(const Lattice &scel,
                                                 const Lattice &unit,
                                                 double tol);
 
std::istream &operator>>(std::istream &in, const Lattice &lattice_in);
 
Lattice make_superduperlattice(const Lattice &lat1, const Lattice &lat2);
 
Lattice replace_vector(const Lattice &lat, const Eigen::Vector3d &new_vector,
                       double tol);
 
inline Eigen::Matrix3d cart2frac(
    const Eigen::Ref<const Eigen::Matrix3d> &cart_mat, const Lattice &lat) {
  return lat.inv_lat_column_mat() * cart_mat * lat.lat_column_mat();
}
 
inline Eigen::Matrix3d frac2cart(
    const Eigen::Ref<const Eigen::Matrix3d> &frac_mat, const Lattice &lat) {
  return lat.lat_column_mat() * frac_mat * lat.inv_lat_column_mat();
}
 
inline double volume(const Lattice &lat) {
  return lat.lat_column_mat().determinant();
}
 
template <typename IntegralType, int Options = 0>
Lattice make_superlattice(
    const Lattice &lat,
    const Eigen::Matrix<IntegralType, 3, 3, Options> &transf_mat) {
  // TODO: Do this in more places that involve transformation matrices
  static_assert(std::is_integral<IntegralType>::value,
                "Transfomration matrix must be integer matrix");
  return Lattice(Eigen::Matrix3d(lat.lat_column_mat()) *
                     transf_mat.template cast<double>(),
                 lat.tol());
}
 
Eigen::Matrix3l make_transformation_matrix_to_super(const Lattice &tiling_unit,
                                                    const Lattice &superlattice,
                                                    double tol);
 
}  // namespace xtal
}  // namespace CASM
#endif