emerge 0.4.7__py3-none-any.whl → 0.4.8__py3-none-any.whl

emerge/__init__.py

@@ -28,7 +28,7 @@ os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
 
 
 from loguru import logger
-from _emerge.logsettings import logger_format
+from ._emerge.logsettings import logger_format
 import sys
 
 logger.remove()
@@ -36,19 +36,19 @@ logger.add(sys.stderr, format=logger_format)
 
 logger.debug('Importing modules')
 
-from _emerge.simmodel import Simulation3D
-from _emerge.material import Material
-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
-from _emerge.coord import Line
-from _emerge import geo
-from _emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
-from _emerge.mth.common_functions import norm, coax_rout, coax_rin
-from _emerge.physics.microwave.sc import stratton_chu
-from _emerge.periodic import RectCell, HexCell
-from _emerge.mesher import Algorithm2D, Algorithm3D
+from ._emerge.simmodel import Simulation3D
+from ._emerge.material import Material
+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
+from ._emerge.coord import Line
+from ._emerge import geo
+from ._emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
+from ._emerge.mth.common_functions import norm, coax_rout, coax_rin
+from ._emerge.physics.microwave.sc import stratton_chu
+from ._emerge.periodic import RectCell, HexCell
+from ._emerge.mesher import Algorithm2D, Algorithm3D
 from . import lib
-from _emerge.howto import _HowtoClass
+from ._emerge.howto import _HowtoClass
 howto = _HowtoClass()
 logger.debug('Importing complete!')

emerge/_emerge/__init__.py

@@ -0,0 +1,42 @@
+# """A Python based FEM solver.
+# Copyright (C) 2025  name of 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/>.
+
+# """
+# 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/bc.py

