emerge 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

emerge/_emerge/plot/pyvista/display.py

@@ -22,7 +22,7 @@ from ...selection import FaceSelection, DomainSelection, EdgeSelection, Selectio
 from ...physics.microwave.microwave_bc import PortBC, ModalPort
 import numpy as np
 import pyvista as pv
-from typing import Iterable, Literal, Callable
+from typing import Iterable, Literal, Callable, Any
 from ..display import BaseDisplay
 from .display_settings import PVDisplaySettings
 from matplotlib.colors import ListedColormap
@@ -155,7 +155,7 @@ def _select(obj: GeoObject | Selection) -> Selection:
         return obj.select
     return obj
 
-def _merge(lst: list[GeoObject | Selection]) -> Selection:
+def _merge(lst: Iterable[GeoObject | Selection]) -> Selection:
     selections = [_select(item) for item in lst]
     dim = selections[0].dim
     all_tags = []
@@ -168,6 +168,8 @@ def _merge(lst: list[GeoObject | Selection]) -> Selection:
         return FaceSelection(all_tags)
     elif dim==3:
         return DomainSelection(all_tags)
+    else:
+        return Selection(all_tags)
 
 class _AnimObject:
     """ A private class containing the required information for plot items in a view
@@ -199,7 +201,7 @@ class PVDisplay(BaseDisplay):
         self._stop: bool = False
         self._objs: list[_AnimObject] = []
         self._do_animate: bool = False
-        self._Nsteps: int = None
+        self._Nsteps: int  = 0
         self._fps: int = 25
         self._ruler: ScreenRuler = ScreenRuler(self, 0.001)
         self._selector: ScreenSelector = ScreenSelector(self)
@@ -208,10 +210,11 @@ class PVDisplay(BaseDisplay):
 
         self._plot = pv.Plotter()
 
-        self._plot.add_key_event("m", self.activate_ruler)
-        self._plot.add_key_event("f", self.activate_object)
+        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
+
     def activate_ruler(self):
         self._plot.disable_picking()
         self._selector.turn_off()
@@ -310,7 +313,7 @@ class PVDisplay(BaseDisplay):
         points = self._mesh.nodes.T
         return pv.UnstructuredGrid(cells, celltypes, points)
     
-    def mesh(self, obj: GeoObject | Selection | Iterable) -> pv.UnstructuredGrid:
+    def mesh(self, obj: GeoObject | Selection | Iterable) -> pv.UnstructuredGrid | None:
         if isinstance(obj, Iterable):
             obj = _merge(obj)
         else:
@@ -320,11 +323,13 @@ class PVDisplay(BaseDisplay):
             return self.mesh_volume(obj)
         elif isinstance(obj, FaceSelection):
             return self.mesh_surface(obj)
+        else:
+            return None
 
     ## OBLIGATORY METHODS
-    def add_object(self, obj: GeoObject | Selection | Iterable, *args, **kwargs):
-        kwargs = setdefault(kwargs, color=obj.color_rgb, opacity=obj.opacity, silhouette=True)
-        self._plot.add_mesh(self.mesh(obj), pickable=True, *args, **kwargs)
+    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)
 
     def add_scatter(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray):
         """Adds a scatter point cloud
@@ -342,8 +347,8 @@ class PVDisplay(BaseDisplay):
                      dv=(0,0,0), 
                      XYZ=None,
                      field: Literal['E','H'] = 'E', 
-                     k0: float = None,
-                     mode_number: int = None) -> pv.UnstructuredGrid:
+                     k0: float | None = None,
+                     mode_number: int | None = None) -> None:
         
         if XYZ:
             X,Y,Z = XYZ
@@ -408,10 +413,10 @@ class PVDisplay(BaseDisplay):
                  field: np.ndarray,
                  scale: Literal['lin','log','symlog'] = 'lin',
                  cmap: cmap_names = 'coolwarm',
-                 clim: tuple[float, float] = None,
+                 clim: tuple[float, float] | None = None,
                  opacity: float = 1.0,
                  symmetrize: bool = True,
