acoular 24.5__py3-none-any.whl → 24.10__py3-none-any.whl

acoular/tprocess.py

@@ -1,14 +1,12 @@
 # ------------------------------------------------------------------------------
 # Copyright (c) Acoular Development Team.
 # ------------------------------------------------------------------------------
-"""Implements processing in the time domain.
+"""Implements blockwise processing in the time domain.
 
 .. autosummary::
     :toctree: generated/
 
-    SamplesGenerator
-    TimeInOut
-    MaskedTimeInOut
+    MaskedTimeOut
     Trigger
     AngleTracker
     ChannelMixer
@@ -17,7 +15,7 @@
     SpatialInterpolatorConstantRotation
     Mixer
     TimePower
-    TimeAverage
+    TimeCumAverage
     TimeReverse
     Filter
     FilterBank
@@ -26,20 +24,15 @@
     TimeExpAverage
     FiltFreqWeight
     OctaveFilterBank
-    TimeCache
-    TimeCumAverage
     WriteWAV
     WriteH5
-    SampleSplitter
     TimeConvolve
+    MaskedTimeInOut
 """
 
 # imports from other packages
-import threading
 import wave
-from collections import deque
 from datetime import datetime, timezone
-from inspect import currentframe
 from os import path
 from warnings import warn
 
@@ -78,13 +71,13 @@ from numpy import (
     sqrt,
     stack,
     sum,
+    tile,
     unique,
     zeros,
 )
-from numpy.linalg import norm
-from numpy.matlib import repmat
 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 (
@@ -96,7 +89,6 @@ from traits.api import (
     Dict,
     File,
     Float,
-    HasPrivateTraits,
     Instance,
     Int,
     List,
@@ -109,100 +101,28 @@ from traits.api import (
     on_trait_change,
 )
 
+# acoular imports
+from .base import SamplesGenerator, TimeOut
 from .configuration import config
 from .environments import cartToCyl, cylToCart
-from .h5cache import H5cache
-from .h5files import H5CacheFileBase, _get_h5file_class
-
-# acoular imports
+from .h5files import _get_h5file_class
 from .internal import digest, ldigest
 from .microphones import MicGeom
 
 
-class SamplesGenerator(HasPrivateTraits):
-    """Base class for any generating signal processing block.
-
-    It provides a common interface for all SamplesGenerator classes, which
-    generate an output via the generator :meth:`result`.
-    This class has no real functionality on its own and should not be
-    used directly.
-    """
-
-    #: Sampling frequency of the signal, defaults to 1.0
-    sample_freq = Float(1.0, desc='sampling frequency')
-
-    #: Number of channels
-    numchannels = CLong
-
-    #: Number of samples
-    numsamples = CLong
-
-    # internal identifier
-    digest = Property(depends_on=['sample_freq', 'numchannels', 'numsamples'])
-
-    def _get_digest(self):
-        return digest(self)
-
-    def result(self, num):
-        """Python generator that yields the output block-wise.
-
-        Parameters
-        ----------
-        num : integer
-            This parameter defines the size of the blocks to be yielded
-            (i.e. the number of samples per block)
-
-        Returns
-        -------
-        No output since `SamplesGenerator` only represents a base class to derive
-        other classes from.
-
-        """
-
-
-class TimeInOut(SamplesGenerator):
-    """Base class for any time domain signal processing block,
-    gets samples from :attr:`source` and generates output via the
-    generator :meth:`result`.
-    """
-
-    #: Data source; :class:`~acoular.sources.SamplesGenerator` or derived object.
-    source = Trait(SamplesGenerator)
-
-    #: Sampling frequency of output signal, as given by :attr:`source`.
-    sample_freq = Delegate('source')
-
-    #: Number of channels in output, as given by :attr:`source`.
-    numchannels = Delegate('source')
-
-    #: Number of samples in output, as given by :attr:`source`.
-    numsamples = Delegate('source')
-
-    # internal identifier
-    digest = Property(depends_on=['source.digest'])
-
-    @cached_property
-    def _get_digest(self):
-        return digest(self)
-
-    def result(self, num):
-        """Python generator: dummy function, just echoes the output of source,
-        yields samples in blocks of shape (num, :attr:`numchannels`), the last block
-        may be shorter than num.
-        """
-        yield from self.source.result(num)
-
-
-class MaskedTimeInOut(TimeInOut):
+class MaskedTimeOut(TimeOut):
     """Signal processing block for channel and sample selection.
 
     This class serves as intermediary to define (in)valid
     channels and samples for any
     :class:`~acoular.sources.SamplesGenerator` (or derived) object.
-    It gets samples from :attr:`~acoular.tprocess.TimeInOut.source`
+    It gets samples from :attr:`~acoular.base.TimeOut.source`
     and generates output via the generator :meth:`result`.
     """
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     #: Index of the first sample to be considered valid.
     start = CLong(0, desc='start of valid samples')
 
@@ -215,10 +135,10 @@ class MaskedTimeInOut(TimeInOut):
     #: Channel mask to serve as an index for all valid channels, is set automatically.
     channels = Property(depends_on=['invalid_channels', 'source.numchannels'], desc='channel mask')
 
-    #: Number of channels in input, as given by :attr:`~acoular.tprocess.TimeInOut.source`.
+    #: Number of channels in input, as given by :attr:`~acoular.base.TimeOut.source`.
     numchannels_total = Delegate('source', 'numchannels')
 
-    #: Number of samples in input, as given by :attr:`~acoular.tprocess.TimeInOut.source`.
+    #: Number of samples in input, as given by :attr:`~acoular.base.TimeOut.source`.
     numsamples_total = Delegate('source', 'numsamples')
 
     #: Number of valid channels, is set automatically.
@@ -323,11 +243,14 @@ class MaskedTimeInOut(TimeInOut):
                 yield block[:, self.channels]
 
 
-class ChannelMixer(TimeInOut):
+class ChannelMixer(TimeOut):
     """Class for directly mixing the channels of a multi-channel source.
     Outputs a single channel.
     """
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     #: Amplitude weight(s) for the channels as array. If not set, all channels are equally weighted.
     weights = CArray(desc='channel weights')
 
@@ -369,7 +292,7 @@ class ChannelMixer(TimeInOut):
             yield sum(weights * block, 1, keepdims=True)
 
 
-class Trigger(TimeInOut):
+class Trigger(TimeOut):
     """Class for identifying trigger signals.
     Gets samples from :attr:`source` and stores the trigger samples in :meth:`trigger_data`.
 
@@ -383,7 +306,7 @@ class Trigger(TimeInOut):
     vary too much.
     """
 
-    #: Data source; :class:`~acoular.tprocess.SamplesGenerator` or derived object.
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
     source = Instance(SamplesGenerator)
 
     #: Threshold of trigger. Has different meanings for different
@@ -467,20 +390,20 @@ class Trigger(TimeInOut):
     def _get_trigger_data(self):
         self._check_trigger_existence()
         triggerFunc = {'dirac': self._trigger_dirac, 'rect': self._trigger_rect}[self.trigger_type]
-        nSamples = 2048  # number samples for result-method of source
-        threshold = self._threshold(nSamples)
+        num = 2048  # number samples for result-method of source
+        threshold = self._threshold(num)
 
         # get all samples which surpasse the threshold
         peakLoc = array([], dtype='int')  # all indices which surpasse the threshold
-        triggerData = array([])
+        trigger_data = array([])
         x0 = []
         dSamples = 0
-        for triggerSignal in self.source.result(nSamples):
+        for triggerSignal in self.source.result(num):
             localTrigger = flatnonzero(triggerFunc(x0, triggerSignal, threshold))
             if len(localTrigger) != 0:
                 peakLoc = append(peakLoc, localTrigger + dSamples)
-                triggerData = append(triggerData, triggerSignal[localTrigger])
-            dSamples += nSamples
+                trigger_data = append(trigger_data, triggerSignal[localTrigger])
+            dSamples += num
             x0 = triggerSignal[-1]
         if len(peakLoc) <= 1:
             msg = 'Not enough trigger info. Check *threshold* sign and value!'
@@ -498,12 +421,12 @@ class Trigger(TimeInOut):
             peakLocHelp = multiplePeaksWithinHunk[0]
             indHelp = [peakLocHelp, peakLocHelp + 1]
             if self.multiple_peaks_in_hunk == 'extremum':
-                values = triggerData[indHelp]
+                values = trigger_data[indHelp]
                 deleteInd = indHelp[argmin(abs(values))]
             elif self.multiple_peaks_in_hunk == 'first':
                 deleteInd = indHelp[1]
             peakLoc = delete(peakLoc, deleteInd)
-            triggerData = delete(triggerData, deleteInd)
+            trigger_data = delete(trigger_data, deleteInd)
             peakDist = peakLoc[1:] - peakLoc[:-1]
             multiplePeaksWithinHunk = flatnonzero(peakDist < self.hunk_length * maxPeakDist)
 
@@ -520,7 +443,7 @@ class Trigger(TimeInOut):
             )
         return peakLoc, max(peakDist), min(peakDist)
 
-    def _trigger_dirac(self, x0, x, threshold):
+    def _trigger_dirac(self, x0, x, threshold):  # noqa: ARG002
         # x0 not needed here, but needed in _trigger_rect
         return self._trigger_value_comp(x, threshold)
 
@@ -530,20 +453,20 @@ class Trigger(TimeInOut):
         # indPeakHunk = abs(xNew[1:] - xNew[:-1]) > abs(threshold)  # with this line: every edge would be located
         return self._trigger_value_comp(xNew[1:] - xNew[:-1], threshold)
 
-    def _trigger_value_comp(self, triggerData, threshold):
-        return triggerData > threshold if threshold > 0.0 else triggerData < threshold
+    def _trigger_value_comp(self, trigger_data, threshold):
+        return trigger_data > threshold if threshold > 0.0 else trigger_data < threshold
 
-    def _threshold(self, nSamples):
+    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
             meanVal = 0
             cntMean = 0
-            for triggerData in self.source.result(nSamples):
-                maxVal = max(maxVal, triggerData.max())
-                minVal = min(minVal, triggerData.min())
-                meanVal += triggerData.mean()
+            for trigger_data in self.source.result(num):
+                maxVal = max(maxVal, trigger_data.max())
+                minVal = min(minVal, trigger_data.min())
+                meanVal += trigger_data.mean()
                 cntMean += 1
             meanVal /= cntMean
 
@@ -563,7 +486,7 @@ class Trigger(TimeInOut):
         return 0
 
 
-class AngleTracker(MaskedTimeInOut):
+class AngleTracker(MaskedTimeOut):
     """Calculates rotation angle and rpm per sample from a trigger signal
     using spline interpolation in the time domain.
 
@@ -571,9 +494,6 @@ class AngleTracker(MaskedTimeInOut):
 
     """
 
-    #: Data source; :class:`~acoular.tprocess.SamplesGenerator` or derived object.
-    source = Instance(SamplesGenerator)
-
     #: Trigger data from :class:`acoular.tprocess.Trigger`.
     trigger = Instance(Trigger)
 
@@ -642,18 +562,18 @@ class AngleTracker(MaskedTimeInOut):
         # init
         ind = 0
         # trigger data
-        peakloc, maxdist, mindist = self.trigger._get_trigger_data()
+        peakloc, maxdist, mindist = self.trigger.trigger_data()
         TriggerPerRevo = self.trigger_per_revo
         rotDirection = self.rot_direction
-        nSamples = self.source.numsamples
+        num = self.source.numsamples
         samplerate = self.source.sample_freq
-        self._rpm = zeros(nSamples)
-        self._angle = zeros(nSamples)
+        self._rpm = zeros(num)
+        self._angle = zeros(num)
         # number of spline points
         InterpPoints = self.interp_points
 
         # loop over alle timesamples
-        while ind < nSamples:
+        while ind < num:
             # when starting spline forward
             if ind < peakloc[InterpPoints]:
                 peakdist = (
@@ -716,17 +636,20 @@ class AngleTracker(MaskedTimeInOut):
 
         """
         # trigger indices data
-        peakloc = self.trigger._get_trigger_data()[0]
+        peakloc = self.trigger.trigger_data()[0]
         # calculation of average rpm in 1/min
         return (len(peakloc) - 1) / (peakloc[-1] - peakloc[0]) / self.trigger_per_revo * self.source.sample_freq * 60
 
 
-class SpatialInterpolator(TimeInOut):
+class SpatialInterpolator(TimeOut):
     """Base class for spatial interpolation of microphone data.
     Gets samples from :attr:`source` and generates output via the
     generator :meth:`result`.
     """
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     #: :class:`~acoular.microphones.MicGeom` object that provides the real microphone locations.
     mics = Instance(MicGeom(), desc='microphone geometry')
 
@@ -743,9 +666,6 @@ class SpatialInterpolator(TimeInOut):
     def _set_mics_virtual(self, mics_virtual):
         self._mics_virtual = mics_virtual
 
-    #: Data source; :class:`~acoular.tprocess.SamplesGenerator` or derived object.
-    source = Instance(SamplesGenerator)
-
     #: Interpolation method in spacial domain, defaults to linear
     #: linear uses numpy linear interpolation
     #: spline uses scipy CloughTocher algorithm
@@ -784,7 +704,7 @@ class SpatialInterpolator(TimeInOut):
     #: The transformation is done via [x,y,z]_mod = Q * [x,y,z]. (default is Identity).
     Q = CArray(dtype=float64, shape=(3, 3), value=identity(3))
 
-    num_IDW = Trait(3, dtype=int, desc='number of neighboring microphones, DEFAULT=3')
+    num_IDW = Trait(3, dtype=int, desc='number of neighboring microphones, DEFAULT=3')  # noqa: N815
 
     p_weight = Trait(
         2,
@@ -793,7 +713,7 @@ class SpatialInterpolator(TimeInOut):
     )
 
     #: Stores the output of :meth:`_virtNewCoord_func`; Read-Only
-    _virtNewCoord_func = Property(
+    _virtNewCoord_func = Property(  # noqa: N815
         depends_on=['mics.digest', 'mics_virtual.digest', 'method', 'array_dimension', 'interp_at_zero'],
     )
 
@@ -818,21 +738,21 @@ class SpatialInterpolator(TimeInOut):
         return digest(self)
 
     @cached_property
-    def _get_virtNewCoord(self):
+    def _get_virtNewCoord(self):  # noqa N802
         return self._virtNewCoord_func(self.mics.mpos, self.mics_virtual.mpos, self.method, self.array_dimension)
 
     def sinc_mic(self, r):
         """Modified Sinc function for Radial Basis function approximation."""
         return sinc((r * self.mics_virtual.mpos.shape[1]) / (pi))
 
-    def _virtNewCoord_func(self, mic, micVirt, method, array_dimension):
-        """Core functionality for getting the  interpolation .
+    def _virtNewCoord_func(self, mpos, mpos_virt, method, array_dimension):  # noqa N802
+        """Core functionality for getting the interpolation.
 
         Parameters
         ----------
-        mic : float[3, nPhysicalMics]
+        mpos : float[3, nPhysicalMics]
             The mic positions of the physical (really existing) mics
-        micVirt : float[3, nVirtualMics]
+        mpos_virt : float[3, nVirtualMics]
             The mic positions of the virtual mics
         method : string
             The Interpolation method to use
@@ -864,11 +784,11 @@ class SpatialInterpolator(TimeInOut):
 
         """
         # init positions of virtual mics in cyl coordinates
-        nVirtMics = micVirt.shape[1]
+        nVirtMics = mpos_virt.shape[1]
         virtNewCoord = zeros((3, nVirtMics))
         virtNewCoord.fill(nan)
         # init real positions in cyl coordinates
-        nMics = mic.shape[1]
+        nMics = mpos.shape[1]
         newCoord = zeros((3, nMics))
         newCoord.fill(nan)
         # empty mesh object
@@ -876,24 +796,24 @@ class SpatialInterpolator(TimeInOut):
 
         if self.array_dimension == '1D' or self.array_dimension == 'ring':
             # get projections onto new coordinate, for real mics
-            projectionOnNewAxis = cartToCyl(mic, self.Q)[0]
+            projectionOnNewAxis = cartToCyl(mpos, self.Q)[0]
             indReorderHelp = argsort(projectionOnNewAxis)
             mesh.append([projectionOnNewAxis[indReorderHelp], indReorderHelp])
 
             # new coordinates of real mics
-            indReorderHelp = argsort(cartToCyl(mic, self.Q)[0])
-            newCoord = (cartToCyl(mic, self.Q).T)[indReorderHelp].T
+            indReorderHelp = argsort(cartToCyl(mpos, self.Q)[0])
+            newCoord = (cartToCyl(mpos, self.Q).T)[indReorderHelp].T
 
             # and for virtual mics
-            virtNewCoord = cartToCyl(micVirt)
+            virtNewCoord = cartToCyl(mpos_virt)
 
         elif self.array_dimension == '2D':  # 2d case0
             # get virtual mic projections on new coord system
-            virtNewCoord = cartToCyl(micVirt, self.Q)
+            virtNewCoord = cartToCyl(mpos_virt, self.Q)
 
             # new coordinates of real mics
-            indReorderHelp = argsort(cartToCyl(mic, self.Q)[0])
-            newCoord = cartToCyl(mic, self.Q)
+            indReorderHelp = argsort(cartToCyl(mpos, self.Q)[0])
+            newCoord = cartToCyl(mpos, self.Q)
 
             # scipy delauney triangulation
             # Delaunay
@@ -929,10 +849,10 @@ class SpatialInterpolator(TimeInOut):
 
         elif self.array_dimension == '3D':  # 3d case
             # get virtual mic projections on new coord system
-            virtNewCoord = cartToCyl(micVirt, self.Q)
+            virtNewCoord = cartToCyl(mpos_virt, self.Q)
             # get real mic projections on new coord system
-            indReorderHelp = argsort(cartToCyl(mic, self.Q)[0])
-            newCoord = cartToCyl(mic, self.Q)
+            indReorderHelp = 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"
 
@@ -966,14 +886,14 @@ class SpatialInterpolator(TimeInOut):
 
         return mesh, virtNewCoord, newCoord
 
-    def _result_core_func(self, p, phiDelay=None, period=None, Q=Q, interp_at_zero=False):
+    def _result_core_func(self, p, phi_delay=None, period=None, Q=Q, interp_at_zero=False):  # noqa: N803, ARG002 (see #226)
         """Performs the actual Interpolation.
 
         Parameters
         ----------
-        p : float[nSamples, nMicsReal]
+        p : float[num, nMicsReal]
             The pressure field of the yielded sample at real mics.
-        phiDelay : empty list (default) or float[nSamples]
+        phi_delay : empty list (default) or float[num]
             If passed (rotational case), this list contains the angular delay
             of each sample in rad.
         period : None (default) or float
@@ -982,12 +902,12 @@ class SpatialInterpolator(TimeInOut):
 
         Returns
         -------
-        pInterp : float[nSamples, nMicsVirtual]
+        pInterp : float[num, nMicsVirtual]
             The interpolated time data at the virtual mics
 
         """
-        if phiDelay is None:
-            phiDelay = []
+        if phi_delay is None:
+            phi_delay = []
         # number of time samples
         nTime = p.shape[0]
         # number of virtual mixcs
@@ -1015,13 +935,13 @@ class SpatialInterpolator(TimeInOut):
 
         # Interpolation for 1D Arrays
         if self.array_dimension == '1D' or self.array_dimension == 'ring':
-            # for rotation add phidelay
-            if not array_equal(phiDelay, []):
-                xInterpHelp = repmat(virtNewCoord[0, :], nTime, 1) + repmat(phiDelay, virtNewCoord.shape[1], 1).T
+            # 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 no rotation given
             else:
-                xInterp = repmat(virtNewCoord[0, :], nTime, 1)
+                xInterp = tile(virtNewCoord[0, :], (nTime, 1))
             # get ordered microphone posions in radiant
             x = newCoord[0]
             for cntTime in range(nTime):
@@ -1074,11 +994,11 @@ class SpatialInterpolator(TimeInOut):
         # Interpolation for arbitrary 2D Arrays
         elif self.array_dimension == '2D':
             # check rotation
-            if not array_equal(phiDelay, []):
-                xInterpHelp = repmat(virtNewCoord[0, :], nTime, 1) + repmat(phiDelay, virtNewCoord.shape[1], 1).T
+            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]
             else:
-                xInterp = repmat(virtNewCoord[0, :], nTime, 1)
+                xInterp = tile(virtNewCoord[0, :], (nTime, 1))
 
             mesh = meshList[0][0]
             for cntTime in range(nTime):
@@ -1137,7 +1057,7 @@ class SpatialInterpolator(TimeInOut):
                     newPoint3_M = append(newPoint2_M, zeros([1, self.numchannels]), axis=0)
                     newPointCart = cylToCart(newPoint3_M)
                     for ind in arange(len(newPoint[:, 0])):
-                        newPoint_Rep = repmat(newPointCart[:, ind], len(newPoint[:, 0]), 1).T
+                        newPoint_Rep = tile(newPointCart[:, ind], (len(newPoint[:, 0]), 1)).T
                         subtract = newPoint_Rep - newCoordCart
                         normDistance = norm(subtract, axis=0)
                         index_norm = argsort(normDistance)[: self.num_IDW]
@@ -1153,11 +1073,11 @@ class SpatialInterpolator(TimeInOut):
         # Interpolation for arbitrary 3D Arrays
         elif self.array_dimension == '3D':
             # check rotation
-            if not array_equal(phiDelay, []):
-                xInterpHelp = repmat(virtNewCoord[0, :], nTime, 1) + repmat(phiDelay, virtNewCoord.shape[1], 1).T
+            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]
             else:
-                xInterp = repmat(virtNewCoord[0, :], nTime, 1)
+                xInterp = tile(virtNewCoord[0, :], (nTime, 1))
 
             mesh = meshList[0][0]
             for cntTime in range(nTime):
@@ -1253,12 +1173,12 @@ class SpatialInterpolatorRotation(SpatialInterpolator):
         # period for rotation
         period = 2 * pi
         # get angle
-        angle = self.angle_source._get_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):
-            phiDelay = angle[count : count + num]
-            interpVal = self._result_core_func(timeData, phiDelay, period, self.Q, interp_at_zero=False)
+            phi_delay = angle[count : count + num]
+            interpVal = self._result_core_func(timeData, phi_delay, period, self.Q, interp_at_zero=False)
             yield interpVal
             count += num
 
@@ -1311,19 +1231,19 @@ class SpatialInterpolatorConstantRotation(SpatialInterpolator):
         phiOffset = 0.0
         for timeData in self.source.result(num):
             nTime = timeData.shape[0]
-            phiDelay = phiOffset + linspace(0, nTime / self.sample_freq * omega, nTime, endpoint=False)
-            interpVal = self._result_core_func(timeData, phiDelay, period, self.Q, interp_at_zero=False)
-            phiOffset = phiDelay[-1] + omega / self.sample_freq
+            phi_delay = phiOffset + 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
 
 
-class Mixer(TimeInOut):
+class Mixer(TimeOut):
     """Mixes the signals from several sources."""
 
-    #: Data source; :class:`~acoular.tprocess.SamplesGenerator` object.
+    #: Data source; :class:`~acoular.base.SamplesGenerator` object.
     source = Trait(SamplesGenerator)
 
-    #: List of additional :class:`~acoular.tprocess.SamplesGenerator` objects
+    #: List of additional :class:`~acoular.base.SamplesGenerator` objects
     #: to be mixed.
     sources = List(Instance(SamplesGenerator, ()))
 
@@ -1340,7 +1260,7 @@ class Mixer(TimeInOut):
     sdigest = Str()
 
     @observe('sources.items.digest')
-    def _set_sources_digest(self, event):  # noqa ARG002
+    def _set_sourcesdigest(self, event):  # noqa ARG002
         self.sdigest = ldigest(self.sources)
 
     # internal identifier
@@ -1395,9 +1315,12 @@ class Mixer(TimeInOut):
                 break
 
 
-class TimePower(TimeInOut):
+class TimePower(TimeOut):
     """Calculates time-depended power of the signal."""
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     def result(self, num):
         """Python generator that yields the output block-wise.
 
@@ -1418,64 +1341,12 @@ class TimePower(TimeInOut):
             yield temp * temp
 
 
-class TimeAverage(TimeInOut):
-    """Calculates time-dependent average of the signal."""
-
-    #: Number of samples to average over, defaults to 64.
-    naverage = Int(64, desc='number of samples to average over')
-
-    #: Sampling frequency of the output signal, is set automatically.
-    sample_freq = Property(depends_on='source.sample_freq, naverage')
-
-    #: Number of samples of the output signal, is set automatically.
-    numsamples = Property(depends_on='source.numsamples, naverage')
-
-    # internal identifier
-    digest = Property(depends_on=['source.digest', '__class__', 'naverage'])
-
-    @cached_property
-    def _get_digest(self):
-        return digest(self)
-
-    @cached_property
-    def _get_sample_freq(self):
-        if self.source:
-            return 1.0 * self.source.sample_freq / self.naverage
-        return None
-
-    @cached_property
-    def _get_numsamples(self):
-        if self.source:
-            return self.source.numsamples / self.naverage
-        return None
-
-    def result(self, num):
-        """Python generator that yields the output block-wise.
-
-        Parameters
-        ----------
-        num : integer
-            This parameter defines the size of the blocks to be yielded
-            (i.e. the number of samples per block).
-
-        Returns
-        -------
-        Average of the output of source.
-            Yields samples in blocks of shape (num, numchannels).
-            The last block may be shorter than num.
-
-        """
-        nav = self.naverage
-        for temp in self.source.result(num * nav):
-            ns, nc = temp.shape
-            nso = int(ns / nav)
-            if nso > 0:
-                yield temp[: nso * nav].reshape((nso, -1, nc)).mean(axis=1)
-
-
-class TimeCumAverage(TimeInOut):
+class TimeCumAverage(TimeOut):
     """Calculates cumulative average of the signal, useful for Leq."""
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     def result(self, num):
         """Python generator that yields the output block-wise.
 
@@ -1503,9 +1374,12 @@ class TimeCumAverage(TimeInOut):
             yield temp
 
 
-class TimeReverse(TimeInOut):
+class TimeReverse(TimeOut):
     """Calculates the time-reversed signal of a source."""
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     def result(self, num):
         """Python generator that yields the output block-wise.
 
@@ -1522,20 +1396,20 @@ class TimeReverse(TimeInOut):
             The last block may be shorter than num.
 
         """
-        l = []
-        l.extend(self.source.result(num))
-        temp = empty_like(l[0])
-        h = l.pop()
+        result_list = []
+        result_list.extend(self.source.result(num))
+        temp = empty_like(result_list[0])
+        h = result_list.pop()
         nsh = h.shape[0]
         temp[:nsh] = h[::-1]
-        for h in l[::-1]:
+        for h in result_list[::-1]:
             temp[nsh:] = h[: nsh - 1 : -1]
             yield temp
             temp[:nsh] = h[nsh - 1 :: -1]
         yield temp[:nsh]
 
 
-class Filter(TimeInOut):
+class Filter(TimeOut):
     """Abstract base class for IIR filters based on scipy lfilter
     implements a filter with coefficients that may be changed
     during processing.
@@ -1543,6 +1417,9 @@ class Filter(TimeInOut):
     Should not be instanciated by itself
     """
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     #: Filter coefficients
     sos = Property()
 
@@ -1751,13 +1628,16 @@ class FiltFreqWeight(Filter):
         return tf2sos(b, a)
 
 
-class FilterBank(TimeInOut):
+class FilterBank(TimeOut):
     """Abstract base class for IIR filter banks based on scipy lfilter
     implements a bank of parallel filters.
 
     Should not be instanciated by itself
     """
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     #: List of filter coefficients for all filters
     sos = Property()
 
@@ -1856,136 +1736,14 @@ class OctaveFilterBank(FilterBank):
         return sos
 
 
-class TimeCache(TimeInOut):
-    """Caches time signal in cache file."""
-
-    # basename for cache
-    basename = Property(depends_on='digest')
-
-    # hdf5 cache file
-    h5f = Instance(H5CacheFileBase, transient=True)
-
-    # internal identifier
-    digest = Property(depends_on=['source.digest', '__class__'])
-
-    @cached_property
-    def _get_digest(self):
-        return digest(self)
-
-    @cached_property
-    def _get_basename(self):
-        obj = self.source  # start with source
-        basename = 'void'  # if no file source is found
-        while obj:
-            if 'basename' in obj.all_trait_names():  # at original source?
-                basename = obj.basename  # get the name
-                break
-            try:
-                obj = obj.source  # traverse down until original data source
-            except AttributeError:
-                obj = None
-        return basename
-
-    def _pass_data(self, num):
-        yield from self.source.result(num)
-
-    def _write_data_to_cache(self, num):
-        nodename = 'tc_' + self.digest
-        self.h5f.create_extendable_array(nodename, (0, self.numchannels), 'float32')
-        ac = self.h5f.get_data_by_reference(nodename)
-        self.h5f.set_node_attribute(ac, 'sample_freq', self.sample_freq)
-        self.h5f.set_node_attribute(ac, 'complete', False)
-        for data in self.source.result(num):
-            self.h5f.append_data(ac, data)
-            yield data
-        self.h5f.set_node_attribute(ac, 'complete', True)
-
-    def _get_data_from_cache(self, num):
-        nodename = 'tc_' + self.digest
-        ac = self.h5f.get_data_by_reference(nodename)
-        i = 0
-        while i < ac.shape[0]:
-            yield ac[i : i + num]
-            i += num
-
-    def _get_data_from_incomplete_cache(self, num):
-        nodename = 'tc_' + self.digest
-        ac = self.h5f.get_data_by_reference(nodename)
-        i = 0
-        nblocks = 0
-        while i + num <= ac.shape[0]:
-            yield ac[i : i + num]
-            nblocks += 1
-            i += num
-        self.h5f.remove_data(nodename)
-        self.h5f.create_extendable_array(nodename, (0, self.numchannels), 'float32')
-        ac = self.h5f.get_data_by_reference(nodename)
-        self.h5f.set_node_attribute(ac, 'sample_freq', self.sample_freq)
-        self.h5f.set_node_attribute(ac, 'complete', False)
-        for j, data in enumerate(self.source.result(num)):
-            self.h5f.append_data(ac, data)
-            if j >= nblocks:
-                yield data
-        self.h5f.set_node_attribute(ac, 'complete', True)
-
-    # result generator: delivers input, possibly from cache
-    def result(self, num):
-        """Python generator that yields the output from cache block-wise.
-
-        Parameters
-        ----------
-        num : integer
-            This parameter defines the size of the blocks to be yielded
-            (i.e. the number of samples per block).
-
-        Returns
-        -------
-        Samples in blocks of shape (num, numchannels).
-            The last block may be shorter than num.
-            Echos the source output, but reads it from cache
-            when available and prevents unnecassary recalculation.
-
-        """
-        if config.global_caching == 'none':
-            generator = self._pass_data
-        else:
-            nodename = 'tc_' + self.digest
-            H5cache.get_cache_file(self, self.basename)
-            if not self.h5f:
-                generator = self._pass_data
-            elif self.h5f.is_cached(nodename):
-                generator = self._get_data_from_cache
-                if config.global_caching == 'overwrite':
-                    self.h5f.remove_data(nodename)
-                    generator = self._write_data_to_cache
-                elif not self.h5f.get_data_by_reference(nodename).attrs.__contains__('complete'):
-                    if config.global_caching == 'readonly':
-                        generator = self._pass_data
-                    else:
-                        generator = self._get_data_from_incomplete_cache
-                elif not self.h5f.get_data_by_reference(nodename).attrs['complete']:
-                    if config.global_caching == 'readonly':
-                        warn(
-                            "Cache file is incomplete for nodename %s. With config.global_caching='readonly', the cache file will not be used!"
-                            % str(nodename),
-                            Warning,
-                            stacklevel=1,
-                        )
-                        generator = self._pass_data
-                    else:
-                        generator = self._get_data_from_incomplete_cache
-            elif not self.h5f.is_cached(nodename):
-                generator = self._write_data_to_cache
-                if config.global_caching == 'readonly':
-                    generator = self._pass_data
-        yield from generator(num)
-
-
-class WriteWAV(TimeInOut):
+class WriteWAV(TimeOut):
     """Saves time signal from one or more channels as mono/stereo/multi-channel
     `*.wav` file.
     """
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     #: Name of the file to be saved. If none is given, the name will be
     #: automatically generated from the sources.
     name = File(filter=['*.wav'], desc='name of wave file')
@@ -2048,9 +1806,12 @@ class WriteWAV(TimeInOut):
         wf.close()
 
 
-class WriteH5(TimeInOut):
+class WriteH5(TimeOut):
     """Saves time signal as `*.h5` file."""
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     #: Name of the file to be saved. If none is given, the name will be
     #: automatically generated from a time stamp.
     name = File(filter=['*.h5'], desc='name of data file')
@@ -2142,165 +1903,23 @@ class WriteH5(TimeInOut):
                 break
             try:
                 data = next(source_gen)
-            except:
+            except StopIteration:
                 break
             f5h.append_data(ac, data[:anz])
-            yield data
             f5h.flush()
+            yield data
             scount += anz
         f5h.close()
 
 
-class LockedGenerator:
-    """Creates a Thread Safe Iterator.
-    Takes an iterator/generator and makes it thread-safe by
-    serializing call to the `next` method of given iterator/generator.
-    """
-
-    def __init__(self, it):
-        self.it = it
-        self.lock = threading.Lock()
-
-    def __next__(self):  # this function implementation is not python 2 compatible!
-        with self.lock:
-            return self.it.__next__()
-
+class TimeConvolve(TimeOut):
+    """Uniformly partitioned overlap-save method (UPOLS) for fast convolution in the frequency domain.
 
-class SampleSplitter(TimeInOut):
-    """Distributes data blocks from source to several following objects.
-    A separate block buffer is created for each registered object in
-    (:attr:`block_buffer`) .
+    See :cite:`Wefers2015` for details.
     """
 
-    #: dictionary with block buffers (dict values) of registered objects (dict
-    #: keys).
-    block_buffer = Dict(key_trait=Instance(SamplesGenerator))
-
-    #: max elements/blocks in block buffers.
-    buffer_size = Int(100)
-
-    #: defines behaviour in case of block_buffer overflow. Can be set individually
-    #: for each registered object.
-    #:
-    #: * 'error': an IOError is thrown by the class
-    #: * 'warning': a warning is displayed. Possibly leads to lost blocks of data
-    #: * 'none': nothing happens. Possibly leads to lost blocks of data
-    buffer_overflow_treatment = Dict(
-        key_trait=Instance(SamplesGenerator),
-        value_trait=Trait('error', 'warning', 'none'),
-        desc='defines buffer overflow behaviour.',
-    )
-
-    # shadow trait to monitor if source deliver samples or is empty
-    _source_generator_exist = Bool(False)
-
-    # shadow trait to monitor if buffer of objects with overflow treatment = 'error'
-    # or warning is overfilled. Error will be raised in all threads.
-    _buffer_overflow = Bool(False)
-
-    # Helper Trait holds source generator
-    _source_generator = Trait()
-
-    def _create_block_buffer(self, obj):
-        self.block_buffer[obj] = deque([], maxlen=self.buffer_size)
-
-    def _create_buffer_overflow_treatment(self, obj):
-        self.buffer_overflow_treatment[obj] = 'error'
-
-    def _clear_block_buffer(self, obj):
-        self.block_buffer[obj].clear()
-
-    def _remove_block_buffer(self, obj):
-        del self.block_buffer[obj]
-
-    def _remove_buffer_overflow_treatment(self, obj):
-        del self.buffer_overflow_treatment[obj]
-
-    def _assert_obj_registered(self, obj):
-        if obj not in self.block_buffer:
-            raise OSError('calling object %s is not registered.' % obj)
-
-    def _get_objs_to_inspect(self):
-        return [obj for obj in self.buffer_overflow_treatment if self.buffer_overflow_treatment[obj] != 'none']
-
-    def _inspect_buffer_levels(self, inspect_objs):
-        for obj in inspect_objs:
-            if len(self.block_buffer[obj]) == self.buffer_size:
-                if self.buffer_overflow_treatment[obj] == 'error':
-                    self._buffer_overflow = True
-                elif self.buffer_overflow_treatment[obj] == 'warning':
-                    warn('overfilled buffer for object: %s data will get lost' % obj, UserWarning, stacklevel=1)
-
-    def _create_source_generator(self, num):
-        for obj in self.block_buffer:
-            self._clear_block_buffer(obj)
-        self._buffer_overflow = False  # reset overflow bool
-        self._source_generator = LockedGenerator(self.source.result(num))
-        self._source_generator_exist = True  # indicates full generator
-
-    def _fill_block_buffers(self):
-        next_block = next(self._source_generator)
-        [self.block_buffer[obj].appendleft(next_block) for obj in self.block_buffer]
-
-    @on_trait_change('buffer_size')
-    def _change_buffer_size(self):  #
-        for obj in self.block_buffer:
-            self._remove_block_buffer(obj)
-            self._create_block_buffer(obj)
-
-    def register_object(self, *objects_to_register):
-        """Function that can be used to register objects that receive blocks from this class."""
-        for obj in objects_to_register:
-            if obj not in self.block_buffer:
-                self._create_block_buffer(obj)
-                self._create_buffer_overflow_treatment(obj)
-
-    def remove_object(self, *objects_to_remove):
-        """Function that can be used to remove registered objects."""
-        for obj in objects_to_remove:
-            self._remove_block_buffer(obj)
-            self._remove_buffer_overflow_treatment(obj)
-
-    def result(self, num):
-        """Python generator that yields the output block-wise from block-buffer.
-
-        Parameters
-        ----------
-        num : integer
-            This parameter defines the size of the blocks to be yielded
-            (i.e. the number of samples per block).
-
-        Returns
-        -------
-        Samples in blocks of shape (num, numchannels).
-            Delivers a block of samples to the calling object.
-            The last block may be shorter than num.
-
-        """
-        calling_obj = currentframe().f_back.f_locals['self']
-        self._assert_obj_registered(calling_obj)
-        objs_to_inspect = self._get_objs_to_inspect()
-
-        if not self._source_generator_exist:
-            self._create_source_generator(num)
-
-        while not self._buffer_overflow:
-            if self.block_buffer[calling_obj]:
-                yield self.block_buffer[calling_obj].pop()
-            else:
-                self._inspect_buffer_levels(objs_to_inspect)
-                try:
-                    self._fill_block_buffers()
-                except StopIteration:
-                    self._source_generator_exist = False
-                    return
-        else:
-            msg = 'Maximum size of block buffer is reached!'
-            raise OSError(msg)
-
-
-class TimeConvolve(TimeInOut):
-    """Uniformly partitioned overlap-save method (UPOLS) for fast convolution in the frequency domain, see :ref:`Wefers, 2015<Wefers2015>`."""
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
 
     #: Convolution kernel in the time domain.
     #: The second dimension of the kernel array has to be either 1 or match :attr:`~SamplesGenerator.numchannels`.
@@ -2376,13 +1995,13 @@ class TimeConvolve(TimeInOut):
         L = self.kernel.shape[0]
         N = self.source.numchannels
         M = self.source.numsamples
-        P = int(ceil(L / num))  # number of kernel blocks
+        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
 
         idx = 0
-        FDL = zeros([P, num + 1, N], dtype='complex128')
+        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')
 
@@ -2392,16 +2011,16 @@ class TimeConvolve(TimeInOut):
 
         # for very short signals, we are already done
         if R == 1:
-            _append_to_FDL(FDL, idx, P, rfft(buff, axis=0))
-            spec_sum = _spectral_sum(spec_sum, FDL, self._kernel_blocks)
+            _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]
             return
 
         # stream processing of source signal
         for temp in signal_blocks:
-            _append_to_FDL(FDL, idx, P, rfft(buff, axis=0))
-            spec_sum = _spectral_sum(spec_sum, FDL, self._kernel_blocks)
+            _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])],
@@ -2410,33 +2029,50 @@ class TimeConvolve(TimeInOut):
             buff[num : num + temp.shape[0]] = temp  # append new time-data
 
         for _ in range(R - Q):
-            _append_to_FDL(FDL, idx, P, rfft(buff, axis=0))
-            spec_sum = _spectral_sum(spec_sum, FDL, self._kernel_blocks)
+            _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])],
                 axis=0,
             )  # shift input buffer to the left
 
-        _append_to_FDL(FDL, idx, P, rfft(buff, axis=0))
-        spec_sum = _spectral_sum(spec_sum, FDL, self._kernel_blocks)
+        _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]
 
 
 @nb.jit(nopython=True, cache=True)
-def _append_to_FDL(FDL, idx, P, buff):
-    FDL[idx] = buff
-    idx = int(idx + 1 % P)
+def _append_to_fdl(fdl, idx, numblocks_kernel, buff):
+    fdl[idx] = buff
+    idx = int(idx + 1 % numblocks_kernel)
 
 
 @nb.jit(nopython=True, cache=True)
-def _spectral_sum(out, FDL, KB):
-    P, B, N = KB.shape
+def _spectral_sum(out, fdl, kb):
+    P, B, N = kb.shape
     for n in range(N):
         for b in range(B):
             out[b, n] = 0
             for i in range(P):
-                out[b, n] += FDL[i, b, n] * KB[i, b, n]
+                out[b, n] += fdl[i, b, n] * kb[i, b, n]
 
     return out
+
+
+class MaskedTimeInOut(MaskedTimeOut):
+    """Signal processing block for channel and sample selection (alias for :class:`~acoular.tprocess.MaskedTimeOut`.).
+
+    .. deprecated:: 24.10
+        Using :class:`~acoular.tprocess.MaskedTimeInOut` is deprecated and will be removed in Acoular
+        version 25.07. Use :class:`~acoular.tprocess.MaskedTimeOut` instead.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        warn(
+            'Using MaskedTimeInOut is deprecated and will be removed in Acoular version 25.07. Use class MaskedTimeOut instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )