emerge 0.4.6__py3-none-any.whl → 0.4.8__py3-none-any.whl

emerge/_emerge/elements/femdata.py

@@ -0,0 +1,212 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see
+# <https://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+from ..mesh3d import Mesh3D
+import numpy as np
+from typing import Callable
+from scipy.sparse import coo_matrix, csr_matrix
+
+from ..mth.optimized import matmul
+
+class FEMBasis:
+
+    def __init__(self, mesh: Mesh3D):
+        self.mesh: Mesh3D = mesh
+        self.n_edges: int = self.mesh.n_edges
+        self.n_tris: int = self.mesh.n_tris
+        self.n_tets: int = self.mesh.n_tets
+
+        self.n_tet_dofs: int = None
+        self.n_tri_dofs: int = None
+
+        self.n_field: int = 2*self.n_edges + 2*self.n_tris
+
+        self.tet_to_field: np.ndarray = None
+        
+        self.edge_to_field: np.ndarray = None
+
+        self.tri_to_field: np.ndarray = None
+
+        self._rows: np.ndarray = None
+        self._cols: np.ndarray = None
+        
+    
+    def interpolate_Ef(self, field: np.ndarray, basis: np.ndarray = None, origin: np.ndarray = None, tetids: np.ndarray = None) -> Callable:
+        '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
+        if basis is None:
+            basis = np.eye(3)
+
+        if origin is None:
+            origin = np.zeros(3)
+        
+        ibasis = np.linalg.pinv(basis)
+        def func(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
+            xyz = np.array([xs, ys, zs]) + origin[:, np.newaxis]
+            xyzg = matmul(basis, xyz)
+            return matmul(ibasis, np.array(self.interpolate(field, xyzg[0,:], xyzg[1,:], xyzg[2,:], tetids)))
+        return func
+    
+    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, tetids: np.ndarray = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        pass
+    
+    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, constants: np.ndarray, tetids: np.ndarray = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Interpolates the curl of the field at the given points.
+        """
+        pass
+    
+    def empty_tet_matrix(self) -> np.ndarray:
+        nnz = self.n_tets*self.n_tet_dofs**2
+        matrix = np.empty((nnz,), dtype=np.complex128)
+        return matrix
+    
+    def empty_tri_matrix(self) -> np.ndarray:
+        nnz = self.n_tris*self.n_tri_dofs**2
+        matrix = np.zeros((nnz,), dtype=np.complex128)
+        return matrix
+     
+    def empty_tet_rowcol(self) -> tuple[np.ndarray, np.ndarray]:
+        N = self.n_tet_dofs
+        N2 = N**2
+        nnz = self.n_tets*N2
+        rows = np.empty(nnz, dtype=np.int64)
+        cols = np.empty(nnz, dtype=np.int64)
+
+        for itet in range(self.n_tets):
+            p = itet*N2
+            
+            indices = self.tet_to_field[:, itet]
+            for ii in range(self.n_tet_dofs):
+                rows[p+N*ii:p+N*(ii+1)] = indices[ii]
+                cols[p+ii:p+N2:N] = indices[ii]
+        self._rows = rows
+        self._cols = cols 
+        return rows, cols
+    
+    def empty_tri_rowcol(self) -> tuple[np.ndarray, np.ndarray]:
+        N = self.n_tri_dofs
+        N2 = N**2
+        nnz = self.n_tris*N2
+        rows = np.empty(nnz, dtype=np.int64)
+        cols = np.empty(nnz, dtype=np.int64)
+
+        for itri in range(self.n_tris):
+            p = itri*N2
+            indices = self.tri_to_field[:, itri]
+            for ii in range(N):
+                rows[p+N*ii:p+N*(ii+1)] = indices[ii]
+                cols[p+ii:p+N2:N] = indices[ii]
+
+        self._rows = rows
+        self._cols = cols
+        return rows, cols
+
+    def tetslice(self, itet: int) -> slice:
+        N = self.n_tet_dofs**2
+        return slice(itet*N,(itet+1)*N)
+    
+    def trislice(self, itri: int) -> slice:
+        N = self.n_tri_dofs**2
+        return slice(itri*N,(itri+1)*N)
+    
+    def generate_csr(self, data: np.ndarray) -> csr_matrix:
+        ids = np.argwhere(data!=0)[:,0]
+        return csr_matrix((data[ids], (self._rows[ids], self._cols[ids])), shape=(self.n_field, self.n_field))
+    ### QUANTITIES
+
+    def tet_to_edge_lengths(self, itet: int) -> np.ndarray:
+        """
+        Returns the edge lengths of the tetrahedron itet.
+        """
+        return self.mesh.edge_lengths[self.mesh.tet_to_edge[:,itet]]
+    
+    def tri_to_edge_lengths(self, itri: int) -> np.ndarray:
+        """
+        Returns the edge lengths of the triangle itri.
+        """
+        return self.mesh.edge_lengths[self.mesh.tri_to_edge[:,itri]]
+    ####### INDEX MAPPINGS
+
+    def local_tet_to_triid(self, itet: int) -> np.ndarray:
+        raise NotImplementedError("local_tet_to_triid not implemented")
+    
+    def local_tet_to_edgeid(self, itet: int) -> np.ndarray:
+        raise NotImplementedError("local_tet_to_edgeid not implemented")
+
+    def interpolate_index(self, xs: np.ndarray,
+                    ys: np.ndarray,
+                    zs: np.ndarray,
+                    tetids: np.ndarray = None) -> np.ndarray:
+        raise NotImplementedError()
+    
+    def map_edge_to_field(self, edge_ids: np.ndarray) -> np.ndarray:
+        """
+        Returns the field ids for the edges.
+        """
+        return edge_ids
+
+    # ##### CUTS
+
+    @property
+    def bounds(self) -> tuple[tuple[float, float], tuple[float, float],tuple[float, float]]:
+        xmin = np.min(self.mesh.nodes[0,:])
+        xmax = np.max(self.mesh.nodes[0,:])
+        ymin = np.min(self.mesh.nodes[1,:])
+        ymax = np.max(self.mesh.nodes[1,:])
+        zmin = np.min(self.mesh.nodes[2,:])
+        zmax = np.max(self.mesh.nodes[2,:])
+        return (xmin, xmax), (ymin, ymax), (zmin, zmax)
+
+    # @staticmethod
+    # def tet_stiff_mass_submatrix(tet_vertices: np.ndarray, 
+    #                              edge_lengths: np.ndarray, 
+    #                              local_edge_map: np.ndarray, 
+    #                              local_tri_map: np.ndarray, 
+    #                              C_stiffness: float, 
+    #                              C_mass: float) -> tuple[np.ndarray, np.ndarray]:
+    #     pass
+    
+    # @staticmethod
+    # def tri_stiff_mass_submatrix(tri_vertices: np.ndarray, 
+    #                              edge_lengths: np.ndarray,
+    #                              local_edge_map: np.ndarray,
+    #                              C_stiffness: float, 
+    #                              C_mass: float) -> tuple[np.ndarray, np.ndarray]:
+    #     pass
+    
+    # @staticmethod
+    # def tri_stiff_vec_matrix(lcs_vertices: np.ndarray, 
+    #                          edge_lengths: np.ndarray, 
+    #                          gamma: complex, 
+    #                          lcs_Uinc: np.ndarray, 
+    #                          DPTs: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    #     pass
+
+    # @staticmethod
+    # def tri_stiff_matrix(lcs_vertices: np.ndarray, 
+    #                          edge_lengths: np.ndarray, 
+    #                          gamma: complex) -> tuple[np.ndarray, np.ndarray]:
+    #     pass
+    
+    
+    # @staticmethod
+    # def tri_surf_integral(lcs_vertices: np.ndarray, 
+    #                       edge_lengths: np.ndarray, 
+    #                       lcs_Uinc: np.ndarray, 
+    #                       DPTs: np.ndarray) -> complex:
+    #     pass

emerge/_emerge/elements/index_interp.py

@@ -0,0 +1,64 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see
+# <https://www.gnu.org/licenses/>.
+from numba import njit, f8, c16, i8, types
+import numpy as np
+
+
+@njit(i8[:](f8[:,:], i8[:,:], f8[:,:], i8[:]), cache=True, nogil=True)
+def index_interp(coords: np.ndarray,
+                tets: np.ndarray, 
+                nodes: np.ndarray,
+                tetids: np.ndarray):
+    ''' Nedelec 2 tetrahedral interpolation of the analytic curl'''
+    # Solution has shape (nEdges, nsols)
+    nNodes = coords.shape[1]
+    
+    prop = np.zeros((nNodes, ), dtype=np.int64)
+    
+
+    for i_iter in range(tetids.shape[0]):
+        itet = tetids[i_iter]
+        
+        iv1, iv2, iv3, iv4 = tets[:, itet]
+
+        v1 = nodes[:,iv1]
+        v2 = nodes[:,iv2]
+        v3 = nodes[:,iv3]
+        v4 = nodes[:,iv4]
+
+        bv1 = v2 - v1
+        bv2 = v3 - v1
+        bv3 = v4 - v1
+
+        blocal = np.zeros((3,3))
+        blocal[:,0] = bv1
+        blocal[:,1] = bv2
+        blocal[:,2] = bv3
+        basis = np.linalg.pinv(blocal)
+
+        coords_offset = coords - v1[:,np.newaxis]
+        coords_local = (basis @ (coords_offset))
+
+
+        inside = ((coords_local[0,:] + coords_local[1,:] + coords_local[2,:]) <= 1.00000001) & (coords_local[0,:] >= -1e-6) & (coords_local[1,:] >= -1e-6) & (coords_local[2,:] >= -1e-6)
+
+        if inside.sum() == 0:
+            continue
+        
+        prop[inside] = itet
+
+    return prop

emerge/_emerge/elements/legrange2.py

@@ -0,0 +1,172 @@
+# # EMerge is an open source Python based FEM EM simulation module.
+# # Copyright (C) 2025  Robert Fennis.
+
+# # This program is free software; you can redistribute it and/or
+# # modify it under the terms of the GNU General Public License
+# # as published by the Free Software Foundation; either version 2
+# # of the License, or (at your option) any later version.
+
+# # This program is distributed in the hope that it will be useful,
+# # but WITHOUT ANY WARRANTY; without even the implied warranty of
+# # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# # GNU General Public License for more details.
+
+# # You should have received a copy of the GNU General Public License
+# # along with this program; if not, see
+# # <https://www.gnu.org/licenses/>.
+
+# from __future__ import annotations
+# import numpy as np
+# from ..mesh3d import Mesh3D
+# from ..dataset_old import Dataset, Axis
+# from .femdata import FEMBasis
+# from ..mth.tet import leg2_tet_interp, leg2_tet_grad_interp, leg2_tet_stiff
+# from ..mth.tri import leg2_tri_stiff
+# from ..mth.optimized import local_mapping
+# from typing import Callable
+
+# ############### Nedelec2 Class
+
+# class Legrange2(FEMBasis):
+
+
+#     def __init__(self, mesh: Mesh3D):
+#         super().__init__(mesh)
+
+#         self.nedges: int = self.mesh.n_edges
+#         self.ntris: int = self.mesh.n_tris
+#         self.ntets: int = self.mesh.n_tets
+
+#         self.nfield: int = 2*self.nedges + 2*self.ntris
+
+#         self.axes: list[Axis] = []
+#         self.fieldata: Dataset = None
+        
+#         ######## MESH Derived
+
+#         nedges = self.mesh.n_edges
+#         ntris = self.mesh.n_tris
+
+#         self.tet_to_field: np.ndarray = np.zeros((10, self.mesh.tets.shape[1]), dtype=int)
+#         self.tet_to_field[:4,:] = self.mesh.tets
+#         self.tet_to_field[4:10,:] = self.mesh.tet_to_edge + self.mesh.n_nodes
+
+#         self.edge_to_field: np.ndarray = np.arange(nedges) + self.mesh.n_nodes
+
+#         self.tri_to_field: np.ndarray = np.zeros((6,ntris), dtype=int)
+
+#         self.tri_to_field[:3,:] = self.mesh.tris
+#         self.tri_to_field[3:6,:] = self.mesh.tri_to_edge + self.mesh.n_nodes
+
+#         ##
+#         self._field: np.ndarray = None
+
+#     def __call__(self, **kwargs) -> Legrange2:
+#         self._field = self.fielddata(**kwargs)
+#         return self
+    
+#     def interpolate(self, field, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, tet_ids: np.ndarray = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+#         if tet_ids is None:
+#             tet_ids = np.arange(self.mesh.n_tets)
+#         return leg2_tet_interp(np.array([xs, ys,zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, self.mesh.tet_to_edge, self.mesh.tet_to_tri, tet_ids)
+    
+#     def interpolate_grad(self, field, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, tet_ids: np.ndarray = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+#         if tet_ids is None:
+#             tet_ids = np.arange(self.mesh.tet_ids)
+#         return leg2_tet_grad_interp(np.array([xs, ys,zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, self.mesh.tet_to_edge, self.mesh.tet_to_tri, tet_ids)
+    
+#     def fieldf(self, field: np.ndarray, basis: np.ndarray = None, origin: np.ndarray = None) -> Callable:
+#         if basis is None:
+#             basis = np.eye(3)
+
+#         if origin is None:
+#             origin = np.zeros(3)
+        
+#         ibasis = np.linalg.pinv(basis)
+#         def func(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
+#             xyz = np.array([xs, ys, zs]) + origin[:, np.newaxis]
+#             xyzg = basis @ xyz
+#             return ibasis @ np.array(self.interpolate(field, xyzg[0,:], xyzg[1,:], xyzg[2,:]))
+#         return func
+    
+
+#     ###### Vertex getter
+
+#     def field_to_vertices(self, ifield: np.ndarray):
+#         return_ids = ifield[ifield < self.mesh.n_nodes]
+#         return return_ids
+    
+#     def field_to_edges(self, ifield: np.ndarray):
+#         return_ids = ifield[ifield >= self.mesh.n_nodes] - self.mesh.n_nodes
+#         return return_ids
+#     ###### INDEX MAPPINGS
+
+#     def local_tet_to_triid(self, itet: int) -> np.ndarray:
+#         tri_ids = self.tet_to_field[6:10, itet] - self.n_edges
+#         global_tri_map = self.mesh.tris[:, tri_ids]
+#         return local_mapping(self.mesh.tets[:, itet], global_tri_map)
+
+#     def local_tet_to_edgeid(self, itet: int) -> np.ndarray:
+#         global_edge_map = self.mesh.edges[:, self.tet_to_field[:6,itet]]
+#         return local_mapping(self.mesh.tets[:, itet], global_edge_map)
+
+#     def local_tri_to_edgeid(self, itri: int) -> np.ndarray:
+#         global_edge_map = self.mesh.edges[:, self.tri_to_field[:3,itri]]
+#         return local_mapping(self.mesh.tris[:, itri], global_edge_map)
+    
+#     def map_edge_to_field(self, edge_ids: np.ndarray) -> np.ndarray:
+#         """
+#         Returns the field ids for the edges.
+#         """
+#         # Concatinate the edges with the edges + ntris + nedges
+#         edge_ids = np.array(edge_ids)
+#         return np.concatenate((edge_ids, edge_ids + self.ntris + self.nedges))
+    
+#     ########
+#     @staticmethod
+#     def tet_stiff_mass_submatrix(tet_vertices: np.ndarray, 
+#                                  edge_lengths: np.ndarray, 
+#                                  local_edge_map: np.ndarray, 
+#                                  local_tri_map: np.ndarray, 
+#                                  C_stiffness: float, 
+#                                  C_mass: float) -> tuple[np.ndarray, np.ndarray]:
+#         raise NotImplementedError("tet_stiff_mass_submatrix is not implemented for Legrange2")
+    
+#     @staticmethod
+#     def tet_stiff_submatrix(tet_vertices: np.ndarray, 
+#                                  edge_lengths: np.ndarray, 
+#                                  local_edge_map: np.ndarray, 
+#                                  local_tri_map: np.ndarray, 
+#                                  C_stiffness: float) -> tuple[np.ndarray, np.ndarray]:
+#         raise leg2_tet_stiff(tet_vertices, edge_lengths, local_edge_map, local_tri_map, C_stiffness)
+    
+
+#     @staticmethod
+#     def tri_stiff_mass_submatrix(tri_vertices: np.ndarray, 
+#                                  edge_lengths: np.ndarray,
+#                                  local_edge_map: np.ndarray,
+#                                  C_stiffness: float, 
+#                                  C_mass: float) -> tuple[np.ndarray, np.ndarray]:
+#         raise NotImplementedError("tri stiff mass is not implemented for Legrange2")
+    
+#     @staticmethod
+#     def tri_stiff_submatrix(tri_vertices: np.ndarray, 
+#                                  local_edge_map: np.ndarray,
+#                                  C_stiffness: float) -> np.ndarray:
+#         return leg2_tri_stiff(tri_vertices, local_edge_map, C_stiffness)
+    
+
+#     @staticmethod
+#     def tri_stiff_vec_matrix(lcs_vertices: np.ndarray, 
+#                              edge_lengths: np.ndarray, 
+#                              gamma: complex, 
+#                              lcs_Uinc: np.ndarray, 
+#                              DPTs: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+#         raise NotImplementedError("tri stiff mass is not implemented for Legrange2")
+    
+#     @staticmethod
+#     def tri_surf_integral(lcs_vertices: np.ndarray, 
+#                           edge_lengths: np.ndarray, 
+#                           lcs_Uinc: np.ndarray, 
+#                           DPTs: np.ndarray) -> complex:
+#        raise NotImplementedError("tri stiff mass is not implemented for Legrange2")