emerge 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

emerge/__init__.py

@@ -1,5 +1,5 @@
 """A Python based FEM solver.
-Copyright (C) 2025  name of Robert Fennis
+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
@@ -36,7 +36,7 @@ os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
 ############################################################
 #                      IMPORT MODULES                     #
 ############################################################
-
+from ._emerge import _cache_check
 from ._emerge.logsettings import LOG_CONTROLLER
 from loguru import logger
 

emerge/_emerge/__init__.py

@@ -1,5 +1,5 @@
 # """A Python based FEM solver.
-# Copyright (C) 2025  name of Robert Fennis
+# 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
@@ -15,28 +15,3 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-# """
-# import os
-
-# os.environ["OMP_NUM_THREADS"] = "1"
-# os.environ["MKL_NUM_THREADS"] = "1"
-# os.environ["OPENBLAS_NUM_THREADS"] = "1"
-
-# from loguru import logger
-# from .logsettings import logger_format
-# import sys
-
-# logger.remove()
-# logger.add(sys.stderr, format=logger_format)
-
-# logger.debug('Importing modules')
-# from _emerge.simmodel import Simulation3D
-# from _emerge.material import Material, FR4, AIR, VACUUM, COPPER
-# import bc
-# from _emerge.solver import superlu_info, SolverBicgstab, SolverGMRES, SolveRoutine, ReverseCuthillMckee, Sorter, SolverPardiso, SolverUMFPACK
-# from _emerge.cs import CoordinateSystem, Plane, Axis, XAX, YAX, ZAX, XYPLANE, XZPLANE, YZPLANE, YXPLANE, ZXPLANE, ZYPLANE
-# from _emerge.coord import Line
-# import geo
-# from _emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
-# from _emerge.mth.common_functions import norm
-# logger.debug('Importing complete!')

emerge/_emerge/_cache_check.py

@@ -0,0 +1,46 @@
+# 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.core import event, types
+from numba import njit
+
+_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.
+   Please wait…"""
+
+@njit(cache=True)
+def _donothing(a):
+    return a
+
+class Notify(event.Listener):
+    def on_start(self, ev):
+        f = ev.data['dispatcher']
+        sig = ev.data['args']
+        if f is _donothing:          # limit to the function you care about
+            sig = ev.data['args']
+            print(_COMPILE_MESSAGE)
+
+    def on_end(self, ev):        # unused here
+        pass
+
+
+# install listener only for this block:
+with event.install_listener("numba:compile", Notify()):
+    _donothing(0) 

emerge/_emerge/bc.py

@@ -64,17 +64,8 @@ class BoundaryCondition:
         return self.dimension.value
     
     def __repr__(self) -> str:
-        if self.dimension is BCDimension.ANY:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.EDGE:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.NODE:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.FACE:
-            return f'{type(self).__name__}{self.tags}'
-        elif self.dimension is BCDimension.DOMAIN:
-            return f'{type(self).__name__}{self.tags}'
-    
+        return f'{type(self).__name__}{self.tags}'
+
     def __str__(self) -> str:
         return self.__repr__()
     
@@ -183,7 +174,7 @@ class BoundaryConditionSet:
         Returns:
             list[BoundaryCondition]: The list of boundary conditions
         """
-        return [item for item in self. boundary_conditions if isinstance(item, bctype)]
+        return [item for item in self.boundary_conditions if isinstance(item, bctype)]
 
     def reset(self) -> None:
         """Resets the boundary conditions that are defined

emerge/_emerge/const.py

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

emerge/_emerge/elements/nedleg2.py

@@ -22,7 +22,7 @@ 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
-
+from ..const import MU0, C0
 
 ## TODO: TEMPORARY SOLUTION FIX THIS
 
@@ -158,7 +158,7 @@ class NedelecLegrange2(FEMBasis):
 
     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))
+        constant = 1j / ((k0*C0)*MU0)
         urinv = np.zeros_like(ur)
         
         for i in range(ur.shape[2]):

emerge/_emerge/geo/pcb.py

@@ -17,9 +17,6 @@
 
 from __future__ import annotations
 
-import numpy as np
-import gmsh
-
 from ..cs import CoordinateSystem, GCS, Axis
 from ..geometry import GeoPolygon, GeoVolume, GeoSurface
 from ..material import Material, AIR, COPPER
@@ -28,11 +25,14 @@ from .polybased import XYPolygon
 from .operations import change_coordinate_system
 from .pcb_tools.macro import parse_macro
 from .pcb_tools.calculator import PCBCalculator
+
+import numpy as np
 from loguru import logger
 from typing import Literal, Callable, overload
 from dataclasses import dataclass
-import math
 
+import math
+import gmsh
 
 ############################################################
 #                        EXCEPTIONS                        #
@@ -63,7 +63,15 @@ def normalize(vector: np.ndarray) -> np.ndarray:
         return vector
     return vector / norm
 
-def _rot_mat(angle):
+def _rot_mat(angle: float) -> np.ndarray:
+    """Returns a 2D rotation matrix given an angle in degrees
+
+    Args:
+        angle (float): The angle in degrees
+
+    Returns:
+        np.ndarray: The rotation matrix
+    """
     ang = -angle * np.pi/180
     return np.array([[np.cos(ang), -np.sin(ang)], [np.sin(ang), np.cos(ang)]])
 
@@ -265,6 +273,66 @@ class StripTurn(RouteElement):
         else:
             raise RouteException(f'Trying to route a StripTurn with an unknown corner type: {self.corner_type}')
  
+class StripCurve(StripTurn):
+    def __init__(self,
+                 x: float,
+                 y: float,
+                 width: float,
+                 direction: tuple[float, float],
+                 angle: float,
+                 radius: float,
+                 dang: float = 10.0):
+        self.xold: float = x
+        self.yold: float = y
+        self.width: float = width
+        self.old_direction: np.ndarray = normalize(np.array(direction))
+        self.direction: np.ndarray = _rot_mat(angle) @ self.old_direction
+        self.angle: float = angle
+        self.radius: float = radius
+        self.dirright: np.ndarray = np.array([self.old_direction[1], -self.old_direction[0]])
+        self.dang: float = dang
+
+        angd = abs(angle*np.pi/180)
+        self.start = np.array([x,y])
+        self.circ_origin = self.start + radius * np.sign(angle) * self.dirright
+
+        self._xhat = -self.dirright * np.sign(angle)
+        self._yhat = self.old_direction
+        
+        self.end = self.circ_origin + radius*(self._xhat*np.cos(angd)+self._yhat*np.sin(angd))
+        self.x, self.y = self.end
+
+    def __str__(self) -> str:
+        return f'StripCurve[{self.x},{self.y},w={self.width},d=({self.direction})]'
+
+    @property
+    def right(self) -> list[tuple[float, float]]:
+        points: list[tuple[float, float]] = []
+        Npts = int(np.ceil(abs(self.angle/self.dang)))
+        R = self.radius-np.sign(self.angle)*self.width/2
+        print(R, self.circ_origin, self._xhat, self._yhat)
+        for i in range(Npts):
+            ang = abs((i+1)/Npts * self.angle * np.pi/180)
+            pnew = self.circ_origin + R*(self._xhat*np.cos(ang)+self._yhat*np.sin(ang))
+            points.append((pnew[0], pnew[1]))
+        
+        return points
+
+    @property
+    def left(self) -> list[tuple[float, float]]:
+        points: list[tuple[float, float]] = []
+
+        Npts = int(np.ceil(abs(self.angle/self.dang)))
+        R = self.radius+np.sign(self.angle)*self.width/2
+        print(R, self.circ_origin, self._xhat, self._yhat)
+        for i in range(Npts):
+            ang = abs((i+1)/Npts * self.angle * np.pi/180)
+            pnew = self.circ_origin + R*(self._xhat*np.cos(ang)+self._yhat*np.sin(ang))
+            points.append((pnew[0], pnew[1]))
+        
+        return points[::-1]
+
+    
 ############################################################
 #                    THE STRIP PATH CLASS                  #
 ############################################################
@@ -405,7 +473,9 @@ class StripPath:
         """
         x, y = self.end.x, self.end.y
         dx, dy = self.end.direction
