acoular 25.7__py3-none-any.whl → 26.1__py3-none-any.whl

acoular/grids.py

@@ -4,6 +4,24 @@
 """
 Implement support for multidimensional grids and integration sectors.
 
+.. inheritance-diagram::
+                acoular.grids.Grid
+                acoular.grids.RectGrid
+                acoular.grids.RectGrid3D
+                acoular.grids.ImportGrid
+                acoular.grids.LineGrid
+                acoular.grids.MergeGrid
+    :top-classes:
+                acoular.grids.Grid
+    :parts: 1
+
+.. inheritance-diagram::
+                acoular.grids.Sector
+    :include-subclasses:
+    :top-classes:
+                acoular.grids.Sector
+    :parts: 1
+
 .. autosummary::
     :toctree: generated/
 
@@ -30,31 +48,8 @@ import xml.dom.minidom
 from abc import abstractmethod
 from pathlib import Path
 
-from numpy import (
-    absolute,
-    append,
-    arange,
-    argmin,
-    array,
-    asarray,
-    concatenate,
-    copysign,
-    fabs,
-    inf,
-    isscalar,
-    ma,
-    mgrid,
-    newaxis,
-    ones,
-    ones_like,
-    s_,
-    sum,  # noqa: A004
-    tile,
-    unique,
-    where,
-    zeros,
-)
-from scipy.linalg import norm
+import numpy as np
+import scipy.linalg as spla
 
 # from matplotlib.path import Path
 from scipy.spatial import Delaunay
@@ -73,14 +68,13 @@ from traits.api import (
     Union,
     cached_property,
     observe,
-    on_trait_change,
     property_depends_on,
 )
 from traits.trait_errors import TraitError
 
 # acoular imports
-from .deprecation import deprecated_alias
 from .internal import digest, ldigest
+from .tools.utils import Polygon
 
 
 def in_hull(p, hull, border=True, tol=0):
@@ -135,174 +129,6 @@ def in_hull(p, hull, border=True, tol=0):
     return hull.find_simplex(p, tol=tol) > 0
 
 
-def _det(xvert, yvert):
-    xvert = asarray(xvert, dtype=float)
-    yvert = asarray(yvert, dtype=float)
-    x_prev = concatenate(([xvert[-1]], xvert[:-1]))
-    y_prev = concatenate(([yvert[-1]], yvert[:-1]))
-    return sum(yvert * x_prev - xvert * y_prev, axis=0)
-
-
-class Polygon:
-    """
-    Create an object representing a general polygon in a 2D plane.
-
-    This class allows defining a polygon by specifying the coordinates of its vertices and provides
-    methods for checking whether a set of points lies inside the polygon, or if a point is closer to
-    a side or vertex of the polygon.
-
-    Parameters
-    ----------
-    x : array_like
-        Array of x-coordinates of the vertices that define the polygon. These coordinates should
-        form a closed shape (i.e., the last point should be the same as the first point).
-
-    y : array_like
-        Array of y-coordinates of the vertices that define the polygon. These coordinates should
-        correspond to the x-coordinates, forming a closed shape.
-
-    Attributes
-    ----------
-    x : :class:`numpy.ndarray`
-        Array of x-coordinates of the polygon vertices.
-
-    y : :class:`numpy.ndarray`
-        Array of y-coordinates of the polygon vertices.
-    """
-
-    def __init__(self, x, y):
-        if len(x) != len(y):
-            msg = 'x and y must be equally sized.'
-            raise IndexError(msg)
-        self.x = asarray(x, dtype=float)
-        self.y = asarray(y, dtype=float)
-        # Closes the polygon if were open
-        x1, y1 = x[0], y[0]
-        xn, yn = x[-1], y[-1]
-        if x1 != xn or y1 != yn:
-            self.x = concatenate((self.x, [x1]))
-            self.y = concatenate((self.y, [y1]))
-        # Anti-clockwise coordinates
-        if _det(self.x, self.y) < 0:
-            self.x = self.x[::-1]
-            self.y = self.y[::-1]
-
-    def is_inside(self, xpoint, ypoint, smalld=1e-12):
-        """
-        Check if a point or set of points are inside the polygon.
-
-        Parameters
-        ----------
-        xpoint : :class:`float` or array_like
-            Array of x-coordinates of the points to be tested.
-
-        ypoint : :class:`float` or array_like
-            Array of y-coordinates of the points to be tested.
-
-        smalld : :class:`float`, optional
-            Tolerance used for floating point comparisons when checking if a point is exactly on a
-            polygon's edge. The default value is ``1e-12``.
-
-        Returns
-        -------
-        :class:`float` or array_like
-            The distance from the point to the nearest point on the polygon. The values returned
-            have the following meanings:
-            - ``mindst < 0``: Point is outside the polygon.
-            - ``mindst = 0``: Point is on an edge of the polygon.
-            - ``mindst > 0``: Point is inside the polygon.
-
-        Notes
-        -----
-        The method uses an improved algorithm based on Nordbeck and Rydstedt for determining
-        whether a point is inside a polygon :cite:`SLOAN198545`.
-        """
-        xpoint = asarray(xpoint, dtype=float)
-        ypoint = asarray(ypoint, dtype=float)
-        # Scalar to array
-        if xpoint.shape == ():
-            xpoint = array([xpoint], dtype=float)
-            ypoint = array([ypoint], dtype=float)
-            scalar = True
-        else:
-            scalar = False
-        # Check consistency
-        if xpoint.shape != ypoint.shape:
-            msg = 'x and y has different shapes'
-            raise IndexError(msg)
-        # If snear = True: Dist to nearest side < nearest vertex
-        # If snear = False: Dist to nearest vertex < nearest side
-        snear = ma.masked_all(xpoint.shape, dtype=bool)
-        # Initialize arrays
-        mindst = ones_like(xpoint, dtype=float) * inf
-        j = ma.masked_all(xpoint.shape, dtype=int)
-        x = self.x
-        y = self.y
-        n = len(x) - 1  # Number of sides/vertices defining the polygon
-        # Loop over each side defining polygon
-        for i in range(n):
-            d = ones_like(xpoint, dtype=float) * inf
-            # Start of side has coords (x1, y1)
-            # End of side has coords (x2, y2)
-            # Point has coords (xpoint, ypoint)
-            x1 = x[i]
-            y1 = y[i]
-            x21 = x[i + 1] - x1
-            y21 = y[i + 1] - y1
-            x1p = x1 - xpoint
-            y1p = y1 - ypoint
-            # Points on infinite line defined by
-            #     x = x1 + t * (x1 - x2)
-            #     y = y1 + t * (y1 - y2)
-            # where
-            #     t = 0    at (x1, y1)
-            #     t = 1    at (x2, y2)
-            # Find where normal passing through (xpoint, ypoint) intersects
-            # infinite line
-            t = -(x1p * x21 + y1p * y21) / (x21**2 + y21**2)
-            tlt0 = t < 0
-            tle1 = (t >= 0) & (t <= 1)
-            # Normal intersects side
-            d[tle1] = (x1p[tle1] + t[tle1] * x21) ** 2 + (y1p[tle1] + t[tle1] * y21) ** 2
-            # Normal does not intersects side
-            # Point is closest to vertex (x1, y1)
-            # Compute square of distance to this vertex
-            d[tlt0] = x1p[tlt0] ** 2 + y1p[tlt0] ** 2
-            # Store distances
-            mask = d < mindst
-            mindst[mask] = d[mask]
-            j[mask] = i
-            # Point is closer to (x1, y1) than any other vertex or side
-            snear[mask & tlt0] = False
-            # Point is closer to this side than to any other side or vertex
-            snear[mask & tle1] = True
-        if ma.count(snear) != snear.size:
-            msg = 'Error computing distances'
-            raise IndexError(msg)
-        mindst **= 0.5
-        # Point is closer to its nearest vertex than its nearest side, check if
-        # nearest vertex is concave.
-        # If the nearest vertex is concave then point is inside the polygon,
-        # else the point is outside the polygon.
-        jo = j.copy()
-        jo[j == 0] -= 1
-        area = _det([x[j + 1], x[j], x[jo - 1]], [y[j + 1], y[j], y[jo - 1]])
-        mindst[~snear] = copysign(mindst, area)[~snear]
-        # Point is closer to its nearest side than to its nearest vertex, check
-        # if point is to left or right of this side.
-        # If point is to left of side it is inside polygon, else point is
-        # outside polygon.
-        area = _det([x[j], x[j + 1], xpoint], [y[j], y[j + 1], ypoint])
-        mindst[snear] = copysign(mindst, area)[snear]
-        # Point is on side of polygon
-        mindst[fabs(mindst) < smalld] = 0
-        # If input values were scalar then the output should be too
-        if scalar:
-            mindst = float(mindst)
-        return mindst
-
-
-@deprecated_alias({'gpos': 'pos'}, removal_version='25.10')
 class Grid(ABCHasStrictTraits):
     """
     Abstract base class for grid geometries.
