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

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -24,6 +24,7 @@ from ...elements.nedelec2 import Nedelec2
 from ...solver import DEFAULT_ROUTINE, SolveRoutine
 from ...system import called_from_main_function
 from ...selection import FaceSelection
+from ...mth.optimized import compute_distances
 from .microwave_bc import MWBoundaryConditionSet, PEC, ModalPort, LumpedPort, PortBC
 from .microwave_data import MWData
 from .assembly.assembler import Assembler
@@ -60,7 +61,7 @@ def run_job_multi(job: SimJob) -> SimJob:
     return job
 
 
-def _dimstring(data: list[float]) -> str:
+def _dimstring(data: list[float] | np.ndarray) -> str:
     """A String formatter for dimensions in millimeters
 
     Args:
@@ -99,6 +100,21 @@ def shortest_path(xyz1: np.ndarray, xyz2: np.ndarray, Npts: int) -> np.ndarray:
 
     return path
 
+def _pick_central(vertices: np.ndarray) -> np.ndarray:
+    """Computes the coordinate in the vertex set that has the shortest square distance to all other points.
+    
+
+    Args:
+        vertices (np.ndarray): The set of coordinates [3,:]
+
+    Returns:
+        np.ndarray: The most central point
+    """
+    Ds = compute_distances(vertices[0,:], vertices[1,:], vertices[2,:])
+    sumDs = np.sum(Ds**2, axis=1)
+    id_central = np.argwhere(sumDs==np.min(sumDs)).flatten()[0]
+    return vertices[:, id_central].squeeze()
+    
 class Microwave3D:
     """The Electrodynamics time harmonic physics class.
 
@@ -302,8 +318,8 @@ class Microwave3D:
         dotprod = xs*field_axis[0] + ys*field_axis[1] + zs*field_axis[2]
 
         start_id = points[np.argwhere(dotprod == np.min(dotprod))]
-
-        start = np.squeeze(np.mean(self.mesh.nodes[:,start_id],axis=1))
+        
+        start = _pick_central(self.mesh.nodes[:,start_id.flatten()])
         logger.info(f'Starting node = {_dimstring(start)}')
         end = start + port.Vdirection.np*port.height
 
@@ -493,6 +509,7 @@ class Microwave3D:
             if TEM:
                 target_kz = ermean*urmean*1.1*k0
             else:
+                
                 target_kz = ermean*urmean*0.7*k0
 
     
@@ -514,7 +531,8 @@ class Microwave3D:
             Emode[solve_ids] = np.squeeze(eigenmode)
             Emode = Emode * np.exp(-1j*np.angle(np.max(Emode)))
 
-            beta = min(k0*np.sqrt(ermax*urmax), np.emath.sqrt(-eigen_values[i]))
+            beta_base = np.emath.sqrt(-eigen_values[i])
+            beta = min(k0*np.sqrt(ermax*urmax), beta_base)
 
             residuals = -1
 
@@ -559,14 +577,14 @@ class Microwave3D:
         logger.info(f'Elapsed time = {(T2-T0):.2f} seconds.')
         return None
     
