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

acoular/signals.py

@@ -67,7 +67,7 @@ class SignalGenerator(ABCHasStrictTraits):
     """
 
     #: Sampling frequency of the signal in Hz. Default is ``1.0``.
-    sample_freq = Float(1.0, desc='sampling frequency')
+    sample_freq = Float(1.0)
 
     #: The number of samples to generate for the signal.
     num_samples = CInt
@@ -141,10 +141,10 @@ class PeriodicSignalGenerator(SignalGenerator):
     """
 
     #: The frequency of the signal. Default is ``1000.0``.
-    freq = Float(1000.0, desc='Frequency')
+    freq = Float(1000.0)
 
     #: The phase of the signal (in radians). Default is ``0.0``.
-    phase = Float(0.0, desc='Phase')
+    phase = Float(0.0)
 
     #: The amplitude of the signal. Default is ``1.0``.
     amplitude = Float(1.0)
@@ -174,18 +174,18 @@ class NoiseGenerator(SignalGenerator):
     See Also
     --------
     :class:`~acoular.signals.PNoiseGenerator` : For pink noise generation.
-    :class:`~acoular.signals.WNoiseGenerator` : For pink white generation.
+    :class:`~acoular.signals.WNoiseGenerator` : For white noise generation.
     :class:`~acoular.sources.UncorrelatedNoiseSource` : For per-channel noise generation.
     """
 
     #: Root mean square (RMS) amplitude of the signal. For a point source,
     #: this corresponds to the RMS amplitude at a distance of 1 meter. Default is ``1.0``.
-    rms = Float(1.0, desc='rms amplitude')
+    rms = Float(1.0)
 
     #: Seed for random number generator. Default is ``0``.
     #: This parameter should be set differently for different instances
     #: to guarantee statistically independent (non-correlated) outputs.
-    seed = Int(0, desc='random seed value')
+    seed = Int(0)
 
     #: Internal identifier based on generator properties. (read-only)
     digest = Property(depends_on=['rms', 'seed', 'sample_freq', 'num_samples'])
@@ -243,7 +243,7 @@ class WNoiseGenerator(NoiseGenerator):
     array([False, False, False])
     """
 
-    # internal identifier
+    #: A unique identifier for the generator, based on its properties. (read-only)
     digest = Property(depends_on=['rms', 'seed', 'sample_freq', 'num_samples'])
 
     @cached_property
@@ -294,7 +294,7 @@ class PNoiseGenerator(NoiseGenerator):
     #: of the :math:`1/f` spectrum at low frequencies but increase computation time. The  maximum
     #: allowable value depends on the :attr:`number of samples<SignalGenerator.num_samples>`.
     #: Default is ``16``.
-    depth = Int(16, desc='octave depth')
+    depth = Int(16)
 
     #: A unique checksum identifier based on the object properties. (read-only)
     digest = Property(depends_on=['rms', 'seed', 'sample_freq', 'num_samples', 'depth'])
@@ -402,11 +402,11 @@ class FiltWNoiseGenerator(WNoiseGenerator):
 
     #: A :class:`numpy.ndarray` of autoregressive coefficients (denominator). Default is ``[]``,
     #: which results in no AR filtering (i.e., all-pole filter is ``[1.0]``).
-    ar = CArray(value=np.array([]), dtype=float, desc='autoregressive coefficients (coefficients of the denominator)')
+    ar = CArray(value=np.array([]), dtype=float)
 
     #: A :class:`numpy.ndarray` of moving-average coefficients (numerator). Default is ``[]``,
     #: which results in no MA filtering (i.e., all-zero filter is ``[1.0]``).
-    ma = CArray(value=np.array([]), dtype=float, desc='moving-average coefficients (coefficients of the numerator)')
+    ma = CArray(value=np.array([]), dtype=float)
 
     #: A unique checksum identifier based on the object properties. (read-only)
     digest = Property(depends_on=['rms', 'seed', 'sample_freq', 'num_samples', 'ar', 'ma'])

acoular/sources.py

@@ -40,7 +40,7 @@ import numba as nb
 import numpy as np
 import scipy.linalg as spla
 from numpy.fft import fft, ifft
-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,
@@ -258,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
@@ -290,7 +290,7 @@ def get_modes(lOrder, direction, mpos, sourceposition=None):  # noqa: N803
     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
@@ -347,28 +347,28 @@ 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')
+    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(depends_on=['data'])
@@ -516,35 +516,31 @@ 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', 'invalid_channels', '_datachecksum'])
@@ -724,18 +720,26 @@ 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(np.array(self.loc).reshape((3, 1)), self.mics.pos)
+        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)
 
