emerge 0.6.7__py3-none-any.whl → 0.6.8__py3-none-any.whl

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.6.7"
+__version__ = "0.6.8"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -45,7 +45,7 @@ LOG_CONTROLLER.set_default()
 logger.debug('Importing modules')
 
 from ._emerge.simmodel import Simulation
-from ._emerge.material import Material
+from ._emerge.material import Material, FreqCoordDependent, FreqDependent, CoordDependent
 from ._emerge import bc
 from ._emerge.solver import SolverBicgstab, SolverGMRES, SolveRoutine, ReverseCuthillMckee, Sorter, SolverPardiso, SolverUMFPACK, SolverSuperLU, EMSolver
 from ._emerge.cs import CoordinateSystem, CS, GCS, Plane, Axis, XAX, YAX, ZAX, XYPLANE, XZPLANE, YZPLANE, YXPLANE, ZXPLANE, ZYPLANE

emerge/_emerge/_cache_check.py

@@ -22,7 +22,7 @@ _COMPILE_MESSAGE = """
  [ EMERGE ]
 ⚠  Numba is compiling optimized code; this may take a few minutes.
    • Additional functions may be compiled on-the-fly.
-   • Compilation happens only once—subsequent runs load from cache.
+   • Compilation happens only once-subsequent runs load from cache.
    Please wait…"""
 
 @njit(cache=True)

emerge/_emerge/elements/femdata.py

@@ -64,7 +64,7 @@ class FEMBasis:
     def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         raise NotImplementedError()
     
-    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, constants: np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, constants: np.ndarray, tetids: np.ndarray | None = None, usenan: bool = True) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Interpolates the curl of the field at the given points.
         """
@@ -151,7 +151,8 @@ class FEMBasis:
     def interpolate_index(self, xs: np.ndarray,
                     ys: np.ndarray,
                     zs: np.ndarray,
-                    tetids: np.ndarray | None = None) -> np.ndarray:
+                    tetids: np.ndarray | None = None,
+                    usenan: bool = True) -> np.ndarray:
         raise NotImplementedError()
     
     def map_edge_to_field(self, edge_ids: np.ndarray) -> np.ndarray:

emerge/_emerge/elements/index_interp.py

@@ -27,9 +27,8 @@ def index_interp(coords: np.ndarray,
     # Solution has shape (nEdges, nsols)
     nNodes = coords.shape[1]
     
-    prop = np.zeros((nNodes, ), dtype=np.int64)
+    prop = np.full((nNodes, ), -1, dtype=np.int64)
     
-
     for i_iter in range(tetids.shape[0]):
         itet = tetids[i_iter]
         

emerge/_emerge/elements/ned2_interp.py

@@ -130,10 +130,10 @@ def ned2_tet_interp(coords: np.ndarray,
     ys = coords[1,:]
     zs = coords[2,:]
 
-    Ex = np.zeros((nNodes, ), dtype=np.complex128)
-    Ey = np.zeros((nNodes, ), dtype=np.complex128)
-    Ez = np.zeros((nNodes, ), 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)
+    
     for i_iter in range(tetids.shape[0]):
         itet = tetids[i_iter]
 
@@ -259,9 +259,9 @@ def ned2_tet_interp_curl(coords: np.ndarray,
     ys = coords[1,:]
     zs = coords[2,:]
 
-    Ex = np.zeros((nNodes, ), dtype=np.complex128)
-    Ey = np.zeros((nNodes, ), dtype=np.complex128)
-    Ez = np.zeros((nNodes, ), 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)
 
     for i_iter in range(tetids.shape[0]):
         itet = tetids[i_iter]
@@ -382,9 +382,9 @@ def ned2_tri_interp(coords: np.ndarray,
     xs = coords[0,:]
     ys = coords[1,:]
 
-    Ex = np.zeros((nNodes, ), dtype=np.complex128)
-    Ey = np.zeros((nNodes, ), dtype=np.complex128)
-    Ez = np.zeros((nNodes, ), 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)
 
     nodes = nodes[:2,:]
 
@@ -491,9 +491,9 @@ def ned2_tri_interp_full(coords: np.ndarray,
     xs = coords[0,:]
     ys = coords[1,:]
 
-    Ex = np.zeros((nNodes, ), dtype=np.complex128)
-    Ey = np.zeros((nNodes, ), dtype=np.complex128)
-    Ez = np.zeros((nNodes, ), 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)
 
     nodes = nodes[:2,:]
 
@@ -572,9 +572,9 @@ def ned2_tri_interp_curl(coords: np.ndarray,
     xs = coords[0,:]
     ys = coords[1,:]
     jB = 1j*beta
-    Ex = np.zeros((nNodes, ), dtype=np.complex128)
-    Ey = np.zeros((nNodes, ), dtype=np.complex128)
-    Ez = np.zeros((nNodes, ), 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)
 
     nodes = nodes[:2,:]
 

emerge/_emerge/elements/nedelec2.py

@@ -68,30 +68,41 @@ class Nedelec2(FEMBasis):
 
         self.empty_tri_rowcol()
     
-    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, tetids: np.ndarray | None = None, usenan: bool = True) -> 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)
+        vals = 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)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals
     
-    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, c: np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, c: np.ndarray, tetids: np.ndarray | None = None, usenan: bool = True) -> 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)
+        vals = 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)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals
     
     def interpolate_index(self, xs: np.ndarray,
                         ys: np.ndarray,
                         zs: np.ndarray,
-                        tetids: np.ndarray | None = None) -> np.ndarray:
+                        tetids: np.ndarray | None = None,
+                        usenan: bool = True) -> 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)
+        vals = index_interp(np.array([xs, ys, zs]), self.mesh.tets, self.mesh.nodes, tetids)
+        if not usenan:
+            vals[vals==-1]==0
+        return vals
+    
     ###### INDEX MAPPINGS
 
     def local_tet_to_triid(self, itet: int) -> np.ndarray:

emerge/_emerge/elements/nedleg2.py

@@ -73,24 +73,30 @@ class FieldFunctionClass:
         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]:
+    def calcE(self, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         coordinates = np.array([xs, ys])
-        return ned2_tri_interp_full(coordinates, 
+        vals = ned2_tri_interp_full(coordinates, 
                                self.field, 
                                self.tris,  
                                self.nodes, 
                                self.tri_to_field)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals
     
-    def calcH(self, xs: np.ndarray, ys: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def calcH(self, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         coordinates = np.array([xs, ys])
         
-        return ned2_tri_interp_curl(coordinates, 
+        vals = ned2_tri_interp_curl(coordinates, 
                                self.field, 
                                self.tris,  
                                self.nodes, 
                                self.tri_to_field,
                                self.diadic,
                                self.beta)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals
 
 ############### Nedelec2 Class
 
@@ -178,22 +184,28 @@ class NedelecLegrange2(FEMBasis):
 
         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]:
+    def tri_interpolate(self, field, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         coordinates = np.array([xs, ys])
-        return ned2_tri_interp_full(coordinates, 
+        vals = ned2_tri_interp_full(coordinates, 
                                field, 
                                self.mesh.tris,  
                                self.local_nodes, 
                                self.tri_to_field)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals
     
-    def tri_interpolate_curl(self, field, xs: np.ndarray, ys: np.ndarray, diadic: np.ndarray | None = None, beta: float = 0.0) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def tri_interpolate_curl(self, field, xs: np.ndarray, ys: np.ndarray, diadic: np.ndarray | None = None, beta: float = 0.0, usenan: bool = False) -> 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)) # type: ignore
-        return ned2_tri_interp_curl(coordinates, 
+        vals = ned2_tri_interp_curl(coordinates, 
                                field, 
                                self.mesh.tris,  
                                self.local_nodes, 
                                self.tri_to_field,
                                diadic,
-                               beta)
+                               beta)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals

emerge/_emerge/geo/__init__.py

@@ -19,6 +19,6 @@ from .pcb import PCB
 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
+from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect, unite, expand_surface, stretch
 from .polybased import XYPolygon, GeoPrism, Disc, Curve
 from .step import STEPItems

emerge/_emerge/geo/horn.py

@@ -17,7 +17,6 @@
 
 from ..geometry import GeoVolume
 from ..cs import CoordinateSystem
-from ..selection import FaceSelection
 
 import gmsh # type: ignore
 

emerge/_emerge/geo/modeler.py

@@ -381,7 +381,7 @@ class Modeler:
         self._add_function(function)
         return self
     
-    def cyllinder(self,
+    def cylinder(self,
                   radius: float | Series,
                   height: float | Series,
                   position: tuple[float | Series, float | Series, float | Series],

emerge/_emerge/geo/operations.py

@@ -268,6 +268,19 @@ def change_coordinate_system(main: GeoObject,
         fp.affine_transform(M2)
     return main
 
+def stretch(main: GeoObject, fx: float = 1, fy: float = 1, fz: float = 1, origin: tuple[float, float, float] = (0.0, 0.0, 0.0)) -> GeoObject:
+    """Stretches a geometry with a factor fx, fy and fz along the x, y and Z axes respectively
+    
+    The stretch origin is centered at the provided origin.
+
+    Returns:
+        _type_: _description_
+    """
+    gmsh.model.occ.dilate(main.dimtags, *origin, fx, fy, fz)
+    
+    return main
+
+
 @overload
 def unite(*objects: GeoVolume) -> GeoVolume: ...
 

emerge/_emerge/geo/pcb_tools/calculator.py

@@ -20,9 +20,8 @@ class PCBCalculator:
         self.mat = material
         self.unit = unit
 
-
-    def z0(self, Z0: float, layer: int = -1, ground_layer: int = 0):
+    def z0(self, Z0: float, layer: int = -1, ground_layer: int = 0, f0: float = 1e9):
         th = abs(self.layers[layer] - self.layers[ground_layer])*self.unit
         ws = np.geomspace(1e-6,1e-1,101)
-        Z0ms = microstrip_z0(ws, th, self.mat.er)
+        Z0ms = microstrip_z0(ws, th, self.mat.er.scalar(f0))
         return np.interp(Z0, Z0ms[::-1], ws[::-1])/self.unit

emerge/_emerge/geo/pmlbox.py

@@ -17,7 +17,7 @@
 
 from ..geometry import GeoVolume
 from .shapes import Box, Alignment, Plate
-from ..material import Material, AIR
+from ..material import Material, AIR, CoordDependent
 import numpy as np
 from functools import partial
 
@@ -31,6 +31,15 @@ def _add_pml_layer(center: tuple[float, float, float],
                    exponent: float,
                    deltamax: float,
                    material: Material) -> GeoVolume:
+    
+    if material.frequency_dependent:
+        raise ValueError('EMerge cannot handle frequency dependent material properties for PML layers at this point.')
+    if material.coordinate_dependent:
+        raise ValueError('Its not possible to define PML regions for materials that are coordinate dependent.')
+    
+    mater = material.er.scalar(1e9)
+    matur = material.ur.scalar(1e9)
+    
     px, py, pz = center
     W,D,H = dims
     dx, dy, dz = direction
@@ -69,15 +78,16 @@ def _add_pml_layer(center: tuple[float, float, float],
     
     def ermat(x, y, z):
         ers = np.zeros((3,3,x.shape[0]), dtype=np.complex128)
-        ers[0,0,:] = material.er * syf(x,y,z)*szf(x,y,z)/sxf(x,y,z)
-        ers[1,1,:] = material.er * szf(x,y,z)*sxf(x,y,z)/syf(x,y,z)
-        ers[2,2,:] = material.er * sxf(x,y,z)*syf(x,y,z)/szf(x,y,z)
+        ers[0,0,:] = mater * syf(x,y,z)*szf(x,y,z)/sxf(x,y,z)
+        ers[1,1,:] = mater * szf(x,y,z)*sxf(x,y,z)/syf(x,y,z)
+        ers[2,2,:] = mater * sxf(x,y,z)*syf(x,y,z)/szf(x,y,z)
         return ers
+    
     def urmat(x, y, z):
         urs = np.zeros((3,3,x.shape[0]), dtype=np.complex128)
-        urs[0,0,:] = material.ur * syf(x,y,z)*szf(x,y,z)/sxf(x,y,z)
-        urs[1,1,:] = material.ur * szf(x,y,z)*sxf(x,y,z)/syf(x,y,z)
-        urs[2,2,:] = material.ur * sxf(x,y,z)*syf(x,y,z)/szf(x,y,z)
+        urs[0,0,:] = matur * syf(x,y,z)*szf(x,y,z)/sxf(x,y,z)
+        urs[1,1,:] = matur * szf(x,y,z)*sxf(x,y,z)/syf(x,y,z)
+        urs[2,2,:] = matur * sxf(x,y,z)*syf(x,y,z)/szf(x,y,z)
         return urs
     
     pml_box = Box(*pml_block_size, new_center, alignment=Alignment.CENTER)
@@ -106,7 +116,9 @@ def _add_pml_layer(center: tuple[float, float, float],
             plate = Plate(np.array([p0x-tW/2, p0y-tD/2, p0z-dz*thickness/2 + dz*(n+1)*thl]), ax1, ax2)
             planes.append(plate)
     
-    pml_box.material = Material(_neff=np.sqrt(material.er*material.ur), _fer=ermat, _fur=urmat, color='#bbbbff', opacity=0.1)
+    erfunc = CoordDependent(max_value=mater, matrix=ermat)
+    urfunc = CoordDependent(max_value=matur, matrix=urmat)
+    pml_box.material = Material(er=erfunc, ur=urfunc,_neff=np.sqrt(mater*matur), color='#bbbbff', opacity=0.1)
     pml_box.max_meshsize = thickness/N_mesh_layers
     pml_box._embeddings = planes
     
@@ -121,9 +133,10 @@ def pmlbox(width: float,
             material: Material = AIR,
             thickness: float = 0.1,
             Nlayers: int = 1,
-            N_mesh_layers: int = 8,
+            N_mesh_layers: int = 5,
             exponent: float = 1.5,
             deltamax: float = 8.0,
+            sides: str = '',
             top: bool = False,
             bottom: bool = False,
             left: bool = False,
@@ -145,10 +158,11 @@ def pmlbox(width: float,
         alignment (Alignment, optional): Which point of the box is placed at the given coordinate. Defaults to Alignment.CORNER.
         material (Material, optional): The material of the box. Defaults to AIR.
         thickness (float, optional): The thickness of the PML Layer. Defaults to 0.1.
-        Nlayers (int, optional): The number of PML layers (1 is reccomended). Defaults to 1.
-        N_mesh_layers (int, optional): The number of mesh layers. Sets the discretization size accordingly. Defaults to 8
+        Nlayers (int, optional): The number of geometrical PML layers. Defaults to 1.
+        N_mesh_layers (int, optional): The number of mesh layers. Sets the discretization size accordingly. Defaults to 5
         exponent (float, optional): The PML gradient growth function. Defaults to 1.5.
         deltamax (float, optional): A PML matching coefficient. Defaults to 8.0.
+        sides (str, optional): A string of pml sides as characters ([T]op, [B]ottom, [L]eft, [R]ight, [F]ront, b[A]ck)
         top (bool, optional): Add a top PML layer. Defaults to True.
         bottom (bool, optional): Add a bottom PML layer. Defaults to False.
         left (bool, optional): Add a left PML layer. Defaults to False.
@@ -159,6 +173,16 @@ def pmlbox(width: float,
     Returns:
         list[GeoVolume]: A list of objects [main box, *pml boxes]
     """
+    
+    sides = sides.lower()
+
+    top    = "t" in sides or top
+    bottom = "b" in sides or bottom
+    left   = "l" in sides or left
+    right  = "r" in sides or right
+    front  = "f" in sides or front
+    back   = "a" in sides or back
+
     px, py, pz = position
     if alignment == Alignment.CORNER:
         px = px + width / 2

emerge/_emerge/geometry.py

@@ -376,7 +376,7 @@ class GeoObject:
         return self
     
     def prio_up(self) -> GeoObject:
-        """Increase priority by 1
+        """Increases the material selection priority by 1
 
         Returns:
             GeoObject: _description_
@@ -385,7 +385,7 @@ class GeoObject:
         return self
     
     def prio_down(self) -> GeoObject:
-        """Decrase priority by 1
+        """Decreases the material selection priority by 1
 
         Returns:
             GeoObject: _description_
@@ -394,7 +394,7 @@ class GeoObject:
         return self
 
     def background(self) -> GeoObject:
-        """Set the priority to be on the background.
+        """Set the material selection priority to be on the background.
 
         Returns:
             GeoObject: _description_
@@ -403,7 +403,7 @@ class GeoObject:
         return self
 
     def foreground(self) -> GeoObject:
-        """Set the priority to be on top.
+        """Set the material selection priority to be on top.
 
         Returns:
             GeoObject: _description_