acoular 25.7__py3-none-any.whl → 26.1__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,33 +37,10 @@ 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,
-    ones_like,
-    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 scipy.special import sph_harm_y, spherical_jn, spherical_yn
 from traits.api import (
     Any,
     Bool,
@@ -77,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
@@ -110,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):
@@ -202,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
@@ -228,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
 
 
@@ -279,13 +258,13 @@ def get_modes(lOrder, direction, mpos, sourceposition=None):  # noqa: N803
     --------
     :func:`get_radiation_angles` :
         Computes azimuth and elevation angles between microphones and the source.
-    :obj:`scipy.special.sph_harm` : Computes spherical harmonic values.
+    :obj:`scipy.special.sph_harm_y` : Computes spherical harmonic values.
 
     Notes
     -----
     - The azimuth (``azi``) and elevation (``ele``) angles between the microphones and the source
       are calculated using the :func:`get_radiation_angles` function.
-    - Spherical harmonics (``sph_harm``) are computed for each mode ``(l, m)``, where ``l`` is the
+    - Spherical harmonics (``sph_harm_y``) are computed for each mode ``(l, m)``, where ``l`` is the
       degree (ranging from ``0`` to ``lOrder``) and ``m`` is the order
       (ranging from ``-l`` to ``+l``).
     - For negative orders (`m < 0`), the conjugate of the spherical harmonic is computed and scaled
@@ -305,20 +284,19 @@ 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):
-            modes[:, i] = sph_harm(m, lidx, azi, ele)
+            modes[:, i] = sph_harm_y(m, lidx, ele, azi)
             if m < 0:
                 modes[:, i] = modes[:, i].conj() * 1j
             i += 1
     return modes
 
 
-@deprecated_alias({'name': 'file'}, removal_version='25.10')
 class TimeSamples(SamplesGenerator):
     """
     Container for processing time data in ``*.h5`` or NumPy array format.
@@ -330,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.
 
@@ -370,40 +347,34 @@ class TimeSamples(SamplesGenerator):
     """
 
     #: Full path to the ``.h5`` file containing time-domain data.
-    file = Union(None, File(filter=['*.h5'], exists=True), desc='name of data file')
+    file = Union(None, File(filter=['*.h5'], exists=True))
 
     #: 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')
+    basename = Property(depends_on=['file'])
 
     #: 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')
+    num_channels = CInt(0)
 
     #: Total number of time-domain samples, set automatically based on the :attr:`loaded data<file>`
     #: or :attr:`specified array<data>`.
-    num_samples = CInt(0, desc='number of samples')
+    num_samples = CInt(0)
 
     #: A 2D NumPy array containing the time-domain data, shape (:attr:`num_samples`,
     #: :attr:`num_channels`).
-    data = Any(transient=True, desc='the actual time data array')
+    data = Any(transient=True)
 
     #: HDF5 file object.
     h5f = Instance(H5FileBase, transient=True)
 
     #: Metadata loaded from the HDF5 file, if available.
-    metadata = Dict(desc='metadata contained in .h5 file')
+    metadata = Dict()
 
     # 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()
@@ -416,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):
@@ -427,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
@@ -450,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
         ----------
@@ -470,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
         --------
@@ -501,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.
@@ -543,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
     -----