-                 _fieldname: str = None,
+                 _fieldname: str | None = None,
                  **kwargs,):
         """Add a surface plot to the display
         The X,Y,Z coordinates must be a 2D grid of data points. The field must be a real field with the same size.
@@ -460,11 +465,11 @@ class PVDisplay(BaseDisplay):
         kwargs = setdefault(kwargs, cmap=cmap, clim=clim, opacity=opacity, pickable=False, multi_colors=True)
         actor = self._plot.add_mesh(grid, scalars=name, **kwargs)
 
-        if self._animate:
+        if self._do_animate:
             def on_update(obj: _AnimObject, phi: complex):
                 field = obj.T(np.real(obj.field*phi))
                 obj.grid['anim'] = field
-            self._objs.append(_AnimObject(field_flat, T, grid, actor, on_update))
+            self._objs.append(_AnimObject(field_flat, T, grid, actor, on_update)) # type: ignore
         
         
     def add_title(self, title: str) -> None:
@@ -481,14 +486,14 @@ class PVDisplay(BaseDisplay):
     def add_text(self, text: str, 
                  color: str = 'black', 
                  position: Literal['lower_left', 'lower_right', 'upper_left', 'upper_right', 'lower_edge', 'upper_edge', 'right_edge', 'left_edge']='upper_right',
-                 abs_position: tuple[float, float, float] = None):
+                 abs_position: tuple[float, float, float] | None = None):
         viewport = False
         if abs_position is not None:
-            position = abs_position
+            final_position = abs_position
             viewport = True
         self._plot.add_text(
             text,
-            position=position,
+            position=final_position,
             color=color,
             font_size=18,
             viewport=viewport)
@@ -496,7 +501,7 @@ class PVDisplay(BaseDisplay):
     def add_quiver(self, x: np.ndarray, y: np.ndarray, z: np.ndarray,
               dx: np.ndarray, dy: np.ndarray, dz: np.ndarray,
               scale: float = 1,
-              color: tuple[float, float, float] = None,
+              color: tuple[float, float, float] | None = None,
               scalemode: Literal['lin','log'] = 'lin'):
         """Add a quiver plot to the display
 
@@ -562,18 +567,18 @@ class PVDisplay(BaseDisplay):
         grid = pv.StructuredGrid(X,Y,Z)
         field = V.flatten(order='F')
         grid['anim'] = np.real(field)
-        levels = np.linspace(vmin, vmax, Nlevels)
+        levels = list(np.linspace(vmin, vmax, Nlevels))
         contour = grid.contour(isosurfaces=levels)
         actor = self._plot.add_mesh(contour, opacity=0.25, cmap=cmap, pickable=False)
 
-        if self._animate:
+        if self._do_animate:
             def on_update(obj: _AnimObject, phi: complex):
                 new_vals = np.real(obj.field * phi)
                 obj.grid['anim'] = new_vals
                 new_contour = obj.grid.contour(isosurfaces=levels)
-                obj.actor.GetMapper().SetInputData(new_contour)
+                obj.actor.GetMapper().SetInputData(new_contour) # type: ignore
             
