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

acoular/sources.py

@@ -4,6 +4,12 @@
 """
 Measured multichannel data management and simulation of acoustic sources.
 
+.. inheritance-diagram::
+                acoular.sources
+    :top-classes:
+                acoular.base.SamplesGenerator
+    :parts: 1
+
 .. autosummary::
     :toctree: generated/
 
@@ -31,31 +37,9 @@ from os import path
 from warnings import warn
 
 import numba as nb
-from numpy import any as npany
-from numpy import (
-    arange,
-    arctan2,
-    array,
-    ceil,
-    complex128,
-    cross,
-    dot,
-    empty,
-    int64,
-    mod,
-    newaxis,
-    ones,
-    pi,
-    real,
-    repeat,
-    sqrt,
-    tile,
-    uint32,
-    zeros,
-)
-from numpy import min as npmin
+import numpy as np
+import scipy.linalg as spla
 from numpy.fft import fft, ifft
-from scipy.linalg import norm
 from scipy.special import sph_harm, spherical_jn, spherical_yn
 from traits.api import (
     Any,
@@ -76,14 +60,11 @@ from traits.api import (
     Union,
     cached_property,
     observe,
-    on_trait_change,
 )
 
 from .base import SamplesGenerator
 
 # acoular imports
-from .calib import Calib
-from .deprecation import deprecated_alias
 from .environments import Environment
 from .h5files import H5FileBase, _get_h5file_class
 from .internal import digest, ldigest
@@ -109,7 +90,6 @@ def _fill_mic_signal_block(out, signal, rm, ind, blocksize, num_channels, up, pr
             for m in range(num_channels):
                 out[b, m] = signal[int(0.5 + ind[0, m])] / rm[0, m]
             ind += up
-    return out
 
 
 def spherical_hn1(n, z):
@@ -201,7 +181,7 @@ def get_radiation_angles(direction, mpos, sourceposition):
     --------
     :func:`numpy.linalg.norm` :
         Computes the norm of a vector.
-    :func:`numpy.arctan2` :
+    :obj:`numpy.arctan2` :
         Computes the arctangent of two variables, preserving quadrant information.
 
     Notes
@@ -227,21 +207,21 @@ def get_radiation_angles(direction, mpos, sourceposition):
     array([4.71238898, 4.71238898])
     """
     # direction of the Spherical Harmonics
-    direc = array(direction, dtype=float)
-    direc = direc / norm(direc)
+    direc = np.array(direction, dtype=float)
+    direc = direc / spla.norm(direc)
     # distances
-    source_to_mic_vecs = mpos - array(sourceposition).reshape((3, 1))
+    source_to_mic_vecs = mpos - np.array(sourceposition).reshape((3, 1))
     source_to_mic_vecs[2] *= -1  # invert z-axis (acoular)    #-1
     # z-axis (acoular) -> y-axis (spherical)
     # y-axis (acoular) -> z-axis (spherical)
     # theta
-    ele = arctan2(sqrt(source_to_mic_vecs[0] ** 2 + source_to_mic_vecs[2] ** 2), source_to_mic_vecs[1])
-    ele += arctan2(sqrt(direc[0] ** 2 + direc[2] ** 2), direc[1])
-    ele += pi * 0.5  # convert from [-pi/2, pi/2] to [0,pi] range
+    ele = np.arctan2(np.sqrt(source_to_mic_vecs[0] ** 2 + source_to_mic_vecs[2] ** 2), source_to_mic_vecs[1])
+    ele += np.arctan2(np.sqrt(direc[0] ** 2 + direc[2] ** 2), direc[1])
+    ele += np.pi * 0.5  # convert from [-pi/2, pi/2] to [0,pi] range
     # phi
-    azi = arctan2(source_to_mic_vecs[2], source_to_mic_vecs[0])
-    azi += arctan2(direc[2], direc[0])
-    azi = mod(azi, 2 * pi)
+    azi = np.arctan2(source_to_mic_vecs[2], source_to_mic_vecs[0])
+    azi += np.arctan2(direc[2], direc[0])
+    azi = np.mod(azi, 2 * np.pi)
     return azi, ele
 
 
@@ -304,9 +284,9 @@ def get_modes(lOrder, direction, mpos, sourceposition=None):  # noqa: N803
     >>> modes.shape
     (2, 9)
     """
-    sourceposition = sourceposition if sourceposition is not None else array([0, 0, 0])
+    sourceposition = sourceposition if sourceposition is not None else np.array([0, 0, 0])
     azi, ele = get_radiation_angles(direction, mpos, sourceposition)  # angles between source and mics
-    modes = zeros((azi.shape[0], (lOrder + 1) ** 2), dtype=complex128)
+    modes = np.zeros((azi.shape[0], (lOrder + 1) ** 2), dtype=np.complex128)
     i = 0
     for lidx in range(lOrder + 1):
         for m in range(-lidx, lidx + 1):
@@ -317,7 +297,6 @@ def get_modes(lOrder, direction, mpos, sourceposition=None):  # noqa: N803
     return modes
 
 
-@deprecated_alias({'name': 'file'})
 class TimeSamples(SamplesGenerator):
     """
     Container for processing time data in ``*.h5`` or NumPy array format.
@@ -329,13 +308,12 @@ class TimeSamples(SamplesGenerator):
 
     See Also
     --------
-    :class:`acoular.sources.MaskedTimeSamples` :
+    :class:`~acoular.sources.MaskedTimeSamples` :
         Extends the functionality of class :class:`TimeSamples` by enabling the definition of start
         and stop samples as well as the specification of invalid channels.
 
     Notes
     -----
-    - If a calibration object is provided, calibrated time-domain data will be returned.
     - Metadata from the :attr:`HDF5 file<file>` can be accessed through the :attr:`metadata`
       attribute.
 
@@ -374,10 +352,6 @@ class TimeSamples(SamplesGenerator):
     #: Basename of the ``.h5`` file, set automatically from the :attr:`file` attribute.
     basename = Property(depends_on=['file'], desc='basename of data file')
 
-    #: Calibration data, an instance of the :class:`~acoular.calib.Calib` class.
-    #: (optional; if provided, the time data will be calibrated.)
-    calib = Instance(Calib, desc='Calibration data')
-
     #: Number of input channels in the time data, set automatically based on the
     #: :attr:`loaded data<file>` or :attr:`specified array<data>`.
     num_channels = CInt(0, desc='number of input channels')
