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

emerge/_emerge/plot/pyvista/display.py

@@ -26,7 +26,7 @@ from typing import Iterable, Literal, Callable, Any
 from ..display import BaseDisplay
 from .display_settings import PVDisplaySettings
 from matplotlib.colors import ListedColormap
-
+from itertools import cycle
 ### Color scale
 
 # Define the colors we want to use
@@ -40,6 +40,40 @@ cmap_names = Literal['bgy','bgyw','kbc','blues','bmw','bmy','kgy','gray','dimgra
                      'bkr','bky','coolwarm','gwv','bjy','bwy','cwr','colorwheel','isolum','rainbow','fire',
                      'cet_fire','gouldian','kbgyw','cwr','CET_CBL1','CET_CBL3','CET_D1A']
 
+
+def _gen_c_cycle():
+    colors = [
+        "#0000aa",
+        "#aa0000",
+        "#009900",
+        "#990099",
+        "#994400",
+        "#005588"
+    ]
+    return cycle(colors)
+
+C_CYCLE = _gen_c_cycle()
+
+class _RunState:
+    
+    def __init__(self):
+        self.state: bool = False
+        self.ctr: int = 0
+        
+        
+    def run(self):
+        self.state = True
+        self.ctr = 0
+        
+    def stop(self):
+        self.state = False
+        self.ctr = 0
+        
+    def step(self):
+        self.ctr += 1
+    
+ANIM_STATE = _RunState()
+
 def gen_cmap(mesh, N: int = 256):
     # build a linear grid of data‐values (not strictly needed for pure colormap)
     vmin, vmax = mesh['values'].min(), mesh['values'].max()
@@ -201,6 +235,7 @@ class PVDisplay(BaseDisplay):
         self._stop: bool = False
         self._objs: list[_AnimObject] = []
         self._do_animate: bool = False
+        self._closed_via_x: bool = False
         self._Nsteps: int  = 0
         self._fps: int = 25
         self._ruler: ScreenRuler = ScreenRuler(self, 0.001)
@@ -216,6 +251,15 @@ class PVDisplay(BaseDisplay):
         self._ctr: int = 0 
         
         self.camera_position = (1, -1, 1)     # +X, +Z, -Y
+    
+    def _wire_close_events(self):
+        self._closed = False
+
+        def mark_closed(*_):
+            self._closed = True
+            self._stop = True
+        
+        self._plot.add_key_event('q', lambda: mark_closed())
         
     def _update_camera(self):
         x,y,z = self._plot.camera.position
@@ -241,8 +285,12 @@ class PVDisplay(BaseDisplay):
         self._update_camera()
         self._add_aux_items()
         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()
@@ -261,8 +309,9 @@ class PVDisplay(BaseDisplay):
         self._plot = pv.Plotter()
         self._stop = False
         self._objs = []
+        C_CYCLE = _gen_c_cycle()
 
-    def _close_callback(self):
+    def _close_callback(self, arg):
         """The private callback function that stops the animation.
         """
         self._stop = True
@@ -270,16 +319,44 @@ class PVDisplay(BaseDisplay):
     def _animate(self) -> None:
         """Private function that starts the animation loop.
         """
-        self._plot.update()
-        while not self._stop:
-            for step in range(self._Nsteps):
-                if self._stop:
-                    break
+        
+        self._stop = False
+
+        # guard values
+        steps = max(1, int(self._Nsteps))
+        fps   = max(1, int(self._fps))
+        dt    = 1.0 / fps
+        next_tick = time.perf_counter()
+        step = 0
+
+        while (not self._stop
+                and not self._closed_via_x
+                and self._plot.render_window is not None):
+            # process window/UI events so close button works
+            self._plot.update()
+
+            now = time.perf_counter()
+            if now >= next_tick:
+                step = (step + 1) % steps
+                phi = np.exp(1j * (step / steps) * 2*np.pi)
+
+                # update all animated objects
                 for aobj in self._objs:
-                    phi = np.exp(1j*(step/self._Nsteps)*2*np.pi)
                     aobj.update(phi)
-                self._plot.update()
-                time.sleep(1/self._fps)
+
+                # draw one frame
+                self._plot.render()
+
+                # schedule next frame; catch up if we fell behind
+                next_tick += dt
+                if now > next_tick + dt:
+                    next_tick = now + dt
+
+            # be kind to the CPU
+            time.sleep(0.001)
+
+        # ensure cleanup pathway runs once
+        self._close_callback(None)
 
     def animate(self, Nsteps: int = 35, fps: int = 25) -> PVDisplay:
         """ Turns on the animation mode with the specified number of steps and FPS.
@@ -357,11 +434,29 @@ class PVDisplay(BaseDisplay):
             return None
 
     ## OBLIGATORY METHODS
-    def add_object(self, obj: GeoObject | Selection, *args, **kwargs):
-        kwargs = setdefault(kwargs, color=obj.color_rgb, opacity=obj.opacity, silhouette=False, show_edges=False, pickable=True)
+    def add_object(self, obj: GeoObject | Selection, mesh: bool = False, volume_mesh: bool = True, *args, **kwargs):
+        
+        show_edges = False
+        opacity = obj.opacity
+        line_width = 0.5
+        color = obj.color_rgb
+        style='surface'
+        
+        if mesh is True:
+            show_edges = True
+            opacity = 0.7
+            line_width= 1
+            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)
+        mesh_obj = self.mesh(obj)
         
-        actor = self._plot.add_mesh(self.mesh(obj), *args, **kwargs)
-        self._plot.add_mesh(self._volume_edges(_select(obj)), color='#000000', line_width=1, show_edges=True)
+        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)
+        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):
         """Adds a scatter point cloud
@@ -471,6 +566,7 @@ class PVDisplay(BaseDisplay):
         grid = pv.StructuredGrid(x,y,z)
         field_flat = field.flatten(order='F')
 
+
         if scale=='log':
             T = lambda x: np.log10(np.abs(x))
         elif scale=='symlog':
@@ -486,25 +582,28 @@ class PVDisplay(BaseDisplay):
         self._ctr += 1
         grid[name] = static_field
 
+        grid_no_nan = grid.threshold(scalars=name)
+
+        # Determine color limits
         if clim is None:
-            fmin = np.min(static_field)
-            fmax = np.max(static_field)
+            fmin = np.nanmin(static_field)
+            fmax = np.nanmax(static_field)
             clim = (fmin, fmax)
-        
         if symmetrize:
-            lim = max(abs(clim[0]),abs(clim[1]))
+            lim = max(abs(clim[0]), abs(clim[1]))
             clim = (-lim, lim)
 
         kwargs = setdefault(kwargs, cmap=cmap, clim=clim, opacity=opacity, pickable=False, multi_colors=True)
-        actor = self._plot.add_mesh(grid, scalars=name, **kwargs)
+        actor = self._plot.add_mesh(grid_no_nan, scalars=name, **kwargs)
+
 
         if self._do_animate:
             def on_update(obj: _AnimObject, phi: complex):
-                field = obj.T(np.real(obj.field*phi))
-                obj.grid['anim'] = field
-            self._objs.append(_AnimObject(field_flat, T, grid, actor, on_update)) # type: ignore
-        
-        
+                field_anim = obj.T(np.real(obj.field * phi))
+                obj.grid[name] = field_anim
+            self._objs.append(_AnimObject(field_flat, T, grid_no_nan, actor, on_update))
+
+
     def add_title(self, title: str) -> None:
         """Adds a title
 
@@ -524,6 +623,8 @@ class PVDisplay(BaseDisplay):
         if abs_position is not None:
             final_position = abs_position
             viewport = True
+        else:
+            final_position = abs_position
         self._plot.add_text(
             text,
             position=final_position,
@@ -554,6 +655,11 @@ class PVDisplay(BaseDisplay):
         dx = dx.flatten().real
         dy = dy.flatten().real
         dz = dz.flatten().real
+        
+        ids = np.invert(np.isnan(dx))
+        
+        x, y, z, dx, dy, dz = x[ids], y[ids], z[ids], dx[ids], dy[ids], dz[ids]
+        
         dmin = _min_distance(x,y,z)
 
         dmax = np.max(_norm(dx,dy,dz))
@@ -569,8 +675,10 @@ class PVDisplay(BaseDisplay):
         kwargs = dict()
         if color is not None:
             kwargs['color'] = color
+            
         pl = self._plot.add_arrows(Coo, Vec, scalars=None, clim=None, cmap=None, **kwargs)
 
+        
     def add_contour(self,
                      X: np.ndarray,
                      Y: np.ndarray,

emerge/_emerge/plot/simple_plots.py

@@ -533,7 +533,7 @@ def plot_ff(
     dB: bool = False,
     labels: Optional[List[str]] = None,
     xlabel: str = "Theta (rad)",
-    ylabel: str = "|E|",
+    ylabel: str = "",
     linestyles: Union[str, List[str]] = "-",
     linewidth: float = 2.0,
     markers: Optional[Union[str, List[Optional[str]]]] = None,

emerge/_emerge/simmodel.py

@@ -245,13 +245,20 @@ class Simulation:
         vM, vm, vp = [float(x) for x in version.split('.')]
         cM, cm, cp = [float(x) for x in __version__.split('.')]
         if vM != cM:
-            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}")
+            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}. \n You can upgrade your version of emerge with: pip --upgrade emerge")
         if vm != cm:
-            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}")
+            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}. \n You can upgrade your version of emerge with: pip --upgrade emerge")
         if vp != cp:
-            logger.warning(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}")
+            logger.warning("You are running a script designed for a different version of EMerge.")
+            logger.warning(f"The script version: {version}")
+            logger.warning(f"EMerge version:     {__version__}")
+            logger.warning("Usually EMerge works without a problem but Errors may occur.")
+            logger.warning("You can upgrade your version of emerge with: pip --upgrade emerge")
             logger.warning("You may suppress this error by removing the call to .check_version().")
-            input('Press enter to proceed...')
+            logger.warning("Press Ctrl+C to abort.")
+            ans = input('Press enter to proceed or [Q] to quit:')
+            if ans.lower().strip()=='q':
+                quit()
 
     def save(self) -> None:
         """Saves the current model in the provided project directory."""
@@ -319,24 +326,26 @@ class Simulation:
     def view(self, 
              selections: list[Selection] | None = None, 
              use_gmsh: bool = False,
-             volume_opacity: float = 0.1,
-             surface_opacity: float = 1,
-             show_edges: bool = True) -> None:
+             plot_mesh: bool = False,
+             volume_mesh: bool = True,
+             opacity: float | None = None) -> None:
         """View the current geometry in either the BaseDisplay object (PVDisplay only) or
         the GMSH viewer.
 
         Args:
-            selections (list[Selection], optional): Additional selections to highlight. Defaults to None.
-            use_gmsh (bool, optional): Whether to use the GMSH display. Defaults to False.
-            opacity (float, optional): The global opacity of all objects.. Defaults to None.
-            show_edges (bool, optional): Whether to show the geometry edges. Defaults to None.
+            selections (list[Selection] | None, optional): Optional selections to highlight. Defaults to None.
+            use_gmsh (bool, optional): If GMSH's GUI should be used. Defaults to False.
+            plot_mesh (bool, optional): If the mesh should be plot instead of the object. Defaults to False.
+            volume_mesh (bool, optional): If the internal mesh should be plot instead of only the surface boundary mesh. Defaults to True
+            opacity (float | None, optional): The object/mesh opacity. Defaults to None.
+
         """
         if not (self.display is not None and self.mesh.defined) or use_gmsh:
             gmsh.model.occ.synchronize()
             gmsh.fltk.run()
             return
         for geo in _GEOMANAGER.all_geometries():
-            self.display.add_object(geo)
+            self.display.add_object(geo, mesh=plot_mesh, opacity=opacity, volume_mesh=volume_mesh)
         if selections:
             [self.display.add_object(sel, color='red', opacity=0.3) for sel in selections]
         self.display.show()
@@ -456,7 +465,7 @@ class Simulation:
 
             logger.info(f'Iterating: {params}')
             if len(dims_flat)==1:
-                yield (dims_flat[0][i_iter],)
+                yield dims_flat[0][i_iter]
             else:
                 yield (dim[i_iter] for dim in dims_flat) # type: ignore
         self.mw.cache_matrices = True

emerge/_emerge/solver.py

@@ -289,10 +289,14 @@ class Solver:
 
     def __init__(self):
         self.own_preconditioner: bool = False
+        self.initialized: bool = False
 
     def __str__(self) -> str:
         return f'{self.__class__.__name__}'
     
+    def initialize(self) -> None:
+        return None
+
     def duplicate(self) -> Solver:
         return self.__class__()
 
@@ -324,6 +328,9 @@ class EigSolver:
     def __init__(self):
         self.own_preconditioner: bool = False
 
+    def initialize(self) -> None:
+        return None
+
     def __str__(self) -> str:
         return f'{self.__class__.__name__}'
     
@@ -513,7 +520,19 @@ class SolverUMFPACK(Solver):
         super().__init__()
         self.A: np.ndarray = None
         self.b: np.ndarray = None
-        self.umfpack: um.UmfpackContext = um.UmfpackContext('zl')
+        
+        self.umfpack: um.UmfpackContext | None = None
+        
+        # SETTINGS
+        self._pivoting_threshold: float = 0.001
+
+        self.fact_symb: bool = False
+        self.initalized: bool = False
+
+    def initialize(self):
+        if self.initalized:
+            return
+        self.umfpack = um.UmfpackContext('zl')
         self.umfpack.control[um.UMFPACK_PRL] = 0 # ty: ignore
         self.umfpack.control[um.UMFPACK_IRSTEP] = 2 # ty: ignore
         self.umfpack.control[um.UMFPACK_STRATEGY] = um.UMFPACK_STRATEGY_SYMMETRIC # ty: ignore
@@ -522,21 +541,16 @@ class SolverUMFPACK(Solver):
         self.umfpack.control[um.UMFPACK_SYM_PIVOT_TOLERANCE] = 0.001 # ty: ignore
         self.umfpack.control[um.UMFPACK_BLOCK_SIZE] = 64 # ty: ignore
         self.umfpack.control[um.UMFPACK_FIXQ] = -1 # ty: ignore
-        
-        # SETTINGS
-        self._pivoting_threshold: float = 0.001
-
-        self.fact_symb: bool = False
-
+        self.initalized = True
     def reset(self) -> None:
         self.fact_symb = False
     
-    def set_options(self,
-                    pivoting_threshold: float | None = None) -> None:
-            if pivoting_threshold is not None:
-                self.umfpack.control[um.UMFPACK_PIVOT_TOLERANCE] = pivoting_threshold # ty: ignore
-                self.umfpack.control[um.UMFPACK_SYM_PIVOT_TOLERANCE] = pivoting_threshold # ty: ignore
-                self._pivoting_threshold = pivoting_threshold
+    def set_options(self, pivoting_threshold: float | None = None) -> None:
+        self.initialize()
+        if pivoting_threshold is not None:
+            self.umfpack.control[um.UMFPACK_PIVOT_TOLERANCE] = pivoting_threshold # ty: ignore
+            self.umfpack.control[um.UMFPACK_SYM_PIVOT_TOLERANCE] = pivoting_threshold # ty: ignore
+            self._pivoting_threshold = pivoting_threshold
 
     def duplicate(self) -> Solver:
         new_solver = self.__class__()
@@ -568,11 +582,17 @@ class SolverPardiso(Solver):
 
     def __init__(self):
         super().__init__()
-        self.solver: PardisoInterface = PardisoInterface()
+        self.solver: PardisoInterface | None = None
         self.fact_symb: bool = False
         self.A: np.ndarray = None
         self.b: np.ndarray = None
 
+    def initialize(self) -> None:
+        if self.initialized:
+            return
+        self.solver = PardisoInterface()
+        self.initialized = True
+        
     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:
@@ -594,11 +614,18 @@ class SolverPardiso(Solver):
 class CuDSSSolver(Solver):
     real_only = False
     def __init__(self):
-        self._cudss = CuDSSInterface()
+        super().__init__()
+        self._cudss: CuDSSInterface | None = None
         self.fact_symb: bool = False
         self.fact_numb: bool = False
+        
+    def initialize(self) -> None:
+        if self.initialized:
+            return
+        self._cudss = CuDSSInterface()
         self._cudss._PRES = 2
-
+        self.initialized = True
+        
     def reset(self) -> None:
         self.fact_symb = False
         self.fact_numb = False
@@ -674,7 +701,7 @@ class SolverARPACK(EigSolver):
             target_k0: float = 0,
             which: str = 'LM',
             sign: float = 1.0) -> tuple[np.ndarray, np.ndarray]:
-        logger.info(f'Searching around 	β = {target_k0:.2f} rad/m')
+        logger.info(f'Searching around 	β = {target_k0:.2f} rad/m with ARPACK')
         sigma = sign*(target_k0**2)
         eigen_values, eigen_modes = eigs(A, k=nmodes, M=B, sigma=sigma, which=which)
         return eigen_values, eigen_modes
@@ -698,7 +725,7 @@ class SmartARPACK_BMA(EigSolver):
             which: str = 'LM',
             sign: float = 1.) -> tuple[np.ndarray, np.ndarray]:
 
-        logger.info(f'Searching around 	β = {target_k0:.2f} rad/m')
+        logger.info(f'Searching around 	β = {target_k0:.2f} rad/m with SmartARPACK (BMA)')
         qs = np.geomspace(1, self.search_range, self.symmetric_steps)
         tot_eigen_values = []
         tot_eigen_modes = []
@@ -747,7 +774,7 @@ class SmartARPACK(EigSolver):
             target_k0: float = 0,
             which: str = 'LM',
             sign: float = 1.) -> tuple[np.ndarray, np.ndarray]:
-        logger.info(f'Searching around 	β = {target_k0:.2f} rad/m')
+        logger.info(f'Searching around 	β = {target_k0:.2f} rad/m with SmartARPACK')
         qs = np.geomspace(1, self.search_range, self.symmetric_steps)
         tot_eigen_values = []
         tot_eigen_modes = []
@@ -1062,7 +1089,7 @@ class SolveRoutine:
         if direct or A.shape[0] < 1000:
             return self.solvers[EMSolver.LAPACK]  # type: ignore
         else:
-            return self.solvers[EMSolver.ARPACK]  # type: ignore
+            return self.solvers[EMSolver.SMART_ARPACK_BMA]  # type: ignore
     
     def solve(self, A: csr_matrix | csr_matrix, 
               b: np.ndarray, 
@@ -1085,7 +1112,7 @@ class SolveRoutine:
             np.ndarray: The resultant solution.
         """
         solver: Solver = self._get_solver(A, b)
