emerge 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

emerge/_emerge/physics/microwave/simjob.py

@@ -17,39 +17,39 @@
 
 import numpy as np
 import os
-from scipy.sparse import csr_matrix, save_npz, load_npz
+from scipy.sparse import csr_matrix, save_npz, load_npz # type: ignore
 from ...solver import SolveReport
 
 class SimJob:
 
     def __init__(self, 
                  A: csr_matrix,
-                 b: np.ndarray,
+                 b: np.ndarray | None,
                  freq: float,
                  cache_factorization: bool,
                  B: csr_matrix = None
                  ):
 
         self.A: csr_matrix = A
-        self.B: csr_matrix = B
-        self.b: np.ndarray = b
-        self.P: csr_matrix = None
-        self.Pd: csr_matrix = None
+        self.B: csr_matrix | None = B
+        self.b: np.ndarray | None = b
+        self.P: csr_matrix | None= None
+        self.Pd: csr_matrix | None = None
         self.has_periodic: bool = False
 
         self.freq: float = freq
         self.k0: float = 2*np.pi*freq/299792458
         self.cache_factorization: bool = cache_factorization
         self._fields: dict[int, np.ndarray] = dict()
-        self.port_vectors: dict = None
-        self.solve_ids = None
+        self.port_vectors: dict | None = None
+        self.solve_ids: np.ndarray | None = None
 
-        self.store_limit = None
-        self.relative_path = None
-        self._store_location = {}
+        self.store_limit: int | None = None
+        self.relative_path: str | None  = None
+        self._store_location: dict = {}
         self._stored: bool = False
 
-        self._active_port: int = None
+        self._active_port: int = -1
         self.reports: list[SolveReport] = []
         self.id: int = -1
         self.store_if_needed()

emerge/_emerge/physics/microwave/sparam.py

@@ -15,14 +15,14 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-from .microwave_bc import RobinBC
+from .microwave_bc import PortBC
 from ...mth.integrals import surface_integral
 import numpy as np
 from typing import Callable
 
 def sparam_waveport(nodes: np.ndarray,
                     tri_vertices: np.ndarray,
-                    bc: RobinBC, 
+                    bc: PortBC, 
                     freq: float,
                     fieldf: Callable,
                     ndpts: int = 4):
@@ -62,18 +62,18 @@ def sparam_waveport(nodes: np.ndarray,
         Ex2, Ey2, Ez2 = modef_c(x,y,z)
         return Ex1*Ex2 + Ey1*Ey2 + Ez1*Ez2
     
-    mode_dot_field = surface_integral(nodes, tri_vertices, inproduct1, ndpts=ndpts)
-    norm = surface_integral(nodes, tri_vertices, inproduct2, ndpts=ndpts)
+    mode_dot_field = surface_integral(nodes, tri_vertices, inproduct1, gq_order=ndpts)
+    norm = surface_integral(nodes, tri_vertices, inproduct2, gq_order=ndpts)
     
     svec = mode_dot_field/norm
     return svec
 
 def sparam_mode_power(nodes: np.ndarray,
                     tri_vertices: np.ndarray,
-                    bc: RobinBC, 
+                    bc: PortBC, 
                     k0: float,
                     const: np.ndarray,
-                    ndpts: int = 4):
+                    gq_order: int = 4):
     ''' Compute the S-parameters assuming a wave port mode
     
     Arguments:
@@ -83,7 +83,7 @@ def sparam_mode_power(nodes: np.ndarray,
     bc: RobinBC = The port boundary condition object
     freq: float = The frequency at which to do the calculation
     fielf: Callable = The interpolation fuction that computes the E-field from the simulation
-    ndpts: int = 4 the number of Duvanant integration points to use (default = 4)
+    gq_order: int = 4 the Gauss-Quadrature order (default = 4)
     '''
 
     def modef(x, y, z):
