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

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
         

emerge/_emerge/selection.py

@@ -536,7 +536,7 @@ class Selector:
                 nx: float,
                 ny: float,
                 nz: float,
-                tolerance: float = 1e-6) -> FaceSelection:
+                tolerance: float = 1e-8) -> FaceSelection:
         """Returns a FaceSelection for all faces that lie in a provided infinite plane
         specified by an origin plus a plane normal vector.
 

emerge/_emerge/simmodel.py

@@ -51,11 +51,9 @@ Known problems/solutions:
 --------------------------
 """
 
-
 class SimulationError(Exception):
     pass
 
-
 ############################################################
 #                 BASE 3D SIMULATION MODEL                 #
 ############################################################
@@ -93,7 +91,6 @@ class Simulation3D:
         
         self.mesh: Mesh3D = Mesh3D(self.mesher)
         self.select: Selector = Selector()
-        self.set_loglevel(loglevel)
 
         ## STATES
         self.__active: bool = False
@@ -102,9 +99,6 @@ class Simulation3D:
 
         self.display: PVDisplay = PVDisplay(self.mesh)
 
-        if logfile:
-            self.set_logfile()
-
         self.save_file: bool = save_file
         self.load_file: bool = load_file
 
@@ -115,6 +109,10 @@ class Simulation3D:
 
         self._initialize_simulation()
 
+        self.set_loglevel(loglevel)
+        if logfile:
+            self.set_logfile()
+
         self._update_data()
     
 
@@ -286,6 +284,8 @@ class Simulation3D:
             loglevel ('DEBUG','INFO','WARNING','ERROR'): The loglevel
         """
         LOG_CONTROLLER.set_std_loglevel(loglevel)
+        if loglevel not in ('TRACE','DEBUG'):
+            gmsh.option.setNumber("General.Terminal", 0)
 
     def set_logfile(self) -> None:
         """Adds a file output for the logger."""
@@ -318,7 +318,6 @@ class Simulation3D:
 
         return None
         
-    
     def set_periodic_cell(self, cell: PeriodicCell, excluded_faces: list[FaceSelection] | None = None):
         """Set the given periodic cell object as the simulations peridicity.
 
@@ -332,7 +331,7 @@ class Simulation3D:
     def commit_geometry(self, *geometries: GeoObject | list[GeoObject]) -> None:
         """Finalizes and locks the current geometry state of the simulation.
 
-        The geometries may be provided (legacy behavior) but are automatically managed underwater.
+        The geometries may be provided (legacy behavior) but are automatically managed in the background.
         
         """
         geometries_parsed: Any = None
@@ -375,12 +374,16 @@ class Simulation3D:
         self.mesher.set_mesh_size(self.mw.get_discretizer(), self.mw.resolution)
         
         try:
+            gmsh.logger.start()
             gmsh.model.mesh.generate(3)
+            logs = gmsh.logger.get()
+            gmsh.logger.stop()
+            for log in logs:
+                logger.trace('[GMSH] '+log)
         except Exception:
             logger.error('GMSH Mesh error detected.')
             print(_GMSH_ERROR_TEXT)
             raise
-        
         self.mesh.update(self.mesher._get_periodic_bcs())
         self.mesh.exterior_face_tags = self.mesher.domain_boundary_face_tags
         gmsh.model.occ.synchronize()

emerge/_emerge/simulation_data.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 import numpy as np
 from loguru import logger
-from typing import TypeVar, Generic, Any, List, Union, Dict
+from typing import TypeVar, Generic, Any, List, Union, Dict, Generator
 from collections import defaultdict
 
 T = TypeVar("T")
@@ -187,6 +187,10 @@ class DataContainer:
         self.entries.append(entry)
         return entry
     
+    def iterate(self) -> Generator[tuple[dict[str, float], dict[str, Any]], None, None]:
+        for entry in self.entries:
+            yield entry.vars, entry.data
+
     @property
     def last(self) -> DataEntry:
         """Returns the last added entry"""