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

emerge/_emerge/plot/pyvista/display.py

@@ -284,15 +284,16 @@ class PVDisplay(BaseDisplay):
         self._ruler.min_length = max(1e-3, min(self._mesh.edge_lengths))
         self._update_camera()
         self._add_aux_items()
+        # self._plot.renderer.enable_depth_peeling(20, 0.8)
+        # self._plot.enable_anti_aliasing(self.set.anti_aliassing)
         if self._do_animate:
             self._wire_close_events()
             self.add_text('Press Q to close!',color='red', position='upper_left')
             self._plot.show(auto_close=False, interactive_update=True, before_close_callback=self._close_callback)
             self._animate()
-            
-            
         else:
             self._plot.show()
+        
         self._reset()
     
     def set_mesh(self, mesh: Mesh3D):
@@ -440,8 +441,20 @@ class PVDisplay(BaseDisplay):
         opacity = obj.opacity
         line_width = 0.5
         color = obj.color_rgb
+        metal = obj._metal
         style='surface'
         
+        # Default render settings
+        metallic = 0.05
+        roughness = 0.5
+        pbr = False
+        
+        if metal:
+            pbr = True
+            metallic = 0.8
+            roughness = 0.3
+        
+        # Default keyword arguments when plotting Mesh mode.
         if mesh is True:
             show_edges = True
             opacity = 0.7
@@ -449,13 +462,28 @@ class PVDisplay(BaseDisplay):
             style='wireframe'
             color=next(C_CYCLE)
         
-        kwargs = setdefault(kwargs, color=color, opacity=opacity, line_width=line_width, show_edges=show_edges, pickable=True, style=style)
+        # Defining the default keyword arguments for PyVista
+        kwargs = setdefault(kwargs, color=color, 
+                            opacity=opacity, 
+                            metallic=metallic, 
+                            pbr=pbr,
+                            roughness=roughness,
+                            line_width=line_width, 
+                            show_edges=show_edges, 
+                            pickable=True, 
+                            style=style)
         mesh_obj = self.mesh(obj)
         
         if mesh is True and volume_mesh is True:
             mesh_obj = mesh_obj.extract_all_edges()
-        
         actor = self._plot.add_mesh(mesh_obj, *args, **kwargs)
+        
+        # Push 3D Geometries back to avoid Z-fighting with 2D geometries.
+        if obj.dim==3:
+            mapper = actor.GetMapper()
+            mapper.SetResolveCoincidentTopology(1)
+            mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(1,1)
+        
         self._plot.add_mesh(self._volume_edges(_select(obj)), color='#000000', line_width=2, show_edges=True)
 
     def add_scatter(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray):
@@ -568,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/pyvista/display_settings.py

@@ -1,3 +1,4 @@
+from typing import Literal
 
 class PVDisplaySettings:
 
@@ -22,4 +23,6 @@ class PVDisplaySettings:
         self.background_bottom: str = "#c0d2e8"
         self.background_top: str = "#ffffff"
         self.grid_line_color: str = "#8e8e8e"
-        self.z_boost: float = 1e-6
+        self.z_boost: float = 0#1e-9
+        self.depth_peeling: bool = True
+        self.anti_aliassing: Literal["msaa","ssaa",'fxaa'] = "msaa"

emerge/_emerge/plot/simple_plots.py

@@ -406,25 +406,30 @@ and sparse frequency annotations (e.g., labeled by frequency).
     plt.tight_layout()
     plt.show()
 
-def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray, 
-                      dblim=[-40, 5], 
-                    xunit="GHz", 
-                    levelindicator: int | float | None = None, 
-                    noise_floor=-150, 
-                    fill_areas: list[tuple] | None = None, 
-                    spec_area: list[tuple[float,...]] | None = None,
-                    unwrap_phase=False, 
-                    logx: bool = False,
-                    labels: list[str] | None = None,
-                    linestyles: list[str] | None = None,
-                    colorcycle: list[int] | None = None,
-                    filename: str | None = None,
-                    show_plot: bool = True,
-                    figdata: tuple | None = None) -> tuple[plt.Figure, plt.Axes, plt.Axes]:
+def plot_sp(f: np.ndarray | list[np.ndarray], S: list[np.ndarray] | np.ndarray, 
+            dblim=[-40, 5], 
+            xunit="GHz", 
+            levelindicator: int | float | None = None, 
+            noise_floor=-150, 
+            fill_areas: list[tuple] | None = None, 
+            spec_area: list[tuple[float,...]] | None = None,
+            unwrap_phase=False, 
+            logx: bool = False,
+            labels: list[str] | None = None,
+            linestyles: list[str] | None = None,
+            colorcycle: list[int] | None = None,
+            filename: str | None = None,
+            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".
@@ -444,7 +449,12 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
         Ss = [S]
     else:
         Ss = S
-
+        
+    if not isinstance(f, list):
+        fs = [f for _ in Ss]
+    else:
+        fs = f
+    
     if linestyles is None:
         linestyles = ['-' for _ in S]
 
@@ -452,7 +462,8 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
         colorcycle = [i for i, S in enumerate(S)]
 
     unitdivider: dict[str, float] = {"MHz": 1e6, "GHz": 1e9, "kHz": 1e3}
-    fnew = f / unitdivider[xunit]
+    
+    fs = [f / unitdivider[xunit] for f in fs]
 
     if figdata is None:
         # Create two subplots: one for magnitude and one for phase
@@ -463,10 +474,10 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
     minphase, maxphase = -180, 180
 
     maxy = 0
-    for s, ls, cid in zip(Ss, linestyles, colorcycle):
+    for f, s, ls, cid in zip(fs, Ss, linestyles, colorcycle):
         # Calculate and plot magnitude in dB
         SdB = 20 * np.log10(np.abs(s) + 10**(noise_floor/20) * np.random.rand(*s.shape) + 10**((noise_floor-30)/20))
-        ax_mag.plot(fnew, SdB, label="Magnitude (dB)", linestyle=ls, color=EMERGE_COLORS[cid % len(EMERGE_COLORS)])
+        ax_mag.plot(f, SdB, label="Magnitude (dB)", linestyle=ls, color=EMERGE_COLORS[cid % len(EMERGE_COLORS)])
         if np.max(SdB) > maxy:
             maxy = np.max(SdB)
         # Calculate and plot phase in degrees
@@ -475,12 +486,12 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
             phase = np.unwrap(phase, period=360)
             minphase = min(np.min(phase), minphase)
             maxphase = max(np.max(phase), maxphase)
-        ax_phase.plot(fnew, phase, label="Phase (degrees)", linestyle=ls, color=EMERGE_COLORS[cid % len(EMERGE_COLORS)])
+        ax_phase.plot(f, phase, label="Phase (degrees)", linestyle=ls, color=EMERGE_COLORS[cid % len(EMERGE_COLORS)])
 
         # Annotate level indicators if specified
         if isinstance(levelindicator, (int, float)) and levelindicator is not None:
             lvl = levelindicator
-            fcross = hintersections(fnew, SdB, lvl)
+            fcross = hintersections(f, SdB, lvl)
             for fs in fcross:
                 ax_mag.annotate(
                     f"{str(fs)[:4]}{xunit}",
@@ -500,16 +511,18 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
             f2 = fmax / unitdivider[xunit]
             ax_mag.fill_between([f1, f2], vmin,vmax, color='red', alpha=0.2)
     # Configure magnitude plot (ax_mag)
+    fmin = min([min(f) for f in fs])
+    fmax = max([max(f) for f in fs])
     ax_mag.set_ylabel("Magnitude (dB)")
     ax_mag.set_xlabel(f"Frequency ({xunit})")
-    ax_mag.axis([min(fnew), max(fnew), dblim[0], max(maxy*1.1,dblim[1])]) # type: ignore
+    ax_mag.axis([fmin, fmax, dblim[0], max(maxy*1.1,dblim[1])]) # type: ignore
     ax_mag.axhline(y=0, color="k", linewidth=1)
     ax_mag.xaxis.set_minor_locator(tck.AutoMinorLocator(2))
     ax_mag.yaxis.set_minor_locator(tck.AutoMinorLocator(2))
     # Configure phase plot (ax_phase)
     ax_phase.set_ylabel("Phase (degrees)")
     ax_phase.set_xlabel(f"Frequency ({xunit})")
-    ax_phase.axis([min(fnew), max(fnew), minphase, maxphase]) # type: ignore
+    ax_phase.axis([fmin, fmax, minphase, maxphase]) # type: ignore
     ax_phase.xaxis.set_minor_locator(tck.AutoMinorLocator(2))
     ax_phase.yaxis.set_minor_locator(tck.AutoMinorLocator(2))
     if logx:
@@ -527,7 +540,7 @@ def plot_sp(f: 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,
@@ -546,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.
@@ -567,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
@@ -583,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)
@@ -612,6 +632,8 @@ def plot_ff(
 def plot_ff_polar(
     theta: np.ndarray,
     E: Union[np.ndarray, Sequence[np.ndarray]],
+    dB: bool = False,
+    dBfloor: float = -30,
     labels: Optional[List[str]] = None,
     linestyles: Union[str, List[str]] = "-",
     linewidth: float = 2.0,
@@ -649,6 +671,8 @@ def plot_ff_polar(
         E_list = list(E)
     n_series = len(E_list)
 
+    if dB:
+        E_list = [20*np.log10(np.clip(np.abs(e), a_min=10**(dBfloor/20), a_max = 1e9)) for e in E_list]
     # Style broadcasting
     def _broadcast(param, default):
         if isinstance(param, list):
@@ -665,11 +689,15 @@ def plot_ff_polar(
     ax.set_theta_zero_location(zero_location) # type: ignore
     ax.set_theta_direction(-1 if clockwise else 1) # type: ignore
     ax.set_rlabel_position(rlabel_angle) # type: ignore
+    ymin = min([min(E) for E in E_list])
+    ymax = max([max(E) for E in E_list])
+    yrange = ymax-ymin
 
+    ax.set_ylim(ymin-0.05*yrange, ymax+0.05*yrange)
     for i, Ei in enumerate(E_list):
-        mag = np.abs(Ei)
+        
         ax.plot(
-            theta, mag,
+            theta, Ei,
             linestyle=linestyles[i],
             linewidth=linewidth,
             marker=markers[i],

emerge/_emerge/projects/_load_base.txt

@@ -17,8 +17,7 @@ with em.Simulation("myfile", load_file=True) as m:
     S11 = data.S(1,1)
     S21 = data.S(2,1)
     plt.plot_sp(f/1e9, [S11, S21])
-
-    m.set_mesh(m.data.mw.field[0].mesh)
+    
     m.display.add_object(m['box'])
     m.display.add_surf(*m.data.mw.field[0].cutplane(1*mm, z=5*mm).scalar('Ez','real'))
     m.display.show()

emerge/_emerge/selection.py

@@ -205,6 +205,10 @@ class Selection:
     def centers(self) -> list[tuple[float, float, float],]:
         return [gmsh.model.occ.get_center_of_mass(self.dim, tag) for tag in self.tags]
     
+    @property
+    def _metal(self) -> bool:
+        return False
+    
     @property
     def opacity(self) -> float:
         return 0.6

emerge/_emerge/simmodel.py

@@ -31,7 +31,7 @@ from typing import Literal, Generator, Any
 from loguru import logger
 import numpy as np
 import gmsh # type: ignore
-import joblib # type: ignore
+import cloudpickle
 import os
 import inspect
 from pathlib import Path
@@ -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()
     
 
@@ -181,7 +182,10 @@ class Simulation:
 
             # Restier the Exit GMSH function on proper program abortion
             register(self._exit_gmsh)
-
+        else:
+            gmsh.finalize()
+            gmsh.initialize()
+            
         # Create a new GMSH model or load it
         if not self.load_file:
             gmsh.model.add(self.modelname)
@@ -283,7 +287,8 @@ class Simulation:
         # Pack and save data
         dataset = dict(simdata=self.data, mesh=self.mesh)
         data_path = self.modelpath / 'simdata.emerge'
-        joblib.dump(dataset, str(data_path))
+        with open(str(data_path), "wb") as f_out:
+            cloudpickle.dump(dataset, f_out)
         logger.info(f"Saved simulation data to: {data_path}")
 
     def load(self) -> None:
@@ -304,7 +309,8 @@ class Simulation:
         #self.mesh.update([])
 
         # Load data
-        datapack = joblib.load(str(data_path))
+        with open(str(data_path), "rb") as f_in:
+            datapack= cloudpickle.load(f_in)
         self.data = datapack['simdata']
         self._set_mesh(datapack['mesh'])
         logger.info(f"Loaded simulation data from: {data_path}")
@@ -319,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={})