@@ -0,0 +1,197 @@
+# 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 __future__ import annotations
+from enum import Enum
+from loguru import logger
+from .selection import Selection, FaceSelection
+import numpy as np
+from .geometry import GeoObject
+
+class BCDimension(Enum):
+    ANY = -1
+    NODE = 0
+    EDGE = 1
+    FACE = 2
+    DOMAIN = 3
+
+def _unique(input: list[int]) -> list:
+    """ Returns a sorted list of all unique integers/floats in a list."""
+    output = sorted(list(set(input)))
+    return output
+
+class BoundaryCondition:
+    """A generalized class for all boundary condition objects.
+    """
+    
+    def __init__(self, assignment: GeoObject | Selection):
+
+        self.dimension: BCDimension = BCDimension.ANY
+        self.indices: list[int] = []
+        self.face_indices: list[int] = []
+        self.edge_indices: list[int] = []
+        
+        
+        if isinstance(assignment, GeoObject):
+            assignment = assignment.select
+        
+        self.selection: Selection = assignment
+        self.tags: list[int] = self.selection.tags
+    
+    @property
+    def dim(self) -> int:
+        ''' The dimension of the boundary condition as integer (0,1,2,3).'''
+        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}'
+    
+    def __str__(self) -> str:
+        return self.__repr__()
+    
+    def check_dimension(self, tags: list[tuple[int,int]]) -> None:
+        # check if all tags have the same timension (dim, tag)
+        if not isinstance(tags, list):
+            raise TypeError(f'Argument tags must be of type list, instead its {type(tags)}')
+        if len(tags) == 0:
+            return
+        if not all(isinstance(x, tuple) and len(x) == 2 for x in tags):
+            raise TypeError(f'Argument tags must be of type list of tuples, instead its {type(tags)}')
+        if not all(isinstance(x[0], int) and isinstance(x[1], int) for x in tags):
+            raise TypeError(f'Argument tags must be of type list of tuples of ints, instead its {type(tags)}')
+        if not all(x[0] == tags[0][0] for x in tags):
+            raise ValueError(f'All tags must have the same dimension, instead its {tags}')
+        dimension = tags[0][0]
+        if self.dimension is BCDimension.ANY:
+            logger.info(f'Assigning dimension {BCDimension(dimension)} to {self}')
+            self.dimension = BCDimension(dimension)
+        elif self.dimension != BCDimension(dimension):
+            raise ValueError(f'Current boundary condition has dimension {self.dimension}, but tags have dimension {BCDimension(dimension)}')
+        
+    def add_tags(self, tags: list[tuple[int,int]]) -> None:
+        """Adds the given taggs to this boundary condition.
+
+        Args:
+            tags (list[tuple[int,int]]): The tags to include
+        """
+        self.check_dimension(tags)
+        tags = [x[1] for x in tags]
+        self.tags = _unique(self.tags + tags)
+    
+    def remove_tags(self, tags: list[int]) -> list[int]:
+        """Removes the tags provided by tags from this boundary condition.
+
+        Return sonly the tags that are actually excluded from this face.
+
+        Args:
+            tags (list[int]): The tags to exclude.
+
+        Returns:
+            list[int]: A list of actually excluded tags.
+        """
+        excluded_edges = [x for x in self.tags if x in tags]
+        self.tags = [x for x in self.tags if x not in tags]
+        return excluded_edges
+    
+    def exclude_bc(self, other: BoundaryCondition) -> list[int]:
+        """Excludes all faces for a provided boundary condition object from this boundary condition assignment.
+
+        Args:
+            other (BoundaryCondition): The boundary condition of which the faces should be excluded
+
+        Returns:
+            list[int]: A list of excluded face tags.
+        """
+        return self.remove_tags(other.tags)
+
+class BoundaryConditionSet:
+
+    def __init__(self):
+
+        self.boundary_conditions: list[BoundaryCondition] = []
+        self._initialized: bool = False
+    
+    def _construct_bc(self, constructor: type):
+        def constr(*args, **kwargs):
+            obj = constructor(*args, **kwargs)
+            self.assign(obj)
+            return obj
+        return constr
+    
+    def count(self, bctype: type) -> int:
+        return len(self.oftype(bctype))
+    
+    def oftype(self, bctype: type) -> list[BoundaryCondition]:
+        return [item for item in self. boundary_conditions if isinstance(item, bctype)]
+
+    def reset(self) -> None:
+        self.boundary_conditions = []
+
+    def assign(self, 
+               bc: BoundaryCondition) -> None:
+        """Assign a boundary-condition object to a domain or list of domains.
+        This method must be called to submit any boundary condition object you made to the physics.
+
+        Args:
+            bcs *(BoundaryCondition): A list of boundary condition objects.
+        """
+        self._initialized = True
+        wordmap = {
+            0: 'point',
+            1: 'edge',
+            2: 'face',
+            3: 'domain'
+        }
+
+        bc.add_tags(bc.selection.dimtags)
+
+        logger.info('Excluding other possible boundary conditions')
+
+        for existing_bc in self.boundary_conditions:
+            excluded = existing_bc.exclude_bc(bc)
+            if excluded:
+                logger.debug(f'Removed the {excluded} tags from {wordmap[bc.dim]} BC {existing_bc}')
+        self.boundary_conditions.append(bc)
+
+class Periodic(BoundaryCondition):
+
+    def __init__(self, 
+                 selection1: FaceSelection,
+                 selection2: FaceSelection,
+                 dv: tuple[float,float,float],
+                 ):
+        self.face1: BoundaryCondition = BoundaryCondition(selection1)
+        self.face2: BoundaryCondition = BoundaryCondition(selection2)
+        super().__init__(FaceSelection(selection1.tags + selection2.tags))
+        self.dv: tuple[float,float,float] = dv
+        self.ux: float = 0
+        self.uy: float = 0
+        self.uz: float = 0
+
+    def phi(self, k0) -> complex:
+        dx, dy, dz = self.dv
+        return np.exp(-1j*k0*(self.ux*dx+self.uy*dy+self.uz*dz))
+    

emerge/_emerge/coord.py

