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

emerge/_emerge/physics/microwave/assembly/curlcurl.py

@@ -22,16 +22,12 @@ from numba_progress import ProgressBar, ProgressBarType
 from ....mth.optimized import local_mapping, matinv, dot_c, cross_c, compute_distances
 from numba import c16, types, f8, i8, njit, prange
 
-
 ############################################################
 #                  CACHED FACTORIAL VALUES                 #
 ############################################################
 
-
 _FACTORIALS = np.array([1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880], dtype=np.int64)
 
-
-
 ############################################################
 #                  INDEX MAPPING FUNCTIONS                 #
 ############################################################
@@ -264,7 +260,6 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
             Dmat[ei+0,ej+10] = Q*VAD
             Dmat[ei+10,ej+0] = Q*VBC
             Dmat[ei+10,ej+10] = Q*VBD
-
             
             Fmat[ei+0,ej+0] = Q2*(VABCD*BD1-VABCC*BE1-VAACD*BF1+VAACC*BG1)
             Fmat[ei+0,ej+10] = Q2*(VABDD*BD1-VABCD*BE1-VAADD*BF1+VAACD*BG1)
@@ -313,7 +308,6 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
             BH1 = dot_c(GB,BC1)
             BI1 = dot_c(GA,BD1)
             BJ1 = dot_c(GB,BD1)
-
             
             Dmat[ei+0,ej+6] = L1*Lac2*(-6*VAD*AI1-3*VAC*AJ1-3*VAF*AK1)
             Dmat[ei+0,ej+16] = L1*Lab2*(6*VAF*AK1+3*VAD*AI1-3*VAC*AJ1)
@@ -372,7 +366,6 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
             VBCEF = VOLUME_COEFF_CACHE[B,E,F,C]
             VADEF = VOLUME_COEFF_CACHE[E,A,D,F]
 
-            
             Lac2 = Ds[ej1, fj]
             Lab2 = Ds[ej1, ej2]
 