@@ -397,12 +371,10 @@ class TimeSamples(SamplesGenerator):
     metadata = Dict(desc='metadata contained in .h5 file')
 
     # Checksum over first data entries of all channels
-    _datachecksum = Property()
+    _datachecksum = Property(depends_on=['data'])
 
     #: A unique identifier for the samples, based on its properties. (read-only)
-    digest = Property(
-        depends_on=['basename', 'calib.digest', '_datachecksum', 'sample_freq', 'num_channels', 'num_samples']
-    )
+    digest = Property(depends_on=['basename', '_datachecksum', 'sample_freq', 'num_channels', 'num_samples'])
 
     def _get__datachecksum(self):
         return self.data[0, :].sum()
@@ -415,8 +387,8 @@ class TimeSamples(SamplesGenerator):
     def _get_basename(self):
         return get_file_basename(self.file)
 
-    @on_trait_change('basename')
-    def _load_data(self):
+    @observe('basename')
+    def _load_data(self, event):  # noqa ARG002
         # Open the .h5 file and set attributes.
         if self.h5f is not None:
             with contextlib.suppress(OSError):
@@ -426,8 +398,8 @@ class TimeSamples(SamplesGenerator):
         self._load_timedata()
         self._load_metadata()
 
-    @on_trait_change('data')
-    def _load_shapes(self):
+    @observe('data')
+    def _load_shapes(self, event):  # noqa ARG002
         # Set :attr:`num_channels` and :attr:`num_samples` from data.
         if self.data is not None:
             self.num_samples, self.num_channels = self.data.shape
@@ -449,8 +421,7 @@ class TimeSamples(SamplesGenerator):
 
         The :meth:`result` method is a Python generator that yields blocks of time-domain data
         of the specified size. Data is either read from an HDF5 file (if :attr:`file` is set)
-        or from a NumPy array (if :attr:`data` is directly provided). If a calibration object
-        is specified, the returned data is calibrated.
+        or from a NumPy array (if :attr:`data` is directly provided).
 
         Parameters
         ----------
@@ -469,14 +440,6 @@ class TimeSamples(SamplesGenerator):
         ------
         :obj:`OSError`
             If no samples are available (i.e., :attr:`num_samples` is ``0``).
-        :obj:`ValueError`
-            If the calibration data does not match the number of channels.
-
-        Warnings
-        --------
-        A deprecation warning is raised if the calibration functionality is used directly in
-        :class:`TimeSamples`. Instead, the :class:`~acoular.calib.Calib` class should be used as a
-        separate processing block.
 
         Examples
         --------
@@ -500,36 +463,11 @@ class TimeSamples(SamplesGenerator):
             raise OSError(msg)
         self._datachecksum  # trigger checksum calculation # noqa: B018
         i = 0
