acoular 24.7__py3-none-any.whl → 25.1__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,16 @@
     TimeExpAverage
     FiltFreqWeight
     OctaveFilterBank
-    TimeCache
-    TimeCumAverage
     WriteWAV
     WriteH5
-    SampleSplitter
     TimeConvolve
+    MaskedTimeInOut
 """
 
 # imports from other packages
-import threading
 import wave
-from collections import deque
+from abc import abstractmethod
 from datetime import datetime, timezone
-from inspect import currentframe
 from os import path
 from warnings import warn
 
@@ -77,158 +71,93 @@ from numpy import (
     split,
     sqrt,
     stack,
-    sum,
+    sum,  # noqa: A004
+    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 (
     Bool,
     CArray,
-    CLong,
+    CInt,
     Constant,
     Delegate,
     Dict,
+    Enum,
     File,
     Float,
-    HasPrivateTraits,
     Instance,
     Int,
     List,
-    ListInt,
+    Map,
     Property,
     Str,
-    Trait,
+    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 .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
+from .tools.utils import find_basename
 
 
-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):
+@deprecated_alias({'numchannels_total': 'num_channels_total', 'numsamples_total': 'num_samples_total'})
+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`.
     """
 
-    #: Index of the first sample to be considered valid.
-    start = CLong(0, desc='start of valid samples')
+    # Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
+    # Index of the first sample to be considered valid.
+    start = CInt(0, desc='start of valid samples')
 
-    #: Index of the last sample to be considered valid.
-    stop = Trait(None, None, CLong, desc='stop of valid samples')
+    # Index of the last sample to be considered valid.
+    stop = Union(None, CInt, desc='stop of valid samples')
 
-    #: Channels that are to be treated as invalid.
-    invalid_channels = ListInt(desc='list of invalid channels')
+    # Channels that are to be treated as invalid.
+    invalid_channels = List(int, desc='list of invalid channels')
 
-    #: 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')
+    # Channel mask to serve as an index for all valid channels, is set automatically.
+    channels = Property(depends_on=['invalid_channels', 'source.num_channels'], desc='channel mask')
 
-    #: Number of channels in input, as given by :attr:`~acoular.tprocess.TimeInOut.source`.
-    numchannels_total = Delegate('source', 'numchannels')
+    # Number of channels in input, as given by :attr:`~acoular.base.TimeOut.source`.
+    num_channels_total = Delegate('source', 'num_channels')
 
-    #: Number of samples in input, as given by :attr:`~acoular.tprocess.TimeInOut.source`.
-    numsamples_total = Delegate('source', 'numsamples')
+    # Number of samples in input, as given by :attr:`~acoular.base.TimeOut.source`.
+    num_samples_total = Delegate('source', 'num_samples')
 
-    #: Number of valid channels, is set automatically.
-    numchannels = Property(depends_on=['invalid_channels', 'source.numchannels'], desc='number of valid input channels')
+    # Number of valid channels, is set automatically.
+    num_channels = Property(
+        depends_on=['invalid_channels', 'source.num_channels'], desc='number of valid input channels'
+    )
 
-    #: Number of valid time samples, is set automatically.
-    numsamples = Property(depends_on=['start', 'stop', 'source.numsamples'], desc='number of valid samples per channel')
+    # Number of valid time samples, is set automatically.
+    num_samples = Property(
+        depends_on=['start', 'stop', 'source.num_samples'], desc='number of valid samples per channel'
+    )
 
-    #: Name of the cache file without extension, readonly.
-    basename = Property(depends_on='source.digest', desc='basename for cache file')
+    # Name of the cache file without extension, readonly.
+    basename = Property(depends_on=['source.digest'], desc='basename for cache file')
 
     # internal identifier
     digest = Property(depends_on=['source.digest', 'start', 'stop', 'invalid_channels'])
@@ -239,26 +168,32 @@ class MaskedTimeInOut(TimeInOut):
 
     @cached_property
     def _get_basename(self):
-        if 'basename' in self.source.all_trait_names():
-            return self.source.basename
-        return self.source.__class__.__name__ + self.source.digest
+        warn(
+            (
+                f'The basename attribute of a {self.__class__.__name__} object is deprecated'
+                ' and will be removed in a future release!'
+            ),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return find_basename(self.source, alternative_basename=self.source.__class__.__name__ + self.source.digest)
 
     @cached_property
     def _get_channels(self):
         if len(self.invalid_channels) == 0:
             return slice(0, None, None)
-        allr = [i for i in range(self.numchannels_total) if i not in self.invalid_channels]
+        allr = [i for i in range(self.num_channels_total) if i not in self.invalid_channels]
         return array(allr)
 
     @cached_property
-    def _get_numchannels(self):
+    def _get_num_channels(self):
         if len(self.invalid_channels) == 0:
-            return self.numchannels_total
+            return self.num_channels_total
         return len(self.channels)
 
     @cached_property
-    def _get_numsamples(self):
-        sli = slice(self.start, self.stop).indices(self.numsamples_total)
+    def _get_num_samples(self):
+        sli = slice(self.start, self.stop).indices(self.num_samples_total)
         return sli[1] - sli[0]
 
     def result(self, num):
@@ -272,22 +207,22 @@ class MaskedTimeInOut(TimeInOut):
 
         Returns
         -------
-        Samples in blocks of shape (num, :attr:`numchannels`).
+        Samples in blocks of shape (num, :attr:`num_channels`).
             The last block may be shorter than num.
 
         """
-        sli = slice(self.start, self.stop).indices(self.numsamples_total)
+        sli = slice(self.start, self.stop).indices(self.num_samples_total)
         start = sli[0]
         stop = sli[1]
         if start >= stop:
             msg = 'no samples available'
             raise OSError(msg)
 
-        if start != 0 or stop != self.numsamples_total:
+        if start != 0 or stop != self.num_samples_total:
             offset = -start % num
             if offset == 0:
                 offset = num
-            buf = empty((num + offset, self.numchannels), dtype=float)
+            buf = empty((num + offset, self.num_channels), dtype=float)
             bsize = 0
             i = 0
             fblock = True
@@ -323,16 +258,19 @@ 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.
     """
 
-    #: Amplitude weight(s) for the channels as array. If not set, all channels are equally weighted.
+    # 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')
 
     # Number of channels is always one here.
-    numchannels = Constant(1)
+    num_channels = Constant(1)
 
     # internal identifier
     digest = Property(depends_on=['source.digest', 'weights'])
@@ -357,10 +295,10 @@ class ChannelMixer(TimeInOut):
 
         """
         if self.weights.size:
-            if self.weights.shape in {(self.source.numchannels,), (1,)}:
+            if self.weights.shape in {(self.source.num_channels,), (1,)}:
                 weights = self.weights
             else:
-                msg = f'Weight factors can not be broadcasted: {self.weights.shape}, {(self.source.numchannels,)}'
+                msg = f'Weight factors can not be broadcasted: {self.weights.shape}, {(self.source.num_channels,)}'
                 raise ValueError(msg)
         else:
             weights = 1
@@ -369,7 +307,7 @@ class ChannelMixer(TimeInOut):
             yield sum(weights * block, 1, keepdims=True)
 
 
-class Trigger(TimeInOut):
+class Trigger(TimeOut):  # pragma: no cover
     """Class for identifying trigger signals.
     Gets samples from :attr:`source` and stores the trigger samples in :meth:`trigger_data`.
 
@@ -383,59 +321,56 @@ 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
-    #: :attr:`~acoular.tprocess.Trigger.trigger_type`. The sign is relevant.
-    #: If a sample of the signal is above/below the positive/negative threshold,
-    #: it is assumed to be a peak.
-    #: Default is None, in which case a first estimate is used: The threshold
-    #: is assumed to be 75% of the max/min difference between all extremums and the
-    #: mean value of the trigger signal. E.g: the mean value is 0 and there are positive
-    #: extremums at 400 and negative extremums at -800. Then the estimated threshold would be
-    #: 0.75 * -800 = -600.
+    # Threshold of trigger. Has different meanings for different
+    # :attr:`~acoular.tprocess.Trigger.trigger_type`. The sign is relevant.
+    # If a sample of the signal is above/below the positive/negative threshold,
+    # it is assumed to be a peak.
+    # Default is None, in which case a first estimate is used: The threshold
+    # is assumed to be 75% of the max/min difference between all extremums and the
+    # mean value of the trigger signal. E.g: the mean value is 0 and there are positive
+    # extremums at 400 and negative extremums at -800. Then the estimated threshold would be
+    # 0.75 * -800 = -600.
     threshold = Float(None)
 
-    #: Maximum allowable variation of length of each revolution duration. Default is
-    #: 2%. A warning is thrown, if any revolution length surpasses this value:
-    #: abs(durationEachRev - meanDuration) > 0.02 * meanDuration
+    # Maximum allowable variation of length of each revolution duration. Default is
+    # 2%. A warning is thrown, if any revolution length surpasses this value:
+    # abs(durationEachRev - meanDuration) > 0.02 * meanDuration
     max_variation_of_duration = Float(0.02)
 
-    #: Defines the length of hunks via lenHunk = hunk_length * maxOncePerRevDuration.
-    #: If there are multiple peaks within lenHunk, then the algorithm will
-    #: cancel all but one out (see :attr:`~acoular.tprocess.Trigger.multiple_peaks_in_hunk`).
-    #: Default is to 0.1.
+    # Defines the length of hunks via lenHunk = hunk_length * maxOncePerRevDuration.
+    # If there are multiple peaks within lenHunk, then the algorithm will
+    # cancel all but one out (see :attr:`~acoular.tprocess.Trigger.multiple_peaks_in_hunk`).
+    # Default is to 0.1.
     hunk_length = Float(0.1)
 
-    #: Type of trigger.
-    #:
-    #: 'dirac': a single puls is assumed (sign of
-    #: :attr:`~acoular.tprocess.Trigger.trigger_type` is important).
-    #: Sample will trigger if its value is above/below the pos/neg threshold.
-    #:
-    #: 'rect' : repeating rectangular functions. Only every second
-    #: edge is assumed to be a trigger. The sign of
-    #: :attr:`~acoular.tprocess.Trigger.trigger_type` gives information
-    #: on which edge should be used (+ for rising edge, - for falling edge).
-    #: Sample will trigger if the difference between its value and its predecessors value
-    #: is above/below the pos/neg threshold.
-    #:
-    #: Default is 'dirac'.
-    trigger_type = Trait('dirac', 'rect')
-
-    #: Identifier which peak to consider, if there are multiple peaks in one hunk
-    #: (see :attr:`~acoular.tprocess.Trigger.hunk_length`). Default is to 'extremum',
-    #: in which case the extremal peak (maximum if threshold > 0, minimum if threshold < 0) is considered.
-    multiple_peaks_in_hunk = Trait('extremum', 'first')
-
-    #: Tuple consisting of 3 entries:
-    #:
-    #: 1.: -Vector with the sample indices of the 1/Rev trigger samples
-    #:
-    #: 2.: -maximum of number of samples between adjacent trigger samples
-    #:
-    #: 3.: -minimum of number of samples between adjacent trigger samples
+    # Type of trigger.
+    #
+    # 'dirac': a single pulse is assumed (sign of :attr:`~acoular.tprocess.Trigger.trigger_type` is
+    # important). Sample will trigger if its value is above/below the pos/neg threshold.
+    #
+    # 'rect' : repeating rectangular functions. Only every second edge is assumed to be a trigger.
+    # The sign of :attr:`~acoular.tprocess.Trigger.trigger_type` gives information on which edge
+    # should be used (+ for rising edge, - for falling edge). Sample will trigger if the difference
+    # between its value and its predecessors value is above/below the pos/neg threshold.
+    #
+    # Default is 'dirac'.
+    trigger_type = Enum('dirac', 'rect')
+
+    # Identifier which peak to consider, if there are multiple peaks in one hunk : (see
+    # :attr:`~acoular.tprocess.Trigger.hunk_length`). Default is to 'extremum', : in which case the
+    # extremal peak (maximum if threshold > 0, minimum if threshold < 0) is considered.
+    multiple_peaks_in_hunk = Enum('extremum', 'first')
+
+    # Tuple consisting of 3 entries:
+    #
+    # 1.: -Vector with the sample indices of the 1/Rev trigger samples
+    #
+    # 2.: -maximum of number of samples between adjacent trigger samples
+    #
+    # 3.: -minimum of number of samples between adjacent trigger samples
     trigger_data = Property(
         depends_on=[
             'source.digest',
@@ -513,8 +448,8 @@ class Trigger(TimeInOut):
         faultyInd = flatnonzero(diffDist > self.max_variation_of_duration * meanDist)
         if faultyInd.size != 0:
             warn(
-                'In Trigger-Identification: The distances between the peaks (and therefor the lengths of the revolutions) vary too much (check samples %s).'
-                % str(peakLoc[faultyInd] + self.source.start),
+                f'In Trigger-Identification: The distances between the peaks (and therefore the lengths of the \
+                revolutions) vary too much (check samples {peakLoc[faultyInd] + self.source.start}).',
                 Warning,
                 stacklevel=2,
             )
@@ -527,7 +462,8 @@ class Trigger(TimeInOut):
     def _trigger_rect(self, x0, x, threshold):
         # x0 stores the last value of the the last generator cycle
         xNew = append(x0, x)
-        # indPeakHunk = abs(xNew[1:] - xNew[:-1]) > abs(threshold)  # with this line: every edge would be located
+        # 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)
 
     def _trigger_value_comp(self, trigger_data, threshold):
@@ -551,30 +487,33 @@ class Trigger(TimeInOut):
             maxTriggerHelp = [minVal, maxVal] - meanVal
             argInd = argmax(abs(maxTriggerHelp))
             thresh = maxTriggerHelp[argInd] * 0.75  # 0.75 for 75% of max trigger signal
-            warn('No threshold was passed. An estimated threshold of %s is assumed.' % thresh, Warning, stacklevel=2)
+            warn(f'No threshold was passed. An estimated threshold of {thresh} is assumed.', Warning, stacklevel=2)
         else:  # take user defined  threshold
             thresh = self.threshold
         return thresh
 
     def _check_trigger_existence(self):
-        nChannels = self.source.numchannels
-        if not nChannels == 1:
-            raise Exception('Trigger signal must consist of ONE channel, instead %s channels are given!' % nChannels)
+        nChannels = self.source.num_channels
+        if nChannels != 1:
+            msg = f'Trigger signal must consist of ONE channel, instead {nChannels} channels are given!'
+            raise Exception(msg)
         return 0
 
+    def result(self, num):
+        msg = 'result method not implemented yet! Data from source will be passed without transformation.'
+        warn(msg, Warning, stacklevel=2)
+        yield from self.source.result(num)
+
 
-class AngleTracker(MaskedTimeInOut):
+class AngleTracker(MaskedTimeOut):
     """Calculates rotation angle and rpm per sample from a trigger signal
     using spline interpolation in the time domain.
 
-    Gets samples from :attr:`trigger` and stores the angle and rpm samples in :meth:`angle` and :meth:`rpm`.
-
+    Gets samples from :attr:`trigger` and stores the angle and rpm samples in :meth:`angle` and
+    :meth:`rpm`.
     """
 
-    #: Data source; :class:`~acoular.tprocess.SamplesGenerator` or derived object.
-    source = Instance(SamplesGenerator)
-
-    #: Trigger data from :class:`acoular.tprocess.Trigger`.
+    # Trigger data from :class:`acoular.tprocess.Trigger`.
     trigger = Instance(Trigger)
 
     # internal identifier
@@ -589,29 +528,29 @@ class AngleTracker(MaskedTimeInOut):
         ],
     )
 
-    #: Trigger signals per revolution,
-    #: defaults to 1.
+    # Trigger signals per revolution,
+    # defaults to 1.
     trigger_per_revo = Int(1, desc='trigger signals per revolution')
 
-    #: Flag to set counter-clockwise (1) or clockwise (-1) rotation,
-    #: defaults to -1.
+    # Flag to set counter-clockwise (1) or clockwise (-1) rotation,
+    # defaults to -1.
     rot_direction = Int(-1, desc='mathematical direction of rotation')
 
-    #: Points of interpolation used for spline,
-    #: defaults to 4.
+    # Points of interpolation used for spline,
+    # defaults to 4.
     interp_points = Int(4, desc='Points of interpolation used for spline')
 
-    #: rotation angle in radians for first trigger position
+    # rotation angle in radians for first trigger position
     start_angle = Float(0, desc='rotation angle for trigger position')
 
-    #: revolutions per minute for each sample, read-only
-    rpm = Property(depends_on='digest', desc='revolutions per minute for each sample')
+    # revolutions per minute for each sample, read-only
+    rpm = Property(depends_on=['digest'], desc='revolutions per minute for each sample')
 
-    #: average revolutions per minute, read-only
-    average_rpm = Property(depends_on='digest', desc='average revolutions per minute')
+    # average revolutions per minute, read-only
+    average_rpm = Property(depends_on=['digest'], desc='average revolutions per minute')
 
-    #: rotation angle in radians for each sample, read-only
-    angle = Property(depends_on='digest', desc='rotation angle for each sample')
+    # rotation angle in radians for each sample, read-only
+    angle = Property(depends_on=['digest'], desc='rotation angle for each sample')
 
     # Internal flag to determine whether rpm and angle calculation has been processed,
     # prevents recalculation
@@ -642,17 +581,17 @@ class AngleTracker(MaskedTimeInOut):
         # init
         ind = 0
         # trigger data
-        peakloc, maxdist, mindist = self.trigger.trigger_data()
+        peakloc, maxdist, mindist = self.trigger.trigger_data
         TriggerPerRevo = self.trigger_per_revo
         rotDirection = self.rot_direction
-        num = self.source.numsamples
+        num = self.source.num_samples
         samplerate = self.source.sample_freq
         self._rpm = zeros(num)
         self._angle = zeros(num)
         # number of spline points
         InterpPoints = self.interp_points
 
-        # loop over alle timesamples
+        # loop over all timesamples
         while ind < num:
             # when starting spline forward
             if ind < peakloc[InterpPoints]:
@@ -716,21 +655,24 @@ class AngleTracker(MaskedTimeInOut):
 
         """
         # trigger indices data
-        peakloc = self.trigger.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):  # pragma: no cover
     """Base class for spatial interpolation of microphone data.
     Gets samples from :attr:`source` and generates output via the
     generator :meth:`result`.
     """
 
-    #: :class:`~acoular.microphones.MicGeom` object that provides the real microphone locations.
+    # 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')
 
-    #: :class:`~acoular.microphones.MicGeom` object that provides the virtual microphone locations.
+    # :class:`~acoular.microphones.MicGeom` object that provides the virtual microphone locations.
     mics_virtual = Property(desc='microphone geometry')
 
     _mics_virtual = Instance(MicGeom, desc='internal microphone geometry;internal usage, read only')
@@ -743,15 +685,12 @@ 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
-    #: rbf is scipy radial basis function with multiquadric, cubic and sinc functions
-    #: idw refers to the inverse distance weighting algorithm
-    method = Trait(
+    # Interpolation method in spatial domain, defaults to linear
+    # linear uses numpy linear interpolation
+    # spline uses scipy CloughTocher algorithm
+    # rbf is scipy radial basis function with multiquadric, cubic and sinc functions
+    # idw refers to the inverse distance weighting algorithm
+    method = Enum(
         'linear',
         'spline',
         'rbf-multiquadric',
@@ -762,42 +701,41 @@ class SpatialInterpolator(TimeInOut):
         desc='method for interpolation used',
     )
 
-    #: spacial dimensionality of the array geometry
-    array_dimension = Trait('1D', '2D', 'ring', '3D', 'custom', desc='spacial dimensionality of the array geometry')
+    # spatial dimensionality of the array geometry
+    array_dimension = Enum('1D', '2D', 'ring', '3D', 'custom', desc='spatial dimensionality of the array geometry')
 
-    #: Sampling frequency of output signal, as given by :attr:`source`.
+    # Sampling frequency of output signal, as given by :attr:`source`.
     sample_freq = Delegate('source', 'sample_freq')
 
-    #: Number of channels in output.
-    numchannels = Property()
+    # Number of channels in output.
+    num_channels = Property()
 
-    #: Number of samples in output, as given by :attr:`source`.
-    numsamples = Delegate('source', 'numsamples')
+    # Number of samples in output, as given by :attr:`source`.
+    num_samples = Delegate('source', 'num_samples')
 
-    #:Interpolate a point at the origin of the Array geometry
+    # Interpolate a point at the origin of the Array geometry
     interp_at_zero = Bool(False)
 
-    #: The rotation must be around the z-axis, which means from x to y axis.
-    #: If the coordinates are not build like that, than this 3x3 orthogonal
-    #: transformation matrix Q can be used to modify the coordinates.
-    #: It is assumed that with the modified coordinates the rotation is around the z-axis.
-    #: The transformation is done via [x,y,z]_mod = Q * [x,y,z]. (default is Identity).
+    # The rotation must be around the z-axis, which means from x to y axis.
+    # If the coordinates are not build like that, than this 3x3 orthogonal
+    # transformation matrix Q can be used to modify the coordinates.
+    # It is assumed that with the modified coordinates the rotation is around the z-axis.
+    # 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')  # noqa: N815
+    num_IDW = Int(3, desc='number of neighboring microphones, DEFAULT=3')  # noqa: N815
 
-    p_weight = Trait(
+    p_weight = Float(
         2,
-        dtype=float,
         desc='used in interpolation for virtual microphone, weighting power exponent for IDW',
     )
 
-    #: Stores the output of :meth:`_virtNewCoord_func`; Read-Only
+    # Stores the output of :meth:`_virtNewCoord_func`; Read-Only
     _virtNewCoord_func = Property(  # noqa: N815
         depends_on=['mics.digest', 'mics_virtual.digest', 'method', 'array_dimension', 'interp_at_zero'],
     )
 
-    #: internal identifier
+    # internal identifier
     digest = Property(
         depends_on=[
             'mics.digest',
@@ -810,7 +748,7 @@ class SpatialInterpolator(TimeInOut):
         ],
     )
 
-    def _get_numchannels(self):
+    def _get_num_channels(self):
         return self.mics_virtual.num_mics
 
     @cached_property
@@ -842,26 +780,30 @@ class SpatialInterpolator(TimeInOut):
         Returns
         -------
         mesh : List[]
-            The items of these lists are dependent of the reduced interpolation dimension of each subarray.
+            The items of these lists depend on the reduced interpolation dimension of each subarray.
             If the Array is 1D the list items are:
                 1. item : float64[nMicsInSpecificSubarray]
-                    Ordered positions of the real mics on the new 1d axis, to be used as inputs for numpys interp.
+                    Ordered positions of the real mics on the new 1d axis,
+                    to be used as inputs for numpys interp.
                 2. item : int64[nMicsInArray]
-                    Indices identifying how the measured pressures must be evaluated, s.t. the entries of the previous item (see last line)
-                    correspond to their initial pressure values
+                    Indices identifying how the measured pressures must be evaluated, s.t. the
+                    entries of the previous item (see last line) correspond to their initial
+                    pressure values.
             If the Array is 2D or 3d the list items are:
                 1. item : Delaunay mesh object
-                    Delauney mesh (see scipy.spatial.Delaunay) for the specific Array
+                    Delaunay mesh (see scipy.spatial.Delaunay) for the specific Array
                 2. item : int64[nMicsInArray]
-                    same as 1d case, BUT with the difference, that here the rotational periodicy is handled, when constructing the mesh.
-                    Therefor the mesh could have more vertices than the actual Array mics.
+                    same as 1d case, BUT with the difference, that here the rotational periodicity
+                    is handled, when constructing the mesh. Therefore, the mesh could have more
+                    vertices than the actual Array mics.
 
         virtNewCoord : float64[3, nVirtualMics]
-            Projection of each virtual mic onto its new coordinates. The columns of virtNewCoord correspond to [phi, rho, z]
+            Projection of each virtual mic onto its new coordinates. The columns of virtNewCoord
+            correspond to [phi, rho, z].
 
         newCoord : float64[3, nMics]
-            Projection of each mic onto its new coordinates. The columns of newCoordinates correspond to [phi, rho, z]
-
+            Projection of each mic onto its new coordinates. The columns of newCoordinates
+            correspond to [phi, rho, z].
         """
         # init positions of virtual mics in cyl coordinates
         nVirtMics = mpos_virt.shape[1]
@@ -1017,12 +959,12 @@ class SpatialInterpolator(TimeInOut):
         if self.array_dimension == '1D' or self.array_dimension == 'ring':
             # for rotation add phi_delay
             if not array_equal(phi_delay, []):
-                xInterpHelp = repmat(virtNewCoord[0, :], nTime, 1) + repmat(phi_delay, virtNewCoord.shape[1], 1).T
+                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)
-            # get ordered microphone posions in radiant
+                xInterp = tile(virtNewCoord[0, :], (nTime, 1))
+            # get ordered microphone positions in radiant
             x = newCoord[0]
             for cntTime in range(nTime):
                 if self.method == 'linear':
@@ -1075,10 +1017,10 @@ class SpatialInterpolator(TimeInOut):
         elif self.array_dimension == '2D':
             # check rotation
             if not array_equal(phi_delay, []):
-                xInterpHelp = repmat(virtNewCoord[0, :], nTime, 1) + repmat(phi_delay, virtNewCoord.shape[1], 1).T
+                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):
@@ -1134,10 +1076,10 @@ class SpatialInterpolator(TimeInOut):
                 # using inverse distance weighting
                 elif self.method == 'IDW':
                     newPoint2_M = newPoint.T
-                    newPoint3_M = append(newPoint2_M, zeros([1, self.numchannels]), axis=0)
+                    newPoint3_M = append(newPoint2_M, zeros([1, self.num_channels]), 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]
@@ -1154,10 +1096,10 @@ class SpatialInterpolator(TimeInOut):
         elif self.array_dimension == '3D':
             # check rotation
             if not array_equal(phi_delay, []):
-                xInterpHelp = repmat(virtNewCoord[0, :], nTime, 1) + repmat(phi_delay, virtNewCoord.shape[1], 1).T
+                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):
@@ -1207,17 +1149,22 @@ class SpatialInterpolator(TimeInOut):
         # return interpolated pressure values
         return pInterp
 
+    def result(self, num):
+        msg = 'result method not implemented yet! Data from source will be passed without transformation.'
+        warn(msg, Warning, stacklevel=2)
+        yield from self.source.result(num)
+
 
-class SpatialInterpolatorRotation(SpatialInterpolator):
+class SpatialInterpolatorRotation(SpatialInterpolator):  # pragma: no cover
     """Spatial  Interpolation for rotating sources. Gets samples from :attr:`source`
     and angles from  :attr:`AngleTracker`.Generates output via the generator :meth:`result`.
 
     """
 
-    #: Angle data from AngleTracker class
+    # Angle data from AngleTracker class
     angle_source = Instance(AngleTracker)
 
-    #: Internal identifier
+    # Internal identifier
     digest = Property(
         depends_on=[
             'source.digest',
@@ -1246,7 +1193,7 @@ class SpatialInterpolatorRotation(SpatialInterpolator):
 
         Returns
         -------
-        Samples in blocks of shape (num, :attr:`numchannels`).
+        Samples in blocks of shape (num, :attr:`num_channels`).
             The last block may be shorter than num.
 
         """
@@ -1263,14 +1210,14 @@ class SpatialInterpolatorRotation(SpatialInterpolator):
             count += num
 
 
-class SpatialInterpolatorConstantRotation(SpatialInterpolator):
+class SpatialInterpolatorConstantRotation(SpatialInterpolator):  # pragma: no cover
     """Spatial linear Interpolation for constantly rotating sources.
     Gets samples from :attr:`source` and generates output via the
     generator :meth:`result`.
     """
 
-    #: Rotational speed in rps. Positive, if rotation is around positive z-axis sense,
-    #: which means from x to y axis.
+    # Rotational speed in rps. Positive, if rotation is around positive z-axis sense,
+    # which means from x to y axis.
     rotational_speed = Float(0.0)
 
     # internal identifier
@@ -1302,7 +1249,7 @@ class SpatialInterpolatorConstantRotation(SpatialInterpolator):
 
         Returns
         -------
-        Samples in blocks of shape (num, :attr:`numchannels`).
+        Samples in blocks of shape (num, :attr:`num_channels`).
             The last block may be shorter than num.
 
         """
@@ -1317,30 +1264,30 @@ class SpatialInterpolatorConstantRotation(SpatialInterpolator):
             yield interpVal
 
 
-class Mixer(TimeInOut):
+class Mixer(TimeOut):
     """Mixes the signals from several sources."""
 
-    #: Data source; :class:`~acoular.tprocess.SamplesGenerator` object.
-    source = Trait(SamplesGenerator)
+    # Data source; :class:`~acoular.base.SamplesGenerator` object.
+    source = Instance(SamplesGenerator)
 
-    #: List of additional :class:`~acoular.tprocess.SamplesGenerator` objects
-    #: to be mixed.
+    # List of additional :class:`~acoular.base.SamplesGenerator` objects
+    # to be mixed.
     sources = List(Instance(SamplesGenerator, ()))
 
-    #: Sampling frequency of the signal as given by :attr:`source`.
+    # Sampling frequency of the 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 channels in output as given by :attr:`source`.
+    num_channels = Delegate('source')
 
-    #: Number of samples in output as given by :attr:`source`.
-    numsamples = Delegate('source')
+    # Number of samples in output as given by :attr:`source`.
+    num_samples = Delegate('source')
 
     # internal identifier
     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
@@ -1355,9 +1302,11 @@ class Mixer(TimeInOut):
         if self.source:
             for s in self.sources:
                 if self.sample_freq != s.sample_freq:
-                    raise ValueError('Sample frequency of %s does not fit' % s)
-                if self.numchannels != s.numchannels:
-                    raise ValueError('Channel count of %s does not fit' % s)
+                    msg = f'Sample frequency of {s} does not fit'
+                    raise ValueError(msg)
+                if self.num_channels != s.num_channels:
+                    msg = f'Channel count of {s} does not fit'
+                    raise ValueError(msg)
 
     def result(self, num):
         """Python generator that yields the output block-wise.
@@ -1372,7 +1321,7 @@ class Mixer(TimeInOut):
 
         Returns
         -------
-        Samples in blocks of shape (num, numchannels).
+        Samples in blocks of shape (num, num_channels).
             The last block may be shorter than num.
 
         """
@@ -1395,9 +1344,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.
 
@@ -1410,7 +1362,7 @@ class TimePower(TimeInOut):
         Returns
         -------
         Squared output of source.
-            Yields samples in blocks of shape (num, numchannels).
+            Yields samples in blocks of shape (num, num_channels).
             The last block may be shorter than num.
 
         """
@@ -1418,64 +1370,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.
 
@@ -1488,7 +1388,7 @@ class TimeCumAverage(TimeInOut):
         Returns
         -------
         Cumulative average of the output of source.
-            Yields samples in blocks of shape (num, numchannels).
+            Yields samples in blocks of shape (num, num_channels).
             The last block may be shorter than num.
 
         """
@@ -1503,9 +1403,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.
 
@@ -1517,7 +1420,7 @@ class TimeReverse(TimeInOut):
 
         Returns
         -------
-        Yields samples in blocks of shape (num, numchannels).
+        Yields samples in blocks of shape (num, num_channels).
             Time-reversed output of source.
             The last block may be shorter than num.
 
@@ -1535,15 +1438,18 @@ class TimeReverse(TimeInOut):
         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.
 
-    Should not be instanciated by itself
+    Should not be instantiated by itself.
     """
 
-    #: Filter coefficients
+    # Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
+    # Filter coefficients
     sos = Property()
 
     def _get_sos(self):
@@ -1560,13 +1466,13 @@ class Filter(TimeInOut):
 
         Returns
         -------
-        Samples in blocks of shape (num, numchannels).
+        Samples in blocks of shape (num, num_channels).
             Delivers the bandpass filtered output of source.
             The last block may be shorter than num.
 
         """
         sos = self.sos
-        zi = zeros((sos.shape[0], 2, self.source.numchannels))
+        zi = 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
@@ -1577,19 +1483,19 @@ class Filter(TimeInOut):
 class FiltOctave(Filter):
     """Octave or third-octave filter (causal, non-zero phase delay)."""
 
-    #: Band center frequency; defaults to 1000.
+    # Band center frequency; defaults to 1000.
     band = Float(1000.0, desc='band center frequency')
 
-    #: Octave fraction: 'Octave' or 'Third octave'; defaults to 'Octave'.
-    fraction = Trait('Octave', {'Octave': 1, 'Third octave': 3}, desc='fraction of octave')
+    # Octave fraction: 'Octave' or 'Third octave'; defaults to 'Octave'.
+    fraction = Map({'Octave': 1, 'Third octave': 3}, default_value='Octave', desc='fraction of octave')
 
-    #: Filter order
+    # Filter order
     order = Int(3, desc='IIR filter order')
 
     sos = Property(depends_on=['band', 'fraction', 'source.digest', 'order'])
 
     # internal identifier
-    digest = Property(depends_on=['source.digest', '__class__', 'band', 'fraction', 'order'])
+    digest = Property(depends_on=['source.digest', 'band', 'fraction', 'order'])
 
     @cached_property
     def _get_digest(self):
@@ -1622,11 +1528,11 @@ class FiltFiltOctave(FiltOctave):
     It requires large amounts of memory!
     """
 
-    #: Filter order (applied for forward filter and backward filter)
+    # Filter order (applied for forward filter and backward filter)
     order = Int(2, desc='IIR filter half order')
 
     # internal identifier
-    digest = Property(depends_on=['source.digest', '__class__', 'band', 'fraction', 'order'])
+    digest = Property(depends_on=['source.digest', 'band', 'fraction', 'order'])
 
     @cached_property
     def _get_digest(self):
@@ -1664,20 +1570,20 @@ class FiltFiltOctave(FiltOctave):
 
         Returns
         -------
-        Samples in blocks of shape (num, numchannels).
+        Samples in blocks of shape (num, num_channels).
             Delivers the zero-phase bandpass filtered output of source.
             The last block may be shorter than num.
 
         """
         sos = self.sos
-        data = empty((self.source.numsamples, self.source.numchannels))
+        data = empty((self.source.num_samples, self.source.num_channels))
         j = 0
         for block in self.source.result(num):
             ns, nc = block.shape
             data[j : j + ns] = block
             j += ns
         # filter one channel at a time to save memory
-        for j in range(self.source.numchannels):
+        for j in range(self.source.num_channels):
             data[:, j] = sosfiltfilt(sos, data[:, j])
         j = 0
         ns = data.shape[0]
@@ -1692,13 +1598,13 @@ class TimeExpAverage(Filter):
     I (non-standard) -> 35 ms.
     """
 
-    #: time weighting
-    weight = Trait('F', {'F': 0.125, 'S': 1.0, 'I': 0.035}, desc='time weighting')
+    # time weighting
+    weight = Map({'F': 0.125, 'S': 1.0, 'I': 0.035}, default_value='F', desc='time weighting')
 
     sos = Property(depends_on=['weight', 'source.digest'])
 
     # internal identifier
-    digest = Property(depends_on=['source.digest', '__class__', 'weight'])
+    digest = Property(depends_on=['source.digest', 'weight'])
 
     @cached_property
     def _get_digest(self):
@@ -1713,15 +1619,15 @@ class TimeExpAverage(Filter):
 
 
 class FiltFreqWeight(Filter):
-    """Frequency weighting filter accoring to IEC 61672."""
+    """Frequency weighting filter according to IEC 61672."""
 
-    #: weighting characteristics
-    weight = Trait('A', ('A', 'C', 'Z'), desc='frequency weighting')
+    # weighting characteristics
+    weight = Enum('A', 'C', 'Z', desc='frequency weighting')
 
     sos = Property(depends_on=['weight', 'source.digest'])
 
     # internal identifier
-    digest = Property(depends_on=['source.digest', '__class__', 'weight'])
+    digest = Property(depends_on=['source.digest', 'weight'])
 
     @cached_property
     def _get_digest(self):
@@ -1751,36 +1657,43 @@ class FiltFreqWeight(Filter):
         return tf2sos(b, a)
 
 
-class FilterBank(TimeInOut):
+@deprecated_alias({'numbands': 'num_bands'}, read_only=True)
+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
+    Should not be instantiated by itself.
     """
 
-    #: List of filter coefficients for all filters
+    # Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
+    # List of filter coefficients for all filters
     sos = Property()
 
-    #: List of labels for bands
+    # List of labels for bands
     bands = Property()
 
-    #: Number of bands
-    numbands = Property()
+    # Number of bands
+    num_bands = Property()
 
-    #: Number of bands
-    numchannels = Property()
+    # Number of bands
+    num_channels = Property()
 
+    @abstractmethod
     def _get_sos(self):
-        return [tf2sos([1], [1])]
+        """Returns a list of second order section coefficients."""
 
+    @abstractmethod
     def _get_bands(self):
-        return ['']
+        """Returns a list of labels for the bands."""
 
-    def _get_numbands(self):
-        return 0
+    @abstractmethod
+    def _get_num_bands(self):
+        """Returns the number of bands."""
 
-    def _get_numchannels(self):
-        return self.numbands * self.source.numchannels
+    def _get_num_channels(self):
+        return self.num_bands * self.source.num_channels
 
     def result(self, num):
         """Python generator that yields the output block-wise.
@@ -1793,16 +1706,16 @@ class FilterBank(TimeInOut):
 
         Returns
         -------
-        Samples in blocks of shape (num, numchannels).
+        Samples in blocks of shape (num, num_channels).
             Delivers the bandpass filtered output of source.
             The last block may be shorter than num.
 
         """
-        numbands = self.numbands
-        snumch = self.source.numchannels
+        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.numchannels), dtype='float')
+        res = zeros((num, self.num_channels), dtype='float')
         for block in self.source.result(num):
             for i in range(numbands):
                 res[:, i * snumch : (i + 1) * snumch], zi[i] = sosfilt(sos[i], block, axis=0, zi=zi[i])
@@ -1812,26 +1725,26 @@ class FilterBank(TimeInOut):
 class OctaveFilterBank(FilterBank):
     """Octave or third-octave filter bank."""
 
-    #: Lowest band center frequency index; defaults to 21 (=125 Hz).
+    # Lowest band center frequency index; defaults to 21 (=125 Hz).
     lband = Int(21, desc='lowest band center frequency index')
 
-    #: Lowest band center frequency index + 1; defaults to 40 (=8000 Hz).
+    # Lowest band center frequency index + 1; defaults to 40 (=8000 Hz).
     hband = Int(40, desc='lowest band center frequency index')
 
-    #: Octave fraction: 'Octave' or 'Third octave'; defaults to 'Octave'.
-    fraction = Trait('Octave', {'Octave': 1, 'Third octave': 3}, desc='fraction of octave')
+    # Octave fraction: 'Octave' or 'Third octave'; defaults to 'Octave'.
+    fraction = Map({'Octave': 1, 'Third octave': 3}, default_value='Octave', desc='fraction of octave')
 
-    #: List of filter coefficients for all filters
+    # List of filter coefficients for all filters
     ba = Property(depends_on=['lband', 'hband', 'fraction', 'source.digest'])
 
-    #: List of labels for bands
+    # List of labels for bands
     bands = Property(depends_on=['lband', 'hband', 'fraction'])
 
