emerge 0.4.11__tar.gz → 0.5.0__tar.gz

{emerge-0.4.11 → emerge-0.5.0}/.bumpversion.toml

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

{emerge-0.4.11 → emerge-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.4.11
+Version: 0.5.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

{emerge-0.4.11 → emerge-0.5.0}/emerge/__init__.py

@@ -18,22 +18,29 @@ along with this program; if not, see
 """
 import os
 
-NTHREADS = "1"
 
-os.environ["OMP_NUM_THREADS"] = "4"
-os.environ["MKL_NUM_THREADS"] = "4"
+############################################################
+#               HANDLE ENVIRONMENT VARIABLES              #
+############################################################
+
+NTHREADS = "1"
+os.environ["EMERGE_STD_LOGLEVEL"] = os.getenv("EMERGE_STD_LOGLEVEL", default="INFO")
+os.environ["EMERGE_FILE_LOGLEVEL"] = os.getenv("EMERGE_FILE_LOGLEVEL", default="DEBUG")
+os.environ["OMP_NUM_THREADS"] = os.getenv("OMP_NUM_THREADS", default="4")
+os.environ["MKL_NUM_THREADS"] = os.getenv("MKL_NUM_THREADS", default="4")
 os.environ["OPENBLAS_NUM_THREADS"] = NTHREADS
 os.environ["VECLIB_MAXIMUM_THREADS"] = NTHREADS
 os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
 
 
-from loguru import logger
-from ._emerge.logsettings import logger_format
-import sys
+############################################################
+#                      IMPORT MODULES                     #
+############################################################
 
-logger.remove()
-logger.add(sys.stderr, format=logger_format)
+from ._emerge.logsettings import LOG_CONTROLLER
+from loguru import logger
 
+LOG_CONTROLLER.set_default()
 logger.debug('Importing modules')
 
 from ._emerge.simmodel import Simulation3D

{emerge-0.4.11 → emerge-0.5.0}/emerge/_emerge/bc.py

@@ -31,8 +31,11 @@ class BCDimension(Enum):
 
 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
+    return sorted(list(set(input)))
+
+############################################################
+#               BASE BOUNDARY CONDITION CLASS              #
+############################################################
 
 class BoundaryCondition:
     """A generalized class for all boundary condition objects.
@@ -141,13 +144,47 @@ class BoundaryConditionSet:
             return obj
         return constr
     
+    def assigned(self, dim: int = 2) -> list[int]:
+        """Returns all boundary tags that have a boundary condition assigned to them
+
+        Args:
+            dim (int, optional): The dimension. Defaults to 2.
+
+        Returns:
+            list[int]: The list of tags
+        """
+        tags = []
+        for bc in self.boundary_conditions:
+            if bc.dim != dim:
+                continue
+            tags.extend(bc.tags)
+        return tags
+
     def count(self, bctype: type) -> int:
+        """Returns the number of a certain boundary condition type
+
+        Args:
+            bctype (type): The boundary condtion type
+
+        Returns:
+            int: The number of occurances
+        """
         return len(self.oftype(bctype))
     
     def oftype(self, bctype: type) -> list[BoundaryCondition]:
+        """Returns a list of all boundary conditions of a certain type.
+
+        Args:
+            bctype (type): The boundar condition type
+
+        Returns:
+            list[BoundaryCondition]: The list of boundary conditions
+        """
         return [item for item in self. boundary_conditions if isinstance(item, bctype)]
 
     def reset(self) -> None:
+        """Resets the boundary conditions that are defined
+        """
         self.boundary_conditions = []
 
     def assign(self, 
@@ -158,6 +195,8 @@ class BoundaryConditionSet:
         Args:
             bcs *(BoundaryCondition): A list of boundary condition objects.
         """
+        if bc in self.boundary_conditions:
+            return
         self._initialized = True
         wordmap = {
             0: 'point',

{emerge-0.4.11 → emerge-0.5.0}/emerge/_emerge/geo/__init__.py

@@ -15,7 +15,7 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-from .pcb import PCBLayouter
+from .pcb import PCB
 from .pmlbox import pmlbox
 from .horn import Horn
 from .shapes import Cyllinder, CoaxCyllinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment

{emerge-0.4.11 → emerge-0.5.0}/emerge/_emerge/geo/pcb.py

@@ -35,9 +35,26 @@ from dataclasses import dataclass
 import math
 
 
-SizeNames = Literal['0402','0603','1005','1608','2012','3216','3225','4532','5025','6332']
+############################################################
+#                        EXCEPTIONS                        #
+############################################################
+
+class RouteException(Exception):
+    pass
+
+############################################################
+#                         CONSTANTS                        #
+############################################################
+
+SIZE_NAMES = Literal['0402','0603','1005','1608','2012','3216','3225','4532','5025','6332']
 _SMD_SIZE_DICT = {x: (float(x[:2])*0.05, float(x[2:])*0.1) for x in ['0402','0603','1005','1608','2012','3216','3225','4532','5025','6332']}
 
+
+############################################################
+#                         FUNCTIONS                        #
+############################################################
+
+
 def approx(a,b):
     return abs(a-b) < 1e-8
 
@@ -51,8 +68,10 @@ def _rot_mat(angle):
     ang = -angle * np.pi/180
     return np.array([[np.cos(ang), -np.sin(ang)], [np.sin(ang), np.cos(ang)]])
 
-class RouteException(Exception):
-    pass
+############################################################
+#                          CLASSES                         #
+############################################################
+
 
 class PCBPoly:
 
@@ -240,10 +259,14 @@ class StripTurn(RouteElement):
 
             return [(xend, yend), (x2, y2), (x1, y1)]
  
+############################################################
+#                    THE STRIP PATH CLASS                  #
+############################################################
+
 class StripPath:
 
-    def __init__(self, pcb: PCBLayouter):
-        self.pcb: PCBLayouter = pcb
+    def __init__(self, pcb: PCB):
+        self.pcb: PCB = pcb
         self.path: list[RouteElement] = []
         self.z: float = 0
 
@@ -423,7 +446,7 @@ class StripPath:
         self.pcb._checkpoint = self
         return paths
 
-    def lumped_element(self, impedance_function: Callable, size: SizeNames | tuple) -> StripPath:
+    def lumped_element(self, impedance_function: Callable, size: SIZE_NAMES | tuple) -> StripPath:
         """Adds a lumped element to the PCB.
 
         The first argument should be the impedance function as function of frequency. For a capacitor this would be:
@@ -730,7 +753,7 @@ class StripPath:
         return self
 
     def macro(self, path: str, width: float = None, start_dir: tuple[float, float] = None) -> StripPath:
-        """Parse an EMerge macro command string
+        r"""Parse an EMerge macro command string
 
         The start direction by default is the abslute current heading. If a specified heading is provided
         the macro language will assume that as the current heading and generate commands accordingly. 
@@ -743,7 +766,7 @@ class StripPath:
         - v X: Turn to down and move X forward
         - ^ X: Turn to up and move X forward
         - T X,Y: Taper X forward to width Y
-        - \ X: Turn relative right 90 degrees and X forward
+        - \\ X: Turn relative right 90 degrees and X forward
         - / X: Turn relative left 90 degrees and X forward
 
         (*) All commands X can also be provided as X,Y to change the width
@@ -771,8 +794,12 @@ class StripPath:
         if element_nr >= len(self.path):
             self.path.append(RouteElement())
         return self.path[element_nr]
-    
-class PCBLayouter:
+
+############################################################
+#                     PCB DESIGN CLASS                    #
+############################################################
+
+class PCB:
     def __init__(self,
                  thickness: float,
                  unit: float = 0.001,
@@ -1241,4 +1268,15 @@ class PCBLayouter:
             polys = GeoSurface(tags)
             polys.material = COPPER
         return polys
-                
+                
+
+############################################################
+#                        DEPRICATED                       #
+############################################################
+
+class PCBLayouter(PCB):
+
+    def __init__(self, *args, **kwargs):
+        logger.warning('PCBLayouter will be depricated. Use PCB instead.')
+        super().__init__(*args, **kwargs)
+        

{emerge-0.4.11 → emerge-0.5.0}/emerge/_emerge/howto.py

@@ -49,14 +49,14 @@ class _HowtoClass:
 
         After making geometries, you should pass all of them to
         the simulation object
-        >>> model.define_geometry(box, sphere,...)
+        >>> model.commit_geometry(box, sphere,...)
 
         You can also directly store geometries into the model class by treating
         it as a list (using __getitem__ and __setitem__)
         >>> model['box'] = emerge.geo.Box(...)
 
         In this case, all geometries will be automatically included. You shoul still call:
-        >>> model.define_geometry()
+        >>> model.commit_geometry()
 
         """
 

emerge-0.5.0/emerge/_emerge/logsettings.py

@@ -0,0 +1,83 @@
+from loguru import logger
+import sys
+from typing import Literal
+from enum import Enum
+from pathlib import Path
+import os
+
+
+############################################################
+#                          FORMATS                         #
+############################################################
+
+TRACE_FORMAT = (
+    "{time: YY/MM/DD - (ddd) - HH:mm:ss.SSSS} | <green>{elapsed}</green> [ <level>{level}</level> ] "
+    " <level>{message}</level>"
+)
+DEBUG_FORMAT = (
+    "<green>{elapsed}</green> [<level>{level}</level>] "
+    " <level>{message}</level>"
+)
+INFO_FORMAT = (
+    "<green>{elapsed}</green> [<level>{level}</level>] "
+    " <level>{message}</level>"
+)
+WARNING_FORMAT = (
+    "<green>{elapsed}</green> [<level>{level}</level>] "
+    " <level>{message}</level>"
+)
+ERROR_FORMAT = (
+    "<green>{elapsed}</green> [<level>{level}</level>] "
+    " <level>{message}</level>"
+)
+FORMAT_DICT = {
+    'TRACE': TRACE_FORMAT,
+    'DEBUG': DEBUG_FORMAT,
+    'INFO': INFO_FORMAT,
+    'WARNING': WARNING_FORMAT,
+    'ERROR': ERROR_FORMAT,
+}
+
+LLTYPE = Literal['TRACE','DEBUG','INFO','WARNING','ERROR'] 
+
+
+############################################################
+#                      LOG CONTROLLER                     #
+############################################################
+
+class LogController:
+    
+    def __init__(self):
+        logger.remove()
+        self.std_handlers: list[int] = []
+        self.file_handlers: list[int] = []
+        self.level: LLTYPE = 'INFO'
+        self.file_level: LLTYPE = 'INFO'
+    
+    def set_default(self):
+        value = os.getenv("EMERGE_STD_LOGLEVEL", default="INFO")
+        self.set_std_loglevel(value)
+
+    def add_std_logger(self, loglevel: LLTYPE) -> None:
+        handle_id = logger.add(sys.stderr, 
+                level=loglevel, 
+                format=FORMAT_DICT.get(loglevel, INFO_FORMAT))
+        self.std_handlers.append(handle_id)
+
+    def set_std_loglevel(self, loglevel: str):
+        handler = {"sink": sys.stdout, 
+                   "level": loglevel, 
+                   "format": FORMAT_DICT.get(loglevel, INFO_FORMAT)}
+        logger.configure(handlers=[handler])
+        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
+        os.environ["EMERGE_FILE_LOGLEVEL"] = loglevel
+
+LOG_CONTROLLER = LogController()

{emerge-0.4.11 → emerge-0.5.0}/emerge/_emerge/mesh3d.py

@@ -27,6 +27,7 @@ from .mth.optimized import outward_normal
 from loguru import logger
 from functools import cache
 from .bc import Periodic
+from .mth.pairing import pair_coordinates
 
 @njit(f8(f8[:], f8[:], f8[:]), cache=True, nogil=True)
 def area(x1: np.ndarray, x2: np.ndarray, x3: np.ndarray):
@@ -87,8 +88,6 @@ class Mesh3D:
         
         self.geometry: Mesher = mesher
 
-        self.exterior_face_tags: list[int] = None
-        
         # All spatial objects
         self.nodes: np.ndarray = None
         self.n_i2t: dict = None
@@ -143,6 +142,7 @@ class Mesh3D:
         ## Memory
         self.ftag_to_tri: dict[int, list[int]] = dict()
         self.ftag_to_node: dict[int, list[int]] = dict()
+        self.ftag_to_edge: dict[int, list[int]] = dict()
         self.vtag_to_tet:  dict[int, list[int]] = dict()
     
     @property
@@ -245,6 +245,17 @@ class Mesh3D:
             nodes.extend(self.ftag_to_node[facetag])
         
         return np.array(sorted(list(set(nodes))))
+
+    def get_edges(self, face_tags: Union[int, list[int]]) -> np.ndarray:
+        '''Returns a numpyarray of all the edges that belong to the given face tags'''
+        if isinstance(face_tags, int):
+            face_tags = [face_tags,]
+        
+        edges = []
+        for facetag in face_tags:
+            edges.extend(self.ftag_to_edge[facetag])
+        
+        return np.array(sorted(list(set(edges))))
     
     
     def update(self, periodic_bcs: list[Periodic] = None):
@@ -405,7 +416,8 @@ class Mesh3D:
             self.ftag_to_node[t] = node_tags
             node_tags = np.squeeze(np.array(node_tags)).reshape(-1,3).T
             self.ftag_to_tri[t] = [self.get_tri(node_tags[0,i], node_tags[1,i], node_tags[2,i]) for i in range(node_tags.shape[1])]
-
+            self.ftag_to_edge[t] = sorted(list(np.unique(self.tri_to_edge[:,self.ftag_to_tri[t]].flatten())))
+        
         vol_dimtags = gmsh.model.get_entities(3)
         for d,t in vol_dimtags:
             domain_tag, v_tags, node_tags = gmsh.model.mesh.get_elements(3, t)
@@ -457,16 +469,8 @@ class Mesh3D:
         node_ids_1 = sorted(list(set(node_ids_1)))
         node_ids_2 = sorted(list(set(node_ids_2)))
         dv = np.array(bc.dv)
-        nodemapdict = defaultdict(lambda: [None, None])
-        
-        mult = int(10**(-np.round(np.log10(dsmin))+2))
         
-        for i1, i2 in zip(node_ids_1, node_ids_2):
-            nodemapdict[gen_key(self.nodes[:,i1], mult)][0] = i1
-            nodemapdict[gen_key(self.nodes[:,i2]-dv, mult)][1] = i2
-
-        nodemap = {i1: i2 for i1, i2 in nodemapdict.values()}
-
+        nodemap = pair_coordinates(self.nodes, node_ids_1, node_ids_2, 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)}
@@ -565,6 +569,20 @@ class Mesh3D:
     def boundary_surface(self, 
                          face_tags: Union[int, list[int]], 
                          origin: tuple[float, float, float] = None) -> SurfaceMesh:
+        """Returns a SurfaceMesh class that is a 2D mesh isolated from the 3D mesh
+
+        The mesh will be based on the given set of face tags.
+
+        In order to properly allign the normal vectors, an alignment origin can be provided.
+        If not provided, the center point of all boundaries will be used.
+
+        Args:
+            face_tags (Union[int, list[int]]): The list of face tags to use
+            origin (tuple[float, float, float], optional): The normal vecor alignment origin.. Defaults to None.
+
+        Returns:
+            SurfaceMesh: The resultant surface mesh
+        """
         tri_ids = self.get_triangles(face_tags)
         if origin is None:
             nodes = self.nodes[:,self.get_nodes(face_tags)]

{emerge-0.4.11 → emerge-0.5.0}/emerge/_emerge/mth/common_functions.py

@@ -18,16 +18,43 @@
 import numpy as np
 
 def  norm(Field: np.ndarray) -> np.ndarray:
-    ''' Computes the complex norm of a field (3,N)'''
+    """ Computes the complex norm of a field (3,N)
+
+    Args:
+        Field (np.ndarray): The input field, shape (3,N)
+
+    Returns:
+        np.ndarray: The complex norm in shape (N,)
+    """
     return np.sqrt(np.abs(Field[0,:])**2 + np.abs(Field[1,:])**2 + np.abs(Field[2,:])**2)
 
 def coax_rout(rin: float,
               eps_r: float = 1,
               Z0: float = 50) -> float:
+    """Computes the outer radius given a dielectric constant, inner radius and characteristic impedance
+
+    Args:
+        rin (float): The inner radius
+        eps_r (float, optional): The dielectric permittivity. Defaults to 1.
+        Z0 (float, optional): The impedance. Defaults to 50.
+
+    Returns:
+        float: The outer radius
+    """
     return rin*10**(Z0*np.sqrt(eps_r)/138)
 
 def coax_rin(rout: float,
               eps_r: float = 1,
               Z0: float = 50) -> float:
+    """Computes the inner radius given a dielectric constant, outer radius and characteristic impedance
+
+    Args:
+        rin (float): The outer radius
+        eps_r (float, optional): The dielectric permittivity. Defaults to 1.
+        Z0 (float, optional): The impedance. Defaults to 50.
+
+    Returns:
+        float: The inner radius
+    """
     return rout/10**(Z0*np.sqrt(eps_r)/138)
 

{emerge-0.4.11 → emerge-0.5.0}/emerge/_emerge/mth/integrals.py

@@ -17,10 +17,14 @@
 
 import numpy as np
 from typing import Callable
-from numba import njit, f8, i8, types, c16
+from numba import njit, f8, i8, c16
 from .optimized import gaus_quad_tri, generate_int_points_tri, calc_area
 
 
+############################################################
+#                 NUMBA OPTIMIZED INTEGRALS                #
+############################################################
+
 @njit(c16(f8[:,:], i8[:,:], c16[:], f8[:,:], c16[:,:]), cache=True, nogil=True)
 def _fast_integral_c(nodes, triangles, constants, DPTs, field_values):
     tot = np.complex128(0.0)
@@ -48,16 +52,34 @@ def _fast_integral_f(nodes, triangles, constants, DPTs, field_values):
         tot = tot + constants[it] * field * A
     return tot
 
+
+############################################################
+#                      PYTHON WRAPPER                     #
+############################################################
+
 def surface_integral(nodes: np.ndarray, 
                      triangles: np.ndarray, 
                      function: Callable, 
                      constants: np.ndarray = None,
-                     ndpts: int = 4):
+                     gq_order: int = 4) -> complex:
+    """Computes the surface integral of a scalar-field
+
+    Computes I = Σ ∫∫ C ᐧ f(x,y,z) dA
+
+    Args:
+        nodes (np.ndarray): The integration nodes
+        triangles (np.ndarray): The integration triangles
+        function (Callable): The scalar field f(x,y,z)
+        constants (np.ndarray, optional): The constant C. Defaults to None.
+        ndpts (int, optional): Order of gauss quadrature points. Defaults to 4.
 
+    Returns:
+        complex: The integral I.
+    """
     if constants is None:
         constants = np.ones(triangles.shape[1])
         
-    DPTs = gaus_quad_tri(ndpts)
+    DPTs = gaus_quad_tri(gq_order)
     xall_flat, yall_flat, zall_flat, shape = generate_int_points_tri(nodes, triangles, DPTs)
 
     fvals = function(xall_flat, yall_flat, zall_flat)