-        if self.calib:
-            warn(
-                'The use of the calibration functionality in TimeSamples is deprecated and will be removed in \
-                       Acoular 25.10. Use the Calib class as an additional processing block instead.',
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            if self.calib.num_mics == self.num_channels:
-                cal_factor = self.calib.data[newaxis]
-            else:
-                msg = f'calibration data not compatible: {self.calib.num_mics:d}, {self.num_channels:d}'
-                raise ValueError(msg)
-            while i < self.num_samples:
-                yield self.data[i : i + num] * cal_factor
-                i += num
-        else:
-            while i < self.num_samples:
-                yield self.data[i : i + num]
-                i += num
-
-
-@deprecated_alias(
-    {
-        'numchannels_total': 'num_channels_total',
-        'numsamples_total': 'num_samples_total',
-        'numchannels': 'num_channels',
-        'numsamples': 'num_samples',
-    },
-    read_only=['numchannels', 'numsamples'],
-)
+        while i < self.num_samples:
+            yield self.data[i : num + i]
+            i += num
+
+
 class MaskedTimeSamples(TimeSamples):
     """
     Container to process and manage time-domain data with support for masking samples and channels.
@@ -542,7 +480,7 @@ class MaskedTimeSamples(TimeSamples):
 
     See Also
     --------
-    :class:`acoular.sources.TimeSamples` : The parent class for managing unmasked time-domain data.
+    :class:`~acoular.sources.TimeSamples` : The parent class for managing unmasked time-domain data.
 
     Notes
     -----
@@ -609,7 +547,7 @@ class MaskedTimeSamples(TimeSamples):
     )
 
     #: A unique identifier for the samples, based on its properties. (read-only)
-    digest = Property(depends_on=['basename', 'start', 'stop', 'calib.digest', 'invalid_channels', '_datachecksum'])
+    digest = Property(depends_on=['basename', 'start', 'stop', 'invalid_channels', '_datachecksum'])
 
     @cached_property
     def _get_digest(self):
@@ -620,7 +558,7 @@ class MaskedTimeSamples(TimeSamples):
         if len(self.invalid_channels) == 0:
             return slice(0, None, None)
         allr = [i for i in range(self.num_channels_total) if i not in self.invalid_channels]
-        return array(allr)
+        return np.array(allr)
 
     @cached_property
     def _get_num_channels(self):
@@ -633,8 +571,8 @@ class MaskedTimeSamples(TimeSamples):
         sli = slice(self.start, self.stop).indices(self.num_samples_total)
         return sli[1] - sli[0]
 
-    @on_trait_change('basename')
-    def _load_data(self):
+    @observe('basename')
+    def _load_data(self, event):  # noqa ARG002
         # Open the .h5 file and set attributes.
         if not path.isfile(self.file):
             # no file there
@@ -649,8 +587,8 @@ class MaskedTimeSamples(TimeSamples):
         self._load_timedata()
         self._load_metadata()
 
-    @on_trait_change('data')
-    def _load_shapes(self):
+    @observe('data')
+    def _load_shapes(self, event):  # noqa ARG002
         # Set :attr:`num_channels` and num_samples from :attr:`~acoular.sources.TimeSamples.data`.
         if self.data is not None:
             self.num_samples_total, self.num_channels_total = self.data.shape
@@ -666,8 +604,7 @@ class MaskedTimeSamples(TimeSamples):
         Generate blocks of valid time-domain data iteratively.
 
         The :meth:`result` method is a Python generator that yields blocks of valid time-domain data
-        based on the specified :attr:`start` and :attr:`stop` indices and the valid channels. Data
-        can be calibrated if a calibration object, given by :attr:`calib`, is provided.
+        based on the specified :attr:`start` and :attr:`stop` indices and the valid channels.
 
         Parameters
         ----------
@@ -687,15 +624,6 @@ class MaskedTimeSamples(TimeSamples):
         :obj:`OSError`
             If no valid samples are available (i.e., :attr:`start` and :attr:`stop` indices result
             in an empty range).
-        :obj:`ValueError`
-            If the :attr:`calibration data<calib>` is incompatible with the
-            :attr:`number of valid channels<num_channels>`.
-
-        Warnings
-        --------
-        A deprecation warning is raised if the calibration functionality is used directly in
-        :class:`MaskedTimeSamples`. Instead, the :class:`acoular.calib.Calib` class should be used
-        as a separate processing block.
 
         Examples
         --------
@@ -720,33 +648,15 @@ class MaskedTimeSamples(TimeSamples):
         sli = slice(self.start, self.stop).indices(self.num_samples_total)
         i = sli[0]
         stop = sli[1]
-        cal_factor = 1.0
         if i >= stop:
             msg = 'no samples available'
             raise OSError(msg)
         self._datachecksum  # trigger checksum calculation # noqa: B018
-        if self.calib:
-            warn(
-                'The use of the calibration functionality in MaskedTimeSamples is deprecated and will be removed in \
-                       Acoular 25.10. Use the Calib class as an additional processing block instead.',
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            if self.calib.num_mics == self.num_channels_total:
-                cal_factor = self.calib.data[self.channels][newaxis]
-            elif self.calib.num_mics == self.num_channels:
-                cal_factor = self.calib.data[newaxis]
-            elif self.calib.num_mics == 0:
-                warn('No calibration data used.', Warning, stacklevel=2)
-            else:
-                msg = f'calibration data not compatible: {self.calib.num_mics:d}, {self.num_channels:d}'
-                raise ValueError(msg)
         while i < stop:
-            yield self.data[i : min(i + num, stop)][:, self.channels] * cal_factor
+            yield self.data[i : min(i + num, stop)][:, self.channels]
             i += num
 
 
-@deprecated_alias({'numchannels': 'num_channels', 'numsamples': 'num_samples'}, read_only=True)
 class PointSource(SamplesGenerator):
     """
     Define a fixed point source emitting a signal, intended for simulations.
@@ -758,9 +668,9 @@ class PointSource(SamplesGenerator):
 
     See Also
     --------
-    :class:`acoular.signals.SignalGenerator` : For defining custom emitted signals.
-    :class:`acoular.microphones.MicGeom` : For specifying microphone geometries.
-    :class:`acoular.environments.Environment` : For modeling sound propagation effects.
+    :class:`~acoular.signals.SignalGenerator` : For defining custom emitted signals.
+    :class:`~acoular.microphones.MicGeom` : For specifying microphone geometries.
+    :class:`~acoular.environments.Environment` : For modeling sound propagation effects.
 
     Notes
     -----
@@ -825,8 +735,8 @@ class PointSource(SamplesGenerator):
     mics = Instance(MicGeom, desc='microphone geometry')
 
     def _validate_locations(self):
-        dist = self.env._r(array(self.loc).reshape((3, 1)), self.mics.pos)
-        if npany(dist < 1e-7):
+        dist = self.env._r(np.array(self.loc).reshape((3, 1)), self.mics.pos)
+        if np.any(dist < 1e-7):
             warn('Source and microphone locations are identical.', Warning, stacklevel=2)
 
     #: An :class:`~acoular.environments.Environment` or derived object providing sound propagation
@@ -904,31 +814,32 @@ class PointSource(SamplesGenerator):
             If signal processing or propagation cannot be performed.
         """
         self._validate_locations()
-        N = int(ceil(self.num_samples / num))  # number of output blocks
+        num_samples_estimate = self.num_samples + (self.start_t - self.start) * self.sample_freq
+        N = int(np.ceil(num_samples_estimate / num))  # number of output blocks
         signal = self.signal.usignal(self.up)
-        out = empty((num, self.num_channels))
+        out = np.empty((num, self.num_channels))
         # distances
-        rm = self.env._r(array(self.loc).reshape((3, 1)), self.mics.pos).reshape(1, -1)
+        rm = self.env._r(np.array(self.loc).reshape((3, 1)), self.mics.pos).reshape(1, -1)
         # emission time relative to start_t (in samples) for first sample
         ind = (-rm / self.env.c - self.start_t + self.start) * self.sample_freq * self.up
 
         if self.prepadding == 'zeros':
             # number of blocks where signal behaviour is amended
-            pre = -int(npmin(ind[0]) // (self.up * num))
+            pre = -int(np.min(ind[0]) // (self.up * num))
             # amend signal for first blocks
             # if signal stops during prepadding, terminate
             if pre >= N:
                 for _nb in range(N - 1):
-                    out = _fill_mic_signal_block(out, signal, rm, ind, num, self.num_channels, self.up, True)
+                    _fill_mic_signal_block(out, signal, rm, ind, num, self.num_channels, self.up, True)
                     yield out
 
                 blocksize = self.num_samples % num or num
-                out = _fill_mic_signal_block(out, signal, rm, ind, blocksize, self.num_channels, self.up, True)
+                _fill_mic_signal_block(out, signal, rm, ind, blocksize, self.num_channels, self.up, True)
                 yield out[:blocksize]
                 return
             else:
                 for _nb in range(pre):
-                    out = _fill_mic_signal_block(out, signal, rm, ind, num, self.num_channels, self.up, True)
+                    _fill_mic_signal_block(out, signal, rm, ind, num, self.num_channels, self.up, True)
                     yield out
 
         else:
@@ -936,12 +847,12 @@ class PointSource(SamplesGenerator):
 
         # main generator
         for _nb in range(N - pre - 1):
-            out = _fill_mic_signal_block(out, signal, rm, ind, num, self.num_channels, self.up, False)
+            _fill_mic_signal_block(out, signal, rm, ind, num, self.num_channels, self.up, False)
             yield out
 
         # last block of variable size
         blocksize = self.num_samples % num or num
-        out = _fill_mic_signal_block(out, signal, rm, ind, blocksize, self.num_channels, self.up, False)
+        _fill_mic_signal_block(out, signal, rm, ind, blocksize, self.num_channels, self.up, False)
         yield out[:blocksize]
 
 
@@ -1025,9 +936,9 @@ class SphericalHarmonicSource(PointSource):
             lOrder=self.lOrder,
             direction=self.direction,
             mpos=self.mics.pos,
-            sourceposition=array(self.loc),
+            sourceposition=np.array(self.loc),
         )
-        return real(ifft(fft(signals, axis=0) * (Y_lm @ self.alpha), axis=0))
+        return np.real(ifft(fft(signals, axis=0) * (Y_lm @ self.alpha), axis=0))
 
     def result(self, num=128):
         """
@@ -1059,15 +970,15 @@ class SphericalHarmonicSource(PointSource):
 
         signal = self.signal.usignal(self.up)
         # emission time relative to start_t (in samples) for first sample
-        rm = self.env._r(array(self.loc).reshape((3, 1)), self.mics.pos)
-        ind = (-rm / self.env.c - self.start_t + self.start) * self.sample_freq + pi / 30
+        rm = self.env._r(np.array(self.loc).reshape((3, 1)), self.mics.pos)
+        ind = (-rm / self.env.c - self.start_t + self.start) * self.sample_freq + np.pi / 30
         i = 0
         n = self.num_samples
-        out = empty((num, self.num_channels))
+        out = np.empty((num, self.num_channels))
         while n:
             n -= 1
             try:
-                out[i] = signal[array(0.5 + ind * self.up, dtype=int64)] / rm
+                out[i] = signal[np.array(0.5 + ind * self.up, dtype=np.int64)] / rm
                 ind += 1
                 i += 1
                 if i == num:
@@ -1090,8 +1001,8 @@ class MovingPointSource(PointSource):
 
     See Also
     --------
-    :class:`acoular.sources.PointSource` : For modeling stationary point sources.
-    :class:`acoular.trajectory.Trajectory` : For specifying source motion paths.
+    :class:`~acoular.sources.PointSource` : For modeling stationary point sources.
+    :class:`~acoular.trajectory.Trajectory` : For specifying source motion paths.
     """
 
     #: Determines whether convective amplification is considered. When ``True``, the amplitude of
@@ -1126,6 +1037,51 @@ class MovingPointSource(PointSource):
     def _get_digest(self):
         return digest(self)
 
+    def get_moving_direction(self, direction, time=0):
+        """
+        Calculate the moving direction of the source along its trajectory.
+
+        This method computes the updated direction vector for the moving source, considering both
+        translation along the :attr:`~MovingPointSource.trajectory` and rotation defined by the
+        :attr:`reference vector<rvec>`. If the :attr:`reference vector<rvec>` is `(0, 0, 0)`, only
+        translation is applied. Otherwise, the method incorporates rotation into the calculation.
+
+        Parameters
+        ----------
+        direction : :class:`numpy.ndarray`
+            The initial orientation of the source, specified as a three-dimensional array.
+        time : :class:`float`, optional
+            The time at which the :attr:`~MovingPointSource.trajectory` position and velocity are
+            evaluated. Defaults to ``0``.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            The updated direction vector of the moving source after translation and, if applicable,
+            rotation. The output is a three-dimensional array.
+
+        Notes
+        -----
+        - The method computes the translation direction vector based on the
+          :attr:`~MovingPointSource.trajectory`'s velocity at the specified time.
+        - If the :attr:`reference vector<rvec>` is non-zero, the method constructs a rotation matrix
+          to compute the new source direction based on the
+          :attr:`~MovingPointSource.trajectory`'s motion and the :attr:`reference vector<rvec>`.
+        - The rotation matrix ensures that the new orientation adheres to the right-hand rule and
+          remains orthogonal.
+        """
+        trajg1 = np.array(self.trajectory.location(time, der=1))[:, 0][:, np.newaxis]
+        rflag = (self.rvec == 0).all()  # flag translation vs. rotation
+        if rflag:
+            return direction
+        dx = np.array(trajg1.T)  # direction vector (new x-axis)
+        dy = np.cross(self.rvec, dx)  # new y-axis
+        dz = np.cross(dx, dy)  # new z-axis
+        RM = np.array((dx, dy, dz)).T  # rotation matrix
+        RM /= np.sqrt((RM * RM).sum(0))  # column normalized
+        newdir = np.dot(RM, direction)
+        return np.cross(newdir[:, 0].T, self.rvec.T).T
+
     def result(self, num=128):
         """
         Generate the output signal at microphones in blocks, accounting for source motion.
@@ -1164,46 +1120,48 @@ class MovingPointSource(PointSource):
         # from the end of the calculated signal.
 
         signal = self.signal.usignal(self.up)
-        out = empty((num, self.num_channels))
         # shortcuts and initial values
-        m = self.mics
-        t = self.start * ones(m.num_mics)
-        i = 0
+        num_mics = self.num_channels
+        mpos = self.mics.pos[:, :, np.newaxis]
+        t = self.start + np.ones(num_mics)[:, np.newaxis] * np.arange(num) / self.sample_freq
         epslim = 0.1 / self.up / self.sample_freq
         c0 = self.env.c
         tr = self.trajectory
         n = self.num_samples
-        while n:
-            n -= 1
-            eps = ones(m.num_mics)
+        while n > 0:
+            eps = np.ones_like(t)  # init discrepancy in time
             te = t.copy()  # init emission time = receiving time
             j = 0
             # Newton-Rhapson iteration
             while abs(eps).max() > epslim and j < 100:
-                loc = array(tr.location(te))
-                rm = loc - m.pos  # distance vectors to microphones
-                rm = sqrt((rm * rm).sum(0))  # absolute distance
-                loc /= sqrt((loc * loc).sum(0))  # distance unit vector
-                der = array(tr.location(te, der=1))
+                loc = np.array(tr.location(te.flatten())).reshape((3, num_mics, -1))
+                rm = loc - mpos  # distance vectors to microphones
+                rm = np.sqrt((rm * rm).sum(0))  # absolute distance
+                loc /= np.sqrt((loc * loc).sum(0))  # distance unit vector
+                der = np.array(tr.location(te.flatten(), der=1)).reshape((3, num_mics, -1))
                 Mr = (der * loc).sum(0) / c0  # radial Mach number
-                eps = (te + rm / c0 - t) / (1 + Mr)  # discrepancy in time
+                eps[:] = (te + rm / c0 - t) / (1 + Mr)  # discrepancy in time
                 te -= eps
                 j += 1  # iteration count
-            t += 1.0 / self.sample_freq
+            t += num / self.sample_freq
             # emission time relative to start time
             ind = (te - self.start_t + self.start) * self.sample_freq
             if self.conv_amp:
                 rm *= (1 - Mr) ** 2
             try:
-                out[i] = signal[array(0.5 + ind * self.up, dtype=int64)] / rm
-                i += 1
-                if i == num:
-                    yield out
-                    i = 0
-            except IndexError:  # if no more samples available from the source
+                ind = np.array(0.5 + ind * self.up, dtype=np.int64)
+                out = (signal[ind] / rm).T
+                yield out[:n]
+            except IndexError:  # last incomplete frame
+                signal_length = signal.shape[0]
+                # Filter ind to exclude columns containing values greater than signal_length
+                mask = (ind < signal_length).all(axis=0)
+                out = (signal[ind[:, mask]] / rm[:, mask]).T
+                # If out is not empty, yield it
+                if out.size > 0:
+                    yield out[:n]
                 break
-        if i > 0:  # if there are still samples to yield
-            yield out[:i]
+            n -= num
 
 
 class PointSourceDipole(PointSource):
@@ -1218,7 +1176,7 @@ class PointSourceDipole(PointSource):
 
     See Also
     --------
-    :class:`acoular.sources.PointSource` : For modeling stationary point sources.
+    :class:`~acoular.sources.PointSource` : For modeling stationary point sources.
 
     Notes
     -----
@@ -1293,10 +1251,10 @@ class PointSourceDipole(PointSource):
 
         mpos = self.mics.pos
         # position of the dipole as (3,1) vector
-        loc = array(self.loc, dtype=float).reshape((3, 1))
+        loc = np.array(self.loc, dtype=float).reshape((3, 1))
         # direction vector from tuple
-        direc = array(self.direction, dtype=float) * 1e-5
-        direc_mag = sqrt(dot(direc, direc))
+        direc = np.array(self.direction, dtype=float) * 1e-5
+        direc_mag = np.sqrt(np.dot(direc, direc))
 
         # normed direction vector
         direc_n = direc / direc_mag
@@ -1310,7 +1268,7 @@ class PointSourceDipole(PointSource):
         dir2 = (direc_n * dist / 2.0).reshape((3, 1))
 
         signal = self.signal.usignal(self.up)
-        out = empty((num, self.num_channels))
+        out = np.empty((num, self.num_channels))
 
         # distance from dipole center to microphones
         rm = self.env._r(loc, mpos)
@@ -1333,8 +1291,8 @@ class PointSourceDipole(PointSource):
                     rm
                     / dist
                     * (
-                        signal[array(0.5 + ind1 * self.up, dtype=int64)] / rm1
-                        - signal[array(0.5 + ind2 * self.up, dtype=int64)] / rm2
+                        signal[np.array(0.5 + ind1 * self.up, dtype=np.int64)] / rm1
+                        - signal[np.array(0.5 + ind2 * self.up, dtype=np.int64)] / rm2
                     )
                 )
                 ind1 += 1.0
@@ -1347,7 +1305,8 @@ class PointSourceDipole(PointSource):
             except IndexError:
                 break
 
-        yield out[:i]
+        if i > 0:
+            yield out[:i]
 
 
 class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
@@ -1367,8 +1326,8 @@ class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
 
     See Also
     --------
-    :class:`acoular.sources.PointSourceDipole` : For stationary dipole sources.
-    :class:`acoular.sources.MovingPointSource` :
+    :class:`~acoular.sources.PointSourceDipole` : For stationary dipole sources.
+    :class:`~acoular.sources.MovingPointSource` :
         For moving point sources without dipole characteristics.
     """
 
@@ -1389,7 +1348,7 @@ class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
     #: A reference vector, perpendicular to the x and y-axis of moving source, defining the axis of
     #: rotation for the dipole directivity. If set to ``(0, 0, 0)``, the dipole is only translated
     #: along the :attr:`~MovingPointSource.trajectory` without rotation. Default is ``(0, 0, 0)``.
-    rvec = CArray(dtype=float, shape=(3,), value=array((0, 0, 0)), desc='reference vector')
+    rvec = CArray(dtype=float, shape=(3,), value=np.array((0, 0, 0)), desc='reference vector')
 
     @cached_property
     def _get_digest(self):
@@ -1431,70 +1390,25 @@ class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
         terminates when the time discrepancy (``eps``) is below a threshold (``epslim``)
         or after 100 iterations.
         """
-        eps = ones(self.mics.num_mics)
+        eps = np.ones(self.mics.num_mics)
         epslim = 0.1 / self.up / self.sample_freq
         te = t.copy()  # init emission time = receiving time
         j = 0
         # Newton-Rhapson iteration
         while abs(eps).max() > epslim and j < 100:
-            xs = array(self.trajectory.location(te))
+            xs = np.array(self.trajectory.location(te))
             loc = xs.copy()
             loc += direction
             rm = loc - self.mics.pos  # distance vectors to microphones
-            rm = sqrt((rm * rm).sum(0))  # absolute distance
-            loc /= sqrt((loc * loc).sum(0))  # distance unit vector
-            der = array(self.trajectory.location(te, der=1))
+            rm = np.sqrt((rm * rm).sum(0))  # absolute distance
+            loc /= np.sqrt((loc * loc).sum(0))  # distance unit vector
+            der = np.array(self.trajectory.location(te, der=1))
             Mr = (der * loc).sum(0) / self.env.c  # radial Mach number
             eps = (te + rm / self.env.c - t) / (1 + Mr)  # discrepancy in time
             te -= eps
             j += 1  # iteration count
         return te, rm, Mr, xs
 
-    def get_moving_direction(self, direction, time=0):
-        """
-        Calculate the moving direction of the dipole source along its trajectory.
-
-        This method computes the updated direction vector for the dipole source, considering both
-        translation along the trajectory and rotation defined by the :attr:`reference vector<rvec>`.
-        If the reference vector is ``(0, 0, 0)``, only translation is applied. Otherwise, the method
-        incorporates rotation into the calculation.
-
-        Parameters
-        ----------
-        direction : :class:`numpy.ndarray`
-            The initial direction vector of the dipole, specified as a 3-element
-            array representing the orientation of the dipole lobes.
-        time : :class:`float`, optional
-            The time at which the trajectory position and velocity are evaluated. Defaults to ``0``.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            The updated direction vector of the dipole source after translation
-            and, if applicable, rotation. The output is a 3-element array.
-
-        Notes
-        -----
-        - The method computes the translation direction vector based on the trajectory's velocity at
-          the specified time.
-        - If the :attr:`reference vector<rvec>` is non-zero, the method constructs a rotation matrix
-          to compute the new dipole direction based on the trajectory's motion and the
-          reference vector.
-        - The rotation matrix ensures that the new dipole orientation adheres
-          to the right-hand rule and remains orthogonal.
-        """
-        trajg1 = array(self.trajectory.location(time, der=1))[:, 0][:, newaxis]
-        rflag = (self.rvec == 0).all()  # flag translation vs. rotation
-        if rflag:
-            return direction
-        dx = array(trajg1.T)  # direction vector (new x-axis)
-        dy = cross(self.rvec, dx)  # new y-axis
-        dz = cross(dx, dy)  # new z-axis
-        RM = array((dx, dy, dz)).T  # rotation matrix
-        RM /= sqrt((RM * RM).sum(0))  # column normalized
-        newdir = dot(RM, direction)
-        return cross(newdir[:, 0].T, self.rvec.T).T
-
     def result(self, num=128):
         """
         Generate the output signal at microphones in blocks.
@@ -1521,8 +1435,8 @@ class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
         mpos = self.mics.pos
 
         # direction vector from tuple
-        direc = array(self.direction, dtype=float) * 1e-5
-        direc_mag = sqrt(dot(direc, direc))
+        direc = np.array(self.direction, dtype=float) * 1e-5
+        direc_mag = np.sqrt(np.dot(direc, direc))
         # normed direction vector
         direc_n = direc / direc_mag
         c = self.env.c
@@ -1533,10 +1447,10 @@ class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
         dir2 = (direc_n * dist / 2.0).reshape((3, 1))
 
         signal = self.signal.usignal(self.up)
-        out = empty((num, self.num_channels))
+        out = np.empty((num, self.num_channels))
         # shortcuts and initial values
         m = self.mics
-        t = self.start * ones(m.num_mics)
+        t = self.start * np.ones(m.num_mics)
 
         i = 0
         n = self.num_samples
@@ -1545,7 +1459,7 @@ class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
             te, rm, Mr, locs = self.get_emission_time(t, 0)
             t += 1.0 / self.sample_freq
             # location of the center
-            loc = array(self.trajectory.location(te), dtype=float)[:, 0][:, newaxis]
+            loc = np.array(self.trajectory.location(te), dtype=float)[:, 0][:, np.newaxis]
             # distance of the dipoles from the center
             diff = self.get_moving_direction(dir2, te)
 
@@ -1564,8 +1478,8 @@ class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
                     rm
                     / dist
                     * (
-                        signal[array(0.5 + ind * self.up, dtype=int64)] / rm1
-                        - signal[array(0.5 + ind * self.up, dtype=int64)] / rm2
+                        signal[np.array(0.5 + ind * self.up, dtype=np.int64)] / rm1
+                        - signal[np.array(0.5 + ind * self.up, dtype=np.int64)] / rm2
                     )
                 )
                 i += 1
@@ -1574,7 +1488,9 @@ class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
                     i = 0
             except IndexError:
                 break
-        yield out[:i]
+
+        if i > 0:
+            yield out[:i]
 
 
 class LineSource(PointSource):
@@ -1595,7 +1511,7 @@ class LineSource(PointSource):
 
     See Also
     --------
-    :class:`acoular.sources.PointSource` : For modeling stationary point sources.
+    :class:`~acoular.sources.PointSource` : For modeling stationary point sources.
 
     Notes
     -----
@@ -1659,24 +1575,24 @@ class LineSource(PointSource):
         mpos = self.mics.pos
 
         # direction vector from tuple
-        direc = array(self.direction, dtype=float)
+        direc = np.array(self.direction, dtype=float)
         # normed direction vector
-        direc_n = direc / norm(direc)
+        direc_n = direc / spla.norm(direc)
         c = self.env.c
 
         # distance between monopoles in the line
         dist = self.length / self.num_sources
 
         # blocwise output
-        out = zeros((num, self.num_channels))
+        out = np.zeros((num, self.num_channels))
 
         # distance from line start position to microphones
-        loc = array(self.loc, dtype=float).reshape((3, 1))
+        loc = np.array(self.loc, dtype=float).reshape((3, 1))
 
         # distances from monopoles in the line to microphones
-        rms = empty((self.num_channels, self.num_sources))
-        inds = empty((self.num_channels, self.num_sources))
-        signals = empty((self.num_sources, len(self.signal.usignal(self.up))))
+        rms = np.empty((self.num_channels, self.num_sources))
+        inds = np.empty((self.num_channels, self.num_sources))
+        signals = np.empty((self.num_sources, len(self.signal.usignal(self.up))))
         # for every source - distances
         for s in range(self.num_sources):
             rms[:, s] = self.env._r((loc.T + direc_n * dist * s).T, mpos)
@@ -1693,18 +1609,19 @@ class LineSource(PointSource):
             try:
                 for s in range(self.num_sources):
                     # sum sources
-                    out[i] += signals[s, array(0.5 + inds[:, s].T * self.up, dtype=int64)] / rms[:, s]
+                    out[i] += signals[s, np.array(0.5 + inds[:, s].T * self.up, dtype=np.int64)] / rms[:, s]
 
                 inds += 1.0
                 i += 1
                 if i == num:
                     yield out
-                    out = zeros((num, self.num_channels))
+                    out = np.zeros((num, self.num_channels))
                     i = 0
             except IndexError:
                 break
 
-        yield out[:i]
+        if i > 0:
+            yield out[:i]
 
 
 class MovingLineSource(LineSource, MovingPointSource):
@@ -1724,10 +1641,10 @@ class MovingLineSource(LineSource, MovingPointSource):
 
     See Also
     --------
-    :class:`acoular.sources.LineSource` :
+    :class:`~acoular.sources.LineSource` :
         For :class:`line sources<LineSource>` consisting of
         :attr:`coherent or incoherent<LineSource.coherence>` monopoles.
-    :class:`acoular.sources.MovingPointSource` :
+    :class:`~acoular.sources.MovingPointSource` :
         For moving point sources without dipole characteristics.
     """
 
