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

acoular/fprocess.py

@@ -4,6 +4,13 @@
 """
 Implements blockwise processing methods in the frequency domain.
 
+.. inheritance-diagram::
+                acoular.fprocess
+    :top-classes:
+                acoular.base.Generator,
+                acoular.spectra.BaseSpectra
+    :parts: 1
+
 .. autosummary::
     :toctree: generated/
 
@@ -19,14 +26,12 @@ from traits.api import Bool, CArray, Enum, Instance, Int, Property, Union, cache
 
 # acoular imports
 from .base import SamplesGenerator, SpectraGenerator, SpectraOut, TimeOut
-from .deprecation import deprecated_alias
 from .fastFuncs import calcCSM
 from .internal import digest
 from .process import SamplesBuffer
 from .spectra import BaseSpectra
 
 
-@deprecated_alias({'numfreqs': 'num_freqs', 'numsamples': 'num_samples'}, read_only=True, removal_version='25.10')
 class RFFT(BaseSpectra, SpectraOut):
     """
     Compute the one-sided Fast Fourier Transform (FFT) for real-valued multichannel time data.
@@ -167,7 +172,6 @@ class RFFT(BaseSpectra, SpectraOut):
             yield fftdata[: j + 1]
 
 
-@deprecated_alias({'numsamples': 'num_samples'}, read_only=True, removal_version='25.10')
 class IRFFT(TimeOut):
     """
     Perform the inverse Fast Fourier Transform (IFFT) for one-sided multi-channel spectra.
@@ -347,7 +351,6 @@ class AutoPowerSpectra(SpectraOut):
             yield ((temp * temp.conjugate()).real * scale).astype(self.precision)
 
 
-@deprecated_alias({'numchannels': 'num_channels'}, read_only=True, removal_version='25.10')
 class CrossPowerSpectra(AutoPowerSpectra):
     """
     Compute the complex-valued auto- and cross-power spectra from frequency-domain data.

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,13 +68,11 @@ 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
 
 
@@ -136,11 +129,11 @@ def in_hull(p, hull, border=True, 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)
+    xvert = np.asarray(xvert, dtype=float)
+    yvert = np.asarray(yvert, dtype=float)
+    x_prev = np.concatenate(([xvert[-1]], xvert[:-1]))
+    y_prev = np.concatenate(([yvert[-1]], yvert[:-1]))
+    return np.sum(yvert * x_prev - xvert * y_prev, axis=0)
 
 
 class Polygon:
@@ -174,14 +167,14 @@ class Polygon:
         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)
+        self.x = np.asarray(x, dtype=float)
+        self.y = np.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]))
+            self.x = np.concatenate((self.x, [x1]))
+            self.y = np.concatenate((self.y, [y1]))
         # Anti-clockwise coordinates
         if _det(self.x, self.y) < 0:
             self.x = self.x[::-1]
@@ -217,12 +210,12 @@ class Polygon:
         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)
+        xpoint = np.asarray(xpoint, dtype=float)
+        ypoint = np.asarray(ypoint, dtype=float)
         # Scalar to array
         if xpoint.shape == ():
-            xpoint = array([xpoint], dtype=float)
-            ypoint = array([ypoint], dtype=float)
+            xpoint = np.array([xpoint], dtype=float)
+            ypoint = np.array([ypoint], dtype=float)
             scalar = True
         else:
             scalar = False
@@ -232,16 +225,16 @@ class Polygon:
             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)
+        snear = np.ma.masked_all(xpoint.shape, dtype=bool)
         # Initialize arrays
-        mindst = ones_like(xpoint, dtype=float) * inf
-        j = ma.masked_all(xpoint.shape, dtype=int)
+        mindst = np.ones_like(xpoint, dtype=float) * np.inf
+        j = np.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
+            d = np.ones_like(xpoint, dtype=float) * np.inf
             # Start of side has coords (x1, y1)
             # End of side has coords (x2, y2)
             # Point has coords (xpoint, ypoint)
@@ -276,7 +269,7 @@ class Polygon:
             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:
+        if np.ma.count(snear) != snear.size:
             msg = 'Error computing distances'
             raise IndexError(msg)
         mindst **= 0.5
@@ -287,22 +280,21 @@ class 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]
+        mindst[~snear] = np.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]
+        mindst[snear] = np.copysign(mindst, area)[snear]
         # Point is on side of polygon
-        mindst[fabs(mindst) < smalld] = 0
+        mindst[np.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,14 +304,13 @@ 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
@@ -332,7 +323,7 @@ class Grid(ABCHasStrictTraits):
 
     #: 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>`).
+    #: All positions' coordinates are in meters by default (:ref:`see here <units_note_grids>`).
     pos = Property(desc='x, y, z positions of grid points')
 
     #: A unique identifier for the grid, based on its properties. (read-only)
@@ -385,7 +376,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):
         """
@@ -457,7 +448,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.
@@ -526,7 +516,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 +632,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):
@@ -708,13 +698,13 @@ class RectGrid3D(RectGrid):
         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 +723,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 +800,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 +853,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.
@@ -906,8 +895,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 +913,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 +1019,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.
@@ -1084,7 +1072,7 @@ class LineGrid(Grid):
 
     #: 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>`).
+    #: All positions' coordinates are in meters by default (:ref:`see here <units_note_grids>`).
     pos = Property(desc='x, y, z positions of grid points')
 
     #: A unique identifier for the grid, based on its properties. (read-only)
@@ -1107,15 +1095,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.
@@ -1177,17 +1164,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 +1228,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):
@@ -1354,7 +1341,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)
 
@@ -1442,7 +1429,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)
 
@@ -1510,7 +1497,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 +1554,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 +1614,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 +1674,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:

acoular/h5cache.py

@@ -32,23 +32,27 @@ class HDF5Cache(HasStrictTraits):
             pass
 
     def close_cachefile(self, cachefile):
+        """Close a cache file and remove it from the reference counter."""
         self.open_file_reference.pop(Path(cachefile.filename))
         cachefile.close()
 
     def get_open_cachefiles(self):
+        """Get an iterator over all open cache files."""
         try:
             return self.open_files.itervalues()
         except AttributeError:
             return iter(self.open_files.values())
 
     def close_unreferenced_cachefiles(self):
+        """Close cache files that are no longer referenced by any objects."""
         for cachefile in self.get_open_cachefiles():
             if not self.is_reference_existent(cachefile):
                 self.close_cachefile(cachefile)
 
     def is_reference_existent(self, file):
+        """Check if a file object still has active references."""
         exist_flag = False
-        # inspect all refererres to the file object
+        # inspect all referrers to the file object
         gc.collect()  # clear garbage before collecting referrers
         for ref in gc.get_referrers(file):
             # does the file object have a referrer that has a 'h5f'