emerge 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

emerge/_emerge/physics/microwave/assembly/robinbc.py

@@ -312,34 +312,31 @@ def compute_bc_entries_excited(vertices_global, tris, Bmat, Bvec, surf_triangle_
 
 
 @njit(c16[:,:](f8[:,:], f8[:], c16), cache=True, nogil=True, parallel=False)
-def ned2_tri_stiff(vertices, edge_lengths, gamma):
+def ned2_tri_stiff(glob_vertices, edge_lengths, gamma):
     ''' Nedelec-2 Triangle Stiffness matrix and forcing vector (For Boundary Condition of the Third Kind)
 
     '''
     local_edge_map = np.array([[0,1,0],[1,2,2]])
     Bmat = np.zeros((8,8), dtype=np.complex128)
 
-    xs = vertices[0,:]
-    ys = vertices[1,:]
-    zs = vertices[2,:]
-
-    ax1 = np.array([xs[1]-xs[0], ys[1]-ys[0], zs[1]-zs[0]])
-    ax2 = np.array([xs[2]-xs[0], ys[2]-ys[0], zs[2]-zs[0]])
-    ax1 = ax1/np.linalg.norm(ax1)
-    ax2 = ax2/np.linalg.norm(ax2)
-
-    axn = cross(ax1, ax2)
-    ax2 = -cross(axn, ax1)
+    orig = glob_vertices[:,0]
+    v2 = glob_vertices[:,1]
+    v3 = glob_vertices[:,2]
+    
+    e1 = v2-orig
+    e2 = v3-orig
+    zhat = normalize(cross(e1, e2))
+    xhat = normalize(e1)
+    yhat = normalize(cross(zhat, xhat))
     basis = np.zeros((3,3), dtype=np.float64)
-    basis[:,0] = ax1
-    basis[:,1] = ax2
-    basis[:,2] = axn
-    basis = np.linalg.pinv(basis)
-    lcs_vertices = basis @ np.ascontiguousarray(vertices)
-
+    basis[0,:] = xhat
+    basis[1,:] = yhat
+    basis[2,:] = zhat
+    lcs_vertices = optim_matmul(basis, glob_vertices - orig[:,np.newaxis])
+    
     xs = lcs_vertices[0,:]
     ys = lcs_vertices[1,:]
-
+    
     x1, x2, x3 = xs
     y1, y2, y3 = ys
 
@@ -359,7 +356,7 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
     GLs = (GL1, GL2, GL3)
 
     Area = 0.5 * np.abs((x1 - x3) * (y2 - y1) - (x1 - x2) * (y3 - y1))
-
+    
     letters = [1,2,3,4,5,6]
 
     tA, tB, tC = letters[0], letters[1], letters[2]
@@ -367,11 +364,12 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
     
     Lt1, Lt2 = Ds[2, 0], Ds[1, 0]
     
+
     COEFF = gamma/(2*Area)**2
     AREA_COEFF = AREA_COEFF_CACHE_BASE * Area
     for ei in range(3):
         ei1, ei2 = local_edge_map[:, ei]
-        Li = edge_lengths[ei]
+        Li = Ds[ei1, ei2]
         
         A = letters[ei1]
         B = letters[ei2]
@@ -381,24 +379,25 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
 
         for ej in range(3):
             ej1, ej2 = local_edge_map[:, ej]
-            Lj = edge_lengths[ej]
+            Lj = Ds[ej1, ej2]
 
             C = letters[ej1]
             D = letters[ej2]
 
             GC = GLs[ej1]
             GD = GLs[ej2]
+
             DAC = dot(GA,GC)
             DAD = dot(GA,GD)
             DBC = dot(GB,GC)
             DBD = dot(GB,GD)
             LL = Li*Lj
-
-            Bmat[ei,ej] += LL*COEFF*(AREA_COEFF[A,B,C,D]*DAC-AREA_COEFF[A,B,C,C]*DAD-AREA_COEFF[A,A,C,D]*DBC+AREA_COEFF[A,A,C,C]*DBD)
-            Bmat[ei,ej+4] += LL*COEFF*(AREA_COEFF[A,B,D,D]*DAC-AREA_COEFF[A,B,C,D]*DAD-AREA_COEFF[A,A,D,D]*DBC+AREA_COEFF[A,A,C,D]*DBD)
-            Bmat[ei+4,ej] += LL*COEFF*(AREA_COEFF[B,B,C,D]*DAC-AREA_COEFF[B,B,C,C]*DAD-AREA_COEFF[A,B,C,D]*DBC+AREA_COEFF[A,B,C,C]*DBD)
-            Bmat[ei+4,ej+4] += LL*COEFF*(AREA_COEFF[B,B,D,D]*DAC-AREA_COEFF[B,B,C,D]*DAD-AREA_COEFF[A,B,D,D]*DBC+AREA_COEFF[A,B,C,D]*DBD)
-        
+            
+            Bmat[ei,ej] += LL*(AREA_COEFF[A,B,C,D]*DAC-AREA_COEFF[A,B,C,C]*DAD-AREA_COEFF[A,A,C,D]*DBC+AREA_COEFF[A,A,C,C]*DBD)
+            Bmat[ei,ej+4] += LL*(AREA_COEFF[A,B,D,D]*DAC-AREA_COEFF[A,B,C,D]*DAD-AREA_COEFF[A,A,D,D]*DBC+AREA_COEFF[A,A,C,D]*DBD)
+            Bmat[ei+4,ej] += LL*(AREA_COEFF[B,B,C,D]*DAC-AREA_COEFF[B,B,C,C]*DAD-AREA_COEFF[A,B,C,D]*DBC+AREA_COEFF[A,B,C,C]*DBD)
+            Bmat[ei+4,ej+4] += LL*(AREA_COEFF[B,B,D,D]*DAC-AREA_COEFF[B,B,C,D]*DAD-AREA_COEFF[A,B,D,D]*DBC+AREA_COEFF[A,B,C,D]*DBD)
+            
         FA = dot(GA,GtC)
         FB = dot(GA,GtA)
         FC = dot(GB,GtC)
@@ -406,15 +405,15 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
         FE = dot(GA,GtB)
         FF = dot(GB,GtB)
 
-        Bmat[ei,3] += Li*Lt1*COEFF*(AREA_COEFF[A,B,tA,tB]*FA-AREA_COEFF[A,B,tB,tC]*FB-AREA_COEFF[A,A,tA,tB]*FC+AREA_COEFF[A,A,tB,tC]*FD)
-        Bmat[ei,7] += Li*Lt2*COEFF*(AREA_COEFF[A,B,tB,tC]*FB-AREA_COEFF[A,B,tC,tA]*FE-AREA_COEFF[A,A,tB,tC]*FD+AREA_COEFF[A,A,tC,tA]*FF)
-        Bmat[3,ei] += Lt1*Li*COEFF*(AREA_COEFF[tA,tB,A,B]*FA-AREA_COEFF[tA,tB,A,A]*FC-AREA_COEFF[tB,tC,A,B]*FB+AREA_COEFF[tB,tC,A,A]*FD)
-        Bmat[7,ei] += Lt2*Li*COEFF*(AREA_COEFF[tB,tC,A,B]*FB-AREA_COEFF[tB,tC,A,A]*FD-AREA_COEFF[tC,tA,A,B]*FE+AREA_COEFF[tC,tA,A,A]*FF)
-        Bmat[ei+4,3] += Li*Lt1*COEFF*(AREA_COEFF[B,B,tA,tB]*FA-AREA_COEFF[B,B,tB,tC]*FB-AREA_COEFF[A,B,tA,tB]*FC+AREA_COEFF[A,B,tB,tC]*FD)
-        Bmat[ei+4,7] += Li*Lt2*COEFF*(AREA_COEFF[B,B,tB,tC]*FB-AREA_COEFF[B,B,tC,tA]*FE-AREA_COEFF[A,B,tB,tC]*FD+AREA_COEFF[A,B,tC,tA]*FF)
-        Bmat[3,ei+4] += Lt1*Li*COEFF*(AREA_COEFF[tA,tB,B,B]*FA-AREA_COEFF[tA,tB,A,B]*FC-AREA_COEFF[tB,tC,B,B]*FB+AREA_COEFF[tB,tC,A,B]*FD)
-        Bmat[7,ei+4] += Lt2*Li*COEFF*(AREA_COEFF[tB,tC,B,B]*FB-AREA_COEFF[tB,tC,A,B]*FD-AREA_COEFF[tC,tA,B,B]*FE+AREA_COEFF[tC,tA,A,B]*FF)
-      
+        Bmat[ei,3] += Li*Lt1*(AREA_COEFF[A,B,tA,tB]*FA-AREA_COEFF[A,B,tB,tC]*FB-AREA_COEFF[A,A,tA,tB]*FC+AREA_COEFF[A,A,tB,tC]*FD)
+        Bmat[ei,7] += Li*Lt2*(AREA_COEFF[A,B,tB,tC]*FB-AREA_COEFF[A,B,tC,tA]*FE-AREA_COEFF[A,A,tB,tC]*FD+AREA_COEFF[A,A,tC,tA]*FF)
+        Bmat[3,ei] += Lt1*Li*(AREA_COEFF[tA,tB,A,B]*FA-AREA_COEFF[tA,tB,A,A]*FC-AREA_COEFF[tB,tC,A,B]*FB+AREA_COEFF[tB,tC,A,A]*FD)
+        Bmat[7,ei] += Lt2*Li*(AREA_COEFF[tB,tC,A,B]*FB-AREA_COEFF[tB,tC,A,A]*FD-AREA_COEFF[tC,tA,A,B]*FE+AREA_COEFF[tC,tA,A,A]*FF)
+        Bmat[ei+4,3] += Li*Lt1*(AREA_COEFF[B,B,tA,tB]*FA-AREA_COEFF[B,B,tB,tC]*FB-AREA_COEFF[A,B,tA,tB]*FC+AREA_COEFF[A,B,tB,tC]*FD)
+        Bmat[ei+4,7] += Li*Lt2*(AREA_COEFF[B,B,tB,tC]*FB-AREA_COEFF[B,B,tC,tA]*FE-AREA_COEFF[A,B,tB,tC]*FD+AREA_COEFF[A,B,tC,tA]*FF)
+        Bmat[3,ei+4] += Lt1*Li*(AREA_COEFF[tA,tB,B,B]*FA-AREA_COEFF[tA,tB,A,B]*FC-AREA_COEFF[tB,tC,B,B]*FB+AREA_COEFF[tB,tC,A,B]*FD)
+        Bmat[7,ei+4] += Lt2*Li*(AREA_COEFF[tB,tC,B,B]*FB-AREA_COEFF[tB,tC,A,B]*FD-AREA_COEFF[tC,tA,B,B]*FE+AREA_COEFF[tC,tA,A,B]*FF)
+    
     H1 = dot(GtA,GtC)
     H2 = dot(GtA,GtA)
     H3 = dot(GtA,GtB)
@@ -423,8 +422,8 @@ def ned2_tri_stiff(vertices, edge_lengths, gamma):
     Bmat[3,7] += Lt1*Lt2*(AREA_COEFF[tA,tB,tB,tC]*H1-AREA_COEFF[tA,tB,tC,tA]*dot(GtB,GtC)-AREA_COEFF[tB,tC,tB,tC]*H2+AREA_COEFF[tB,tC,tC,tA]*H3)
     Bmat[7,3] += Lt2*Lt1*(AREA_COEFF[tB,tC,tA,tB]*H1-AREA_COEFF[tB,tC,tB,tC]*H2-AREA_COEFF[tC,tA,tA,tB]*dot(GtB,GtC)+AREA_COEFF[tC,tA,tB,tC]*H3)
     Bmat[7,7] += Lt2*Lt2*(AREA_COEFF[tB,tC,tB,tC]*H2-AREA_COEFF[tB,tC,tC,tA]*H3-AREA_COEFF[tC,tA,tB,tC]*H3+AREA_COEFF[tC,tA,tC,tA]*dot(GtB,GtB))
-    
 
+    Bmat = Bmat * COEFF
     return Bmat
 
 @njit(c16[:](f8[:,:], i8[:,:], c16[:], f8[:,:], i8[:], c16), cache=True, nogil=True, parallel=False)

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -25,7 +25,6 @@ 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 ...settings import Settings
 from .microwave_bc import MWBoundaryConditionSet, PEC, ModalPort, LumpedPort, PortBC
 from .microwave_data import MWData
@@ -101,21 +100,6 @@ def shortest_path(xyz1: np.ndarray, xyz2: np.ndarray, Npts: int) -> np.ndarray:
     path = (1 - t) * p1[:, np.newaxis] + t * p2[:, np.newaxis]
 
     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.
@@ -248,6 +232,14 @@ class Microwave3D:
         self.set_frequency(np.linspace(fmin, fmax, Npoints))
     
     def fdense(self, Npoints: int) -> np.ndarray:
+        """Return a resampled version of the current frequency range
+
+        Args:
+            Npoints (int): The new number of points
+
+        Returns:
+            np.ndarray: The new frequency axis
+        """
         if len(self.frequencies) == 1:
             raise ValueError('Only 1 frequency point known. At least two need to be defined.')
         fmin = min(self.frequencies)
@@ -497,7 +489,7 @@ class Microwave3D:
         if freq is None:
             freq = self.frequencies[0]
         
-        materials = self.mesh.retreive(self.mesher.volumes)
+        materials = self.mesh._get_material_assignment(self.mesher.volumes)
 
         ertet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
         tandtet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
@@ -655,7 +647,7 @@ class Microwave3D:
         if self.basis is None:
             raise SimulationError('Cannot proceed, the simulation basis class is undefined.')
 
-        materials = self.mesh.retreive(self.mesher.volumes)
+        materials = self.mesh._get_material_assignment(self.mesher.volumes)
 
         ### Does this move
         logger.debug('Initializing frequency domain sweep.')
@@ -853,7 +845,7 @@ class Microwave3D:
         if self.basis is None:
             raise SimulationError('Cannot proceed. The simulation basis class is undefined.')
 
-        materials = self.mesh.retreive(self.mesher.volumes)
+        materials = self.mesh._get_material_assignment(self.mesher.volumes)
         
         # 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)

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -19,19 +19,17 @@ from __future__ import annotations
 import numpy as np
 from loguru import logger
 from typing import Callable, Literal
+from dataclasses import dataclass
+from collections import defaultdict
 from ...selection import Selection, FaceSelection
 from ...cs import CoordinateSystem, Axis, GCS, _parse_axis
 from ...coord import Line
 from ...geometry import GeoSurface, GeoObject
-from dataclasses import dataclass
-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, EPS0, MU0
 
-
-
 ############################################################
 #                     UTILITY FUNCTIONS                    #
 ############################################################
@@ -125,6 +123,7 @@ class RobinBC(BoundaryCondition):
     _include_stiff: bool = False
     _include_mass: bool = False
     _include_force: bool = False
+    _isabc: bool = False
 
     def __init__(self, selection: GeoSurface | Selection):
         """A Generalization of any boundary condition of the third kind (Robin).
@@ -264,11 +263,13 @@ class AbsorbingBoundary(RobinBC):
     _include_stiff: bool = True
     _include_mass: bool = True
     _include_force: bool = False
-
+    _isabc: bool = True
+    
     def __init__(self,
                  face: FaceSelection | GeoSurface,
-                 order: int = 1,
-                 origin: tuple | None = None):
+                 order: int = 2,
+                 origin: tuple | None = None,
+                 abctype: Literal['A','B','C','D','E'] = 'B'):
         """Creates an AbsorbingBoundary condition.
 
         Currently only a first order boundary condition is possible. Second order will be supported later.
@@ -286,7 +287,15 @@ class AbsorbingBoundary(RobinBC):
         self.order: int = order
         self.origin: tuple = origin
         self.cs: CoordinateSystem = GCS
-
+        
+        self.abctype: Literal['A','B','C','D','E']  = abctype
+        self.o2coeffs: tuple[float, float] = {'A': (1.0, -0.5),
+                                              'B': (1.00023, -0.51555),
+                                              'C': (1.03084, -0.73631),
+                                              'D': (1.06103, -0.84883),
+                                              'E': (1.12500, -1.00000)
+                                              }
+        
     def get_basis(self) -> np.ndarray:
         return np.eye(3)
 
@@ -306,15 +315,10 @@ class AbsorbingBoundary(RobinBC):
         Returns:
             complex: The γ-constant
         """
-        if self.order == 2:
-            
-            p0 = 1.06103
-            p2 = -0.84883
-            ky = k0*0.5
-            return 1j*k0*p0 - 1j*p2*ky**2/k0
-        else:
-            Factor = 1
-            return 1j*self.get_beta(k0)*Factor
+        if self.order==1:
+            return 1j*k0
+        
+        return 1j*k0*self.o2coeffs[self.abctype][0]
     
    
 @dataclass
@@ -1002,6 +1006,7 @@ class SurfaceImpedance(RobinBC):
                  material: Material | None = None,
                  surface_conductance: float | None = None,
                  surface_roughness: float = 0,
+                 thickness: float | None = None,
                  sr_model: Literal['Hammerstad-Jensen'] = 'Hammerstad-Jensen',
                  ):
         """Generates a SurfaceImpedance bounary condition.
@@ -1021,7 +1026,8 @@ class SurfaceImpedance(RobinBC):
             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'.
+            thickness (float | None, optional): The layer thickness. Defaults to None
+            sr_model (Literal["Hammerstad-Jensen", optional): The surface roughness model. Defaults to 'Hammerstad-Jensen'.
         """
         super().__init__(face)
 
@@ -1029,7 +1035,11 @@ class SurfaceImpedance(RobinBC):
         self._mur: float | complex = 1.0
         self._epsr: float | complex = 1.0
         self.sigma: float = 0.0
+        self.thickness: float | None = thickness
         
+        if isinstance(face, GeoObject) and thickness is None:
+            self.thickness = face._load('thickness')
+            
         if material is not None:
             self.sigma = material.cond.scalar(1e9)
             self._mur = material.ur
@@ -1067,10 +1077,17 @@ class SurfaceImpedance(RobinBC):
         sigma = self.sigma
         mur = self._material.ur.scalar(f0)
         er = self._material.er.scalar(f0)
-        
+        eps = EPS0*er
+        mu = MU0*mur
         rho = 1/sigma
-        d_skin = (2*rho/(w0*MU0*mur) * ((1+(w0*EPS0*er*rho)**2)**0.5 + rho*w0*EPS0*er))**0.5
-        R = rho/d_skin
+        d_skin = (2*rho/(w0*mu) * ((1+(w0*eps*rho)**2)**0.5 + rho*w0*eps))**0.5
+        logger.debug(f'Computed skin depth δ={d_skin*1e6:.2}μm')
+        R = (1+1j)*rho/d_skin
+        if self.thickness is not None:
+            eps_c = eps - 1j * sigma / w0
+            gamma_m = 1j * w0 * np.sqrt(mu*eps_c)
+            R = R / np.tanh(gamma_m * self.thickness)
+            logger.debug(f'Impedance scaler due to thickness: {1/ np.tanh(gamma_m * self.thickness) :.4f}')
         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

@@ -1036,32 +1036,6 @@ class MWField:
             return E[0,:], E[1,:], E[2,:], H[0,:], H[1,:], H[2,:]
     
         return dict(freq=freq, ff_function=function)
-
-    # def surface_integral(self, faces: FaceSelection | GeoSurface, fieldfunction: Callable) -> float | complex:
-    #     """Computes a surface integral on the selected faces. 
-    
-    #     The fieldfunction argument must be a callable of a single argument x, which will
-    #     be of type EHField which is restuned by the field.interpolate(x,y,z) function. It has
-    #     fields like Ez, Ey, Sx etc that can be called. 
-
-    #     Args:
-    #         faces (FaceSelection | GeoSurface): _description_
-    #         fieldfunction (Callable): _description_
-
-    #     Returns:
-    #         float | complex: _description_
-    #     """
-    #     from ...mth.integrals import surface_integral
-        
-    #     def ff(x, y, z):
-    #         fieldobj = self.interpolate(x,y,z)
-    #         return fieldfunction(fieldobj)
-        
-    #     nodes = self.mesh.get_nodes(faces.tags)
-    #     triangles = self.mesh.get_triangles(faces.tags)
-        
-    #     return surface_integral(nodes, triangles, ff)
-        
         
 class MWScalar:
     """The MWDataSet class stores solution data of FEM Time Harmonic simulations.
@@ -1137,6 +1111,9 @@ class MWScalarNdim:
         self._portmap: dict[int, float|int] = dict()
         self._portnumbers: list[int | float] = []
 
+    def dense_f(self, N: int) -> np.ndarray:
+        return np.linspace(np.min(self.freq), np.max(self.freq), N)
+    
     def S(self, i1: int, i2: int) -> np.ndarray:
         return self.Sp[...,self._portmap[i1], self._portmap[i2]]
     

emerge/_emerge/physics/microwave/port_functions.py

@@ -17,11 +17,10 @@
 
 import numpy as np
 from ...elements.nedleg2 import NedelecLegrange2
-from ...mth.integrals import surface_integral
-
 
 def compute_avg_power_flux(field: NedelecLegrange2, mode: np.ndarray, k0: float, ur: np.ndarray, beta: float):
-
+    from ...mth.integrals import surface_integral
+    
     Efunc = field.interpolate_Ef(mode)
     Hfunc = field.interpolate_Hf(mode, k0, ur, beta)
     nx, ny, nz = field.mesh.normals[:,0]
@@ -37,7 +36,8 @@ def compute_avg_power_flux(field: NedelecLegrange2, mode: np.ndarray, k0: float,
     return Ptot
 
 def compute_peak_power_flux(field: NedelecLegrange2, mode: np.ndarray, k0: float, ur: np.ndarray, beta: float):
-
+    from ...mth.integrals import surface_integral
+    
     Efunc = field.interpolate_Ef(mode)
     Hfunc = field.interpolate_Hf(mode, k0, ur, beta)
     nx, ny, nz = field.mesh.normals[:,0]

emerge/_emerge/plot/pyvista/display.py

@@ -435,7 +435,7 @@ class PVDisplay(BaseDisplay):
             return None
 
     ## OBLIGATORY METHODS
-    def add_object(self, obj: GeoObject | Selection, mesh: bool = False, volume_mesh: bool = True, *args, **kwargs):
+    def add_object(self, obj: GeoObject | Selection, mesh: bool = False, volume_mesh: bool = True, label: bool = False, *args, **kwargs):
         
         show_edges = False
         opacity = obj.opacity
@@ -471,7 +471,10 @@ class PVDisplay(BaseDisplay):
                             line_width=line_width, 
                             show_edges=show_edges, 
                             pickable=True, 
+                            smooth_shading=False,
+                            split_sharp_edges=True,
                             style=style)
+        
         mesh_obj = self.mesh(obj)
         
         if mesh is True and volume_mesh is True:
@@ -485,7 +488,15 @@ class PVDisplay(BaseDisplay):
             mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(1,0.5)
         
         self._plot.add_mesh(self._volume_edges(_select(obj)), color='#000000', line_width=2, show_edges=True)
-
+        
+        if isinstance(obj, GeoObject) and label:
+            points = []
+            labels = []
+            for dt in obj.dimtags:
+                points.append(self._mesh.dimtag_to_center[dt])
+                labels.append(obj.name)
+            self._plot.add_point_labels(points, labels, shape_color='white')
+            
     def add_objects(self, *objects, **kwargs) -> None:
         """Add a series of objects provided as a list of arguments
         """

emerge/_emerge/plot/simple_plots.py

@@ -317,6 +317,7 @@ and sparse frequency annotations (e.g., labeled by frequency).
     colors_list  = _broadcast(colors, None, 'colors')
     lw_list      = _broadcast(linewidth, None, 'linewidth')
     labels_list: Optional[List[Optional[str]]]
+    
     if labels is None:
         labels_list = None
     else:
@@ -377,7 +378,9 @@ and sparse frequency annotations (e.g., labeled by frequency).
 
         # frequency labels (sparse)
         fi = fs_list[i]
-        if fi[0] is not None and n_flabels > 0 and len(s) > 0 and len(fi) > 0:
+        if fi is None:
+            continue
+        if n_flabels > 0 and len(s) > 0 and len(fi) > 0:
             n = min(len(s), len(fi))
             step = max(1, int(round(n / n_flabels))) if n_flabels > 0 else n  # avoid step=0
             idx = np.arange(0, n, step)

emerge/_emerge/selection.py

@@ -18,7 +18,6 @@
 from __future__ import annotations
 import gmsh # type: ignore
 import numpy as np
-from scipy.spatial import ConvexHull # type: ignore
 from .cs import Axis, CoordinateSystem, _parse_vector, Plane
 from typing import Callable, TypeVar, Iterable, Any
 
@@ -34,6 +33,8 @@ def align_rectangle_frame(pts3d: np.ndarray, normal: np.ndarray) -> dict[str, An
     """
     
     # 1. centroid
+    from scipy.spatial import ConvexHull # type: ignore
+    
     Omat = np.squeeze(np.mean(pts3d, axis=0))
 
     # 2. build e_x, e_y
@@ -537,9 +538,8 @@ class Selector:
                 x: float,
                 y: float,
                 z: float,
-                nx: float,
-                ny: float,
-                nz: float,
+                normal_axis: Axis | tuple[float, float, float] | None = None,
+                plane: Plane | None = None,
                 tolerance: float = 1e-8) -> FaceSelection:
         """Returns a FaceSelection for all faces that lie in a provided infinite plane
         specified by an origin plus a plane normal vector.
@@ -548,17 +548,20 @@ class Selector:
             x (float): The plane origin X-coordinate
             y (float): The plane origin Y-coordinate
             z (float): The plane origin Z-coordinate
-            nx (float): The plane normal X-component
-            ny (float): The plane normal Y-component
-            nz (float): The plane normal Z-component
+            normal_axis (Axis, tuple): The plane normal vector
             tolerance (float, optional): An in plane tolerance (displacement and normal dot product). Defaults to 1e-6.
 
         Returns:
             FaceSelection: All faces that lie in the specified plane
         """
         orig = np.array([x,y,z])
-        norm = np.array([nx,ny,nz])
-        norm = norm/np.linalg.norm(norm)
+        if plane is not None:
+            norm = plane.normal.np
+        elif normal_axis is not None:
+            norm = _parse_vector(normal_axis)
+            norm = norm/np.linalg.norm(norm)
+        else:
+            raise RuntimeError('No plane or axis defined for selection.')
         
         dimtags = gmsh.model.getEntities(2)
         coords = [gmsh.model.occ.getCenterOfMass(*tag) for tag in dimtags]