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 <IntegerLattice.h>
#include <LatticeModule.h>
#include <StaticID.h>
#include <BestRationalApproximation.h>
#include <vector>
#include <range.h>
#include <map>
#include <unordered_map>
#include "RLLL.h"
#include <Rational.h>
#include <Farey.h>
#include <RationalApproximations.h>
#include <algorithm>
#include <fstream>
 
 
namespace gbLAB
{
    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;
};
}
#endif