-
+        solver.initialize()
         NF = A.shape[0]
         NS = solve_ids.shape[0]
 
@@ -1178,7 +1205,7 @@ class SolveRoutine:
             SolveReport: The solution report
         """
         solver = self._get_eig_solver_bma(A, B, direct=direct)
-
+        solver.initialize()
         NF = A.shape[0]
         NS = solve_ids.shape[0]
 

{emerge-0.6.6.dist-info → emerge-0.6.8.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-emerge/__init__.py,sha256=vDTOfX6iIL3c8TpaSgwGStFWAgPYHb-QlQ4vmhyOzAc,2642
+emerge/__init__.py,sha256=d0irj6Zl58a3DO_ilpI77vqIe9_S1-UspMjSHbXCbr8,2693
 emerge/__main__.py,sha256=WVf16sfrOI910QWohrQDaChZdRifMNoS6VKzCT6f3ZA,92
 emerge/cli.py,sha256=NU1uhwuZ6i50680v3_I4kDZPTHqz74gOYK71UBhb8oE,666
 emerge/ext.py,sha256=IBoHH5PQFj5pYMfp6r-uMpNNgbSe8c0g9x8qjBzzVmU,223
@@ -6,42 +6,42 @@ emerge/lib.py,sha256=kUb4n7VGK4ncR5IHdjvVVd8klSiqZ427ckmEFet16M0,23465
 emerge/plot.py,sha256=AH2D9rKeWUXlSOlh-pUUfLt0oxVLcqF_piki-BmPEg0,83
 emerge/pyvista.py,sha256=-Ht2YcZYsh8-dici5ZPNAWwsis6uz5wNj8n8mxv5fog,42
 emerge/_emerge/__init__.py,sha256=aidfiILy33dt3VyiZ2mgtA87mq-WQ5pXItZUE5wR5ws,703
-emerge/_emerge/_cache_check.py,sha256=fGOiLTdtzg8HIsNP6vrs8BwvgBGAijwg06zsR1v6trQ,1549
+emerge/_emerge/_cache_check.py,sha256=_m9rV-VcaC4uNfETZ2Rp1tkA-gZ5FD3xL3KOHlgdvyA,1547
 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/dataset.py,sha256=UcSAJ_siLrOjNBBWRWsS3GUZUpayp63EM6pP6ClwKDI,1534
 emerge/_emerge/geo2d.py,sha256=e_HkX1GQ2iYrdO0zeEgzVOzfGyU1WGJyjeGBAobOttE,3323
-emerge/_emerge/geometry.py,sha256=2mxVF2Ezd_rK9y6LecgrK1wZ7NbtzROz2BXgu_mPMjg,19190
+emerge/_emerge/geometry.py,sha256=_hBZMRcYImO3rXRex0wcNWPDmdlrQoMJ6NZh4H_CUPo,19277
 emerge/_emerge/howto.py,sha256=c4UxUNpA1tygr3OoR-LH-h0UZv-Tf9K8tpCiAU18BKE,8173
 emerge/_emerge/logsettings.py,sha256=DcUWIUUhdLe9ev5XC1bd5ZUrJz00MjABkY8rnekFrPY,3373
-emerge/_emerge/material.py,sha256=HTjQ8wDzkBwYA1sLPRuqR8lPeoXsW-4m5K3yXoKqjXQ,4022
-emerge/_emerge/mesh3d.py,sha256=Kszo-ogeByvoAVmrCIASc44PRIw-MblxNtwFB0AHa1A,34500
+emerge/_emerge/material.py,sha256=jMAe7W7qT1fcgbah_5DncaPDa7kVGF2GEdnNZ0aoh6k,14973
+emerge/_emerge/mesh3d.py,sha256=2expfu7YR6KbtaEeR7JELxXkTul0cFECRwwO5bpdgqE,34697
 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=x8cGN93BAmO80C0gn6feWcW126vorscsZVzhreTOLxs,21298
-emerge/_emerge/simmodel.py,sha256=guiNnSSxdc6qABHr78LAdp9U1dVxb-SPWBgaKTxFzgw,19535
+emerge/_emerge/simmodel.py,sha256=OVAO1HdtLb7NdgPVWK3G1bRyINPjyC8jpawLDEK6rR8,20280
 emerge/_emerge/simulation_data.py,sha256=r9-9lpLeA1Z5HU3jDVOXV1H80GVawnXL5K81_dvmlE4,14506
-emerge/_emerge/solver.py,sha256=PGPI2LuF4XhfyS8KfC-49X9M1mtYUadgHyqopYfPj58,48542
+emerge/_emerge/solver.py,sha256=kZr_lNnLbHe2LBO9ujyHdfh47jc_qqnFgrlPwhZZMHE,49348
 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=3rFVz1-PLtqxnDFvTH1Q9dA98lO5VyjcFKecCJCwfQ4,8020
-emerge/_emerge/elements/index_interp.py,sha256=DlDy2KrhM5QsF6jYQIl4BJndr9F9wnjFMXxlX3ewb4s,2070
-emerge/_emerge/elements/ned2_interp.py,sha256=kMhbjS1fACa1fmhSkQTU35jS3iF63dJcFe5DHl4Xo78,32541
-emerge/_emerge/elements/nedelec2.py,sha256=chU3Ewz7grKZtpyglj2qFJYHvBzCXFQZa1skzjfHoPo,6138
-emerge/_emerge/elements/nedleg2.py,sha256=qVPKtJpT7UCA5dcI_mXNX7Co4tzVCvlxQv5VtsLuKN8,8468
-emerge/_emerge/geo/__init__.py,sha256=WAAnqNuIrbZWMc7k3mgQ3L_qXRK12gZ755N3MLBJD7I,1126
-emerge/_emerge/geo/horn.py,sha256=h4GzGzEkXgWaQgoBMvhFgGsqOrNRB3CJg3RBKXigCz0,4186
-emerge/_emerge/geo/modeler.py,sha256=gbxmwXAdR7kKW_EFbkd1QPVqJWKJpnTufI7lxaqPyjU,15573
-emerge/_emerge/geo/operations.py,sha256=U6F4vIBW0FnFzeYWBsxxjC3Nf5DS97okgUWYxJzN1KQ,10973
-emerge/_emerge/geo/pcb.py,sha256=kzkpen96KmeRe2qZvMUhOzifPlBv43YaMpQsRG_dzto,52351
-emerge/_emerge/geo/pmlbox.py,sha256=TNjuyPtuqrAU5Yl8GrLlievuwYf3hUKJaCEz0cXKSzo,7922
+emerge/_emerge/elements/femdata.py,sha256=o5P-lRAW_xWEOQ_jrT5zRciFZwq1LqCIXfaWurWdjmw,8082
+emerge/_emerge/elements/index_interp.py,sha256=02CTHaokaAepBRvt7cHVwh3EpOA3sVE3qvEAkDjmwro,2072
+emerge/_emerge/elements/ned2_interp.py,sha256=TwZr6f7USERIHrSShhEWofq_mMwFV5xHqSIRLLiUz48,32650
+emerge/_emerge/elements/nedelec2.py,sha256=9cPAkxUdEFIn2HrSVPuChm7fxEjW3QAqyM0o3z9wCCw,6467
+emerge/_emerge/elements/nedleg2.py,sha256=6pPrBMEwQqhPwIa2LTHYfqyOrLQI19O4XAoAfmTvYAE,8884
+emerge/_emerge/geo/__init__.py,sha256=ZLwXMj81H-5ti2CmWJHriECe8PRDKNwXKvTbawtsWQA,1151
+emerge/_emerge/geo/horn.py,sha256=otrtPphO2zoRaSOb7NV-iRaydL1uWDAl2xJ6-8Sef24,4148
+emerge/_emerge/geo/modeler.py,sha256=_PMz3lFSa7FmJHWdY-4U1Sqbed-Egy85S_AdjlCldC4,15572
+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=2B_is3pzsZydWu2yC7XSJZ0T00HNQeQ8Q71EGaOIrNI,21140
+emerge/_emerge/geo/shapes.py,sha256=-ct-TJh69oj5fqJcQql4pNk3acJWTIQzYOQeAFXDfWk,23319
 emerge/_emerge/geo/step.py,sha256=XcAiEN8W4umNmZdYmrGHX_aJUuiMgc6vgT-UIk8Gbqc,2689
-emerge/_emerge/geo/pcb_tools/calculator.py,sha256=eGYUXdXmHUJCPlfJyY96S87wjeAVFG-e4sPOwbYj0eA,832
+emerge/_emerge/geo/pcb_tools/calculator.py,sha256=VbMP2xC9i7OFwtqnnwfYgyJSEcJIjr2VIy_Ez1hYqlU,859
 emerge/_emerge/geo/pcb_tools/macro.py,sha256=0g-0anOFyxrEkFobiSu0cwWFRQ32xB8Az24mmwo0z6M,2992
 emerge/_emerge/mth/common_functions.py,sha256=oURfF-8p_0s1dKbUATc15dnKHFwvqWa6GC-JMW9UwnI,2061
 emerge/_emerge/mth/integrals.py,sha256=lL7KrHdyFGpboQyvf6W_4bZRZCrMbjd2e8GDHctL-B8,3572
@@ -50,16 +50,16 @@ 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=5P8yyr6e6hFHBS1JAFHq8gsU1CxFG1LTelKVggv7AjY,42007
-emerge/_emerge/physics/microwave/microwave_bc.py,sha256=-fxeZREL42snL4XvXuUqo4QJh24o8lHJ_IcWxkt5yAU,42484
-emerge/_emerge/physics/microwave/microwave_data.py,sha256=rIxHAaVFhKgedeEdEGqEd-2zXT0ZRUtL588NCA_d4XQ,46722
+emerge/_emerge/physics/microwave/microwave_3d.py,sha256=lKHaMcL8kztwUF4V9zUycT7Ec7aTZS9SAiZh6auzCYc,42379
+emerge/_emerge/physics/microwave/microwave_bc.py,sha256=5BJfxgQWmgUt_Kd0ofVW4YUgzZxXv2wb8gvcJmBfhCA,42443
+emerge/_emerge/physics/microwave/microwave_data.py,sha256=0SQInYEVdp7rlDIUt51Hb6lQNg2GYnt3zqmTbMArVIk,49302
 emerge/_emerge/physics/microwave/periodic.py,sha256=wYSUgLFVtCLqSG3EDKoCDRU93iPUzBdXzVRdHTRmbpI,3000
 emerge/_emerge/physics/microwave/port_functions.py,sha256=aVU__AkVk8b1kH2J_oDLF5iNReCxC9nzCtesFSSSSQo,2112
 emerge/_emerge/physics/microwave/sc.py,sha256=WZvoPhmHkfEv619RhmN09sXDBV0ryTqybwErA8Rc7lU,4735
 emerge/_emerge/physics/microwave/simjob.py,sha256=aCWCs7IXBfVBWWYhwyHvXSRHY3FOd3CK5ABcaFEsNnM,4927
 emerge/_emerge/physics/microwave/sparam.py,sha256=1SXGyr1UsrPnCIi4ffwobM4pzgkj50y4LrWCr_J5IRY,4946
 emerge/_emerge/physics/microwave/touchstone.py,sha256=pMcCOLWVqIKctcShcJxyaV-0rhRWXMSS1Jz14dVQEyY,5799
-emerge/_emerge/physics/microwave/assembly/assembler.py,sha256=lTQ2hELZCG5bC4ybhkAoDSi9zr6K4i2N7LuJ4npxd4o,21926
+emerge/_emerge/physics/microwave/assembly/assembler.py,sha256=kOOHQErjcb-OEafYGKphs5P8v5vllJGRxr6mdyR1oCY,22826
 emerge/_emerge/physics/microwave/assembly/curlcurl.py,sha256=iYHTNI48bmC6SjCiCMPoY4yqsf__e_h_vbW0fNKQpNQ,18686
 emerge/_emerge/physics/microwave/assembly/generalized_eigen.py,sha256=LOybnxdy1x6R6d0lPnfnKckZSiYRfWOW9MUFlV_ygfs,16945
 emerge/_emerge/physics/microwave/assembly/generalized_eigen_hb.py,sha256=XcWWoDVU7KlcjP8re3o-Kb63A3px4CJ-OPjCT57_J8E,17382
@@ -67,10 +67,10 @@ 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=q3IuoW4qrp5xv2S3vsVgATdE1QajWmA5_59Ma7I6GA0,24433
+emerge/_emerge/plot/simple_plots.py,sha256=oFJXSNI--HwydgOUt88NdRsxqldxfy5mb38eZTx9qHs,24430
 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=L7_cy7C6EnIIj_-V5E_-j5ORJtIXscvYCmBE03-eCK4,34692
+emerge/_emerge/plot/pyvista/display.py,sha256=5pi1LSHHVCutspQT2lcwWaF-eWoR_VE1OmkKtpizQhI,37321
 emerge/_emerge/plot/pyvista/display_settings.py,sha256=K2OhzKqeFzMXlEfZ5F4CQ9sN3l7nOgVjLplZBuMPjvE,899
 emerge/_emerge/projects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/projects/_gen_base.txt,sha256=DqQz36PZg6v1ovQjHvPjd0t4AIbmikZdb9dmrNYsK3w,598
@@ -78,8 +78,8 @@ emerge/_emerge/projects/_load_base.txt,sha256=94o0eSWoDKlNR336EmhpG_S5syQHIUPHQx
 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/pardiso_interface.py,sha256=iVFxToMmIzhj3hcAP-O_MDHKz82ePFIHY1us11kzUBU,15305
-emerge-0.6.6.dist-info/METADATA,sha256=d_K1k2mCNNqBkh6A5SX85lvlwYNR0mVP6e54QX-bX30,3304
-emerge-0.6.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emerge-0.6.6.dist-info/entry_points.txt,sha256=8rFvAXticpKg4OTC8JEvAksnduW72KIEskCGG9XnFf8,43
-emerge-0.6.6.dist-info/licenses/LICENSE,sha256=SuHm9Fw32RI6tylP2YCyTPITMwpueazVUZwUMFRE_zk,17856
-emerge-0.6.6.dist-info/RECORD,,
+emerge-0.6.8.dist-info/METADATA,sha256=Yi_WDwKLxyKakod3QDuaRgz7RvnxAAk0CJVuVnPii1M,3304
+emerge-0.6.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emerge-0.6.8.dist-info/entry_points.txt,sha256=8rFvAXticpKg4OTC8JEvAksnduW72KIEskCGG9XnFf8,43
+emerge-0.6.8.dist-info/licenses/LICENSE,sha256=VOCXWddrjMN5j7TvnSAOh1Dx7jkugdwq9Lqhycf5inc,17852
+emerge-0.6.8.dist-info/RECORD,,

{emerge-0.6.6.dist-info → emerge-0.6.8.dist-info}/licenses/LICENSE

@@ -1,5 +1,5 @@
 ──────────────────────────────────────────────────────────────────────────────
-PREAMBLE — Licence map and disclaimers (not part of the GNU GPL text)
+PREAMBLE - Licence map and disclaimers (not part of the GNU GPL text)
 ──────────────────────────────────────────────────────────────────────────────
 This repository is distributed under two distinct licences:
 
@@ -11,7 +11,7 @@ This repository is distributed under two distinct licences:
     When you distribute binaries containing these components, the complete
     corresponding source code must be offered under GPL-2.0+.
 
-  • **`lib.py` — materials-property database**  
+  • **`lib.py` - materials-property database**  
     This single file is dedicated to the public domain under **CC0 1.0**.
     You may copy, modify, merge, publish, distribute, sublicense and/or sell
     copies of `lib.py` without restriction.  The data it contains are