acoular 24.7__py3-none-any.whl → 25.1__py3-none-any.whl

acoular/tbeamform.py

@@ -18,15 +18,12 @@
 """
 
 # imports from other packages
-import contextlib
-from warnings import warn
 
 from numpy import (
     arange,
     argmax,
     array,
     ceil,
-    concatenate,
     dot,
     empty,
     float32,
@@ -40,22 +37,22 @@ from numpy import (
     r_,
     s_,
     sqrt,
-    sum,
+    sum,  # noqa: A004
     unique,
     where,
     zeros,
 )
-from numpy.linalg import norm
-from traits.api import Bool, CArray, Delegate, Enum, Float, Instance, Int, List, Property, Range, Trait, cached_property
-from traits.trait_errors import TraitError
+from scipy.linalg import norm
+from traits.api import Bool, CArray, Enum, Float, Instance, Int, List, Map, Property, Range, cached_property
 
+from .base import SamplesGenerator, TimeOut
 from .fbeamform import SteeringVector
 from .grids import RectGrid
 
 # acoular imports
 from .internal import digest
-from .tfastfuncs import _delayandsum4, _delayandsum5, _delays, _steer_I, _steer_II, _steer_III, _steer_IV
-from .tprocess import TimeInOut
+from .process import SamplesBuffer
+from .tfastfuncs import _delayandsum4, _delayandsum5, _delays
 from .trajectory import Trajectory
 
 
@@ -75,9 +72,8 @@ def const_power_weight(bf):
     -------
     array of floats
         The weight factors.
-
     """
-    r = bf.steer.env._r(zeros((3, 1)), bf.steer.mics.mpos)  # distances to center
+    r = bf.steer.env._r(zeros((3, 1)), bf.steer.mics.pos)  # distances to center
     # round the relative distances to one decimal place
     r = (r / r.max()).round(decimals=1)
     ru, ind = unique(r, return_inverse=True)
@@ -93,199 +89,94 @@ def const_power_weight(bf):
 possible_weights = {'none': None, 'power': const_power_weight}
 
 
-class BeamformerTime(TimeInOut):
+class BeamformerTime(TimeOut):
     """Provides a basic time domain beamformer with time signal output
     for a spatially fixed grid.
     """
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     # Instance of :class:`~acoular.fbeamform.SteeringVector` or its derived classes
     # that contains information about the steering vector. This is a private trait.
     # Do not set this directly, use `steer` trait instead.
-    _steer_obj = Instance(SteeringVector(), SteeringVector)
-
-    #: :class:`~acoular.fbeamform.SteeringVector` or derived object.
-    #: Defaults to :class:`~acoular.fbeamform.SteeringVector` object.
-    steer = Property(desc='steering vector object')
-
-    def _get_steer(self):
-        return self._steer_obj
-
-    def _set_steer(self, steer):
-        if type(steer) == SteeringVector:
-            # This condition may be replaced at a later time by: isinstance(steer, SteeringVector): -- (derived classes allowed)
-            self._steer_obj = steer
-        elif steer in ('true level', 'true location', 'classic', 'inverse'):
-            # Type of steering vectors, see also :ref:`Sarradj, 2012<Sarradj2012>`.
-            warn(
-                "Deprecated use of 'steer' trait. Please use object of class 'SteeringVector' in the future.",
-                Warning,
-                stacklevel=2,
-            )
-            self._steer_obj.steer_type = steer
-        else:
-            raise (TraitError(args=self, name='steer', info='SteeringVector', value=steer))
-
-    # --- List of backwards compatibility traits and their setters/getters -----------
-
-    # :class:`~acoular.environments.Environment` or derived object.
-    # Deprecated! Only kept for backwards compatibility.
-    # Now governed by :attr:`steer` trait.
-    env = Property()
-
-    def _get_env(self):
-        return self._steer_obj.env
-
-    def _set_env(self, env):
-        warn("Deprecated use of 'env' trait. ", Warning, stacklevel=2)
-        self._steer_obj.env = env
-
-    # The speed of sound.
-    # Deprecated! Only kept for backwards compatibility.
-    # Now governed by :attr:`steer` trait.
-    c = Property()
-
-    def _get_c(self):
-        return self._steer_obj.env.c
-
-    def _set_c(self, c):
-        warn("Deprecated use of 'c' trait. ", Warning, stacklevel=2)
-        self._steer_obj.env.c = c
-
-    # :class:`~acoular.grids.Grid`-derived object that provides the grid locations.
-    # Deprecated! Only kept for backwards compatibility.
-    # Now governed by :attr:`steer` trait.
-    grid = Property()
-
-    def _get_grid(self):
-        return self._steer_obj.grid
-
-    def _set_grid(self, grid):
-        warn("Deprecated use of 'grid' trait. ", Warning, stacklevel=2)
-        self._steer_obj.grid = grid
-
-    # :class:`~acoular.microphones.MicGeom` object that provides the microphone locations.
-    # Deprecated! Only kept for backwards compatibility.
-    # Now governed by :attr:`steer` trait
-    mpos = Property()
-
-    def _get_mpos(self):
-        return self._steer_obj.mics
-
-    def _set_mpos(self, mpos):
-        warn("Deprecated use of 'mpos' trait. ", Warning, stacklevel=2)
-        self._steer_obj.mics = mpos
-
-    # Sound travel distances from microphone array center to grid points (r0)
-    # and all array mics to grid points (rm). Readonly.
-    # Deprecated! Only kept for backwards compatibility.
-    # Now governed by :attr:`steer` trait
-    r0 = Property()
-
-    def _get_r0(self):
-        return self._steer_obj.r0
-
-    rm = Property()
-
-    def _get_rm(self):
-        return self._steer_obj.rm
-
-    # --- End of backwards compatibility traits --------------------------------------
+    steer = Instance(SteeringVector, args=())
 
     #: Number of channels in output (=number of grid points).
-    numchannels = Delegate('grid', 'size')
+    num_channels = Property()
 
     #: Spatial weighting function.
-    weights = Trait('none', possible_weights, desc='spatial weighting function')
+    weights = Map(possible_weights, default_value='none', desc='spatial weighting function')
     # (from timedomain.possible_weights)
 
-    # buffer with microphone time signals used for processing. Internal use
-    buffer = CArray(desc='buffer containing microphone signals')
-
-    # index indicating position of current processing sample. Internal use.
-    bufferIndex = Int(desc='index indicating position in buffer')  # noqa: N815
-
     # internal identifier
     digest = Property(
-        depends_on=['_steer_obj.digest', 'source.digest', 'weights', '__class__'],
+        depends_on=['steer.digest', 'source.digest', 'weights'],
     )
 
-    @cached_property
+    def _get_num_channels(self):
+        return self.steer.grid.size
+
     def _get_digest(self):
         return digest(self)
 
     def _get_weights(self):
         return self.weights_(self)[newaxis] if self.weights_ else 1.0
 
-    def _fill_buffer(self, num):
-        """Generator that fills the signal buffer."""
-        weights = self._get_weights()
-        for block in self.source.result(num):
-            block *= weights
-            ns = block.shape[0]
-            bufferSize = self.buffer.shape[0]
-            self.buffer[0 : (bufferSize - ns)] = self.buffer[-(bufferSize - ns) :]
-            self.buffer[-ns:, :] = block
-            self.bufferIndex -= ns
-            yield
-
     def result(self, num=2048):
-        """Python generator that yields the *squared* deconvolved beamformer
-        output with optional removal of autocorrelation block-wise.
+        """Python generator that yields the time-domain beamformer output.
+
+        The output time signal starts for source signals that were emitted from
+        the :class:`~acoular.grids.Grid` at `t=0`.
 
         Parameters
         ----------
-        num : integer, defaults to 2048
+        num : int
             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, :attr:`~BeamformerTime.numchannels`).
-            :attr:`~BeamformerTime.numchannels` is usually very \
-            large (number of grid points).
-            The last block may be shorter than num. \
-            The output starts for signals that were emitted
-            from the grid at `t=0`.
-
+            (i.e. the number of samples per block). Defaults to 2048.
+
+        Yields
+        ------
+        numpy.ndarray
+            Samples in blocks of shape (num, :attr:`~BeamformerTime.num_channels`).
+                :attr:`~BeamformerTime.num_channels` is usually very \
+                large (number of grid points).
+                The last block returned by the generator may be shorter than num.
         """
         # initialize values
+        steer_func = self.steer._steer_funcs_time[self.steer.steer_type]
         fdtype = float64
         idtype = int64
-        numMics = self.steer.mics.num_mics
+        num_mics = self.steer.mics.num_mics
         n_index = arange(0, num + 1)[:, newaxis]
         c = self.steer.env.c / self.source.sample_freq
-        amp = empty((1, self.grid.size, numMics), dtype=fdtype)
-        # delays = empty((1,self.grid.size,numMics),dtype=fdtype)
-        d_index = empty((1, self.grid.size, numMics), dtype=idtype)
-        d_interp2 = empty((1, self.grid.size, numMics), dtype=fdtype)
-        _steer_III(self.rm[newaxis, :, :], self.r0[newaxis, :], amp)
-        _delays(self.rm[newaxis, :, :], c, d_interp2, d_index)
+        amp = empty((1, self.steer.grid.size, num_mics), dtype=fdtype)
+        # delays = empty((1,self.steer.grid.size,num_mics),dtype=fdtype)
+        d_index = empty((1, self.steer.grid.size, num_mics), dtype=idtype)
+        d_interp2 = empty((1, self.steer.grid.size, num_mics), dtype=fdtype)
+        steer_func(self.steer.rm[newaxis, :, :], self.steer.r0[newaxis, :], amp)
+        _delays(self.steer.rm[newaxis, :, :], c, d_interp2, d_index)
         amp.shape = amp.shape[1:]
         # delays.shape = delays.shape[1:]
         d_index.shape = d_index.shape[1:]
         d_interp2.shape = d_interp2.shape[1:]
-        maxdelay = int((self.rm / c).max()) + 2 + num  # +2 because of interpolation
-        initialNumberOfBlocks = int(ceil(maxdelay / num))
-        bufferSize = initialNumberOfBlocks * num
-        self.buffer = zeros((bufferSize, numMics), dtype=float)
-        self.bufferIndex = bufferSize  # indexing current time sample in buffer
-        fill_buffer_generator = self._fill_buffer(num)
-        for _ in range(initialNumberOfBlocks):
-            next(fill_buffer_generator)
+        max_sample_delay = int((self.steer.rm / c).max()) + 2
+        weights = self._get_weights()
 
-        # start processing
-        flag = True
-        while flag:
-            samplesleft = self.buffer.shape[0] - self.bufferIndex
-            if samplesleft - maxdelay <= 0:
-                num += samplesleft - maxdelay
-                maxdelay += samplesleft - maxdelay
+        buffer = SamplesBuffer(
+            source=self.source,
+            length=int(ceil((num + max_sample_delay) / num)) * num,
+            result_num=num + max_sample_delay,
+            shift_index_by='num',
+            dtype=fdtype,
+        )
+        for p_res in buffer.result(num):
+            p_res *= weights
+            if p_res.shape[0] < buffer.result_num:  # last block shorter
+                num = p_res.shape[0] - max_sample_delay
                 n_index = arange(0, num + 1)[:, newaxis]
-                flag = False
             # init step
-            p_res = array(self.buffer[self.bufferIndex : self.bufferIndex + maxdelay, :])
-            Phi, autopow = self.delay_and_sum(num, p_res, d_interp2, d_index, amp)
+            Phi, autopow = self._delay_and_sum(num, p_res, d_interp2, d_index, amp)
             if 'Cleant' not in self.__class__.__name__:
                 if 'Sq' not in self.__class__.__name__:
                     yield Phi[:num]
@@ -294,6 +185,7 @@ class BeamformerTime(TimeInOut):
                 else:
                     yield Phi[:num] ** 2
             else:
+                p_res_copy = p_res.copy()
                 Gamma = zeros(Phi.shape)
                 Gamma_autopow = zeros(Phi.shape)
                 J = 0
@@ -304,13 +196,13 @@ class BeamformerTime(TimeInOut):
                     imax = argmax(powPhi)
                     t_float = d_interp2[imax] + d_index[imax] + n_index
                     t_ind = t_float.astype(int64)
-                    for m in range(numMics):
-                        p_res[t_ind[: num + 1, m], m] -= self.damp * interp(
+                    for m in range(num_mics):
+                        p_res_copy[t_ind[: num + 1, m], m] -= self.damp * interp(
                             t_ind[: num + 1, m],
                             t_float[:num, m],
-                            Phi[:num, imax] * self.r0[imax] / self.rm[imax, m],
+                            Phi[:num, imax] * self.steer.r0[imax] / self.steer.rm[imax, m],
                         )
-                    nextPhi, nextAutopow = self.delay_and_sum(num, p_res, d_interp2, d_index, amp)
+                    nextPhi, nextAutopow = self._delay_and_sum(num, p_res_copy, d_interp2, d_index, amp)
                     if self.r_diag:
                         pownextPhi = (nextPhi[:num] ** 2 - nextAutopow).sum(0).clip(min=0)
                     else:
@@ -331,14 +223,11 @@ class BeamformerTime(TimeInOut):
                     yield Gamma[:num] ** 2 - (self.damp**2) * Gamma_autopow[:num]
                 else:
                     yield Gamma[:num] ** 2
-            self.bufferIndex += num
-            with contextlib.suppress(StopIteration):
-                next(fill_buffer_generator)
 
-    def delay_and_sum(self, num, p_res, d_interp2, d_index, amp):
+    def _delay_and_sum(self, num, p_res, d_interp2, d_index, amp):
         """Standard delay-and-sum method."""
-        result = empty((num, self.grid.size), dtype=float)  # output array
-        autopow = empty((num, self.grid.size), dtype=float)  # output array
+        result = empty((num, self.steer.grid.size), dtype=float)  # output array
+        autopow = empty((num, self.steer.grid.size), dtype=float)  # output array
         _delayandsum4(p_res, d_index, d_interp2, amp, result, autopow)
         return result, autopow
 
@@ -354,13 +243,35 @@ class BeamformerTimeSq(BeamformerTime):
 
     # internal identifier
     digest = Property(
-        depends_on=['_steer_obj.digest', 'source.digest', 'r_diag', 'weights', '__class__'],
+        depends_on=['steer.digest', 'source.digest', 'r_diag', 'weights'],
     )
 
     @cached_property
     def _get_digest(self):
         return digest(self)
 
+    def result(self, num=2048):
+        """Python generator that yields the **squared** time-domain beamformer output.
+
+        The squared output time signal starts for source signals that were emitted from
+        the :class:`~acoular.grids.Grid` at `t=0`.
+
+        Parameters
+        ----------
+        num : int
+            This parameter defines the size of the blocks to be yielded
+            (i.e. the number of samples per block). Defaults to 2048.
+
+        Yields
+        ------
+        numpy.ndarray
+            Samples in blocks of shape (num, :attr:`~BeamformerTime.num_channels`).
+                :attr:`~BeamformerTime.num_channels` is usually very \
+                large (number of grid points).
+                The last block returned by the generator may be shorter than num.
+        """
+        return super().result(num)
+
 
 class BeamformerTimeTraj(BeamformerTime):
     """Provides a basic time domain beamformer with time signal output
