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

emerge/_emerge/geometry.py

@@ -33,6 +33,7 @@ def _map_tags(tags: list[int], mapping: dict[int, list[int]]):
 
 def _bbcenter(x1, y1, z1, x2, y2, z2):
     return np.array([(x1+x2)/2, (y1+y2)/2, (z1+z2)/2])
+
 FaceNames = Literal['back','front','left','right','top','bottom']
 
 class _KEY_GENERATOR:
@@ -47,8 +48,9 @@ class _KEY_GENERATOR:
 class _GeometryManager:
 
     def __init__(self):
-        self.geometry_list: dict[str, list[GeoObject]] = dict()
+        self.geometry_list: dict[str, dict[str, GeoObject]] = dict()
         self.active: str = ''
+        self.geometry_names: dict[str, set[str]] = dict()
 
     def get_surfaces(self) -> list[GeoSurface]:
         return [geo for geo in self.all_geometries() if geo.dim==2]
@@ -56,23 +58,40 @@ class _GeometryManager:
     def all_geometries(self, model: str | None = None) -> list[GeoObject]:
         if model is None:
             model = self.active
-        return [geo for geo in self.geometry_list[model] if geo._exists]
+        return [geo for geo in self.geometry_list[model].values() if geo._exists]
 
+    def all_names(self, model: str | None = None) -> set[str]:
+        if model is None:
+            model = self.active
+        return self.geometry_names[model]
+    
+    def get_name(self, suggestion: str, model: str | None = None) -> str:
+        names = self.all_names(model)
+        if suggestion not in names:
+            return suggestion
+        for i in range(1_000_000):
+            if f'{suggestion}_{i}' not in names:
+                return f'{suggestion}_{i}'
+        raise RuntimeError('Cannot generate a unique name.')
+        
     def submit_geometry(self, geo: GeoObject, model: str | None = None) -> None:
         if model is None:
             model = self.active
-        self.geometry_list[model].append(geo)
+        self.geometry_list[model][geo.name] = geo
+        self.geometry_names[model].add(geo.name)
 
     def sign_in(self, modelname: str) -> None:
         # if modelname not in self.geometry_list:
         #     self.geometry_list[modelname] = []
         if modelname is self.geometry_list:
             logger.warning(f'{modelname} already exist, Geometries will be reset.')
-        self.geometry_list[modelname] = []
+        self.geometry_list[modelname] = dict()
+        self.geometry_names[modelname] = set()
         self.active = modelname
 
     def reset(self, modelname: str) -> None:
-        self.geometry_list[modelname] = []
+        self.geometry_list[modelname] = dict()
+        self.geometry_names[modelname] = set()
     
     def lowest_priority(self) -> int:
         return min([geo._priority for geo in self.all_geometries()])
@@ -219,7 +238,8 @@ class GeoObject:
     """A generalization of any OpenCASCADE entity described by a dimension and a set of tags.
     """
     dim: int = -1
-    def __init__(self, tags: list[int] | None = None):
+    _default_name: str = 'GeoObject'
+    def __init__(self, tags: list[int] | None = None, name: str | None = None):
         if tags is None:
             tags = []
         self.old_tags: list[int] = []
@@ -238,18 +258,63 @@ class GeoObject:
         self._priority: int = 10
 
         self._exists: bool = True
+        
+        self.give_name(name)
         _GEOMANAGER.submit_geometry(self)
 
+    def _store(self, name: str, data: Any) -> None:
+        """Store a property as auxilliary data under a given name
+
+        Args:
+            name (str): Name field
+            data (Any): Data to store
+        """
+        self._aux_data[name] = data
+
+    def _load(self, name: str) -> Any | None:
+        """Load data with a given name. If it doesn't exist, it returns None
+
+        Args:
+            name (str): The property to retreive
+
+        Returns:
+            Any | None: The property
+        """
+        return self._aux_data.get(name, None)
+    
+    def give_name(self, name: str | None = None) -> GeoObject:
+        """Assign a name to this object
+
+        Args:
+            name (str | None, optional): The name for the object. Defaults to None.
+        """
+        if name is None:
+            name = self._default_name
+        self.name: str = _GEOMANAGER.get_name(name)
+        return self
+    
     @property
     def color_rgb(self) -> tuple[float, float, float]:
+        """The color of the object in RGB float tuple
+
+        Returns:
+            tuple[float, float, float]: The color
+        """
         return self.material.color_rgb
     
     @property
     def opacity(self) -> float:
+        """The opacity of the object
+
+        Returns:
+            float: The opacity
+        """
         return self.material.opacity
     
     @property
     def _metal(self) -> bool:
+        """If the material should be rendered as metal
+        """
         return self.material._metal
     
     @property
@@ -266,6 +331,14 @@ class GeoObject:
     
     @staticmethod
     def merged(objects: list[GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject]) -> list[GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject] | GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject:
+        """Create a GeoObject by merging an iterable of GeoObjects
+
+        Args:
+            objects (list[GeoPoint  |  GeoEdge  |  GeoSurface  |  GeoVolume  |  GeoObject]): A list of geo objects
+
+        Returns:
+            GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject: The resultant object
+        """
         dim = objects[0].dim
         tags = []
         out: GeoObject | None = None
@@ -291,6 +364,17 @@ class GeoObject:
                           origin: np.ndarray | None = None,
                           normal: np.ndarray | None = None,
                           tag: int | None = None):
+        """Adds a face identifier (face pointer) to this object
+
+        Args:
+            name (str): The name for the face
+            origin (np.ndarray | None, optional): A point on the object. Defaults to None.
+            normal (np.ndarray | None, optional): The normal of the face. Defaults to None.
+            tag (int | None, optional): The tace tag used to extract the origin and normal. Defaults to None.
+
+        Raises:
+            ValueError: _description_
+        """
         if tag is not None:
             o = gmsh.model.occ.get_center_of_mass(2, tag)
             n = gmsh.model.get_normal(tag, (0,0))
@@ -302,6 +386,7 @@ class GeoObject:
         raise ValueError('Eitehr a tag or an origin + normal must be provided!')
     
     def make_copy(self) -> GeoObject:
+        """ Copies this object and returns a new object (also in GMSH)"""
         new_dimtags = gmsh.model.occ.copy(self.dimtags)
         new_obj = GeoObject.from_dimtags(new_dimtags)
         new_obj.material = self.material
@@ -319,6 +404,11 @@ class GeoObject:
         return new_obj
 
     def replace_tags(self, tagmap: dict[int, list[int]]):
+        """Replaces the GMSH tags assigned to this objects
+
+        Args:
+            tagmap (dict[int, list[int]]): A map that shows which tag is mapped to which set of new tags.
+        """
         self.old_tags = self.tags
         newtags = []
         for tag in self.tags:
@@ -454,7 +544,9 @@ class GeoObject:
         self._priority = _GEOMANAGER.highest_priority()+10
         return self
     
