emerge 0.5.5__py3-none-any.whl → 0.5.6__py3-none-any.whl

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -20,7 +20,7 @@ import numpy as np
 from loguru import logger
 from typing import Callable, Literal
 from ...selection import Selection, FaceSelection
-from ...cs import CoordinateSystem, Axis, GCS
+from ...cs import CoordinateSystem, Axis, GCS, _parse_axis
 from ...coord import Line
 from ...geometry import GeoSurface, GeoObject
 from dataclasses import dataclass
@@ -28,7 +28,23 @@ 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
+from ...const import Z0, C0, EPS0, MU0
+
+
+
+############################################################
+#                     UTILITY FUNCTIONS                    #
+############################################################
+
+def _inner_product(function: Callable, x: np.ndarray, y: np.ndarray, z: np.ndarray, ax: Axis) -> float:
+            Exyz = function(x,y,z)
+            return np.sum(Exyz[0,:]*ax.x + Exyz[1,:]*ax.y + Exyz[2,:]*ax.z)
+        
+        
+
+############################################################
+#                   MAIN BC MANAGER CLASS                  #
+############################################################
 
 class MWBoundaryConditionSet(BoundaryConditionSet):
 
@@ -83,6 +99,10 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         return port
 
 
+############################################################
+#                    BOUNDARY CONDITIONS                   #
+############################################################
+
 
 class PEC(BoundaryCondition):
     
@@ -313,7 +333,7 @@ class PortMode:
         self.energy = np.mean(np.abs(self.modefield)**2)
 
     def __str__(self):
-        return f'PortMode(k0={self.k0}, beta={self.beta}, neff={self.neff}, energy={self.energy})'
+        return f'PortMode(k0={self.k0}, beta={self.beta}({self.neff:.3f}))'
     
     def set_power(self, power: complex) -> None:
         self.norm_factor = np.sqrt(1/np.abs(power))
@@ -371,8 +391,8 @@ class FloquetPort(PortBC):
         """
         return 1j*self.get_beta(k0)
     
-    def get_Uinc(self, x_local: np.ndarray, y_local: np.ndarray, k0: float) -> np.ndarray:
-        return -2*1j*self.get_beta(k0)*self.port_mode_3d(x_local, y_local, 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,
@@ -449,7 +469,7 @@ class ModalPort(PortBC):
         self.port_number: int= port_number
         self.active: bool = active
         self.power: float = power
-        
+        self.alignment_vectors: list[Axis] = []
 
         self.selected_mode: int = 0
         self.modes: dict[float, list[PortMode]] = defaultdict(list)
@@ -459,6 +479,7 @@ class ModalPort(PortBC):
         self.initialized: bool = False
         self._first_k0: float | None = None
         self._last_k0: float | None = None
+        
 
         if cs is None:
             logger.info('Constructing coordinate system from normal port')
@@ -474,6 +495,17 @@ class ModalPort(PortBC):
     def modetype(self, k0: float) -> Literal['TEM','TE','TM']:
         return self.get_mode(k0).modetype
     
+    def align_modes(self, *axes: tuple | np.ndarray | Axis) -> None:
+        """Set a reriees of Axis objects that define a sequence of mode field
+        alignments.
+
+        The modes will be sorted to maximize the inner product: |∬ E(x,y) · ax dS|
+        
+        Args:
+            *axes (tuple, np.ndarray, Axis): The alignment vectors.
+        """ 
+        self.alignment_vectors = [_parse_axis(ax) for ax in axes]
+        
     @property
     def nmodes(self) -> int:
         if self._last_k0 is None:
@@ -488,6 +520,26 @@ class ModalPort(PortBC):
     def sort_modes(self) -> None:
         """Sorts the port modes based on total energy
         """
+        
+        if len(self.alignment_vectors) > 0:
+            logger.trace(f'Sorting modes based on alignment vectors: {self.alignment_vectors}')
+            X, Y, Z = self.selection.sample(5)
+            X = X.flatten()
+            Y = Y.flatten()
+            Z = Z.flatten()
+            for k0, modes in self.modes.items():
+                logger.trace(f'Aligning modes for k0={k0:.3f} rad/m')
+                new_modes = []
+                for ax in self.alignment_vectors:
+                    logger.trace(f'.mode vector {ax}')
+                    integrals = [_inner_product(m.E_function, X, Y, Z, ax) for m in modes]
+                    integral, opt_mode = sorted([pair for pair in zip(integrals, modes)], key=lambda x: abs(x[0]), reverse=True)[0]
+                    opt_mode.polarity = np.sign(integral.real)
+                    logger.trace(f'Optimal mode = {opt_mode} ({integral}), polarization alignment = {opt_mode.polarity}')
+                    new_modes.append(opt_mode)
+                    
+                self.modes[k0] = new_modes
+            return
         for k0, modes in self.modes.items():
             self.modes[k0] = sorted(modes, key=lambda m: m.energy, reverse=True)
 
@@ -578,8 +630,8 @@ class ModalPort(PortBC):
     def get_gamma(self, k0: float) -> complex:
         return 1j*self.get_beta(k0)
     
-    def get_Uinc(self, x_local, y_local, k0) -> np.ndarray:
-        return -2*1j*self.get_beta(k0)*self.port_mode_3d(x_local, y_local, k0)
+    def get_Uinc(self, x_global: np.ndarray, y_global: np.ndarray, z_global: np.ndarray, k0) -> 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,
@@ -691,8 +743,8 @@ class RectangularWaveguide(PortBC):
         """
         return 1j*self.get_beta(k0)
     
-    def get_Uinc(self, x_local: np.ndarray, y_local: np.ndarray, k0: float) -> np.ndarray:
-        return -2*1j*self.get_beta(k0)*self.port_mode_3d(x_local, y_local, 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,
@@ -826,9 +878,9 @@ class LumpedPort(PortBC):
         """
         return 1j*k0*Z0/self.surfZ
     
-    def get_Uinc(self, x_local, y_local, k0) -> np.ndarray:
+    def get_Uinc(self, x_global: np.ndarray, y_global: np.ndarray, z_global: np.ndarray, k0) -> np.ndarray:
         Emag = -1j*2*k0 * self.voltage/self.height * (Z0/self.surfZ)
-        return Emag*self.port_mode_3d(x_local, y_local, k0)
+        return Emag*self.port_mode_3d_global(x_global, y_global, z_global, k0)
     
     def port_mode_3d(self, 
                      x_local: np.ndarray,
@@ -871,7 +923,6 @@ class LumpedPort(PortBC):
         Exg, Eyg, Ezg = self.cs.in_global_basis(Ex, Ey, Ez)
         return np.array([Exg, Eyg, Ezg])
 
-
 class LumpedElement(RobinBC):
     
     _include_stiff: bool = True
@@ -948,8 +999,6 @@ class LumpedElement(RobinBC):
         """
         return 1j*k0*Z0/self.surfZ(k0)
     
-
-
 class SurfaceImpedance(RobinBC):
     
     _include_stiff: bool = True
@@ -959,29 +1008,45 @@ class SurfaceImpedance(RobinBC):
     def __init__(self, 
                  face: FaceSelection | GeoSurface,
                  material: Material | None = None,
+                 surface_conductance: float | None = None,
+                 surface_roughness: float = 0,
+                 sr_model: Literal['Hammerstad-Jensen'] = 'Hammerstad-Jensen',
                  ):
-        """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.
+        """Generates a SurfaceImpedance bounary condition.
+
+        The surface impedance model treats a 2D surface selection as a finite conductor. It is not
+        intended to be used for dielectric materials.
+
+        The surface resistivity is computed based on the material properties: σ, ε and μ. 
+
+        The user may also supply the surface condutivity directly. 
+
+        Optionally, a surface roughness in meters RMS may be supplied. In the current implementation
+        The Hammersstad-Jensen model is used increasing the resistivity by a factor (1 + 2/π tan⁻¹(1.4(Δ/δ)²).
 
         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.
+            face (FaceSelection | GeoSurface): The face to apply this condition to.
+            material (Material | None, optional): The matrial to assign. Defaults to None.
+            surface_conductance (float | None, optional): The specific bulk conductivity to use. Defaults to None.
+            surface_roughness (float, optional): The surface roughness. Defaults to 0.
+            sr_model (Literal['Hammerstad, optional): The surface roughness model. Defaults to 'Hammerstad-Jensen'.
         """
         super().__init__(face)
 
-        self.material: Material = material 
-    
+        self._material: Material | None = material
+        self._mur: float | complex = 1.0
+        self._epsr: float | complex = 1.0
+
+        self.sigma: float = 0.0
+        if material is not None:
+            self.sigma = material.cond
+            self._mur = material.ur
+            self._epsr = material.er
+        if surface_conductance is not None:
+            self.sigma = surface_conductance
+        
+        self._sr: float = surface_roughness
+        self._sr_model: str = sr_model
     
     def get_basis(self) -> np.ndarray | None:
         return None
@@ -1004,9 +1069,10 @@ class SurfaceImpedance(RobinBC):
             complex: The γ-constant
         """
         w0 = k0*C0
-        sigma = self.material.cond
+        sigma = self.sigma
         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
+        d_skin = (2*rho/(w0*MU0*self._mur) * ((1+(w0*EPS0*self._epsr*rho)**2)**0.5 + rho*w0*EPS0*self._epsr))**0.5
         R = rho/d_skin
+        if self._sr_model=='Hammerstad-Jensen' and self._sr > 0.0:
+            R = R * (1 + 2/np.pi * np.arctan(1.4*(self._sr/d_skin)**2))
         return 1j*k0*Z0/R

emerge/_emerge/physics/microwave/microwave_data.py

@@ -777,7 +777,7 @@ class MWField:
             syms (list[Literal['Ex','Ey','Ez','Hx','Hy','Hz']], optional): E and H-plane symmetry planes where Ex is E-symmetry in x=0. Defaults to []
 
         Returns:
-            tuple[np.ndarray, np.ndarray, np.ndarray]: _description_
+            tuple[np.ndarray, np.ndarray, np.ndarray]: Angles (N,), E(3,N), H(3,N)
         """
         refdir = _parse_axis(ref_direction).np
         plane_normal_parsed = _parse_axis(plane_normal).np

emerge/_emerge/plot/pyvista/display.py

@@ -213,8 +213,18 @@ class PVDisplay(BaseDisplay):
         self._plot.add_key_event("m", self.activate_ruler) # type: ignore
         self._plot.add_key_event("f", self.activate_object) # type: ignore
 
-        self._ctr: int = 0
-
+        self._ctr: int = 0 
+        
+        self.camera_position = (1, -1, 1)     # +X, +Z, -Y
+        
+    def _update_camera(self):
+        x,y,z = self._plot.camera.position
+        d = (x**2+y**2+z**2)**(0.5)
+        px, py, pz = self.camera_position
+        dp = (px**2+py**2+pz**2)**(0.5)
+        px, py, pz = px/dp, py/dp, pz/dp
+        self._plot.camera.position = (d*px, d*py, d*pz)
+        
     def activate_ruler(self):
         self._plot.disable_picking()
         self._selector.turn_off()
@@ -228,6 +238,7 @@ class PVDisplay(BaseDisplay):
     def show(self):
         """ Shows the Pyvista display. """
         self._ruler.min_length = max(1e-3, min(self._mesh.edge_lengths))
+        self._update_camera()
         self._add_aux_items()
         if self._do_animate:
             self._plot.show(auto_close=False, interactive_update=True, before_close_callback=self._close_callback)
@@ -300,7 +311,25 @@ class PVDisplay(BaseDisplay):
         cells[:,1:] = self._mesh.tets[:,tets].T
         cells[:,0] = 4
         celltypes = np.full(ntets, fill_value=pv.CellType.TETRA, dtype=np.uint8)
-        points = self._mesh.nodes.T
+        points = self._mesh.nodes.copy().T
+        return pv.UnstructuredGrid(cells, celltypes, points)
+    
+    def _volume_edges(self, obj: GeoObject | Selection) -> pv.UnstructuredGrid:
+        """Adds the edges of objects
+
+        Args:
+            obj (DomainSelection | None, optional): _description_. Defaults to None.
+
+        Returns:
+            pv.UnstructuredGrid: The unstrutured grid object
+        """
+        edge_ids = self._mesh.domain_edges(obj.dimtags)
+        nedges = edge_ids.shape[0]
+        cells = np.zeros((nedges,3), dtype=np.int64)
+        cells[:,1:] = self._mesh.edges[:,edge_ids].T
+        cells[:,0] = 2
+        celltypes = np.full(nedges, fill_value=pv.CellType.CUBIC_LINE, dtype=np.uint8)
+        points = self._mesh.nodes.copy().T
         return pv.UnstructuredGrid(cells, celltypes, points)
     
     def mesh_surface(self, surface: FaceSelection) -> pv.UnstructuredGrid:
@@ -310,7 +339,8 @@ class PVDisplay(BaseDisplay):
         cells[:,1:] = self._mesh.tris[:,tris].T
         cells[:,0] = 3
         celltypes = np.full(ntris, fill_value=pv.CellType.TRIANGLE, dtype=np.uint8)
-        points = self._mesh.nodes.T
+        points = self._mesh.nodes.copy().T
+        points[:,2] += self.set.z_boost
         return pv.UnstructuredGrid(cells, celltypes, points)
     
     def mesh(self, obj: GeoObject | Selection | Iterable) -> pv.UnstructuredGrid | None:
@@ -328,8 +358,10 @@ class PVDisplay(BaseDisplay):
 
     ## OBLIGATORY METHODS
     def add_object(self, obj: GeoObject | Selection, *args, **kwargs):
-        kwargs = setdefault(kwargs, color=obj.color_rgb, opacity=obj.opacity, silhouette=True, pickable=True)
-        self._plot.add_mesh(self.mesh(obj), *args, **kwargs)
+        kwargs = setdefault(kwargs, color=obj.color_rgb, opacity=obj.opacity, silhouette=False, show_edges=False, pickable=True)
+        
+        actor = self._plot.add_mesh(self.mesh(obj), *args, **kwargs)
+        self._plot.add_mesh(self._volume_edges(_select(obj)), color='#000000', line_width=1, show_edges=True)
 
     def add_scatter(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray):
         """Adds a scatter point cloud
@@ -348,7 +380,7 @@ class PVDisplay(BaseDisplay):
                      XYZ=None,
                      field: Literal['E','H'] = 'E', 
                      k0: float | None = None,
-                     mode_number: int | None = None) -> None:
+                     mode_number: int = 0) -> None:
         
         if XYZ:
             X,Y,Z = XYZ
@@ -385,6 +417,7 @@ class PVDisplay(BaseDisplay):
                 k0 = port.get_mode(0).k0
             else:
                 k0 = 1
+        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/plot/pyvista/display_settings.py

@@ -22,3 +22,4 @@ class PVDisplaySettings:
         self.background_bottom: str = "#c0d2e8"
         self.background_top: str = "#ffffff"
         self.grid_line_color: str = "#8e8e8e"
+        self.z_boost: float = 1e-6

emerge/_emerge/simmodel.py

@@ -313,7 +313,7 @@ class Simulation3D:
         for geo in _GEOMANAGER.all_geometries():
             self.display.add_object(geo)
         if selections:
-            [self.display.add_object(sel, color='red', opacity=0.7) for sel in selections]
+            [self.display.add_object(sel, color='red', opacity=0.3) for sel in selections]
         self.display.show()
 
         return None
@@ -435,7 +435,21 @@ class Simulation3D:
             else:
                 yield (dim[i_iter] for dim in dims_flat) # type: ignore
         self.mw.cache_matrices = True
+    
+    def export(self, filename: str):
+        """Exports the model or mesh depending on the extension. 
+        
+        Exporting is realized by GMSH.
+        Supported file formats are:
+        
+        3D Model: .opt, .geo_unrolled, .brep, .xao ,.step and .iges
+        Mesh: .msh, .inp, .key, ._0000.rad, .celum, .cgns, .diff, .unv, .ir3, .mes, .mesh 
+              .mail, .m, .bdf, .off, .p3d, .stl, .wrl, .vtk, .dat, .ply2, .su2, .neu, .x3d
 
+        Args:
+            filename (str): The filename
+        """
+        gmsh.write(filename)
     ############################################################
     #                     DEPRICATED FUNCTIONS                #
     ############################################################

emerge/_emerge/solve_interfaces/cudss_interface.py

@@ -21,6 +21,7 @@ from nvmath import CudaDataType # ty: ignore
 
 from scipy.sparse import csr_matrix
 import numpy as np
+from typing import Literal
 
 from loguru import logger
 
@@ -51,6 +52,11 @@ def _c_pointer(arry) -> int:
 ############################################################
 
 class CuDSSInterface:
+    """the CuDSSInterface class implements the nvmath bindings and cupy
+    control for EMerge.
+    """
+    AlgType = cudss.AlgType
+
     def __init__(self):
         self.A_cu = None
         self.b_cu = None
@@ -92,10 +98,31 @@ class CuDSSInterface:
             reorder_alg.nbytes
         )
 
-    def set_algorithm(self, alg_type: cudss.AlgType):
-        self.RALG = alg_type
+    def set_algorithm(self, alg_type: Literal['METIS','COLAMD','COLAM_BT','AMD']):
+        """Define fill-in reduction column permuation algorithm. The options are:
+
+         - "METIS" (Default) = NVidia's own Nested Dissection METIS sorter
+         - "COLAMD" = Column approximate minimum degree
+         - "COLAM_BT" = Column Approximate Minimum Degree Block Triangular
+         - "AMD" = Approximate Minimum Degree
+
+        Args:
+            alg_type (str): The chosen type
+        """
+        if alg_type=='METIS':
+            self.RALG = ALG_NEST_DISS_METIS
+        elif alg_type =='COLAMD':
+            self.RALG = ALG_COLAMD
+        elif alg_type == 'COLAMD_BT':
+            self.RALG = ALG_COLAMD_BLOCK_TRI
+        elif alg_type == 'AMD':
+            self.RALG = ALG_AMD
+        else:
+            logger.warning(f'Algorithm type {alg_type} is not of the chosen set. Ignoring setting.')
     
     def init_type(self):
+        """Initializes the value data type of the solver (float vs complex, single vs double).
+        """
         if self._PRES == 1:
             if self._COMP:
                 self.c_dtype = cp.complex64
@@ -112,6 +139,11 @@ class CuDSSInterface:
                 self.VTYPE = FLOAT64
 
     def submit_matrix(self, A: csr_matrix):
+        """Sets the given csr_matrix as the matrix to be solved.
+
+        Args:
+            A (csr_matrix): The csr_format matrix for the problem Ax=b
+        """
         self.N = A.shape[0]
 
         if np.iscomplexobj(A):
@@ -132,12 +164,21 @@ class CuDSSInterface:
         self._COL_IDS = self.A_cu.indices.astype(cp.int32)
 
     def submit_vector(self, b: np.ndarray):
+        """Submits the dense vector b to be solved.
+
+        Args:
+            b (np.ndarray): The dense vector for the problem Ax=b
+        """
         self.b_cu = cp.array(b).astype(self.c_dtype)
     
     def create_solvec(self):
+        """Initializes a solution vector that the nvmath binding can access.
+        """
         self.x_cu = cp.empty_like(self.b_cu)
 
     def _update_dss_data(self):
+        """Updates the currently defined matrix data into the existing memory.ALG_AMD
+        """
         cudss.matrix_set_values(self.A_cobj, _c_pointer(self._VAL))
 
         
@@ -147,6 +188,7 @@ class CuDSSInterface:
                                     int(self.VTYPE), int(cudss.Layout.COL_MAJOR))
 
     def _create_dss_data(self):