@@ -369,7 +280,7 @@ class BeamformerTimeTraj(BeamformerTime):
 
     #: :class:`~acoular.trajectory.Trajectory` or derived object.
     #: Start time is assumed to be the same as for the samples.
-    trajectory = Trait(Trajectory, desc='trajectory of the grid center')
+    trajectory = Instance(Trajectory, desc='trajectory of the grid center')
 
     #: Reference vector, perpendicular to the y-axis of moving grid.
     rvec = CArray(dtype=float, shape=(3,), value=array((0, 0, 0)), desc='reference vector')
@@ -378,19 +289,18 @@ class BeamformerTimeTraj(BeamformerTime):
     conv_amp = Bool(False, desc='determines if convective amplification of source is considered')
 
     #: Floating point and integer precision
-    precision = Trait(64, [32, 64], desc='numeric precision')
+    precision = Enum(64, 32, desc='numeric precision')
 
     # internal identifier
     digest = Property(
         depends_on=[
-            '_steer_obj.digest',
+            'steer.digest',
             'source.digest',
             'weights',
             'precision',
             'rvec',
             'conv_amp',
             'trajectory.digest',
-            '__class__',
         ],
     )
 
@@ -398,7 +308,7 @@ class BeamformerTimeTraj(BeamformerTime):
     def _get_digest(self):
         return digest(self)
 
-    def get_moving_gpos(self):
+    def _get_moving_gpos(self):
         """Python generator that yields the moving grid coordinates samplewise."""
 
         def cross(a, b):
@@ -408,7 +318,7 @@ class BeamformerTimeTraj(BeamformerTime):
             return array([a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]])
 
         start_t = 0.0
-        gpos = self.grid.pos()
+        gpos = self.steer.grid.pos
         trajg = self.trajectory.traj(start_t, delta_t=1 / self.source.sample_freq)
         trajg1 = self.trajectory.traj(start_t, delta_t=1 / self.source.sample_freq, der=1)
         rflag = (self.rvec == 0).all()  # flag translation vs. rotation
@@ -430,43 +340,38 @@ class BeamformerTimeTraj(BeamformerTime):
                 #                print(loc[:])
                 yield tpos
 
-    def get_macostheta(self, g1, tpos, rm):
+    def _get_macostheta(self, g1, tpos, rm):
         vvec = array(g1)  # velocity vector
         ma = norm(vvec) / self.steer.env.c  # machnumber
         fdv = (vvec / sqrt((vvec * vvec).sum()))[:, newaxis]  # unit vecor velocity
-        mpos = self.steer.mics.mpos[:, newaxis, :]
+        mpos = self.steer.mics.pos[:, newaxis, :]
         rmv = tpos[:, :, newaxis] - mpos
         return (ma * sum(rmv.reshape((3, -1)) * fdv, 0) / rm.reshape(-1)).reshape(rm.shape)
 
     def get_r0(self, tpos):
         if isscalar(self.steer.ref) and self.steer.ref > 0:
             return self.steer.ref  # full((self.steer.grid.size,), self.steer.ref)
-        return self.env._r(tpos)
-
-    def increase_buffer(self, num):
-        ar = zeros((num, self.steer.mics.num_mics), dtype=self.buffer.dtype)
-        self.buffer = concatenate((ar, self.buffer), axis=0)
-        self.bufferIndex += num
+        return self.steer.env._r(tpos)
 
     def result(self, num=2048):
-        """Python generator that yields the deconvolved output block-wise.
+        """Python generator that yields the time-domain beamformer output.
+
+        The output time signal starts for source signals that were emitted from
+        the :class:`~acoular.grids.Grid` at `t=0`.
 
         Parameters
         ----------
-        num : integer, defaults to 2048
+        num : int
             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, :attr:`~BeamformerTime.numchannels`).
-            :attr:`~BeamformerTime.numchannels` is usually very \
-            large (number of grid points).
-            The last block may be shorter than num. \
-            The output starts for signals that were emitted
-            from the grid at `t=0`.
-
+            (i.e. the number of samples per block). Defaults to 2048.
+
+        Yields
+        ------
+        numpy.ndarray
+            Samples in blocks of shape (num, :attr:`~BeamformerTime.num_channels`).
+                :attr:`~BeamformerTime.num_channels` is usually very \
+                large (number of grid points).
+                The last block returned by the generator may be shorter than num.
         """
         # initialize values
         if self.precision == 64:
@@ -477,36 +382,28 @@ class BeamformerTimeTraj(BeamformerTime):
             idtype = int32
         w = self._get_weights()
         c = self.steer.env.c / self.source.sample_freq
-        numMics = self.steer.mics.num_mics
-        mpos = self.steer.mics.mpos.astype(fdtype)
-        m_index = arange(numMics, dtype=idtype)
+        num_mics = self.steer.mics.num_mics
+        mpos = self.steer.mics.pos.astype(fdtype)
+        m_index = arange(num_mics, dtype=idtype)
         n_index = arange(num, dtype=idtype)[:, newaxis]
-        blockrm = empty((num, self.grid.size, numMics), dtype=fdtype)
-        blockrmconv = empty((num, self.grid.size, numMics), dtype=fdtype)
-        amp = empty((num, self.grid.size, numMics), dtype=fdtype)
-        # delays = empty((num,self.grid.size,numMics),dtype=fdtype)
-        d_index = empty((num, self.grid.size, numMics), dtype=idtype)
-        d_interp2 = empty((num, self.grid.size, numMics), dtype=fdtype)
-        blockr0 = empty((num, self.grid.size), dtype=fdtype)
-        self.buffer = zeros((2 * num, numMics), dtype=fdtype)
-        self.bufferIndex = self.buffer.shape[0]
-        movgpos = self.get_moving_gpos()  # create moving grid pos generator
+        blockrm = empty((num, self.steer.grid.size, num_mics), dtype=fdtype)
+        blockrmconv = empty((num, self.steer.grid.size, num_mics), dtype=fdtype)
+        amp = empty((num, self.steer.grid.size, num_mics), dtype=fdtype)
+        # delays = empty((num,self.steer.grid.size,num_mics),dtype=fdtype)
+        d_index = empty((num, self.steer.grid.size, num_mics), dtype=idtype)
+        d_interp2 = empty((num, self.steer.grid.size, num_mics), dtype=fdtype)
+        blockr0 = empty((num, self.steer.grid.size), dtype=fdtype)
+        movgpos = self._get_moving_gpos()  # create moving grid pos generator
         movgspeed = self.trajectory.traj(0.0, delta_t=1 / self.source.sample_freq, der=1)
-        fill_buffer_generator = self._fill_buffer(num)
-        for _i in range(2):
-            next(fill_buffer_generator)
+        weights = self._get_weights()
 
         # preliminary implementation of different steering vectors
-        steer_func = {
-            'classic': _steer_I,
-            'inverse': _steer_II,
-            'true level': _steer_III,
-            'true location': _steer_IV,
-        }[self.steer.steer_type]
+        steer_func = self.steer._steer_funcs_time[self.steer.steer_type]
 
         # start processing
         flag = True
-        dflag = True  # data is available
+        buffer = SamplesBuffer(source=self.source, length=num * 2, shift_index_by='num', dtype=fdtype)
+        buffered_result = buffer.result(num)
         while flag:
             for i in range(num):
                 tpos = next(movgpos).astype(fdtype)
@@ -515,30 +412,27 @@ class BeamformerTimeTraj(BeamformerTime):
                 blockrm[i, :, :] = rm
                 if self.conv_amp:
                     ht = next(movgspeed)
-                    blockrmconv[i, :, :] = rm * (1 - self.get_macostheta(ht, tpos, rm)) ** 2
+                    blockrmconv[i, :, :] = rm * (1 - self._get_macostheta(ht, tpos, rm)) ** 2
             if self.conv_amp:
                 steer_func(blockrmconv, blockr0, amp)
             else:
                 steer_func(blockrm, blockr0, amp)
             _delays(blockrm, c, d_interp2, d_index)
-            # _modf(delays, d_interp2, d_index)
-            maxdelay = (d_index.max((1, 2)) + arange(0, num)).max() + 2  # + because of interpolation
-            # increase buffer size because of greater delays
-            while maxdelay > self.buffer.shape[0] and dflag:
-                self.increase_buffer(num)
-                try:
-                    next(fill_buffer_generator)
-                except StopIteration:
-                    dflag = False
-            samplesleft = self.buffer.shape[0] - self.bufferIndex
-            # last block may be shorter
-            if samplesleft - maxdelay <= 0:
-                num = sum((d_index.max((1, 2)) + 1 + arange(0, num)) < samplesleft)
+            max_sample_delay = (d_index.max((1, 2)) + 2).max()  # + because of interpolation
+            buffer.result_num = num + max_sample_delay
+
+            try:
+                time_block = next(buffered_result)
+                time_block *= weights
+            except StopIteration:
+                break
+            if time_block.shape[0] < buffer.result_num:  # last block shorter
+                num = sum((d_index.max((1, 2)) + 1 + arange(0, num)) < time_block.shape[0])
                 n_index = arange(num, dtype=idtype)[:, newaxis]
                 flag = False
             # init step
-            p_res = self.buffer[self.bufferIndex : self.bufferIndex + maxdelay, :].copy()
-            Phi, autopow = self.delay_and_sum(num, p_res, d_interp2, d_index, amp)
+            p_res = time_block.copy()
+            Phi, autopow = self._delay_and_sum(num, p_res, d_interp2, d_index, amp)
             if 'Cleant' not in self.__class__.__name__:
                 if 'Sq' not in self.__class__.__name__:
                     yield Phi[:num]
@@ -570,14 +464,14 @@ class BeamformerTimeTraj(BeamformerTime):
                     ind_min = t_float.min(0).astype(idtype)
                     # store time history at max power focus point
                     h = Phi[:num, imax] * blockr0[:num, imax]
-                    for m in range(numMics):
+                    for m in range(num_mics):
                         # subtract interpolated time history from microphone signals
                         p_res[ind_min[m] : ind_max[m], m] -= self.damp * interp(
                             t_ind[ind_min[m] : ind_max[m]],
                             t_float[:num, m],
                             h / blockrm1[:num, imax, m],
                         )
-                    nextPhi, nextAutopow = self.delay_and_sum(num, p_res, d_interp2, d_index, amp)
+                    nextPhi, nextAutopow = self._delay_and_sum(num, p_res, d_interp2, d_index, amp)
                     if self.r_diag:
                         pownextPhi = (nextPhi[:num] * nextPhi[:num] - nextAutopow).sum(0).clip(min=0)
                     else:
@@ -598,17 +492,12 @@ class BeamformerTimeTraj(BeamformerTime):
                     yield Gamma[:num] ** 2 - (self.damp**2) * Gamma_autopow[:num]
                 else:
                     yield Gamma[:num] ** 2
-            self.bufferIndex += num
-            try:
-                next(fill_buffer_generator)
-            except StopIteration:
-                dflag = False
 
-    def delay_and_sum(self, num, p_res, d_interp2, d_index, amp):
+    def _delay_and_sum(self, num, p_res, d_interp2, d_index, amp):
         """Standard delay-and-sum method."""
         fdtype = float64 if self.precision == 64 else float32
-        result = empty((num, self.grid.size), dtype=fdtype)  # output array
-        autopow = empty((num, self.grid.size), dtype=fdtype)  # output array
+        result = empty((num, self.steer.grid.size), dtype=fdtype)  # output array
+        autopow = empty((num, self.steer.grid.size), dtype=fdtype)  # output array
         _delayandsum5(p_res, d_index, d_interp2, amp, result, autopow)
         return result, autopow
 
@@ -622,7 +511,7 @@ class BeamformerTimeSqTraj(BeamformerTimeSq, BeamformerTimeTraj):
     # internal identifier
     digest = Property(
         depends_on=[
-            '_steer_obj.digest',
+            'steer.digest',
             'source.digest',
             'r_diag',
             'weights',
@@ -630,7 +519,6 @@ class BeamformerTimeSqTraj(BeamformerTimeSq, BeamformerTimeTraj):
             'rvec',
             'conv_amp',
             'trajectory.digest',
-            '__class__',
         ],
     )
 
@@ -638,12 +526,34 @@ class BeamformerTimeSqTraj(BeamformerTimeSq, BeamformerTimeTraj):
     def _get_digest(self):
         return digest(self)
 
+    def result(self, num=2048):
+        """Python generator that yields the **squared** time-domain beamformer output.
+
+        The squared output time signal starts for source signals that were emitted from
+        the :class:`~acoular.grids.Grid` at `t=0`.
+
+        Parameters
+        ----------
+        num : int
+            This parameter defines the size of the blocks to be yielded
+            (i.e. the number of samples per block). Defaults to 2048.
+
+        Yields
+        ------
+        numpy.ndarray
+            Samples in blocks of shape (num, :attr:`~BeamformerTime.num_channels`).
+                :attr:`~BeamformerTime.num_channels` is usually very \
+                large (number of grid points).
+                The last block returned by the generator may be shorter than num.
+        """
+        return super().result(num)
+
 
 class BeamformerCleant(BeamformerTime):
-    """CLEANT deconvolution method, see :ref:`Cousson et al., 2019<Cousson2019>`.
+    """CLEANT deconvolution method.
 
     An implementation of the CLEAN method in time domain. This class can only
-    be used for static sources.
+    be used for static sources. See :cite:`Cousson2019` for details.
     """
 
     #: Boolean flag, always False
@@ -658,20 +568,42 @@ class BeamformerCleant(BeamformerTime):
 
     # internal identifier
     digest = Property(
-        depends_on=['_steer_obj.digest', 'source.digest', 'weights', '__class__', 'damp', 'n_iter'],
+        depends_on=['steer.digest', 'source.digest', 'weights', 'damp', 'n_iter'],
     )
 
     @cached_property
     def _get_digest(self):
         return digest(self)
 
+    def result(self, num=2048):
+        """Python generator that yields the deconvolved time-domain beamformer output.
+
+        The output starts for signals that were emitted from the :class:`~acoular.grids.Grid` at
+        `t=0`.
+
+        Parameters
+        ----------
+        num : int
+            This parameter defines the size of the blocks to be yielded
+            (i.e. the number of samples per block). Defaults to 2048.
+
+        Yields
+        ------
+        numpy.ndarray
+            Samples in blocks of shape (num, :attr:`~BeamformerTime.num_channels`).
+                :attr:`~BeamformerTime.num_channels` is usually very \
+                large (number of grid points).
+                The last block returned by the generator may be shorter than num.
+        """
+        return super().result(num)
+
 
 class BeamformerCleantSq(BeamformerCleant):
-    """CLEANT deconvolution method, see :ref:`Cousson et al., 2019<Cousson2019>`
-    with optional removal of autocorrelation.
+    """CLEANT deconvolution method with optional removal of autocorrelation.
 
     An implementation of the CLEAN method in time domain. This class can only
