emerge 0.4.7__py3-none-any.whl → 0.4.8__py3-none-any.whl

emerge/_emerge/physics/microwave/periodic.py

@@ -0,0 +1,82 @@
+# from ...selection import FaceSelection, SELECTOR_OBJ
+# import numpy as np
+# from typing import Generator
+# from .microwave_bc import Periodic, FloquetPort
+# from ...geo.extrude import XYPolygon, GeoPrism
+# from ...geo import XYPlate, Alignment
+# from ...periodic import PeriodicCell
+
+# class MWPeriodicCell(PeriodicCell):
+
+#     def __post_init__(self):
+#         self._bcs: list[Periodic] = []
+#         self._ports: list[FloquetPort] = []
+
+#     def volume(self, z1: float, z2: float) -> GeoPrism:
+#         """Genereates a volume with the cell geometry ranging from z1 tot z2
+
+#         Args:
+#             z1 (float): The start height
+#             z2 (float): The end height
+
+#         Returns:
+#             GeoPrism: The resultant prism
+#         """
+#         raise NotImplementedError('This method is not implemented for this subclass.')
+    
+#     def floquet_port(self, z: float) -> FloquetPort:
+#         raise NotImplementedError('This method is not implemented for this subclass.')
+    
+#     def cell_data(self) -> Generator[tuple[FaceSelection,FaceSelection,tuple[float, float, float]], None, None]:
+#         """An iterator that yields the two faces of the hex cell plus a cell periodicity vector
+
+#         Yields:
+#             Generator[np.ndarray, np.ndarray, np.ndarray]: The face and periodicity data
+#         """
+#         raise NotImplementedError('This method is not implemented for this subclass.')
+
+#     @property
+#     def bcs(self) -> list[Periodic]:
+#         """Returns a list of Periodic boundary conditions for the given PeriodicCell
+
+#         Args:
+#             exclude_faces (list[FaceSelection], optional): A possible list of faces to exclude from the bcs. Defaults to None.
+
+#         Returns:
+#             list[Periodic]: The list of Periodic boundary conditions
+#         """
+#         if not self._bcs:
+#             bcs = []
+#             for f1, f2, a in self.cell_data():
+#                 if self.excluded_faces is not None:
+#                     f1 = f1 - self.excluded_faces
+#                     f2 = f2 - self.excluded_faces
+#                 bcs.append(Periodic(f1, f2, a))
+#             self._bcs = bcs
+#         return self._bcs
+    
+#     def set_scanangle(self, theta: float, phi: float, degree: bool = True) -> None:
+#         """Sets the scanangle for the periodic condition. (0,0) is defined along the Z-axis
+
+#         Args:
+#             theta (float): The theta angle
+#             phi (float): The phi angle
+#             degree (bool): If the angle is in degrees. Defaults to True
+#         """
+#         if degree:
+#             theta = theta*np.pi/180
+#             phi = phi*np.pi/180
+
+        
+#         ux = np.sin(theta)*np.cos(phi)
+#         uy = np.sin(theta)*np.sin(phi)
+#         uz = np.cos(theta)
+#         for bc in self._bcs:
+#             bc.ux = ux
+#             bc.uy = uy
+#             bc.uz = uz
+#         for port in self._ports:
+#             port.scan_theta = theta
+#             port.scan_phi = phi
+
+        

emerge/_emerge/physics/microwave/port_functions.py

@@ -0,0 +1,53 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see
+# <https://www.gnu.org/licenses/>.
+
+import numpy as np
+from ...elements.nedleg2 import NedelecLegrange2
+from ...mth.integrals import surface_integral
+
+
+def compute_avg_power_flux(field: NedelecLegrange2, mode: np.ndarray, k0: float, ur: np.ndarray, beta: float):
+
+    Efunc = field.interpolate_Ef(mode)
+    Hfunc = field.interpolate_Hf(mode, k0, ur, beta)
+    nx, ny, nz = field.mesh.normals[:,0]
+    def S(x,y,z):
+        Ex, Ey, Ez = Efunc(x,y,z)
+        Hx, Hy, Hz = Hfunc(x,y,z)
+        Sx = 1/2*np.real(Ey*np.conj(Hz) - Ez*np.conj(Hy))
+        Sy = 1/2*np.real(Ez*np.conj(Hx) - Ex*np.conj(Hz))
+        Sz = 1/2*np.real(Ex*np.conj(Hy) - Ey*np.conj(Hx))
+        return nx*Sx + ny*Sy + nz*Sz
+
+    Ptot = surface_integral(field.mesh.nodes, field.mesh.tris, S, None, 4)
+    return Ptot
+
+def compute_peak_power_flux(field: NedelecLegrange2, mode: np.ndarray, k0: float, ur: np.ndarray, beta: float):
+
+    Efunc = field.interpolate_Ef(mode)
+    Hfunc = field.interpolate_Hf(mode, k0, ur, beta)
+    nx, ny, nz = field.mesh.normals[:,0]
+    def S(x,y,z):
+        Ex, Ey, Ez = Efunc(x,y,z)
+        Hx, Hy, Hz = Hfunc(x,y,z)
+        Sx = np.real(Ey*np.conj(Hz) - Ez*np.conj(Hy))
+        Sy = np.real(Ez*np.conj(Hx) - Ex*np.conj(Hz))
+        Sz = np.real(Ex*np.conj(Hy) - Ey*np.conj(Hx))
+        return nx*Sx + ny*Sy + nz*Sz
+
+    Ptot = surface_integral(field.mesh.nodes, field.mesh.tris, S, None, 4)
+    return Ptot

emerge/_emerge/physics/microwave/sc.py

@@ -0,0 +1,175 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see
+# <https://www.gnu.org/licenses/>.
+
+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_progress.progress import ProgressBarType
+
+LR = 0.001
+@njit(
+    TupleType((c8[:, :], c8[:, :]))(
+        c8[:, :],
+        c8[:, :],
+        f4[:, :],
+        f4[:, :],
+        f4[:, :],
+        f4,
+        ProgressBarType,
+    ),
+    parallel=True,
+    fastmath=True,
+    cache=True,
+    nogil=True,
+)
+def stratton_chu_ff(Ein, Hin, vis, wns, tpout, k0, pgb):
+    
+    Ex = Ein[0, :].flatten()
+    Ey = Ein[1, :].flatten()
+    Ez = Ein[2, :].flatten()
+    Hx = Hin[0, :].flatten()
+    Hy = Hin[1, :].flatten()
+    Hz = Hin[2, :].flatten()
+    vx = vis[0, :].flatten()
+    vy = vis[1, :].flatten()
+    vz = vis[2, :].flatten()
+    nx = wns[0, :].flatten()
+    ny = wns[1, :].flatten()
+    nz = wns[2, :].flatten()
+    
+    Emag = np.sqrt(np.abs(Ex)**2 + np.abs(Ey)**2 + np.abs(Ez)**2)
+    
+    Elevel = np.max(Emag) * LR
+    ids = np.argwhere(Emag > Elevel)
+    Nids = ids.shape[0]
+    #iadd = NT // Nids
+    Ex = Ex[Emag > Elevel]
+    Ey = Ey[Emag > Elevel]
+    Ez = Ez[Emag > Elevel]
+    Hx = Hx[Emag > Elevel]
+    Hy = Hy[Emag > Elevel]
+    Hz = Hz[Emag > Elevel]
+    vx = vx[Emag > Elevel]
+    vy = vy[Emag > Elevel]
+    vz = vz[Emag > Elevel]
+    nx = nx[Emag > Elevel]
+    ny = ny[Emag > Elevel]
+    nz = nz[Emag > Elevel]
+
+    thout = tpout[0, :]
+    phout = tpout[1, :]
+
+    rx = np.sin(thout) * np.cos(phout)
+    ry = np.sin(thout) * np.sin(phout)
+    rz = np.cos(thout)
+
+    kx = k0 * rx
+    ky = k0 * ry
+    kz = k0 * rz
+
+    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)
+
+    Z0 = np.float32(376.73031366857)
+
+    Q = np.complex64(-1j * k0 / (4 * np.pi))
+    ii = np.complex64(1j)
+
+    NxHx = ny * Hz - nz * Hy
+    NxHy = nz * Hx - nx * Hz
+    NxHz = nx * Hy - ny * Hx
+
+    NxEx = ny * Ez - nz * Ey
+    NxEy = nz * Ex - nx * Ez
+    NxEz = nx * Ey - ny * Ex
+
+    for j in prange(Nids):
+        xi = vx[j]
+        yi = vy[j]
+        zi = vz[j]
+        G = np.exp(ii * (kx * xi + ky * yi + kz * zi))
+
+        RxNxHx = ry * NxHz[j] - rz * NxHy[j]
+        RxNxHy = rz * NxHx[j] - rx * NxHz[j]
+        RxNxHz = rx * NxHy[j] - ry * NxHx[j]
+
+        ie1x = (NxEx[j] - Z0 * RxNxHx) * G
+        ie1y = (NxEy[j] - Z0 * RxNxHy) * G
+        ie1z = (NxEz[j] - Z0 * RxNxHz) * G
+
+        Eoutx += Q * (ry * ie1z - rz * ie1y)
+        Eouty += Q * (rz * ie1x - rx * ie1z)
+        Eoutz += Q * (rx * ie1y - ry * ie1x)
+
+        # ii += iadd
+        pgb.update(1)
+    Eout[0, :] = Eoutx
+    Eout[1, :] = Eouty
+    Eout[2, :] = Eoutz
+
+    Hout[0, :] = (ry * Eoutz - rz * Eouty) / Z0
+    Hout[1, :] = (rz * Eoutx - rx * Eoutz) / Z0
+    Hout[2, :] = (rx * Eouty - ry * Eoutx) / Z0
+
+    return Eout, Hout
+
+def stratton_chu(Ein, Hin, mesh: SurfaceMesh, theta: np.ndarray, phi: np.ndarray, k0: float):
+
+    Ein = np.array(Ein)
+    Hin = np.array(Hin)
+
+    Emag = np.sqrt(np.abs(Ein[0,:])**2 + np.abs(Ein[1,:])**2 + np.abs(Ein[2,:])**2)
+    Ntot = np.argwhere(Emag>0.000001*np.max(Emag)).shape[0]
+    logger.debug(f'Percentage Included: {Ntot/Emag.shape[0]*100:.0f}%')
+    areas = mesh.areas
+    vis = mesh.edge_centers
+
+    wns = np.zeros_like(vis).astype(np.float32)
+
+    tri_normals = mesh.normals
+    tri_ids = mesh.tri_to_edge
+
+    for i in range(mesh.n_tris):
+        n = tri_normals[:,i]
+        i1, i2, i3 = tri_ids[:,i]
+        wns[:,i1] += n*areas[i]/3
+        wns[:,i2] += n*areas[i]/3
+        wns[:,i3] += n*areas[i]/3
+    
+    Eout = None
+    Hout = None
+    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),
+            pgb,
+        )
+    return Eout.astype(np.complex128), Hout.astype(np.complex128)

emerge/_emerge/physics/microwave/simjob.py

@@ -0,0 +1,147 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see
+# <https://www.gnu.org/licenses/>.
+
+import numpy as np
+import os
+from scipy.sparse import csr_matrix, save_npz, load_npz
+from ...solver import SolveReport
+
+class SimJob:
+
+    def __init__(self, 
+                 A: csr_matrix,
+                 b: np.ndarray,
+                 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.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.store_limit = None
+        self.relative_path = None
+        self._store_location = {}
+        self._stored: bool = False
+
+        self._active_port: int = None
+        self.reports: list[SolveReport] = []
+        self.id: int = -1
+        self.store_if_needed()
+
+    def maybe_store(self, matrix, name):
+        if self.store_limit is None:
+            return matrix
+        
+        if matrix is not None and matrix.nnz > self.store_limit:
+            # Create temp directory if needed
+            os.makedirs(self.relative_path, exist_ok=True)
+            path = os.path.join(self.relative_path, f"csr_{str(self.freq).replace('.','_')}_{name}.npz")
+            save_npz(path, matrix, compressed=False)
+            self._store_location[name] = path
+            self._stored = True
+            return None  # Unload from memory
+        return matrix
+    
+    def store_if_needed(self):
+        self.A = self.maybe_store(self.A, 'A')
+        if self.has_periodic:
+            self.P = self.maybe_store(self.P, 'P')
+            self.Pd = self.maybe_store(self.Pd, 'Pd')
+
+    def load_if_needed(self, name):
+        if name in self._store_location:
+            return load_npz(self._store_location[name])
+        return getattr(self, name)
+
+    def iter_Ab(self):
+        reuse_factorization = False
+
+        for key, mode in self.port_vectors.items():
+            # Set port as active and add the port mode to the forcing vector
+            self._active_port = key
+
+            b_active = self.b + mode
+            A = self.load_if_needed('A')
+            
+
+            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
+
+            yield A, b_active, self.solve_ids, reuse_factorization
+
+            reuse_factorization = True
+        
+        self.cleanup()
+
+    def yield_AC(self):
+        A = self.A
+        B = self.B
+        
+        if self.has_periodic:
+            P = self.P
+            Pd = self.Pd
+            A = Pd @ A @ P
+            B = Pd @ B @ P
+
+        return A, B, self.solve_ids
+        
+    def fix_solutions(self, solution: np.ndarray) -> np.ndarray:
+        if self.has_periodic:
+            solution = self.P @ solution
+        return solution
+    
+    def submit_solution(self, solution: np.ndarray, report: SolveReport):
+        # Solve the Ax=b problem
+
+        if self.has_periodic:
+            solution = self.P @ solution
+        # From now reuse the factorization
+
+        self._fields[self._active_port] = solution
+        self.reports.append(report)
+        self.routine = None
+    
+    def cleanup(self):
+        if not self._stored:
+            return
+        
+        if not os.path.isdir(self.relative_path):
+            return
+
+        # Remove only the files we saved
+        for path in self._store_location.values():
+            if os.path.isfile(path):
+                os.remove(path)
+
+        # If the directory is now empty, remove it
+        if not os.listdir(self.relative_path):
+            os.rmdir(self.relative_path)

emerge/_emerge/physics/microwave/sparam.py

@@ -0,0 +1,138 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see
+# <https://www.gnu.org/licenses/>.
+
+from .microwave_bc import RobinBC
+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, 
+                    freq: float,
+                    fieldf: Callable,
+                    ndpts: int = 4):
+    ''' Compute the S-parameters assuming a wave port mode
+    
+    Arguments:
+    ----------
+    nodes: np.ndarray = (3,:) np.ndarray of all nodes in the mesh.
+    tri_vertices: np.ndarray = (3,:) np.ndarray of triangle indices that need to be integrated,
+    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)
+    '''
+    
+    def modef(x, y, z):
+        return bc.port_mode_3d_global(x, y, z, freq)
+
+    def modef_c(x, y, z):
+        return np.conj(modef(x, y, z))
+    
+    Q = 0
+    if bc.active:
+        Q = 1
+
+    def fieldf_p(x, y, z):
+        return fieldf(x,y,z) - Q * modef(x,y,z)
+    
+    
+    def inproduct1(x, y, z):
+        Ex1, Ey1, Ez1 = fieldf_p(x,y,z)
+        Ex2, Ey2, Ez2 = modef_c(x,y,z)
+        return Ex1*Ex2 + Ey1*Ey2 + Ez1*Ez2
+    
+    def inproduct2(x, y, z):
+        Ex1, Ey1, Ez1 = modef(x,y,z)
+        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)
+    
+    svec = mode_dot_field/norm
+    return svec
+
+def sparam_mode_power(nodes: np.ndarray,
+                    tri_vertices: np.ndarray,
+                    bc: RobinBC, 
+                    k0: float,
+                    const: np.ndarray,
+                    ndpts: int = 4):
+    ''' Compute the S-parameters assuming a wave port mode
+    
+    Arguments:
+    ----------
+    nodes: np.ndarray = (3,:) np.ndarray of all nodes in the mesh.
+    tri_vertices: np.ndarray = (3,:) np.ndarray of triangle indices that need to be integrated,
+    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)
+    '''
+
+    def modef(x, y, z):
+        return bc.port_mode_3d_global(x, y, z, k0)
+    
+    def inproduct2(x, y, z):
+        Ex1, Ey1, Ez1 = modef(x,y,z)
+        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, ndpts=ndpts)
+    
+    return norm
+
+def sparam_field_power(nodes: np.ndarray,
+                    tri_vertices: np.ndarray,
+                    bc: RobinBC, 
+                    k0: float,
+                    fieldf: Callable,
+                    const: np.ndarray,
+                    ndpts: int = 4):
+    ''' Compute the S-parameters assuming a wave port mode
+    
+    Arguments:
+    ----------
+    nodes: np.ndarray = (3,:) np.ndarray of all nodes in the mesh.
+    tri_vertices: np.ndarray = (3,:) np.ndarray of triangle indices that need to be integrated,
+    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)
+    '''
+    
+    def modef(x, y, z):
+        return bc.port_mode_3d_global(x, y, z, k0)
+    
+    Q = 0
+    if bc.active:
+        Q = 1
+
+    def fieldf_p(x, y, z):
+        return fieldf(x,y,z) - Q * modef(x,y,z)
+    
+    def inproduct1(x, y, z):
+        Ex1, Ey1, Ez1 = fieldf_p(x,y,z)
+        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, ndpts=ndpts)
+    
+    svec = mode_dot_field
+    return svec