@@ -1749,59 +1666,12 @@ class MovingLineSource(LineSource, MovingPointSource):
     #: rotation for the line source directivity. If set to ``(0, 0, 0)``, the line source is only
     #: translated along the :attr:`~MovingPointSource.trajectory` without rotation. Default is
     #: ``(0, 0, 0)``.
-    rvec = CArray(dtype=float, shape=(3,), value=array((0, 0, 0)), desc='reference vector')
+    rvec = CArray(dtype=float, shape=(3,), value=np.array((0, 0, 0)), desc='reference vector')
 
     @cached_property
     def _get_digest(self):
         return digest(self)
 
-    def get_moving_direction(self, direction, time=0):
-        """
-        Calculate the moving direction of the line source along its trajectory.
-
-        This method computes the updated direction vector for the line source,
-        considering both translation along the :attr:`~MovingPointSource.trajectory` and rotation
-        defined by the :attr:`reference vector<rvec>`. If the :attr:`reference vector<rvec>` is
-        `(0, 0, 0)`, only translation is applied. Otherwise, the method incorporates rotation
-        into the calculation.
-
-        Parameters
-        ----------
-        direction : :class:`numpy.ndarray`
-            The initial direction vector of the line source, specified as a
-            3-element array representing the orientation of the line.
-        time : :class:`float`, optional
-            The time at which the :attr:`~MovingPointSource.trajectory` position and velocity
-            are evaluated. Defaults to ``0``.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            The updated direction vector of the line source after translation and,
-            if applicable, rotation. The output is a 3-element array.
-
-        Notes
-        -----
-        - The method computes the translation direction vector based on the
-          :attr:`~MovingPointSource.trajectory`'s velocity at the specified time.
-        - If the :attr:`reference vector<rvec>` is non-zero, the method constructs a
-          rotation matrix to compute the new line source direction based on the
-          :attr:`~MovingPointSource.trajectory`'s motion and the :attr:`reference vector<rvec>`.
-        - The rotation matrix ensures that the new orientation adheres to the
-          right-hand rule and remains orthogonal.
-        """
-        trajg1 = array(self.trajectory.location(time, der=1))[:, 0][:, newaxis]
-        rflag = (self.rvec == 0).all()  # flag translation vs. rotation
-        if rflag:
-            return direction
-        dx = array(trajg1.T)  # direction vector (new x-axis)
-        dy = cross(self.rvec, dx)  # new y-axis
-        dz = cross(dx, dy)  # new z-axis
-        RM = array((dx, dy, dz)).T  # rotation matrix
-        RM /= sqrt((RM * RM).sum(0))  # column normalized
-        newdir = dot(RM, direction)
-        return cross(newdir[:, 0].T, self.rvec.T).T
-
     def get_emission_time(self, t, direction):
         """
         Calculate the emission time for a moving line source based on its trajectory.
@@ -1844,19 +1714,19 @@ class MovingLineSource(LineSource, MovingPointSource):
         - The method iterates until the difference between the computed emission time and
           the current time is sufficiently small (within a defined threshold).
         """
