emerge 0.6.9__py3-none-any.whl → 0.6.10__py3-none-any.whl

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.6.9"
+__version__ = "0.6.10"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -43,12 +43,13 @@ from loguru import logger
 
 LOG_CONTROLLER.set_default()
 logger.debug('Importing modules')
+LOG_CONTROLLER._set_log_buffer()
 
 from ._emerge.simmodel import Simulation
 from ._emerge.material import Material, FreqCoordDependent, FreqDependent, CoordDependent
 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.cs import CoordinateSystem, CS, GCS, Plane, Axis, XAX, YAX, ZAX, XYPLANE, XZPLANE, YZPLANE, YXPLANE, ZXPLANE, ZYPLANE, cs
 from ._emerge.coord import Line
 from ._emerge import geo
 from ._emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
@@ -62,4 +63,12 @@ from ._emerge.howto import _HowtoClass
 
 howto = _HowtoClass()
 
-logger.debug('Importing complete!')
+logger.debug('Importing complete!')
+
+
+############################################################
+#                         CONSTANTS                        #
+############################################################
+
+CENTER = geo.Alignment.CENTER
+CORNER = geo.Alignment.CORNER

emerge/_emerge/cs.py

@@ -530,3 +530,39 @@ CS = CoordinateSystem
 # The global coordinate system
 GCS = CoordinateSystem(XAX, YAX, ZAX, np.zeros(3), _is_global=True)
 
+def cs(axes: str, origin: tuple[float, float, float] = (0.,0.,0.,)) -> CoordinateSystem:
+    """Generate a coordinate system based on a simple string
+    The string must contain the letters x, X, y, Y, z and/or Z. 
+    Small letters refer to positive axes and capitals to negative axes.
+    
+    The string must be 3 characters long.
+    
+    The first position indices which global axis gets assigned to the new local X-axis
+    The second position indicates the Y-axis
+    The third position indicates the Z-axis
+    
+    Thus, rotating the global XYZ coordinate system 90 degrees around the Z axis would yield: yXz
+
+    Args:
+        axes (str): The axis description
+        origin (tuple[float, float, float], optional): The origin of the coordinate system. Defaults to (0.,0.,0.,).
+
+    Returns:
+        CoordinateSystem: The resultant coordinate system
+    """
+    if len(axes) != 3:
+        raise ValueError('Axis object must be of length 3')
+    
+    axlib = {
+        'x': Axis(np.array([1.0,0.,0.])),
+        'X': Axis(np.array([-1.0,0.,0.])),
+        'y': Axis(np.array([0.,1.0,0.])),
+        'Y': Axis(np.array([0.,-1.0,0.])),
+        'z': Axis(np.array([0.,0.,1.0])),
+        'Z': Axis(np.array([0.,0.,-1.0])),
+    }
+    ax_obj = [axlib[ax] for ax in axes]
+    
+    return (ax_obj[0]*ax_obj[1]*ax_obj[2]).displace(*origin)
+
+

emerge/_emerge/geo/polybased.py

@@ -206,6 +206,7 @@ def orthonormalize(axis: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray
     Zaxis = np.abs(Zaxis/np.linalg.norm(Zaxis))
     return Xaxis, Yaxis, Zaxis
 
+
 class GeoPrism(GeoVolume):
     """The GepPrism class generalizes the GeoVolume for extruded convex polygons.
     Besides having a volumetric definitions, the class offers a .front_face 
@@ -216,35 +217,65 @@ class GeoPrism(GeoVolume):
     """
     def __init__(self,
                  volume_tag: int,
-                 front_tag: int,
-                 side_tags: list[int],):
+                 front_tag: int | None = None,
+                 side_tags: list[int] | None = None,
+                 _axis: Axis | None = None):
         super().__init__(volume_tag)
-        self.front_tag: int = front_tag
-        self.back_tag: int = None
+        
+        
+        
+        if front_tag is not None and side_tags is not None:
+            self.front_tag: int = front_tag
+            self.back_tag: int = None
 
-        gmsh.model.occ.synchronize()
-        o1 = gmsh.model.occ.get_center_of_mass(2, self.front_tag)
-        n1 = gmsh.model.get_normal(self.front_tag, (0,0))
-        self._add_face_pointer('back', o1, n1)
+            gmsh.model.occ.synchronize()
+            self._add_face_pointer('back', tag=self.front_tag)
 
-        tags = gmsh.model.get_boundary(self.dimtags, oriented=False)
-        
-        for dim, tag in tags:
-            if (dim,tag) in side_tags:
-                continue
-            o2 = gmsh.model.occ.get_center_of_mass(2, tag)
-            n2 = gmsh.model.get_normal(tag, (0,0))
-            self._add_face_pointer('front', o2, n2)
-            self.back_tag = tag
-            break
+            tags = gmsh.model.get_boundary(self.dimtags, oriented=False)
+            
+            for dim, tag in tags:
+                if (dim,tag) in side_tags:
+                    continue
+                self._add_face_pointer('front',tag=tag)
+                self.back_tag = tag
+                break
 
-        self.side_tags: list[int] = [dt[1] for dt in tags if dt[1]!=self.front_tag and dt[1]!=self.back_tag]
+            self.side_tags: list[int] = [dt[1] for dt in tags if dt[1]!=self.front_tag and dt[1]!=self.back_tag]
 
-        for tag in self.side_tags:
-            o2 = gmsh.model.occ.get_center_of_mass(2, tag)
-            n2 = gmsh.model.get_normal(tag, (0,0))
-            self._add_face_pointer(f'side{tag}', o2, n2)
-            self.back_tag = tag
+            for tag in self.side_tags:
+    
+                self._add_face_pointer(f'side{tag}', tag=tag)
+                self.back_tag = tag
+                
+        elif _axis is not None:
+            _axis = _parse_axis(_axis)
+            gmsh.model.occ.synchronize()
+            tags = gmsh.model.get_boundary(self.dimtags, oriented=False)
+            faces = []
+            for dim, tag in tags:
+                o1 = np.array(gmsh.model.occ.get_center_of_mass(2, tag))
+                n1 = np.array(gmsh.model.get_normal(tag, (0,0)))
+                if abs(np.sum(n1*_axis.np)) > 0.99:
+                    dax = sum(o1 * _axis.np)
+                    faces.append((o1, n1, dax, tag))
+            
+            faces = sorted(faces, key=lambda x: x[2])
+            ftags = []
+            if len(faces) >= 2:
+                ftags.append(faces[0][3])
+                ftags.append(faces[-1][3])
+                self._add_face_pointer('front',faces[0][0], faces[0][1])
+                self._add_face_pointer('back', faces[-1][0], faces[-1][1])
+            elif len(faces)==1:
+                ftags.append(faces[0][3])
+                self._add_face_pointer('cap',faces[0][0], faces[0][1])
+            
+            ictr = 1
+            for dim, tag in tags:
+                if tag in ftags:
+                    continue
+                self._add_face_pointer(f'side{ictr}', tag=tag)
+                ictr += 1
 
     def outside(self, *exclude: Literal['front','back']) -> FaceSelection:
         """Select all outside faces except for the once specified by outside
@@ -462,9 +493,10 @@ class XYPolygon:
         ax, ay, az = axis
         
         volume = gmsh.model.occ.revolve(poly_fin.dimtags, x,y,z, ax, ay, az, angle*np.pi/180)
+        
         tags = [t for d,t in volume if d==3]
-        surftags = [t for d,t in volume if d==2]
-        return GeoPrism(tags, surftags[0], surftags)
+        poly_fin.remove()
+        return GeoPrism(tags, _axis=axis)
 
     @staticmethod
     def circle(radius: float, 

emerge/_emerge/geo/shapes.py

@@ -27,6 +27,12 @@ from typing import Literal
 from functools import reduce
 
 class Alignment(Enum):
+    """The alignment Enum describes if a box, cube or rectangle location
+    is specified for the center or the bottom - front - left corner (min X Y and Z)
+
+    Args:
+        Enum (_type_): _description_
+    """
     CENTER = 1
     CORNER = 2
 

emerge/_emerge/geometry.py

@@ -285,9 +285,18 @@ class GeoObject:
     
     def _add_face_pointer(self, 
                           name: str,
-                          origin: np.ndarray,
-                          normal: np.ndarray):
-        self._face_pointers[name] = _FacePointer(origin, normal)
+                          origin: np.ndarray | None = None,
+                          normal: np.ndarray | None = None,
+                          tag: int | None = None):
+        if tag is not None:
+            o = gmsh.model.occ.get_center_of_mass(2, tag)
+            n = gmsh.model.get_normal(tag, (0,0))
+            self._face_pointers[name] = _FacePointer(o, n)
+            return
+        if origin is not None and normal is not None:
+            self._face_pointers[name] = _FacePointer(origin, normal)
+            return
+        raise ValueError('Eitehr a tag or an origin + normal must be provided!')
     
     def make_copy(self) -> GeoObject:
         new_dimtags = gmsh.model.occ.copy(self.dimtags)

emerge/_emerge/logsettings.py

@@ -18,11 +18,14 @@
 from loguru import logger
 import sys
 from typing import Literal
-from enum import Enum
 from pathlib import Path
 import os
-import gmsh
+from collections import deque
 
+_LOG_BUFFER = deque()
+
+def _log_sink(message):
+    _LOG_BUFFER.append(message)
 ############################################################
 #                          FORMATS                         #
 ############################################################
@@ -82,6 +85,14 @@ class LogController:
                 format=FORMAT_DICT.get(loglevel, INFO_FORMAT))
         self.std_handlers.append(handle_id)
 
+    def _set_log_buffer(self):
+        logger.add(_log_sink)
+        
+    def _flush_log_buffer(self):
+        for msg in list(_LOG_BUFFER):
+            logger.opt(depth=6).log(msg.record["level"].name, msg.record["message"])
+        _LOG_BUFFER.clear()
+        
     def set_std_loglevel(self, loglevel: str):
         handler = {"sink": sys.stdout, 
                    "level": loglevel, 

emerge/_emerge/material.py

@@ -310,6 +310,8 @@ class Material:
 
         self.color: str = color
         self.opacity: float = opacity
+        self._hash_key: int = -1
+        
         if _neff is None:
             self._neff: Callable = lambda f: np.sqrt(self.ur._fmax(f)*self.er._fmax(f))
         else:
@@ -318,8 +320,14 @@ class Material:
         self._color_rgb = tuple(int(hex_str[i:i+2], 16)/255.0 for i in (0, 2, 4))
         self._metal: bool = _metal
 
+    def __hash__(self):
+        return self._hash_key
+    
     def __str__(self) -> str:
-        return f'Material({self.name})'
+        return f'Material({self.name}, {self._hash_key})'
+    
+    def __repr__(self):
+        return f'Material({self.name}, {self._hash_key})'
     
     def initialize(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, ids: np.ndarray):
         """Initializes the Material properties to be evaluated at xyz-coordinates for
@@ -343,6 +351,7 @@ class Material:
         self.ur.reset()
         self.tand.reset()
         self.cond.reset()
+        self._hash_key = -1
         
     @property
     def frequency_dependent(self) -> bool:

emerge/_emerge/mesh3d.py

@@ -544,22 +544,33 @@ class Mesh3D(Mesh):
         #arry = np.zeros((3,3,self.n_tets,), dtype=np.complex128)
         for vol in volumes:
             vol.material.reset()
-            
+        
         materials = []
+        i = 0
+        for vol in volumes:
+            if vol.material not in materials:
+                materials.append(vol.material)
+                vol.material._hash_key = i
+                i += 1
         
         xs = self.centers[0,:]
         ys = self.centers[1,:]
         zs = self.centers[2,:]
         
+        matassign = -1*np.ones((self.n_tets,), dtype=np.int64)
+        
         for volume in sorted(volumes, key=lambda x: x._priority):
         
             for dimtag in volume.dimtags:
                 etype, etag_list, ntags = gmsh.model.mesh.get_elements(*dimtag)
                 for etags in etag_list:
                     tet_ids = np.array([self.tet_t2i[t] for t in etags])
-                    volume.material.initialize(xs[tet_ids], ys[tet_ids], zs[tet_ids], tet_ids)
-                    if volume.material not in materials:
-                        materials.append(volume.material)
+                    matassign[tet_ids] = volume.material._hash_key
+        
+        for mat in materials:
+            ids = np.argwhere(matassign==mat._hash_key).flatten()
+            mat.initialize(xs[ids], ys[ids], zs[ids], ids)
+                    
         
         return materials
     

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -53,7 +53,7 @@ def run_job_multi(job: SimJob) -> SimJob:
     Returns:
         SimJob: The solved SimJob
     """
-    routine = DEFAULT_ROUTINE.duplicate()._configure_routine('MP')
+    routine = DEFAULT_ROUTINE._configure_routine('MP')
     for A, b, ids, reuse, aux in job.iter_Ab():
         solution, report = routine.solve(A, b, ids, reuse, id=job.id)
         report.add(**aux)

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -306,11 +306,17 @@ class AbsorbingBoundary(RobinBC):
         Returns:
             complex: The γ-constant
         """
-        return 1j*self.get_beta(k0)
+        if self.order == 2:
+            
+            p0 = 1.06103
+            p2 = -0.84883
+            ky = k0*0.5
+            return 1j*k0*p0 - 1j*p2*ky**2/k0
+        else:
+            Factor = 1
+            return 1j*self.get_beta(k0)*Factor
     
-    def get_Uinc(self, x_local: np.ndarray, y_local: np.ndarray, k0: float) -> np.ndarray:
-        return np.zeros((3, len(x_local)), dtype=np.complex128)
-
+   
 @dataclass
 class PortMode:
     modefield: np.ndarray
@@ -825,9 +831,9 @@ class LumpedPort(PortBC):
         self.Vdirection: Axis = direction # type: ignore
         self.type = 'TEM'
         
-        logger.info('Constructing coordinate system from normal port')
-        self.cs = Axis(self.selection.normal).construct_cs()  # type: ignore
-
+        # logger.info('Constructing coordinate system from normal port')
+        # self.cs = Axis(self.selection.normal).construct_cs()  # type: ignore
+        self.cs = GCS
         self.vintline: Line | None = None
         self.v_integration = True
 
@@ -881,14 +887,7 @@ class LumpedPort(PortBC):
                      k0: float,
                      which: Literal['E','H'] = 'E') -> np.ndarray:
         ''' Compute the port mode E-field in local coordinates (XY) + Z out of plane.'''
-
-        px, py, pz = self.cs.in_local_basis(*self.Vdirection.np)
-        
-        Ex = px*np.ones_like(x_local)
-        Ey = py*np.ones_like(x_local)
-        Ez = pz*np.ones_like(x_local)
-        Exyz = np.array([Ex, Ey, Ez])
-        return Exyz
+        raise RuntimeError('This function should never be called in this context.')
 
     def port_mode_3d_global(self, 
                             x_global: np.ndarray,
@@ -911,10 +910,9 @@ class LumpedPort(PortBC):
         Returns:
             np.ndarray: The E-field in (3,N) indexing.
         """
-        xl, yl, _ = self.cs.in_local_cs(x_global, y_global, z_global)
-        Ex, Ey, Ez = self.port_mode_3d(xl, yl, k0)
-        Exg, Eyg, Ezg = self.cs.in_global_basis(Ex, Ey, Ez)
-        return np.array([Exg, Eyg, Ezg])
+        ON = np.ones_like(x_global)
+        Ex, Ey, Ez = self.Vdirection.np
+        return np.array([Ex*ON, Ey*ON, Ez*ON])
 
 
 class LumpedElement(RobinBC):

emerge/_emerge/plot/pyvista/display.py

@@ -596,7 +596,7 @@ class PVDisplay(BaseDisplay):
 
 
         if scale=='log':
-            T = lambda x: np.log10(np.abs(x))
+            T = lambda x: np.log10(np.abs(x+1e-12))
         elif scale=='symlog':
             T = lambda x: np.sign(x) * np.log10(1 + np.abs(x*np.log(10)))
         else:

emerge/_emerge/plot/simple_plots.py

@@ -422,9 +422,14 @@ def plot_sp(f: np.ndarray | list[np.ndarray], S: list[np.ndarray] | np.ndarray,
             show_plot: bool = True,
             figdata: tuple | None = None) -> tuple[plt.Figure, plt.Axes, plt.Axes]:
     """Plot S-parameters in dB and phase
+    
+    One may provide:
+     - A single frequency with a single S-parameter
+     - A single frequency with a list of S-parameters
+     - A list of frequencies with a list of S-parameters
 
     Args:
-        f (np.ndarray): Frequency vector
+        f (np.ndarray | list[np.ndarray]): Frequency vector or list of frequencies
         S (list[np.ndarray] | np.ndarray): S-parameters to plot (list or single array)
         dblim (list, optional): Decibel y-axis limit. Defaults to [-80, 5].
         xunit (str, optional): Frequency unit. Defaults to "GHz".
@@ -535,7 +540,7 @@ def plot_sp(f: np.ndarray | list[np.ndarray], S: list[np.ndarray] | np.ndarray,
 
     
 def plot_ff(
-    theta: np.ndarray,
+    theta: np.ndarray | list[np.ndarray],
     E: Union[np.ndarray, Sequence[np.ndarray]],
     grid: bool = True,
     dB: bool = False,
@@ -554,7 +559,7 @@ def plot_ff(
 
     Parameters
     ----------
-    theta : np.ndarray
+    theta : np.ndarray | list[np.ndarray]
         Angle array (radians).
     E : np.ndarray or sequence of np.ndarray
         Complex E-field samples; magnitude will be plotted.
@@ -575,6 +580,12 @@ def plot_ff(
         E_list = [E]
     else:
         E_list = list(E)
+        
+    if not isinstance(theta, list):
+        thetas = [theta for _ in E_list]
+    else:
+        thetas = theta
+        
     n_series = len(E_list)
 
     # Style broadcasting
@@ -591,6 +602,7 @@ def plot_ff(
 
     fig, ax = plt.subplots()
     for i, Ei in enumerate(E_list):
+        theta = thetas[i]
         mag = np.abs(Ei)
         if dB:
             mag = 20*np.log10(mag)

emerge/_emerge/simmodel.py

@@ -68,7 +68,7 @@ class Simulation:
                  loglevel: Literal['TRACE','DEBUG','INFO','WARNING','ERROR'] = 'INFO',
                  load_file: bool = False,
                  save_file: bool = False,
-                 logfile: bool = False,
+                 write_log: bool = False,
                  path_suffix: str = ".EMResults"):
         """Generate a Simulation class object.
 
@@ -80,7 +80,7 @@ class Simulation:
             loglevel ("DEBUG","INFO","WARNING","ERROR", optional): The loglevel to use for loguru. Defaults to 'INFO'.
             load_file (bool, optional): If the simulatio model should be loaded from a file. Defaults to False.
             save_file (bool, optional): if the simulation file should be stored to a file. Defaults to False.
-            logfile (bool, optional): If a file should be created that contains the entire log of the simulation. Defaults to False.
+            write_log (bool, optional): If a file should be created that contains the entire log of the simulation. Defaults to False.
             path_suffix (str, optional): The suffix that will be added to the results directory. Defaults to ".EMResults".
         """
 
@@ -113,9 +113,10 @@ class Simulation:
         self._initialize_simulation()
 
         self.set_loglevel(loglevel)
-        if logfile:
-            self.set_logfile()
+        if write_log:
+            self.set_write_log()
 
+        LOG_CONTROLLER._flush_log_buffer()
         self._update_data()
     
 
@@ -324,7 +325,7 @@ class Simulation:
         if loglevel not in ('TRACE','DEBUG'):
             gmsh.option.setNumber("General.Terminal", 0)
 
-    def set_logfile(self) -> None:
+    def set_write_log(self) -> None:
         """Adds a file output for the logger."""
         LOG_CONTROLLER.set_write_file(self.modelpath)
         

emerge/_emerge/solve_interfaces/cudss_interface.py

@@ -15,7 +15,16 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-import cupy as cp # ty: ignore
+import warnings
+from loguru import logger
+
+# Catch the Cuda warning and print it with Loguru.
+with warnings.catch_warnings(record=True) as w:
+    warnings.simplefilter("always")
+    import cupy as cp
+    for warn in w:
+        logger.debug(f"{warn.category.__name__}: {warn.message}")
+
 import nvmath.bindings.cudss as cudss # ty: ignore
 from nvmath import CudaDataType # ty: ignore
 
@@ -23,9 +32,6 @@ from scipy.sparse import csr_matrix
 import numpy as np
 from typing import Literal
 
-from loguru import logger
-
-
 ############################################################
 #                         CONSTANTS                        #
 ############################################################

emerge/_emerge/solver.py

@@ -504,6 +504,7 @@ class SolverSuperLU(Solver):
         logger.info(f'[ID={id}] Calling SuperLU Solver.')
         self.single = True
         if not reuse_factorization:
+            logger.trace('Computing LU-Decomposition')
             self.lu = splu(A, permc_spec='MMD_AT_PLUS_A', relax=0, diag_pivot_thresh=self._pivoting_threshold, options=self.options)
         x = self.lu.solve(b)
         aux = {
@@ -518,6 +519,7 @@ class SolverUMFPACK(Solver):
 
     def __init__(self):
         super().__init__()
+        logger.trace('Creating UMFPACK solver')
         self.A: np.ndarray = None
         self.b: np.ndarray = None
         
@@ -532,6 +534,7 @@ class SolverUMFPACK(Solver):
     def initialize(self):
         if self.initalized:
             return
+        logger.trace('Initializing UMFPACK Solver')
         self.umfpack = um.UmfpackContext('zl')
         self.umfpack.control[um.UMFPACK_PRL] = 0 # ty: ignore
         self.umfpack.control[um.UMFPACK_IRSTEP] = 2 # ty: ignore
@@ -542,7 +545,9 @@ class SolverUMFPACK(Solver):
         self.umfpack.control[um.UMFPACK_BLOCK_SIZE] = 64 # ty: ignore
         self.umfpack.control[um.UMFPACK_FIXQ] = -1 # ty: ignore
         self.initalized = True
+        
     def reset(self) -> None:
+        logger.trace('Resetting UMFPACK solver state')
         self.fact_symb = False
     
     def set_options(self, pivoting_threshold: float | None = None) -> None:
@@ -562,13 +567,14 @@ class SolverUMFPACK(Solver):
         A.indptr  = A.indptr.astype(np.int64)
         A.indices = A.indices.astype(np.int64)
         if self.fact_symb is False:
-            logger.debug(f'[ID={id}] Executing symbollic factorization.')
+            logger.trace(f'[ID={id}] Executing symbollic factorization.')
             self.umfpack.symbolic(A)
             self.fact_symb = True
         if not reuse_factorization:
-            #logger.debug('Executing numeric factorization.')
+            logger.trace(f'[ID={id}] Executing numeric factorization.')
             self.umfpack.numeric(A)
             self.A = A
+        logger.trace(f'[ID={id}] Solving linear system.')
         x = self.umfpack.solve(um.UMFPACK_A, self.A, b, autoTranspose = False ) # ty: ignore
         aux = {
             "Pivoting Threshold": str(self._pivoting_threshold),
@@ -596,12 +602,14 @@ class SolverPardiso(Solver):
     def solve(self, A, b, precon, reuse_factorization: bool = False, id: int = -1) -> tuple[np.ndarray, SolveReport]:
         logger.info(f'[ID={id}] Calling Pardiso Solver')
         if self.fact_symb is False:
-            logger.debug(f'[ID={id}] Executing symbollic factorization.')
+            logger.trace(f'[ID={id}] Executing symbollic factorization.')
             self.solver.symbolic(A)
             self.fact_symb = True
         if not reuse_factorization:
+            logger.trace(f'[ID={id}] Executing numeric factorization.')
             self.solver.numeric(A)
             self.A = A
+        logger.trace(f'[ID={id}] Solving linear system.')
         x, error = self.solver.solve(A, b)
         if error != 0:
             logger.error(f'[ID={id}] Terminated with error code {error}')
@@ -634,13 +642,15 @@ class CuDSSSolver(Solver):
         logger.info(f'[ID={id}] Calling cuDSS Solver')
         
         if self.fact_symb is False:
-            logger.debug('Executing symbollic factorization')
+            logger.trace(f'[ID={id}] Starting from symbollic factorization.')
             x = self._cudss.from_symbolic(A,b)
             self.fact_symb = True
         else:
             if reuse_factorization:
+                logger.trace(f'[ID={id}] Solving linear system.')
                 x = self._cudss.from_solve(b)
             else:
+                logger.trace(f'[ID={id}] Starting from numeric factorization.')
                 x = self._cudss.from_numeric(A,b)
         
         return x, SolveReport(solver=str(self), exit_code=0, aux={})

{emerge-0.6.9.dist-info → emerge-0.6.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.6.9
+Version: 0.6.10
 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.6.9.dist-info → emerge-0.6.10.dist-info}/RECORD

@@ -1,4 +1,4 @@
-emerge/__init__.py,sha256=CADecqlZ97GZvSCPedEzhmI3N_1o0qeCaaxgjlUccio,2693
+emerge/__init__.py,sha256=8FrSyF_ro5TDOwMM76VyItYnpfiK_LOumuCAugk2DiI,2977
 emerge/__main__.py,sha256=WVf16sfrOI910QWohrQDaChZdRifMNoS6VKzCT6f3ZA,92
 emerge/cli.py,sha256=NU1uhwuZ6i50680v3_I4kDZPTHqz74gOYK71UBhb8oE,666
 emerge/ext.py,sha256=IBoHH5PQFj5pYMfp6r-uMpNNgbSe8c0g9x8qjBzzVmU,223
@@ -10,21 +10,21 @@ emerge/_emerge/_cache_check.py,sha256=_m9rV-VcaC4uNfETZ2Rp1tkA-gZ5FD3xL3KOHlgdvy
 emerge/_emerge/bc.py,sha256=TeSVNkDgOGaoHw5raTzhUV0ngtyHa33sXAoL2hRn70M,8077
 emerge/_emerge/const.py,sha256=PTZZTSDOP5NsZ8XnJrKTY2P0tPUhmutBJ1yrm-t7xsI,129
 emerge/_emerge/coord.py,sha256=BKvyrcnHY-_bgHqysnByy5k9_DK4VVfr9KKkRaawG2E,4371
-emerge/_emerge/cs.py,sha256=YNT2Nn6Dh8fYPUMlT6w0msHnQpZREbbl_ZXTGNppCVs,18392
+emerge/_emerge/cs.py,sha256=gULfov6s0jODOdQkH6NmGBbG5wvny1-bJU8fdAlpCHo,19730
 emerge/_emerge/dataset.py,sha256=UcSAJ_siLrOjNBBWRWsS3GUZUpayp63EM6pP6ClwKDI,1534
 emerge/_emerge/geo2d.py,sha256=e_HkX1GQ2iYrdO0zeEgzVOzfGyU1WGJyjeGBAobOttE,3323
-emerge/_emerge/geometry.py,sha256=z6MxW7Q2i1pu12pPaAvIf5PsP84ea3GY2MOG_daLx_8,19537
+emerge/_emerge/geometry.py,sha256=OcQ0wvritkg7Q8oihQI_hLjDGx7JkFaPwfEeJ3_u3Bs,19987
 emerge/_emerge/howto.py,sha256=c4UxUNpA1tygr3OoR-LH-h0UZv-Tf9K8tpCiAU18BKE,8173
-emerge/_emerge/logsettings.py,sha256=DcUWIUUhdLe9ev5XC1bd5ZUrJz00MjABkY8rnekFrPY,3373
-emerge/_emerge/material.py,sha256=FITj4pGlJw6AwsxC275lMbbCJ38mIjwGpA9omblq6ck,15228
-emerge/_emerge/mesh3d.py,sha256=2expfu7YR6KbtaEeR7JELxXkTul0cFECRwwO5bpdgqE,34697
+emerge/_emerge/logsettings.py,sha256=s8UboFEtB0aIuLB2FSL2WIbw0_kB363iHNIy4uGQi7w,3711
+emerge/_emerge/material.py,sha256=bVuMyrmts08at4nUc4ttgYHPsY1cLYNKNmJ4RwgR9TY,15462
+emerge/_emerge/mesh3d.py,sha256=qmdbuuR6W_5nMg7K5fts08v2lk0K8otUO6C4gS0Zjks,35008
 emerge/_emerge/mesher.py,sha256=fKgPb6oZe_bqp0XYfZ6UNgBfRaAS3-tjUtZX8NalJe8,13199
 emerge/_emerge/periodic.py,sha256=xfdKKq3qX7iBBestnRizOzJNfXlpr9lCPkiYhfrRIR8,12013
 emerge/_emerge/plot.py,sha256=cf1I9mj7EIUJcq8vmANlUkqoV6QqVaJaP-zlC-T9E18,8041
 emerge/_emerge/selection.py,sha256=Clx3YopcYwaN61rX4wdDsEJo_0F-DWGe3AP8rPjvTzY,21368
-emerge/_emerge/simmodel.py,sha256=lzrWtPQlhKHs4QHTj-icg2tycCn_zhq4PITHhAhC9I0,20451
+emerge/_emerge/simmodel.py,sha256=qycNtzKgNllQvPQrbSlKhimJQ1ucMIEM-BsKCrHJemE,20504
 emerge/_emerge/simulation_data.py,sha256=r9-9lpLeA1Z5HU3jDVOXV1H80GVawnXL5K81_dvmlE4,14506
-emerge/_emerge/solver.py,sha256=kZr_lNnLbHe2LBO9ujyHdfh47jc_qqnFgrlPwhZZMHE,49348
+emerge/_emerge/solver.py,sha256=J7aIpW7Eni56wnVhXL2JSuwRf8HuTBQCUrXKx31u5EU,49927
 emerge/_emerge/system.py,sha256=p4HNz7d_LMRNE9Gk75vVdFecDH2iN_groAM9u-yQTpk,1618
 emerge/_emerge/elements/__init__.py,sha256=I3n9aic6lJW-oGeqTEZ-Fpxvyl2i-WqsHdnrM3v1oB8,799
 emerge/_emerge/elements/femdata.py,sha256=o5P-lRAW_xWEOQ_jrT5zRciFZwq1LqCIXfaWurWdjmw,8082
@@ -38,8 +38,8 @@ emerge/_emerge/geo/modeler.py,sha256=_PMz3lFSa7FmJHWdY-4U1Sqbed-Egy85S_AdjlCldC4
 emerge/_emerge/geo/operations.py,sha256=lqfCU99uiLc0vDGqILpMP1YgKs1e-gwEcSLbI_gE6TA,12441
 emerge/_emerge/geo/pcb.py,sha256=MmY-A-Xnd85aQw6ouOnsZKcui_kH86fw4l0GoR4qQu0,53442
 emerge/_emerge/geo/pmlbox.py,sha256=gaIG_AoZNQnIyJ8C7x64U-Hw5dsmllWMiZDAH4iRoM0,8784
-emerge/_emerge/geo/polybased.py,sha256=loVJRBjYCTUlti5tHwfH8iU-Inb6n2sOS2Cw4gVKid4,31917
-emerge/_emerge/geo/shapes.py,sha256=-ct-TJh69oj5fqJcQql4pNk3acJWTIQzYOQeAFXDfWk,23319
+emerge/_emerge/geo/polybased.py,sha256=3Lpbbw6o9ypTvInMNcLa-zF5jP8uOSn9c_Tiv_R85cc,33055
+emerge/_emerge/geo/shapes.py,sha256=i0kcwC1EqOpXonJUhdpRKfed3MaFnPsEc_vgTfRSWwI,23532
 emerge/_emerge/geo/step.py,sha256=XcAiEN8W4umNmZdYmrGHX_aJUuiMgc6vgT-UIk8Gbqc,2689
 emerge/_emerge/geo/pcb_tools/calculator.py,sha256=VbMP2xC9i7OFwtqnnwfYgyJSEcJIjr2VIy_Ez1hYqlU,859
 emerge/_emerge/geo/pcb_tools/macro.py,sha256=0g-0anOFyxrEkFobiSu0cwWFRQ32xB8Az24mmwo0z6M,2992
@@ -50,8 +50,8 @@ emerge/_emerge/mth/pairing.py,sha256=i8bBvTeMmzgF0JdiDNJiTXxx913x4f10777pzD6FJo0
 emerge/_emerge/physics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/physics/microwave/__init__.py,sha256=QHeILGYWmvbfLl1o9wrTiWLm0evfXDgS0JiikUoMTts,28
 emerge/_emerge/physics/microwave/adaptive_freq.py,sha256=aWhijhCVAbnuwkru-I1AaRdY20uyozf6OWRIh9r2ijg,9786
-emerge/_emerge/physics/microwave/microwave_3d.py,sha256=lKHaMcL8kztwUF4V9zUycT7Ec7aTZS9SAiZh6auzCYc,42379
-emerge/_emerge/physics/microwave/microwave_bc.py,sha256=dU2vi8amEewM1ZLgtOk4oYXknH_gzt2c6J9BH4aIJiw,42294
+emerge/_emerge/physics/microwave/microwave_3d.py,sha256=ocyLCLt6iZ2FlmqLvNCqxSDKdFRirUFRQYGNi8xgyRk,42367
+emerge/_emerge/physics/microwave/microwave_bc.py,sha256=YaEkSyOsC9Di7-JItijuRKD60ZA9CmEX8Tu8pViMN90,42114
 emerge/_emerge/physics/microwave/microwave_data.py,sha256=njeNfw_Is4bc97H-hefi-Bk8NSGMElXk0yzDb4v6mVk,50365
 emerge/_emerge/physics/microwave/periodic.py,sha256=wYSUgLFVtCLqSG3EDKoCDRU93iPUzBdXzVRdHTRmbpI,3000
 emerge/_emerge/physics/microwave/port_functions.py,sha256=aVU__AkVk8b1kH2J_oDLF5iNReCxC9nzCtesFSSSSQo,2112
@@ -67,19 +67,19 @@ emerge/_emerge/physics/microwave/assembly/periodicbc.py,sha256=Zg1kgQMccDQA2oVEr
 emerge/_emerge/physics/microwave/assembly/robinbc.py,sha256=syJ-NuHHA0WDQECuaPdeW-OfzIGHmxxqalKiokSyJFI,17742
 emerge/_emerge/plot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/plot/display.py,sha256=TQLlKb-LkaG5ZOSLfxp9KXPlZPRFTxNj1LhVQ-Lp1-s,18476
-emerge/_emerge/plot/simple_plots.py,sha256=qMQoMdSdTMQX5LvjI1n_dpZ6e51LzRCUOZuu5uHPd3w,24806
+emerge/_emerge/plot/simple_plots.py,sha256=lzAyLpY4yaAgMBgNkpeIxdrdSp5nQH6JmBI_ZfjzuhY,25229
 emerge/_emerge/plot/matplotlib/mpldisplay.py,sha256=szKafDrgdAW5Nyc5UOHuJC87n0WGkXYackOVv182TDQ,8671
 emerge/_emerge/plot/pyvista/__init__.py,sha256=CPclatEu6mFnJZzCQk09g6T6Fh20WTbiLAJGSwAnPXU,30
-emerge/_emerge/plot/pyvista/display.py,sha256=GJ_fmU1AWLzPWwl3CQd50LOOmjEQ0JWaNFOk17Ux60M,38348
+emerge/_emerge/plot/pyvista/display.py,sha256=Y8BT3ML9eeSQw_HLDmi3KCe0xtA8qOahOnCPGgvnM2g,38354
 emerge/_emerge/plot/pyvista/display_settings.py,sha256=k4JfiNuaVDpPZrZa0sIuuFFwLvYAWDS17tusUCVHNu0,1036
 emerge/_emerge/projects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/projects/_gen_base.txt,sha256=DqQz36PZg6v1ovQjHvPjd0t4AIbmikZdb9dmrNYsK3w,598
 emerge/_emerge/projects/_load_base.txt,sha256=bHsZ4okxa9uu8qP4UOxSAeIQzuwpRtN0i71rg8wuqMA,473
 emerge/_emerge/projects/generate_project.py,sha256=TNw-0SpLc82MBq0bd9hB_yqvBZCgmuPonCBsHTp91uk,1450
-emerge/_emerge/solve_interfaces/cudss_interface.py,sha256=-SjiTNIyE7iJ8Bm14Cva5e2lpJDgfiS2Mvz1Bgy-UL4,9688
+emerge/_emerge/solve_interfaces/cudss_interface.py,sha256=Iszyy7RuuCa_FgfROEyTSSWbmR2LzMUkEcR8klzIKOQ,9915
 emerge/_emerge/solve_interfaces/pardiso_interface.py,sha256=iVFxToMmIzhj3hcAP-O_MDHKz82ePFIHY1us11kzUBU,15305
-emerge-0.6.9.dist-info/METADATA,sha256=yAvC6lujrzubYu_H2qBafFx1k3c_kuoO3gD83cldhtA,3338
-emerge-0.6.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emerge-0.6.9.dist-info/entry_points.txt,sha256=8rFvAXticpKg4OTC8JEvAksnduW72KIEskCGG9XnFf8,43
-emerge-0.6.9.dist-info/licenses/LICENSE,sha256=VOCXWddrjMN5j7TvnSAOh1Dx7jkugdwq9Lqhycf5inc,17852
-emerge-0.6.9.dist-info/RECORD,,
+emerge-0.6.10.dist-info/METADATA,sha256=tmedxST_2MpgTZXZK7GGc0RMNt_9DjEMKlJjw6IFh0g,3339
+emerge-0.6.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emerge-0.6.10.dist-info/entry_points.txt,sha256=8rFvAXticpKg4OTC8JEvAksnduW72KIEskCGG9XnFf8,43
+emerge-0.6.10.dist-info/licenses/LICENSE,sha256=VOCXWddrjMN5j7TvnSAOh1Dx7jkugdwq9Lqhycf5inc,17852
+emerge-0.6.10.dist-info/RECORD,,