-        
+        if abs(angle) <= 20:
+            corner_type = 'square'
+            logger.warning('Small turn detected, defaulting to rectangular corners because chamfers would add to much detail.')
         if width is not None:
             if width != self.end.width:
                 self._add_element(StripLine(x, y, width, (dx, dy)))
@@ -413,6 +483,37 @@ class StripPath:
             width=self.end.width
         self._add_element(StripTurn(x, y, width, (dx, dy), angle, corner_type))
         return self
+
+    def curve(self, angle: float, radius: float,
+             width: float | None = None, 
+             corner_type: Literal['champher','square'] = 'champher',
+             dang: float = 10) -> StripPath:
+        """Adds a bend to the strip path.
+
+        The angle is specified in degrees. The width of the turn will be the same as the last segment.
+        optionally, a different width may be provided. 
+        By default, all corners will be cut using the "champher" type. Other options are not yet provided.
+
+        Args:
+            angle (float): The turning angle
+            width (float, optional): The stripline width. Defaults to None.
+            corner_type (str, optional): The corner type. Defaults to 'champher'.
+
+        Returns:
+            StripPath: The current StripPath object
+        """
+        if angle == 0:
+            logger.trace('Zero angle turn, passing action')
+            return self
+        x, y = self.end.x, self.end.y
+        dx, dy = self.end.direction
+        if width is not None:
+            if width != self.end.width:
+                self._add_element(StripLine(x, y, width, (dx, dy)))
+        else:
+            width=self.end.width
+        self._add_element(StripCurve(x, y, width, (dx, dy), angle, radius, dang=dang))
+        return self
     
     def store(self, name: str) -> StripPath:
         """ Store the current x,y coordinate labeled in the PCB object.
@@ -495,7 +596,6 @@ class StripPath:
         self.pcb._lumped_element(poly, impedance_function, width, length)
         return self.pcb.new(x+dx*length, y+dy*length, self.end.width, self.end.direction, self.z)
 
-
     def cut(self) -> StripPath:
         """Split the current path in N new paths given by a new departure direction
 