@@ -579,38 +516,34 @@ class MaskedTimeSamples(TimeSamples):
     """
 
     #: Index of the first sample to be considered valid. Default is ``0``.
-    start = CInt(0, desc='start of valid samples')
+    start = CInt(0)
 
     #: Index of the last sample to be considered valid. If ``None``, all remaining samples from the
     #: :attr:`start` index onward are considered valid. Default is ``None``.
-    stop = Union(None, CInt, desc='stop of valid samples')
+    stop = Union(None, CInt)
 
     #: List of channel indices to be excluded from processing. Default is ``[]``.
-    invalid_channels = List(int, desc='list of invalid channels')
+    invalid_channels = List(int)
 
     #: A mask or index array representing valid channels. Automatically updated based on the
     #: :attr:`invalid_channels` and :attr:`num_channels_total` attributes.
-    channels = Property(depends_on=['invalid_channels', 'num_channels_total'], desc='channel mask')
+    channels = Property(depends_on=['invalid_channels', 'num_channels_total'])
 
     #: Total number of input channels, including invalid channels. (read-only).
-    num_channels_total = CInt(0, desc='total number of input channels')
+    num_channels_total = CInt(0)
 
     #: Total number of samples, including invalid samples. (read-only).
-    num_samples_total = CInt(0, desc='total number of samples per channel')
+    num_samples_total = CInt(0)
 
     #: Number of valid input channels after excluding :attr:`invalid_channels`. (read-only)
-    num_channels = Property(
-        depends_on=['invalid_channels', 'num_channels_total'], desc='number of valid input channels'
-    )
+    num_channels = Property(depends_on=['invalid_channels', 'num_channels_total'])
 
     #: Number of valid time-domain samples, based on :attr:`start` and :attr:`stop` indices.
     #: (read-only)
-    num_samples = Property(
-        depends_on=['start', 'stop', 'num_samples_total'], desc='number of valid samples per channel'
-    )
+    num_samples = Property(depends_on=['start', 'stop', 'num_samples_total'])
 
     #: 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):
@@ -621,7 +554,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):
@@ -634,8 +567,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
@@ -650,8 +583,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
@@ -667,8 +600,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
         ----------
@@ -688,15 +620,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
         --------
@@ -721,33 +644,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, removal_version='25.10')
 class PointSource(SamplesGenerator):
     """
     Define a fixed point source emitting a signal, intended for simulations.
@@ -759,9 +664,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
     -----
@@ -815,19 +720,27 @@ class PointSource(SamplesGenerator):
     #: Instance of the :class:`~acoular.signals.SignalGenerator` class defining the emitted signal.
     signal = Instance(SignalGenerator)
 
-    #: Coordinates ``(x, y, z)`` of the source in a left-oriented system. Default is
-    #: ``(0.0, 0.0, 1.0)``.
-    loc = Tuple((0.0, 0.0, 1.0), desc='source location')
+    #: Coordinates ``(x, y, z)`` of the source. Default is ``np.array([[0.0], [0.0], [1.0]])``.
+    loc = Property(CArray, desc='source location')
+
+    _loc = CArray(shape=(3, 1), value=np.array([[0.0], [0.0], [1.0]]), dtype=float)
+
+    def _get_loc(self):
+        return self._loc
+
+    def _set_loc(self, value):
+        value = np.asarray(value, dtype=float).reshape((3, 1))
+        self._loc = value
 
     #: Number of output channels, automatically set based on the :attr:`microphone geometry<mics>`.
     num_channels = Delegate('mics', 'num_mics')
 
     #: :class:`~acoular.microphones.MicGeom` object defining the positions of the microphones.
-    mics = Instance(MicGeom, desc='microphone geometry')
+    mics = Instance(MicGeom)
 
     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(self.loc, 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
@@ -836,10 +749,10 @@ class PointSource(SamplesGenerator):
     env = Instance(Environment, args=())
 
     #: Start time of the signal in seconds. Default is ``0.0``.
-    start_t = Float(0.0, desc='signal start time')
+    start_t = Float(0.0)
 
     #: Start time of data acquisition at the microphones in seconds. Default is ``0.0``.
-    start = Float(0.0, desc='sample start time')
+    start = Float(0.0)
 
     #: Behavior of the signal for negative time indices,
     #: i.e. if (:attr:`start` ``<`` :attr:`start_t`):
@@ -848,10 +761,10 @@ class PointSource(SamplesGenerator):
     #: - ``'zeros'``: Use zeros, recommended for deterministic signals.
     #:
     #: Default is ``'loop'``.
-    prepadding = Enum('loop', 'zeros', desc='Behaviour for negative time indices.')
+    prepadding = Enum('loop', 'zeros')
 
     #: Internal upsampling factor for finer signal resolution. Default is ``16``.
-    up = Int(16, desc='upsampling factor')
+    up = Int(16)
 
     #: Total number of samples in the emitted signal, derived from the :attr:`signal` generator.
     num_samples = Delegate('signal')
@@ -905,31 +818,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(self.loc, 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:
@@ -937,12 +851,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]
 
 
@@ -959,18 +873,18 @@ class SphericalHarmonicSource(PointSource):
     """
 
     #: Order of the spherical harmonic representation. Default is ``0``.
-    lOrder = Int(0, desc='Order of spherical harmonic')  # noqa: N815
+    lOrder = Int(0)  # noqa: N815
 
     #: Coefficients of the spherical harmonic modes for the given :attr:`lOrder`.
-    alpha = CArray(desc='coefficients of the (lOrder,) spherical harmonic mode')
+    alpha = CArray()
 
     #: Vector defining the orientation of the spherical harmonic source. Default is
     #: ``(1.0, 0.0, 0.0)``.
-    direction = Tuple((1.0, 0.0, 0.0), desc='Spherical Harmonic orientation')
+    direction = Tuple((1.0, 0.0, 0.0))
 
     #: Behavior of the signal for negative time indices. Currently only supports `loop`. Default is
     #: ``'loop'``.
-    prepadding = Enum('loop', desc='Behaviour for negative time indices.')
+    prepadding = Enum('loop')
 
     # Unique identifier for the current state of the source, based on its properties. (read-only)
     digest = Property(
@@ -1026,9 +940,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):
         """
@@ -1060,15 +974,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(self.loc, 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:
@@ -1091,22 +1005,22 @@ 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
     #: the signal is adjusted based on the relative motion between the source and microphones.
     #: Default is ``False``.
-    conv_amp = Bool(False, desc='determines if convective amplification is considered')
+    conv_amp = Bool(False)
 
     #: Instance of the :class:`~acoular.trajectory.Trajectory` class specifying the source's motion.
     #: The trajectory defines the source's position and velocity at any given time.
-    trajectory = Instance(Trajectory, desc='trajectory of the source')
+    trajectory = Instance(Trajectory)
 
     #: Behavior of the signal for negative time indices. Currently only supports ``'loop'``.
     #: Default is ``'loop'``.
-    prepadding = Enum('loop', desc='Behaviour for negative time indices.')
+    prepadding = Enum('loop')
 
     #: A unique identifier for the current state of the source, based on its properties. (read-only)
     digest = Property(
@@ -1127,6 +1041,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.
@@ -1167,25 +1126,25 @@ class MovingPointSource(PointSource):
         signal = self.signal.usignal(self.up)
         # shortcuts and initial values
         num_mics = self.num_channels
-        mpos = self.mics.pos[:, :, newaxis]
-        t = self.start + ones(num_mics)[:, newaxis] * arange(num) / self.sample_freq
+        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 > 0:
-            eps = ones_like(t)  # init discrepancy in time
+            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.flatten())).reshape((3, num_mics, -1))
-                rm = loc - mpos  # 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.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
+                loc = np.array(tr.location(te.flatten())).reshape((3, num_mics, -1))
+                der = np.array(tr.location(te.flatten(), der=1)).reshape((3, num_mics, -1))
+                dv = mpos - loc  # distance vectors from source to microphones
+                rm = np.sqrt((dv * dv).sum(0))  # absolute distance
+                dv /= rm  # just directions from source to microphones
+                Mr = (der * dv).sum(0) / c0  # radial Mach number
+                eps[:] = (te + rm / c0 - t) / (1 - Mr)  # discrepancy in time
                 te -= eps
                 j += 1  # iteration count
             t += num / self.sample_freq
@@ -1194,7 +1153,7 @@ class MovingPointSource(PointSource):
             if self.conv_amp:
                 rm *= (1 - Mr) ** 2
             try:
-                ind = array(0.5 + ind * self.up, dtype=int64)
+                ind = np.array(0.5 + ind * self.up, dtype=np.int64)
                 out = (signal[ind] / rm).T
                 yield out[:n]
             except IndexError:  # last incomplete frame
@@ -1221,7 +1180,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
     -----
@@ -1239,11 +1198,11 @@ class PointSourceDipole(PointSource):
     #: Default is ``(0.0, 0.0, 1.0)`` (z-axis orientation).
     #:
     #: **Note:** Use vectors with order of magnitude around ``1.0`` or less for good results.
-    direction = Tuple((0.0, 0.0, 1.0), desc='dipole orientation and distance of the inversely phased monopoles')
+    direction = Tuple((0.0, 0.0, 1.0))
 
     #: Behavior of the signal for negative time indices. Currently only supports ``'loop'``.
     #: Default is ``'loop'``.
-    prepadding = Enum('loop', desc='Behaviour for negative time indices.')
+    prepadding = Enum('loop')
 
     #: A unique identifier for the current state of the source, based on its properties. (read-only)
     digest = Property(
@@ -1296,10 +1255,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 = self.loc
         # 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
@@ -1313,7 +1272,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)
@@ -1336,8 +1295,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
@@ -1350,7 +1309,8 @@ class PointSourceDipole(PointSource):
             except IndexError:
                 break
 
-        yield out[:i]
+        if i > 0:
+            yield out[:i]
 
 
 class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
@@ -1370,8 +1330,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.
     """
 
@@ -1392,7 +1352,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)))
 
     @cached_property
     def _get_digest(self):
@@ -1434,70 +1394,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.
@@ -1524,8 +1439,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
@@ -1536,10 +1451,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
@@ -1548,7 +1463,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)
 
@@ -1567,8 +1482,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
@@ -1577,7 +1492,9 @@ class MovingPointSourceDipole(PointSourceDipole, MovingPointSource):
                     i = 0
             except IndexError:
                 break
-        yield out[:i]
+
+        if i > 0:
+            yield out[:i]
 
 
 class LineSource(PointSource):
@@ -1598,7 +1515,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
     -----
@@ -1606,19 +1523,19 @@ class LineSource(PointSource):
     """
 
     #: Vector to define the orientation of the line source. Default is ``(0.0, 0.0, 1.0)``.
-    direction = Tuple((0.0, 0.0, 1.0), desc='Line orientation ')
+    direction = Tuple((0.0, 0.0, 1.0))
 
     #: Vector to define the length of the line source in meters. Default is ``1.0``.
-    length = Float(1, desc='length of the line source')
+    length = Float(1)
 
     #: Number of monopole sources in the line source. Default is ``1``.
     num_sources = Int(1)
 
     #: Strength coefficients for each monopole source.
-    source_strength = CArray(desc='coefficients of the source strength')
+    source_strength = CArray()
 
     #: Coherence mode for the monopoles (``'coherent'`` or ``'incoherent'``).
-    coherence = Enum('coherent', 'incoherent', desc='coherence mode')
+    coherence = Enum('coherent', 'incoherent')
 
     #: A unique identifier for the current state of the source, based on its properties. (read-only)
     digest = Property(
@@ -1662,24 +1579,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 = self.loc
 
         # 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)
@@ -1696,18 +1613,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):
@@ -1727,10 +1645,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.
     """
 
@@ -1752,59 +1670,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)))
 
     @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.
@@ -1847,19 +1718,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
@@ -1887,21 +1758,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
@@ -1913,20 +1784,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
@@ -1938,19 +1809,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, removal_version='25.10')
 class UncorrelatedNoiseSource(SamplesGenerator):
     """
     Simulate uncorrelated white or pink noise signals at multiple channels.
@@ -1962,8 +1834,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
     -----
@@ -2006,12 +1878,12 @@ class UncorrelatedNoiseSource(SamplesGenerator):
     #: Instance of a :class:`~acoular.signals.NoiseGenerator`-derived class. For example:
     #:    - :class:`~acoular.signals.WNoiseGenerator` for white noise.
     #:    - :class:`~acoular.signals.PNoiseGenerator` for pink noise.
-    signal = Instance(NoiseGenerator, desc='type of noise')
+    signal = Instance(NoiseGenerator)
 
     #: 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)
 
     #: Number of output channels, automatically determined by the number of microphones
     #: defined in the :attr:`mics` attribute. Corresponds to the number of uncorrelated noise
@@ -2021,15 +1893,15 @@ class UncorrelatedNoiseSource(SamplesGenerator):
     #: :class:`~acoular.microphones.MicGeom` object specifying the positions of microphones.
     #: This attribute is used to define the microphone geometry and the
     #: :attr:`number of channels<num_channels>`.
-    mics = Instance(MicGeom, desc='microphone geometry')
+    mics = Instance(MicGeom)
 
     #: Start time of the generated noise signal in seconds. Determines the time offset for the noise
     #: output relative to the start of data acquisition. Default is ``0.0``.
-    start_t = Float(0.0, desc='signal start time')
+    start_t = Float(0.0)
 
     #: Start time of data acquisition at the microphones in seconds. This value determines when the
     #: generated noise begins relative to the acquisition process.  Default is ``0.0``.
-    start = Float(0.0, desc='sample start time')
+    start = Float(0.0)
 
     #: Total number of samples in the noise signal, derived from the :attr:`signal` generator.
     #: This value determines the length of the output signal for all channels.
@@ -2089,14 +1961,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
@@ -2114,7 +1986,6 @@ class UncorrelatedNoiseSource(SamplesGenerator):
                 return
 
 
-@deprecated_alias({'numchannels': 'num_channels', 'numsamples': 'num_samples'}, read_only=True, removal_version='25.10')
 class SourceMixer(SamplesGenerator):
     """
     Combine signals from multiple sources by mixing their outputs.
@@ -2126,7 +1997,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
     -----
@@ -2228,7 +2099,7 @@ class SourceMixer(SamplesGenerator):
     #: The size of the weights array must match the number of sources in :attr:`sources`.
     #: For example, with two sources, ``weights = [1.0, 0.5]`` would mix the first source at
     #: full amplitude and the second source at half amplitude.
-    weights = CArray(desc='channel weights')
+    weights = CArray()
 
     #: Internal identifier for the combined state of all sources, used to track
     #: changes in the sources for reproducibility and caching.
@@ -2316,7 +2187,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]
@@ -2345,7 +2216,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
     -----
@@ -2386,8 +2257,7 @@ class PointSourceConvolve(PointSource):
     (256, 4)
     (256, 4)
     (256, 4)
-    (256, 4)
-    (75, 4)
+    (232, 4)
 
     The last block has fewer samples.
     """
@@ -2395,24 +2265,36 @@ class PointSourceConvolve(PointSource):
     #: Convolution kernel in the time domain.
     #: The array must either have one column (a single kernel applied to all channels)
     #: or match the number of output channels in its second dimension.
-    kernel = CArray(dtype=float, desc='Convolution kernel.')
+    kernel = CArray(dtype=float)
 
     #: Start time of the signal in seconds. Default is ``0.0``.
-    start_t = Enum(0.0, desc='signal start time')
+    start_t = Enum(0.0)
 
     #: Start time of the data acquisition the the microphones in seconds. Default is ``0.0``.
-    start = Enum(0.0, desc='sample start time')
+    start = Enum(0.0)
 
     #: Behavior for negative time indices. Default is ``None``.
-    prepadding = Enum(None, desc='Behavior for negative time indices.')
+    prepadding = Enum(None)
 
     #: Upsampling factor for internal use. Default is ``None``.
-    up = Enum(None, desc='upsampling factor')
+    up = Enum(None)
 
     #: Unique identifier for the current state of the source,
     #: based on microphone geometry, input signal, source location, and kernel. (read-only)
     digest = Property(depends_on=['mics.digest', 'signal.digest', 'loc', 'kernel'])
 
+    #: Controls whether to extend the output to include the full convolution result.
+    #:
+    #: - If ``False`` (default): Output length is :math:`\\max(L, M)`, where :math:`L` is the
+    #:   kernel length and :math:`M` is the signal length. This mode keeps the output length
+    #:   equal to the longest input (different from NumPy's ``mode='same'``, since it does not
+    #:   pad the output).
+    #: - If ``True``: Output length is :math:`L + M - 1`, returning the full convolution at
+    #:   each overlap point (similar to NumPy's ``mode='full'``).
+    #:
+    #: Default is ``False``.
+    extend_signal = Bool(False)
+
     @cached_property
     def _get_digest(self):
         return digest(self)
@@ -2444,7 +2326,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,
@@ -2454,5 +2336,6 @@ class PointSourceConvolve(PointSource):
         time_convolve = TimeConvolve(
             source=source,
             kernel=self.kernel,
+            extend_signal=self.extend_signal,
         )
         yield from time_convolve.result(num)