-        eps = ones(self.mics.num_mics)
+        eps = np.ones(self.mics.num_mics)
         epslim = 0.1 / self.up / self.sample_freq
         te = t.copy()  # init emission time = receiving time
         j = 0
         # Newton-Rhapson iteration
         while abs(eps).max() > epslim and j < 100:
-            xs = array(self.trajectory.location(te))
+            xs = np.array(self.trajectory.location(te))
             loc = xs.copy()
             loc += direction
             rm = loc - self.mics.pos  # distance vectors to microphones
-            rm = sqrt((rm * rm).sum(0))  # absolute distance
-            loc /= sqrt((loc * loc).sum(0))  # distance unit vector
-            der = array(self.trajectory.location(te, der=1))
+            rm = np.sqrt((rm * rm).sum(0))  # absolute distance
+            loc /= np.sqrt((loc * loc).sum(0))  # distance unit vector
+            der = np.array(self.trajectory.location(te, der=1))
             Mr = (der * loc).sum(0) / self.env.c  # radial Mach number
             eps = (te + rm / self.env.c - t) / (1 + Mr)  # discrepancy in time
             te -= eps
@@ -1884,21 +1754,21 @@ class MovingLineSource(LineSource, MovingPointSource):
         mpos = self.mics.pos
 
         # direction vector from tuple
-        direc = array(self.direction, dtype=float)
+        direc = np.array(self.direction, dtype=float)
         # normed direction vector
-        direc_n = direc / norm(direc)
+        direc_n = direc / spla.norm(direc)
 
         # distance between monopoles in the line
         dist = self.length / self.num_sources
         dir2 = (direc_n * dist).reshape((3, 1))
 
         # blocwise output
-        out = zeros((num, self.num_channels))
+        out = np.zeros((num, self.num_channels))
 
         # distances from monopoles in the line to microphones
-        rms = empty((self.num_channels, self.num_sources))
-        inds = empty((self.num_channels, self.num_sources))
-        signals = empty((self.num_sources, len(self.signal.usignal(self.up))))
+        rms = np.empty((self.num_channels, self.num_sources))
+        inds = np.empty((self.num_channels, self.num_sources))
+        signals = np.empty((self.num_sources, len(self.signal.usignal(self.up))))
         # coherence
         for s in range(self.num_sources):
             # new seed for every source
@@ -1910,20 +1780,20 @@ class MovingLineSource(LineSource, MovingPointSource):
 
         # shortcuts and initial values
         m = self.mics
