Lattice.h

Go to the documentation of this file.

/* This file is part of gbLAB.
 *
 * gbLAB is distributed without any warranty under the MIT License.
 */
 
 
#ifndef gbLAB_Lattice_h_
#define gbLAB_Lattice_h_
 
#include "../Math/BestRationalApproximation.h"
#include "../Math/Farey.h"
#include "../Math/RLLL.h"
#include "../Math/Rational.h"
#include "../Math/RationalApproximations.h"
#include "../Utilities/StaticID.h"
#include "../Utilities/range.h"
#include "IntegerLattice.h"
#include "LatticeCore.h"
#include "LatticeModule.h"
#include <algorithm>
#include <fstream>
#include <map>
#include <unordered_map>
#include <vector>
 
namespace oILAB {
template <int dim> class Lattice : public StaticID<Lattice<dim>> {
  static constexpr double roundTol = FLT_EPSILON;
 
  using VectorDimD = typename LatticeCore<dim>::VectorDimD;
  using MatrixDimD = typename LatticeCore<dim>::MatrixDimD;
  using VectorDimI = typename LatticeCore<dim>::VectorDimI;
  using MatrixDimI = typename LatticeCore<dim>::MatrixDimI;
  using IntScalarType = typename LatticeCore<dim>::IntScalarType;
 
public:
  const MatrixDimD latticeBasis;
  const MatrixDimD reciprocalBasis;
  const MatrixDimD F;
 
  Lattice(const MatrixDimD &A, const MatrixDimD &Q = MatrixDimD::Identity());
 
  LatticeVector<dim> latticeVector(const VectorDimD &p) const;
 
  LatticeDirection<dim> latticeDirection(const VectorDimD &d,
                                         const double &tol = FLT_EPSILON) const;
 
  ReciprocalLatticeVector<dim>
  reciprocalLatticeVector(const VectorDimD &p) const;
 
  ReciprocalLatticeDirection<dim>
  reciprocalLatticeDirection(const VectorDimD &d,
                             const double &tol = FLT_EPSILON) const;
 
  std::vector<ReciprocalLatticeDirection<dim>>
  directionOrthogonalReciprocalLatticeBasis(const LatticeDirection<dim> &l,
                                            const bool &useRLLL = false) const;
 
  RationalLatticeDirection<dim> rationalLatticeDirection(
      const VectorDimD &d,
      const typename BestRationalApproximation::LongIntType &maxDen,
      const double &magnitudeTol,
      const double &directionTol = FLT_EPSILON) const;
  RationalReciprocalLatticeDirection<dim> rationalReciprocalLatticeDirection(
      const VectorDimD &d,
      const typename BestRationalApproximation::LongIntType &maxDen,
      const double &magnitudeTol,
      const double &directionTol = FLT_EPSILON) const;
 
  std::vector<LatticeDirection<dim>>
  planeParallelLatticeBasis(const ReciprocalLatticeDirection<dim> &l,
                            const bool &useRLLL = false) const;
 
  double interPlanarSpacing(const ReciprocalLatticeDirection<dim> &r) const;
 
  template <int dm = dim>
  typename std::enable_if<dm == 3, std::vector<MatrixDimD>>::type
  generateCoincidentLattices(const ReciprocalLatticeDirection<dim> &rd,
                             const double &maxDen = 100,
                             const int &N = 100) const;
 
  template <int dm = dim>
  typename std::enable_if<dm == 2, std::vector<MatrixDimD>>::type
  generateCoincidentLattices(const double &maxStrain, const int &maxDen = 50,
                             const int &N = 30) const;
 
  template <int dm = dim>
  typename std::enable_if<dm == 2, std::vector<MatrixDimD>>::type
  generateCoincidentLattices(const Lattice<dim> &undeformedLattice,
                             const double &maxStrain, const int &maxDen = 50,
                             const int &N = 30) const;
 
  template <int dm = dim>
  typename std::enable_if<dm == 3, std::vector<LatticeVector<dim>>>::type
  box(const std::vector<LatticeVector<dim>> &boxVectors,
      const std::string &filename = "") const;
 
  template <int dm = dim>
  typename std::enable_if<dm == 2, std::vector<LatticeVector<dim>>>::type
  box(const std::vector<LatticeVector<dim>> &boxVectors,
      const std::string &filename = "") const;
};
} // namespace oILAB
#endif