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

emerge/_emerge/physics/microwave/microwave_data.py

@@ -20,13 +20,14 @@ from ...simulation_data import BaseDataset, DataContainer
 from ...elements.femdata import FEMBasis
 from dataclasses import dataclass
 import numpy as np
-from typing import Literal, Any
+from typing import Literal
 from loguru import logger
 from .adaptive_freq import SparamModel
 from ...cs import Axis, _parse_axis
 from ...selection import FaceSelection
 from ...geometry import GeoSurface
 from ...mesh3d import Mesh3D
+from ...const import Z0, MU0, EPS0
 
 EMField = Literal[
     "er", "ur", "freq", "k0",
@@ -36,9 +37,6 @@ EMField = Literal[
     "mode", "beta",
 ]
 
-EPS0 = 8.854187818814e-12
-MU0 = 1.2566370612720e-6
-
 def arc_on_plane(ref_dir, normal, angle_range_deg, num_points=100):
     """
     Generate theta/phi coordinates of an arc on a plane.
@@ -128,7 +126,7 @@ def generate_ndim(
     outer_data: dict[str, list[float]],
     inner_data: list[float],
     outer_labels: tuple[str, ...]
-) -> np.ndarray:
+) -> tuple[np.ndarray,...]:
     """
     Generates an N-dimensional grid of values from flattened data, and returns each axis array plus the grid.
 
@@ -231,10 +229,10 @@ class Sparam:
 
 @dataclass
 class PortProperties:
-    port_number: int | None = None
+    port_number: int = -1
     k0: float | None= None
     beta: float | None = None
-    Z0: float | None = None
+    Z0: float | complex | None = None
     Pout: float | None = None
     mode_number: int = 1
 
@@ -259,7 +257,7 @@ class FarfieldData:
 
     def surfplot(self, 
              polarization: Literal['Ex','Ey','Ez','Etheta','Ephi','normE'], 
-             isotropic: bool = True, dB: bool = False, dBfloor: float = -30, rmax: float = None,
+             isotropic: bool = True, dB: bool = False, dBfloor: float = -30, rmax: float | None = None,
              offset: tuple[float, float, float] = (0,0,0)) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
         """Returns the parameters to be used as positional arguments for the display.add_surf() function.
 
@@ -297,7 +295,7 @@ class FarfieldData:
             logger.warning('Defaulting to normE')
             F = np.sqrt(np.abs(self.E[0,:])**2 + np.abs(self.E[1,:])**2 + np.abs(self.E[2,:])**2)
         if isotropic:
-            F = F/np.sqrt(376.730313412/(2*np.pi))
+            F = F/np.sqrt(Z0/(2*np.pi))
         if dB:
             F = 20*np.log10(np.clip(np.abs(F), a_min=10**(dBfloor/20), a_max = 1e9))-dBfloor
         if rmax is not None:
@@ -345,7 +343,7 @@ class EHField:
     
     @property
     def Dy(self) -> np.ndarray:
-        return self.Et*self.er
+        return self.Ey*self.er
     
     @property
     def Dz(self) -> np.ndarray:
@@ -499,16 +497,16 @@ class EHField:
         Returns:
             (X,Y,Z,Field): The coordinates plus field scalar
         """
-        field = getattr(self, field)
+        field_arry = getattr(self, field)
         if metric=='abs':
-            field = np.abs(field)
+            field = np.abs(field_arry)
         elif metric=='real':
-            field = field.real
+            field = field_arry.real
         elif metric=='imag':
-            field = field.imag
+            field = field_arry.imag
         elif metric=='complex':
-            field = field
-        return self.x, self.y, self.z, field
+            field = field_arry
+        return self.x, self.y, self.z, field_arry
 
 class _EHSign:
     """A small class to manage the sign of field components when computing the far-field with Stratton-Chu
@@ -588,7 +586,7 @@ class MWField:
                             mode_number: int,
                             k0: float,
                             beta: float,
-                            Z0: float,
+                            Z0: float | complex | None,
                             Pout: float) -> None:
         self.port_modes.append(PortProperties(port_number=port_number,
                                               mode_number=mode_number,
@@ -609,7 +607,7 @@ class MWField:
     def _field(self) -> np.ndarray:
         if self._mode_field is not None:
             return self._mode_field
-        return sum([self.excitation[mode.port_number]*self._fields[mode.port_number] for mode in self.port_modes]) 
+        return sum([self.excitation[mode.port_number]*self._fields[mode.port_number] for mode in self.port_modes]) # type: ignore
     
     def set_field_vector(self) -> None:
         """Defines the default excitation coefficients for the current dataset"""
@@ -662,7 +660,7 @@ class MWField:
         self.Ez = Ez.reshape(shp)
 
         
-        constants = 1/ (-1j*2*np.pi*self.freq*(self._dur*4*np.pi*1e-7) )
+        constants = 1/ (-1j*2*np.pi*self.freq*(self._dur*MU0) )
         Hx, Hy, Hz = self.basis.interpolate_curl(self._field, xf, yf, zf, constants)
         ids = self.basis.interpolate_index(xf, yf, zf)
         self.er = self._der[ids].reshape(shp)
@@ -678,9 +676,9 @@ class MWField:
 
     def cutplane(self, 
                      ds: float,
-                     x: float=None,
-                     y: float=None,
-                     z: float=None) -> EHField:
+                     x: float | None = None,
+                     y: float | None = None,
+                     z: float | None = None) -> EHField:
         xb, yb, zb = self.basis.bounds
         xs = np.linspace(xb[0], xb[1], int((xb[1]-xb[0])/ds))
         ys = np.linspace(yb[0], yb[1], int((yb[1]-yb[0])/ds))
@@ -765,8 +763,8 @@ class MWField:
                          faces: FaceSelection | GeoSurface,
                          ang_range: tuple[float, float] = (-180, 180),
                          Npoints: int = 201,
-                         origin: tuple[float, float, float] = None,
-                         syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+                         origin: tuple[float, float, float] | None = None,
+                         syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """Compute the farfield electric and magnetic field defined by a circle.
 
         Args:
@@ -782,18 +780,18 @@ class MWField:
             tuple[np.ndarray, np.ndarray, np.ndarray]: _description_
         """
         refdir = _parse_axis(ref_direction).np
-        plane_normal = _parse_axis(plane_normal).np
-        theta, phi = arc_on_plane(refdir, plane_normal, ang_range, Npoints)
+        plane_normal_parsed = _parse_axis(plane_normal).np
+        theta, phi = arc_on_plane(refdir, plane_normal_parsed, ang_range, Npoints)
         E,H = self.farfield(theta, phi, faces, origin, syms = syms)
         angs = np.linspace(*ang_range, Npoints)*np.pi/180
         return angs, E ,H
 
     def farfield_3d(self, 
                     faces: FaceSelection | GeoSurface,
-                    thetas: np.ndarray = None,
-                    phis: np.ndarray = None,
-                    origin: tuple[float, float, float] = None,
-                    syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] = None) -> FarfieldData:
+                    thetas: np.ndarray | None = None,
+                    phis: np.ndarray | None = None,
+                    origin: tuple[float, float, float] | None = None,
+                    syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> FarfieldData:
         """Compute the farfield in a 3D angular grid
 
         If thetas and phis are not provided, they default to a sample space of 2 degrees.
@@ -823,8 +821,8 @@ class MWField:
     def farfield(self, theta: np.ndarray,
                  phi: np.ndarray,
                  faces: FaceSelection | GeoSurface,
-                 origin: tuple[float, float, float] = None,
-                 syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] = None) -> tuple[np.ndarray, np.ndarray]:
+                 origin: tuple[float, float, float] | None = None,
+                 syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> tuple[np.ndarray, np.ndarray]:
         """Compute the farfield at the provided theta/phi coordinates
 
         Args:
@@ -874,7 +872,7 @@ class MWField:
         
         return Eff, Hff
 
-    def optycal(self, faces: FaceSelection | GeoSurface = None) -> tuple:
+    def optycal(self, faces: FaceSelection | GeoSurface | None = None) -> tuple:
         """Export this models exterior to an Optical acceptable dataset
 
         Args:
@@ -953,7 +951,7 @@ class MWScalar:
                             mode_number: int,
                             k0: float,
                             beta: float,
-                            Z0: float,
+                            Z0: float | complex,
                             Pout: float) -> None:
         i = self._portmap[port_number]
         self.beta[i] = beta
@@ -1026,9 +1024,9 @@ class MWScalarNdim:
 
     def export_touchstone(self, 
                             filename: str,
-                            Z0ref: float = None,
+                            Z0ref: float | None = None,
                             format: Literal['RI','MA','DB'] = 'RI',
-                            custom_comments: list[str] = None,
+                            custom_comments: list[str] | None = None,
                             funit: Literal['HZ','KHZ','MHZ','GHZ'] = 'GHZ'):
         """Export the S-parameter data to a touchstone file
 
@@ -1063,9 +1061,9 @@ class MWScalarNdim:
                         filename: str,
                         Smatrix: np.ndarray,
                         frequencies: np.ndarray, 
-                        Z0ref: float = None,
+                        Z0ref: float | None = None,
                         format: Literal['RI','MA','DB'] = 'RI',
-                        custom_comments: list[str] = None,
+                        custom_comments: list[str] | None = None,
                         funit: Literal['HZ','KHZ','MHZ','GHZ'] = 'GHZ') -> None:
         """Save an S-parameter matrix to a touchstone file.
         

emerge/_emerge/physics/microwave/sc.py

@@ -19,19 +19,21 @@ from numba_progress import ProgressBar
 from ...mesh3d import SurfaceMesh
 import numpy as np
 from loguru import logger
-from numba import c8, c16, f8, i8, njit, prange, typeof, f4
-from numba.types import Tuple as TupleType
+from numba import c16, njit, prange, f8
+from numba.types import Tuple as TupleType  # ty: ignore
 from numba_progress.progress import ProgressBarType
+from ...const import Z0
 
 LR = 0.001
+
 @njit(
-    TupleType((c8[:, :], c8[:, :]))(
-        c8[:, :],
-        c8[:, :],
-        f4[:, :],
-        f4[:, :],
-        f4[:, :],
-        f4,
+    TupleType((c16[:, :], c16[:, :]))(
+        c16[:, :],
+        c16[:, :],
+        f8[:, :],
+        f8[:, :],
+        f8[:, :],
+        f8,
         ProgressBarType,
     ),
     parallel=True,
@@ -86,17 +88,15 @@ def stratton_chu_ff(Ein, Hin, vis, wns, tpout, k0, pgb):
 
     N = tpout.shape[1]
 
-    Eout = np.zeros((3, N)).astype(np.complex64)
-    Hout = np.zeros((3, N)).astype(np.complex64)
-
-    Eoutx = np.zeros((N,)).astype(np.complex64)
-    Eouty = np.zeros((N,)).astype(np.complex64)
-    Eoutz = np.zeros((N,)).astype(np.complex64)
+    Eout = np.zeros((3, N)).astype(np.complex128)
+    Hout = np.zeros((3, N)).astype(np.complex128)
 
-    Z0 = np.float32(376.73031366857)
+    Eoutx = np.zeros((N,)).astype(np.complex128)
+    Eouty = np.zeros((N,)).astype(np.complex128)
+    Eoutz = np.zeros((N,)).astype(np.complex128)
 
-    Q = np.complex64(-1j * k0 / (4 * np.pi))
-    ii = np.complex64(1j)
+    Q = np.complex128(-1j * k0 / (4 * np.pi))
+    ii = np.complex128(1j)
 
     NxHx = ny * Hz - nz * Hy
     NxHy = nz * Hx - nx * Hz
@@ -106,7 +106,7 @@ def stratton_chu_ff(Ein, Hin, vis, wns, tpout, k0, pgb):
     NxEy = nz * Ex - nx * Ez
     NxEz = nx * Ey - ny * Ex
 
-    for j in prange(Nids):
+    for j in prange(Nids): # ty: ignore
         xi = vx[j]
         yi = vy[j]
         zi = vz[j]
@@ -147,7 +147,7 @@ def stratton_chu(Ein, Hin, mesh: SurfaceMesh, theta: np.ndarray, phi: np.ndarray
     areas = mesh.areas
     vis = mesh.edge_centers
 
-    wns = np.zeros_like(vis).astype(np.float32)
+    wns = np.zeros_like(vis).astype(np.float64)
 
     tri_normals = mesh.normals
     tri_ids = mesh.tri_to_edge
@@ -164,12 +164,12 @@ def stratton_chu(Ein, Hin, mesh: SurfaceMesh, theta: np.ndarray, phi: np.ndarray
     tpout = np.array([theta, phi])
     with ProgressBar(total=Ntot, ncols=100, dynamic_ncols=False) as pgb:
         Eout, Hout = stratton_chu_ff(
-            Ein.astype(np.complex64),
-            Hin.astype(np.complex64),
-            vis.astype(np.float32),
-            wns.astype(np.float32),
-            tpout.astype(np.float32),
-            np.float32(k0),
+            Ein.astype(np.complex128),
+            Hin.astype(np.complex128),
+            vis.astype(np.float64),
+            wns.astype(np.float64),
+            tpout.astype(np.float64),
+            np.float64(k0),
             pgb,
         )
     return Eout.astype(np.complex128), Hout.astype(np.complex128)

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
+                 B: csr_matrix | None = 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()
@@ -88,15 +88,20 @@ class SimJob:
 
             b_active = self.b + mode
             A = self.load_if_needed('A')
-            
+
+            aux = {
+                'Active port': str(key),
+            }
 
             if self.has_periodic:
                 P = self.load_if_needed('P')
                 Pd = self.load_if_needed('Pd')
                 b_active = Pd @ b_active
                 A = Pd @ A @ P
+                aux['Periodic reduction'] = str(P.shape)
 
-            yield A, b_active, self.solve_ids, reuse_factorization
+            
+            yield A, b_active, self.solve_ids, reuse_factorization, aux
 
             reuse_factorization = True
         

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.