@@ -637,7 +737,7 @@ class StripPath:
     def to(self, dest: tuple[float, float], 
            arrival_dir: tuple[float, float] | None = None,
            arrival_margin: float  | None= None,
-           angle_step: float = 90):
+           angle_step: float = 90) -> StripPath:
         """
         Extend the path from current end point to dest (x, y).
         Optionally ensure arrival in arrival_dir after a straight segment of arrival_margin.
@@ -743,9 +843,8 @@ class StripPath:
         back_ang = math.degrees(math.atan2(cross2, dot2))
         
         backoff = math.tan(abs(back_ang)*np.pi/360)*self.end.width/2
-        self.straight(s - backoff)
-        
 
+        self.straight(s - backoff)
         self.turn(-back_ang)
 
         x0 = self.end.x
@@ -753,7 +852,6 @@ class StripPath:
         D = math.hypot(tx-x0, ty-y0)
         # 4) Final straight into destination by arrival_margin + t
         self.straight(D)
-        
 
         return self
 
@@ -801,7 +899,7 @@ class StripPath:
         return self.path[element_nr]
 
 ############################################################
-#                     PCB DESIGN CLASS                    #
+#                     PCB DESIGN CLASS                     #
 ############################################################
 
 class PCB:
@@ -1270,7 +1368,6 @@ class PCB:
             polys.material = COPPER
         return polys
                 
-
 ############################################################
 #                        DEPRICATED                       #
 ############################################################

emerge/_emerge/geo/pcb_tools/calculator.py

@@ -1,9 +1,9 @@
 import numpy as np
 from ...material import Material
+from ...const import Z0 as n0
 
 PI = np.pi
 TAU = 2*PI
-n0 = 376.73
 
 def microstrip_z0(W: float, th: float, er: float):
     u = W/th
@@ -14,7 +14,7 @@ def microstrip_z0(W: float, th: float, er: float):
 
 class PCBCalculator:
 
-    def __init__(self, thickness: float, layers: np.array, material: Material, unit: float):
+    def __init__(self, thickness: float, layers: np.ndarray, material: Material, unit: float):
         self.th = thickness
         self.layers = layers
         self.mat = material

emerge/_emerge/geometry.py

@@ -299,7 +299,7 @@ class GeoObject:
         for tag in self.tags:
             newtags.extend(tagmap.get(tag, [tag,]))
         self.tags = newtags
-        logger.debug(f'Replaced {self.old_tags} with {self.tags}')
+        logger.debug(f'{self} Replaced {self.old_tags} -> {self.tags}')
     
     def update_tags(self, tag_mapping: dict[int,dict]) -> GeoObject:
         ''' Update the tag definition of a GeoObject after fragementation.'''

emerge/_emerge/logsettings.py

@@ -1,34 +1,52 @@
+# 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 loguru import logger
 import sys
 from typing import Literal
 from enum import Enum
 from pathlib import Path
 import os
-
+import gmsh
 
 ############################################################
 #                          FORMATS                         #
 ############################################################
 
 TRACE_FORMAT = (
-    "{time: YY/MM/DD - (ddd) - HH:mm:ss.SSSS} | <green>{elapsed}</green> [ <level>{level}</level> ] "
-    " <level>{message}</level>"
+    "{time:ddd YY/MM/DD HH:mm:ss.SSSS} {level:<7} {thread.id:<15} {line:>4}: "
+    "{message}"
 )
+
 DEBUG_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 INFO_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 WARNING_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 ERROR_FORMAT = (
-    "<green>{elapsed}</green> [<level>{level}</level>] "
-    " <level>{message}</level>"
+    "<green>{elapsed}</green>  <level>{level:<7}</level>: "
+    "<level>{message}</level>"
 )
 FORMAT_DICT = {
     'TRACE': TRACE_FORMAT,
@@ -71,10 +89,8 @@ class LogController:
         logger.configure(handlers=[handler]) # type: ignore
         self.level = loglevel
         os.environ["EMERGE_STD_LOGLEVEL"] = loglevel
-        
 
     def set_write_file(self, path: Path, loglevel: str = 'TRACE'):
-
         handler_id = logger.add(str(path / 'logging.log'), mode='w', level=loglevel, format=FORMAT_DICT.get(loglevel, INFO_FORMAT), colorize=False, backtrace=True, diagnose=True)
         self.file_handlers.append(handler_id)
         self.file_level = loglevel

emerge/_emerge/material.py

@@ -45,6 +45,10 @@ class Material:
         hex_str = self.color.lstrip('#')
         self._color_rgb = tuple(int(hex_str[i:i+2], 16)/255.0 for i in (0, 2, 4))
 
+    @property
+    def sigma(self) -> float:
+        return self.cond
+        
     @property
     def color_rgb(self) -> tuple[float,float,float]:
         return self._color_rgb

emerge/_emerge/mesh3d.py

@@ -455,15 +455,11 @@ class Mesh3D(Mesh):
         Returns:
             tuple[dict[int, int], np.ndarray, np.ndarray]: The node index mapping and the node index arrays
         """
-
-        def gen_key(coord, mult):
-            return tuple([int(round(c*mult)) for c in coord])
         
-        ftag_to_node = dict()
-        face_dimtags = gmsh.model.get_entities(2)
-
         node_ids_1 = []
         node_ids_2 = []
+
+        face_dimtags = gmsh.model.get_entities(2)
         
         for d,t in face_dimtags:
             domain_tag, f_tags, node_tags = gmsh.model.mesh.get_elements(2, t)
@@ -472,19 +468,23 @@ class Mesh3D(Mesh):
                 node_ids_1.extend(node_tags)
             if t in bc.face2.tags:
                 node_ids_2.extend(node_tags)