@@ -94,17 +94,17 @@ def sparam_mode_power(nodes: np.ndarray,
         Ex2, Ey2, Ez2 = np.conj(modef(x,y,z))
         return (Ex1*Ex2 + Ey1*Ey2 + Ez1*Ez2)/(2*bc.Zmode(k0))
     
-    norm = surface_integral(nodes, tri_vertices, inproduct2, const, gq_order=ndpts)
+    norm = surface_integral(nodes, tri_vertices, inproduct2, const, gq_order=gq_order)
     
     return norm
 
 def sparam_field_power(nodes: np.ndarray,
                     tri_vertices: np.ndarray,
-                    bc: RobinBC, 
+                    bc: PortBC, 
                     k0: float,
                     fieldf: Callable,
                     const: np.ndarray,
-                    ndpts: int = 4):
+                    gq_order: int = 4) -> complex:
     ''' Compute the S-parameters assuming a wave port mode
     
     Arguments:
@@ -114,7 +114,7 @@ def sparam_field_power(nodes: np.ndarray,
     bc: RobinBC = The port boundary condition object
     freq: float = The frequency at which to do the calculation
     fielf: Callable = The interpolation fuction that computes the E-field from the simulation
-    ndpts: int = 4 the number of Duvanant integration points to use (default = 4)
+    gq_order: int = 4 the Gauss-Quadrature order (default = 4)
     '''
     
     def modef(x, y, z):
@@ -132,7 +132,7 @@ def sparam_field_power(nodes: np.ndarray,
         Ex2, Ey2, Ez2 = np.conj(modef(x,y,z))
         return (Ex1*Ex2 + Ey1*Ey2 + Ez1*Ez2) / (2*bc.Zmode(k0))
     
-    mode_dot_field = surface_integral(nodes, tri_vertices, inproduct1, const, gq_order=ndpts)
+    mode_dot_field = surface_integral(nodes, tri_vertices, inproduct1, const, gq_order=gq_order)
     
     svec = mode_dot_field
     return svec

emerge/_emerge/physics/microwave/touchstone.py

@@ -31,7 +31,7 @@ def generate_touchstone(filename: str,
                         freq: np.ndarray,
                         Smat: np.ndarray,
                         data_format: Literal['RI','MA','DB'],
-                        custom_comments: list[str] = None,
+                        custom_comments: list[str] | None = None,
                         funit: Literal['HZ','KHZ','MHZ','GHZ'] = 'GHZ') -> None:
     """
     Export S-parameter data to a Touchstone file

emerge/_emerge/plot/display.py

@@ -18,7 +18,7 @@ class BaseDisplay:
     def show(self):
         raise NotImplementedError('This method is not implemented')
         
-    def add_object(self, obj: GeoObject | Selection | Iterable,*args, **kwargs):
+    def add_object(self, obj: GeoObject | Selection,*args, **kwargs):
         """ Adds an object to the display
 
         Keyword arguments
@@ -352,14 +352,20 @@ class BaseDisplay:
     def add_scatter(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray):
         raise NotImplementedError('This method is not implemented')
 
-    def add_portmode(self, port: PortBC, k0: float, Npoints: int = 10, dv=(0,0,0), XYZ=None,
-                      field: Literal['E','H'] = 'E'):
+    def add_portmode(self, port: PortBC, 
+                     Npoints: int = 10, 
+                     dv=(0,0,0), 
+                     XYZ=None,
+                     field: Literal['E','H'] = 'E', 
+                     k0: float | None = None,
+                     mode_number: int | None = None):
         raise NotImplementedError('This method is not implemented')
 
     def add_quiver(self, x: np.ndarray, y: np.ndarray, z: np.ndarray,
               dx: np.ndarray, dy: np.ndarray, dz: np.ndarray,
               scale: float = 1,
-              scalemode: Literal['lin','log'] = 'lin'):
+              color: tuple[float, float, float] | None = None,
+              scalemode: Literal['lin','log'] = 'lin') -> None:
         
         raise NotImplementedError('This method is not implemented')
     
@@ -370,10 +376,10 @@ class BaseDisplay:
                  field: np.ndarray,
                  scale: Literal['lin','log','symlog'] = 'lin',
                  cmap: cmap_names = 'coolwarm',
-                 clim: tuple[float, float] = None,
+                 clim: tuple[float, float] | None = None,
                  opacity: float = 1.0,
                  symmetrize: bool = True,
-                 animate: bool = False,
+                 _fieldname: str | None = None,
                  **kwargs,):
         """Add a surface plot to the display
         The X,Y,Z coordinates must be a 2D grid of data points. The field must be a real field with the same size.

emerge/_emerge/plot/pyvista/display.py

@@ -22,7 +22,7 @@ from ...selection import FaceSelection, DomainSelection, EdgeSelection, Selectio
 from ...physics.microwave.microwave_bc import PortBC, ModalPort
 import numpy as np
 import pyvista as pv
-from typing import Iterable, Literal, Callable
+from typing import Iterable, Literal, Callable, Any
 from ..display import BaseDisplay
 from .display_settings import PVDisplaySettings
 from matplotlib.colors import ListedColormap
@@ -155,7 +155,7 @@ def _select(obj: GeoObject | Selection) -> Selection:
         return obj.select
     return obj
 
-def _merge(lst: list[GeoObject | Selection]) -> Selection:
+def _merge(lst: Iterable[GeoObject | Selection]) -> Selection:
     selections = [_select(item) for item in lst]
     dim = selections[0].dim
     all_tags = []
@@ -168,6 +168,8 @@ def _merge(lst: list[GeoObject | Selection]) -> Selection:
         return FaceSelection(all_tags)
     elif dim==3:
         return DomainSelection(all_tags)
+    else:
+        return Selection(all_tags)
 
 class _AnimObject:
     """ A private class containing the required information for plot items in a view
@@ -199,7 +201,7 @@ class PVDisplay(BaseDisplay):
         self._stop: bool = False
         self._objs: list[_AnimObject] = []
         self._do_animate: bool = False
-        self._Nsteps: int = None
+        self._Nsteps: int  = 0
         self._fps: int = 25
         self._ruler: ScreenRuler = ScreenRuler(self, 0.001)
         self._selector: ScreenSelector = ScreenSelector(self)
@@ -208,10 +210,11 @@ class PVDisplay(BaseDisplay):
 
         self._plot = pv.Plotter()
 
-        self._plot.add_key_event("m", self.activate_ruler)
-        self._plot.add_key_event("f", self.activate_object)
+        self._plot.add_key_event("m", self.activate_ruler) # type: ignore
+        self._plot.add_key_event("f", self.activate_object) # type: ignore
 
         self._ctr: int = 0
+
     def activate_ruler(self):
         self._plot.disable_picking()
         self._selector.turn_off()
@@ -310,7 +313,7 @@ class PVDisplay(BaseDisplay):
         points = self._mesh.nodes.T
         return pv.UnstructuredGrid(cells, celltypes, points)
     
-    def mesh(self, obj: GeoObject | Selection | Iterable) -> pv.UnstructuredGrid:
+    def mesh(self, obj: GeoObject | Selection | Iterable) -> pv.UnstructuredGrid | None:
         if isinstance(obj, Iterable):
             obj = _merge(obj)
         else:
@@ -320,11 +323,13 @@ class PVDisplay(BaseDisplay):
             return self.mesh_volume(obj)
         elif isinstance(obj, FaceSelection):
             return self.mesh_surface(obj)
+        else:
+            return None
 
     ## OBLIGATORY METHODS
-    def add_object(self, obj: GeoObject | Selection | Iterable, *args, **kwargs):
-        kwargs = setdefault(kwargs, color=obj.color_rgb, opacity=obj.opacity, silhouette=True)
-        self._plot.add_mesh(self.mesh(obj), pickable=True, *args, **kwargs)
+    def add_object(self, obj: GeoObject | Selection, *args, **kwargs):
+        kwargs = setdefault(kwargs, color=obj.color_rgb, opacity=obj.opacity, silhouette=True, pickable=True)
+        self._plot.add_mesh(self.mesh(obj), *args, **kwargs)
 
     def add_scatter(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray):
         """Adds a scatter point cloud
@@ -342,8 +347,8 @@ class PVDisplay(BaseDisplay):
                      dv=(0,0,0), 
                      XYZ=None,
                      field: Literal['E','H'] = 'E', 
-                     k0: float = None,
-                     mode_number: int = None) -> pv.UnstructuredGrid:
+                     k0: float | None = None,
+                     mode_number: int | None = None) -> None:
         
         if XYZ:
             X,Y,Z = XYZ
@@ -408,10 +413,10 @@ class PVDisplay(BaseDisplay):
                  field: np.ndarray,
                  scale: Literal['lin','log','symlog'] = 'lin',
                  cmap: cmap_names = 'coolwarm',
-                 clim: tuple[float, float] = None,
+                 clim: tuple[float, float] | None = None,
                  opacity: float = 1.0,
                  symmetrize: bool = True,
-                 _fieldname: str = None,
+                 _fieldname: str | None = None,
                  **kwargs,):
         """Add a surface plot to the display
         The X,Y,Z coordinates must be a 2D grid of data points. The field must be a real field with the same size.
@@ -460,11 +465,11 @@ class PVDisplay(BaseDisplay):
         kwargs = setdefault(kwargs, cmap=cmap, clim=clim, opacity=opacity, pickable=False, multi_colors=True)
         actor = self._plot.add_mesh(grid, scalars=name, **kwargs)
 
-        if self._animate:
+        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))
+            self._objs.append(_AnimObject(field_flat, T, grid, actor, on_update)) # type: ignore
         
         
     def add_title(self, title: str) -> None:
@@ -481,14 +486,14 @@ class PVDisplay(BaseDisplay):
     def add_text(self, text: str, 
                  color: str = 'black', 
                  position: Literal['lower_left', 'lower_right', 'upper_left', 'upper_right', 'lower_edge', 'upper_edge', 'right_edge', 'left_edge']='upper_right',
-                 abs_position: tuple[float, float, float] = None):
+                 abs_position: tuple[float, float, float] | None = None):
         viewport = False
         if abs_position is not None:
-            position = abs_position
+            final_position = abs_position
             viewport = True
         self._plot.add_text(
             text,
-            position=position,
+            position=final_position,
             color=color,
             font_size=18,
             viewport=viewport)