-            self._objs.append(_AnimObject(field, lambda x: x, grid, actor, on_update))
+            self._objs.append(_AnimObject(field, lambda x: x, grid, actor, on_update)) # type: ignore
 
     def _add_aux_items(self) -> None:
         saved_camera = {
@@ -591,8 +596,8 @@ class PVDisplay(BaseDisplay):
             plane = pv.Plane(
                 center=(0, 0, 0),
                 direction=(1, 0, 0),    # normal vector pointing along +X
-                i_size=length,
-                j_size=length,
+                i_size=length, # type: ignore
+                j_size=length, # type: ignore
                 i_resolution=1,
                 j_resolution=1
             )
@@ -617,8 +622,8 @@ class PVDisplay(BaseDisplay):
             plane = pv.Plane(
                 center=(0, 0, 0),
                 direction=(0, 1, 0),    # normal vector pointing along +X
-                i_size=length,
-                j_size=length,
+                i_size=length, # type: ignore
+                j_size=length, # type: ignore
                 i_resolution=1,
                 j_resolution=1
             )
@@ -642,8 +647,8 @@ class PVDisplay(BaseDisplay):
             plane = pv.Plane(
                 center=(0, 0, 0),
                 direction=(0, 0, 1),    # normal vector pointing along +X
-                i_size=length,
-                j_size=length,
+                i_size=length, # type: ignore
+                j_size=length, # type: ignore
                 i_resolution=1,
                 j_resolution=1
             )
@@ -776,11 +781,11 @@ class PVDisplay(BaseDisplay):
 
         if self.set.add_light:
             light = pv.Light()
-            light.set_direction_angle(*self.set.light_angle)
+            light.set_direction_angle(*self.set.light_angle) # type: ignore
             self._plot.add_light(light)
 
-        self._plot.set_background(self.set.background_bottom, top=self.set.background_top)
-        self._plot.add_axes()
+        self._plot.set_background(self.set.background_bottom, top=self.set.background_top) # type: ignore
+        self._plot.add_axes() # type: ignore
 
         self._plot.camera.position = saved_camera["position"]
         self._plot.camera.focal_point = saved_camera["focal_point"]
@@ -837,7 +842,7 @@ class ScreenSelector:
                 celltypes = np.full(ntris, fill_value=pv.CellType.TRIANGLE, dtype=np.uint8)
                 points = self.disp._mesh.nodes.T
                 grid = pv.UnstructuredGrid(cells, celltypes, points)
-                grid._tag = key
+                grid._tag = key # type: ignore
                 self.grids.append(grid)
                 self.surfs[key] = points[nodes,:].T
         
@@ -856,14 +861,14 @@ class ScreenSelector:
             meany = np.mean(ys)
             meanz = np.mean(zs)
             data = (meanx, meany, meanz, min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
-            encoded = encode_data(data)
+            encoded = encode_data(data) #type: ignore
             print(f'Face code key={key}: ', encoded)
 
         self.disp._plot.enable_mesh_picking(callback, style='surface', left_clicking=True, use_actor=True)
     
     def turn_off(self) -> None:
         for actor in self.select_actors:
-            self.disp._plot.remove_actor(actor)
+            self.disp._plot.remove_actor(actor) # type: ignore
         self.select_actors = []
         for actor in self.original_actors:
             if isinstance(actor, pv.Text):
@@ -876,9 +881,9 @@ class ScreenRuler:
     def __init__(self, display: PVDisplay, min_length: float):
         self.disp: PVDisplay = display
         self.points: list[tuple] = [(0,0,0),(0,0,0)]
-        self.text: pv.Text = None
-        self.ruler = None
-        self.state = False
+        self.text: pv.Text | None = None
+        self.ruler: Any = None
+        self.state: bool = False
         self.min_length: float = min_length
     
     @freeze
@@ -916,7 +921,7 @@ class ScreenRuler:
     
     def set_ruler(self) -> None:
         if self.ruler is None:
-            self.ruler = self.disp._plot.add_ruler(self.points[0], self.points[1], title=f'{1000*self.dist:.2f}mm')
+            self.ruler = self.disp._plot.add_ruler(self.points[0], self.points[1], title=f'{1000*self.dist:.2f}mm') # type: ignore
         else:
             p1 = self.ruler.GetPositionCoordinate()
             p2 = self.ruler.GetPosition2Coordinate()

emerge/_emerge/plot/pyvista/display_settings.py

@@ -17,7 +17,7 @@ class PVDisplaySettings:
         self.show_zgrid: bool = True
         self.grid_line_width: float = 1.0
         self.add_light: bool = False
-        self.light_angle: float = (20, -20)
+        self.light_angle: tuple[float, float] = (20., -20.)
         self.cast_shadows: bool = True
         self.background_bottom: str = "#c0d2e8"
         self.background_top: str = "#ffffff"

emerge/_emerge/plot/simple_plots.py

@@ -36,7 +36,7 @@ ggplot_styles = {
 
 plt.rcParams.update(ggplot_styles)
 
-def _gen_grid(xs: tuple, ys: tuple, N = 201) -> list[np.ndarray]:
+def _gen_grid(xs: tuple, ys: tuple, N = 201) -> list[tuple[np.ndarray, np.ndarray]]:
     """Generate a grid of lines for the Smith Chart
 
     Args:
@@ -279,18 +279,18 @@ def smith(f: np.ndarray, S: np.ndarray) -> None:
 def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray, 
                       dblim=[-40, 5], 
                     xunit="GHz", 
-                    levelindicator: int | float =None, 
+                    levelindicator: int | float | None = None, 
                     noise_floor=-150, 
-                    fill_areas: list[tuple]= None, 
-                    spec_area: list[tuple[float]] = None,
+                    fill_areas: list[tuple] | None = None, 
+                    spec_area: list[tuple[float,...]] | None = None,
                     unwrap_phase=False, 
                     logx: bool = False,
-                    labels: list[str] = None,
-                    linestyles: list[str] = None,
-                    colorcycle: list[int] = None,
-                    filename: str = None,
+                    labels: list[str] | None = None,
+                    linestyles: list[str] | None = None,
+                    colorcycle: list[int] | None = None,
+                    filename: str | None = None,
                     show_plot: bool = True,
-                    figdata: tuple = None) -> None:
+                    figdata: tuple | None = None) -> tuple[plt.Figure, plt.Axes, plt.Axes]:
     """Plot S-parameters in dB and phase
 
     Args:
@@ -321,7 +321,7 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
     if colorcycle is None:
         colorcycle = [i for i, S in enumerate(S)]
 
-    unitdivider = {"MHz": 1e6, "GHz": 1e9, "kHz": 1e3}
+    unitdivider: dict[str, float] = {"MHz": 1e6, "GHz": 1e9, "kHz": 1e3}
     fnew = f / unitdivider[xunit]
 
     if figdata is None:
@@ -372,14 +372,14 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
     # Configure magnitude plot (ax_mag)
     ax_mag.set_ylabel("Magnitude (dB)")
     ax_mag.set_xlabel(f"Frequency ({xunit})")
-    ax_mag.axis([min(fnew), max(fnew), dblim[0], max(maxy*1.1,dblim[1])])
+    ax_mag.axis([min(fnew), max(fnew), dblim[0], max(maxy*1.1,dblim[1])]) # type: ignore
     ax_mag.axhline(y=0, color="k", linewidth=1)
     ax_mag.xaxis.set_minor_locator(tck.AutoMinorLocator(2))
     ax_mag.yaxis.set_minor_locator(tck.AutoMinorLocator(2))
     # Configure phase plot (ax_phase)
     ax_phase.set_ylabel("Phase (degrees)")
     ax_phase.set_xlabel(f"Frequency ({xunit})")
-    ax_phase.axis([min(fnew), max(fnew), minphase, maxphase])
+    ax_phase.axis([min(fnew), max(fnew), minphase, maxphase]) # type: ignore
     ax_phase.xaxis.set_minor_locator(tck.AutoMinorLocator(2))
     ax_phase.yaxis.set_minor_locator(tck.AutoMinorLocator(2))
     if logx:
@@ -532,9 +532,9 @@ def plot_ff_polar(
     markers = _broadcast(markers, None) if markers is not None else [None] * n_series
 
     fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
-    ax.set_theta_zero_location(zero_location)
-    ax.set_theta_direction(-1 if clockwise else 1)
-    ax.set_rlabel_position(rlabel_angle)
+    ax.set_theta_zero_location(zero_location) # type: ignore
+    ax.set_theta_direction(-1 if clockwise else 1) # type: ignore
+    ax.set_rlabel_position(rlabel_angle) # type: ignore
 
     for i, Ei in enumerate(E_list):
         mag = np.abs(Ei)

emerge/_emerge/selection.py

@@ -16,13 +16,13 @@
 # <https://www.gnu.org/licenses/>.
 
 from __future__ import annotations
-import gmsh
+import gmsh # type: ignore
 import numpy as np
-from scipy.spatial import ConvexHull
+from scipy.spatial import ConvexHull # type: ignore
 from .cs import Axis, CoordinateSystem, _parse_vector, Plane
-from typing import Callable, TypeVar
+from typing import Callable, TypeVar, Iterable, Any
 
-def align_rectangle_frame(pts3d: np.ndarray, normal: np.ndarray) -> dict[str, np.ndarray]:
+def align_rectangle_frame(pts3d: np.ndarray, normal: np.ndarray) -> dict[str, Any]:
     """Tries to find a rectangle as convex-hull of a set of points with a given normal vector.
 
     Args:
@@ -66,9 +66,9 @@ def align_rectangle_frame(pts3d: np.ndarray, normal: np.ndarray) -> dict[str, np
         xmax, ymax = rot.max(axis=0)
         area = (xmax-xmin)*(ymax-ymin)
         if area < best[1]:
-            best = (theta, area, (xmin,xmax,ymin,ymax), R)
+            best = (theta, area, (xmin,xmax,ymin,ymax), R) # type: ignore
 
-    theta, _, (xmin,xmax,ymin,ymax), R = best
+    theta, _, (xmin,xmax,ymin,ymax), R = best # type: ignore
 
     # 6. rectangle axes in 3D
     u =  np.cos(-theta)*e_x + np.sin(-theta)*e_y
@@ -172,9 +172,9 @@ class Selection:
 
     """
     dim: int = -1
-    def __init__(self, tags: list[int] = None):
+    def __init__(self, tags: list[int] | set[int] | tuple[int] | None = None):
 
-        self._tags: set[int] = {}
+        self._tags: set[int] = set()
 
         if tags is not None:
             if not isinstance(tags, (list,set,tuple)):
@@ -182,7 +182,7 @@ class Selection:
             self._tags = set(tags)
     
     @staticmethod
-    def from_dim_tags(dim: int, tags: list[int]) -> DomainSelection | PointSelection | FaceSelection | EdgeSelection:
+    def from_dim_tags(dim: int, tags: list[int] | set[int]) -> Selection:
         if dim==0:
             return PointSelection(tags)
         elif dim==1:
@@ -198,7 +198,7 @@ class Selection:
         return list(self._tags)
     
     @property
-    def color_rgb(self) -> tuple[int,int,int]:
+    def color_rgb(self) -> tuple[float, float, float]:
         return (0.5,0.5,1.0)
     
     @property
@@ -225,14 +225,14 @@ class Selection:
             return [gmsh.model.occ.getCenterOfMass(self.dim, tag) for tag in self.tags]
     
     @property
-    def points(self) -> np.ndarray | list[np.ndarray]:
+    def points(self) -> list[np.ndarray]:
         '''A list of 3D coordinates of all nodes comprising the selection.'''
         points = gmsh.model.get_boundary(self.dimtags, recursive=True)
         coordinates = [gmsh.model.getValue(*p, []) for p in points]
         return coordinates
     
     @property
-    def bounding_box(self) -> tuple[np.ndarray, np.ndarray]:
+    def bounding_box(self) -> tuple[Iterable, Iterable]:
         if len(self.tags)==1:
             return gmsh.model.occ.getBoundingBox(self.dim, self.tags[0])
         else:
@@ -248,7 +248,7 @@ class Selection:
                 maxz = max(maxz, z1)
             return (minx, miny, minz), (maxx, maxy, maxz)
         
-    def exclude(self, xyz_excl_function: Callable = lambda x,y,z: True, plane: Plane = None, axis: Axis = None) -> Selection:
+    def exclude(self, xyz_excl_function: Callable = lambda x,y,z: True, plane: Plane | None = None, axis: Axis | None = None) -> Selection:
         """Exclude points by evaluating a function(x,y,z)-> bool
 
         This modifies the selection such that the selection does not contain elements
@@ -266,10 +266,10 @@ class Selection:
             norm = axis.np
             include2 = [abs(gmsh.model.getNormal(tag, np.array([0,0]))@norm)<0.9 for tag in self.tags]
             include = [i1 for i1, i2 in zip(include, include2) if i1 and i2]
-        self._tags = [t for incl, t in zip(include, self._tags) if incl]
+        self._tags = set([t for incl, t in zip(include, self._tags) if incl])
         return self
     
-    def isolate(self, xyz_excl_function: Callable = lambda x,y,z: True, plane: Plane = None, axis: Axis = None) -> Selection:
+    def isolate(self, xyz_excl_function: Callable = lambda x,y,z: True, plane: Plane | None = None, axis: Axis | None = None) -> Selection:
         """Include points by evaluating a function(x,y,z)-> bool
 
         This modifies the selection such that the selection does not contain elements
@@ -287,7 +287,7 @@ class Selection:
             norm = axis.np
             include2 = [(gmsh.model.getNormal(tag, np.array([0,0]))@norm)>0.99 for tag in self.tags]
             include1 = [i1 for i1, i2 in zip(include1, include2) if i1 and i2]
-        self._tags = [t for incl, t in zip(include1, self._tags) if incl]
+        self._tags = set([t for incl, t in zip(include1, self._tags) if incl])
         return self
 
     def __operable__(self, other: Selection) -> None:
@@ -295,30 +295,28 @@ class Selection:
             raise ValueError(f'Selection dimensions must be equal. Trying to operate on dim {self.dim} and {other.dim}')
         pass
 
-    def __add__(self, other: TSelection) -> TSelection:
+    def __add__(self, other: Selection) -> Selection:
         self.__operable__(other)
-        return Selection.from_dim_tags(self.dim, self._tags + other._tags)
+        return Selection.from_dim_tags(self.dim, self._tags.union(other._tags))
     
-    def __and__(self, other: TSelection) -> TSelection:
+    def __and__(self, other: Selection) -> Selection:
         self.__operable__(other)
         return Selection.from_dim_tags(self.dim, self._tags.intersection(other._tags))
     
-    def __or__(self, other: TSelection) -> TSelection:
+    def __or__(self, other: Selection) -> Selection:
         self.__operable__(other)
         return Selection.from_dim_tags(self.dim, self._tags.union(other._tags))
     
-    def __sub__(self, other: TSelection) -> TSelection:
+    def __sub__(self, other: Selection) -> Selection:
         self.__operable__(other)
         return Selection.from_dim_tags(self.dim, self._tags.difference(other.tags))
-    
-
 
 class PointSelection(Selection):
     """A Class representing a selection of points.
 
     """
     dim: int = 0
-    def __init__(self, tags: list[int] = None):
+    def __init__(self, tags: list[int] | set [int] | None = None):
         super().__init__(tags)
 
 class EdgeSelection(Selection):
@@ -326,7 +324,7 @@ class EdgeSelection(Selection):
 
     """
     dim: int = 1
-    def __init__(self, tags: list[int] = None):
+    def __init__(self, tags: list[int] | set [int] | None = None):
         super().__init__(tags)
 
 class FaceSelection(Selection):
@@ -334,7 +332,7 @@ class FaceSelection(Selection):
 
     """
     dim: int = 2
-    def __init__(self, tags: list[int] = None):
+    def __init__(self, tags: list[int] | set [int] | None = None):
         super().__init__(tags)
 
     @property
@@ -355,14 +353,14 @@ class FaceSelection(Selection):
         
         pts3d = self.points
         normal = self.normal
-        data = align_rectangle_frame(pts3d, normal)
+        data = align_rectangle_frame(np.array(pts3d), normal)
         plane = data['axes'][:2]
         origin = data['origin']
 
         cs = CoordinateSystem(Axis(plane[0]), Axis(plane[1]), Axis(data['axes'][2]), origin)
 
-        size1 = np.linalg.norm(data['corners'][1] - data['corners'][0])
-        size2 = np.linalg.norm(data['corners'][2] - data['corners'][0])
+        size1 = float(np.linalg.norm(data['corners'][1] - data['corners'][0]))
+        size2 = float(np.linalg.norm(data['corners'][2] - data['corners'][0]))
 
         if size1>size2:
             cs.swapxy()
@@ -382,7 +380,7 @@ class FaceSelection(Selection):
                 a NxN numpy array of Y coordinates.
             Z: np.ndarray
                 a NxN numpy array of Z coordinates'''
-        coordset = []
+        coordset: list[tuple[np.ndarray, np.ndarray, np.ndarray]] = []
         for tag in self.tags:
             tags, coord, param = gmsh.model.mesh.getNodes(2, tag, includeBoundary=True)
             
@@ -419,17 +417,15 @@ class FaceSelection(Selection):
         Y = [c[1] for c in coordset]
         Z = [c[2] for c in coordset]
         if len(X) == 1:
-            X = X[0]
-            Y = Y[0]
-            Z = Z[0]
-        return X, Y, Z
+            return X[0], Y[0], Z[0]
+        return np.array(X), np.array(Y), np.array(Z)
     
 class DomainSelection(Selection):
     """A Class representing a selection of domains.
 
     """
     dim: int = 3
-    def __init__(self, tags: list[int] = None):
+    def __init__(self, tags: list[int] | set[int] | None = None):
         super().__init__(tags)
 
 SELECT_CLASS: dict[int, type[Selection]] = {
@@ -501,7 +497,7 @@ class Selector:
                 x: float,
                 y: float,
                 z: float,
-                vector: tuple[float, float, float] | np.ndarray | Axis) -> FaceSelection | EdgeSelection | DomainSelection:
+                vector: tuple[float, float, float] | np.ndarray | Axis) -> Selection:
         '''Returns a list of selections that are in the layer defined by the plane normal vector and the point (x,y,z)
         
         The layer is specified by two infinite planes normal to the provided vector. The first plane is originated
@@ -529,7 +525,7 @@ class Selector:
         output = []
         for i, c in enumerate(coords):
             c_local = c - np.array([x,y,z])
-            if 0 < np.dot(vector, c_local) < L:
+            if 0 < np.dot(vector, c_local) < L: # type: ignore
                 output.append(dimtags[i][1])
         return SELECT_CLASS[self._current_dim](output)
     
@@ -565,8 +561,8 @@ class Selector:
         normals = [gmsh.model.get_normal(t, (0,0)) for d,t, in dimtags]
         tags = []
         for (d,t), o, n in zip(dimtags, coords, normals):
-            normdist = np.abs((o-orig)@norm)
-            dotnorm = np.abs(n@norm)
+            normdist = np.abs((o-orig) @ norm)
+            dotnorm = np.abs(n @ norm)
             if normdist < tolerance and dotnorm > 1-tolerance:
                 tags.append(t)
         return FaceSelection(tags)