-    #: Number of bands
-    numbands = Property(depends_on=['lband', 'hband', 'fraction'])
+    # Number of bands
+    num_bands = Property(depends_on=['lband', 'hband', 'fraction'])
 
     # internal identifier
-    digest = Property(depends_on=['source.digest', '__class__', 'lband', 'hband', 'fraction', 'order'])
+    digest = Property(depends_on=['source.digest', 'lband', 'hband', 'fraction', 'order'])
 
     @cached_property
     def _get_digest(self):
@@ -1842,7 +1755,7 @@ class OctaveFilterBank(FilterBank):
         return [10 ** (i / 10) for i in range(self.lband, self.hband, 4 - self.fraction_)]
 
     @cached_property
-    def _get_numbands(self):
+    def _get_num_bands(self):
         return len(self.bands)
 
     @cached_property
@@ -1856,148 +1769,27 @@ 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):
+@deprecated_alias({'name': 'file'})
+class WriteWAV(TimeOut):
     """Saves time signal from one or more channels as mono/stereo/multi-channel
     `*.wav` file.
     """
 
-    #: 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')
+    # 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.
+    file = File(filter=['*.wav'], desc='name of wave file')
 
-    #: Basename for cache, readonly.
-    basename = Property(depends_on='digest')
+    # Basename for cache, readonly.
+    basename = Property(depends_on=['digest'])
 