@@ -496,7 +501,7 @@ class PVDisplay(BaseDisplay):
     def add_quiver(self, x: np.ndarray, y: np.ndarray, z: np.ndarray,
               dx: np.ndarray, dy: np.ndarray, dz: np.ndarray,
               scale: float = 1,
-              color: tuple[float, float, float] = None,
+              color: tuple[float, float, float] | None = None,
               scalemode: Literal['lin','log'] = 'lin'):
         """Add a quiver plot to the display
 
@@ -562,18 +567,18 @@ class PVDisplay(BaseDisplay):
         grid = pv.StructuredGrid(X,Y,Z)
         field = V.flatten(order='F')
         grid['anim'] = np.real(field)
-        levels = np.linspace(vmin, vmax, Nlevels)
+        levels = list(np.linspace(vmin, vmax, Nlevels))
         contour = grid.contour(isosurfaces=levels)
         actor = self._plot.add_mesh(contour, opacity=0.25, cmap=cmap, pickable=False)
 
-        if self._animate:
+        if self._do_animate:
             def on_update(obj: _AnimObject, phi: complex):
                 new_vals = np.real(obj.field * phi)
                 obj.grid['anim'] = new_vals
                 new_contour = obj.grid.contour(isosurfaces=levels)
-                obj.actor.GetMapper().SetInputData(new_contour)
+                obj.actor.GetMapper().SetInputData(new_contour) # type: ignore
             
-            self._objs.append(_AnimObject(field, lambda x: x, grid, actor, on_update))
+            self._objs.append(_AnimObject(field, lambda x: x, grid, actor, on_update)) # type: ignore
 
     def _add_aux_items(self) -> None:
         saved_camera = {
@@ -591,8 +596,8 @@ class PVDisplay(BaseDisplay):
             plane = pv.Plane(
                 center=(0, 0, 0),
                 direction=(1, 0, 0),    # normal vector pointing along +X
-                i_size=length,
-                j_size=length,
+                i_size=length, # type: ignore
+                j_size=length, # type: ignore
                 i_resolution=1,
                 j_resolution=1
             )
@@ -617,8 +622,8 @@ class PVDisplay(BaseDisplay):
             plane = pv.Plane(
                 center=(0, 0, 0),
                 direction=(0, 1, 0),    # normal vector pointing along +X
-                i_size=length,
-                j_size=length,
+                i_size=length, # type: ignore
+                j_size=length, # type: ignore
                 i_resolution=1,
                 j_resolution=1
             )
@@ -642,8 +647,8 @@ class PVDisplay(BaseDisplay):
             plane = pv.Plane(
                 center=(0, 0, 0),
                 direction=(0, 0, 1),    # normal vector pointing along +X
-                i_size=length,
-                j_size=length,
+                i_size=length, # type: ignore
+                j_size=length, # type: ignore
                 i_resolution=1,
                 j_resolution=1
             )
@@ -776,11 +781,11 @@ class PVDisplay(BaseDisplay):
 
         if self.set.add_light:
             light = pv.Light()
-            light.set_direction_angle(*self.set.light_angle)
+            light.set_direction_angle(*self.set.light_angle) # type: ignore
             self._plot.add_light(light)
 
-        self._plot.set_background(self.set.background_bottom, top=self.set.background_top)
-        self._plot.add_axes()
+        self._plot.set_background(self.set.background_bottom, top=self.set.background_top) # type: ignore
+        self._plot.add_axes() # type: ignore
 
         self._plot.camera.position = saved_camera["position"]
         self._plot.camera.focal_point = saved_camera["focal_point"]
@@ -837,7 +842,7 @@ class ScreenSelector:
                 celltypes = np.full(ntris, fill_value=pv.CellType.TRIANGLE, dtype=np.uint8)
                 points = self.disp._mesh.nodes.T
                 grid = pv.UnstructuredGrid(cells, celltypes, points)
-                grid._tag = key
+                grid._tag = key # type: ignore
                 self.grids.append(grid)
                 self.surfs[key] = points[nodes,:].T
         
@@ -856,14 +861,14 @@ class ScreenSelector:
             meany = np.mean(ys)
             meanz = np.mean(zs)
             data = (meanx, meany, meanz, min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
-            encoded = encode_data(data)
+            encoded = encode_data(data) #type: ignore
             print(f'Face code key={key}: ', encoded)
 
         self.disp._plot.enable_mesh_picking(callback, style='surface', left_clicking=True, use_actor=True)
     
     def turn_off(self) -> None:
         for actor in self.select_actors:
-            self.disp._plot.remove_actor(actor)
+            self.disp._plot.remove_actor(actor) # type: ignore
         self.select_actors = []
         for actor in self.original_actors:
             if isinstance(actor, pv.Text):
@@ -876,9 +881,9 @@ class ScreenRuler:
     def __init__(self, display: PVDisplay, min_length: float):
         self.disp: PVDisplay = display
         self.points: list[tuple] = [(0,0,0),(0,0,0)]
-        self.text: pv.Text = None
-        self.ruler = None
-        self.state = False
+        self.text: pv.Text | None = None
+        self.ruler: Any = None
+        self.state: bool = False
         self.min_length: float = min_length
     
     @freeze
@@ -916,7 +921,7 @@ class ScreenRuler:
     
     def set_ruler(self) -> None:
         if self.ruler is None:
-            self.ruler = self.disp._plot.add_ruler(self.points[0], self.points[1], title=f'{1000*self.dist:.2f}mm')
+            self.ruler = self.disp._plot.add_ruler(self.points[0], self.points[1], title=f'{1000*self.dist:.2f}mm') # type: ignore
         else:
             p1 = self.ruler.GetPositionCoordinate()
             p2 = self.ruler.GetPosition2Coordinate()

emerge/_emerge/plot/pyvista/display_settings.py

@@ -17,7 +17,7 @@ class PVDisplaySettings:
         self.show_zgrid: bool = True
         self.grid_line_width: float = 1.0
         self.add_light: bool = False
-        self.light_angle: float = (20, -20)
+        self.light_angle: tuple[float, float] = (20., -20.)
         self.cast_shadows: bool = True
         self.background_bottom: str = "#c0d2e8"
         self.background_top: str = "#ffffff"

emerge/_emerge/plot/simple_plots.py

@@ -36,7 +36,7 @@ ggplot_styles = {
 
 plt.rcParams.update(ggplot_styles)
 
-def _gen_grid(xs: tuple, ys: tuple, N = 201) -> list[np.ndarray]:
+def _gen_grid(xs: tuple, ys: tuple, N = 201) -> list[tuple[np.ndarray, np.ndarray]]:
     """Generate a grid of lines for the Smith Chart
 
     Args:
