Lattice.hh

Go to the documentation of this file.

#ifndef LATTICE_HH
#define LATTICE_HH

#include <iostream>
#include <cmath>

#include "casm/misc/Comparisons.hh"
#include "casm/container/Array.hh"
#include "casm/container/LinearAlgebra.hh"
#include "casm/container/Counter.hh"

namespace CASM {
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  class SymGroup;
  class SymOp;
  class ScelEnumProps;

  class Lattice : public Comparisons<Lattice> {
  public:
    typedef Eigen::Matrix3d::ColXpr LatVec;
    typedef Eigen::Matrix3d::ConstColXpr ConstLatVec;

    Lattice(const Eigen::Vector3d &vec1, const Eigen::Vector3d &vec2,
            const Eigen::Vector3d &vec3);

    Lattice(const Eigen::Ref<const Eigen::Matrix3d> &lat_mat = Eigen::Matrix3d::Identity());

    static Lattice fcc();

    static Lattice bcc();

    static Lattice cubic();

    static Lattice hexagonal();

    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 vol()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;
    }

    Array<int> calc_kpoints(Array<int> prim_kpoints, Lattice prim_lat);

    Lattice get_reciprocal() const;

    void generate_point_group(SymGroup &point_group, double pg_tol = TOL) const;

    template<typename SymOpIterator, typename SymOpOutputIterator>
    SymOpOutputIterator find_invariant_subgroup(SymOpIterator begin, SymOpIterator end, SymOpOutputIterator result, double pg_tol = TOL) const;

    void find_invariant_subgroup(const SymGroup &super_group, SymGroup &sub_group, double pg_tol = TOL) const;


    bool is_canonical(double tol = TOL) const;

    bool is_canonical(const SymGroup &pg, double tol = TOL) const;

    SymOp to_canonical(double tol = TOL) const;

    SymOp to_canonical(const SymGroup &pg, double tol = TOL) const;

    SymOp from_canonical(double tol = TOL) const;

    SymOp from_canonical(const SymGroup &pg, double tol = TOL) const;

    Lattice canonical_form(double tol = TOL) const;

    Lattice canonical_form(const SymGroup &pg, double tol = TOL) const;


    void generate_supercells(Array<Lattice> &supercell, const SymGroup &effective_pg, const ScelEnumProps &enum_props) const;

    template <typename T>
    Lattice make_supercell(const Eigen::Matrix<T, 3, 3> &trans_mat) const;

    Lattice get_reduced_cell() 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;

    // ***This should live somewhere else
    template<typename CoordType, typename CoordType2>
    Array<CoordType> gridstruc_build(double max_radius, double min_radius, Array<CoordType> basis, CoordType2 lat_point);

    void read(std::istream &stream);
    void print(std::ostream &stream, int _prec = 8) const;

    bool is_equivalent(const Lattice &RHS, double tol) const;

    bool operator<(const Lattice &RHS) const;

    //Eigen::Matrix3d operator/(const Lattice &RHS);

    //John G 121212
    bool is_supercell_of(const Lattice &tile, Eigen::Matrix3d &multimat, double _tol = TOL) const;
    bool is_supercell_of(const Lattice &tile, const Array<SymOp> &symlist, Eigen::Matrix3d &multimat, double _tol = TOL) const;

    bool is_supercell_of(const Lattice &tile, double _tol = TOL) const;
    bool is_supercell_of(const Lattice &tile, const Array<SymOp> &symlist, double _tol = TOL) const;

    Lattice box(const Lattice &prim, const Lattice &scel, bool verbose = false) const;

    Lattice &make_right_handed();

    bool is_right_handed() const;

    Eigen::Vector3i get_millers(Eigen::Vector3d plane_normal, double tolerance = TOL) const;

    Lattice get_lattice_in_plane(Eigen::Vector3i millers, int max_vol = 20) const; //John G 121030

    Array<double> pg_converge(double large_tol);
    void pg_converge(double small_tol, double large_tol, double increment);

    void symmetrize(const SymGroup &relaxed_pg);

    void symmetrize(double _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;

    //int periodicity_dim;   //dimension of periodicity
    //int periodicity_axis;  //index of lattice vector that is non-periodic (2d) or periodic (1d)

  };


  // write Lattice in json as array of vectors
  jsonParser &to_json(const Lattice &lat, jsonParser &json);
  void from_json(Lattice &lat, const jsonParser &json);


  /* never write a Matrix*Lattice operator, PLEASE

     template <class T>
     Lattice operator*(const Matrix3<T> &LHS, const Lattice &RHS);

     Lattice operator*(const Eigen::Matrix3d &LHS, const Lattice &RHS);
  */

  double volume(const Lattice &lat);

  Lattice &apply(const SymOp &op, Lattice &lat);

  Lattice copy_apply(const SymOp &op, const Lattice &lat);

  Lattice make_supercell(const Lattice &lat, const Eigen::Matrix3i &transf_mat);

  std::pair<bool, Eigen::MatrixXi> is_supercell(const Lattice &scel, const Lattice &unit, double tol);

  template<typename Object, typename OpIterator>
  std::pair<OpIterator, Eigen::MatrixXi> is_supercell(
    const Object &scel,
    const Object &unit,
    OpIterator begin,
    OpIterator end,
    double tol);

  std::istream &operator>>(std::istream &in, const Lattice &lattice_in);

  Lattice superdupercell(const Lattice &lat1, const Lattice &lat2);

  template<typename LatIterator, typename SymOpIterator>
  Lattice superdupercell(LatIterator begin,
                         LatIterator end,
                         SymOpIterator op_begin = SymOpIterator(),
                         SymOpIterator op_end = SymOpIterator());

  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();
  }

  //********************************************************************
  // A column of trans_mat specifies a lattice vector of the supercell in terms of the
  // lattice vectors of (*this) lattice.
  template <typename T>
  Lattice Lattice::make_supercell(const Eigen::Matrix<T, 3, 3> &trans_mat) const {
    return Lattice(lat_column_mat() * trans_mat);
  }

  inline double volume(const Lattice &lat) {
    return lat.lat_column_mat().determinant();
  }

  inline Lattice make_supercell(const Lattice &lat, const Eigen::Matrix3i &transf_mat) {
    return Lattice(Eigen::Matrix3d(lat.lat_column_mat()) * transf_mat.cast<double>());
  }

}
#endif