emerge 1.0.5__tar.gz → 1.0.7__tar.gz

{emerge-1.0.5 → emerge-1.0.7}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "1.0.5"
+current_version = "1.0.7"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{emerge-1.0.5 → emerge-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 1.0.5
+Version: 1.0.7
 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,7 +11,8 @@ 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

{emerge-1.0.5 → emerge-1.0.7}/emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "1.0.5"
+__version__ = "1.0.7"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -33,7 +33,7 @@ os.environ["OPENBLAS_NUM_THREADS"] = NTHREADS
 os.environ["VECLIB_NUM_THREADS"] = NTHREADS
 os.environ["VECLIB_MAXIMUM_THREADS"] = NTHREADS
 os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
-os.environ["NUMBA_NUM_THREADS"] = "4"
+os.environ["NUMBA_NUM_THREADS"] = os.getenv("NUMBA_NUM_THREADS", default="4")
 os.environ.setdefault("NUMBA_THREADING_LAYER", "workqueue")
 
 ############################################################

{emerge-1.0.5 → emerge-1.0.7}/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.5 → emerge-1.0.7}/emerge/_emerge/geo/horn.py

@@ -17,6 +17,7 @@
 
 from ..geometry import GeoVolume
 from ..cs import CoordinateSystem
+from ..selection import FaceSelection
 
 import gmsh # type: ignore
 
@@ -103,4 +104,19 @@ class Horn(GeoVolume):
         
         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)
+        self._add_face_pointer('back', pc + height/2*dax, dax)
+        
+    @property
+    def front(self) -> FaceSelection:
+        """The first local -Z face of the Horn."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back local +Z face of the Horn."""
+        return self.face('back')
+    
+    @property
+    def sides(self) -> FaceSelection:
+        """The outside faces excluding the top and bottom."""
+        return self.boundary(exclude=('front','back'))

{emerge-1.0.5 → emerge-1.0.7}/emerge/_emerge/geo/pcb.py

@@ -1331,7 +1331,6 @@ class PCB:
         poly._aux_data['width'] = stripline.width*self.unit
         poly._aux_data['height'] = height*self.unit
         poly._aux_data['vdir'] = self.cs.zax
-        poly._aux_data['idir'] = Axis(self.cs.xax.np*stripline.dirright[0] + self.cs.yax.np*stripline.dirright[1])
         
         return poly
 
@@ -1346,6 +1345,7 @@ class PCB:
                   point: StripLine,
                   height: float,
                   width_multiplier: float = 5.0,
