LatticeBindings.h

Go to the documentation of this file.

//
// Created by Nikhil Chandra Admal on 7/3/25.
//
 
#ifndef OILAB_LATTICE_BINDINGS_H
#define OILAB_LATTICE_BINDINGS_H
 
#include <pybind11/pybind11.h>
#include "../Lattices/LatticeModule.h"
#include <pybind11/stl.h>
namespace py = pybind11;
 
namespace pyoilab {
    template<int dim>
    void bind_Lattice(py::module_ &m) {
      using Lattice = oILAB::Lattice<dim>;
      using PyLatticeVector = PyLatticeVector<dim>;
      using PyReciprocalLatticeDirection = PyReciprocalLatticeDirection<dim>;
      using PyLatticeDirection = PyLatticeDirection<dim>;
      using LatticeVector = oILAB::LatticeVector<dim>;
 
      using MatrixDimD = Eigen::Matrix<double, dim, dim>;
      using VectorDimD = Eigen::Matrix<double, dim, 1>;
 
      py::class_<Lattice> cls(m,
                              ("Lattice" + std::to_string(dim) + "D").c_str());
      cls.def(py::init<const MatrixDimD &, const MatrixDimD &>(), py::arg("A"),
              py::arg("Q") = MatrixDimD::Identity())
          .def_readonly("latticeBasis", &Lattice::latticeBasis)
          .def_readonly("reciprocalBasis", &Lattice::reciprocalBasis)
          .def_readonly("F", &Lattice::F)
          .def("interPlanarSpacing",
               [](const Lattice &lattice,
                  const PyReciprocalLatticeDirection &pyrlv) {
                 return lattice.interPlanarSpacing(pyrlv.rld);
               })
          .def("latticeVector",
               [](const Lattice &lattice, const VectorDimD &p) {
                 return PyLatticeVector(lattice.latticeVector(p));
               })
          .def(
              "box",
              [](const Lattice &lattice,
                 const std::vector<PyLatticeVector> &boxPyLatticeVectors,
                 const std::string &filename) {
                std::vector<LatticeVector> boxLatticeVectors;
                for(const auto& v : boxPyLatticeVectors)
                  boxLatticeVectors.push_back(v.lv);
                auto latticeVectors= lattice.box(boxLatticeVectors,filename);
 
                std::vector<PyLatticeVector> pyLatticeVectors;
                for(const auto& v : latticeVectors)
                  pyLatticeVectors.push_back(PyLatticeVector(v));
                return pyLatticeVectors;
              },
              py::arg("boxVectors"), py::arg("filename") = "");
      if constexpr (dim == 3) {
        cls.def(
            "generateCoincidentLattices",
            [](const Lattice &lattice, const PyReciprocalLatticeDirection &rd,
               const double &maxDen, const int &N) {
              return lattice.generateCoincidentLattices(rd.rld, maxDen, N);
            },
            py::arg("rd"), py::arg("maxDen") = 100, py::arg("N") = 100);
        }
        if constexpr(dim==2) {
            cls.def("generateCoincidentLattices",
                 [](const Lattice& lattice, const double& maxStrain, const double& maxDen, const int& N) {
                     return lattice.generateCoincidentLattices(maxStrain, maxDen, N);
                 }, py::arg("maxStrain"),py::arg("maxDen") = 50, py::arg("N") = 30);
            cls.def("generateCoincidentLattices",
                    [](const Lattice& lattice, const Lattice& underformedLattice, const double& maxStrain, const double& maxDen, const int& N) {
                        return lattice.generateCoincidentLattices(underformedLattice, maxStrain, maxDen, N);
                    }, py::arg("undeformedLattice"), py::arg("maxStrain"),py::arg("maxDen") = 50, py::arg("N") = 30);
        }
        cls.def("latticeDirection",[](const Lattice& self, const VectorDimD& d, const double& tol){
            return PyLatticeDirection(self.latticeDirection(d,tol));
        }, py::arg("cartesianCoordinate"), py::arg("tol")=FLT_EPSILON);
        cls.def("reciprocalLatticeDirection",[](const Lattice& self, const VectorDimD& d, const double& tol){
            return PyReciprocalLatticeDirection(self.reciprocalLatticeDirection(d,tol));
        }, py::arg("cartesianCoordinate"), py::arg("tol")=FLT_EPSILON);
        cls.def("planeParallelLatticeBasis",[](const Lattice& self, const PyReciprocalLatticeDirection& l, const bool& useRLLL){
            auto latticeBasis2D= self.planeParallelLatticeBasis(l.rld, useRLLL);
            std::vector<PyLatticeDirection> pyLatticeBasis2D;
            for(const auto elem : latticeBasis2D)
                pyLatticeBasis2D.push_back(elem);
            return pyLatticeBasis2D;
        }, py::arg("reciprocalLatticeDirection"), py::arg("useRLLL")=false);
    }
}
#endif //OILAB_LATTICE_BINDINGS_H