-    be used for static sources.
+    be used for static sources. See :cite:`Cousson2019` for details on the method
+    and :cite:`Kujawski2020` for details on the autocorrelation removal.
     """
 
     #: Boolean flag, if 'True' (default), the main diagonal is removed before beamforming.
@@ -679,32 +611,54 @@ class BeamformerCleantSq(BeamformerCleant):
 
     # internal identifier
     digest = Property(
-        depends_on=['_steer_obj.digest', 'source.digest', 'weights', '__class__', 'damp', 'n_iter', 'r_diag'],
+        depends_on=['steer.digest', 'source.digest', 'weights', 'damp', 'n_iter', 'r_diag'],
     )
 
     @cached_property
     def _get_digest(self):
         return digest(self)
 
+    def result(self, num=2048):
+        """Python generator that yields the *squared* deconvolved time-domain beamformer output.
+
+        The output starts for signals that were emitted from the :class:`~acoular.grids.Grid` at
+        `t=0`. Per default, block-wise removal of autocorrelation is performed, which can be turned
+        of by setting :attr:`r_diag` to `False`.
+
+        Parameters
+        ----------
+        num : int
+            This parameter defines the size of the blocks to be yielded
+            (i.e. the number of samples per block). Defaults to 2048.
+
+        Yields
+        ------
+        numpy.ndarray
+            Samples in blocks of shape (num, :attr:`~BeamformerTime.num_channels`).
+                :attr:`~BeamformerTime.num_channels` is usually very \
+                large (number of grid points).
+                The last block returned by the generator may be shorter than num.
+        """
+        return super().result(num)
+
 
 class BeamformerCleantTraj(BeamformerCleant, BeamformerTimeTraj):
-    """CLEANT deconvolution method, see :ref:`Cousson et al., 2019<Cousson2019>`.
+    """CLEANT deconvolution method.
 
     An implementation of the CLEAN method in time domain for moving sources
-    with known trajectory.
+    with known trajectory. See :cite:`Cousson2019` for details.
     """
 
     #: Floating point and integer precision