@@ -312,28 +138,27 @@ class Grid(ABCHasStrictTraits):
     implementations and should not be instantiated directly as it lacks concrete functionality.
 
     .. _units_note_grids:
+    .. admonition:: Unit of length
 
-    Unit System
-    -----------
-    The source code is agnostic to the unit of length. The positions' coordinates are assumed to be
-    in meters. This is consistent with the standard :class:`~acoular.environments.Environment` class
-    which uses the speed of sound at 20°C at sea level under standard atmosphere pressure in m/s.
-    If the positions' coordinates are provided in a unit other than meter, it is advisable to change
-    the :attr:`~acoular.environments.Environment.c` attribute to match the given unit.
+      The source code is agnostic to the unit of length. The positions' coordinates are assumed to
+      be in meters. This is consistent with the standard :class:`~acoular.environments.Environment`
+      class which uses the speed of sound at 20°C at sea level under standard atmosphere pressure in
+      m/s. If the positions' coordinates are provided in a unit other than meter, it is advisable to
+      change the :attr:`~acoular.environments.Environment.c` attribute to match the given unit.
     """
 
     #: The total number of grid points. This property is automatically calculated based on other
     #: defining attributes of the grid. (read-only)
-    size = Property(desc='overall number of grid points')
+    size = Property()
 
     #: The shape of the grid, represented as a tuple. Primarily useful for Cartesian grids.
     #: (read-only)
-    shape = Property(desc='grid shape as tuple')
+    shape = Property()
 
     #: The grid positions represented as a (3, :attr:`size`) array of :class:`floats<float>`.
     #: (read-only)
-    #: All positions' coordinates are in meters by default (see :ref:`notes <units_note_grids>`).
-    pos = Property(desc='x, y, z positions of grid points')
+    #: All positions' coordinates are in meters by default (:ref:`see here <units_note_grids>`).
+    pos = Property()
 
     #: A unique identifier for the grid, based on its properties. (read-only)
     digest = Property
@@ -385,7 +210,7 @@ class Grid(ABCHasStrictTraits):
         # construct grid-shaped array with "True" entries where sector is
         xyi = sector.contains(xpos).reshape(self.shape)
         # return indices of "True" entries
-        return where(xyi)
+        return np.where(xyi)
 
     def export_gpos(self, filename):
         """
@@ -446,7 +271,7 @@ class Grid(ABCHasStrictTraits):
                 pos_str = ' '.join(
                     [
                         '  <pos',
-                        f'Name="Point {i+1}"',
+                        f'Name="Point {i + 1}"',
                         f'x="{self.pos[0, i]}"',
                         f'y="{self.pos[1, i]}"',
                         f'z="{self.pos[2, i]}"',
@@ -457,7 +282,6 @@ class Grid(ABCHasStrictTraits):
             f.write('</Grid>')
 
 
-@deprecated_alias({'gpos': 'pos'}, read_only=True, removal_version='25.10')
 class RectGrid(Grid):
     """
     Provides a 2D Cartesian grid for beamforming results.
@@ -467,31 +291,31 @@ class RectGrid(Grid):
     """
 
     #: The lower x-limit that defines the grid. Default is ``-1``.
-    x_min = Float(-1.0, desc='minimum  x-value')
+    x_min = Float(-1.0)
 
     #: The upper x-limit that defines the grid. Default is ``1``.
-    x_max = Float(1.0, desc='maximum  x-value')
+    x_max = Float(1.0)
 
     #: The lower y-limit that defines the grid. Default is ``-1``.
-    y_min = Float(-1.0, desc='minimum  y-value')
+    y_min = Float(-1.0)
 
     #: The upper y-limit that defines the grid. Default is ``1``.
-    y_max = Float(1.0, desc='maximum  y-value')
+    y_max = Float(1.0)
 
     #: The constant z-coordinate of the grid plane. Default is ``1.0``.
-    z = Float(1.0, desc='position on z-axis')
+    z = Float(1.0)
 
     #: The side length of each cell. Default is ``0.1``.
-    increment = Float(0.1, desc='step size')
+    increment = Float(0.1)
 
     #: Number of grid points along x-axis. (read-only)
-    nxsteps = Property(desc='number of grid points along x-axis')
+    nxsteps = Property()
 
     #: Number of grid points along y-axis. (read-only)
-    nysteps = Property(desc='number of grid points along y-axis')
+    nysteps = Property()
 
     #: The grid's extension in :obj:`matplotlib.pyplot.imshow` compatible form. (read-only)
-    extent = Property(desc='grid extent as (x_min, x_max, y_min, y_max)')
+    extent = Property()
 
     #: A unique identifier for the grid, based on its properties. (read-only)
     digest = Property(
@@ -526,7 +350,7 @@ class RectGrid(Grid):
 
     @property_depends_on(['x_min', 'x_max', 'y_min', 'y_max', 'increment'])
     def _get_pos(self):
-        bpos = mgrid[
+        bpos = np.mgrid[
             self.x_min : self.x_max : self.nxsteps * 1j,
             self.y_min : self.y_max : self.nysteps * 1j,
             self.z : self.z + 0.1,
@@ -642,36 +466,36 @@ class RectGrid(Grid):
             dr2 = (xpos[0, :] - r[0]) ** 2 + (xpos[1, :] - r[1]) ** 2
             # array with true/false entries
             inds = dr2 <= r[2] ** 2
-            for np in arange(self.size)[inds]:  # np -- points in x2-circle
-                xi, yi = self.index(xpos[0, np], xpos[1, np])
+            for n_p in np.arange(self.size)[inds]:  # n_p -- points in x2-circle
+                xi, yi = self.index(xpos[0, n_p], xpos[1, n_p])
                 xis += [xi]
                 yis += [yi]
             if not (xis and yis):  # if no points in circle, take nearest one
                 return self.index(r[0], r[1])
-            return array(xis), array(yis)
+            return np.array(xis), np.array(yis)
         if len(r) == 4:  # rectangular subdomain - old functionality
             xi1, yi1 = self.index(min(r[0], r[2]), min(r[1], r[3]))
             xi2, yi2 = self.index(max(r[0], r[2]), max(r[1], r[3]))
-            return s_[xi1 : xi2 + 1], s_[yi1 : yi2 + 1]
+            return np.s_[xi1 : xi2 + 1], np.s_[yi1 : yi2 + 1]
         xpos = self.pos
         xis = []
         yis = []
         # replaced matplotlib Path by numpy
-        # p = Path(array(r).reshape(-1,2))
+        # p = Path(np.array(r).reshape(-1,2))
         # inds = p.contains_points()
-        # inds = in_poly(xpos[:2,:].T,array(r).reshape(-1,2))
-        poly = Polygon(array(r).reshape(-1, 2)[:, 0], array(r).reshape(-1, 2)[:, 1])
+        # inds = in_poly(xpos[:2,:].T,np.array(r).reshape(-1,2))
+        poly = Polygon(np.array(r).reshape(-1, 2)[:, 0], np.array(r).reshape(-1, 2)[:, 1])
         dists = poly.is_inside(xpos[0, :], xpos[1, :])
         inds = dists >= 0
-        for np in arange(self.size)[inds]:  # np -- points in x2-circle
-            xi, yi = self.index(xpos[0, np], xpos[1, np])
+        for n_p in np.arange(self.size)[inds]:  # n_p -- points in x2-circle
+            xi, yi = self.index(xpos[0, n_p], xpos[1, n_p])
             xis += [xi]
             yis += [yi]
         if not (xis and yis):  # if no points inside, take nearest to center
-            center = array(r).reshape(-1, 2).mean(0)
+            center = np.array(r).reshape(-1, 2).mean(0)
             return self.index(center[0], center[1])
-        return array(xis), array(yis)
-        # return arange(self.size)[inds]
+        return np.array(xis), np.array(yis)
+        # return np.arange(self.size)[inds]
 
 
 class RectGrid3D(RectGrid):
@@ -682,39 +506,38 @@ class RectGrid3D(RectGrid):
     """
 
     #: The lower z-limit that defines the grid. Default is ``-1.0``.
-    z_min = Float(-1.0, desc='minimum  z-value')
+    z_min = Float(-1.0)
 
     #: The upper z-limit that defines the grid. Default is ``1.0``.
-    z_max = Float(1.0, desc='maximum  z-value')
+    z_max = Float(1.0)
 
     #: Number of grid points along x-axis. (read-only)
-    nxsteps = Property(desc='number of grid points along x-axis')
+    nxsteps = Property()
 
     #: Number of grid points along y-axis. (read-only)
-    nysteps = Property(desc='number of grid points along y-axis')
+    nysteps = Property()
 
     #: Number of grid points along z-axis. (read-only)
-    nzsteps = Property(desc='number of grid points along z-axis')
+    nzsteps = Property()
 
-    # Private trait for increment handling
-    _increment = Union(Float(), CArray(shape=(3,), dtype=float), default_value=0.1, desc='step size')
+    _increment = Union(Float(), CArray(shape=(3,), dtype=float), default_value=0.1)
 
     #: The cell side length for the grid. This can either be a scalar (same increments in all 3
     #: dimensions) or a (3,) array of :class:`tuple` of :class:`floats<float>` with respective
     #: increments in x-, y-, and z-direction. Default is ``0.1``.
-    increment = Property(desc='step size')
+    increment = Property()
 
     def _get_increment(self):
         return self._increment
 
     def _set_increment(self, increment):
-        if isscalar(increment):
+        if np.isscalar(increment):
             try:
-                self._increment = absolute(float(increment))
+                self._increment = np.abs(float(increment))
             except ValueError as ve:
                 raise TraitError(args=self, name='increment', info='Float or CArray(3,)', value=increment) from ve
         elif len(increment) == 3:
-            self._increment = array(increment, dtype=float)
+            self._increment = np.array(increment, dtype=float)
         else:
             raise (TraitError(args=self, name='increment', info='Float or CArray(3,)', value=increment))
 
@@ -733,28 +556,28 @@ class RectGrid3D(RectGrid):
 
     @property_depends_on(['x_min', 'x_max', '_increment'])
     def _get_nxsteps(self):
-        i = abs(self.increment) if isscalar(self.increment) else abs(self.increment[0])
+        i = abs(self.increment) if np.isscalar(self.increment) else abs(self.increment[0])
         if i != 0:
             return int(round((abs(self.x_max - self.x_min) + i) / i))
         return 1
 
     @property_depends_on(['y_min', 'y_max', '_increment'])
     def _get_nysteps(self):
-        i = abs(self.increment) if isscalar(self.increment) else abs(self.increment[1])
+        i = abs(self.increment) if np.isscalar(self.increment) else abs(self.increment[1])
         if i != 0:
             return int(round((abs(self.y_max - self.y_min) + i) / i))
         return 1
 
     @property_depends_on(['z_min', 'z_max', '_increment'])
     def _get_nzsteps(self):
-        i = abs(self.increment) if isscalar(self.increment) else abs(self.increment[2])
+        i = abs(self.increment) if np.isscalar(self.increment) else abs(self.increment[2])
         if i != 0:
             return int(round((abs(self.z_max - self.z_min) + i) / i))
         return 1
 
     @property_depends_on('digest')
     def _get_pos(self):
-        bpos = mgrid[
+        bpos = np.mgrid[
             self.x_min : self.x_max : self.nxsteps * 1j,
             self.y_min : self.y_max : self.nysteps * 1j,
             self.z_min : self.z_max : self.nzsteps * 1j,
@@ -810,7 +633,7 @@ class RectGrid3D(RectGrid):
         if z < self.z_min or z > self.z_max:
             msg = f'z-value out of range {z:f} ({self.z_min:f}, {self.z_max:f})'
             raise ValueError(msg)
-        if isscalar(self.increment):
+        if np.isscalar(self.increment):
             incx = incy = incz = self.increment
         else:
             incx, incy, incz = self.increment
@@ -863,10 +686,9 @@ class RectGrid3D(RectGrid):
         """
         xi1, yi1, zi1 = self.index(min(x1, x2), min(y1, y2), min(z1, z2))
         xi2, yi2, zi2 = self.index(max(x1, x2), max(y1, y2), max(z1, z2))
-        return s_[xi1 : xi2 + 1], s_[yi1 : yi2 + 1], s_[zi1 : zi2 + 1]
+        return np.s_[xi1 : xi2 + 1], np.s_[yi1 : yi2 + 1], np.s_[zi1 : zi2 + 1]
 
 
-@deprecated_alias({'from_file': 'file', 'gpos_file': 'pos'}, removal_version='25.10')
 class ImportGrid(Grid):
     """
     Load a 3D grid from an XML file.
@@ -876,13 +698,14 @@ class ImportGrid(Grid):
     """
 
     #: Name of the .xml-file from which to read the data.
-    file = Union(None, File(filter=['*.xml'], exists=True), desc='name of the xml file to import')
+    file = Union(None, File(filter=['*.xml'], exists=True))
 
-    _gpos = CArray(dtype=float, desc='x, y, z position of all Grid Points')
+    #: x, y, z position of all Grid Points
+    _gpos = CArray(dtype=float)
 
     #: Names of subgrids for each point.
     #: This is an optional property, typically used when grids are divided into named subregions.
-    subgrids = CArray(desc='names of subgrids for each point')
+    subgrids = CArray()
 
     #: A unique identifier for the grid, based on its properties. (read-only)
     digest = Property(depends_on=['_gpos'])
@@ -906,8 +729,8 @@ class ImportGrid(Grid):
     def _set_pos(self, pos):
         self._gpos = pos
 
-    @on_trait_change('file')
-    def import_gpos(self):
+    @observe('file')
+    def _import_pos(self, event):  # noqa ARG002
         """
         Import the grid point locations and subgrid names from an XML file.
 
@@ -924,14 +747,14 @@ class ImportGrid(Grid):
 
         >>> import numpy as np
         >>>
-        >>> # Grid 1: ten points aranged in a circle in the x-y plane at z=0
+        >>> # Grid 1: ten points arranged in a circle in the x-y plane at z=0
         >>> args = 2 * np.pi * np.arange(10) / 10
         >>> x1 = np.cos(args)
         >>> y1 = np.sin(args)
         >>> z1 = np.zeros_like(x1)
         >>> grid1 = np.vstack([x1, y1, z1]).T
         >>>
-        >>> # Grid 2: nine points aranged in a mesh grid the the x-y plane at z=1
+        >>> # Grid 2: nine points arranged in a mesh grid in the x-y plane at z=1
         >>> a = np.linspace(-1, 1, 3)
         >>> x2, y2 = np.meshgrid(a, a)
         >>> z2 = np.ones_like(x2)
@@ -1030,11 +853,10 @@ class ImportGrid(Grid):
         for el in doc.getElementsByTagName('pos'):
             names.append(el.getAttribute('subgrid'))
             xyz.append([float(el.getAttribute(a)) for a in 'xyz'])
-        self._gpos = array(xyz, 'd').swapaxes(0, 1)
-        self.subgrids = array(names)
+        self._gpos = np.array(xyz, 'd').swapaxes(0, 1)
+        self.subgrids = np.array(names)
 
 
-@deprecated_alias({'gpos': 'pos', 'numpoints': 'num_points'}, read_only=['gpos'], removal_version='25.10')
 class LineGrid(Grid):
     """
     Define a 3D grid for a line geometry.
@@ -1070,22 +892,22 @@ class LineGrid(Grid):
     loc = Tuple((0.0, 0.0, 0.0))
 
     #: A vector defining the orientation of the line in 3D space. Default is ``(1.0, 0.0, 0.0)``.
-    direction = Tuple((1.0, 0.0, 0.0), desc='Line orientation ')
+    direction = Tuple((1.0, 0.0, 0.0))
 
     #: Total length of the line. Default is ``1.0``.
-    length = Float(1, desc='length of the line source')
+    length = Float(1)
 
     #: Number of grid points along the line. Default is ``1``.
-    num_points = Int(1, desc='length of the line source')
+    num_points = Int(1)
 
     #: The total number of grid points. Automatically updated when other grid-defining attributes
     #: are set. (read-only)
-    size = Property(desc='overall number of grid points')
+    size = Property()
 
     #: A (3, :attr:`size`) array containing the x, y, and z positions of the grid points.
     #: (read-only)
-    #: All positions' coordinates are in meters by default (see :ref:`notes <units_note_grids>`).
-    pos = Property(desc='x, y, z positions of grid points')
+    #: All positions' coordinates are in meters by default (:ref:`see here <units_note_grids>`).
+    pos = Property()
 
     #: A unique identifier for the grid, based on its properties. (read-only)
     digest = Property(
@@ -1107,15 +929,14 @@ class LineGrid(Grid):
     @property_depends_on(['num_points', 'length', 'direction', 'loc'])
     def _get_pos(self):
         dist = self.length / (self.num_points - 1)
-        loc = array(self.loc, dtype=float).reshape((3, 1))
-        direc_n = array(self.direction) / norm(self.direction)
-        pos = zeros((self.num_points, 3))
+        loc = np.array(self.loc, dtype=float).reshape((3, 1))
+        direc_n = np.array(self.direction) / spla.norm(self.direction)
+        pos = np.zeros((self.num_points, 3))
         for s in range(self.num_points):
             pos[s] = loc.T + direc_n * dist * s
         return pos.T
 
 
-@deprecated_alias({'gpos': 'pos'}, read_only=True, removal_version='25.10')
 class MergeGrid(Grid):
     """
     Base class for merging multiple grid geometries.
@@ -1148,13 +969,13 @@ class MergeGrid(Grid):
 
     #: A list of :class:`Grid` objects to be merged. Each grid is treated as a subdomain in the
     #: resulting merged grid.
-    grids = List(desc='list of grids')
+    grids = List()
 
     #: A list of unique digests for each grid being merged. (read-only)
-    grid_digest = Str(desc='digest of the merged grids')
+    grid_digest = Str()
 
     #: Names of subgrids corresponding to each point in the merged grid. (read-only)
-    subgrids = Property(desc='names of subgrids for each point')
+    subgrids = Property()
 
     #: A unique identifier for the grid, based on its properties. (read-only)
     digest = Property(depends_on=['grids', 'grid_digest'])
@@ -1177,17 +998,17 @@ class MergeGrid(Grid):
 
     @property_depends_on(['digest'])
     def _get_subgrids(self):
-        subgrids = zeros((1, 0), dtype=str)
+        subgrids = np.zeros((1, 0), dtype=str)
         for grid in self.grids:
-            subgrids = append(subgrids, tile(grid.__class__.__name__ + grid.digest, grid.size))
-        return subgrids[:, newaxis].T
+            subgrids = np.append(subgrids, np.tile(grid.__class__.__name__ + grid.digest, grid.size))
+        return subgrids[:, np.newaxis].T
 
     @property_depends_on(['digest'])
     def _get_pos(self):
-        bpos = zeros((3, 0))
+        bpos = np.zeros((3, 0))
         for grid in self.grids:
-            bpos = append(bpos, grid.pos, axis=1)
-        return unique(bpos, axis=1)
+            bpos = np.append(bpos, grid.pos, axis=1)
+        return np.unique(bpos, axis=1)
 
 
 class Sector(ABCHasStrictTraits):
@@ -1241,7 +1062,7 @@ class Sector(ABCHasStrictTraits):
         >>> sector.contains(positions)
         array([ True,  True])
         """
-        return ones(pos.shape[1], dtype=bool)
+        return np.ones(pos.shape[1], dtype=bool)
 
 
 class SingleSector(Sector):
@@ -1261,16 +1082,16 @@ class SingleSector(Sector):
 
     #: If ``True``, grid points lying on the sector border are included in the sector. Default is
     #: ``True``.
-    include_border = Bool(True, desc='include points on the border')
+    include_border = Bool(True)
 
     #: The absolute tolerance to apply when determining if a grid point lies on the sector border.
     #: Default is ``1e-12``.
-    abs_tol = Float(1e-12, desc='absolute tolerance for sector border')
+    abs_tol = Float(1e-12)
 
     #: If ``True``, the ``contains`` method (as in :meth:`RectSector.contains`,
     #: :meth:`RectSector3D.contains`, :meth:`CircSector.contains`, and :meth:`PolySector.contains`)
     #: returns the nearest grid point if no grid points are inside the sector. Default is ``True``.
-    default_nearest = Bool(True, desc='``contains`` method return nearest grid point to center if none inside sector')
+    default_nearest = Bool(True)
 
 
 class RectSector(SingleSector):
@@ -1289,16 +1110,16 @@ class RectSector(SingleSector):
     """
 
     #: The minimum x position of the rectangle. Default is ``-1.0``.
-    x_min = Float(-1.0, desc='minimum x position of the rectangle')
+    x_min = Float(-1.0)
 
     #: The maximum x position of the rectangle. Default is ``1.0``.
-    x_max = Float(1.0, desc='maximum x position of the rectangle')
+    x_max = Float(1.0)
 
     #: The minimum y position of the rectangle. Default is ``-1.0``.
-    y_min = Float(-1.0, desc='minimum y position of the rectangle')
+    y_min = Float(-1.0)
 
     #: The maximum y position of the rectangle. Default is ``1.0``.
-    y_max = Float(1.0, desc='maximum y position of the rectangle')
+    y_max = Float(1.0)
 
     def contains(self, pos):
         """
@@ -1354,7 +1175,7 @@ class RectSector(SingleSector):
             x = (xmin + xmax) / 2.0
             y = (ymin + ymax) / 2.0
             dr2 = (pos[0, :] - x) ** 2 + (pos[1, :] - y) ** 2
-            inds[argmin(dr2)] = True
+            inds[np.argmin(dr2)] = True
 
         return inds.astype(bool)
 
@@ -1373,10 +1194,10 @@ class RectSector3D(RectSector):
     """
 
     #: The lower z position of the cuboid. Default is ``-1.0``.
-    z_min = Float(-1.0, desc='minimum z position of the cuboid')
+    z_min = Float(-1.0)
 
     #: The upper z position of the cuboid.  Default is ``1.0``.
-    z_max = Float(1.0, desc='maximum z position of the cuboid')
+    z_max = Float(1.0)
 
     def contains(self, pos):
         """
@@ -1442,7 +1263,7 @@ class RectSector3D(RectSector):
             x = (xmin + xmax) / 2.0
             y = (ymin + ymax) / 2.0
             dr2 = (pos[0, :] - x) ** 2 + (pos[1, :] - y) ** 2
-            inds[argmin(dr2)] = True
+            inds[np.argmin(dr2)] = True
 
         return inds.astype(bool)
 
@@ -1462,13 +1283,13 @@ class CircSector(SingleSector):
     """
 
     #: The x position of the circle center. Default is ``0.0``.
-    x = Float(0.0, desc='x position of the circle center')
+    x = Float(0.0)
 
     #: The y position of the circle center. Default is ``0.0``.
-    y = Float(0.0, desc='y position of the circle center')
+    y = Float(0.0)
 
     #: Radius of the circle. Default is ``1.0``.
-    r = Float(1.0, desc='radius of the circle')
+    r = Float(1.0)
 
     def contains(self, pos):
         """
@@ -1510,7 +1331,7 @@ class CircSector(SingleSector):
 
         # if there's no point inside
         if ~inds.any() and self.default_nearest:
-            inds[argmin(dr2)] = True
+            inds[np.argmin(dr2)] = True
 
         return inds
 
@@ -1567,14 +1388,14 @@ class PolySector(SingleSector):
         >>> sec.contains(grid.pos)
         array([False, False, False, False,  True,  True, False,  True,  True])
         """
-        poly = Polygon(array(self.edges).reshape(-1, 2)[:, 0], array(self.edges).reshape(-1, 2)[:, 1])
+        poly = Polygon(np.array(self.edges).reshape(-1, 2)[:, 0], np.array(self.edges).reshape(-1, 2)[:, 1])
         dists = poly.is_inside(pos[0, :], pos[1, :])
         inds = dists >= -self.abs_tol if self.include_border else dists > 0
 
         # if none inside, take nearest
         if ~inds.any() and self.default_nearest:
-            dr2 = array(self.edges).reshape(-1, 2).mean(0)
-            inds[argmin(dr2)] = True
+            dr2 = np.array(self.edges).reshape(-1, 2).mean(0)
+            inds[np.argmin(dr2)] = True
 
         return inds
 
@@ -1627,12 +1448,12 @@ class ConvexSector(SingleSector):
         >>> sec.contains(grid.pos)
         array([False, False, False, False,  True,  True, False,  True,  True])
         """
-        inds = in_hull(pos[:2, :].T, array(self.edges).reshape(-1, 2), border=self.include_border, tol=self.abs_tol)
+        inds = in_hull(pos[:2, :].T, np.array(self.edges).reshape(-1, 2), border=self.include_border, tol=self.abs_tol)
 
         # if none inside, take nearest
         if ~inds.any() and self.default_nearest:
-            dr2 = array(self.edges).reshape(-1, 2).mean(0)  # Use the centroid of the polygon as the "center"
-            inds[argmin(dr2)] = True
+            dr2 = np.array(self.edges).reshape(-1, 2).mean(0)  # Use the centroid of the polygon as the "center"
+            inds[np.argmin(dr2)] = True
 
         return inds
 
@@ -1687,7 +1508,7 @@ class MultiSector(Sector):
         array([False, False, False, False,  True,  True, False,  True,  True])
         """
         # initialize with only "False" entries
-        inds = zeros(pos.shape[1], dtype=bool)
+        inds = np.zeros(pos.shape[1], dtype=bool)
 
         # add points contained in each sector
         for sec in self.sectors: