emerge 1.0.7__py3-none-any.whl → 1.1.0__py3-none-any.whl

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -29,6 +29,7 @@ from ...bc import BoundaryCondition, BoundaryConditionSet, Periodic
 from ...periodic import PeriodicCell, HexCell, RectCell
 from ...material import Material
 from ...const import Z0, C0, EPS0, MU0
+from ...logsettings import DEBUG_COLLECTOR
 
 ############################################################
 #                     UTILITY FUNCTIONS                    #
@@ -59,6 +60,7 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         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.UserDefinedPort: type[UserDefinedPort] = self._construct_bc(UserDefinedPort)
 
         self._cell: PeriodicCell | None = None
 
@@ -341,7 +343,6 @@ class PortMode:
     norm_factor: float = 1
     freq: float = 0
     neff: float = 1
-    TEM: bool = True
     Z0: float = 50.0
     polarity: float = 1.0
     modetype: Literal['TEM','TE','TM'] = 'TEM'
@@ -459,7 +460,7 @@ class ModalPort(PortBC):
                  port_number: int, 
                  cs: CoordinateSystem | None = None,
                  power: float = 1,
-                 TEM: bool = False,
+                 modetype: Literal['TE','TM','TEM'] | None = None,
                  mixed_materials: bool = False):
         """Generes a ModalPort boundary condition for a port that requires eigenmode solutions for the mode.
 
@@ -476,7 +477,7 @@ class ModalPort(PortBC):
             port_number (int): The port number as an integer
             cs (CoordinateSystem, optional): The local coordinate system of the port face. Defaults to None.
             power (float, optional): The radiated power. Defaults to 1.
-            TEM (bool, optional): Wether the mode should be considered as a TEM mode. Defaults to False
+            modetype (str[TE, TM, TEM], optional): Wether the mode should be considered as a TEM mode. Defaults to False
             mixed_materials (bool, optional): Wether the port consists of multiple different dielectrics. This requires
                 A recalculation of the port mode at every frequency
         """
@@ -490,7 +491,7 @@ class ModalPort(PortBC):
         self.selected_mode: int = 0
         self.modes: dict[float, list[PortMode]] = defaultdict(list)
 
-        self.TEM: bool = TEM
+        self.forced_modetype: Literal['TE','TM','TEM'] | None = modetype
         self.mixed_materials: bool = mixed_materials
         self.initialized: bool = False
         self._first_k0: float | None = None
@@ -506,7 +507,25 @@ class ModalPort(PortBC):
             raise ValueError('No Coordinate System could be derived.')
         self._er: np.ndarray | None = None
         self._ur: np.ndarray | None = None
+        
+        self.vintline: list[Line] = []
+
+    def set_integration_line(self, c1: tuple[float, float, float], c2: tuple[float, float, float], N: int = 21) -> None:
+        """Define the integration line start and end point
+
+        Args:
+            c1 (tuple[float, float, float]): The start coordinate
+            c2 (tuple[float, float, float]): The end coordinate
+            N (int, optional): The number of integration points. Defaults to 21.
+        """
+        self.vintline.append(Line.from_points(c1, c2, N))
     
+    def reset(self) -> None:
+        self.modes: dict[float, list[PortMode]] = defaultdict(list)
+        self.initialized: bool = False
+        self.plus_terminal: list[tuple[int, int]] = []
+        self.minus_terminal: list[tuple[int, int]] = []
+        
     def portZ0(self, k0: float) -> complex | float | None:
         return self.get_mode(k0).Z0
     
@@ -524,6 +543,11 @@ class ModalPort(PortBC):
         """ 
         self.alignment_vectors = [_parse_axis(ax) for ax in axes]
     
+    def _get_alignment_vector(self, index: int) -> np.ndarray | None:
+        if len(self.alignment_vectors) > index:
+            return self.alignment_vectors[index].np
+        return None
+    
     def set_terminals(self, positive: Selection | GeoObject | None = None,
                       negative: Selection | GeoObject | None = None,
                       ground: Selection | GeoObject | None = None) -> None:
@@ -616,7 +640,7 @@ class ModalPort(PortBC):
                  beta: float,
                  k0: float,
                  residual: float,
-                 TEM: bool,
+                 number: int,
                  freq: float) -> PortMode | None:
         """Add a mode function to the ModalPort
 
@@ -627,16 +651,17 @@ class ModalPort(PortBC):
             beta (float): The out-of-plane propagation constant 
             k0 (float): The free space phase constant
             residual (float): The solution residual
-            TEM (bool): Whether its a TEM mode
             freq (float): The frequency of the port mode
 
         Returns:
             PortMode: The port mode object.
         """
-        mode = PortMode(field, E_function, H_function, k0, beta, residual, TEM=TEM, freq=freq)
+        mode = PortMode(field, E_function, H_function, k0, beta, residual, freq=freq)
+        
         if mode.energy < 1e-4:
             logger.debug(f'Ignoring mode due to a low mode energy: {mode.energy}')
             return None
+        
         self.modes[k0].append(mode)
         self.initialized = True
 
@@ -659,7 +684,7 @@ class ModalPort(PortBC):
     
     def get_beta(self, k0: float) -> float:
         mode = self.get_mode(k0)
-        if mode.TEM:
+        if self.forced_modetype=='TEM':
             beta = mode.beta/mode.k0 * k0
         else:
             freq = k0*299792458/(2*np.pi)
@@ -816,6 +841,125 @@ class RectangularWaveguide(PortBC):
         Exg, Eyg, Ezg = self.cs.in_global_basis(Ex, Ey, Ez)
         return np.array([Exg, Eyg, Ezg])
 
+def _f_zero(k0,x,y,z):
+    "Zero field function"
+    return np.zeros_like(x, dtype=np.complex128)
+
+class UserDefinedPort(PortBC):
+    
+    _include_stiff: bool = True
+    _include_mass: bool = False
+    _include_force: bool = True
+
+    def __init__(self, 
+                 face: FaceSelection | GeoSurface,
+                 port_number: int, 
+                 Ex: Callable | None = None,
+                 Ey: Callable | None = None,
+                 Ez: Callable | None = None,
+                 kz: Callable | None = None,
+                 power: float = 1.0,
+                 modetype: Literal['TEM','TE','TM'] = 'TEM',
+                 cs: CoordinateSystem | None = None):
+        """Creates a user defined port field
+        
+        The UserDefinedPort is defined based on user defined field callables. All undefined callables will default to 0 field or k0.
+        
+        All spatial field functions should be defined using the template:
+        >>> def Ec(k0: float, x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray
+        >>>     return #shape like x
+        
+        Args:
+            face (FaceSelection, GeoSurface): The port boundary face selection
+            port_number (int): The port number
+            Ex (Callable): The Ex(k0,x,y,z) field
+            Ey (Callable): The Ey(k0,x,y,z) field
+            Ez (Callable): The Ez(k0,x,y,z) field
+            kz (Callable): The out of plane propagation constant kz(k0)
+            power (float): The port output power
+        """
+        super().__init__(face)
+        if cs is None:
+            cs = GCS
+
+        self.cs = cs
+        self.port_number: int= port_number
+        self.active: bool = False
+        self.power: float = power
+        self.type: str = 'TE'
+        if Ex is None:
+            Ex = _f_zero
+        if Ey is None:
+            Ey = _f_zero
+        if Ez is None:
+            Ez = _f_zero
+        if kz is None:
+            kz = lambda k0: k0
+
+        self._fex: Callable = Ex
+        self._fey: Callable = Ey
+        self._fez: Callable = Ez
+        self._fkz: Callable = kz
+        self.type = modetype
+
+    def get_basis(self) -> np.ndarray:
+        return self.cs._basis
+        
+    def get_inv_basis(self) -> np.ndarray:
+        return self.cs._basis_inv
+    
+    def modetype(self, k0):
+        return self.type
+    
+    def get_amplitude(self, k0: float) -> float:
+        return np.sqrt(self.power)
+
+    def get_beta(self, k0: float) -> float:
+        ''' Return the out of plane propagation constant. βz.'''
+        return self._fkz(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
+        """
+        return 1j*self.get_beta(k0)
+    
+    def get_Uinc(self, x_global: np.ndarray, y_global: np.ndarray, z_global: np.ndarray, k0: float) -> np.ndarray:
+        return -2*1j*self.get_beta(k0)*self.port_mode_3d_global(x_global, y_global, z_global, k0)
+    
+    def port_mode_3d(self, 
+                     x_local: np.ndarray,
+                     y_local: np.ndarray,
+                     k0: float,
+                     which: Literal['E','H'] = 'E') -> np.ndarray:
+        x_global, y_global, z_global = self.cs.in_global_cs(x_local, y_local, 0*x_local)
+
+        Egxyz = self.port_mode_3d_global(x_global,y_global,z_global,k0,which=which)
+        
+        Ex, Ey, Ez = self.cs.in_local_basis(Egxyz[0,:], Egxyz[1,:], Egxyz[2,:])
+
+        Exyz = np.array([Ex, Ey, Ez])
+        return Exyz
+
+    def port_mode_3d_global(self, 
+                            x_global: np.ndarray,
+                            y_global: np.ndarray,
+                            z_global: np.ndarray,
+                            k0: float,
+                            which: Literal['E','H'] = 'E') -> np.ndarray:
+        '''Compute the port mode field for global xyz coordinates.'''
+        xl, yl, _ = self.cs.in_local_cs(x_global, y_global, z_global)
+        Ex = self._fex(k0, x_global, y_global, z_global)
+        Ey = self._fey(k0, x_global, y_global, z_global)
+        Ez = self._fez(k0, x_global, y_global, z_global)
+        Exg, Eyg, Ezg = self.cs.in_global_basis(Ex, Ey, Ez)
+        return np.array([Exg, Eyg, Ezg])
+    
 class LumpedPort(PortBC):
     
     _include_stiff: bool = True
@@ -874,6 +1018,11 @@ class LumpedPort(PortBC):
         self.vintline: list[Line] = []
         self.v_integration = True
 
+        # Sanity checks
+        if self.width > 0.5 or self.height > 0.5:
+            DEBUG_COLLECTOR.add_report(f'{self}: A lumped port width/height larger than 0.5m has been detected: width={self.width:.3f}m. Height={self.height:.3f}.m. Perhaps you forgot a unit like mm, um, or mil')
+
+        
     @property
     def surfZ(self) -> float:
         """The surface sheet impedance for the lumped port

emerge/_emerge/plot/pyvista/display.py

@@ -15,20 +15,21 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 from __future__ import annotations
-import time
 from ...mesh3d import Mesh3D
+from ...simstate import SimState
 from ...geometry import GeoObject
 from ...selection import FaceSelection, DomainSelection, EdgeSelection, Selection, encode_data
 from ...physics.microwave.microwave_bc import PortBC, ModalPort
-import numpy as np
-import pyvista as pv
-from typing import Iterable, Literal, Callable, Any
 from ..display import BaseDisplay
 from .display_settings import PVDisplaySettings
-from matplotlib.colors import ListedColormap
 from .cmap_maker import make_colormap
 
+import time
+import numpy as np
+import pyvista as pv
+from typing import Iterable, Literal, Callable, Any
 from itertools import cycle
+from loguru import logger
 ### Color scale
 
 # Define the colors we want to use
@@ -232,8 +233,8 @@ class _AnimObject:
 
 class PVDisplay(BaseDisplay):
 
-    def __init__(self, mesh: Mesh3D):
-        self._mesh: Mesh3D = mesh
+    def __init__(self, state: SimState):
+        self._state: SimState = state
         self.set: PVDisplaySettings = PVDisplaySettings()
         
         # Animation options
@@ -260,6 +261,9 @@ class PVDisplay(BaseDisplay):
         self._cbar_lim: tuple[float, float] | None = None
         self.camera_position = (1, -1, 1)     # +X, +Z, -Y
     
+    @property
+    def _mesh(self) -> Mesh3D:
+        return self._state.mesh
     
     def cbar(self, name: str, n_labels: int = 5, interactive: bool = False, clim: tuple[float, float] | None = None ) -> PVDisplay:
         self._cbar_args = dict(title=name, n_labels=n_labels, interactive=interactive)
@@ -302,8 +306,7 @@ class PVDisplay(BaseDisplay):
         self._ruler.min_length = max(1e-3, min(self._mesh.edge_lengths))
         self._update_camera()
         self._add_aux_items()
-        # self._plot.renderer.enable_depth_peeling(20, 0.8)
-        # self._plot.enable_anti_aliasing(self.set.anti_aliassing)
+        self._add_background()
         if self._do_animate:
             self._wire_close_events()
             self.add_text('Press Q to close!',color='red', position='upper_left')
@@ -313,14 +316,17 @@ class PVDisplay(BaseDisplay):
             self._plot.show()
         
         self._reset()
-    
-    def set_mesh(self, mesh: Mesh3D):
-        """Define the mesh to be used
 
-        Args:
-            mesh (Mesh3D): The mesh object
-        """
-        self._mesh = mesh
+    def _add_background(self):
+        from pyvista import examples
+        from requests.exceptions import ConnectionError
+        
+        try:
+            cubemap = examples.download_sky_box_cube_map()
+            self._plot.set_environment_texture(cubemap)
+        except ConnectionError:
+            logger.warning(f'No internet, no background texture will be used.')
+        
 
     def _reset(self):
         """ Resets key display parameters."""
@@ -456,6 +462,10 @@ class PVDisplay(BaseDisplay):
     ## OBLIGATORY METHODS
     def add_object(self, obj: GeoObject | Selection, mesh: bool = False, volume_mesh: bool = True, label: bool = False, *args, **kwargs):
         
+        if isinstance(obj, GeoObject):
+            if obj._hidden:
+                return
+            
         show_edges = False
         opacity = obj.opacity
         line_width = 0.5

emerge/_emerge/settings.py

@@ -1,12 +1,130 @@
+# 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 typing import Literal
 
 class Settings:
-    
     def __init__(self):
-        self.mw_2dbc: bool = True
-        self.mw_2dbc_lim: float = 10.0
-        self.mw_2dbc_peclim: float = 1e8
-        self.mw_3d_peclim: float = 1e7
+        self._mw_2dbc: bool = True 
+        self._mw_2dbc_lim: float = 10.0
+        self._mw_2dbc_peclim: float = 1e8
+        self._mw_3d_peclim: float = 1e7
+        self._mw_cap_sp_single: bool = True
+        self._mw_cap_sp_col: bool = True
+        self._mw_recip_sp: bool = False
+        self._size_check: bool = True
+        
+    
+
+    ############################################################
+    #                            GETTERS                       #
+    ############################################################
+
+    @property
+    def mw_2dbc(self) -> bool:
+        """ This variable determines is 2D boundary conditions will be automatically assigned based on material properties.
+        """
+        return self._mw_2dbc
+    
+    @property
+    def mw_2dbc_lim(self) -> float:
+        """This variable is the bulk conductivity limit in S/m beyond which a surface material will automatically be assigned as a SurfaceImpedance boundary condition."""
+        return self._mw_2dbc_lim
+    
+    @property
+    def mw_2dbc_peclim(self) -> float:
+        """This variable determines a bulk conductivity limit in S/m beyond which a conductor is assigned PEC instead of a SurfaceImpedance boundary condition."""
+        return self._mw_2dbc_peclim
+    
+    @property
+    def mw_3d_peclim(self) -> float:
+        """This variable determines if bulk conductors with a bulk conductivity beyond a limit (.mw_3d_peclim) are considered PEC.
+
+        """
+        return self._mw_3d_peclim
+    
+    @property
+    def size_check(self) -> bool:
+        """If a total volume check should be considered (100,000 tetrahedra) to hard crash the simulation assuming that the problem size will be too high to solver.
+        100.000 Tetrahedra would yield approximately 700k Degrees of Freedom
+        """
+        return self._size_check
+    
+    @property
+    def mw_cap_sp_single(self) -> bool:
+        """If Single S-parameters should be capped with their magnitude to at most 1.0"""
+        return self._mw_cap_sp_single
+    
+    @property
+    def mw_cap_sp_col(self) -> bool:
+        """If Single S-parameters columns should be power normalized to 1.0"""
+        return self._mw_cap_sp_col
+    
+    @property
+    def mw_recip_sp(self) -> bool:
+        """If reciprodicty should be explicitly enforced"""
+        return self._mw_recip_sp
+    ############################################################
+    #                            SETTERS                       #
+    ############################################################
+
+    @mw_2dbc.setter
+    def mw_2dbc(self, value: bool) -> None:
+        """ This variable determines is 2D boundary conditions will be automatically assigned based on material properties.
+        """
+        self._mw_2dbc = value
         
+    @mw_2dbc_lim.setter
+    def mw_2dbc_lim(self, value: float):
+        """This variable is the bulk conductivity limit in S/m beyond which a surface material will automatically be assigned as a SurfaceImpedance boundary condition."""
+        self._mw_2dbc_lim = value
+    
+    @mw_2dbc_peclim.setter
+    def mw_2dbc_peclim(self, value: float):
+        """This variable determines a bulk conductivity limit in S/m beyond which a conductor is assigned PEC instead of a SurfaceImpedance boundary condition."""
+        
+        self._mw_2dbc_peclim = value
+    
+    @mw_3d_peclim.setter
+    def mw_3d_peclim(self, value: float):
+        """This variable determines if bulk conductors with a bulk conductivity beyond a limit (.mw_3d_peclim) are considered PEC.
+
+        """
+        self._mw_3d_peclim = value
+        
+    @size_check.setter
+    def size_check(self, value: bool):
+        """If a total volume check should be considered (100,000 tetrahedra) to hard crash the simulation assuming that the problem size will be too high to solver.
+        100.000 Tetrahedra would yield approximately 700k Degrees of Freedom
+        """
+        self._size_check = value
+        
+    @mw_cap_sp_single.setter
+    def mw_cap_sp_single(self, value: bool) -> bool:
+        """If Single S-parameters should be capped with their magnitude to at most 1.0"""
+        self._mw_cap_sp_single = value
+    
+    @mw_cap_sp_col.setter
+    def mw_cap_sp_col(self, value: bool) -> bool:
+        """If Single S-parameters columns should be power normalized to 1.0"""
+        self._mw_cap_sp_col = value
+    
+    @mw_recip_sp.setter
+    def mw_recip_sp(self, value: bool) -> bool:
+        """If reciprodicty should be explicitly enforced"""
+        self._mw_recip_sp = value
+    
 DEFAULT_SETTINGS = Settings()