@@ -745,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`):
@@ -757,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')
@@ -819,7 +823,7 @@ class PointSource(SamplesGenerator):
         signal = self.signal.usignal(self.up)
         out = np.empty((num, self.num_channels))
         # distances
-        rm = self.env._r(np.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
 
@@ -869,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(
@@ -970,7 +974,7 @@ class SphericalHarmonicSource(PointSource):
 
         signal = self.signal.usignal(self.up)
         # emission time relative to start_t (in samples) for first sample
-        rm = self.env._r(np.array(self.loc).reshape((3, 1)), self.mics.pos)
+        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
@@ -1008,15 +1012,15 @@ class MovingPointSource(PointSource):
     #: 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(
@@ -1135,12 +1139,12 @@ class MovingPointSource(PointSource):
             # Newton-Rhapson iteration
             while abs(eps).max() > epslim and j < 100:
                 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
+                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,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(
@@ -1251,7 +1255,7 @@ class PointSourceDipole(PointSource):
 
         mpos = self.mics.pos
         # position of the dipole as (3,1) vector
-        loc = np.array(self.loc, dtype=float).reshape((3, 1))
+        loc = self.loc
         # direction vector from tuple
         direc = np.array(self.direction, dtype=float) * 1e-5
         direc_mag = np.sqrt(np.dot(direc, direc))
@@ -1348,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=np.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):
@@ -1519,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(
@@ -1587,7 +1591,7 @@ class LineSource(PointSource):
         out = np.zeros((num, self.num_channels))
 
         # distance from line start position to microphones
-        loc = np.array(self.loc, dtype=float).reshape((3, 1))
+        loc = self.loc
 
         # distances from monopoles in the line to microphones
         rms = np.empty((self.num_channels, self.num_sources))
@@ -1666,7 +1670,7 @@ 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=np.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):
@@ -1874,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=np.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
@@ -1889,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.
@@ -2095,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.
@@ -2253,8 +2257,7 @@ class PointSourceConvolve(PointSource):
     (256, 4)
     (256, 4)
     (256, 4)
-    (256, 4)
-    (75, 4)
+    (232, 4)
 
     The last block has fewer samples.
     """
@@ -2262,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)
@@ -2321,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)

acoular/spectra.py

@@ -85,7 +85,6 @@ class BaseSpectra(ABCHasStrictTraits):
             'Blackman': np.blackman,
         },
         default_value='Rectangular',
-        desc='type of window for FFT',
     )
 
     #: Overlap factor for FFT block averaging. One of:
@@ -97,7 +96,7 @@ class BaseSpectra(ABCHasStrictTraits):
     #: - ``'75%'``
     #:
     #: - ``'87.5%'``
-    overlap = Map({'None': 1, '50%': 2, '75%': 4, '87.5%': 8}, default_value='None', desc='overlap of FFT blocks')
+    overlap = Map({'None': 1, '50%': 2, '75%': 4, '87.5%': 8}, default_value='None')
 
     #: FFT block size. Must be one of: ``128``, ``256``, ``512``, ``1024``, ... ``65536``.
     #: Default is ``1024``.
@@ -112,11 +111,10 @@ class BaseSpectra(ABCHasStrictTraits):
         16384,
         32768,
         65536,
-        desc='number of samples per FFT block',
     )
 
     #: Precision of the FFT, corresponding to NumPy dtypes. Default is ``'complex128'``.
-    precision = Enum('complex128', 'complex64', desc='precision of the fft')
+    precision = Enum('complex128', 'complex64')
 
     #: A unique identifier for the spectra, based on its properties. (read-only)
     digest = Property(depends_on=['precision', 'block_size', 'window', 'overlap'])
@@ -207,19 +205,16 @@ class PowerSpectra(BaseSpectra):
     #: :class:`SamplesGenerator<acoular.base.SamplesGenerator>` or a derived class.
     source = Instance(SamplesGenerator)
 
-    # Shadow trait, should not be set directly, for internal use.
-    _ind_low = Int(1, desc='index of lowest frequency line')
-
-    # Shadow trait, should not be set directly, for internal use.
-    _ind_high = Union(Int(-1), None, desc='index of highest frequency line')
+    _ind_low = Int(1)
+    _ind_high = Union(Int(-1), None)
 
     #: Index of lowest frequency line to compute. Default is ``1``. Only used by objects that fetch
     #: the CSM. PowerSpectra computes every frequency line.
-    ind_low = Property(_ind_low, desc='index of lowest frequency line')
+    ind_low = Property(_ind_low)
 
     #: Index of highest frequency line to compute. Default is ``-1``
     #: (last possible line for default :attr:`~BaseSpectra.block_size`).
-    ind_high = Property(_ind_high, desc='index of lowest frequency line')
+    ind_high = Property(_ind_high)
 
     # Stores the set lower frequency, for internal use, should not be set directly.
     _freqlc = Float(0)
@@ -233,37 +228,37 @@ class PowerSpectra(BaseSpectra):
     _index_set_last = Bool(True)
 
     #: A flag indicating whether the result should be cached in HDF5 files. Default is ``True``.
-    cached = Bool(True, desc='cached flag')
+    cached = Bool(True)
 
     #: The number of FFT blocks used for averaging. This is derived from the
     #: :attr:`~BaseSpectra.block_size` and :attr:`~BaseSpectra.overlap` parameters. (read-only)
-    num_blocks = Property(desc='overall number of FFT blocks')
+    num_blocks = Property()
 
     #: 2-element array with the lowest and highest frequency. If the higher frequency is larger than
     #: the max frequency, the max frequency will be the upper bound.
-    freq_range = Property(desc='frequency range')
+    freq_range = Property()
     # If set, will overwrite :attr:`_freqlc`  and :attr:`_freqhc` according to the range. The
     # freq_range interval will be the smallest discrete frequency inside the half-open interval
     # [_freqlc, _freqhc[ and the smallest upper frequency outside of the interval.
 
     #: The sequence of frequency indices between :attr:`ind_low` and :attr:`ind_high`. (read-only)
-    indices = Property(desc='index range')
+    indices = Property()
 
     #: The name of the cache file (without the file extension) used for storing results. (read-only)
-    basename = Property(depends_on=['source.digest'], desc='basename for cache file')
+    basename = Property(depends_on=['source.digest'])
 
     #: The cross-spectral matrix, represented as an array of shape ``(n, m, m)`` of complex values
     #: for ``n`` frequencies and ``m`` channels as in :attr:`~BaseSpectra.num_channels`. (read-only)
-    csm = Property(desc='cross spectral matrix')
+    csm = Property()
 
     #: The eigenvalues of the CSM, stored as an array of shape ``(n,)`` of floats for ``n``
     #: frequencies. (read-only)
-    eva = Property(desc='eigenvalues of cross spectral matrix')
+    eva = Property()
 
     #: The eigenvectors of the cross spectral matrix, stored as an array of shape ``(n, m, m)`` of
     #: floats for ``n`` frequencies and ``m`` channels as in :attr:`~BaseSpectra.num_channels`.
     #: (read-only)
-    eve = Property(desc='eigenvectors of cross spectral matrix')
+    eve = Property()
 
     #: A unique identifier for the spectra, based on its properties.  (read-only)
     digest = Property(
@@ -617,50 +612,46 @@ class PowerSpectraImport(PowerSpectra):
 
     #: The cross-spectral matrix stored in an array of shape ``(n, m, m)`` of complex for ``n``
     #: frequencies and ``m`` channels.
-    csm = Property(desc='cross spectral matrix')
+    csm = Property()
 
     #: The frequencies included in the CSM in ascending order. Accepts list, array, or a single
     #: float value.
-    frequencies = Union(None, CArray, Float, desc='frequencies included in the cross-spectral matrix')
+    frequencies = Union(None, CArray, Float)
 
     #: Number of time data channels, inferred from the shape of the CSM.
     num_channels = Property(depends_on=['digest'])
 
     #: :class:`PowerSpectraImport` does not consume time data; source is always ``None``.
-    source = Enum(None, desc='PowerSpectraImport cannot consume time data')
+    source = Enum(None)
 
     #: Sampling frequency of the signal. Default is ``None``
-    sample_freq = Enum(None, desc='sampling frequency')
+    sample_freq = Enum(None)
 
     #: Block size for FFT, non-functional in this class.
-    block_size = Enum(None, desc='PowerSpectraImport does not operate on blocks of time data')
+    block_size = Enum(None)
 
     #: Windowing method, non-functional in this class.
-    window = Enum(None, desc='PowerSpectraImport does not perform windowing')
+    window = Enum(None)
 
     #: Overlap between blocks, non-functional in this class.
-    overlap = Enum(None, desc='PowerSpectraImport does not consume time data')
+    overlap = Enum(None)
 
     #: Caching capability, always disabled.
-    cached = Enum(False, desc='PowerSpectraImport has no caching capabilities')
+    cached = Enum(False)
 
     #: Number of FFT blocks, always ``None``.
-    num_blocks = Enum(None, desc='PowerSpectraImport cannot determine the number of blocks')
-
-    # Shadow trait, should not be set directly, for internal use.
-    _ind_low = Int(0, desc='index of lowest frequency line')
+    num_blocks = Enum(None)
 
-    # Shadow trait, should not be set directly, for internal use.
-    _ind_high = Union(None, Int, desc='index of highest frequency line')
+    _ind_low = Int(0)
+    _ind_high = Union(None, Int)
 
     #: A unique identifier for the spectra, based on its properties. (read-only)
     digest = Property(depends_on=['_csmsum'])
 
     #: Name of the cache file without extension. (read-only)
-    basename = Property(depends_on=['digest'], desc='basename for cache file')
+    basename = Property(depends_on=['digest'])
 
-    # Shadow trait for storing the CSM, for internal use only.
-    _csm = Union(None, CArray(shape=(None, None, None)), desc='cross spectral matrix')
+    _csm = Union(None, CArray(shape=(None, None, None)))
 
     # Checksum for the CSM to trigger digest calculation, for internal use only.
     _csmsum = Float()