@@ -0,0 +1,119 @@
+# 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 __future__ import annotations
+import numpy as np
+from typing import Callable
+
+def gauss3_composite(x: np.ndarray, y: np.ndarray) -> float:
+    """
+    Composite 3-point Gauss (order-2) integral
+    on *equally spaced* 1-D data.
+
+    Sections:
+        (x0,x1,x2), (x2,x3,x4), (x4,x5,x6), ...
+
+    The rule on one section [x_i, x_{i+2}] is
+
+        ∫ f dx  ≈  (h/2) Σ_k w_k · f( x̄ + (h/2) ξ_k )
+
+    where  h = x_{i+2}−x_i  and
+          ξ = (−√3/5, 0, +√3/5),
+          w = (8/9, 5/9, 8/9)  ← as requested.
+
+    Because f is only known at the three nodes, we
+    rebuild the quadratic that interpolates them and
+    evaluate that polynomial at the Gauss points.
+    """
+    x = np.asarray(x, dtype=np.complex128)
+    y = np.asarray(y, dtype=np.complex128)
+
+    if x.ndim != 1 or y.ndim != 1 or x.size != y.size:
+        raise ValueError("x and y must be 1-D arrays of equal length.")
+    if x.size % 2 == 0:
+        raise ValueError("Number of samples must be odd (… 0,1,2; 2,3,4; …).")
+
+    # constant spacing
+    h = x[1] - x[0]
+
+    # Gauss–Legendre nodes and *your* weights
+    xi = np.sqrt(3/5)
+    nodes   = np.array([-xi, 0.0, +xi])
+    weights = np.array([5/9, 8/9, 5/9])
+
+    total = 0.0
+    for i in range(0, x.size - 2, 2):
+        y0, y1, y2 = y[i:i+3]
+    #     array([[ 5.00000000e-01, -1.00000000e+00,  5.00000000e-01],
+    #    [-5.00000000e-01,  3.71914213e-17,  5.00000000e-01],
+    #    [-5.55111512e-17,  1.00000000e+00,  5.55111512e-17]])
+        # coefficients of the quadratic passing through
+        # (-1,y0), (0,y1), (1,y2) in local coords t
+        a = y0*0.5 - y1 + 0.5*y2
+        b = -y0*0.5 + 0.5*y2
+        c = y1
+
+        # local → global mapping
+        poly_vals = a*nodes**2 + b*nodes + c
+        total += np.dot(weights, poly_vals)
+
+    return total
+
+class Line:
+    """ A Line class used for convenient definition of integration lines"""
+    def __init__(self, xpts: np.ndarray,
+                 ypts: np.ndarray,
+                 zpts: np.ndarray):
+        self.xs: np.ndarray = xpts
+        self.ys: np.ndarray = ypts
+        self.zs: np.ndarray = zpts
+        self.dxs: np.ndarray = xpts[1:] - xpts[:-1]
+        self.dys: np.ndarray = ypts[1:] - ypts[:-1]
+        self.dzs: np.ndarray = zpts[1:] - zpts[:-1]
+        self.dl = np.sqrt(self.dxs**2 + self.dys**2 + self.dzs**2)
+        self.length: float = np.sum(np.sqrt(self.dxs**2 + self.dys**2 + self.dzs**2))
+        self.l: np.ndarray = np.concatenate((np.array([0,]), np.cumsum(self.dl))) 
+        self.xmid: np.ndarray = 0.5*(xpts[:-1] + xpts[1:])
+        self.ymid: np.ndarray = 0.5*(ypts[:-1] + ypts[1:])
+        self.zmid: np.ndarray = 0.5*(zpts[:-1] + zpts[1:])
+
+        self.dx = self.dxs[0]
+        self.dy = self.dys[0]
+        self.dz = self.dzs[0]
+    
+    @property
+    def cmid(self) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        return self.xmid, self.ymid, self.zmid
+
+    @property
+    def cpoint(self) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        return self.xs, self.ys, self.zs
+    
+    @staticmethod
+    def from_points(start: np.ndarray, end: np.ndarray, Npts: int) -> Line:
+        x1, y1, z1 = start
+        x2, y2, z2 = end
+        xs = np.linspace(x1, x2, Npts)
+        ys = np.linspace(y1, y2, Npts)
+        zs = np.linspace(z1, z2, Npts)
+        return Line(xs, ys, zs)
+    
+    def line_integral(self, evalfunc: Callable) -> complex:
+        """Compute the line integral for a complex vector field function evalfunc."""
+        Ex, Ey, Ez = evalfunc(*self.cpoint)
+        EdotL = Ex*self.dx + Ey*self.dy + Ez*self.dz
+        return gauss3_composite(self.l, EdotL)