-        t = self.start * ones(m.num_mics)
+        t = self.start * np.ones(m.num_mics)
         i = 0
         n = self.num_samples
         while n:
             n -= 1
             t += 1.0 / self.sample_freq
             te1, rm1, Mr1, locs1 = self.get_emission_time(t, 0)
-            # trajg1 = array(self.trajectory.location( te1, der=1))[:,0][:,newaxis]
+            # trajg1 = np.array(self.trajectory.location( te1, der=1))[:,0][:,np.newaxis]
 
             # get distance and ind for every source in the line
             for s in range(self.num_sources):
                 diff = self.get_moving_direction(dir2, te1)
-                te, rm, Mr, locs = self.get_emission_time(t, tile((diff * s).T, (self.num_channels, 1)).T)
-                loc = array(self.trajectory.location(te), dtype=float)[:, 0][:, newaxis]
+                te, rm, Mr, locs = self.get_emission_time(t, np.tile((diff * s).T, (self.num_channels, 1)).T)
+                loc = np.array(self.trajectory.location(te), dtype=float)[:, 0][:, np.newaxis]
                 diff = self.get_moving_direction(dir2, te)
                 rms[:, s] = self.env._r((loc + diff * s), mpos)
                 inds[:, s] = (te - self.start_t + self.start) * self.sample_freq
@@ -1935,19 +1805,20 @@ class MovingLineSource(LineSource, MovingPointSource):
                 # subtract the second signal b/c of phase inversion
                 for s in range(self.num_sources):
                     # sum sources
-                    out[i] += signals[s, array(0.5 + inds[:, s].T * self.up, dtype=int64)] / rms[:, s]
+                    out[i] += signals[s, np.array(0.5 + inds[:, s].T * self.up, dtype=np.int64)] / rms[:, s]
 
                 i += 1
                 if i == num:
                     yield out
-                    out = zeros((num, self.num_channels))
+                    out = np.zeros((num, self.num_channels))
                     i = 0
             except IndexError:
                 break
-        yield out[:i]
+
+        if i > 0:
+            yield out[:i]
 
 
-@deprecated_alias({'numchannels': 'num_channels'}, read_only=True)
 class UncorrelatedNoiseSource(SamplesGenerator):
     """
     Simulate uncorrelated white or pink noise signals at multiple channels.
@@ -1959,8 +1830,8 @@ class UncorrelatedNoiseSource(SamplesGenerator):
 
     See Also
     --------
-    :class:`acoular.signals.SignalGenerator` : For defining noise types and properties.
-    :class:`acoular.microphones.MicGeom` : For specifying microphone geometries.
+    :class:`~acoular.signals.SignalGenerator` : For defining noise types and properties.
+    :class:`~acoular.microphones.MicGeom` : For specifying microphone geometries.
 
     Notes
     -----
@@ -2008,7 +1879,7 @@ class UncorrelatedNoiseSource(SamplesGenerator):
     #: Array of random seed values for generating uncorrelated noise at each channel. If left empty,
     #: seeds will be automatically generated as ``np.arange(self.num_channels) + signal.seed``. The
     #: size of the array must match the :attr:`number of output channels<num_channels>`.
-    seed = CArray(dtype=uint32, desc='random seed values')
+    seed = CArray(dtype=np.uint32, desc='random seed values')
 
     #: Number of output channels, automatically determined by the number of microphones
     #: defined in the :attr:`mics` attribute. Corresponds to the number of uncorrelated noise
@@ -2086,14 +1957,14 @@ class UncorrelatedNoiseSource(SamplesGenerator):
         Noise = self.signal.__class__
         # create or get the array of random seeds
         if not self.seed.size > 0:
-            seed = arange(self.num_channels) + self.signal.seed
+            seed = np.arange(self.num_channels) + self.signal.seed
         elif self.seed.shape == (self.num_channels,):
             seed = self.seed
         else:
             msg = f'Seed array expected to be of shape ({self.num_channels:d},), but has shape {self.seed.shape}.'
             raise ValueError(msg)
         # create array with [num_channels] noise signal tracks
-        signal = array(
+        signal = np.array(
             [
                 Noise(seed=s, num_samples=self.num_samples, sample_freq=self.sample_freq, rms=self.signal.rms).signal()
                 for s in seed
@@ -2111,7 +1982,6 @@ class UncorrelatedNoiseSource(SamplesGenerator):
                 return
 
 
-@deprecated_alias({'numchannels': 'num_channels', 'numsamples': 'num_samples'}, read_only=True)
 class SourceMixer(SamplesGenerator):
     """
     Combine signals from multiple sources by mixing their outputs.
@@ -2123,7 +1993,7 @@ class SourceMixer(SamplesGenerator):
 
     See Also
     --------
-    :class:`acoular.base.SamplesGenerator` : Base class for signal generators.
+    :class:`~acoular.base.SamplesGenerator` : Base class for signal generators.
 
     Notes
     -----
@@ -2313,7 +2183,7 @@ class SourceMixer(SamplesGenerator):
         gens = [i.result(num) for i in self.sources[1:]]
         weights = self.weights.copy()
         if weights.size == 0:
-            weights = array([1.0 for j in range(len(self.sources))])
+            weights = np.array([1.0 for j in range(len(self.sources))])
         assert weights.shape[0] == len(self.sources)
         for temp in self.sources[0].result(num):
             temp *= weights[0]
@@ -2342,7 +2212,7 @@ class PointSourceConvolve(PointSource):
     See Also
     --------
     :class:`PointSource` : Base class for point sources.
-    :class:`acoular.tprocess.TimeConvolve` : Class used for performing time-domain convolution.
+    :class:`~acoular.tprocess.TimeConvolve` : Class used for performing time-domain convolution.
 
     Notes
     -----
@@ -2441,7 +2311,7 @@ class PointSourceConvolve(PointSource):
         - Convolution is performed using the :class:`~acoular.tprocess.TimeConvolve` class
           to ensure efficiency.
         """
-        data = repeat(self.signal.signal()[:, newaxis], self.mics.num_mics, axis=1)
+        data = np.repeat(self.signal.signal()[:, np.newaxis], self.mics.num_mics, axis=1)
         source = TimeSamples(
             data=data,
             sample_freq=self.sample_freq,