+        """Creates a new memory slot for the CSR matrix of the matrix A"""
         self.A_cobj = cudss.matrix_create_csr(
             self.N,self.N,self._NNZ,
             _c_pointer(self._ROW_START),

emerge/_emerge/solve_interfaces/pardiso_interface.py

@@ -15,6 +15,7 @@
 # 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 __future__ import annotations
 import os
 import sys

emerge/_emerge/solver.py

@@ -44,11 +44,8 @@ If so, attempt to import PyPardiso (if its installed)
 ############################################################
 
 if 'arm' not in platform.processor():
-    try:
-        from .solve_interfaces.pardiso_interface import PardisoInterface
-        _PARDISO_AVAILABLE = True
-    except ModuleNotFoundError:
-        logger.info('Pardiso not found, defaulting to SuperLU')
+    from .solve_interfaces.pardiso_interface import PardisoInterface
+    _PARDISO_AVAILABLE = True
 
 
 ############################################################
@@ -62,7 +59,6 @@ try:
 except ModuleNotFoundError:
     logger.debug('UMFPACK not found, defaulting to SuperLU')
 
-
 ############################################################
 #                           CUDSS                          #
 ############################################################
@@ -72,7 +68,10 @@ try:
     _CUDSS_AVAILABLE = True
 except ModuleNotFoundError:
     pass
-
+except ImportError as e:
+    logger.error('Error while importing CuDSS dependencies:')
+    logger.exception(e)
+    
 ############################################################
 #                       SOLVE REPORT                       #
 ############################################################
@@ -177,7 +176,8 @@ def filter_real_modes(eigvals: np.ndarray, eigvecs: np.ndarray,
 #               EIGENMODE ORTHOGONALITY CHECK              #
 ############################################################
 
-def filter_unique_eigenpairs(eigen_values: list[complex], eigen_vectors: list[np.ndarray], tol=-3) -> tuple[list[complex], list[np.ndarray]]:
+def filter_unique_eigenpairs(eigen_values: list[complex], 
+                             eigen_vectors: list[np.ndarray], tol=-3) -> tuple[list[complex], list[np.ndarray]]:
     """
     Filters eigenvectors by orthogonality using dot-product tolerance.
     
@@ -301,7 +301,8 @@ class Solver:
         Options may be ignored depending on the type of solver used."""
         pass
         
-    def solve(self, A: csr_matrix, b: np.ndarray, precon: Preconditioner, reuse_factorization: bool = False, id: int = -1) -> tuple[np.ndarray, SolveReport]:
+    def solve(self, A: csr_matrix, b: np.ndarray, precon: Preconditioner, 
+              reuse_factorization: bool = False, id: int = -1) -> tuple[np.ndarray, SolveReport]:
         raise NotImplementedError("This classes Ax=B solver method is not implemented.")
     
     def reset(self) -> None:
@@ -329,7 +330,8 @@ class EigSolver:
     def duplicate(self) -> Solver:
         return self.__class__()
 
-    def eig(self, A: csr_matrix | csr_matrix, B: csr_matrix | csr_matrix, nmodes: int = 6, target_k0: float = 0.0, which: str = 'LM', sign: float = 1.):
+    def eig(self, A: csr_matrix | csr_matrix, B: csr_matrix | csr_matrix, nmodes: int = 6, 
+            target_k0: float = 0.0, which: str = 'LM', sign: float = 1.):
         raise NotImplementedError("This classes eigenmdoe solver method is not implemented.")
     
     def reset(self) -> None:
@@ -337,7 +339,6 @@ class EigSolver:
         pass
 
 
-
 ############################################################
 #                          SORTERS                         #
 ############################################################
@@ -379,7 +380,9 @@ class ILUPrecon(Preconditioner):
 
     def init(self, A, b):
         logger.info("Generating ILU Preconditioner")
-        self.ilu = sparse.linalg.spilu(A, drop_tol=1e-2, fill_factor=self.fill_factor, permc_spec='MMD_AT_PLUS_A', diag_pivot_thresh=0.001, options=self.options) # ty: ignore
+        self.ilu = sparse.linalg.spilu(A, drop_tol=1e-2, fill_factor=self.fill_factor, # ty: ignore
+                                       permc_spec='MMD_AT_PLUS_A', diag_pivot_thresh=0.001, 
+                                       options=self.options) 
         self.M = sparse.linalg.LinearOperator(A.shape, self.ilu.solve) # ty: ignore
 
 
@@ -601,7 +604,7 @@ class CuDSSSolver(Solver):
         self.fact_numb = False
 
     def solve(self, A, b, precon, reuse_factorization: bool = False, id: int = -1):
-        logger.info(f'[{id}] Calling cuDSS Solver')
+        logger.info(f'[ID={id}] Calling cuDSS Solver')
         
         if self.fact_symb is False:
             logger.debug('Executing symbollic factorization')
@@ -911,7 +914,8 @@ class SolveRoutine:
         return new_routine
     
     def set_solver(self, *solvers: EMSolver | EigSolver | Solver) -> None:
-        """Set a given Solver class instance as the main solver. Solvers will be checked on validity for the given problem.
+        """Set a given Solver class instance as the main solver. 
+        Solvers will be checked on validity for the given problem.
 
         Args:
             solver (EMSolver | Solver): The solver objects
@@ -923,7 +927,8 @@ class SolveRoutine:
                 self.forced_solver.append(solver)
     
     def disable(self, *solvers: EMSolver) -> None:
-        """Disable a given Solver class instance as the main solver. Solvers will be checked on validity for the given problem.
+        """Disable a given Solver class instance as the main solver. 
+        Solvers will be checked on validity for the given problem.
 
         Args:
             solver (EMSolver): The solver objects
@@ -945,7 +950,8 @@ class SolveRoutine:
                     - "SI" = Single threaded
                     - "MT" = Multi threaded
                     - "MP" = Multi-processing,
-            smart_search (bool, optional): Wether to use smart-search solvers for eigenmode problems. Defaults to False.
+            smart_search (bool, optional): Wether to use smart-search solvers 
+            for eigenmode problems. Defaults to False.
 
         Returns:
             SolveRoutine: The same SolveRoutine object.
@@ -998,7 +1004,6 @@ class SolveRoutine:
                 return solver
         return self.pick_solver(A,b)
         
-    
     def pick_solver(self, A: csr_matrix, b: np.ndarray) -> Solver:
         """Returns the relevant Solver object given a certain matrix and source vector
 
@@ -1187,7 +1192,10 @@ class SolveRoutine:
         end = time.time()
 
         simtime = end-start
-        return eigen_values, eigen_modes, SolveReport(ndof=A.shape[0], nnz=A.nnz, ndof_solve=Asel.shape[0], nnz_solve=Asel.nnz, simtime=simtime, solver=str(solver), sorter='None', precon='None')
+        return eigen_values, eigen_modes, SolveReport(ndof=A.shape[0], nnz=A.nnz, 
+                                                      ndof_solve=Asel.shape[0], nnz_solve=Asel.nnz, 
+                                                      simtime=simtime, solver=str(solver), 
+                                                      sorter='None', precon='None')
 
     def eig(self, 
             A: csr_matrix | csr_matrix, 
@@ -1234,7 +1242,6 @@ class SolveRoutine:
 
         return eigen_values, sols, SolveReport(ndof=A.shape[0], nnz=A.nnz, ndof_solve=Asel.shape[0], nnz_solve=Asel.nnz, simtime=simtime, solver=str(solver), sorter='None', precon='None')
 
-
 class AutomaticRoutine(SolveRoutine):
     """ Defines the Automatic Routine for EMerge.
     """

emerge/ext.py

@@ -0,0 +1,4 @@
+
+from ._emerge.solver import Solver, EigSolver, Preconditioner, Sorter
+from ._emerge.geometry import GeoVolume, GeoSurface, GeoEdge, GeoPoint, _FacePointer
+from ._emerge.physics.microwave.microwave_bc import RobinBC, PortBC

emerge/lib.py

@@ -29,7 +29,7 @@ GREY = "#bfbfbf"
 MET_ALUMINUM         = Material(cond=3.77e7,  color=GREY, opacity=0.5)
 MET_CARBON           = Material(cond=3.33e4,  color=GREY, opacity=0.5)
 MET_CHROMIUM         = Material(cond=5.56e6,  color=GREY, opacity=0.5)
-MET_COPPER           = Material(cond=5.8e7,   color="#62290c", opacity=0.5)
+MET_COPPER           = Material(cond=5.8e7,   color="#62290c", opacity=1.0)
 MET_GOLD             = Material(cond=4.10e7,  color=GREY, opacity=0.5)
 MET_INDIUM           = Material(cond=6.44e6,  color=GREY, opacity=0.5)
 MET_IRIDIUM          = Material(cond=2.13e7,  color=GREY, opacity=0.5)