-    def frequency_domain(self, 
-                         parallel: bool = False,
-                         njobs: int = 2, 
-                         harddisc_threshold: int | None = None,
-                         harddisc_path: str = 'EMergeSparse',
-                         frequency_groups: int = -1,
-                         multi_processing: bool = False,
-                         automatic_modal_analysis: bool = True) -> MWData:
+    def run_sweep(self, 
+                parallel: bool = False,
+                njobs: int = 2, 
+                harddisc_threshold: int | None = None,
+                harddisc_path: str = 'EMergeSparse',
+                frequency_groups: int = -1,
+                multi_processing: bool = False,
+                automatic_modal_analysis: bool = True) -> MWData:
         """Executes a frequency domain study
 
         The study is distributed over "njobs" workers.
@@ -999,179 +1017,13 @@ class Microwave3D:
             mode_p = sparam_mode_power(self.mesh.nodes, tri_vertices, bc, k0, const, 5)
             return field_p, mode_p
 
-    # def frequency_domain_single(self, automatic_modal_analysis: bool = False) -> MWData:
-    #     """Execute a frequency domain study without distributed frequency sweep.
-
-    #     Args:
-    #         automatic_modal_analysis (bool, optional): Automatically compute port modes. Defaults to False.
-
-    #     Raises:
-    #         SimulationError: _description_
-
-    #     Returns:
-    #         MWSimData: The Simulation data.
-    #     """
-    #     T0 = time.time()
-    #     mesh = self.mesh
-    #     if self.bc._initialized is False:
-    #         raise SimulationError('Cannot run a modal analysis because no boundary conditions have been assigned.')
-        
-    #     self._initialize_field()
-    #     self._initialize_bc_data()
-        
-    #     er = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
-    #     ur = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)
-    #     cond = self.mesh.retreive(lambda mat,x,y,z: mat.cond, self.mesher.volumes)[0,0,:]
-
-    #     ertri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
-    #     urtri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
-    #     condtri = np.zeros((self.mesh.n_tris,), dtype=np.complex128)
-
-    #     for itri in range(self.mesh.n_tris):
-    #         itet = self.mesh.tri_to_tet[0,itri]
-    #         ertri[:,:,itri] = er[:,:,itet]
-    #         urtri[:,:,itri] = ur[:,:,itet]
-    #         condtri[itri] = cond[itet]
-        
-    #     #### Port settings
-
-    #     all_ports = self.bc.oftype(PortBC)
-    #     port_numbers = [port.port_number for port in all_ports]
-
-    #     ##### FOR PORT SWEEP SET ALL ACTIVE TO FALSE. THIS SHOULD BE FIXED LATER
-    #     ### COMPUTE WHICH TETS ARE CONNECTED TO PORT INDICES
-
-    #     all_port_tets = []
-    #     for port in all_ports:
-    #         port.active=False
-            
-    #     all_port_tets = mesh.get_face_tets(*[port.tags for port in all_ports])
-        
-
-    #     logger.debug(f'Starting the simulation of {len(self.frequencies)} frequency points.')
-
-    #     # ITERATE OVER FREQUENCIES
-    #     for freq in self.frequencies:
-    #         logger.info(f'Simulation frequency = {freq/1e9:.3f} GHz') 
-            
-    #         # Assembling matrix problem
-    #         if automatic_modal_analysis:
-    #             self._compute_modes(freq)
-            
-    #         job = self.assembler.assemble_freq_matrix(self.basis, er, ur, cond, self.bc.boundary_conditions, freq, cache_matrices=self.cache_matrices)
-
-    #         logger.debug(f'Routine: {self.solveroutine}')
 
-    #         for A, b, ids, reuse in job.iter_Ab():
-    #             solution, report = self.solveroutine.solve(A, b, ids, reuse)
-    #             job.submit_solution(solution, report)
+    ############################################################
+    #                     DEPRICATED FUNCTIONS                #
+    ############################################################
 
-    #         self.data.setreport(job.reports, freq=freq, **self._params)
-
-    #         k0 = 2*np.pi*freq/299792458
-
-    #         scalardata = self.data.scalar.new(freq=freq, **self._params)
-    #         scalardata.init_sp(port_numbers)
-    #         scalardata.freq = freq
-    #         scalardata.k0 = k0
-
-    #         fielddata = self.data.field.new(freq=freq, **self._params)
-    #         fielddata.freq = freq
-    #         fielddata.er = np.squeeze(er[0,0,:])
-    #         fielddata.ur = np.squeeze(ur[0,0,:])
-
-    #         # Recording port information
-    #         for i, port in enumerate(all_ports):
-    #             fielddata.add_port_properties(port.port_number,
-    #                                      mode_number=port.mode_number,
-    #                                      k0 = k0,
-    #                                      beta = port.get_beta(k0),
-    #                                      Z0 = port.portZ0(k0),
-    #                                      Pout= port.power)
-            
-    #         for active_port in all_ports:
-                
-    #             active_port.active = True
-    #             solution = job._fields[active_port.port_number]
-
-    #             fielddata._fields[active_port.port_number] = solution # TODO: THIS IS VERY FRAIL
-    #             fielddata.basis = self.basis
-
-    #             # Compute the S-parameters
-    #             # Define the field interpolation function
-    #             fieldf = self.basis.interpolate_Ef(solution, tetids=all_port_tets)
-
-    #             # Active port power
-    #             logger.debug('Active ports:')
-    #             tris = mesh.get_triangles(active_port.tags)
-    #             tri_vertices = mesh.tris[:,tris]
-    #             pfield, pmode = self._compute_s_data(active_port, fieldf, tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
-    #             logger.debug(f'Field Amplitude = {np.abs(pfield):.3f}, Excitation = {np.abs(pmode):.2f}')
-    #             Pout = pmode
-                
-    #             #Passive ports
-    #             logger.debug('Passive ports:')
-    #             for bc in all_ports:
-    #                 tris = mesh.get_triangles(bc.tags)
-    #                 tri_vertices = mesh.tris[:,tris]
-    #                 pfield, pmode = self._compute_s_data(bc, fieldf, tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
-    #                 logger.debug(f'Field amplitude = {np.abs(pfield):.3f}, Excitation= {np.abs(pmode):.2f}')
-    #                 scalardata.write_S(bc.port_number, active_port.port_number, pfield/Pout)
-
-    #             active_port.active=False
-            
-    #         fielddata.set_field_vector()
-
-    #     logger.info('Simulation Complete!')
-    #     T2 = time.time()    
-    #     logger.info(f'Elapsed time = {(T2-T0):.2f} seconds.')
-    #     return self.data
-## DEPRICATED
-
-
-
-    # 
-    # def eigenmode(self, mesh: Mesh3D, solver = None, num_sols: int = 6):
-    #     if solver is None:
-    #         logger.info('Defaulting to BiCGStab.')
-    #         solver = sparse.linalg.eigs
-
-    #     if self.order == 1:
-    #         logger.info('Detected 1st order elements.')
-    #         from ...elements.nedelec1.assembly import assemble_eig_matrix
-    #         ft = FieldType.VEC_LIN
-
-    #     elif self.order == 2:
-    #         logger.info('Detected 2nd order elements.')
-    #         from ...elements.nedelec2.assembly import assemble_eig_matrix_E
-    #         ft = FieldType.VEC_QUAD
-        
-    #     er = self.mesh.retreive(mesh.centers, lambda mat,x,y,z: mat.fer3d(x,y,z))
-    #     ur = self.mesh.retreive(mesh.centers, lambda mat,x,y,z: mat.fur3d(x,y,z))
-        
-    #     dataset = Dataset3D(mesh, self.frequencies, 0, ft)
-    #     dataset.er = er
-    #     dataset.ur = ur
-    #     logger.info('Solving eigenmodes.')
-        
-    #     f_target = self.frequencies[0]
-    #     sigma = (2 * np.pi * f_target / 299792458)**2
-
-    #     A, B, solvenodes = assemble_eig_matrix(mesh, er, ur, self.boundary_conditions)
-        
-    #     A = A[np.ix_(solvenodes, solvenodes)]
-    #     B = B[np.ix_(solvenodes, solvenodes)]
-    #     #A = sparse.csc_matrix(A)
-    #     #B = sparse.csc_matrix(B)
-        
-    #     w, v = sparse.linalg.eigs(A, k=num_sols, M=B, sigma=sigma, which='LM')
-        
-    #     logger.info(f'Eigenvalues: {np.sqrt(w)*299792458/(2*np.pi) * 1e-9} GHz')
-
-    #     Esol = np.zeros((num_sols, mesh.nfield), dtype=np.complex128)
-
-    #     Esol[:, solvenodes] = v.T
-        
-    #     dataset.set_efield(Esol)
-
-    #     self.basis = dataset
+    def frequency_domain(self, *args, **kwargs):
+        """DEPRICATED VERSION: Use run_sweep() instead.
+        """
+        logger.warning('This function is depricated. Please use run_sweep() instead')
+        self.run_sweep(*args, **kwargs)

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