emerge 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

emerge/__init__.py

@@ -32,7 +32,7 @@ warnings.filterwarnings(
 ############################################################
 import os
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 
 NTHREADS = "1"
 os.environ["EMERGE_STD_LOGLEVEL"] = os.getenv("EMERGE_STD_LOGLEVEL", default="INFO")
@@ -74,6 +74,7 @@ from ._emerge.mesher import Algorithm2D, Algorithm3D
 from . import lib
 from ._emerge.howto import _HowtoClass
 from ._emerge.emerge_update import update_emerge
+
 howto = _HowtoClass()
 
 logger.debug('Importing complete!')

emerge/_emerge/const.py

@@ -2,4 +2,5 @@ C0 = 299792458
 Z0 = 376.73031366857
 PI = 3.14159265358979323846
 EPS0 = 8.854187818814e-12
-MU0 = 1/(C0*C0*EPS0)#1.2566370612720e-6
+#MU0 = 1.2566370612720e-6 #
+MU0 = 1/(C0*C0*EPS0)#

emerge/_emerge/elements/ned2_interp.py

@@ -14,9 +14,35 @@
 # 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 # type: ignore
+from numba import njit, f8, c16, i8, types, prange # type: ignore
 import numpy as np
-from ..mth.optimized import compute_distances
+from ..mth.optimized import compute_distances, matmul
+
+
+@njit(f8[:,:](f8[:,:]), cache=True, nogil=True)
+def matinv(M: np.ndarray) -> np.ndarray:
+    """Optimized matrix inverse of 3x3 matrix
+
+    Args:
+        M (np.ndarray): Input matrix M of shape (3,3)
+
+    Returns:
+        np.ndarray: The matrix inverse inv(M)
+    """
+    out = np.zeros((3,3), dtype=np.float64)
+   
+    det = M[0,0]*M[1,1]*M[2,2] - M[0,0]*M[1,2]*M[2,1] - M[0,1]*M[1,0]*M[2,2] + M[0,1]*M[1,2]*M[2,0] + M[0,2]*M[1,0]*M[2,1] - M[0,2]*M[1,1]*M[2,0]
+    out[0,0] = M[1,1]*M[2,2] - M[1,2]*M[2,1]
+    out[0,1] = -M[0,1]*M[2,2] + M[0,2]*M[2,1]
+    out[0,2] = M[0,1]*M[1,2] - M[0,2]*M[1,1]
+    out[1,0] = -M[1,0]*M[2,2] + M[1,2]*M[2,0]
+    out[1,1] = M[0,0]*M[2,2] - M[0,2]*M[2,0]
+    out[1,2] = -M[0,0]*M[1,2] + M[0,2]*M[1,0]
+    out[2,0] = M[1,0]*M[2,1] - M[1,1]*M[2,0]
+    out[2,1] = -M[0,0]*M[2,1] + M[0,1]*M[2,0]
+    out[2,2] = M[0,0]*M[1,1] - M[0,1]*M[1,0]
+    out = out/det
+    return out
 
 @njit(types.Tuple((f8[:], f8[:], f8[:], f8[:], f8))(f8[:], f8[:], f8[:]), cache = True, nogil=True)
 def tet_coefficients(xs, ys, zs):
@@ -112,7 +138,7 @@ def local_mapping(vertex_ids, triangle_ids):
 
     return out
 
-@njit(types.Tuple((c16[:], c16[:], c16[:]))(f8[:,:], c16[:], i8[:,:], i8[:,:], i8[:,:], f8[:,:], i8[:,:], i8[:]), cache=True, nogil=True)
+@njit(types.Tuple((c16[:], c16[:], c16[:]))(f8[:,:], c16[:], i8[:,:], i8[:,:], i8[:,:], f8[:,:], i8[:,:], i8[:]), cache=True, nogil=True, parallel=False)
 def ned2_tet_interp(coords: np.ndarray,
                          solutions: np.ndarray, 
                          tets: np.ndarray, 
@@ -130,22 +156,20 @@ def ned2_tet_interp(coords: np.ndarray,
     ys = coords[1,:]
     zs = coords[2,:]
 
-    Ex = np.full((nNodes, ), np.nan, dtype=np.complex128)
-    Ey = np.full((nNodes, ), np.nan, dtype=np.complex128)
-    Ez = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    # Ex = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    # Ey = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    # Ez = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ex = np.zeros((nNodes, ), dtype=np.complex128)
+    Ey = np.zeros((nNodes, ), dtype=np.complex128)
+    Ez = np.zeros((nNodes, ), dtype=np.complex128)
+    setnan = np.zeros((nNodes, ), dtype=np.complex128)
+    assigned = np.zeros((nNodes,), dtype=np.int64)-1
     
     for i_iter in range(tetids.shape[0]):
         itet = tetids[i_iter]
 
         iv1, iv2, iv3, iv4 = tets[:, itet]
 
-        g_node_ids = tets[:, itet]
-        g_edge_ids = edges[:, tet_to_field[:6, itet]]
-        g_tri_ids = tris[:, tet_to_field[6:10, itet]-nEdges]
-
-        l_edge_ids = local_mapping(g_node_ids, g_edge_ids)
-        l_tri_ids = local_mapping(g_node_ids, g_tri_ids)
-
         v1 = nodes[:,iv1]
         v2 = nodes[:,iv2]
         v3 = nodes[:,iv3]
@@ -159,19 +183,30 @@ def ned2_tet_interp(coords: np.ndarray,
         blocal[:,0] = bv1
         blocal[:,1] = bv2
         blocal[:,2] = bv3
-        basis = np.linalg.pinv(blocal)
+        basis = matinv(blocal)
 
-        coords_offset = coords - v1[:,np.newaxis]
-        coords_local = (basis @ (coords_offset))
-
-        field_ids = tet_to_field[:, itet]
-        Etet = solutions[field_ids]
+        v1x, v1y, v1z = v1[0], v1[1], v1[2]
+        
+        coords_offset = coords*1.0
+        coords_offset[0,:] = coords_offset[0,:] - v1x
+        coords_offset[1,:] = coords_offset[1,:] - v1y
+        coords_offset[2,:] = coords_offset[2,:] - v1z
+        
+        coords_local = matmul(basis, coords_offset)#(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
         
+        assigned[inside] = itet
+    
+    for i_iter in range(tetids.shape[0]):
+        itet = tetids[i_iter]
+        
+        inside = assigned==itet
+        if inside.sum() == 0:
+            continue
         ######### INSIDE THE TETRAHEDRON #########
         
         x = xs[inside==1]
@@ -184,6 +219,16 @@ def ned2_tet_interp(coords: np.ndarray,
 
         a_s, b_s, c_s, d_s, V = tet_coefficients(xvs, yvs, zvs)
         
+        g_node_ids = tets[:, itet]
+        g_edge_ids = edges[:, tet_to_field[:6, itet]]
+        g_tri_ids = tris[:, tet_to_field[6:10, itet]-nEdges]
+
+        l_edge_ids = local_mapping(g_node_ids, g_edge_ids)
+        l_tri_ids = local_mapping(g_node_ids, g_tri_ids)
+        
+        field_ids = tet_to_field[:, itet]
+        Etet = solutions[field_ids]
+        
         Em1s = Etet[0:6]
         Ef1s = Etet[6:10]
         Em2s = Etet[10:16]
@@ -192,6 +237,7 @@ def ned2_tet_interp(coords: np.ndarray,
         Exl = np.zeros(x.shape, dtype=np.complex128)
         Eyl = np.zeros(x.shape, dtype=np.complex128)
         Ezl = np.zeros(x.shape, dtype=np.complex128)
+        
         V1 = (216*V**3)
         for ie in range(6):
             Em1, Em2 = Em1s[ie], Em2s[ie]
@@ -243,12 +289,17 @@ def ned2_tet_interp(coords: np.ndarray,
             Eyl += ey
             Ezl += ez
 
-        Ex[inside] = Exl
-        Ey[inside] = Eyl
-        Ez[inside] = Ezl
+        Ex[inside] += Exl
+        Ey[inside] += Eyl
+        Ez[inside] += Ezl
+        setnan[inside] += 1
+    
+    Ex[setnan==0] = np.nan
+    Ey[setnan==0] = np.nan
+    Ez[setnan==0] = np.nan
     return Ex, Ey, Ez
 
-@njit(types.Tuple((c16[:], c16[:], c16[:]))(f8[:,:], c16[:], i8[:,:], i8[:,:], i8[:,:], f8[:,:], i8[:,:], c16[:], i8[:]), cache=True, nogil=True)
+@njit(types.Tuple((c16[:], c16[:], c16[:]))(f8[:,:], c16[:], i8[:,:], i8[:,:], i8[:,:], f8[:,:], i8[:,:], c16[:], i8[:]), cache=True, nogil=True, parallel=False)
 def ned2_tet_interp_curl(coords: np.ndarray,
                          solutions: np.ndarray, 
                          tets: np.ndarray, 
@@ -266,22 +317,21 @@ def ned2_tet_interp_curl(coords: np.ndarray,
     xs = coords[0,:]
     ys = coords[1,:]
     zs = coords[2,:]
-
-    Ex = np.full((nNodes, ), np.nan, dtype=np.complex128)
-    Ey = np.full((nNodes, ), np.nan, dtype=np.complex128)
-    Ez = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    
+    # Ex = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    # Ey = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    # Ez = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ex = np.zeros((nNodes, ), dtype=np.complex128)
+    Ey = np.zeros((nNodes, ), dtype=np.complex128)
+    Ez = np.zeros((nNodes, ), dtype=np.complex128)
+    setnan = np.zeros((nNodes, ), dtype=np.complex128)
+    assigned = np.zeros((nNodes,), dtype=np.int64)-1
 
     for i_iter in range(tetids.shape[0]):
         itet = tetids[i_iter]
         
         iv1, iv2, iv3, iv4 = tets[:, itet]
 
-        g_node_ids = tets[:, itet]
-        g_edge_ids = edges[:, tet_to_field[:6, itet]]
-        g_tri_ids = tris[:, tet_to_field[6:10, itet]-nEdges]
-
-        l_edge_ids = local_mapping(g_node_ids, g_edge_ids)
-        l_tri_ids = local_mapping(g_node_ids, g_tri_ids)
 
         v1 = nodes[:,iv1]
         v2 = nodes[:,iv2]
@@ -296,19 +346,43 @@ def ned2_tet_interp_curl(coords: np.ndarray,
         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))
+        basis = matinv(blocal)
 
-        field_ids = tet_to_field[:, itet]
-        Etet = solutions[field_ids]
+        v1x, v1y, v1z = v1[0], v1[1], v1[2]
+        
+        coords_offset = coords*1.0
+        coords_offset[0,:] = coords_offset[0,:] - v1x
+        coords_offset[1,:] = coords_offset[1,:] - v1y
+        coords_offset[2,:] = coords_offset[2,:] - v1z
+        
+        #coords_local = (basis @ (coords_offset))
+        coords_local = matmul(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
         
+        assigned[inside] = itet
+
+
+    for i_iter in range(tetids.shape[0]):
+        itet = tetids[i_iter] 
+        
+        inside = (assigned==itet)
+        if inside.sum() == 0:
+            continue
+        
+        g_node_ids = tets[:, itet]
+        g_edge_ids = edges[:, tet_to_field[:6, itet]]
+        g_tri_ids = tris[:, tet_to_field[6:10, itet]-nEdges]
+
+        l_edge_ids = local_mapping(g_node_ids, g_edge_ids)
+        l_tri_ids = local_mapping(g_node_ids, g_tri_ids)
+        
+        field_ids = tet_to_field[:, itet]
+        Etet = solutions[field_ids]
+        
         const = c[itet]
         ######### INSIDE THE TETRAHEDRON #########
         
@@ -420,9 +494,15 @@ def ned2_tet_interp_curl(coords: np.ndarray,
             Eyl += ey
             Ezl += ez
 
-        Ex[inside] = Exl*const
-        Ey[inside] = Eyl*const
-        Ez[inside] = Ezl*const
+        Ex[inside] += Exl*const
+        Ey[inside] += Eyl*const
+        Ez[inside] += Ezl*const
+        setnan[inside] += 1
+    
+    Ex[setnan==0] = np.nan
+    Ey[setnan==0] = np.nan
+    Ez[setnan==0] = np.nan
+    
     return Ex, Ey, Ez
 
 @njit(types.Tuple((c16[:], c16[:], c16[:]))(f8[:,:], c16[:], i8[:,:], f8[:,:], i8[:,:]), cache=True, nogil=True)

emerge/_emerge/geo/__init__.py

@@ -19,6 +19,6 @@ from .pcb import PCB, PCBLayer
 from .pmlbox import pmlbox
 from .horn import Horn
 from .shapes import Cylinder, CoaxCylinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment, Cone
-from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect, unite, expand_surface, stretch
+from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect, unite, expand_surface, stretch, extrude
 from .polybased import XYPolygon, GeoPrism, Disc, Curve
 from .step import STEPItems

emerge/_emerge/geo/operations.py

@@ -282,6 +282,24 @@ def stretch(main: GeoObject, fx: float = 1, fy: float = 1, fz: float = 1, origin
     
     return main
 
+def extrude(main: GeoSurface, dx: float = 0.0, dy: float = 0.0, dz: float = 0.0) -> GeoObject:
+    """Extrudes a surface entity by a displacement
+
+    Args:
+        main (GeoSurface): _description_
+        dx (float): _description_
+        dy (float): _description_
+        dz (float): _description_
+
+    Returns:
+        GeoObject: _description_
+    """
+    dtout = gmsh.model.occ.extrude(main.dimtags, dx, dy, dz)
+    out = [dt[1] for dt in dtout if dt[0]==3]
+    obj_out = GeoVolume(out, name=f'Extrusion[{main.name}]')
+    gmsh.model.occ.synchronize()
+    return obj_out
+    
 
 @overload
 def unite(*objects: GeoVolume) -> GeoVolume: ...
@@ -313,7 +331,9 @@ def unite(*objects: GeoObject) -> GeoObject:
         other._exists = False
     new_dimtags, mapping = gmsh.model.occ.fuse(dts, main.dimtags)
     
+    newname = 'Union[' + ','.join([obj.name for obj in objects]) + ']'
     new_obj = GeoObject.from_dimtags(new_dimtags)._take_tools(*objects)
+    new_obj.name = newname
     new_obj.set_material(main.material)
     new_obj.prio_set(main._priority)
     

emerge/_emerge/geo/pcb.py

@@ -25,7 +25,7 @@ from .polybased import XYPolygon
 from .operations import change_coordinate_system, unite
 from .pcb_tools.macro import parse_macro
 from .pcb_tools.calculator import PCBCalculator
-
+from ..logsettings import DEBUG_COLLECTOR
 import numpy as np
 from loguru import logger
 from typing import Literal, Callable, overload
@@ -960,7 +960,8 @@ class PCB:
                  stack: list[PCBLayer] = None,
                  name: str | None = None,
                  trace_thickness: float | None = None,
-                 zs: np.ndarray | None = None
+                 zs: np.ndarray | None = None,
+                 thick_traces: bool = False,
                  ):
         """Creates a new PCB layout class instance
 
@@ -974,9 +975,11 @@ class PCB:
             stack (list[PCBLayer], optional): Optional list of PCBLayer classes for multilayer PCB with different dielectrics. Defaults to None.
             name (str | None, optional): The PCB object name. Defaults to None.
             trace_thickness (float | None, optional): The conductor trace thickness if important. Defaults to None.
+            thick_traces: (bool, optional): If traces should be given a thickness and modeled in 3D. Defaults to False
         """
 
         self.thickness: float = thickness
+        self._thick_traces: bool = thick_traces
         self._stack: list[PCBLayer] = []
         
         if zs is not None:
@@ -1016,9 +1019,10 @@ class PCB:
             
         self.dielectric_priority: int = 11
         self.via_priority: int = 12
+        self.conductor_priority: int = 13
 
-        self.traces: list[GeoPolygon] = []
-        self.ports: list[GeoPolygon] = []
+        self.traces: list[GeoPolygon | GeoVolume] = []
+        self.ports: list[GeoPolygon | GeoVolume] = []
         self.vias: list[Via] = []
 
         self.xs: list[float] = []
@@ -1032,7 +1036,10 @@ class PCB:
         self.calc: PCBCalculator = PCBCalculator(self.thickness, self._zs, self.material, self.unit)
 
         self.name: str = _NAME_MANAGER(name, self._DEFNAME)
-    
+
+        if not self._thick_traces and self.trace_material is not PEC:
+            DEBUG_COLLECTOR.add_report('Non PEC surface materials are used without thick traces. The SurfaceImpedance boundary condition will be used that is known to not be accurate.' +
+                                       'Please set thick_traces=True in the PCB constructor to ensure accurate losses until this issue is fixed.')
 
     ############################################################
     #                          PROPERTIES                     #
@@ -1099,7 +1106,7 @@ class PCB:
             self.paths.append(StripPath(self))
         return self.paths[path_nr]
     
-    def _gen_poly(self, xys: list[tuple[float, float]], z: float, name: str | None = None) -> GeoPolygon:
+    def _gen_poly(self, xys: list[tuple[float, float]], z: float, name: str | None = None) -> GeoPolygon | GeoVolume:
         """ Generates a GeoPoly out of a list of (x,y) coordinate tuples.
         
         
@@ -1120,8 +1127,16 @@ class PCB:
         
         tag_wire = gmsh.model.occ.addWire(ltags)
         planetag = gmsh.model.occ.addPlaneSurface([tag_wire,])
-        poly = GeoPolygon([planetag,], name=name)
-        poly._store('thickness', self.trace_thickness)
+        if self._thick_traces:
+            if self.trace_thickness is None:
+                raise ValueError('Trace thickness not defined, cannot generate polygons. Make sure to define a trace thickness in the PCB() constructor.')
+            dx, dy, dz = self.cs.zax.np*self.trace_thickness
+            dimtags = gmsh.model.occ.extrude([(2,planetag),], dx, dy, dz)
+            voltags = [dt[1] for dt in dimtags if dt[0]==3]
+            poly = GeoVolume(voltags, name=name).prio_set(self.conductor_priority)
+        else:
+            poly = GeoPolygon([planetag,], name=name)
+            poly._store('thickness', self.trace_thickness)
         return poly
     
 
@@ -1236,7 +1251,7 @@ class PCB:
               height: float | None = None,
               origin: tuple[float, float] | None = None,
               alignment: Alignment = Alignment.CORNER,
-              name: str | None = None) -> GeoSurface:
+              name: str | None = None) -> GeoSurface | GeoVolume:
         """Generates a generic rectangular plate in the XY grid.
         If no size is provided, it defaults to the entire PCB size assuming that the bounds are determined.
 
@@ -1264,10 +1279,13 @@ class PCB:
                                                         origin[1] - height*self.unit/2, 
                                                         origin[2])
 
-        plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0), name=name) # type: ignore
-        plane._store('thickness', self.thickness)
-        plane = change_coordinate_system(plane, self.cs) # type: ignore
-        plane.set_material(self.trace_material)
+        if self._thick_traces:
+            plane = Box(width*self.unit, height*self.unit, self.trace_thickness, position=origin, name=name).set_material(self.trace_material)
+        else:
+            plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0), name=name) # type: ignore
+            plane._store('thickness', self.thickness)
+            plane = change_coordinate_system(plane, self.cs) # type: ignore
+            plane.set_material(self.trace_material)
         return plane # type: ignore
     
     def radial_stub(self, pos: tuple[float, float], length: float, angle: float, direction: tuple[float, float], Nsections: int = 8, w0: float = 0, z: float = 0, material: Material = None, name: str = None) -> None:
@@ -1525,12 +1543,12 @@ class PCB:
         self.polies.append(poly)
     
     @overload
-    def compile_paths(self, merge: Literal[True]) -> GeoSurface: ...
+    def compile_paths(self, merge: Literal[True]) -> GeoSurface | GeoVolume: ...
     
     @overload
-    def compile_paths(self, merge: Literal[False] = ...) -> list[GeoSurface]: ...
+    def compile_paths(self, merge: Literal[False] = ...) -> list[GeoSurface] | list[GeoVolume]: ...
 
-    def compile_paths(self, merge: bool = False) -> list[GeoPolygon] | GeoSurface:
+    def compile_paths(self, merge: bool = False) -> list[GeoPolygon] | GeoSurface | GeoVolume:
         """Compiles the striplines and returns a list of polygons or asingle one.
 
         The Z=0 argument determines the height of the striplines. Z=0 corresponds to the top of

emerge/_emerge/geo/shapes.py

@@ -314,6 +314,7 @@ class Cylinder(GeoVolume):
                                          height*ax[0], height*ax[1], height*ax[2],
                                          radius)
             super().__init__(cyl, name=name)
+        
         self._add_face_pointer('front', cs.origin, -cs.zax.np)
         self._add_face_pointer('back', cs.origin+height*cs.zax.np, cs.zax.np)
         self._add_face_pointer('bottom', cs.origin, -cs.zax.np)