-    #: Channel(s) to save. List can only contain one or two channels.
-    channels = ListInt(desc='channel to save')
+    # Channel(s) to save. List can only contain one or two channels.
+    channels = List(int, desc='channel to save')
 
     # internal identifier
-    digest = Property(depends_on=['source.digest', 'channels', '__class__'])
+    digest = Property(depends_on=['source.digest', 'channels'])
 
     @cached_property
     def _get_digest(self):
@@ -2005,18 +1797,15 @@ class WriteWAV(TimeInOut):
 
     @cached_property
     def _get_basename(self):
-        obj = self.source  # start with source
-        try:
-            while obj:
-                if 'basename' in obj.all_trait_names():  # at original source?
-                    basename = obj.basename  # get the name
-                    break
-                obj = obj.source  # traverse down until original data source
-            else:
-                basename = 'void'
-        except AttributeError:
-            basename = 'void'  # if no file source is found
-        return basename
+        warn(
+            (
+                f'The basename attribute of a {self.__class__.__name__} object is deprecated'
+                ' and will be removed in a future release!'
+            ),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return find_basename(self.source)
 
     def save(self):
         """Saves source output to one- or multiple-channel `*.wav` file."""
@@ -2025,51 +1814,59 @@ class WriteWAV(TimeInOut):
             msg = 'No channels given for output.'
             raise ValueError(msg)
         if nc > 2:
-            warn('More than two channels given for output, exported file will have %i channels' % nc, stacklevel=1)
-        if self.name == '':
+            warn(f'More than two channels given for output, exported file will have {nc:d} channels', stacklevel=1)
+        if self.file == '':
             name = self.basename
             for nr in self.channels:
-                name += '_%i' % nr
+                name += f'{nr:d}'
             name += '.wav'
         else:
-            name = self.name
-        wf = wave.open(name, 'w')
-        wf.setnchannels(nc)
-        wf.setsampwidth(2)
-        wf.setframerate(self.source.sample_freq)
-        wf.setnframes(self.source.numsamples)
-        mx = 0.0
-        ind = array(self.channels)
-        for data in self.source.result(1024):
-            mx = max(abs(data[:, ind]).max(), mx)
-        scale = 0.9 * 2**15 / mx
-        for data in self.source.result(1024):
-            wf.writeframesraw(array(data[:, ind] * scale, dtype=int16).tostring())
-        wf.close()
-
-
-class WriteH5(TimeInOut):
+            name = self.file
+        with wave.open(name, 'w') as wf:
+            wf.setnchannels(nc)
+            wf.setsampwidth(2)
+            wf.setframerate(self.source.sample_freq)
+            wf.setnframes(self.source.num_samples)
+            mx = 0.0
+            ind = array(self.channels)
+            for data in self.source.result(1024):
+                mx = max(abs(data[:, ind]).max(), mx)
+            scale = 0.9 * 2**15 / mx
+            for data in self.source.result(1024):
+                wf.writeframesraw(array(data[:, ind] * scale, dtype=int16).tostring())
+
+    def result(self, num):
+        msg = 'result method not implemented yet! Data from source will be passed without transformation.'
+        warn(msg, Warning, stacklevel=2)
+        yield from self.source.result(num)
+
+
+@deprecated_alias({'name': 'file', 'numsamples_write': 'num_samples_write', 'writeflag': 'write_flag'})
+class WriteH5(TimeOut):
     """Saves time signal as `*.h5` file."""
 
-    #: 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')
+    # 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.
+    file = File(filter=['*.h5'], desc='name of data file')
 
-    #: Number of samples to write to file by `result` method.
-    #: defaults to -1 (write as long as source yields data).
-    numsamples_write = Int(-1)
+    # Number of samples to write to file by `result` method.
+    # defaults to -1 (write as long as source yields data).
+    num_samples_write = Int(-1)
 
     # flag that can be raised to stop file writing
-    writeflag = Bool(True)
+    write_flag = Bool(True)
 
     # internal identifier
-    digest = Property(depends_on=['source.digest', '__class__'])
+    digest = Property(depends_on=['source.digest'])
 
-    #: The floating-number-precision of entries of H5 File corresponding
-    #: to numpy dtypes. Default is 32 bit.
-    precision = Trait('float32', 'float64', desc='precision of H5 File')
+    # The floating-number-precision of entries of H5 File corresponding
+    # to numpy dtypes. Default is 32 bit.
+    precision = Enum('float32', 'float64', desc='precision of H5 File')
 
-    #: Metadata to be stored in HDF5 file object
+    # Metadata to be stored in HDF5 file object
     metadata = Dict(desc='metadata to be stored in .h5 file')
 
     @cached_property
@@ -2077,15 +1874,15 @@ class WriteH5(TimeInOut):
         return digest(self)
 
     def create_filename(self):
-        if self.name == '':
+        if self.file == '':
             name = datetime.now(tz=timezone.utc).isoformat('_').replace(':', '-').replace('.', '_')
-            self.name = path.join(config.td_dir, name + '.h5')
+            self.file = path.join(config.td_dir, name + '.h5')
 
     def get_initialized_file(self):
         file = _get_h5file_class()
         self.create_filename()
-        f5h = file(self.name, mode='w')
-        f5h.create_extendable_array('time_data', (0, self.numchannels), self.precision)
+        f5h = file(self.file, mode='w')
+        f5h.create_extendable_array('time_data', (0, self.num_channels), self.precision)
         ac = f5h.get_data_by_reference('time_data')
         f5h.set_node_attribute(ac, 'sample_freq', self.sample_freq)
         self.add_metadata(f5h)
@@ -2105,6 +1902,8 @@ class WriteH5(TimeInOut):
         if nitems > 0:
             f5h.create_new_group('metadata', '/')
             for key, value in self.metadata.items():
+                if isinstance(value, str):
+                    value = array(value, dtype='S')
                 f5h.create_array('/metadata', key, value)
 
     def result(self, num):
@@ -2120,19 +1919,19 @@ class WriteH5(TimeInOut):
 
         Returns
         -------
-        Samples in blocks of shape (num, numchannels).
+        Samples in blocks of shape (num, num_channels).
             The last block may be shorter than num.
             Echos the source output, but reads it from cache
-            when available and prevents unnecassary recalculation.
+            when available and prevents unnecessary recalculation.
 
         """
-        self.writeflag = True
+        self.write_flag = True
         f5h = self.get_initialized_file()
         ac = f5h.get_data_by_reference('time_data')
         scount = 0
-        stotal = self.numsamples_write
+        stotal = self.num_samples_write
         source_gen = self.source.result(num)
-        while self.writeflag:
+        while self.write_flag:
             sleft = stotal - scount
             if stotal != -1 and sleft > 0:
                 anz = min(num, sleft)
@@ -2145,166 +1944,24 @@ class WriteH5(TimeInOut):
             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()
+class TimeConvolve(TimeOut):
+    """Fast frequency domain convolution with the Uniformly partitioned overlap-save method (UPOLS).
 
-    def __next__(self):  # this function implementation is not python 2 compatible!
-        with self.lock:
-            return self.it.__next__()
-
-
-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`.
-    #: If only a single kernel is supplied, it is applied to all channels.
+    # Convolution kernel in the time domain. The second dimension of the kernel array has to be
+    # either 1 or match :attr:`~SamplesGenerator.num_channels`. If only a single kernel is supplied,
+    # it is applied to all channels.
     kernel = CArray(dtype=float, desc='Convolution kernel.')
 
     _block_size = Int(desc='Block size')
@@ -2315,7 +1972,7 @@ class TimeConvolve(TimeInOut):
     )
 
     # internal identifier
-    digest = Property(depends_on=['source.digest', 'kernel', '__class__'])
+    digest = Property(depends_on=['source.digest', 'kernel'])
 
     @cached_property
     def _get_digest(self):
@@ -2330,9 +1987,9 @@ class TimeConvolve(TimeInOut):
         if self.kernel.ndim > 2:
             msg = 'Only one or two dimensional kernels accepted.'
             raise ValueError(msg)
-        # check if number of kernels matches numchannels
-        if self.kernel.shape[1] not in (1, self.source.numchannels):
-            msg = 'Number of kernels must be either `numchannels` or one.'
+        # check if number of kernels matches num_channels
+        if self.kernel.shape[1] not in (1, self.source.num_channels):
+            msg = 'Number of kernels must be either `num_channels` or one.'
             raise ValueError(msg)
 
     # compute the rfft of the kernel blockwise
@@ -2366,7 +2023,7 @@ class TimeConvolve(TimeInOut):
 
         Returns
         -------
-        Samples in blocks of shape (num, numchannels).
+        Samples in blocks of shape (num, num_channels).
             The last block may be shorter than num.
 
         """
@@ -2374,8 +2031,8 @@ class TimeConvolve(TimeInOut):
         # initialize variables
         self._block_size = num
         L = self.kernel.shape[0]
-        N = self.source.numchannels
-        M = self.source.numsamples
+        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
@@ -2425,13 +2082,13 @@ class TimeConvolve(TimeInOut):
 
 
 @nb.jit(nopython=True, cache=True)
-def _append_to_fdl(fdl, idx, numblocks_kernel, buff):
+def _append_to_fdl(fdl, idx, numblocks_kernel, buff):  # pragma: no cover
     fdl[idx] = buff
     idx = int(idx + 1 % numblocks_kernel)
 
 
 @nb.jit(nopython=True, cache=True)
-def _spectral_sum(out, fdl, kb):
+def _spectral_sum(out, fdl, kb):  # pragma: no cover
     P, B, N = kb.shape
     for n in range(N):
         for b in range(B):
@@ -2440,3 +2097,21 @@ def _spectral_sum(out, fdl, kb):
                 out[b, n] += fdl[i, b, n] * kb[i, b, n]
 
     return out
+
+
+class MaskedTimeInOut(MaskedTimeOut):
+    """Signal processing block for channel and sample selection.
+
+    .. 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,
+        )