@@ -279,18 +279,18 @@ def smith(f: np.ndarray, S: np.ndarray) -> None:
 def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray, 
                       dblim=[-40, 5], 
                     xunit="GHz", 
-                    levelindicator: int | float =None, 
+                    levelindicator: int | float | None = None, 
                     noise_floor=-150, 
-                    fill_areas: list[tuple]= None, 
-                    spec_area: list[tuple[float]] = None,
+                    fill_areas: list[tuple] | None = None, 
+                    spec_area: list[tuple[float,...]] | None = None,
                     unwrap_phase=False, 
                     logx: bool = False,
-                    labels: list[str] = None,
-                    linestyles: list[str] = None,
-                    colorcycle: list[int] = None,
-                    filename: str = None,
+                    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:
+                    figdata: tuple | None = None) -> tuple[plt.Figure, plt.Axes, plt.Axes]:
     """Plot S-parameters in dB and phase
 
     Args:
@@ -321,7 +321,7 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
     if colorcycle is None:
         colorcycle = [i for i, S in enumerate(S)]
 
-    unitdivider = {"MHz": 1e6, "GHz": 1e9, "kHz": 1e3}
+    unitdivider: dict[str, float] = {"MHz": 1e6, "GHz": 1e9, "kHz": 1e3}
     fnew = f / unitdivider[xunit]
 
     if figdata is None:
@@ -372,14 +372,14 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
     # Configure magnitude plot (ax_mag)
     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])])
+    ax_mag.axis([min(fnew), max(fnew), 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])
+    ax_phase.axis([min(fnew), max(fnew), minphase, maxphase]) # type: ignore
     ax_phase.xaxis.set_minor_locator(tck.AutoMinorLocator(2))
     ax_phase.yaxis.set_minor_locator(tck.AutoMinorLocator(2))
     if logx:
@@ -532,9 +532,9 @@ def plot_ff_polar(
     markers = _broadcast(markers, None) if markers is not None else [None] * n_series
 
     fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
-    ax.set_theta_zero_location(zero_location)
-    ax.set_theta_direction(-1 if clockwise else 1)
-    ax.set_rlabel_position(rlabel_angle)
+    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
 
     for i, Ei in enumerate(E_list):
         mag = np.abs(Ei)