-            ftag_to_node[t] = node_tags
+
+
+        node_ids_1 = sorted(list(set(node_ids_1)))
+        node_ids_2 = sorted(list(set(node_ids_2)))
         
         all_node_ids = np.unique(np.array(node_ids_1 + node_ids_2))
         dsmin = shortest_distance(self.nodes[:,all_node_ids])
 
-        node_ids_1_arry = np.sort(np.unique(np.array(node_ids_1)))
-        node_ids_2_arry = np.sort(np.unique(np.array(node_ids_2)))
+        node_ids_1_arry = np.array(node_ids_1)
+        node_ids_2_arry = np.array(node_ids_2)
         dv = np.array(bc.dv)
         
         nodemap = pair_coordinates(self.nodes, node_ids_1_arry, node_ids_2_arry, dv, dsmin/2)
         node_ids_2_unsorted = [nodemap[i] for i in sorted(node_ids_1)]
         node_ids_2_sorted = sorted(node_ids_2_unsorted)
         conv_map = {i1: i2 for i1, i2 in zip(node_ids_2_unsorted, node_ids_2_sorted)}
+
         return conv_map, np.array(node_ids_2_unsorted), np.array(node_ids_2_sorted)
 
 

emerge/_emerge/mth/integrals.py

@@ -60,7 +60,7 @@ def _fast_integral_f(nodes, triangles, constants, DPTs, field_values):
 def surface_integral(nodes: np.ndarray, 
                      triangles: np.ndarray, 
                      function: Callable, 
-                     constants: np.ndarray = None,
+                     constants: np.ndarray | None = None,
                      gq_order: int = 4) -> complex:
     """Computes the surface integral of a scalar-field
 

emerge/_emerge/mth/pairing.py

@@ -47,7 +47,6 @@ def link_coords(coords: np.ndarray, ids1: np.ndarray, ids2: np.ndarray, disp: np
     for i1 in range(N):
         ictr = 0
         c1 = coords[:,ids1[i1]]
-
         for i2 in range(id_start, N):
             if available[i2] == 0:
                 continue
@@ -91,7 +90,7 @@ def pair_coordinates(coords: np.ndarray, ids1: np.ndarray, ids2: np.ndarray, dis
     ids2_c_sorted = sorted(ids2, key= lambda x: tuple(coords[:,x]-disp))
 
     mapping = link_coords(coords, np.array(ids1_c_sorted), np.array(ids2_c_sorted), disp, dsmax)
-
+    
     mapping = {i: j for i,j in zip(mapping[0,:], mapping[1,:])}
     
     return mapping

emerge/_emerge/periodic.py

@@ -31,7 +31,7 @@ def _pair_selection(f1: Selection, f2: Selection, translation: tuple[float, floa
     f2s = []
     for t1, c1 in zip(f1.tags, c1s):
         for t2, c2 in zip(f2.tags, c2s):
-            if np.linalg.norm((c1 + ds)-c2) < 1e-6:
+            if np.linalg.norm((c1 + ds)-c2) < 1e-8:
                 f1s.append(Selection([t1,]))
                 f2s.append(Selection([t2,]))
     return f1s, f2s

emerge/_emerge/physics/microwave/adaptive_freq.py

@@ -108,10 +108,6 @@ def vectfit_step(f: np.ndarray, s: np.ndarray, poles: np.ndarray) -> np.ndarray:
     b = np.concatenate((b.real, b.imag))
     x, residuals, rnk, s = np.linalg.lstsq(A, b, rcond=-1)
 
-    residues = x[:N]
-    d = x[N]
-    h = x[N+1]
-
     # We only want the "tilde" part in (A.4)
     x = x[-N:]
 
@@ -197,7 +193,7 @@ def vectfit_auto(f: np.ndarray,
     w = s.imag
     pole_locs = np.linspace(w[0], w[-1], n_poles+2)[1:-1]
     lr = loss_ratio
-    init_poles = poles = np.concatenate([[p*(-lr + 1j), p*(-lr - 1j)] for p in pole_locs])
+    poles = np.concatenate([[p*(-lr + 1j), p*(-lr - 1j)] for p in pole_locs])
 
     if inc_real:
         poles = np.concatenate((poles, [1]))