-    precision = Trait(32, [32, 64], desc='numeric precision')
+    precision = Enum(32, 64, desc='numeric precision')
 
     # internal identifier
     digest = Property(
         depends_on=[
-            '_steer_obj.digest',
+            'steer.digest',
             'source.digest',
             'weights',
             'precision',
-            '__class__',
             'damp',
             'n_iter',
             'rvec',
@@ -717,13 +671,35 @@ class BeamformerCleantTraj(BeamformerCleant, BeamformerTimeTraj):
     def _get_digest(self):
         return digest(self)
 
+    def result(self, num=2048):
+        """Python generator that yields the deconvolved time-domain beamformer output.
+
+        The output starts for signals that were emitted from the :class:`~acoular.grids.Grid` at
+        `t=0`.
+
+        Parameters
+        ----------
+        num : int
+            This parameter defines the size of the blocks to be yielded
+            (i.e. the number of samples per block). Defaults to 2048.
+
+        Yields
+        ------
+        numpy.ndarray
+            Samples in blocks of shape (num, :attr:`~BeamformerTime.num_channels`).
+                :attr:`~BeamformerTime.num_channels` is usually very \
+                large (number of grid points).
+                The last block returned by the generator may be shorter than num.
+        """
+        return super().result(num)
+
 
 class BeamformerCleantSqTraj(BeamformerCleantTraj, BeamformerTimeSq):
-    """CLEANT deconvolution method, see :ref:`Cousson et al., 2019<Cousson2019>`
-    with optional removal of autocorrelation.
+    """CLEANT deconvolution method with optional removal of autocorrelation.
 
     An implementation of the CLEAN method in time domain for moving sources
-    with known trajectory.
+    with known trajectory. See :cite:`Cousson2019` for details on the method and
+    :cite:`Kujawski2020` for details on the autocorrelation removal.
     """
 
     #: Boolean flag, if 'True' (default), the main diagonal is removed before beamforming.
@@ -732,11 +708,10 @@ class BeamformerCleantSqTraj(BeamformerCleantTraj, BeamformerTimeSq):
     # internal identifier
     digest = Property(
         depends_on=[
-            '_steer_obj.digest',
+            'steer.digest',
             'source.digest',
             'weights',
             'precision',
-            '__class__',
             'damp',
             'n_iter',
             'rvec',
@@ -750,25 +725,51 @@ class BeamformerCleantSqTraj(BeamformerCleantTraj, BeamformerTimeSq):
     def _get_digest(self):
         return digest(self)
 
+    def result(self, num=2048):
+        """Python generator that yields the *squared* deconvolved time-domain beamformer output.
+
+        The output starts for signals that were emitted from the :class:`~acoular.grids.Grid` at
+        `t=0`. Per default, block-wise removal of autocorrelation is performed, which can be turned
+        of by setting :attr:`r_diag` to `False`.
+
+        Parameters
+        ----------
+        num : int
+            This parameter defines the size of the blocks to be yielded
+            (i.e. the number of samples per block). Defaults to 2048.
+
+        Yields
+        ------
+        numpy.ndarray
+            Samples in blocks of shape (num, :attr:`~BeamformerTime.num_channels`).
+                :attr:`~BeamformerTime.num_channels` is usually very \
+                large (number of grid points).
+                The last block returned by the generator may be shorter than num.
+        """
+        return super().result(num)
+
 
-class IntegratorSectorTime(TimeInOut):
+class IntegratorSectorTime(TimeOut):
     """Provides an Integrator in the time domain."""
 
+    #: Data source; :class:`~acoular.base.SamplesGenerator` or derived object.
+    source = Instance(SamplesGenerator)
+
     #: :class:`~acoular.grids.RectGrid` object that provides the grid locations.
-    grid = Trait(RectGrid, desc='beamforming grid')
+    grid = Instance(RectGrid, desc='beamforming grid')
 
     #: List of sectors in grid
     sectors = List()
 
-    #: Clipping, in Dezibel relative to maximum (negative values)
+    #: Clipping, in Decibel relative to maximum (negative values)
     clip = Float(-350.0)
 
     #: Number of channels in output (= number of sectors).
-    numchannels = Property(depends_on=['sectors'])
+    num_channels = Property(depends_on=['sectors'])
 
     # internal identifier
     digest = Property(
-        depends_on=['sectors', 'clip', 'grid.digest', 'source.digest', '__class__'],
+        depends_on=['sectors', 'clip', 'grid.digest', 'source.digest'],
     )
 
     @cached_property
@@ -776,7 +777,7 @@ class IntegratorSectorTime(TimeInOut):
         return digest(self)
 
     @cached_property
-    def _get_numchannels(self):
+    def _get_num_channels(self):
         return len(self.sectors)
 
     def result(self, num=1):
@@ -791,14 +792,13 @@ class IntegratorSectorTime(TimeInOut):
 
         Returns
         -------
-        Samples in blocks of shape (num, :attr:`numchannels`).
-        :attr:`numchannels` is the number of sectors.
+        Samples in blocks of shape (num, :attr:`num_channels`).
+        :attr:`num_channels` is the number of sectors.
         The last block may be shorter than num.
-
         """
         inds = [self.grid.indices(*sector) for sector in self.sectors]
         gshape = self.grid.shape
-        o = empty((num, self.numchannels), dtype=float)  # output array
+        o = empty((num, self.num_channels), dtype=float)  # output array
         for r in self.source.result(num):
             ns = r.shape[0]
             mapshape = (ns,) + gshape