+                  width: float | None = None,
                   name: str | None = 'ModalPort'
                   ) -> GeoSurface:
         """Generate a wave-port as a GeoSurface.
@@ -1365,11 +1365,16 @@ class PCB:
         
         height = (self.thickness + height)
         
+        if width is not None:
+            W = width
+        else:
+            W = point.width*width_multiplier
+            
         ds = point.dirright
-        x0 = point.x - ds[0]*point.width*width_multiplier/2
-        y0 = point.y - ds[1]*point.width*width_multiplier/2
+        x0 = point.x - ds[0]*W/2
+        y0 = point.y - ds[1]*W/2
         z0 =  - self.thickness
-        ax1 = np.array([ds[0], ds[1], 0])*self.unit*point.width*width_multiplier
+        ax1 = np.array([ds[0], ds[1], 0])*self.unit*W
         ax2 = np.array([0,0,1])*height*self.unit
 
         plate = Plate(np.array([x0,y0,z0])*self.unit, ax1, ax2, name=name)
@@ -1443,7 +1448,7 @@ 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.thickness)
+        poly._store('thickness', self.trace_thickness)
         return poly
     
     @overload
@@ -1508,6 +1513,5 @@ class PCB:
         
         if merge:
             polys = unite(*polys)
-            
         return polys
 

{emerge-1.0.5 → emerge-1.0.7}/emerge/_emerge/geo/polybased.py

@@ -231,7 +231,22 @@ class GeoPrism(GeoVolume):
         tagslist = [self._face_tags(name) for name in  self._face_pointers.keys() if name not in exclude]
         
         tags = list(reduce(lambda a,b: a+b, tagslist))
-        return FaceSelection(tags)       
+        return FaceSelection(tags)
+    
+    @property
+    def front(self) -> FaceSelection:
+        """The first local -Z face of the prism."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back local +Z face of the prism."""
+        return self.face('back')
+    
+    @property
+    def sides(self) -> FaceSelection:
+        """The outside faces excluding the top and bottom."""
+        return self.boundary(exclude=('front','back'))
 
 class XYPolygon:
     """This class generalizes a polygon in an un-embedded XY space that can be embedded in 3D space.

{emerge-1.0.5 → emerge-1.0.7}/emerge/_emerge/geo/shapes.py

@@ -97,6 +97,35 @@ class Box(GeoVolume):
         self._add_face_pointer('top', pc + height/2*hax, hax)
         self._add_face_pointer('bottom', pc - height/2*hax, -hax)
         
+    @property
+    def left(self) -> FaceSelection:
+        """The left (-X) face."""
+        return self.face('left')
+    
+    @property
+    def right(self) -> FaceSelection:
+        """The right (+X) face."""
+        return self.face('right')
+    
+    @property
+    def top(self) -> FaceSelection:
+        """The top (+Z) face."""
+        return self.face('top')
+    
+    @property
+    def bottom(self) -> FaceSelection:
+        """The bottom (-Z) face."""
+        return self.face('bottom')
+    
+    @property
+    def front(self) -> FaceSelection:
+        """The front (-Y) face."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back (+Y) face."""
+        return self.face('back')
     
     def outside(self, *exclude: Literal['bottom','top','right','left','front','back']) -> FaceSelection:
         """Select all outside faces except for the once specified by outside
@@ -131,6 +160,11 @@ class Sphere(GeoVolume):
         x,y,z = position
         self.tags: list[int] = [gmsh.model.occ.addSphere(x,y,z,radius),]
 
+    @property
+    def outside(self) -> FaceSelection:
+        """The outside boundary of the sphere.
+        """
+        return self.boundary()
 
 class XYPlate(GeoSurface):
     """Generates and XY-plane oriented plate
@@ -301,6 +335,21 @@ class Cylinder(GeoVolume):
 
         xo, yo, zo = self.cs.in_global_cs(x.flatten(), y.flatten(), z.flatten())
         return xo, yo, zo
+    
+    @property
+    def front(self) -> FaceSelection:
+        """The first local -Z face of the cylinder."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back local +Z face of the cylinder."""
+        return self.face('back')
+    
+    @property
+    def shell(self) -> FaceSelection:
+        """The outside faces excluding the top and bottom."""
+        return self.boundary(exclude=('front','back'))
 
 
 class CoaxCylinder(GeoVolume):
@@ -382,6 +431,16 @@ class CoaxCylinder(GeoVolume):
         xo, yo, zo = self.cs.in_global_cs(x.flatten(), y.flatten(), z.flatten())
         return xo, yo, zo
     
+    @property
+    def front(self) -> FaceSelection:
+        """The first local -Z face of the cylinder."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back local +Z face of the cylinder."""
+        return self.face('back')
+    
 class HalfSphere(GeoVolume):
     """A half sphere volume."""
     _default_name: str = 'HalfSphere'
@@ -411,7 +470,25 @@ class HalfSphere(GeoVolume):
         self._add_face_pointer('back',np.array(position), np.array(direction))
         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))
 
