emerge 0.4.6__tar.gz

emerge-0.4.6/.gitignore

@@ -0,0 +1,39 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# paths
+meshes/
+
+# Meshes
+*.msh
+
+# tests
+**/test_*
+
+version_update.txt
+
+# EMerge data files
+*.emerge
+*.stl
+*.step
+*.s1p
+*.s2p
+*.s3p
+*.s4p
+*.snp
+*.csv
+*.fig
+
+manual_scripts/
+
+*.EMResults
+
+tests/

emerge-0.4.6/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: emerge
+Version: 0.4.6
+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
+Requires-Python: <4.0,>=3.10
+Requires-Dist: gmsh>=4.13.1
+Requires-Dist: joblib>=1.5.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: numba-progress>=1.1.3
+Requires-Dist: numba>=0.61.2
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: pyvista>=0.45.2
+Requires-Dist: scipy>=1.15.3
+Provides-Extra: pypardiso
+Requires-Dist: pypardiso; extra == 'pypardiso'
+Provides-Extra: umfpack
+Requires-Dist: scikit-umfpack; extra == 'umfpack'
+Description-Content-Type: text/markdown
+
+## Introduction
+
+Hello everybody. Thanks for showing interest in this repository.
+
+Feel free to download your version of EMerge and start playing around with it!
+If you have suggestions/changes/questions either use the Github issue system or join the Discord using the following link:
+
+**https://discord.gg/7PF4WcS6uA**
+
+## How to install
+
+Clone this repository or download the files. While in the EMerge path containing the src/emerge folder, install the module using:
+```
+pip install .
+```
+If you want to install the library with PyPardiso on Intel machines, you can install the optional dependency with EMerge using:
+```
+pip install ".[pypardiso]"
+```
+
+## Compatibility
+
+As far as I know, the library should work on all systems. PyPARDISO is not supported on ARM but the current SuperLU and UMFPACK solvers work on ARM as well. Both SuperLU and UMFPACK can run on multi-processing implementations as long as you do entry-point protection:
+```
+import emerge as em
+
+def main():
+    # setup simulation
+
+    model.mw.frequency_domain(True, ..., multi_processing=True)
+
+if __name__ == "__main__":
+    main()
+```
+Otherwise, the parallel solver will default to SuperLU which is significantly slower on larger problems.
+
+## Required libraries
+
+To run this FEM library you need the following libraries
+
+ - numpy
+ - scipy
+ - pypardiso
+ - gmsh
+ - loguru
+ - numba
+ - matplotlib (for the matplotlib base display)
+ - pyvista (for the PyVista base display)
+ - numba-progress
+ - scikit-umfpack
+
+## NOTICE
+
+First time runs will be very slow because Numba needs to generate local C-compiled functions of the assembler and other mathematical functions. These compilations are chached so this should only take time once.

emerge-0.4.6/README.md

@@ -0,0 +1,54 @@
+## Introduction
+
+Hello everybody. Thanks for showing interest in this repository.
+
+Feel free to download your version of EMerge and start playing around with it!
+If you have suggestions/changes/questions either use the Github issue system or join the Discord using the following link:
+
+**https://discord.gg/7PF4WcS6uA**
+
+## How to install
+
+Clone this repository or download the files. While in the EMerge path containing the src/emerge folder, install the module using:
+```
+pip install .
+```
+If you want to install the library with PyPardiso on Intel machines, you can install the optional dependency with EMerge using:
+```
+pip install ".[pypardiso]"
+```
+
+## Compatibility
+
+As far as I know, the library should work on all systems. PyPARDISO is not supported on ARM but the current SuperLU and UMFPACK solvers work on ARM as well. Both SuperLU and UMFPACK can run on multi-processing implementations as long as you do entry-point protection:
+```
+import emerge as em
+
+def main():
+    # setup simulation
+
+    model.mw.frequency_domain(True, ..., multi_processing=True)
+
+if __name__ == "__main__":
+    main()
+```
+Otherwise, the parallel solver will default to SuperLU which is significantly slower on larger problems.
+
+## Required libraries
+
+To run this FEM library you need the following libraries
+
+ - numpy
+ - scipy
+ - pypardiso
+ - gmsh
+ - loguru
+ - numba
+ - matplotlib (for the matplotlib base display)
+ - pyvista (for the PyVista base display)
+ - numba-progress
+ - scikit-umfpack
+
+## NOTICE
+
+First time runs will be very slow because Numba needs to generate local C-compiled functions of the assembler and other mathematical functions. These compilations are chached so this should only take time once.

emerge-0.4.6/_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-0.4.6/_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-0.4.6/_emerge/cli.py

@@ -0,0 +1,19 @@
+import sys
+import argparse
+from _emerge.projects.generate_project import generate_project
+
+def main():
+    parser = argparse.ArgumentParser(description="Emerge Project Generator CLI")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # Subcommand: new
+    new_parser = subparsers.add_parser("new", help="Create a new project")
+    new_parser.add_argument("projectname", type=str, help="Name of the project directory")
+    new_parser.add_argument("filename", type=str, help="Base name for files")
+
+    args = parser.parse_args()
+
+    if args.command == "new":
+        generate_project(args.projectname, args.filename)
+    else:
+        parser.print_help()

emerge-0.4.6/_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)