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

acoular/tprocess.py

@@ -4,6 +4,12 @@
 """
 Implement blockwise processing in the time domain.
 
+.. inheritance-diagram::
+                acoular.tprocess
+    :top-classes:
+                acoular.base.TimeOut
+    :parts: 1
+
 .. autosummary::
     :toctree: generated/
 
@@ -39,46 +45,9 @@ from warnings import warn
 
 import numba as nb
 import numpy as np
-from numpy import (
-    append,
-    arange,
-    argmax,
-    argmin,
-    argsort,
-    array,
-    array_equal,
-    asarray,
-    ceil,
-    concatenate,
-    cumsum,
-    delete,
-    empty,
-    empty_like,
-    exp,
-    flatnonzero,
-    float64,
-    identity,
-    inf,
-    interp,
-    linspace,
-    mean,
-    nan,
-    newaxis,
-    pi,
-    polymul,
-    sin,
-    sinc,
-    split,
-    sqrt,
-    stack,
-    sum,  # noqa: A004
-    tile,
-    unique,
-    zeros,
-)
+import scipy.linalg as spla
 from scipy.fft import irfft, rfft
 from scipy.interpolate import CloughTocher2DInterpolator, CubicSpline, LinearNDInterpolator, Rbf, splev, splrep
-from scipy.linalg import norm
 from scipy.signal import bilinear, butter, sosfilt, sosfiltfilt, tf2sos
 from scipy.spatial import Delaunay
 from traits.api import (
@@ -101,13 +70,11 @@ from traits.api import (
     Union,
     cached_property,
     observe,
-    on_trait_change,
 )
 
 # acoular imports
 from .base import SamplesGenerator, TimeOut
 from .configuration import config
-from .deprecation import deprecated_alias
 from .environments import cartToCyl, cylToCart
 from .h5files import _get_h5file_class
 from .internal import digest, ldigest
@@ -116,9 +83,6 @@ from .process import Cache
 from .tools.utils import find_basename
 
 
-@deprecated_alias(
-    {'numchannels_total': 'num_channels_total', 'numsamples_total': 'num_samples_total'}, removal_version='25.10'
-)
 class MaskedTimeOut(TimeOut):
     """
     A signal processing block that allows for the selection of specific channels and time samples.
@@ -141,17 +105,17 @@ class MaskedTimeOut(TimeOut):
     source = Instance(SamplesGenerator)
 
     #: The index of the first valid sample. Default is ``0``.
-    start = CInt(0, desc='start of valid samples')
+    start = CInt(0)
 
     #: The index of the last valid sample (exclusive).
     #: If set to :obj:`None`, the selection continues until the end of the available data.
-    stop = Union(None, CInt, desc='stop of valid samples')
+    stop = Union(None, CInt)
 
     #: List of channel indices to be excluded from processing.
-    invalid_channels = List(int, desc='list of invalid channels')
+    invalid_channels = List(int)
 
     #: A mask or index array representing valid channels. (automatically updated)
-    channels = Property(depends_on=['invalid_channels', 'source.num_channels'], desc='channel mask')
+    channels = Property(depends_on=['invalid_channels', 'source.num_channels'])
 
     #: Total number of input channels, including invalid channels, as given by
     #: :attr:`~acoular.base.TimeOut.source`. (read-only).
@@ -161,19 +125,15 @@ class MaskedTimeOut(TimeOut):
     num_samples_total = Delegate('source', 'num_samples')
 
     #: Number of valid input channels after excluding :attr:`invalid_channels`. (read-only)
-    num_channels = Property(
-        depends_on=['invalid_channels', 'source.num_channels'], desc='number of valid input channels'
-    )
+    num_channels = Property(depends_on=['invalid_channels', 'source.num_channels'])
 
     #: Number of valid time-domain samples, based on :attr:`start` and :attr:`stop` indices.
     #: (read-only)
-    num_samples = Property(
-        depends_on=['start', 'stop', 'source.num_samples'], desc='number of valid samples per channel'
-    )
+    num_samples = Property(depends_on=['start', 'stop', 'source.num_samples'])
 
     #: The name of the cache file (without extension). It serves as an internal reference for data
     #: caching and tracking processed files. (automatically generated)
-    basename = Property(depends_on=['source.digest'], desc='basename for cache file')
+    basename = Property(depends_on=['source.digest'])
 
     #: A unique identifier for the object, based on its properties. (read-only)
     digest = Property(depends_on=['source.digest', 'start', 'stop', 'invalid_channels'])
@@ -199,7 +159,7 @@ class MaskedTimeOut(TimeOut):
         if len(self.invalid_channels) == 0:
             return slice(0, None, None)
         allr = [i for i in range(self.num_channels_total) if i not in self.invalid_channels]
-        return array(allr)
+        return np.array(allr)
 
     @cached_property
     def _get_num_channels(self):
@@ -251,7 +211,7 @@ class MaskedTimeOut(TimeOut):
             offset = -start % num
             if offset == 0:
                 offset = num
-            buf = empty((num + offset, self.num_channels), dtype=float)
+            buf = np.empty((num + offset, self.num_channels), dtype=float)
             bsize = 0
             i = 0
             fblock = True
@@ -310,7 +270,7 @@ class ChannelMixer(TimeOut):
     #: If not explicitly set, all channels are weighted equally (delault is ``1``).
     #: The shape of :attr:`weights` must match the :attr:`number of input channels<num_channels>`.
     #: If an incompatible shape is provided, a :obj:`ValueError` will be raised.
-    weights = CArray(desc='channel weights')
+    weights = CArray()
 
     #: The number of output channels, which is always ``1`` for this class since it produces a
     #: single mixed output. (read-only)
@@ -360,7 +320,7 @@ class ChannelMixer(TimeOut):
             weights = 1
 
         for block in self.source.result(num):
-            yield sum(weights * block, 1, keepdims=True)
+            yield np.sum(weights * block, 1, keepdims=True)
 
 
 class Trigger(TimeOut):  # pragma: no cover
@@ -472,15 +432,15 @@ class Trigger(TimeOut):  # pragma: no cover
         threshold = self._threshold(num)
 
         # get all samples which surpasse the threshold
-        peakLoc = array([], dtype='int')  # all indices which surpasse the threshold
-        trigger_data = array([])
+        peakLoc = np.array([], dtype='int')  # all indices which surpasse the threshold
+        trigger_data = np.array([])
         x0 = []
         dSamples = 0
         for triggerSignal in self.source.result(num):
-            localTrigger = flatnonzero(triggerFunc(x0, triggerSignal, threshold))
+            localTrigger = np.flatnonzero(triggerFunc(x0, triggerSignal, threshold))
             if len(localTrigger) != 0:
-                peakLoc = append(peakLoc, localTrigger + dSamples)
-                trigger_data = append(trigger_data, triggerSignal[localTrigger])
+                peakLoc = np.append(peakLoc, localTrigger + dSamples)
+                trigger_data = np.append(trigger_data, triggerSignal[localTrigger])
             dSamples += num
             x0 = triggerSignal[-1]
         if len(peakLoc) <= 1:
@@ -494,24 +454,24 @@ class Trigger(TimeOut):  # pragma: no cover
         # which peak is the correct one -> delete the other one.
         # if there are no multiple peaks in any hunk left -> leave the while
         # loop and continue with program
-        multiplePeaksWithinHunk = flatnonzero(peakDist < self.hunk_length * maxPeakDist)
+        multiplePeaksWithinHunk = np.flatnonzero(peakDist < self.hunk_length * maxPeakDist)
         while len(multiplePeaksWithinHunk) > 0:
             peakLocHelp = multiplePeaksWithinHunk[0]
             indHelp = [peakLocHelp, peakLocHelp + 1]
             if self.multiple_peaks_in_hunk == 'extremum':
                 values = trigger_data[indHelp]
-                deleteInd = indHelp[argmin(abs(values))]
+                deleteInd = indHelp[np.argmin(abs(values))]
             elif self.multiple_peaks_in_hunk == 'first':
                 deleteInd = indHelp[1]
-            peakLoc = delete(peakLoc, deleteInd)
-            trigger_data = delete(trigger_data, deleteInd)
+            peakLoc = np.delete(peakLoc, deleteInd)
+            trigger_data = np.delete(trigger_data, deleteInd)
             peakDist = peakLoc[1:] - peakLoc[:-1]
-            multiplePeaksWithinHunk = flatnonzero(peakDist < self.hunk_length * maxPeakDist)
+            multiplePeaksWithinHunk = np.flatnonzero(peakDist < self.hunk_length * maxPeakDist)
 
         # check whether distances between peaks are evenly distributed
-        meanDist = mean(peakDist)
+        meanDist = np.mean(peakDist)
         diffDist = abs(peakDist - meanDist)
-        faultyInd = flatnonzero(diffDist > self.max_variation_of_duration * meanDist)
+        faultyInd = np.flatnonzero(diffDist > self.max_variation_of_duration * meanDist)
         if faultyInd.size != 0:
             warn(
                 f'In Trigger-Identification: The distances between the peaks (and therefore the lengths of the \
@@ -527,7 +487,7 @@ class Trigger(TimeOut):  # pragma: no cover
 
     def _trigger_rect(self, x0, x, threshold):
         # x0 stores the last value of the the last generator cycle
-        xNew = append(x0, x)
+        xNew = np.append(x0, x)
         # indPeakHunk = abs(xNew[1:] - xNew[:-1]) > abs(threshold)
         # with above line, every edge would be located
         return self._trigger_value_comp(xNew[1:] - xNew[:-1], threshold)
@@ -538,8 +498,8 @@ class Trigger(TimeOut):  # pragma: no cover
     def _threshold(self, num):
         if self.threshold is None:  # take a guessed threshold
             # get max and min values of whole trigger signal
-            maxVal = -inf
-            minVal = inf
+            maxVal = -np.inf
+            minVal = np.inf
             meanVal = 0
             cntMean = 0
             for trigger_data in self.source.result(num):
@@ -551,7 +511,7 @@ class Trigger(TimeOut):  # pragma: no cover
 
             # get 75% of maximum absolute value of trigger signal
             maxTriggerHelp = [minVal, maxVal] - meanVal
-            argInd = argmax(abs(maxTriggerHelp))
+            argInd = np.argmax(abs(maxTriggerHelp))
             thresh = maxTriggerHelp[argInd] * 0.75  # 0.75 for 75% of max trigger signal
             warn(f'No threshold was passed. An estimated threshold of {thresh} is assumed.', Warning, stacklevel=2)
         else:  # take user defined  threshold
@@ -625,7 +585,7 @@ class AngleTracker(MaskedTimeOut):
 
     #: Number of trigger signals per revolution. This allows tracking scenarios where multiple
     #: trigger pulses occur per rotation. Default is ``1``, meaning a single trigger per revolution.
-    trigger_per_revo = Int(1, desc='trigger signals per revolution')
+    trigger_per_revo = Int(1)
 
     #: Rotation direction flag:
     #:
@@ -633,26 +593,26 @@ class AngleTracker(MaskedTimeOut):
     #: - ``-1``: clockwise rotation.
     #:
     #: Default is ``-1``.
-    rot_direction = Int(-1, desc='mathematical direction of rotation')
+    rot_direction = Int(-1)
 
     #: Number of points used for spline interpolation. Default is ``4``.
-    interp_points = Int(4, desc='Points of interpolation used for spline')
+    interp_points = Int(4)
 
     #: Initial rotation angle (in radians) corresponding to the first trigger event. This allows
     #: defining a custom starting reference angle. Default is ``0``.
-    start_angle = Float(0, desc='rotation angle for trigger position')
+    start_angle = Float(0)
 
     #: Revolutions per minute (RPM) computed for each sample.
     #: It is based on the trigger data. (read-only)
-    rpm = Property(depends_on=['digest'], desc='revolutions per minute for each sample')
+    rpm = Property(depends_on=['digest'])
 
     #: Average revolutions per minute over the entire dataset.
     #: It is computed based on the trigger intervals. (read-only)
-    average_rpm = Property(depends_on=['digest'], desc='average revolutions per minute')
+    average_rpm = Property(depends_on=['digest'])
 
     #: Computed rotation angle (in radians) for each sample.
     #: It is interpolated from the trigger data. (read-only)
-    angle = Property(depends_on=['digest'], desc='rotation angle for each sample')
+    angle = Property(depends_on=['digest'])
 
     # Internal flag to determine whether rpm and angle calculation has been processed,
     # prevents recalculation
@@ -670,7 +630,7 @@ class AngleTracker(MaskedTimeOut):
 
     # helperfunction for trigger index detection
     def _find_nearest_idx(self, peakarray, value):
-        peakarray = asarray(peakarray)
+        peakarray = np.asarray(peakarray)
         return (abs(peakarray - value)).argmin()
 
     def _to_rpm_and_angle(self):
@@ -688,8 +648,8 @@ class AngleTracker(MaskedTimeOut):
         rotDirection = self.rot_direction
         num = self.source.num_samples
         samplerate = self.source.sample_freq
-        self._rpm = zeros(num)
-        self._angle = zeros(num)
+        self._rpm = np.zeros(num)
+        self._angle = np.zeros(num)
         # number of spline points
         InterpPoints = self.interp_points
 
@@ -701,7 +661,7 @@ class AngleTracker(MaskedTimeOut):
                     peakloc[self._find_nearest_idx(peakarray=peakloc, value=ind) + 1]
                     - peakloc[self._find_nearest_idx(peakarray=peakloc, value=ind)]
                 )
-                splineData = stack(
+                splineData = np.stack(
                     (range(InterpPoints), peakloc[ind // peakdist : ind // peakdist + InterpPoints]),
                     axis=0,
                 )
@@ -711,7 +671,7 @@ class AngleTracker(MaskedTimeOut):
                     peakloc[self._find_nearest_idx(peakarray=peakloc, value=ind)]
                     - peakloc[self._find_nearest_idx(peakarray=peakloc, value=ind) - 1]
                 )
-                splineData = stack(
+                splineData = np.stack(
                     (range(InterpPoints), peakloc[ind // peakdist - InterpPoints : ind // peakdist]),
                     axis=0,
                 )
@@ -719,16 +679,16 @@ class AngleTracker(MaskedTimeOut):
             Spline = splrep(splineData[:, :][1], splineData[:, :][0], k=3)
             self._rpm[ind] = splev(ind, Spline, der=1, ext=0) * 60 * samplerate
             self._angle[ind] = (
-                splev(ind, Spline, der=0, ext=0) * 2 * pi * rotDirection / TriggerPerRevo + self.start_angle
-            ) % (2 * pi)
+                splev(ind, Spline, der=0, ext=0) * 2 * np.pi * rotDirection / TriggerPerRevo + self.start_angle
+            ) % (2 * np.pi)
             # next sample
             ind += 1
         # calculation complete
         self._calc_flag = True
 
     # reset calc flag if something has changed
-    @on_trait_change('digest')
-    def _reset_calc_flag(self):
+    @observe('digest')
+    def _reset_calc_flag(self, event):  # noqa ARG002
         self._calc_flag = False
 
     # calc rpm from trigger data
@@ -777,14 +737,15 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
 
     #: The physical microphone geometry. An instance of :class:`~acoular.microphones.MicGeom` that
     #: defines the positions of the real microphones used for measurement.
-    mics = Instance(MicGeom(), desc='microphone geometry')
+    mics = Instance(MicGeom())
 
     #: The virtual microphone geometry. This property defines the positions
     #: of virtual microphones where interpolated pressure values are computed.
     #: Default is the physical microphone geometry (:attr:`mics`).
-    mics_virtual = Property(desc='microphone geometry')
+    mics_virtual = Property()
 
-    _mics_virtual = Instance(MicGeom, desc='internal microphone geometry;internal usage, read only')
+    #: internal microphone geometry;internal usage, read only
+    _mics_virtual = Instance(MicGeom)
 
     def _get_mics_virtual(self):
         if not self._mics_virtual and self.mics:
@@ -814,7 +775,6 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
         'IDW',
         'custom',
         'sinc',
-        desc='method for interpolation used',
     )
 
     #: Defines the spatial dimensionality of the microphone array.
@@ -826,7 +786,7 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
     #: - ``'ring'``: Circular arrays where rotation needs to be considered.
     #: - ``'3D'``: Three-dimensional microphone distributions.
     #: - ``'custom'``: User-defined microphone arrangements.
-    array_dimension = Enum('1D', '2D', 'ring', '3D', 'custom', desc='spatial dimensionality of the array geometry')
+    array_dimension = Enum('1D', '2D', 'ring', '3D', 'custom')
 
     #: Sampling frequency of the output signal, inherited from the :attr:`source`. This defines the
     #: rate at which microphone pressure samples are acquired and processed.
@@ -856,19 +816,16 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
     #:
     #: where :math:`Q` is the transformation matrix and :math:`(x', y', z')` are the modified
     #: coordinates. If no transformation is needed, :math:`Q` defaults to the identity matrix.
-    Q = CArray(dtype=float64, shape=(3, 3), value=identity(3))
+    Q = CArray(dtype=np.float64, shape=(3, 3), value=np.identity(3))
 
     #: Number of neighboring microphones used in IDW interpolation. This parameter determines how
     #: many physical microphones contribute to the weighted sum in inverse distance weighting (IDW)
     #: interpolation.
-    num_IDW = Int(3, desc='number of neighboring microphones, DEFAULT=3')  # noqa: N815
+    num_IDW = Int(3)  # noqa: N815
 
     #: Weighting exponent for IDW interpolation. This parameter controls the influence of distance
     #: in inverse distance weighting (IDW). A higher value gives more weight to closer microphones.
-    p_weight = Float(
-        2,
-        desc='used in interpolation for virtual microphone, weighting power exponent for IDW',
-    )
+    p_weight = Float(2)
 
     # Stores the output of :meth:`_virtNewCoord_func`; Read-Only
     _virtNewCoord_func = Property(  # noqa: N815
@@ -897,7 +854,7 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
 
     @cached_property
     def _get_virtNewCoord(self):  # noqa N802
-        return self._virtNewCoord_func(self.mics.mpos, self.mics_virtual.mpos, self.method, self.array_dimension)
+        return self._virtNewCoord_func(self.mics.pos, self.mics_virtual.pos, self.method, self.array_dimension)
 
     def sinc_mic(self, r):
         """
@@ -919,7 +876,7 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
         :class:`numpy.ndarray`
             Evaluated sinc function values at the given radial distances.
         """
-        return sinc((r * self.mics_virtual.mpos.shape[1]) / (pi))
+        return np.sinc((r * self.mics_virtual.mpos.shape[1]) / (np.pi))
 
     def _virtNewCoord_func(self, mpos, mpos_virt, method, array_dimension):  # noqa N802
         # Core functionality for getting the interpolation.
@@ -966,23 +923,23 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
 
         # init positions of virtual mics in cyl coordinates
         nVirtMics = mpos_virt.shape[1]
-        virtNewCoord = zeros((3, nVirtMics))
-        virtNewCoord.fill(nan)
+        virtNewCoord = np.zeros((3, nVirtMics))
+        virtNewCoord.fill(np.nan)
         # init real positions in cyl coordinates
         nMics = mpos.shape[1]
-        newCoord = zeros((3, nMics))
-        newCoord.fill(nan)
+        newCoord = np.zeros((3, nMics))
+        newCoord.fill(np.nan)
         # empty mesh object
         mesh = []
 
         if self.array_dimension == '1D' or self.array_dimension == 'ring':
             # get projections onto new coordinate, for real mics
             projectionOnNewAxis = cartToCyl(mpos, self.Q)[0]
-            indReorderHelp = argsort(projectionOnNewAxis)
+            indReorderHelp = np.argsort(projectionOnNewAxis)
             mesh.append([projectionOnNewAxis[indReorderHelp], indReorderHelp])
 
             # new coordinates of real mics
-            indReorderHelp = argsort(cartToCyl(mpos, self.Q)[0])
+            indReorderHelp = np.argsort(cartToCyl(mpos, self.Q)[0])
             newCoord = (cartToCyl(mpos, self.Q).T)[indReorderHelp].T
 
             # and for virtual mics
@@ -993,7 +950,7 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
             virtNewCoord = cartToCyl(mpos_virt, self.Q)
 
             # new coordinates of real mics
-            indReorderHelp = argsort(cartToCyl(mpos, self.Q)[0])
+            indReorderHelp = np.argsort(cartToCyl(mpos, self.Q)[0])
             newCoord = cartToCyl(mpos, self.Q)
 
             # scipy delauney triangulation
@@ -1002,29 +959,29 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
 
             if self.interp_at_zero:
                 # add a point at zero
-                tri.add_points(array([[0], [0]]).T)
+                tri.add_points(np.array([[0], [0]]).T)
 
             # extend mesh with closest boundary points of repeating mesh
-            pointsOriginal = arange(tri.points.shape[0])
+            pointsOriginal = np.arange(tri.points.shape[0])
             hull = tri.convex_hull
-            hullPoints = unique(hull)
+            hullPoints = np.unique(hull)
 
             addRight = tri.points[hullPoints]
-            addRight[:, 0] += 2 * pi
+            addRight[:, 0] += 2 * np.pi
             addLeft = tri.points[hullPoints]
-            addLeft[:, 0] -= 2 * pi
+            addLeft[:, 0] -= 2 * np.pi
 
-            indOrigPoints = concatenate((pointsOriginal, pointsOriginal[hullPoints], pointsOriginal[hullPoints]))
+            indOrigPoints = np.concatenate((pointsOriginal, pointsOriginal[hullPoints], pointsOriginal[hullPoints]))
             # add all hull vertices to original mesh and check which of those
             # are actual neighbors of the original array. Cancel out all others.
-            tri.add_points(concatenate([addLeft, addRight]))
+            tri.add_points(np.concatenate([addLeft, addRight]))
             indices, indptr = tri.vertex_neighbor_vertices
-            hullNeighbor = empty((0), dtype='int32')
+            hullNeighbor = np.empty((0), dtype='int32')
             for currHull in hullPoints:
                 neighborOfHull = indptr[indices[currHull] : indices[currHull + 1]]
-                hullNeighbor = append(hullNeighbor, neighborOfHull)
-            hullNeighborUnique = unique(hullNeighbor)
-            pointsNew = unique(append(pointsOriginal, hullNeighborUnique))
+                hullNeighbor = np.append(hullNeighbor, neighborOfHull)
+            hullNeighborUnique = np.unique(hullNeighbor)
+            pointsNew = np.unique(np.append(pointsOriginal, hullNeighborUnique))
             tri = Delaunay(tri.points[pointsNew])  # re-meshing
             mesh.append([tri, indOrigPoints[pointsNew]])
 
@@ -1032,36 +989,36 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
             # get virtual mic projections on new coord system
             virtNewCoord = cartToCyl(mpos_virt, self.Q)
             # get real mic projections on new coord system
-            indReorderHelp = argsort(cartToCyl(mpos, self.Q)[0])
+            indReorderHelp = np.argsort(cartToCyl(mpos, self.Q)[0])
             newCoord = cartToCyl(mpos, self.Q)
             # Delaunay
             tri = Delaunay(newCoord.T, incremental=True)  # , incremental=True,qhull_options =  "Qc QJ Q12"
 
             if self.interp_at_zero:
                 # add a point at zero
-                tri.add_points(array([[0], [0], [0]]).T)
+                tri.add_points(np.array([[0], [0], [0]]).T)
 
             # extend mesh with closest boundary points of repeating mesh
-            pointsOriginal = arange(tri.points.shape[0])
+            pointsOriginal = np.arange(tri.points.shape[0])
             hull = tri.convex_hull
-            hullPoints = unique(hull)
+            hullPoints = np.unique(hull)
 
             addRight = tri.points[hullPoints]
-            addRight[:, 0] += 2 * pi
+            addRight[:, 0] += 2 * np.pi
             addLeft = tri.points[hullPoints]
-            addLeft[:, 0] -= 2 * pi
+            addLeft[:, 0] -= 2 * np.pi
 
-            indOrigPoints = concatenate((pointsOriginal, pointsOriginal[hullPoints], pointsOriginal[hullPoints]))
+            indOrigPoints = np.concatenate((pointsOriginal, pointsOriginal[hullPoints], pointsOriginal[hullPoints]))
             # add all hull vertices to original mesh and check which of those
             # are actual neighbors of the original array. Cancel out all others.
-            tri.add_points(concatenate([addLeft, addRight]))
+            tri.add_points(np.concatenate([addLeft, addRight]))
             indices, indptr = tri.vertex_neighbor_vertices
-            hullNeighbor = empty((0), dtype='int32')
+            hullNeighbor = np.empty((0), dtype='int32')
             for currHull in hullPoints:
                 neighborOfHull = indptr[indices[currHull] : indices[currHull + 1]]
-                hullNeighbor = append(hullNeighbor, neighborOfHull)
-            hullNeighborUnique = unique(hullNeighbor)
-            pointsNew = unique(append(pointsOriginal, hullNeighborUnique))
+                hullNeighbor = np.append(hullNeighbor, neighborOfHull)
+            hullNeighborUnique = np.unique(hullNeighbor)
+            pointsNew = np.unique(np.append(pointsOriginal, hullNeighborUnique))
             tri = Delaunay(tri.points[pointsNew])  # re-meshing
             mesh.append([tri, indOrigPoints[pointsNew]])
 
@@ -1090,24 +1047,24 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
         # number of time samples
         nTime = p.shape[0]
         # number of virtual mixcs
-        nVirtMics = self.mics_virtual.mpos.shape[1]
+        nVirtMics = self.mics_virtual.pos.shape[1]
         # mesh and projection onto polar Coordinates
         meshList, virtNewCoord, newCoord = self._get_virtNewCoord()
         # pressure interpolation init
-        pInterp = zeros((nTime, nVirtMics))
+        pInterp = np.zeros((nTime, nVirtMics))
         # Coordinates in cartesian CO - for IDW interpolation
         newCoordCart = cylToCart(newCoord)
 
         if self.interp_at_zero:
             # interpolate point at 0 in Kartesian CO
             interpolater = LinearNDInterpolator(
-                cylToCart(newCoord[:, argsort(newCoord[0])])[:2, :].T,
-                p[:, (argsort(newCoord[0]))].T,
+                cylToCart(newCoord[:, np.argsort(newCoord[0])])[:2, :].T,
+                p[:, (np.argsort(newCoord[0]))].T,
                 fill_value=0,
             )
             pZero = interpolater((0, 0))
             # add the interpolated pressure at origin to pressure channels
-            p = concatenate((p, pZero[:, newaxis]), axis=1)
+            p = np.concatenate((p, pZero[:, np.newaxis]), axis=1)
 
         # helpfunction reordered for reordered pressure values
         pHelp = p[:, meshList[0][1]]
@@ -1115,31 +1072,31 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
         # Interpolation for 1D Arrays
         if self.array_dimension == '1D' or self.array_dimension == 'ring':
             # for rotation add phi_delay
-            if not array_equal(phi_delay, []):
-                xInterpHelp = tile(virtNewCoord[0, :], (nTime, 1)) + tile(phi_delay, (virtNewCoord.shape[1], 1)).T
-                xInterp = ((xInterpHelp + pi) % (2 * pi)) - pi  #  shifting phi cootrdinate into feasible area [-pi, pi]
+            if not np.array_equal(phi_delay, []):
+                xInterpHelp = np.tile(virtNewCoord[0, :], (nTime, 1)) + np.tile(phi_delay, (virtNewCoord.shape[1], 1)).T
+                xInterp = ((xInterpHelp + np.pi) % (2 * np.pi)) - np.pi  #  shifting phi into feasible area [-pi, pi]
             # if no rotation given
             else:
-                xInterp = tile(virtNewCoord[0, :], (nTime, 1))
+                xInterp = np.tile(virtNewCoord[0, :], (nTime, 1))
             # get ordered microphone positions in radiant
             x = newCoord[0]
             for cntTime in range(nTime):
                 if self.method == 'linear':
                     # numpy 1-d interpolation
-                    pInterp[cntTime] = interp(
+                    pInterp[cntTime] = np.interp(
                         xInterp[cntTime, :],
                         x,
                         pHelp[cntTime, :],
                         period=period,
-                        left=nan,
-                        right=nan,
+                        left=np.nan,
+                        right=np.nan,
                     )
 
                 elif self.method == 'spline':
                     # scipy cubic spline interpolation
                     SplineInterp = CubicSpline(
-                        append(x, (2 * pi) + x[0]),
-                        append(pHelp[cntTime, :], pHelp[cntTime, :][0]),
+                        np.append(x, (2 * np.pi) + x[0]),
+                        np.append(pHelp[cntTime, :], pHelp[cntTime, :][0]),
                         axis=0,
                         bc_type='periodic',
                         extrapolate=None,
@@ -1173,16 +1130,18 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
         # Interpolation for arbitrary 2D Arrays
         elif self.array_dimension == '2D':
             # check rotation
-            if not array_equal(phi_delay, []):
-                xInterpHelp = tile(virtNewCoord[0, :], (nTime, 1)) + tile(phi_delay, (virtNewCoord.shape[1], 1)).T
-                xInterp = ((xInterpHelp + pi) % (2 * pi)) - pi  # shifting phi cootrdinate into feasible area [-pi, pi]
+            if not np.array_equal(phi_delay, []):
+                xInterpHelp = np.tile(virtNewCoord[0, :], (nTime, 1)) + np.tile(phi_delay, (virtNewCoord.shape[1], 1)).T
+                xInterp = ((xInterpHelp + np.pi) % (2 * np.pi)) - np.pi  # shifting phi into feasible area [-pi, pi]
             else:
-                xInterp = tile(virtNewCoord[0, :], (nTime, 1))
+                xInterp = np.tile(virtNewCoord[0, :], (nTime, 1))
 
             mesh = meshList[0][0]
             for cntTime in range(nTime):
                 # points for interpolation
-                newPoint = concatenate((xInterp[cntTime, :][:, newaxis], virtNewCoord[1, :][:, newaxis]), axis=1)
+                newPoint = np.concatenate(
+                    (xInterp[cntTime, :][:, np.newaxis], virtNewCoord[1, :][:, np.newaxis]), axis=1
+                )
                 # scipy 1D interpolation
                 if self.method == 'linear':
                     interpolater = LinearNDInterpolator(mesh, pHelp[cntTime, :], fill_value=0)
@@ -1215,7 +1174,7 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
                         function='cubic',
                     )  # radial basis function interpolator instance
 
-                    virtshiftcoord = array([xInterp[cntTime, :], virtNewCoord[1], virtNewCoord[2]])
+                    virtshiftcoord = np.array([xInterp[cntTime, :], virtNewCoord[1], virtNewCoord[2]])
                     pInterp[cntTime] = rbfi(virtshiftcoord[0], virtshiftcoord[1], virtshiftcoord[2])
 
                 elif self.method == 'rbf-multiquadric':
@@ -1228,40 +1187,40 @@ class SpatialInterpolator(TimeOut):  # pragma: no cover
                         function='multiquadric',
                     )  # radial basis function interpolator instance
 
-                    virtshiftcoord = array([xInterp[cntTime, :], virtNewCoord[1], virtNewCoord[2]])
+                    virtshiftcoord = np.array([xInterp[cntTime, :], virtNewCoord[1], virtNewCoord[2]])
                     pInterp[cntTime] = rbfi(virtshiftcoord[0], virtshiftcoord[1], virtshiftcoord[2])
                 # using inverse distance weighting
                 elif self.method == 'IDW':
                     newPoint2_M = newPoint.T
-                    newPoint3_M = append(newPoint2_M, zeros([1, self.num_channels]), axis=0)
+                    newPoint3_M = np.append(newPoint2_M, np.zeros([1, self.num_channels]), axis=0)
                     newPointCart = cylToCart(newPoint3_M)
-                    for ind in arange(len(newPoint[:, 0])):
-                        newPoint_Rep = tile(newPointCart[:, ind], (len(newPoint[:, 0]), 1)).T
+                    for ind in np.arange(len(newPoint[:, 0])):
+                        newPoint_Rep = np.tile(newPointCart[:, ind], (len(newPoint[:, 0]), 1)).T
                         subtract = newPoint_Rep - newCoordCart
-                        normDistance = norm(subtract, axis=0)
-                        index_norm = argsort(normDistance)[: self.num_IDW]
+                        normDistance = spla.norm(subtract, axis=0)
+                        index_norm = np.argsort(normDistance)[: self.num_IDW]
                         pHelpNew = pHelp[cntTime, index_norm]
                         normNew = normDistance[index_norm]
                         if normNew[0] < 1e-3:
                             pInterp[cntTime, ind] = pHelpNew[0]
                         else:
-                            wholeD = sum(1 / normNew**self.p_weight)
+                            wholeD = np.sum(1 / normNew**self.p_weight)
                             weight = (1 / normNew**self.p_weight) / wholeD
-                            pInterp[cntTime, ind] = sum(pHelpNew * weight)
+                            pInterp[cntTime, ind] = np.sum(pHelpNew * weight)
 
         # Interpolation for arbitrary 3D Arrays
         elif self.array_dimension == '3D':
             # check rotation
-            if not array_equal(phi_delay, []):
-                xInterpHelp = tile(virtNewCoord[0, :], (nTime, 1)) + tile(phi_delay, (virtNewCoord.shape[1], 1)).T
-                xInterp = ((xInterpHelp + pi) % (2 * pi)) - pi  # shifting phi cootrdinate into feasible area [-pi, pi]
+            if not np.array_equal(phi_delay, []):
+                xInterpHelp = np.tile(virtNewCoord[0, :], (nTime, 1)) + np.tile(phi_delay, (virtNewCoord.shape[1], 1)).T
+                xInterp = ((xInterpHelp + np.pi) % (2 * np.pi)) - np.pi  # shifting phi into feasible area [-pi, pi]
             else:
-                xInterp = tile(virtNewCoord[0, :], (nTime, 1))
+                xInterp = np.tile(virtNewCoord[0, :], (nTime, 1))
 
             mesh = meshList[0][0]
             for cntTime in range(nTime):
                 # points for interpolation
-                newPoint = concatenate((xInterp[cntTime, :][:, newaxis], virtNewCoord[1:, :].T), axis=1)
+                newPoint = np.concatenate((xInterp[cntTime, :][:, np.newaxis], virtNewCoord[1:, :].T), axis=1)
 
                 if self.method == 'linear':
                     interpolater = LinearNDInterpolator(mesh, pHelp[cntTime, :], fill_value=0)
@@ -1391,9 +1350,9 @@ class SpatialInterpolatorRotation(SpatialInterpolator):  # pragma: no cover
             a multiple of ``num``.
         """
         # period for rotation
-        period = 2 * pi
+        period = 2 * np.pi
         # get angle
-        angle = self.angle_source.angle()
+        angle = self.angle_source.angle
         # counter to track angle position in time for each block
         count = 0
         for timeData in self.source.result(num):
@@ -1464,12 +1423,12 @@ class SpatialInterpolatorConstantRotation(SpatialInterpolator):  # pragma: no co
             The last block may contain fewer samples if the total number of samples is not
             a multiple of ``num``.
         """
-        omega = 2 * pi * self.rotational_speed
-        period = 2 * pi
+        omega = 2 * np.pi * self.rotational_speed
+        period = 2 * np.pi
         phiOffset = 0.0
         for timeData in self.source.result(num):
             nTime = timeData.shape[0]
-            phi_delay = phiOffset + linspace(0, nTime / self.sample_freq * omega, nTime, endpoint=False)
+            phi_delay = phiOffset + np.linspace(0, nTime / self.sample_freq * omega, nTime, endpoint=False)
             interpVal = self._result_core_func(timeData, phi_delay, period, self.Q, interp_at_zero=False)
             phiOffset = phi_delay[-1] + omega / self.sample_freq
             yield interpVal
@@ -1521,16 +1480,18 @@ class Mixer(TimeOut):
         return digest(self)
 
     def validate_sources(self):
-        # Validate whether the additional sources are compatible with the primary source.
-        #
-        # This method checks if all sources have the same sampling frequency and the same number of
-        # channels. If a mismatch is detected, a :obj:`ValueError` is raised.
-        #
-        # Raises
-        # ------
-        # :obj:`ValueError`
-        #     If any source in :attr:`sources` has a different sampling frequency or
-        #     number of channels than :attr:`source`.
+        """
+        Validate whether the additional sources are compatible with the primary source.
+
+        This method checks if all sources have the same sampling frequency and the same number of
+        channels. If a mismatch is detected, a :obj:`ValueError` is raised.
+
+        Raises
+        ------
+        :obj:`ValueError`
+            If any source in :attr:`sources` has a different sampling frequency or
+            number of channels than :attr:`source`.
+        """
         if self.source:
             for s in self.sources:
                 if self.sample_freq != s.sample_freq:
@@ -1681,12 +1642,12 @@ class TimeCumAverage(TimeOut):
         recalculated by summing the previous cumulative value and the new samples, then dividing by
         the total number of samples up to that point.
         """
-        count = (arange(num) + 1)[:, newaxis]
+        count = (np.arange(num) + 1)[:, np.newaxis]
         for i, temp in enumerate(self.source.result(num)):
             ns, nc = temp.shape
             if not i:
-                accu = zeros((1, nc))
-            temp = (accu * (count[0] - 1) + cumsum(temp, axis=0)) / count[:ns]
+                accu = np.zeros((1, nc))
+            temp = (accu * (count[0] - 1) + np.cumsum(temp, axis=0)) / count[:ns]
             accu = temp[-1]
             count += ns
             yield temp
@@ -1724,7 +1685,7 @@ class TimeReverse(TimeOut):
         ------
         :class:`numpy.ndarray`
             An array containing the time-reversed version of the signal for the current block.
-            Each block will have the shape (``num``, :attr:`acoular.base.TimeOut.num_channels`),
+            Each block will have the shape (``num``, :attr:`~acoular.base.TimeOut.num_channels`),
             where :attr:`~acoular.base.TimeOut.num_channels` is inherited from the :attr:`source`.
             The last block may contain fewer samples if the total number of samples is not
             a multiple of ``num``.
@@ -1739,7 +1700,7 @@ class TimeReverse(TimeOut):
         """
         result_list = []
         result_list.extend(self.source.result(num))
-        temp = empty_like(result_list[0])
+        temp = np.empty_like(result_list[0])
         h = result_list.pop()
         nsh = h.shape[0]
         temp[:nsh] = h[::-1]
@@ -1803,7 +1764,7 @@ class Filter(TimeOut):
             a multiple of ``num``.
         """
         sos = self.sos
-        zi = zeros((sos.shape[0], 2, self.source.num_channels))
+        zi = np.zeros((sos.shape[0], 2, self.source.num_channels))
         for block in self.source.result(num):
             sos = self.sos  # this line is useful in case of changes
             # to self.sos during generator lifetime
@@ -1829,7 +1790,7 @@ class FiltOctave(Filter):
     """
 
     #: The center frequency of the octave or third-octave band. Default is ``1000``.
-    band = Float(1000.0, desc='band center frequency')
+    band = Float(1000.0)
 
     #: Defines whether the filter is an octave-band or third-octave-band filter.
     #:
@@ -1837,11 +1798,11 @@ class FiltOctave(Filter):
     #: - ``'Third octave'``: Third-octave band filter.
     #:
     #: Default is ``'Octave'``.
-    fraction = Map({'Octave': 1, 'Third octave': 3}, default_value='Octave', desc='fraction of octave')
+    fraction = Map({'Octave': 1, 'Third octave': 3}, default_value='Octave')
 
     #: The order of the IIR filter, which affects the steepness of the filter's roll-off.
     #: Default is ``3``.
-    order = Int(3, desc='IIR filter order')
+    order = Int(3)
 
     #: Second-order sections representation of the filter coefficients. This property depends on
     #: :attr:`band`, :attr:`fraction`, :attr:`order`, and the source's digest.
@@ -1880,12 +1841,12 @@ class FiltOctave(Filter):
         # adjust filter edge frequencies for correct power bandwidth (see ANSI 1.11 1987
         # and Kalb,J.T.: "A thirty channel real time audio analyzer and its applications",
         # PhD Thesis: Georgia Inst. of Techn., 1975
-        beta = pi / (2 * self.order)
+        beta = np.pi / (2 * self.order)
         alpha = pow(2.0, 1.0 / (2.0 * self.fraction_))
-        beta = 2 * beta / sin(beta) / (alpha - 1 / alpha)
-        alpha = (1 + sqrt(1 + beta * beta)) / beta
+        beta = 2 * beta / np.sin(beta) / (alpha - 1 / alpha)
+        alpha = (1 + np.sqrt(1 + beta * beta)) / beta
         fr = 2 * self.band / fs
-        if fr > 1 / sqrt(2):
+        if fr > 1 / np.sqrt(2):
             msg = f'band frequency too high:{self.band:f},{fs:f}'
             raise ValueError(msg)
         om1 = fr / alpha
@@ -1916,7 +1877,7 @@ class FiltFiltOctave(FiltOctave):
 
     #: The half-order of the IIR filter, applied twice (once forward and once backward). This
     #: results in a final filter order twice as large as the specified value. Default is ``2``.
-    order = Int(2, desc='IIR filter half order')
+    order = Int(2)
 
     #: A unique identifier for the filter, based on its properties. (read-only)
     digest = Property(depends_on=['source.digest', 'band', 'fraction', 'order'])
@@ -1946,16 +1907,16 @@ class FiltFiltOctave(FiltOctave):
         # filter design
         fs = self.sample_freq
         # adjust filter edge frequencies for correct power bandwidth (see FiltOctave)
-        beta = pi / (2 * self.order)
+        beta = np.pi / (2 * self.order)
         alpha = pow(2.0, 1.0 / (2.0 * self.fraction_))
-        beta = 2 * beta / sin(beta) / (alpha - 1 / alpha)
-        alpha = (1 + sqrt(1 + beta * beta)) / beta
+        beta = 2 * beta / np.sin(beta) / (alpha - 1 / alpha)
+        alpha = (1 + np.sqrt(1 + beta * beta)) / beta
         # additional bandwidth correction for double-pass
         alpha = alpha * {6: 1.01, 5: 1.012, 4: 1.016, 3: 1.022, 2: 1.036, 1: 1.083}.get(self.order, 1.0) ** (
             3 / self.fraction_
         )
         fr = 2 * self.band / fs
-        if fr > 1 / sqrt(2):
+        if fr > 1 / np.sqrt(2):
             msg = f'band frequency too high:{self.band:f},{fs:f}'
             raise ValueError(msg)
         om1 = fr / alpha
@@ -1990,7 +1951,7 @@ class FiltFiltOctave(FiltOctave):
         - Filtering is performed separately for each channel to optimize memory usage.
         """
         sos = self.sos
-        data = empty((self.source.num_samples, self.source.num_channels))
+        data = np.empty((self.source.num_samples, self.source.num_channels))
         j = 0
         for block in self.source.result(num):
             ns, nc = block.shape
@@ -2031,7 +1992,7 @@ class TimeExpAverage(Filter):
     #: - ``'I'`` (Impulse) → 0.035 (non-standard)
     #:
     #: Default is ``'F'``.
-    weight = Map({'F': 0.125, 'S': 1.0, 'I': 0.035}, default_value='F', desc='time weighting')
+    weight = Map({'F': 0.125, 'S': 1.0, 'I': 0.035}, default_value='F')
 
     #: Filter coefficients in second-order section (SOS) format.
     sos = Property(depends_on=['weight', 'source.digest'])
@@ -2073,7 +2034,7 @@ class TimeExpAverage(Filter):
         #
         # This implementation ensures that the filter adapts dynamically
         # based on the source's sampling frequency.
-        alpha = 1 - exp(-1 / self.weight_ / self.sample_freq)
+        alpha = 1 - np.exp(-1 / self.weight_ / self.sample_freq)
         a = [1, alpha - 1]
         b = [alpha]
         return tf2sos(b, a)
@@ -2104,7 +2065,7 @@ class FiltFreqWeight(Filter):
     #: - ``'Z'``: A flat response with no frequency weighting.
     #:
     #: Default is ``'A'``.
-    weight = Enum('A', 'C', 'Z', desc='frequency weighting')
+    weight = Enum('A', 'C', 'Z')
 
     #: Second-order sections (SOS) representation of the filter coefficients. This property is
     #: dynamically computed based on :attr:`weight` and the :attr:`Filter.source`'s digest.
@@ -2163,38 +2124,37 @@ class FiltFreqWeight(Filter):
         f2 = 107.65265
         f3 = 737.86223
         f4 = 12194.217
-        a = polymul([1, 4 * pi * f4, (2 * pi * f4) ** 2], [1, 4 * pi * f1, (2 * pi * f1) ** 2])
+        a = np.polymul([1, 4 * np.pi * f4, (2 * np.pi * f4) ** 2], [1, 4 * np.pi * f1, (2 * np.pi * f1) ** 2])
         if self.weight == 'A':
-            a = polymul(polymul(a, [1, 2 * pi * f3]), [1, 2 * pi * f2])
-            b = [(2 * pi * f4) ** 2 * 10 ** (1.9997 / 20), 0, 0, 0, 0]
+            a = np.polymul(np.polymul(a, [1, 2 * np.pi * f3]), [1, 2 * np.pi * f2])
+            b = [(2 * np.pi * f4) ** 2 * 10 ** (1.9997 / 20), 0, 0, 0, 0]
             b, a = bilinear(b, a, self.sample_freq)
         elif self.weight == 'C':
-            b = [(2 * pi * f4) ** 2 * 10 ** (0.0619 / 20), 0, 0]
+            b = [(2 * np.pi * f4) ** 2 * 10 ** (0.0619 / 20), 0, 0]
             b, a = bilinear(b, a, self.sample_freq)
-            b = append(b, zeros(2))  # make 6th order
-            a = append(a, zeros(2))
+            b = np.append(b, np.zeros(2))  # make 6th order
+            a = np.append(a, np.zeros(2))
         else:
-            b = zeros(7)
+            b = np.zeros(7)
             b[0] = 1.0
             a = b  # 6th order flat response
         return tf2sos(b, a)
 
 
-@deprecated_alias({'numbands': 'num_bands'}, read_only=True, removal_version='25.10')
 class FilterBank(TimeOut):
     """
     Abstract base class for IIR filter banks based on :mod:`scipy.signal.lfilter`.
 
     Implements a bank of parallel filters. This class should not be instantiated by itself.
 
-    Inherits from :class:`acoular.base.TimeOut`, and defines the structure for working with filter
+    Inherits from :class:`~acoular.base.TimeOut`, and defines the structure for working with filter
     banks for processing multi-channel time series data, such as time signal signals.
 
     See Also
     --------
-    :class:`acoular.base.TimeOut` :
+    :class:`~acoular.base.TimeOut` :
         ABC for signal processing blocks that interact with data from a source.
-    :class:`acoular.base.SamplesGenerator` :
+    :class:`~acoular.base.SamplesGenerator` :
         Interface for any generating multi-channel time domain signal processing block.
     :mod:`scipy.signal` :
         SciPy module for signal processing.
@@ -2260,12 +2220,13 @@ class FilterBank(TimeOut):
         numbands = self.num_bands
         snumch = self.source.num_channels
         sos = self.sos
-        zi = [zeros((sos[0].shape[0], 2, snumch)) for _ in range(numbands)]
-        res = zeros((num, self.num_channels), dtype='float')
+        zi = [np.zeros((sos[0].shape[0], 2, snumch)) for _ in range(numbands)]
+        res = np.zeros((num, self.num_channels), dtype='float')
         for block in self.source.result(num):
+            len_block = block.shape[0]
             for i in range(numbands):
-                res[:, i * snumch : (i + 1) * snumch], zi[i] = sosfilt(sos[i], block, axis=0, zi=zi[i])
-            yield res
+                res[:len_block, i * snumch : (i + 1) * snumch], zi[i] = sosfilt(sos[i], block, axis=0, zi=zi[i])
+            yield res[:len_block]
 
 
 class OctaveFilterBank(FilterBank):
@@ -2280,7 +2241,7 @@ class OctaveFilterBank(FilterBank):
     --------
     :class:`FilterBank` :
         The base class for implementing IIR filter banks.
-    :class:`acoular.base.SamplesGenerator` :
+    :class:`~acoular.base.SamplesGenerator` :
         Interface for generating multi-channel time domain signal processing blocks.
     :mod:`scipy.signal` :
         SciPy module for signal processing.
@@ -2288,17 +2249,17 @@ class OctaveFilterBank(FilterBank):
 
     #: The lowest band center frequency index. Default is ``21``.
     #: This index refers to the position in the scale of octave or third-octave bands.
-    lband = Int(21, desc='lowest band center frequency index')
+    lband = Int(21)
 
     #: The highest band center frequency index + 1. Default is ``40``.
     #: This is the position in the scale of octave or third-octave bands.
-    hband = Int(40, desc='highest band center frequency index + 1')
+    hband = Int(40)
 
     #: The fraction of an octave, either ``'Octave'`` or ``'Third octave'``.
     #: Default is ``'Octave'``.
     #: Determines the width of the frequency bands. 'Octave' refers to full octaves,
     #: and ``'Third octave'`` refers to third-octave bands.
-    fraction = Map({'Octave': 1, 'Third octave': 3}, default_value='Octave', desc='fraction of octave')
+    fraction = Map({'Octave': 1, 'Third octave': 3}, default_value='Octave')
 
     #: The list of filter coefficients for all filters in the filter bank.
     #: The coefficients are computed based on the :attr:`lband`, :attr:`hband`,
@@ -2347,7 +2308,6 @@ class OctaveFilterBank(FilterBank):
         return sos
 
 
-@deprecated_alias({'name': 'file'}, removal_version='25.10')
 class WriteWAV(TimeOut):
     """
     Saves time signal from one or more channels as mono, stereo, or multi-channel ``.wav`` file.
@@ -2358,9 +2318,9 @@ class WriteWAV(TimeOut):
 
     See Also
     --------
-    :class:`acoular.base.TimeOut` :
+    :class:`~acoular.base.TimeOut` :
         ABC for signal processing blocks that interact with data from a source.
-    :class:`acoular.base.SamplesGenerator` :
+    :class:`~acoular.base.SamplesGenerator` :
         Interface for generating multi-channel time domain signal processing blocks.
     :mod:`wave` :
         Python module for handling WAV files.
@@ -2372,20 +2332,22 @@ class WriteWAV(TimeOut):
 
     #: The name of the file to be saved. If none is given, the name will be automatically
     #: generated from the source.
-    file = File(filter=['*.wav'], desc='name of wave file')
+    file = File(filter=['*.wav'])
 
     #: The name of the cache file (without extension). It serves as an internal reference for data
     #: caching and tracking processed files. (automatically generated)
     basename = Property(depends_on=['digest'])
 
     #: The list of channels to save. Can only contain one or two channels.
-    channels = List(int, desc='channels to save')
+    channels = List(int)
 
     # Bit depth of the output file.
-    encoding = Enum('uint8', 'int16', 'int32', desc='bit depth of the output file')
+    #: bit depth of the output file
+    encoding = Enum('uint8', 'int16', 'int32')
 
     # Maximum value to scale the output to. If `None`, the maximum value of the data is used.
-    max_val = Either(None, Float, desc='Maximum value to scale the output to.')
+    #: Maximum value to scale the output to.
+    max_val = Either(None, Float)
 
     #: A unique identifier for the filter, based on its properties. (read-only)
     digest = Property(depends_on=['source.digest', 'channels'])
@@ -2485,7 +2447,7 @@ class WriteWAV(TimeOut):
             wf.setnchannels(nc)
             wf.setsampwidth(sw)
             wf.setframerate(fs)
-            ind = array(self.channels)
+            ind = np.array(self.channels)
             if self.max_val is None:
                 # compute maximum and remember result to avoid calling source twice
                 if not isinstance(self.source, Cache):
@@ -2495,7 +2457,7 @@ class WriteWAV(TimeOut):
                 if dtype == np.dtype('uint8'):
                     mx = 0
                     for data in self.source.result(num):
-                        mx = max(abs(data).max(), mx)
+                        mx = max(np.abs(data).max(), mx)
                 elif dtype in (np.dtype('int16'), np.dtype('int32')):
                     # for signed integers, we need special treatment because of asymmetry
                     negmax, posmax = 0, 0
@@ -2528,9 +2490,6 @@ class WriteWAV(TimeOut):
             pass
 
 
-@deprecated_alias(
-    {'name': 'file', 'numsamples_write': 'num_samples_write', 'writeflag': 'write_flag'}, removal_version='25.10'
-)
 class WriteH5(TimeOut):
     """
     Saves time signal data as a ``.h5`` (HDF5) file.
@@ -2541,9 +2500,9 @@ class WriteH5(TimeOut):
 
     See Also
     --------
-    :class:`acoular.base.TimeOut` :
+    :class:`~acoular.base.TimeOut` :
         ABC for signal processing blocks interacting with data from a source.
-    :class:`acoular.base.SamplesGenerator` :
+    :class:`~acoular.base.SamplesGenerator` :
         Interface for generating multi-channel time-domain signal processing blocks.
     h5py :
         Python library for reading and writing HDF5 files.
@@ -2555,7 +2514,7 @@ class WriteH5(TimeOut):
 
     #: The name of the file to be saved. If none is given, the name is automatically
     #: generated based on the current timestamp.
-    file = File(filter=['*.h5'], desc='name of data file')
+    file = File(filter=['*.h5'])
 
     #: The number of samples to write to file per call to `result` method.
     #: Default is ``-1``, meaning all available data from the source will be written.
@@ -2569,10 +2528,10 @@ class WriteH5(TimeOut):
 
     #: Precision of the entries in the HDF5 file, represented as numpy data types.
     #: Default is ``'float32'``.
-    precision = Enum('float32', 'float64', desc='precision of H5 File')
+    precision = Enum('float32', 'float64')
 
     #: Metadata to be stored in the HDF5 file.
-    metadata = Dict(desc='metadata to be stored in .h5 file')
+    metadata = Dict()
 
     @cached_property
     def _get_digest(self):
@@ -2646,7 +2605,7 @@ class WriteH5(TimeOut):
             f5h.create_new_group('metadata', '/')
             for key, value in self.metadata.items():
                 if isinstance(value, str):
-                    value = array(value, dtype='S')
+                    value = np.array(value, dtype='S')
                 f5h.create_array('/metadata', key, value)
 
     def result(self, num):
@@ -2716,9 +2675,9 @@ class TimeConvolve(TimeOut):
 
     See Also
     --------
-    :class:`acoular.base.TimeOut` :
+    :class:`~acoular.base.TimeOut` :
         The parent class for signal processing blocks.
-    :class:`acoular.base.SamplesGenerator` :
+    :class:`~acoular.base.SamplesGenerator` :
         The interface for generating multi-channel time-domain signals.
     """
 
@@ -2728,22 +2687,34 @@ class TimeConvolve(TimeOut):
 
     #: Convolution kernel in the time domain.
     #: The second dimension of the kernel array has to be either ``1`` or match
-    #: the :attr:`source`'s :attr:`~acoular.base.SamplesGenerator.num_channels` attribute.
+    #: the :attr:`source`'s :attr:`~acoular.base.Generator.num_channels` attribute.
     #: If only a single kernel is supplied, it is applied to all channels.
-    kernel = CArray(dtype=float, desc='Convolution kernel.')
+    kernel = CArray(dtype=float)
+
+    #: Controls whether to extend the output to include the full convolution result.
+    #:
+    #: - If ``False`` (default): Output length is :math:`\\max(L, M)`, where :math:`L` is the
+    #:   kernel length and :math:`M` is the signal length. This mode keeps the output length
+    #:   equal to the longest input (different from NumPy's ``mode='same'``, since it does not
+    #:   pad the output).
+    #: - If ``True``: Output length is :math:`L + M - 1`, returning the full convolution at
+    #:   each overlap point (similar to NumPy's ``mode='full'``).
+    #:
+    #: Default is ``False``.
+    extend_signal = Bool(False)
 
     # Internal block size for partitioning signals into smaller segments during processing.
-    _block_size = Int(desc='Block size')
+    #: Block size
+    _block_size = Int()
 
     # Blocks of the convolution kernel in the frequency domain.
     # Computed using Fast Fourier Transform (FFT).
     _kernel_blocks = Property(
         depends_on=['kernel', '_block_size'],
-        desc='Frequency domain Kernel blocks',
     )
 
     #: A unique identifier for the object, based on its properties. (read-only)
-    digest = Property(depends_on=['source.digest', 'kernel'])
+    digest = Property(depends_on=['source.digest', 'kernel', 'extend_signal'])
 
     @cached_property
     def _get_digest(self):
@@ -2786,27 +2757,27 @@ class TimeConvolve(TimeOut):
         #     A 3D array of complex values representing the frequency-domain blocks of the kernel.
         [L, N] = self.kernel.shape
         num = self._block_size
-        P = int(ceil(L / num))
+        P = int(np.ceil(L / num))
         trim = num * (P - 1)
-        blocks = zeros([P, num + 1, N], dtype='complex128')
+        blocks = np.zeros([P, num + 1, N], dtype='complex128')
 
         if P > 1:
-            for i, block in enumerate(split(self.kernel[:trim], P - 1, axis=0)):
-                blocks[i] = rfft(concatenate([block, zeros([num, N])], axis=0), axis=0)
+            for i, block in enumerate(np.split(self.kernel[:trim], P - 1, axis=0)):
+                blocks[i] = rfft(np.concatenate([block, np.zeros([num, N])], axis=0), axis=0)
 
         blocks[-1] = rfft(
-            concatenate([self.kernel[trim:], zeros([2 * num - L + trim, N])], axis=0),
+            np.concatenate([self.kernel[trim:], np.zeros([2 * num - L + trim, N])], axis=0),
             axis=0,
         )
         return blocks
 
     def result(self, num=128):
-        """
+        r"""
         Convolve the source signal with the kernel and yield the result in blocks.
 
-        The method generates the convolution of the source signal with the kernel by processing the
-        signal in small blocks, performing the convolution in the frequency domain, and yielding the
-        results block by block.
+        The method generates the convolution of the source signal (length :math:`M`) with the kernel
+        (length :math:`L`) by processing the signal in small blocks, performing the convolution in
+        the frequency domain, and yielding the results block by block.
 
         Parameters
         ----------
@@ -2817,14 +2788,15 @@ class TimeConvolve(TimeOut):
         Yields
         ------
         :obj:`numpy.ndarray`
-            A array of shape (``num``, :attr:`~acoular.base.SamplesGenerator.num_channels`),
-            where :attr:`~acoular.base.SamplesGenerator.num_channels` is inhereted from the
+            An array of shape (``num``, :attr:`~acoular.base.Generator.num_channels`),
+            where :attr:`~acoular.base.Generator.num_channels` is inherited from the
             :attr:`source`, representing the convolution result in blocks.
 
         Notes
         -----
         - The kernel is first validated and reshaped if necessary.
         - The convolution is computed efficiently using the FFT in the frequency domain.
+        - The output length is determined by the :attr:`extend_signal` property.
         """
         self._validate_kernel()
         # initialize variables
@@ -2832,15 +2804,18 @@ class TimeConvolve(TimeOut):
         L = self.kernel.shape[0]
         N = self.source.num_channels
         M = self.source.num_samples
-        numblocks_kernel = int(ceil(L / num))  # number of kernel blocks
-        Q = int(ceil(M / num))  # number of signal blocks
-        R = int(ceil((L + M - 1) / num))  # number of output blocks
-        last_size = (L + M - 1) % num  # size of final block
+
+        output_size = max(L, M) if not self.extend_signal else L + M - 1
+
+        numblocks_kernel = int(np.ceil(L / num))  # number of kernel blocks
+        Q = int(np.ceil(M / num))  # number of signal blocks
+        R = int(np.ceil(output_size / num))  # number of output blocks
+        last_size = output_size % num  # size of final output block
 
         idx = 0
-        fdl = zeros([numblocks_kernel, num + 1, N], dtype='complex128')
-        buff = zeros([2 * num, N])  # time-domain input buffer
-        spec_sum = zeros([num + 1, N], dtype='complex128')
+        fdl = np.zeros([numblocks_kernel, num + 1, N], dtype='complex128')
+        buff = np.zeros([2 * num, N])  # time-domain input buffer
+        spec_sum = np.zeros([num + 1, N], dtype='complex128')
 
         signal_blocks = self.source.result(num)
         temp = next(signal_blocks)
@@ -2851,7 +2826,8 @@ class TimeConvolve(TimeOut):
             _append_to_fdl(fdl, idx, numblocks_kernel, rfft(buff, axis=0))
             spec_sum = _spectral_sum(spec_sum, fdl, self._kernel_blocks)
             # truncate s.t. total length is L+M-1 (like numpy convolve w/ mode="full")
-            yield irfft(spec_sum, axis=0)[num : last_size + num]
+            final_len = last_size if last_size != 0 else num
+            yield irfft(spec_sum, axis=0)[num : final_len + num]
             return
 
         # stream processing of source signal
@@ -2859,8 +2835,8 @@ class TimeConvolve(TimeOut):
             _append_to_fdl(fdl, idx, numblocks_kernel, rfft(buff, axis=0))
             spec_sum = _spectral_sum(spec_sum, fdl, self._kernel_blocks)
             yield irfft(spec_sum, axis=0)[num:]
-            buff = concatenate(
-                [buff[num:], zeros([num, N])],
+            buff = np.concatenate(
+                [buff[num:], np.zeros([num, N])],
                 axis=0,
             )  # shift input buffer to the left
             buff[num : num + temp.shape[0]] = temp  # append new time-data
@@ -2869,15 +2845,16 @@ class TimeConvolve(TimeOut):
             _append_to_fdl(fdl, idx, numblocks_kernel, rfft(buff, axis=0))
             spec_sum = _spectral_sum(spec_sum, fdl, self._kernel_blocks)
             yield irfft(spec_sum, axis=0)[num:]
-            buff = concatenate(
-                [buff[num:], zeros([num, N])],
+            buff = np.concatenate(
+                [buff[num:], np.zeros([num, N])],
                 axis=0,
             )  # shift input buffer to the left
 
         _append_to_fdl(fdl, idx, numblocks_kernel, rfft(buff, axis=0))
         spec_sum = _spectral_sum(spec_sum, fdl, self._kernel_blocks)
         # truncate s.t. total length is L+M-1 (like numpy convolve w/ mode="full")
-        yield irfft(spec_sum, axis=0)[num : last_size + num]
+        final_len = last_size if last_size != 0 else num
+        yield irfft(spec_sum, axis=0)[num : final_len + num]
 
 
 @nb.jit(nopython=True, cache=True)