+    @property
+    def outside(self) -> FaceSelection:
+        """The outside of the sphere excluding the flat disc face
+
+        Returns:
+            FaceSelection: _description_
+        """
+        return self.boundary(exclude=('disc',))
+    
+    @property
+    def disc(self) -> FaceSelection:
+        """The flat disc face that cuts the sphere in half
+
+        Returns:
+            FaceSelection: _description_
+        """
+        return self.face('disc')
 
 class OldBox(GeoVolume):
     '''The sided box class creates a box just like the Box class but with selectable face tags.
@@ -564,4 +641,19 @@ class Cone(GeoVolume):
         
         self._add_face_pointer('front', p0, ds)
         if r2>0:
-            self._add_face_pointer('back', p0+ds, ds)
+            self._add_face_pointer('back', p0+ds, ds)
+            
+    @property
+    def front(self) -> FaceSelection:
+        """The first local -Z face of the Cone."""
+        return self.face('front')
+    
+    @property
+    def back(self) -> FaceSelection:
+        """The back local +Z face of the Cone. If the tip of the cone has a 0 radius, no back face can be selected."""
+        return self.face('back')
+    
+    @property
+    def shell(self) -> FaceSelection:
+        """The outside faces excluding the top and bottom."""
+        return self.boundary(exclude=('front','back'))

{emerge-1.0.5 → emerge-1.0.7}/emerge/_emerge/geometry.py

@@ -549,17 +549,26 @@ class GeoObject:
         self._priority = _GEOMANAGER.highest_priority()+10
         return self
     
-    def boundary(self, exclude: tuple[FaceNames,...] | None = None, 
+    def boundary(self, 
+                 exclude: Iterable[FaceNames,...] | str | None = None, 
                  tags: list[int] | None = None,
                  tool: GeoObject | None = None) -> FaceSelection:
         """Returns the complete set of boundary faces.
-
+        
         If implemented, it is possible to exclude a set of faces based on their name
-        or a list of tags (integers)
+        or a list of tags.
+        
+        Args:
+            exclude: (Iterable[str], str, None): A single string or list/tuple of strings.
+            tags: A list of face integers (if known)
+            tool: The tool object to base the selection face names one.
 
         Returns:
             FaceSelection: The selected faces
         """
+        if isinstance(exclude, str):
+            exclude = (exclude,)
+            
         if exclude is None:
             exclude = tuple()
             
@@ -572,17 +581,23 @@ class GeoObject:
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
         return FaceSelection([t for d,t in dimtags if t not in tags])
     
-    def face(self, name: FaceNames, tool: GeoObject | None = None) -> FaceSelection:
+    def face(self, name: FaceNames = None, tool: GeoObject | None = None, no: FaceNames = None) -> FaceSelection:
         """Returns the FaceSelection for a given face name.
         
         The face name must be defined for the type of geometry.
 
+        FaceNames include: front, back, left, right, top, bottom, disc
+        
         Args:
             name (FaceNames): The name of the face to select.
+            tool (GeoObject, None): Which object should be used as a source for the face selection.
+            no (FaceNames): If everything BUT a face name should be selected, Equivalent to .boundary(exclude=name).
 
         Returns:
             FaceSelection: The selected face
         """
+        if no is not None:
+            return self.boundary(exclude=no)
         
         return FaceSelection(self._face_tags(name, tool))
 
@@ -593,6 +608,7 @@ class GeoObject:
 
         Args:
             name (FaceNames): The name of the face to select.
+            tool (GeoObject, None): The tool object to use as source of the selection.
 
         Returns:
             FaceSelection: The selected face
@@ -633,10 +649,12 @@ class GeoVolume(GeoObject):
     specific geometry data.'''
     dim = 3
     _default_name: str = 'GeoVolume'
+    
     def __init__(self, tag: int | Iterable[int], name: str | None = None):
         super().__init__(name=name)
         
         self.tags: list[int] = []
+        
         if isinstance(tag, Iterable):
             self.tags = list(tag)
         else:

{emerge-1.0.5 → emerge-1.0.7}/emerge/_emerge/material.py

@@ -14,10 +14,11 @@
 # 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 typing import Callable
 import inspect
+from .const import C0
 
 
 def num_args(func):
@@ -58,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])
@@ -328,7 +329,7 @@ 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))
         self._metal: bool = _metal
-        
+    
     def __getstate__(self):
         state = self.__dict__.copy()
         for k in self._pickle_exclude:
@@ -401,6 +402,34 @@ class Material:
     def color_rgb(self) -> tuple[float,float,float]:
         return self._color_rgb
      
+    @staticmethod
+    def drude_model(conductivity: float, 
+                    colission_time: float, 
+                    er: float = 1.0,
+                    ur: float = 1.0, 
+                    color: str = "#aaaaaa", 
+                    opacity: float = 0.3,
+                    metal: bool = True) -> Material:
+        """Creates a Material using the Drume model for conductivity
+        Requires at least the DC bulk condutivity σ₀ [S/m] and the
+        collision time τ.
+
+        Args:
+            conductivity (float): The DC bulk conductivity σ₀ in S/m
+            colission_time (float): The collision time.
+            er (float, optional): The dielectric constant. Defaults to 1.0.
+            ur (float, optional): The relative permeability. Defaults to 1.0.
+            color (str, optional): The material rendering color. Defaults to "#aaaaaa".
+            opacity (float, optional): The material rendering opacity. Defaults to 0.3.
+            metal (bool, optional): If it should be rendered as a metal.. Defaults to True.
+
+        Returns:
+            Material: The resultant material.
+        """
+        colission_dist = colission_time/C0
+        fsigma = FreqDependent(scalar = lambda f: conductivity/(1 - 1j*2*np.pi*f*colission_dist))
+        return Material(er, ur, 0.0, fsigma, color=color, opacity=opacity, _metal=metal)
+    
 AIR = Material(color="#4496f3", opacity=0.05, name='Air')
 COPPER = Material(cond=5.8e7, color="#62290c", _metal=True, name='Copper')
 PEC = Material(color="#ff78aa", opacity=1.0, cond=1e30, _metal=True, name="PEC")

{emerge-1.0.5 → emerge-1.0.7}/emerge/_emerge/mesh3d.py

@@ -196,7 +196,6 @@ class Mesh3D(Mesh):
             raise ValueError(f'There is no tetrahedron with indices {i1}, {i2}, {i3}, {i4}')
         return output
         
-
     def get_tetrahedra(self, vol_tags: Union[int, list[int]]) -> np.ndarray:
         if isinstance(vol_tags, int):
             vol_tags = [vol_tags,]
@@ -270,6 +269,37 @@ class Mesh3D(Mesh):
             nodes.update(self.get_nodes(tags))
         return np.array([i for i, tet in enumerate(self.tets.T) if not set(tet).isdisjoint(nodes)])
 
+    def _get_dimtags(self, nodes: list[int] | None = None, edges: list[int] | None = None) -> list[tuple[int, int]]:
+        """Returns the geometry dimtags associated with a set of nodes and edges"""
+        if nodes is None:
+            nodes = []
+        if edges is None:
+            edges = []
+        nodes = set(nodes)
+        edges = set(edges)
+        dimtags = []
+        
+        # Test faces
+        for tag, f_nodes in self.ftag_to_node.items():
+            if set(f_nodes).isdisjoint(nodes):
+                continue
+            dimtags.append((2,tag))
+        
+        for tag, f_edges in self.ftag_to_edge.items():
+            if set(f_edges).isdisjoint(edges):
+                continue
+            dimtags.append((2,tag))
+        
+        # test volumes
+        for tag, f_tets in self.vtag_to_tet.items():
+            v_nodes = set(self.tets[:,f_tets].flatten())
+            if not v_nodes.isdisjoint(nodes):
+                dimtags.append((3,tag))
+            v_edges = set(self.tet_to_edge[:,f_tets].flatten())
+            if not v_edges.isdisjoint(edges):
+                dimtags.append((3,tag))
+        return sorted(dimtags)
+    
     def get_nodes(self, face_tags: Union[int, list[int]]) -> np.ndarray:
         '''Returns a numpyarray of all the nodes that belong to the given face tags'''
         if isinstance(face_tags, int):
@@ -572,7 +602,7 @@ class Mesh3D(Mesh):
                 materials.append(vol.material)
                 vol.material._hash_key = i
                 i += 1
-        
+            
         xs = self.centers[0,:]
         ys = self.centers[1,:]
         zs = self.centers[2,:]
@@ -597,7 +627,7 @@ class Mesh3D(Mesh):
     def plot_gmsh(self) -> None:
         gmsh.fltk.run()
 
-    def find_edge_groups(self, edge_ids: np.ndarray) -> list[tuple[Any,...]]:
+    def find_edge_groups(self, edge_ids: np.ndarray) -> list[tuple[int,...]]:
         """
         Find the groups of edges in the mesh.
 

{emerge-1.0.5 → emerge-1.0.7}/emerge/_emerge/mesher.py

@@ -75,6 +75,7 @@ class Mesher:
         self.objects: list[GeoObject] = []
         self.size_definitions: list[tuple[int, float]] = []
         self.mesh_fields: list[int] = []
+        self._amr_fields: list[int] = []
         self.min_size: float = None
         self.max_size: float = None
         self.periodic_cell: PeriodicCell = None
@@ -222,8 +223,13 @@ class Mesher:
         gmsh.model.mesh.field.set_numbers(ctag, "CurvesList", tags)
         gmsh.model.mesh.field.set_number(ctag, "VIn", max_size)
         self.mesh_fields.append(ctag)
+    
+    def _reset_amr_points(self) -> None:
+        for tag in self._amr_fields:
+            gmsh.model.mesh.field.remove(tag)
+        self._amr_fields = []
         
-    def _set_size_on_point(self, tags: list[int], max_size: float) -> None:
+    def _set_amr_point(self, tags: list[int], max_size: float) -> None:
         """Define the size of the mesh on a point
 
         Args:
@@ -233,7 +239,7 @@ class Mesher:
         ctag = gmsh.model.mesh.field.add("Constant")
         gmsh.model.mesh.field.set_numbers(ctag, "PointsList", tags)
         gmsh.model.mesh.field.set_number(ctag, "VIn", max_size)
-        self.mesh_fields.append(ctag)
+        self._amr_fields.append(ctag)
 
     def _configure_mesh_size(self, discretizer: Callable, resolution: float):
         """Defines the mesh sizes based on a discretization callable.
@@ -267,7 +273,7 @@ class Mesher:
             logger.debug(f'Setting mesh size:{1000*size:.3f}mm in domains: {tag}')
             self._set_size_in_domain([tag,], size)
 
-        gmsh.model.mesh.field.setNumbers(mintag, "FieldsList", self.mesh_fields)
+        gmsh.model.mesh.field.setNumbers(mintag, "FieldsList", self.mesh_fields + self._amr_fields)
         gmsh.model.mesh.field.setAsBackgroundMesh(mintag)
 
         for tag, size in self.size_definitions:
@@ -279,8 +285,21 @@ class Mesher:
         logger.trace(f'Unsetting mesh size constraint for domains: {dimtags}')
         for dimtag in dimtags:
             gmsh.model.mesh.setSizeFromBoundary(dimtag[0], dimtag[1], 0)
-            
-    def set_boundary_size(self, boundary: GeoObject | Selection | Iterable, 
+    
+    def add_refinement_point(self,
+                             coordinate: np.ndarray,
+                             refinement: float,
+                             size: float,
+                             gr: float = 1.5):
+        x0, y0, z0 = coordinate
+        disttag = gmsh.model.mesh.field.add("MathEval")
+        newsize = refinement*size
+        funcstr = f"({newsize})/({gr}) - (1-{gr})/({gr}) * Sqrt((x-({x0}))^2+ (y-({y0}))^2 + (z-({z0}))^2)"
+        gmsh.model.mesh.field.setString(disttag, "F", funcstr)
+        self.mesh_fields.append(disttag)
+        
+    def set_boundary_size(self, 
+                          boundary: GeoObject | Selection | Iterable, 
                           size:float,
                           growth_rate: float = 1.4,
                           max_size: float | None = None) -> None: