emerge 1.0.6__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
 
@@ -73,7 +75,6 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         for bc in self.oftype(SurfaceImpedance):
             if bc.sigma > 10.0:
                 bcs.append(bc)
-
         return bcs
         
     def get_type(self, bctype: Literal['PEC','ModalPort','LumpedPort','PMC','LumpedElement','RectangularWaveguide','Periodic','FloquetPort','SurfaceImpedance']) -> FaceSelection:
@@ -342,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'
@@ -460,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.
 
@@ -477,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
         """
@@ -491,12 +491,14 @@ 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
         self._last_k0: float | None = None
         
+        self.plus_terminal: list[tuple[int, int]] = []
+        self.minus_terminal: list[tuple[int, int]] = []
 
         if cs is None:
             logger.info('Constructing coordinate system from normal port')
@@ -505,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
     
@@ -522,6 +542,31 @@ class ModalPort(PortBC):
             *axes (tuple, np.ndarray, Axis): The alignment vectors.
         """ 
         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:
+        """Define which objects/faces/selection should be assigned the positive terminal
+        and which one the negative terminal.
+        
+        The terminal assignment will be used to find an integration line for the impedance calculation.
+
+        Note: Ground is currently unused.
+        
+        Args:
+            positive (Selection | GeoObject | None, optional): The postive terminal. Defaults to None.
+            negative (Selection | GeoObject | None, optional): The negative terminal. Defaults to None.
+            ground (Selection | GeoObject | None, optional): _description_. Defaults to None.
+        """
+        if positive is not None:
+            self.plus_terminal = positive.dimtags
+        if negative is not None:
+            self.minus_terminal = negative.dimtags
         
     @property
     def nmodes(self) -> int:
@@ -569,9 +614,10 @@ class ModalPort(PortBC):
         Returns:
             PortMode: The requested PortMode object
         """
+        options = self.modes[min(self.modes.keys(), key=lambda k: abs(k - k0))]
         if i is None:
-            i = self.selected_mode
-        return self.modes[min(self.modes.keys(), key=lambda k: abs(k - k0))][i]
+            i = min(len(options)-1, self.selected_mode)
+        return options[i]
     
     def global_field_function(self, k0: float = 0, which: Literal['E','H'] = 'E') -> Callable:
         ''' The field function used to compute the E-field. 
@@ -594,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
 
@@ -605,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
 
@@ -637,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)
@@ -794,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
@@ -852,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/physics/microwave/microwave_data.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 from ...simulation_data import BaseDataset, DataContainer
 from ...elements.femdata import FEMBasis
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 import numpy as np
 from typing import Literal
 from loguru import logger
@@ -372,6 +372,7 @@ class EHField:
     freq: float
     er: np.ndarray
     ur: np.ndarray
+    aux: dict[str, np.ndarray] = field(default_factory=dict)
 
     @property
     def k0(self) -> float:
@@ -537,7 +538,7 @@ class EHField:
         
         return self.x, self.y, self.z, Fx, Fy, Fz
     
-    def scalar(self, field: Literal['Ex','Ey','Ez','Hx','Hy','Hz','normE','normH'], metric: Literal['abs','real','imag','complex'] = 'real') -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    def scalar(self, field: Literal['Ex','Ey','Ez','Hx','Hy','Hz','normE','normH'] | str, metric: Literal['abs','real','imag','complex'] = 'real') -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
         """Returns the data X, Y, Z, Field based on the interpolation
 
         For animations, make sure to select the complex metric.
@@ -549,7 +550,11 @@ class EHField:
         Returns:
             (X,Y,Z,Field): The coordinates plus field scalar
         """
-        field_arry = getattr(self, field)
+        if field in self.aux:
+            field_arry = self.aux[field]
+        else:
+            field_arry = getattr(self, field)
+        
         if metric=='abs':
             field = np.abs(field_arry)
         elif metric=='real':
@@ -666,6 +671,10 @@ class MWField:
         self.excitation = {key: 0.0 for key in self._fields.keys()}
         self.excitation[self.port_modes[0].port_number] = 1.0 + 0j
 
+    def excite_port(self, number: int) -> None:
+        self.excitation = {key: 0.0 for key in self._fields.keys()}
+        self.excitation[self.port_modes[number].port_number] = 1.0 + 0j
+        
     @property
     def EH(self) -> tuple[np.ndarray, np.ndarray]:
         ''' Return the electric and magnetic field as a tuple of numpy arrays '''
@@ -726,12 +735,20 @@ class MWField:
         self.Hx = Hx.reshape(shp)
         self.Hy = Hy.reshape(shp)
         self.Hz = Hz.reshape(shp)
-
+        
         self._x = xs
         self._y = ys
         self._z = zs
-        return EHField(xs, ys, zs, self.Ex, self.Ey, self.Ez, self.Hx, self.Hy, self.Hz, self.freq, self.er, self.ur)
-
+        field = EHField(xs, ys, zs, self.Ex, self.Ey, self.Ez, self.Hx, self.Hy, self.Hz, self.freq, self.er, self.ur)
+        
+        return field
+    
+    def _solution_quality(self) -> tuple[np.ndarray, np.ndarray]:
+        from .adaptive_mesh import compute_error_estimate
+        
+        error_tet, max_elem_size = compute_error_estimate(self)
+        return error_tet, max_elem_size
+        
     def boundary(self,
                  selection: FaceSelection) -> EHField:
         nodes = self.mesh.nodes

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
@@ -539,7 +549,7 @@ class PVDisplay(BaseDisplay):
                      XYZ=None,
                      field: Literal['E','H'] = 'E', 
                      k0: float | None = None,
-                     mode_number: int = 0) -> None:
+                     mode_number: int | None = None) -> None:
         
         if XYZ:
             X,Y,Z = XYZ
@@ -584,7 +594,10 @@ class PVDisplay(BaseDisplay):
                 k0 = port.get_mode(0).k0
             else:
                 k0 = 1
-        port.selected_mode = mode_number
+        
+        if isinstance(mode_number, int):
+            port.selected_mode = mode_number
+        
         F = port.port_mode_3d_global(xf,yf,zf,k0, which=field)
 
         Fx = F[0,:].reshape(X.shape).T

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()