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

emerge/_emerge/elements/nedelec2.py

@@ -0,0 +1,140 @@
+# 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 .femdata import FEMBasis
+from .ned2_interp import ned2_tet_interp, ned2_tet_interp_curl
+from ..mth.optimized import local_mapping
+from .index_interp import index_interp
+
+############### Nedelec2 Class
+
+class Nedelec2(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
+        
+        ######## MESH Derived
+
+        nedges = self.mesh.n_edges
+        ntris = self.mesh.n_tris
+
+        self.tet_to_field: np.ndarray = np.zeros((20, self.mesh.tets.shape[1]), dtype=int)
+        self.tet_to_field[:6,:] = self.mesh.tet_to_edge
+        self.tet_to_field[6:10,:] = self.mesh.tet_to_tri + nedges
+        self.tet_to_field[10:16,:] = self.mesh.tet_to_edge + (ntris+nedges)
+        self.tet_to_field[16:20,:] = self.mesh.tet_to_tri + (ntris+2*nedges)
+    
+        self.edge_to_field: np.ndarray = np.zeros((2,nedges), dtype=int)
+
+        self.edge_to_field[0,:] = np.arange(nedges)
+        self.edge_to_field[1,:] = np.arange(nedges) + ntris + nedges
+
+        self.tri_to_field: np.ndarray = np.zeros((8,ntris), dtype=int)
+
+        self.tri_to_field[:3,:] = self.mesh.tri_to_edge
+        self.tri_to_field[3,:] = np.arange(ntris) + nedges
+        self.tri_to_field[4:7,:] = self.mesh.tri_to_edge + nedges + ntris
+        self.tri_to_field[7,:] = np.arange(ntris) + 2*nedges + ntris
+
+        ##
+        self._field: np.ndarray = None
+        self.n_tet_dofs = 20
+        self.n_tri_dofs = 8
+        self._all_tet_ids = np.arange(self.ntets)
+
+        self.empty_tri_rowcol()
+    
+    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]:
+        ''' 
+        Interpolate the provided field data array at the given xs, ys and zs coordinates
+        '''
+        if tetids is None:
+            tetids = self._all_tet_ids
+        return ned2_tet_interp(np.array([xs, ys, zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, tetids)
+    
+    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, c: np.ndarray, tetids: np.ndarray = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Interpolates the curl of the field at the given points.
+        """
+        if tetids is None:
+            tetids = self._all_tet_ids
+        return ned2_tet_interp_curl(np.array([xs, ys, zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, c, tetids)
+    
+    def interpolate_index(self, xs: np.ndarray,
+                        ys: np.ndarray,
+                        zs: np.ndarray,
+                        tetids: np.ndarray = None) -> np.ndarray:
+        if tetids is None:
+            tetids = self._all_tet_ids
+
+        return index_interp(np.array([xs, ys, zs]), self.mesh.tets, self.mesh.nodes, tetids)
+    ###### 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]:
+    #     return ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_map, C_stiffness, C_mass)
+    
+    # @staticmethod
+    # def tri_stiff_vec_matrix(lcs_vertices: np.ndarray, 
+    #                          gamma: complex, 
+    #                          lcs_Uinc: np.ndarray, 
+    #                          DPTs: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    #     return ned2_tri_stiff_force(lcs_vertices, gamma, lcs_Uinc, DPTs)
+
+    # @staticmethod
+    # def tri_surf_integral(lcs_vertices: np.ndarray, 
+    #                       edge_lengths: np.ndarray, 
+    #                       lcs_Uinc: np.ndarray, 
+    #                       DPTs: np.ndarray) -> complex:
+    #     return ned2_tri_surface_integral(lcs_vertices, edge_lengths, lcs_Uinc, DPTs)

emerge/_emerge/elements/nedleg2.py

@@ -0,0 +1,217 @@
+# 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 SurfaceMesh
+from .femdata import FEMBasis
+from .ned2_interp import ned2_tri_interp_full, ned2_tri_interp_curl
+from ..mth.optimized import matinv
+from ..cs import CoordinateSystem
+
+
+## TODO: TEMPORARY SOLUTION FIX THIS
+
+class FieldFunctionClass:
+    """ This Class serves as a picklable class so that ModalPort boundary conditions
+    can actually be stored with the Simulation3D class. Functions aren't picklable in 
+    Python. 
+    
+    I am not happy with the existence of this class, it feels too ad-hoc but for now it
+    is the simplest way. It stores all actually required information needed to do a
+    surface field interpolation without needing to store the Mesh3D and SurfaceMesh class
+    objects plus the NedelecLegrange2 classes with the Simulation3D. 
+
+    As it stands currently, only the GMSH mesh is stored plus the geometry objects. The
+    mesh is reconstructed as it is deterministic.
+    """
+    def __init__(self, 
+                 field: np.ndarray,
+                 cs: CoordinateSystem,
+                 nodes: np.ndarray,
+                 tris: np.ndarray,
+                 tri_to_field: np.ndarray,
+                 EH: str = 'E',
+                 diadic: np.ndarray = None,
+                 beta: float = None,
+                 constant: float = 1.0):
+        self.field: np.ndarray = field
+        self.cs: CoordinateSystem = cs
+        self.nodes: np.ndarray = nodes
+        self.tris: np.ndarray = tris
+        self.tri_to_field: np.ndarray = tri_to_field
+        self.eh: str = EH
+        self.diadic: np.ndarray = diadic
+        self.beta: float = beta
+        self.constant: float = constant
+        if EH == 'H':
+            if diadic is None:
+                self.diadic = np.eye(3)[:,:,np.newaxis()] * np.ones((self.tris.shape[1]))
+
+    def __call__(self, xs: np.ndarray,
+             ys: np.ndarray,
+             zs: np.ndarray):
+        xl, yl, zl = self.cs.in_local_cs(xs, ys, zs)
+        if self.eh == 'E':
+            Fxl, Fyl, Fzl = self.calcE(xl, yl)
+        else:
+            Fxl, Fyl, Fzl = self.calcH(xl, yl)
+        Fx, Fy, Fz = self.cs.in_global_basis(Fxl, Fyl, Fzl)
+        return np.array([Fx, Fy, Fz])*self.constant
+    
+    def calcE(self, xs: np.ndarray, ys: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        coordinates = np.array([xs, ys])
+        return ned2_tri_interp_full(coordinates, 
+                               self.field, 
+                               self.tris,  
+                               self.nodes, 
+                               self.tri_to_field)
+    
+    def calcH(self, xs: np.ndarray, ys: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        coordinates = np.array([xs, ys])
+        
+        return ned2_tri_interp_curl(coordinates, 
+                               self.field, 
+                               self.tris,  
+                               self.nodes, 
+                               self.tri_to_field,
+                               self.diadic,
+                               self.beta)
+
+############### Nedelec2 Class
+
+class NedelecLegrange2(FEMBasis):
+
+
+    def __init__(self, mesh: SurfaceMesh, cs: CoordinateSystem):
+
+        self.mesh: SurfaceMesh = mesh
+
+        self.cs: CoordinateSystem = cs
+
+        ## 
+        nodes = self.mesh.nodes
+        self.local_nodes: np.ndarray = np.array(self.cs.in_local_cs(nodes[0,:], nodes[1,:], nodes[2,:]))
+                                                
+        ## Counters
+        self.n_nodes: int = self.mesh.n_nodes
+        self.n_edges: int = self.mesh.n_edges
+        self.n_tris: int = self.mesh.n_tris
+        self.n_tri_dofs: int = None
+
+        self.n_field: int = 2*self.n_edges + 2*self.n_tris + self.n_nodes + self.n_edges
+        self.n_xy: int = 2*self.n_edges + 2*self.n_tris
+
+        ######## MESH Derived
+        Nn = self.mesh.n_nodes
+        Ne = self.mesh.n_edges
+        Nt = self.mesh.n_tris
+
+        self.tri_to_field: np.ndarray = np.zeros((8 + 6, self.n_tris), dtype=int)
+
+        self.tri_to_field[:3,:] = self.mesh.tri_to_edge
+        self.tri_to_field[3,:] = np.arange(Nt) + Ne
+        self.tri_to_field[4:7,:] = self.mesh.tri_to_edge + Ne + Nt
+        self.tri_to_field[7,:] = np.arange(Nt) + 2*Ne + Nt
+        self.tri_to_field[8:11,:] = self.mesh.tris + (2*Ne + 2*Nt) # + E + T + E + T
+        self.tri_to_field[11:14,:] = self.mesh.tri_to_edge + (2*Ne + 2*Nt + Nn)
+    
+        self.edge_to_field: np.ndarray = np.zeros((5,Ne), dtype=int) #edge mode 1, edge mode 2, edge legrande mode, edge vertex mode 1, edge vertex mode 2
+
+        self.edge_to_field[0,:] = np.arange(Ne)
+        self.edge_to_field[1,:] = np.arange(Ne) + Nt + Ne
+        self.edge_to_field[2,:] = np.arange(Ne) + Ne*2 + Nt*2 + Nn
+        self.edge_to_field[3:,:] = self.mesh.edges + Ne*2 + Nt*2
+
+        ##
+        self._field: np.ndarray = None   
+        self._rows: np.ndarray = None
+        self._cols: np.ndarray = None 
+
+    def __call__(self, **kwargs) -> NedelecLegrange2:
+        self._field = self.fielddata(**kwargs)
+        return self
+    
+    def interpolate_Ef(self, field: np.ndarray) -> FieldFunctionClass:
+        '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
+        
+        # def func(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
+        #     xl, yl, zl = self.cs.in_local_cs(xs, ys, zs)
+        #     Exl, Eyl, Ezl = self.tri_interpolate(field, xl, yl)
+        #     Ex, Ey, Ez = self.cs.in_global_basis(Exl, Eyl, Ezl)
+        #     return np.array([Ex, Ey, Ez])
+        return FieldFunctionClass(field, self.cs, self.local_nodes, self.mesh.tris, self.tri_to_field, 'E')
+
+    def interpolate_Hf(self, field: np.ndarray, k0: float, ur: np.ndarray, beta: float) -> FieldFunctionClass:
+        '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
+        constant = 1j/ ((k0*299792458)*(4*np.pi*1e-7))
+        urinv = np.zeros_like(ur)
+        
+        for i in range(ur.shape[2]):
+            urinv[:,:,i] = matinv(ur[:,:,i])
+
+        # def func(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> np.ndarray:
+        #     xl, yl, _ = self.cs.in_local_cs(xs, ys, zs)
+        #     Exl, Eyl, Ezl = self.tri_interpolate_curl(field, xl, yl, urinv, beta)
+        #     Ex, Ey, Ez = self.cs.in_global_basis(Exl, Eyl, Ezl)
+        #     return np.array([Ex, Ey, Ez])*constant
+        return FieldFunctionClass(field, self.cs, self.local_nodes, self.mesh.tris, self.tri_to_field, 'H', urinv, beta, constant)
+    
+    def tri_interpolate(self, field, xs: np.ndarray, ys: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        coordinates = np.array([xs, ys])
+        return ned2_tri_interp_full(coordinates, 
+                               field, 
+                               self.mesh.tris,  
+                               self.local_nodes, 
+                               self.tri_to_field)
+    
+    def tri_interpolate_curl(self, field, xs: np.ndarray, ys: np.ndarray, diadic: np.ndarray = None, beta: float = 0) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        coordinates = np.array([xs, ys])
+        if diadic is None:
+            diadic = np.eye(3)[:,:,np.newaxis()] * np.ones((self.mesh.n_tris))
+        return ned2_tri_interp_curl(coordinates, 
+                               field, 
+                               self.mesh.tris,  
+                               self.local_nodes, 
+                               self.tri_to_field,
+                               diadic,
+                               beta)
+    
+    
+    # def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, c: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    #     """
+    #     Interpolates the curl of the field at the given points.
+    #     """
+    #     return ned2_tet_interp_curl(np.array([xs, ys,zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, c)
+    
+    # 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
+    
+    ###### INDEX MAPPINGS
+
+    

emerge/_emerge/geo/__init__.py

@@ -0,0 +1,24 @@
+# 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 .pcb import PCBLayouter
+from .pmlbox import pmlbox
+from .horn import Horn
+from .shapes import Cyllinder, CoaxCyllinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment
+from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect
+from .polybased import XYPolygon, GeoPrism
+from .step import STEPItems

emerge/_emerge/geo/horn.py

@@ -0,0 +1,107 @@
+# 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 ..geometry import GeoVolume
+from ..cs import CoordinateSystem
+from ..selection import FaceSelection
+
+import gmsh
+
+class Horn(GeoVolume):
+
+    def __init__(self,
+                 start_aperture: tuple[float, float],
+                 end_aperture: tuple[float, float],
+                 height: float,
+                 cs: CoordinateSystem):
+        """Generate a Horn geometry. The horn is defined by a start and ending rectangle.
+
+        Start aperture is always defined at z=0 and the end at z=height.
+        The horn can be reoriented by choosing a different coordinate system.
+
+        Args:
+            start_aperture (tuple[float, float]): The width/height of the start aperture
+            end_aperture (tuple[float, float]): The width/height of the end aperture
+            height (float): The height of the horn
+            cs (CoordinateSystem): The coordinate systme to place the horn in.
+        """
+        super().__init__([])
+        p0 = cs.origin
+        p1 = p0 + cs.zax.np * height
+
+        wax = cs.xax.np
+        hax = cs.yax.np
+        dax = cs.zax.np
+
+        w1, h1 = start_aperture
+        w2, h2 = end_aperture
+
+        p11 = p0 + wax *w1/2 + hax * h1/2
+        p12 = p0 + wax *w1/2 - hax * h1/2
+        p13 = p0 - wax *w1/2 - hax * h1/2
+        p14 = p0 - wax *w1/2 + hax * h1/2
+
+        p21 = p1 + wax *w2/2 + hax * h2/2
+        p22 = p1 + wax *w2/2 - hax * h2/2
+        p23 = p1 - wax *w2/2 - hax * h2/2
+        p24 = p1 - wax *w2/2 + hax * h2/2
+
+        pt11 = gmsh.model.occ.addPoint(*p11)
+        pt12 = gmsh.model.occ.addPoint(*p12)
+        pt13 = gmsh.model.occ.addPoint(*p13)
+        pt14 = gmsh.model.occ.addPoint(*p14)
+        pt21 = gmsh.model.occ.addPoint(*p21)
+        pt22 = gmsh.model.occ.addPoint(*p22)
+        pt23 = gmsh.model.occ.addPoint(*p23)
+        pt24 = gmsh.model.occ.addPoint(*p24)
+
+        l1r = gmsh.model.occ.addLine(pt11, pt12)
+        l1b = gmsh.model.occ.addLine(pt12, pt13)
+        l1l = gmsh.model.occ.addLine(pt13, pt14)
+        l1t = gmsh.model.occ.addLine(pt14, pt11)
+        
+        l2r = gmsh.model.occ.addLine(pt21, pt22)
+        l2b = gmsh.model.occ.addLine(pt22, pt23)
+        l2l = gmsh.model.occ.addLine(pt23, pt24)
+        l2t = gmsh.model.occ.addLine(pt24, pt21)
+
+        dtr = gmsh.model.occ.addLine(pt11, pt21)
+        dbr = gmsh.model.occ.addLine(pt12, pt22)
+        dbl = gmsh.model.occ.addLine(pt13, pt23)
+        dtl = gmsh.model.occ.addLine(pt14, pt24)
+
+        wbot = gmsh.model.occ.addWire([l1r, l1b, l1l, l1t])
+        wtop = gmsh.model.occ.addWire([l2r, l2b, l2l, l2t])
+        wright = gmsh.model.occ.addWire([l1r, dbr, l2r, dtr])
+        wleft = gmsh.model.occ.addWire([l1l, dbl, l2l, dtl])
+        wfront = gmsh.model.occ.addWire([l1b, dbl, l2b, dbr])
+        wback = gmsh.model.occ.addWire([l1t, dtr, l2t, dtl])
+
+        s1 = gmsh.model.occ.addSurfaceFilling(wbot)
+        s2 = gmsh.model.occ.addSurfaceFilling(wtop)
+        s3 = gmsh.model.occ.addSurfaceFilling(wright)
+        s4 = gmsh.model.occ.addSurfaceFilling(wleft)
+        s5 = gmsh.model.occ.addSurfaceFilling(wfront)
+        s6 = gmsh.model.occ.addSurfaceFilling(wback)
+
+        sv = gmsh.model.occ.addSurfaceLoop([s1, s2, s3, s4, s5, s6])
+
+        self.tags: list[int] = [gmsh.model.occ.addVolume([sv,]),]
+        
+        pc = p0 + dax * height/2
+        self._add_face_pointer('front', pc - height/2*dax, -dax)
+        self._add_face_pointer('back', pc + height/2*dax, dax)