emerge 1.0.6__tar.gz → 1.1.0__tar.gz

{emerge-1.0.6 → emerge-1.1.0}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "1.0.6"
+current_version = "1.1.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"
@@ -29,6 +29,9 @@ filename = "pyproject.toml"
 [[tool.bumpversion.files]]
 filename = "src/emerge/__init__.py"
 
+[[tool.bumpversion.files]]
+filename = "examples/demo0_parallel_plate.py"
+
 [[tool.bumpversion.files]]
 filename = "examples/demo1_stepped_imp_filter.py"
 
@@ -69,4 +72,7 @@ filename = "examples/demo12_mode_alignment.py"
 filename = "examples/demo13_helix_antenna.py"
 
 [[tool.bumpversion.files]]
-filename = "examples/demo14_boundary_selection.py"
+filename = "examples/demo14_boundary_selection.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo15_strip_slotline_transition.py"

{emerge-1.0.6 → emerge-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 1.0.6
+Version: 1.1.0
 Summary: An open source EM FEM simulator in Python
 Project-URL: Homepage, https://github.com/FennisRobert/EMerge
 Project-URL: Issues, https://github.com/FennisRobert/EMerge/issues
@@ -11,14 +11,19 @@ Requires-Dist: joblib>=1.5.1
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib>=3.8.0
 Requires-Dist: mkl!=2024.0; platform_machine == 'x86_64' or platform_machine == 'AMD64'
-Requires-Dist: numba>=0.57.0
+Requires-Dist: numba<=0.60.0,>=0.57.0; platform_system == 'Linux'
+Requires-Dist: numba>=0.57.0; platform_system != 'Linux'
 Requires-Dist: numpy<2.3,>=1.24
 Requires-Dist: pyvista>=0.45.2
 Requires-Dist: scipy>=1.14.0
 Provides-Extra: cudss
 Requires-Dist: cupy-cuda12x; extra == 'cudss'
-Requires-Dist: nvidia-cudss-cu12; extra == 'cudss'
-Requires-Dist: nvmath-python[cu12]; extra == 'cudss'
+Requires-Dist: nvidia-cudss-cu12==0.5.0.16; extra == 'cudss'
+Requires-Dist: nvmath-python[cu12]==0.5.0; extra == 'cudss'
+Provides-Extra: cudss12
+Requires-Dist: cupy-cuda12x; extra == 'cudss12'
+Requires-Dist: nvidia-cudss-cu12==0.5.0.16; extra == 'cudss12'
+Requires-Dist: nvmath-python[cu12]==0.5.0; extra == 'cudss12'
 Provides-Extra: dxf
 Requires-Dist: ezdxf; extra == 'dxf'
 Provides-Extra: umfpack

{emerge-1.0.6 → emerge-1.1.0}/emerge/__init__.py

@@ -16,13 +16,23 @@ along with this program; if not, see
 <https://www.gnu.org/licenses/>.
 
 """
-import os
+############################################################
+#                    WARNING SUPPRESSION                   #
+############################################################
 
-__version__ = "1.0.6"
+import warnings
+warnings.filterwarnings(
+    "ignore",
+    category=DeprecationWarning,
+    message="builtin type swigvarlink.*"
+)
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
 ############################################################
+import os
+
+__version__ = "1.1.0"
 
 NTHREADS = "1"
 os.environ["EMERGE_STD_LOGLEVEL"] = os.getenv("EMERGE_STD_LOGLEVEL", default="INFO")
@@ -36,6 +46,7 @@ os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
 os.environ["NUMBA_NUM_THREADS"] = os.getenv("NUMBA_NUM_THREADS", default="4")
 os.environ.setdefault("NUMBA_THREADING_LAYER", "workqueue")
 
+
 ############################################################
 #                      IMPORT MODULES                     #
 ############################################################
@@ -48,7 +59,7 @@ logger.debug('Importing modules')
 LOG_CONTROLLER._set_log_buffer()
 
 import gmsh
-from ._emerge.simmodel import Simulation
+from ._emerge.simmodel import Simulation, SimulationBeta
 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

{emerge-1.0.6 → emerge-1.1.0}/emerge/_emerge/elements/index_interp.py

@@ -61,3 +61,48 @@ def index_interp(coords: np.ndarray,
         prop[inside] = itet
 
     return prop
+
+@njit(f8[:](f8[:,:], i8[:,:], f8[:,:], i8[:], f8[:]), cache=True, nogil=True)
+def constant_interp(coords: np.ndarray,
+                tets: np.ndarray, 
+                nodes: np.ndarray,
+                tetids: np.ndarray,
+                value: np.ndarray):
+    ''' Nedelec 2 tetrahedral interpolation of the analytic curl'''
+    # Solution has shape (nEdges, nsols)
+    nNodes = coords.shape[1]
+    
+    prop = np.full((nNodes, ), 0, dtype=np.float64)
+    
+    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] = value[itet]
+
+    return prop

{emerge-1.0.6 → emerge-1.1.0}/emerge/_emerge/geo/pcb.py

@@ -934,12 +934,14 @@ class StripPath:
         return self.path[element_nr]
 
 class PCBLayer:
-    
+    _DEFNAME: str = 'PCBLayer'
     def __init__(self, 
                  thickness: float,
-                 material: Material):
+                 material: Material,
+                 name: str | None = None):
         self.th: float = thickness
         self.mat: Material = material
+        self.name: str = _NAME_MANAGER(name, self._DEFNAME)
         
 ############################################################
 #                     PCB DESIGN CLASS                     #
@@ -976,6 +978,7 @@ class PCB:
 
         self.thickness: float = thickness
         self._stack: list[PCBLayer] = []
+        
         if zs is not None:
             self._zs = zs
             self.thickness = np.max(zs)-np.min(zs)
@@ -1029,9 +1032,15 @@ class PCB:
         self.calc: PCBCalculator = PCBCalculator(self.thickness, self._zs, self.material, self.unit)
 
         self.name: str = _NAME_MANAGER(name, self._DEFNAME)
-        
+    
+
+    ############################################################
+    #                          PROPERTIES                     #
+    ############################################################
+
     @property
     def trace(self) -> GeoPolygon:
+        ""
         tags = []
         for trace in self.traces:
             tags.extend(trace.tags)
@@ -1040,29 +1049,36 @@ class PCB:
     
     @property
     def all_objects(self) -> list[GeoPolygon]:
-        return self.traces + self.ports
-    
-
-    def z(self, layer: int) -> float:
-        """Returns the z-height of the given layer number counter from 1 (bottom) to N (top)
-
-        Args:
-            layer (int): The layer number (1 to N)
+        """Returns all objects gnerated by the PCB layer.
 
         Returns:
-            float: the z-height
+            list[GeoPolygon]: _description_
         """
-        if layer <= 0:
-            return self._zs[layer]
-        return self._zs[layer-1]
+        return self.traces + self.ports
     
     @property
     def top(self) -> float:
+        """ The top conductor later height (z-value in meters)."""
         return self._zs[-1]
     
     @property
     def bottom(self) -> float:
+        """The bottom conductor layer height (z-value in meters)
+
+        """
         return self._zs[0]
+
+
+    ############################################################
+    #                       PRIVATE FUNCTIONS                  #
+    ############################################################
+
+    def _lumped_element(self, poly: XYPolygon, function: Callable, width: float, length: float, name: str | None = 'LumpedElement') -> None:
+        geopoly = poly._finalize(self.cs, name=name)
+        geopoly._aux_data['func'] = function
+        geopoly._aux_data['width'] = width
+        geopoly._aux_data['height'] = length
+        self.lumped_elements.append(geopoly)
     
     def _get_z(self, element: RouteElement) -> float :
         """Return the z-height of a given Route Element
@@ -1077,12 +1093,62 @@ class PCB:
             if path._has(element):
                 return path.z
         raise RouteException('Requesting z-height of route element that is not contained in a path.')
+    
+    def __call__(self, path_nr: int) -> StripPath:
+        if path_nr >= len(self.paths):
+            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:
+        """ Generates a GeoPoly out of a list of (x,y) coordinate tuples.
+        
+        
+        Args:
+            xys (list[tuple[float, float]]): A list of (x,y) coordinate tuples.
+            z (float, optional): The z-height of the polygon. Defaults to the top layer.
+            name (str, optional): The name of the polygon.
+            """
+        ptags = []
+        for x,y in xys:
+            px, py, pz = self.cs.in_global_cs(x*self.unit, y*self.unit, z*self.unit)
+            ptags.append(gmsh.model.occ.addPoint(px, py, pz))
+        
+        ltags = []
+        for t1, t2 in zip(ptags[:-1], ptags[1:]):
+            ltags.append(gmsh.model.occ.addLine(t1, t2))
+        ltags.append(gmsh.model.occ.addLine(ptags[-1], ptags[0]))
+        
+        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)
+        return poly
+    
+
+    ############################################################
+    #                        USER FUNCTIONS                   #
+    ############################################################
+
+    def z(self, layer: int) -> float:
+        """Returns the z-height of the given layer number counter from 1 (bottom) to N (top)
+
+        Args:
+            layer (int): The layer number (1 to N)
+
+        Returns:
+            float: the z-height
+        """
+        if layer <= 0:
+            return self._zs[layer]
+        return self._zs[layer-1]
 
     def add_vias(self, *coordinates: tuple[float, float], radius: float,
                  z1: float | None = None,
                  z2: float | None = None,
                  segments: int = 6) -> None:
-        """Add a series of vias provided by a list of coordinates.
+        """Add a series of vias provided by a list of coordinates. 
+        
+        Vias will not be created yet. To generate the actual geometries use the function .generate_vias().
         
         Make sure to define the radius explicitly, otherwise the radius gets interpreted as a coordinate:
         
@@ -1118,10 +1184,7 @@ class PCB:
                     return poly
             raise ValueError(f'There is no stripline or coordinate under the name of {name}')
     
-    def __call__(self, path_nr: int) -> StripPath:
-        if path_nr >= len(self.paths):
-            self.paths.append(StripPath(self))
-        return self.paths[path_nr]
+    
     
     def determine_bounds(self, 
                          leftmargin: float = 0,
@@ -1207,19 +1270,46 @@ class PCB:
         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:
+        x0, y0 = pos
+        dx, dy = direction
+        
+        rx, ry = dy, -dx
+
+        points = []
+        if w0==0:
+            points.append(pos)
+        else:
+            points.append((x0-rx*w0/2, y0-ry*w0/2))
+            points.append((x0+rx*w0/2, y0+ry*w0/2))
+        
+        angs = np.linspace(-angle/2, angle/2, Nsections)*np.pi/180
+        c0 = x0 + 1j*y0
+        vec = length*dx + 1j*length*dy
+        for a in angs:
+            p = c0 + vec*np.exp(1j*a)
+            points.append((p.real, p.imag))
+        
+        xs, ys = zip(*points)
+        self.add_poly(xs, ys, z, material, name)
+        
     def generate_pcb(self, 
                 split_z: bool = True,
-                merge: bool = True) -> GeoVolume:
+                merge: bool = True) -> list[GeoVolume] | GeoVolume:
         """Generate the PCB Block object
 
+        Args:
+            split_z (bool, optional): If a PCB consisting of a thickness, material and n_layers should be split in sub domains. Defaults to True
+            merge: (bool, optional): If an output list of multiple volumes should be merged into a single object.
+        
         Returns:
-            GeoVolume: The PCB Block
+            GeoVolume | List[GeoVolume]: The PCB Block or blocks
         """
         x0, y0, z0 = self.origin*self.unit
         
-        Nmats = len(set([layer.mat.name for layer in self._stack]))
+        n_materials = len(set([layer.mat.name for layer in self._stack]))
         
-        if split_z and self._zs.shape[0]>2 or Nmats > 1:
+        if split_z and self._zs.shape[0]>2 or n_materials > 1:
             
             boxes: list[GeoVolume] = []
             for i, (z1, z2, layer) in enumerate(zip(self._zs[:-1],self._zs[1:],self._stack)):
@@ -1228,12 +1318,12 @@ class PCB:
                           self.length*self.unit,
                           h*self.unit,
                           position=(x0, y0, z0+z1*self.unit),
-                          name=f'{self.name}_layer{i}')
+                          name=layer.name)
                 box.material = layer.mat
                 box = change_coordinate_system(box, self.cs)
                 box.prio_set(self.dielectric_priority)
                 boxes.append(box)
-            if merge and Nmats == 1:
+            if merge and n_materials == 1:
                 return GeoVolume.merged(boxes).prio_set(self.dielectric_priority) # type: ignore
             return boxes # type: ignore
         
@@ -1247,7 +1337,7 @@ class PCB:
         box = change_coordinate_system(box, self.cs)
         return box # type: ignore
 
-    def generate_air(self, height: float, name: str = 'PCBAirbox') -> GeoVolume:
+    def generate_air(self, height: float, name: str = 'PCBAirbox', bottom: bool = False) -> GeoVolume:
         """Generate the Air Block object
 
         This requires that the width, depth and origin are deterimed. This 
@@ -1256,11 +1346,16 @@ class PCB:
         Returns:
             GeoVolume: The PCB Block
         """
+        dz = 0
+        
         x0, y0, z0 = self.origin*self.unit
+        if bottom:
+            dz = z0-self.thickness*self.unit-height*self.unit
+            
         box = Box(self.width*self.unit, 
                   self.length*self.unit, 
                   height*self.unit, 
-                  position=(x0,y0,z0),
+                  position=(x0,y0,z0+dz),
                   name=name)
         box = change_coordinate_system(box, self.cs)
         return box # type: ignore
@@ -1334,16 +1429,9 @@ class PCB:
         
         return poly
 
-    def _lumped_element(self, poly: XYPolygon, function: Callable, width: float, length: float, name: str | None = 'LumpedElement') -> None:
-        geopoly = poly._finalize(self.cs, name=name)
-        geopoly._aux_data['func'] = function
-        geopoly._aux_data['width'] = width
-        geopoly._aux_data['height'] = length
-        self.lumped_elements.append(geopoly)
-
     def modal_port(self,
                   point: StripLine,
-                  height: float,
+                  height: float | tuple[float, float],
                   width_multiplier: float = 5.0,
                   width: float | None = None,
                   name: str | None = 'ModalPort'
@@ -1362,8 +1450,12 @@ class PCB:
         Returns:
             GeoSurface: The GeoSurface object that can be used for the waveguide.
         """
-        
-        height = (self.thickness + height)
+        if isinstance(height, tuple):
+            dz, height = height
+        else:
+            dz = 0
+            
+        height = (self.thickness + height + dz)
         
         if width is not None:
             W = width
@@ -1373,7 +1465,7 @@ class PCB:
         ds = point.dirright
         x0 = point.x - ds[0]*W/2
         y0 = point.y - ds[1]*W/2
-        z0 =  - self.thickness
+        z0 =  - self.thickness - dz
         ax1 = np.array([ds[0], ds[1], 0])*self.unit*W
         ax2 = np.array([0,0,1])*height*self.unit
 
@@ -1428,28 +1520,9 @@ class PCB:
         """
         if material is None:
             material = self.trace_material
-        poly = PCBPoly(xs, ys, z, material,name=name)
+        poly = PCBPoly(xs, ys, z, material, name=name)
         
         self.polies.append(poly)
-        
-
-    def _gen_poly(self, xys: list[tuple[float, float]], z: float, name: str | None = None) -> GeoPolygon:
-        """ Generates a GeoPoly out of a list of (x,y) coordinate tuples"""
-        ptags = []
-        for x,y in xys:
-            px, py, pz = self.cs.in_global_cs(x*self.unit, y*self.unit, z*self.unit)
-            ptags.append(gmsh.model.occ.addPoint(px, py, pz))
-        
-        ltags = []
-        for t1, t2 in zip(ptags[:-1], ptags[1:]):
-            ltags.append(gmsh.model.occ.addLine(t1, t2))
-        ltags.append(gmsh.model.occ.addLine(ptags[-1], ptags[0]))
-        
-        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)
-        return poly
     
     @overload
     def compile_paths(self, merge: Literal[True]) -> GeoSurface: ...

{emerge-1.0.6 → emerge-1.1.0}/emerge/_emerge/geo/shapes.py

@@ -160,11 +160,14 @@ class Sphere(GeoVolume):
         x,y,z = position
         self.tags: list[int] = [gmsh.model.occ.addSphere(x,y,z,radius),]
 
+        gmsh.model.occ.synchronize()
+        self._add_face_pointer('outside', tag=self.boundary().tags[0])
+        
     @property
     def outside(self) -> FaceSelection:
         """The outside boundary of the sphere.
         """
-        return self.boundary()
+        return self.face('outside')
 
 class XYPlate(GeoSurface):
     """Generates and XY-plane oriented plate
@@ -471,15 +474,16 @@ class HalfSphere(GeoVolume):
         self._add_face_pointer('bottom',np.array(position), np.array(direction))
         self._add_face_pointer('face',np.array(position), np.array(direction))
         self._add_face_pointer('disc',np.array(position), np.array(direction))
-
+        
+        gmsh.model.occ.synchronize()
+        self._add_face_pointer('outside', tag=self.boundary(exclude='disc').tags[0])
+        
     @property
     def outside(self) -> FaceSelection:
-        """The outside of the sphere excluding the flat disc face
-
-        Returns:
-            FaceSelection: _description_
+        """The outside boundary of the half sphere.
         """
-        return self.boundary(exclude=('disc',))
+        return self.face('outside')
+
     
     @property
     def disc(self) -> FaceSelection:

{emerge-1.0.6 → emerge-1.1.0}/emerge/_emerge/geometry.py

@@ -88,15 +88,12 @@ class _GeometryManager:
     def sign_in(self, modelname: str) -> None:
         # if modelname not in self.geometry_list:
         #     self.geometry_list[modelname] = []
-        if modelname is self.geometry_list:
-            logger.warning(f'{modelname} already exist, Geometries will be reset.')
         self.geometry_list[modelname] = dict()
         self.geometry_names[modelname] = set()
         self.active = modelname
 
     def reset(self, modelname: str) -> None:
-        self.geometry_list[modelname] = dict()
-        self.geometry_names[modelname] = set()
+        self.sign_in(modelname)
     
     def lowest_priority(self) -> int:
         return min([geo._priority for geo in self.all_geometries()])
@@ -123,9 +120,9 @@ class _FacePointer:
              normals: list[np.ndarray]) -> list[int]:
         tags = []
         for (d,t), o, n in zip(dimtags, origins, normals):
-            normdist = np.abs((o-self.o)@self.n)
+            normdist = np.abs((o-self.o) @ self.n)
             dotnorm = np.abs(n@self.n)
-            if normdist < 1e-3 and dotnorm > 0.99:
+            if normdist < 1e-5 and dotnorm > 0.999:
                 tags.append(t)
         return tags
     
@@ -257,7 +254,7 @@ class GeoObject:
         self._embeddings: list[GeoObject] = []
         self._face_pointers: dict[str, _FacePointer] = dict()
         self._tools: dict[int, dict[str, _FacePointer]] = dict()
-        
+        self._hidden: bool = False
         self._key = _GENERATOR.new()
         self._aux_data: dict[str, Any] = dict()
         self._priority: int = 10
@@ -617,7 +614,25 @@ class GeoObject:
         for name in names:
             tags.extend(self._face_tags(name, tool))
         return FaceSelection(tags)
-        
+    
+    def hide(self) -> GeoObject:
+        """Hides the object from views
+
+        Returns:
+            GeoObject: _description_
+        """
+        self._hidden = True
+        return self
+    
+    def unhide(self) -> GeoObject:
+        """Unhides the object from views
+
+        Returns:
+            GeoObject: _description_
+        """
+        self._hidden = False
+        return self
+    
     @property
     def dimtags(self) -> list[tuple[int, int]]:
         return [(self.dim, tag) for tag in self.tags]

{emerge-1.0.6 → emerge-1.1.0}/emerge/_emerge/logsettings.py

@@ -17,7 +17,7 @@
 
 from loguru import logger
 import sys
-from typing import Literal
+from typing import Literal, Generator
 from pathlib import Path
 import os
 from collections import deque
@@ -132,4 +132,28 @@ class LogController:
         self.file_level = loglevel
         os.environ["EMERGE_FILE_LOGLEVEL"] = loglevel
 
-LOG_CONTROLLER = LogController()
+class DebugCollector:
+    """The DebugController is used by EMerge to collect heuristic
+    warnings for detections of things that might be causing problems but aren't
+    guaranteed to cause them. These logs will be printed at the end of a simulation
+    to ensure that users are aware of them if they abort simulations.
+    
+    """
+    def __init__(self):
+        self.reports: list[str] = []
+    
+    @property
+    def any_warnings(self) -> bool:
+        return len(self.reports)>0
+    
+    def add_report(self, message: str):
+        self.reports.append(message)
+        
+    def all_reports(self) -> Generator[tuple[int, str], None, None]:
+        
+        for i, message in enumerate(self.reports):
+            yield i+1, message
+
+
+LOG_CONTROLLER = LogController()
+DEBUG_COLLECTOR = DebugCollector()

{emerge-1.0.6 → emerge-1.1.0}/emerge/_emerge/material.py

@@ -59,7 +59,7 @@ class MatProperty:
         self._z: np.ndarray = np.array([], dtype=np.float64)
         
         self._fmax = lambda f: value
-
+        
     def initialize(self, x: np.ndarray, y: np.ndarray, z: np.ndarray, ids: np.ndarray) -> None:
         self._apply_to = np.concatenate([self._apply_to, ids])
         self._x = np.concatenate([self._x, x])