-    def boundary(self, exclude: tuple[FaceNames,...] | None = None, tags: list[int] | None = None) -> FaceSelection:
+    def boundary(self, exclude: tuple[FaceNames,...] | None = None, 
+                 tags: list[int] | None = None,
+                 tool: GeoObject | None = None) -> FaceSelection:
         """Returns the complete set of boundary faces.
 
         If implemented, it is possible to exclude a set of faces based on their name
@@ -471,7 +563,7 @@ class GeoObject:
         
         
         for name in exclude:
-            tags.extend(self.face(name).tags)
+            tags.extend(self.face(name, tool=tool).tags)
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
         return FaceSelection([t for d,t in dimtags if t not in tags])
     
@@ -535,8 +627,10 @@ class GeoVolume(GeoObject):
     '''GeoVolume is an interface to the GMSH CAD kernel. It does not represent EMerge
     specific geometry data.'''
     dim = 3
-    def __init__(self, tag: int | Iterable[int]):
-        super().__init__()
+    _default_name: str = 'GeoVolume'
+    def __init__(self, tag: int | Iterable[int], name: str | None = None):
+        super().__init__(name=name)
+        
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
             self.tags = list(tag)
@@ -549,13 +643,14 @@ class GeoVolume(GeoObject):
     
 class GeoPoint(GeoObject):
     dim = 0
-
+    _default_name: str = 'GeoPoint'
+    
     @property
     def selection(self) -> PointSelection:
         return PointSelection(self.tags)
     
-    def __init__(self, tag: int | list[int]):
-        super().__init__()
+    def __init__(self, tag: int | list[int], name: str | None = None):
+        super().__init__(name=name)
 
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
@@ -565,13 +660,14 @@ class GeoPoint(GeoObject):
 
 class GeoEdge(GeoObject):
     dim = 1
-
+    _default_name: str = 'GeoEdge'
+    
     @property
     def selection(self) -> EdgeSelection:
         return EdgeSelection(self.tags)
     
-    def __init__(self, tag: int | list[int]):
-        super().__init__()
+    def __init__(self, tag: int | list[int], name: str | None = None):
+        super().__init__(name=name)
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
             self.tags = list(tag)
@@ -583,13 +679,14 @@ class GeoSurface(GeoObject):
     '''GeoVolume is an interface to the GMSH CAD kernel. It does not reprsent Emerge
     specific geometry data.'''
     dim = 2
-
+    _default_name: str = 'GeoSurface'
+    
     @property
     def selection(self) -> FaceSelection:
         return FaceSelection(self.tags)
     
-    def __init__(self, tag: int | list[int]):
-        super().__init__()
+    def __init__(self, tag: int | list[int], name: str | None = None):
+        super().__init__(name=name)
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
             self.tags = list(tag)
@@ -597,10 +694,12 @@ class GeoSurface(GeoObject):
             self.tags = [tag,]
 
 class GeoPolygon(GeoSurface):
+    _default_name: str = 'GeoPolygon'
     
     def __init__(self,
-                 tags: list[int]):
-        super().__init__(tags)
+                 tags: list[int],
+                 name: str | None = None):
+        super().__init__(tags, name=name)
         self.points: list[int] = []
         self.lines: list[int] = []
 

emerge/_emerge/mesh3d.py

@@ -122,7 +122,6 @@ class Mesh3D(Mesh):
         self.inv_tets: dict = dict()
 
         # Mappings
-
         self.tet_to_edge: np.ndarray = np.array([])
         self.tet_to_edge_sign: np.ndarray = np.array([])
         self.tet_to_tri: np.ndarray = np.array([])
@@ -133,7 +132,6 @@ class Mesh3D(Mesh):
         self.node_to_edge: defaultdict | dict = defaultdict()
 
         # Physics mappings
-
         self.tet_to_field: np.ndarray = np.array([])
         self.edge_to_field: np.ndarray = np.array([])
         self.tri_to_field: np.ndarray = np.array([])
@@ -149,6 +147,10 @@ class Mesh3D(Mesh):
         self.vtag_to_tet:  dict[int, list[int]] = dict()
         self.etag_to_edge: dict[int, list[int]] = dict()
         
+        ## Dervied
+        self.dimtag_to_center: dict[tuple[int, int], tuple[float, float, float]] = dict()
+        self.dimtag_to_edges: dict[tuple[int, int], np.ndarray] = dict()
+        
         self.exterior_face_tags: list[int] = []
     
     @property
@@ -242,7 +244,7 @@ class Mesh3D(Mesh):
 
         return np.array(indices)
     
-    def domain_edges(self, dimtags: list[tuple[int,int]]) -> np.ndarray:
+    def _domain_edge(self, dimtag: tuple[int,int]) -> np.ndarray:
         """Returns a np.ndarray of all edge indices corresponding to a set of dimension tags.
 
         Args:
@@ -252,21 +254,39 @@ class Mesh3D(Mesh):
             np.ndarray: The list of mesh edge element indices.
         """
         dimtags_edge = []
-        for (d,t) in dimtags:
-            if d==1:
-                dimtags_edge.append(t)
-            if d==2:
-                dimtags_edge.extend(gmsh.model.getBoundary([(d,t),], False, False))
-            if d==3:
-                dts = gmsh.model.getBoundary([(d,t),], False, False)
-                dimtags_edge.extend(gmsh.model.getBoundary(dts, False, False))
-        
+        d,t = dimtag
+        if d==0:
+            return np.ndarray([], dtype=np.int64)
+        if d==1:
+            dimtags_edge.append((1,t))
+        if d==2:
+            dimtags_edge.extend(gmsh.model.getBoundary([(d,t),], False, False))
+        if d==3:
+            dts = gmsh.model.getBoundary([(d,t),], False, False)
+            dimtags_edge.extend(gmsh.model.getBoundary(dts, False, False))
+    
         edge_ids = []
         for tag in dimtags_edge:
             edge_ids.extend(self.etag_to_edge[tag[1]])
         edge_ids = np.array(edge_ids)
         return edge_ids
+    
+    def domain_edges(self, dimtags: list[tuple[int,int]]) -> np.ndarray:
+        """Returns a np.ndarray of all edge indices corresponding to a set of dimension tags.
+
+        Args:
+            dimtags (list[tuple[int,int]]): A list of dimtags.
+
+        Returns:
+            np.ndarray: The list of mesh edge element indices.
+        """
         
+        edge_ids = []
+        for dt in dimtags:
+            edge_ids.extend(self.dimtag_to_edges[dt])
+        edge_ids = np.array(edge_ids)
+        return edge_ids
+    
     def get_face_tets(self, *taglist: list[int]) -> np.ndarray:
         ''' Return a list of a tetrahedrons that share a node with any of the nodes in the provided face.'''
         nodes: set = set()
@@ -487,6 +507,13 @@ class Mesh3D(Mesh):
             self.vtag_to_tet[t] = [self.get_tet(node_tags[0,i], node_tags[1,i], node_tags[2,i], node_tags[3,i]) for i in range(node_tags.shape[1])]
 
         self.defined = True
+        
+        for dim in (0,1,2,3):
+            dts= gmsh.model.get_entities(dim)
+            for dt in dts:
+                self.dimtag_to_center[dt] = gmsh.model.occ.get_center_of_mass(*dt)
+                self.dimtag_to_edges[dt] = self._domain_edge(dt)
+                
         logger.trace('Done analyzing mesh.')
 
 

emerge/_emerge/periodic.py

@@ -16,7 +16,7 @@
 # <https://www.gnu.org/licenses/>.
 
 from .cs import Axis, _parse_axis, GCS, _parse_vector
-from .selection import SELECTOR_OBJ, Selection
+from .selection import SELECTOR_OBJ, Selection, FaceSelection
 from .geo import GeoPrism, XYPolygon, Alignment, XYPlate
 from .bc import BoundaryCondition
 from typing import Generator
@@ -50,8 +50,8 @@ def _pair_selection(f1: Selection,
     for t1, c1 in zip(f1.tags, c1s):
         for t2, c2 in zip(f2.tags, c2s):
             if np.linalg.norm((c1 + ds)-c2) < 1e-8:
-                f1s.append(Selection([t1,]))
-                f2s.append(Selection([t2,]))
+                f1s.append(FaceSelection([t1,]))
+                f2s.append(FaceSelection([t2,]))
     return f1s, f2s
 
 
@@ -69,7 +69,7 @@ class PeriodicCell:
 
         self.origins: list[tuple[float, float, float]] = [_parse_vector(origin) for origin in origins] # type: ignore
         self.vectors: list[Axis] = [_parse_axis(vec) for vec in vectors]
-        self.excluded_faces: Selection | None = None
+        self.included_faces: Selection | None = None
         self._bcs: list[Periodic] = []
         self._ports: list[BoundaryCondition] = []
 
@@ -105,9 +105,11 @@ class PeriodicCell:
         for f1, f2, a in self.cell_data():
             f1_new = f1
             f2_new = f2
-            if self.excluded_faces is not None:
-                f1_new = f1 - self.excluded_faces # type: ignore
-                f2_new = f2 - self.excluded_faces # type: ignore
+            if self.included_faces is not None:
+                f1_new = f1 & self.included_faces # type: ignore
+                f2_new = f2 & self.included_faces # type: ignore
+            if len(f1_new.tags)==0:
+                continue
             bcs.append(Periodic(f1_new, f2_new, tuple(a)))
         self._bcs = bcs
         return bcs
@@ -191,16 +193,16 @@ class RectCell(PeriodicCell):
         return XYPlate(self.width, self.height, position=(0,0,z), alignment=Alignment.CENTER)
         
     def cell_data(self):
-        f1s = SELECTOR_OBJ.inplane(*self.fleft[0], *self.fleft[1])
-        f2s = SELECTOR_OBJ.inplane(*self.fright[0], *self.fright[1])
+        f1s = SELECTOR_OBJ.inplane(*self.fleft[0], self.fleft[1])
+        f2s = SELECTOR_OBJ.inplane(*self.fright[0], self.fright[1])
         vec = (self.fright[0][0]-self.fleft[0][0], 
                self.fright[0][1]-self.fleft[0][1], 
                self.fright[0][2]-self.fleft[0][2])
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)):
             yield f1, f2, vec
 
-        f1s = SELECTOR_OBJ.inplane(*self.fbot[0], *self.fbot[1])
-        f2s = SELECTOR_OBJ.inplane(*self.ftop[0], *self.ftop[1])
+        f1s = SELECTOR_OBJ.inplane(*self.fbot[0], self.fbot[1])
+        f2s = SELECTOR_OBJ.inplane(*self.ftop[0], self.ftop[1])
         vec = (self.ftop[0][0]-self.fbot[0][0], 
                self.ftop[0][1]-self.fbot[0][1], 
                self.ftop[0][2]-self.fbot[0][2])
@@ -273,9 +275,9 @@ class HexCell(PeriodicCell):
         o = self.o1[:-1]
         n = self.f11[1][:-1]
         w = nrm(self.p2-self.p1)/2
-        f1s = SELECTOR_OBJ.inplane(*self.f11[0], *self.f11[1])\
+        f1s = SELECTOR_OBJ.inplane(*self.f11[0], self.f11[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
-        f2s = SELECTOR_OBJ.inplane(*self.f12[0], *self.f12[1])\
+        f2s = SELECTOR_OBJ.inplane(*self.f12[0], self.f12[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
         vec = - (self.p1 + self.p2)
 
@@ -285,9 +287,9 @@ class HexCell(PeriodicCell):
         o = self.o2[:-1]
         n = self.f21[1][:-1]
         w = nrm(self.p3-self.p2)/2
-        f1s = SELECTOR_OBJ.inplane(*self.f21[0], *self.f21[1])\
+        f1s = SELECTOR_OBJ.inplane(*self.f21[0], self.f21[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
-        f2s = SELECTOR_OBJ.inplane(*self.f22[0], *self.f22[1])\
+        f2s = SELECTOR_OBJ.inplane(*self.f22[0], self.f22[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
         vec = - (self.p2 + self.p3)
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)): # type: ignore
@@ -296,9 +298,9 @@ class HexCell(PeriodicCell):
         o = self.o3[:-1]
         n = self.f31[1][:-1]
         w = nrm(-self.p1-self.p3)/2
-        f1s = SELECTOR_OBJ.inplane(*self.f31[0], *self.f31[1])\
+        f1s = SELECTOR_OBJ.inplane(*self.f31[0], self.f31[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
-        f2s = SELECTOR_OBJ.inplane(*self.f32[0], *self.f32[1])\
+        f2s = SELECTOR_OBJ.inplane(*self.f32[0], self.f32[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
         vec = - (self.p3 - self.p1)
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)): # type: ignore

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -1002,6 +1002,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 +1022,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 +1031,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 +1073,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

@@ -1137,6 +1137,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/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
@@ -486,6 +486,14 @@ class PVDisplay(BaseDisplay):
         
         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

@@ -537,9 +537,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 +547,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]