@@ -447,7 +440,7 @@ def _matrix_builder(nodes, tets, tris, edges, all_edge_lengths, tet_to_field, te
     dataB = np.empty_like(rows, dtype=np.complex128)
 
     
-    for itet in prange(nT):
+    for itet in prange(nT): # ty: ignore
         p = itet*400
         if np.mod(itet,10)==0:
             pgb.update(10)

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -24,21 +24,22 @@ from ...elements.nedelec2 import Nedelec2
 from ...solver import DEFAULT_ROUTINE, SolveRoutine
 from ...system import called_from_main_function
 from ...selection import FaceSelection
-from scipy.sparse.linalg import inv as sparse_inverse # type: ignore
 from .microwave_bc import MWBoundaryConditionSet, PEC, ModalPort, LumpedPort, PortBC
 from .microwave_data import MWData
 from .assembly.assembler import Assembler
 from .port_functions import compute_avg_power_flux
 from .simjob import SimJob
+
 from concurrent.futures import ThreadPoolExecutor
-import numpy as np
 from loguru import logger
 from typing import Callable, Literal
-import time
-import threading
 import multiprocessing as mp
 from cmath import sqrt as csqrt
 
+import numpy as np
+import threading
+import time
+
 class SimulationError(Exception):
     pass
 
@@ -51,9 +52,10 @@ def run_job_multi(job: SimJob) -> SimJob:
     Returns:
         SimJob: The solved SimJob
     """
-    routine = DEFAULT_ROUTINE.duplicate().configure('MP')
-    for A, b, ids, reuse in job.iter_Ab():
+    routine = DEFAULT_ROUTINE.duplicate()._configure_routine('MP')
+    for A, b, ids, reuse, aux in job.iter_Ab():
         solution, report = routine.solve(A, b, ids, reuse, id=job.id)
+        report.add(**aux)
         job.submit_solution(solution, report)
     return job
 
@@ -117,7 +119,6 @@ class Microwave3D:
         self.bc: MWBoundaryConditionSet = MWBoundaryConditionSet(None)
         self.basis: Nedelec2 | None = None
         self.solveroutine: SolveRoutine = DEFAULT_ROUTINE
-        self.set_order(order)
         self.cache_matrices: bool = True
 
         ## States
@@ -129,6 +130,8 @@ class Microwave3D:
         self._simstart: float = 0.0
         self._simend: float = 0.0
 
+        self.set_order(order)
+
     def reset_data(self):
         self.data = MWData()
 
@@ -352,7 +355,7 @@ class Microwave3D:
             raise ValueError('The field basis is not yet defined.')
 
         logger.debug('Finding PEC TEM conductors')
-        pecs: list[PEC] = self.bc.oftype(PEC) # type: ignore
+        pecs: list[PEC] = self.bc.get_conductors() # type: ignore
         mesh = self.mesh
 
         # Process all PEC Boundary Conditions
@@ -472,13 +475,10 @@ class Microwave3D:
         if freq is None:
             freq = self.frequencies[0]
         
-    
         k0 = 2*np.pi*freq/299792458
         kmax = k0*np.sqrt(ermax.real*urmax.real)
-
-        logger.info('Assembling BMA Matrices')
         
-        Amatrix, Bmatrix, solve_ids, nlf = self.assembler.assemble_bma_matrices(self.basis, er, ur, cond, k0, port, self.bc.boundary_conditions)
+        Amatrix, Bmatrix, solve_ids, nlf = self.assembler.assemble_bma_matrices(self.basis, er, ur, cond, k0, port, self.bc)
         
         logger.debug(f'Total of {Amatrix.shape[0]} Degrees of freedom.')
         logger.debug(f'Applied frequency: {freq/1e9:.2f}GHz')
@@ -515,7 +515,7 @@ class Microwave3D:
             Emode = Emode * np.exp(-1j*np.angle(np.max(Emode)))
 
             beta = min(k0*np.sqrt(ermax*urmax), np.emath.sqrt(-eigen_values[i]))
-            #beta = np.emath.sqrt(eigen_values[i])
+
             residuals = -1
 
             portfE = nlf.interpolate_Ef(Emode)
@@ -628,19 +628,21 @@ class Microwave3D:
         ## DEFINE SOLVE FUNCTIONS
         def get_routine():
             if not hasattr(thread_local, "routine"):
-                thread_local.routine = self.solveroutine.duplicate().configure('MT')
+                thread_local.routine = self.solveroutine.duplicate()._configure_routine('MT')
             return thread_local.routine
 
         def run_job(job: SimJob):
             routine = get_routine()
-            for A, b, ids, reuse in job.iter_Ab():
+            for A, b, ids, reuse, aux in job.iter_Ab():
                 solution, report = routine.solve(A, b, ids, reuse, id=job.id)
+                report.add(**aux)
                 job.submit_solution(solution, report)
             return job
         
         def run_job_single(job: SimJob):
-            for A, b, ids, reuse in job.iter_Ab():
+            for A, b, ids, reuse, aux in job.iter_Ab():
                 solution, report = self.solveroutine.solve(A, b, ids, reuse, id=job.id)
+                report.add(**aux)
                 job.submit_solution(solution, report)
             return job
         
@@ -753,6 +755,15 @@ class Microwave3D:
         thread_local.__dict__.clear()
         logger.info('Solving complete')
 
+        for freq, job in zip(self.frequencies, results):
+            self.data.setreport(job.reports, freq=freq, **self._params)
+
+        for variables, data in self.data.sim.iterate():
+            logger.trace(f'Sim variable: {variables}')
+            for item in data['report']:
+                item.pretty_print(logger.trace)
+
+        self.solveroutine.reset()
         ### Compute S-parameters and return
         self._post_process(results, er, ur, cond)
         return self.data
@@ -883,8 +894,6 @@ class Microwave3D:
             fielddata._der = np.squeeze(er[0,0,:])
             fielddata._dur = np.squeeze(ur[0,0,:])
 
-            self.data.setreport(job.reports, freq=freq, **self._params)
-
             logger.info(f'Post Processing simulation frequency = {freq/1e9:.3f} GHz') 
 
             # Recording port information
@@ -915,20 +924,18 @@ class Microwave3D:
                 Pout = 0.0 + 0j
 
                 # Active port power
-                logger.debug('Active ports:')
                 tris = mesh.get_triangles(active_port.tags)
                 tri_vertices = mesh.tris[:,tris]
                 pfield, pmode = self._compute_s_data(active_port, fieldf, tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
-                logger.debug(f'    Field Amplitude = {np.abs(pfield):.3f}, Excitation = {np.abs(pmode):.2f}')
+                logger.debug(f'[{active_port.port_number}] Active port amplitude = {np.abs(pfield):.3f} (Excitation = {np.abs(pmode):.2f})')
                 Pout = pmode
                 
                 #Passive ports
-                logger.debug('Passive ports:')
                 for bc in all_ports:
                     tris = mesh.get_triangles(bc.tags)
                     tri_vertices = mesh.tris[:,tris]
                     pfield, pmode = self._compute_s_data(bc, fieldf,tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
-                    logger.debug(f'    Field amplitude = {np.abs(pfield):.3f}, Excitation= {np.abs(pmode):.2f}')
+                    logger.debug(f'[{bc.port_number}] Passive amplitude = {np.abs(pfield):.3f}')
                     scalardata.write_S(bc.port_number, active_port.port_number, pfield/Pout)
                 active_port.active=False
             
@@ -988,8 +995,8 @@ class Microwave3D:
             elif bc.modetype(k0) == 'TM':
                 const = 1/((erp[0,0,:] + erp[1,1,:] + erp[2,2,:])/3)
             const = np.squeeze(const)
-            field_p = sparam_field_power(self.mesh.nodes, tri_vertices, bc, k0, fieldfunction, const)
-            mode_p = sparam_mode_power(self.mesh.nodes, tri_vertices, bc, k0, const)
+            field_p = sparam_field_power(self.mesh.nodes, tri_vertices, bc, k0, fieldfunction, const, 5)
+            mode_p = sparam_mode_power(self.mesh.nodes, tri_vertices, bc, k0, const, 5)
             return field_p, mode_p
 
     # def frequency_domain_single(self, automatic_modal_analysis: bool = False) -> MWData:
@@ -1099,7 +1106,7 @@ class Microwave3D:
     #             tris = mesh.get_triangles(active_port.tags)
     #             tri_vertices = mesh.tris[:,tris]
     #             pfield, pmode = self._compute_s_data(active_port, fieldf, tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
-    #             logger.debug(f'    Field Amplitude = {np.abs(pfield):.3f}, Excitation = {np.abs(pmode):.2f}')
+    #             logger.debug(f'Field Amplitude = {np.abs(pfield):.3f}, Excitation = {np.abs(pmode):.2f}')
     #             Pout = pmode
                 
     #             #Passive ports
@@ -1108,7 +1115,7 @@ class Microwave3D:
     #                 tris = mesh.get_triangles(bc.tags)
     #                 tri_vertices = mesh.tris[:,tris]
     #                 pfield, pmode = self._compute_s_data(bc, fieldf, tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
-    #                 logger.debug(f'    Field amplitude = {np.abs(pfield):.3f}, Excitation= {np.abs(pmode):.2f}')
+    #                 logger.debug(f'Field amplitude = {np.abs(pfield):.3f}, Excitation= {np.abs(pmode):.2f}')
     #                 scalardata.write_S(bc.port_number, active_port.port_number, pfield/Pout)
 
     #             active_port.active=False

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -27,6 +27,8 @@ from dataclasses import dataclass
 from collections import defaultdict
 from ...bc import BoundaryCondition, BoundaryConditionSet, Periodic
 from ...periodic import PeriodicCell, HexCell, RectCell
+from ...material import Material
+from ...const import Z0, C0, PI, EPS0, MU0
 
 class MWBoundaryConditionSet(BoundaryConditionSet):
 
@@ -39,13 +41,28 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         self.ModalPort: type[ModalPort] = self._construct_bc(ModalPort)
         self.LumpedPort: type[LumpedPort] = self._construct_bc(LumpedPort)
         self.LumpedElement: type[LumpedElement] = self._construct_bc(LumpedElement)
+        self.SurfaceImpedance: type[SurfaceImpedance] = self._construct_bc(SurfaceImpedance)
         self.RectangularWaveguide: type[RectangularWaveguide] = self._construct_bc(RectangularWaveguide)
         self.Periodic: type[Periodic] = self._construct_bc(Periodic)
         self.FloquetPort: type[FloquetPort] = self._construct_bc(FloquetPort)
 
         self._cell: PeriodicCell | None = None
 
-    def get_type(self, bctype: Literal['PEC','ModalPort','LumpedPort','PMC','LumpedElement','RectangularWaveguide','Periodic','FloquetPort']) -> FaceSelection:
+    def get_conductors(self) -> list[BoundaryCondition]:
+        """Returns a list of all boundary conditions that ought to be considered as a "conductor" 
+        for the purpose of modal analyses.
+
+        Returns:
+            list[BoundaryCondition]: All conductor like boundary conditions
+        """
+        bcs = self.oftype(PEC)
+        for bc in self.oftype(SurfaceImpedance):
+            if bc.material.cond > 1e3:
+                bcs.append(bc)
+
+        return bcs
+
+    def get_type(self, bctype: Literal['PEC','ModalPort','LumpedPort','PMC','LumpedElement','RectangularWaveguide','Periodic','FloquetPort','SurfaceImpedance']) -> FaceSelection:
         tags = []
         for bc in self.boundary_conditions:
             if bctype in str(bc.__class__):
@@ -119,7 +136,7 @@ class RobinBC(BoundaryCondition):
         raise NotImplementedError('get_Uinc not implemented for Port class')
 
 class PortBC(RobinBC):
-    Zvac: float = 376.730313412
+    Zvac: float = Z0
     def __init__(self, face: FaceSelection | GeoSurface):
         """(DO NOT USE) A generalization of the Port boundary condition.
         
@@ -165,9 +182,9 @@ class PortBC(RobinBC):
         if self.modetype(k0)=='TEM':
             return self.Zvac
         elif self.modetype(k0)=='TE':
-            return k0*299792458/self.get_beta(k0) * 4*np.pi*1e-7
+            return k0*299792458/self.get_beta(k0) * MU0
         elif self.modetype(k0)=='TM':
-            return self.get_beta(k0)/(k0*299792458*8.854187818814*1e-12)
+            return self.get_beta(k0)/(k0*299792458*EPS0)
         else:
             raise ValueError(f'Port mode type should be TEM, TE or TM but instead is {self.modetype(k0)}')
     
@@ -183,7 +200,7 @@ class PortBC(RobinBC):
         Returns:
             float: The mode amplitude correction factor.
         """
-        return np.sqrt(self.Zmode(k0)/376.73031341259)
+        return np.sqrt(self.Zmode(k0)/Z0)
     
     @property
     def mode_number(self) -> int:
@@ -300,7 +317,7 @@ class PortMode:
     
     def set_power(self, power: complex) -> None:
         self.norm_factor = np.sqrt(1/np.abs(power))
-        logger.info(f'Setting port mode amplitude to: {self.norm_factor} ')
+        logger.info(f'Setting port mode amplitude to: {self.norm_factor:.2f} ')
 
 class FloquetPort(PortBC):
     _include_stiff: bool = True
@@ -334,7 +351,7 @@ class FloquetPort(PortBC):
             self.cs = GCS
 
     def portZ0(self, k0: float | None = None) -> complex | float | None:
-        return 376.73031341259
+        return Z0
 
     def get_amplitude(self, k0: float) -> float:
         return 1.0
@@ -372,7 +389,7 @@ class FloquetPort(PortBC):
         P = self.pol_p
         S = self.pol_s
 
-        E0 = self.get_amplitude(k0)*np.sqrt(2*376.73031341259/(self.area))
+        E0 = self.get_amplitude(k0)*np.sqrt(2*Z0/(self.area))
         Ex = E0*(-S*np.sin(self.scan_phi) - P*np.cos(self.scan_theta)*np.cos(self.scan_phi))*phi
         Ey = E0*(S*np.cos(self.scan_phi) - P*np.cos(self.scan_theta)*np.sin(self.scan_phi))*phi
         Ez = E0*(-P*E0*np.sin(self.scan_theta))*phi
@@ -646,13 +663,13 @@ class RectangularWaveguide(PortBC):
         return self.cs._basis_inv
     
     def portZ0(self, k0: float) -> complex:
-        return k0*299792458 * 4*np.pi*1e-7/self.get_beta(k0)
+        return k0*299792458 * MU0/self.get_beta(k0)
 
     def modetype(self, k0):
         return self.type
     
     def get_amplitude(self, k0: float) -> float:
-        Zte = 376.73031341259
+        Zte = Z0
         amplitude= np.sqrt(self.power*4*Zte/(self.dims[0]*self.dims[1]))
         return amplitude
 
@@ -807,10 +824,10 @@ class LumpedPort(PortBC):
         Returns:
             complex: The γ-constant
         """
-        return 1j*k0*376.730313412/self.surfZ
+        return 1j*k0*Z0/self.surfZ
     
     def get_Uinc(self, x_local, y_local, k0) -> np.ndarray:
-        Emag = -1j*2*k0 * self.voltage/self.height * (376.730313412/self.surfZ)
+        Emag = -1j*2*k0 * self.voltage/self.height * (Z0/self.surfZ)
         return Emag*self.port_mode_3d(x_local, y_local, k0)
     
     def port_mode_3d(self, 
@@ -899,16 +916,9 @@ class LumpedElement(RobinBC):
         self.Z0: Callable = impedance_function # type: ignore
         self.width: float = width # type: ignore
         self.height: float = height # type: ignore
-        
-        logger.info('Constructing coordinate system from normal port')
-        self.cs = Axis(self.selection.normal).construct_cs() # type: ignore
-
-        self.vintline: Line | None = None
-        self.v_integration = True
-        self.iintline: Line | None = None
 
     def surfZ(self, k0: float) -> float:
-        """The surface sheet impedance for the lumped port
+        """The surface sheet impedance for the lumped Element
 
         Returns:
             float: The surface sheet impedance
@@ -916,18 +926,17 @@ class LumpedElement(RobinBC):
         Z0 = self.Z0(k0*299792458/(2*np.pi))*self.width/self.height
         return Z0
     
-    
-    def get_basis(self) -> np.ndarray:
-        return self.cs._basis
+    def get_basis(self) -> np.ndarray | None:
+        return None
 
-    def get_inv_basis(self) -> np.ndarray:
-        return self.cs._basis_inv
+    def get_inv_basis(self) -> np.ndarray | None:
+        return None
     
     def get_beta(self, k0: float) -> float:
         ''' Return the out of plane propagation constant. βz.'''
 
         return k0
-    
+
     def get_gamma(self, k0: float) -> complex:
         """Computes the γ-constant for matrix assembly. This constant is required for the Robin boundary condition.
 
@@ -937,6 +946,67 @@ class LumpedElement(RobinBC):
         Returns:
             complex: The γ-constant
         """
-        return 1j*k0*376.730313412/self.surfZ(k0)
+        return 1j*k0*Z0/self.surfZ(k0)
+    
 
 
+class SurfaceImpedance(RobinBC):
+    
+    _include_stiff: bool = True
+    _include_mass: bool = False
+    _include_force: bool = False
+
+    def __init__(self, 
+                 face: FaceSelection | GeoSurface,
+                 material: Material | None = None,
+                 ):
+        """Generates a lumped power boundary condition.
+        
+        The lumped port boundary condition assumes a uniform E-field along the "direction" axis.
+        The port with and height must be provided manually in meters. The height is the size
+        in the "direction" axis along which the potential is imposed. The width dimension
+        is orthogonal to that. For a rectangular face its the width and for a cyllindrical face
+        its the circumpherance.
+
+        Args:
+            face (FaceSelection, GeoSurface): The port surface
+            port_number (int): The port number
+            width (float): The port width (meters).
+            height (float): The port height (meters).
+            direction (Axis): The port direction as an Axis object (em.Axis(..) or em.ZAX)
+            active (bool, optional): Whether the port is active. Defaults to False.
+            power (float, optional): The port output power. Defaults to 1.
+            Z0 (float, optional): The port impedance. Defaults to 50.
+        """
+        super().__init__(face)
+
+        self.material: Material = material 
+    
+    
+    def get_basis(self) -> np.ndarray | None:
+        return None
+
+    def get_inv_basis(self) -> np.ndarray | None:
+        return None
+    
+    def get_beta(self, k0: float) -> float:
+        ''' Return the out of plane propagation constant. βz.'''
+
+        return k0
+
+    def get_gamma(self, k0: float) -> complex:
+        """Computes the γ-constant for matrix assembly. This constant is required for the Robin boundary condition.
+
+        Args:
+            k0 (float): The free space propagation constant.
+
+        Returns:
+            complex: The γ-constant
+        """
+        w0 = k0*C0
+        sigma = self.material.cond
+        rho = 1/sigma
+        d_skin = (2*rho/(w0*MU0) * ((1+(w0*EPS0*rho)**2)**0.5 + rho*w0*EPS0))**0.5
+        d_skin = (2*rho/(w0*MU0))**0.5
+        R = rho/d_skin
+        return 1j*k0*Z0/R

emerge/_emerge/physics/microwave/microwave_data.py

@@ -27,6 +27,7 @@ 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.
@@ -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:
@@ -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)

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

@@ -27,7 +27,7 @@ class SimJob:
                  b: np.ndarray | None,
                  freq: float,
                  cache_factorization: bool,
-                 B: csr_matrix = None
+                 B: csr_matrix | None = None
                  ):
 
         self.A: csr_matrix = A
@@ -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