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

acoular/fprocess.py

@@ -51,7 +51,7 @@ class RFFT(BaseSpectra, SpectraOut):
     #: The number of workers to use for FFT calculation.
     #: If set to a negative value, all available logical CPUs are used.
     #: Default is ``None``, which relies on the :func:`scipy.fft.rfft` implementation.
-    workers = Union(Int(), None, default_value=None, desc='number of workers to use')
+    workers = Union(Int(), None, default_value=None)
 
     #: Defines the scaling method for the FFT result. Options are:
     #:
@@ -79,7 +79,8 @@ class RFFT(BaseSpectra, SpectraOut):
 
     # Internal representation of the block size for FFT processing.
     # Used for validation and property management.
-    _block_size = Int(1024, desc='block size of the FFT')
+    #: block size of the FFT
+    _block_size = Int(1024)
 
     #: A unique identifier based on the process properties.
     digest = Property(depends_on=['source.digest', 'scaling', 'precision', '_block_size', 'window', 'overlap'])
@@ -189,12 +190,12 @@ class IRFFT(TimeOut):
     #: The number of workers (threads) to use for the IFFT calculation.
     #: A negative value utilizes all available logical CPUs.
     #: Default is ``None``, which relies on the :func:`scipy.fft.irfft` implementation.
-    workers = Union(Int(), None, default_value=None, desc='number of workers to use')
+    workers = Union(Int(), None, default_value=None)
 
     #: Determines the floating-point precision of the resulting time-domain signals.
     #: Options include ``'float64'`` and ``'float32'``.
     #: Default is ``'float64'``, ensuring high precision.
-    precision = Enum('float64', 'float32', desc='precision of the time signal after the ifft')
+    precision = Enum('float64', 'float32')
 
     #: The total number of time-domain samples in the output.
     #: Computed as the product of the number of input samples and the block size.
@@ -203,7 +204,8 @@ class IRFFT(TimeOut):
 
     # Internal signal buffer used for handling arbitrary output block sizes. Optimizes
     # processing when the requested output block size does not match the source block size.
-    _buffer = CArray(desc='signal buffer')
+    #: signal buffer
+    _buffer = CArray()
 
     #: A unique identifier based on the process properties.
     digest = Property(depends_on=['source.digest', 'scaling', 'precision', '_block_size', 'window', 'overlap'])
@@ -297,11 +299,11 @@ class AutoPowerSpectra(SpectraOut):
     scaling = Enum('power', 'psd')
 
     #: A Boolean flag indicating whether the input spectra are single-sided. Default is ``True``.
-    single_sided = Bool(True, desc='single sided spectrum')
+    single_sided = Bool(True)
 
     #: Specifies the floating-point precision of the computed auto-power spectra.
     #: Options are ``'float64'`` and ``'float32'``. Default is ``'float64'``.
-    precision = Enum('float64', 'float32', desc='floating-number-precision')
+    precision = Enum('float64', 'float32')
 
     #: A unique identifier based on the computation properties.
     digest = Property(depends_on=['source.digest', 'precision', 'scaling', 'single_sided'])
@@ -372,7 +374,7 @@ class CrossPowerSpectra(AutoPowerSpectra):
 
     #: Specifies the floating-point precision of the computed cross-spectral matrix (CSM).
     #: Options are ``'complex128'`` and ``'complex64'``. Default is ``'complex128'``.
-    precision = Enum('complex128', 'complex64', desc='precision of the fft')
+    precision = Enum('complex128', 'complex64')
 
     #: Defines the calculation mode for the cross-spectral matrix:
     #:
@@ -383,7 +385,7 @@ class CrossPowerSpectra(AutoPowerSpectra):
     #:       excluding redundant upper-triangle elements.
     #:
     #: Default is ``'full'``.
-    calc_mode = Enum('full', 'upper', 'lower', desc='calculation mode')
+    calc_mode = Enum('full', 'upper', 'lower')
 
     #: The number of channels in the output data. The value depends on the number of input channels
     #: :math:`n` and the selected :attr:`calc_mode`:

acoular/grids.py

@@ -74,6 +74,7 @@ from traits.trait_errors import TraitError
 
 # acoular imports
 from .internal import digest, ldigest
+from .tools.utils import Polygon
 
 
 def in_hull(p, hull, border=True, tol=0):
@@ -128,173 +129,6 @@ def in_hull(p, hull, border=True, tol=0):
     return hull.find_simplex(p, tol=tol) > 0
 
 
-def _det(xvert, yvert):
-    xvert = np.asarray(xvert, dtype=float)
-    yvert = np.asarray(yvert, dtype=float)
-    x_prev = np.concatenate(([xvert[-1]], xvert[:-1]))
-    y_prev = np.concatenate(([yvert[-1]], yvert[:-1]))
-    return np.sum(yvert * x_prev - xvert * y_prev, axis=0)
-
-
-class Polygon:
-    """
-    Create an object representing a general polygon in a 2D plane.
-
-    This class allows defining a polygon by specifying the coordinates of its vertices and provides
-    methods for checking whether a set of points lies inside the polygon, or if a point is closer to
-    a side or vertex of the polygon.
-
-    Parameters
-    ----------
-    x : array_like
-        Array of x-coordinates of the vertices that define the polygon. These coordinates should
-        form a closed shape (i.e., the last point should be the same as the first point).
-
-    y : array_like
-        Array of y-coordinates of the vertices that define the polygon. These coordinates should
-        correspond to the x-coordinates, forming a closed shape.
-
-    Attributes
-    ----------
-    x : :class:`numpy.ndarray`
-        Array of x-coordinates of the polygon vertices.
-
-    y : :class:`numpy.ndarray`
-        Array of y-coordinates of the polygon vertices.
-    """
-
-    def __init__(self, x, y):
-        if len(x) != len(y):
-            msg = 'x and y must be equally sized.'
-            raise IndexError(msg)
-        self.x = np.asarray(x, dtype=float)
-        self.y = np.asarray(y, dtype=float)
-        # Closes the polygon if were open
-        x1, y1 = x[0], y[0]
-        xn, yn = x[-1], y[-1]
-        if x1 != xn or y1 != yn:
-            self.x = np.concatenate((self.x, [x1]))
-            self.y = np.concatenate((self.y, [y1]))
-        # Anti-clockwise coordinates
-        if _det(self.x, self.y) < 0:
-            self.x = self.x[::-1]
-            self.y = self.y[::-1]
-
-    def is_inside(self, xpoint, ypoint, smalld=1e-12):
-        """
-        Check if a point or set of points are inside the polygon.
-
-        Parameters
-        ----------
-        xpoint : :class:`float` or array_like
-            Array of x-coordinates of the points to be tested.
-
-        ypoint : :class:`float` or array_like
-            Array of y-coordinates of the points to be tested.
-
-        smalld : :class:`float`, optional
-            Tolerance used for floating point comparisons when checking if a point is exactly on a
-            polygon's edge. The default value is ``1e-12``.
-
-        Returns
-        -------
-        :class:`float` or array_like
-            The distance from the point to the nearest point on the polygon. The values returned
-            have the following meanings:
-            - ``mindst < 0``: Point is outside the polygon.
-            - ``mindst = 0``: Point is on an edge of the polygon.
-            - ``mindst > 0``: Point is inside the polygon.
-
-        Notes
-        -----
-        The method uses an improved algorithm based on Nordbeck and Rydstedt for determining
-        whether a point is inside a polygon :cite:`SLOAN198545`.
-        """
-        xpoint = np.asarray(xpoint, dtype=float)
-        ypoint = np.asarray(ypoint, dtype=float)
-        # Scalar to array
-        if xpoint.shape == ():
-            xpoint = np.array([xpoint], dtype=float)
-            ypoint = np.array([ypoint], dtype=float)
-            scalar = True
-        else:
-            scalar = False
-        # Check consistency
-        if xpoint.shape != ypoint.shape:
-            msg = 'x and y has different shapes'
-            raise IndexError(msg)
-        # If snear = True: Dist to nearest side < nearest vertex
-        # If snear = False: Dist to nearest vertex < nearest side
-        snear = np.ma.masked_all(xpoint.shape, dtype=bool)
-        # Initialize arrays
-        mindst = np.ones_like(xpoint, dtype=float) * np.inf
-        j = np.ma.masked_all(xpoint.shape, dtype=int)
-        x = self.x
-        y = self.y
-        n = len(x) - 1  # Number of sides/vertices defining the polygon
-        # Loop over each side defining polygon
-        for i in range(n):
-            d = np.ones_like(xpoint, dtype=float) * np.inf
-            # Start of side has coords (x1, y1)
-            # End of side has coords (x2, y2)
-            # Point has coords (xpoint, ypoint)
-            x1 = x[i]
-            y1 = y[i]
-            x21 = x[i + 1] - x1
-            y21 = y[i + 1] - y1
-            x1p = x1 - xpoint
-            y1p = y1 - ypoint
-            # Points on infinite line defined by
-            #     x = x1 + t * (x1 - x2)
-            #     y = y1 + t * (y1 - y2)
-            # where
-            #     t = 0    at (x1, y1)
-            #     t = 1    at (x2, y2)
-            # Find where normal passing through (xpoint, ypoint) intersects
-            # infinite line
-            t = -(x1p * x21 + y1p * y21) / (x21**2 + y21**2)
-            tlt0 = t < 0
-            tle1 = (t >= 0) & (t <= 1)
-            # Normal intersects side
-            d[tle1] = (x1p[tle1] + t[tle1] * x21) ** 2 + (y1p[tle1] + t[tle1] * y21) ** 2
-            # Normal does not intersects side
-            # Point is closest to vertex (x1, y1)
-            # Compute square of distance to this vertex
-            d[tlt0] = x1p[tlt0] ** 2 + y1p[tlt0] ** 2
-            # Store distances
-            mask = d < mindst
-            mindst[mask] = d[mask]
-            j[mask] = i
-            # Point is closer to (x1, y1) than any other vertex or side
-            snear[mask & tlt0] = False
-            # Point is closer to this side than to any other side or vertex
-            snear[mask & tle1] = True
-        if np.ma.count(snear) != snear.size:
-            msg = 'Error computing distances'
-            raise IndexError(msg)
-        mindst **= 0.5
-        # Point is closer to its nearest vertex than its nearest side, check if
-        # nearest vertex is concave.
-        # If the nearest vertex is concave then point is inside the polygon,
-        # else the point is outside the polygon.
-        jo = j.copy()
-        jo[j == 0] -= 1
-        area = _det([x[j + 1], x[j], x[jo - 1]], [y[j + 1], y[j], y[jo - 1]])
-        mindst[~snear] = np.copysign(mindst, area)[~snear]
-        # Point is closer to its nearest side than to its nearest vertex, check
-        # if point is to left or right of this side.
-        # If point is to left of side it is inside polygon, else point is
-        # outside polygon.
-        area = _det([x[j], x[j + 1], xpoint], [y[j], y[j + 1], ypoint])
-        mindst[snear] = np.copysign(mindst, area)[snear]
-        # Point is on side of polygon
-        mindst[np.fabs(mindst) < smalld] = 0
-        # If input values were scalar then the output should be too
-        if scalar:
-            mindst = float(mindst)
-        return mindst
-
-
 class Grid(ABCHasStrictTraits):
     """
     Abstract base class for grid geometries.
@@ -315,16 +149,16 @@ class Grid(ABCHasStrictTraits):
 
     #: The total number of grid points. This property is automatically calculated based on other
     #: defining attributes of the grid. (read-only)
-    size = Property(desc='overall number of grid points')
+    size = Property()
 
     #: The shape of the grid, represented as a tuple. Primarily useful for Cartesian grids.
     #: (read-only)
-    shape = Property(desc='grid shape as tuple')
+    shape = Property()
 
     #: The grid positions represented as a (3, :attr:`size`) array of :class:`floats<float>`.
     #: (read-only)
     #: All positions' coordinates are in meters by default (:ref:`see here <units_note_grids>`).
-    pos = Property(desc='x, y, z positions of grid points')
+    pos = Property()
 
     #: A unique identifier for the grid, based on its properties. (read-only)
     digest = Property
@@ -437,7 +271,7 @@ class Grid(ABCHasStrictTraits):
                 pos_str = ' '.join(
                     [
                         '  <pos',
-                        f'Name="Point {i+1}"',
+                        f'Name="Point {i + 1}"',
                         f'x="{self.pos[0, i]}"',
                         f'y="{self.pos[1, i]}"',
                         f'z="{self.pos[2, i]}"',
@@ -457,31 +291,31 @@ class RectGrid(Grid):
     """
 
     #: The lower x-limit that defines the grid. Default is ``-1``.
-    x_min = Float(-1.0, desc='minimum  x-value')
+    x_min = Float(-1.0)
 
     #: The upper x-limit that defines the grid. Default is ``1``.
-    x_max = Float(1.0, desc='maximum  x-value')
+    x_max = Float(1.0)
 
     #: The lower y-limit that defines the grid. Default is ``-1``.
-    y_min = Float(-1.0, desc='minimum  y-value')
+    y_min = Float(-1.0)
 
     #: The upper y-limit that defines the grid. Default is ``1``.
-    y_max = Float(1.0, desc='maximum  y-value')
+    y_max = Float(1.0)
 
     #: The constant z-coordinate of the grid plane. Default is ``1.0``.
-    z = Float(1.0, desc='position on z-axis')
+    z = Float(1.0)
 
     #: The side length of each cell. Default is ``0.1``.
-    increment = Float(0.1, desc='step size')
+    increment = Float(0.1)
 
     #: Number of grid points along x-axis. (read-only)
-    nxsteps = Property(desc='number of grid points along x-axis')
+    nxsteps = Property()
 
     #: Number of grid points along y-axis. (read-only)
-    nysteps = Property(desc='number of grid points along y-axis')
+    nysteps = Property()
 
     #: The grid's extension in :obj:`matplotlib.pyplot.imshow` compatible form. (read-only)
-    extent = Property(desc='grid extent as (x_min, x_max, y_min, y_max)')
+    extent = Property()
 
     #: A unique identifier for the grid, based on its properties. (read-only)
     digest = Property(
@@ -672,27 +506,26 @@ class RectGrid3D(RectGrid):
     """
 
     #: The lower z-limit that defines the grid. Default is ``-1.0``.
-    z_min = Float(-1.0, desc='minimum  z-value')
+    z_min = Float(-1.0)
 
     #: The upper z-limit that defines the grid. Default is ``1.0``.
-    z_max = Float(1.0, desc='maximum  z-value')
+    z_max = Float(1.0)
 
     #: Number of grid points along x-axis. (read-only)
-    nxsteps = Property(desc='number of grid points along x-axis')
+    nxsteps = Property()
 
     #: Number of grid points along y-axis. (read-only)
-    nysteps = Property(desc='number of grid points along y-axis')
+    nysteps = Property()
 
     #: Number of grid points along z-axis. (read-only)
-    nzsteps = Property(desc='number of grid points along z-axis')
+    nzsteps = Property()
 
-    # Private trait for increment handling
-    _increment = Union(Float(), CArray(shape=(3,), dtype=float), default_value=0.1, desc='step size')
+    _increment = Union(Float(), CArray(shape=(3,), dtype=float), default_value=0.1)
 
     #: The cell side length for the grid. This can either be a scalar (same increments in all 3
     #: dimensions) or a (3,) array of :class:`tuple` of :class:`floats<float>` with respective
     #: increments in x-, y-, and z-direction. Default is ``0.1``.
-    increment = Property(desc='step size')
+    increment = Property()
 
     def _get_increment(self):
         return self._increment
@@ -865,13 +698,14 @@ class ImportGrid(Grid):
     """
 
     #: Name of the .xml-file from which to read the data.
-    file = Union(None, File(filter=['*.xml'], exists=True), desc='name of the xml file to import')
+    file = Union(None, File(filter=['*.xml'], exists=True))
 
-    _gpos = CArray(dtype=float, desc='x, y, z position of all Grid Points')
+    #: x, y, z position of all Grid Points
+    _gpos = CArray(dtype=float)
 
     #: Names of subgrids for each point.
     #: This is an optional property, typically used when grids are divided into named subregions.
-    subgrids = CArray(desc='names of subgrids for each point')
+    subgrids = CArray()
 
     #: A unique identifier for the grid, based on its properties. (read-only)
     digest = Property(depends_on=['_gpos'])
@@ -1058,22 +892,22 @@ class LineGrid(Grid):
     loc = Tuple((0.0, 0.0, 0.0))
 
     #: A vector defining the orientation of the line in 3D space. Default is ``(1.0, 0.0, 0.0)``.
-    direction = Tuple((1.0, 0.0, 0.0), desc='Line orientation ')
+    direction = Tuple((1.0, 0.0, 0.0))
 
     #: Total length of the line. Default is ``1.0``.
-    length = Float(1, desc='length of the line source')
+    length = Float(1)
 
     #: Number of grid points along the line. Default is ``1``.
-    num_points = Int(1, desc='length of the line source')
+    num_points = Int(1)
 
     #: The total number of grid points. Automatically updated when other grid-defining attributes
     #: are set. (read-only)
-    size = Property(desc='overall number of grid points')
+    size = Property()
 
     #: A (3, :attr:`size`) array containing the x, y, and z positions of the grid points.
     #: (read-only)
     #: All positions' coordinates are in meters by default (:ref:`see here <units_note_grids>`).
-    pos = Property(desc='x, y, z positions of grid points')
+    pos = Property()
 
     #: A unique identifier for the grid, based on its properties. (read-only)
     digest = Property(
@@ -1135,13 +969,13 @@ class MergeGrid(Grid):
 
     #: A list of :class:`Grid` objects to be merged. Each grid is treated as a subdomain in the
     #: resulting merged grid.
-    grids = List(desc='list of grids')
+    grids = List()
 
     #: A list of unique digests for each grid being merged. (read-only)
-    grid_digest = Str(desc='digest of the merged grids')
+    grid_digest = Str()
 
     #: Names of subgrids corresponding to each point in the merged grid. (read-only)
-    subgrids = Property(desc='names of subgrids for each point')
+    subgrids = Property()
 
     #: A unique identifier for the grid, based on its properties. (read-only)
     digest = Property(depends_on=['grids', 'grid_digest'])
@@ -1248,16 +1082,16 @@ class SingleSector(Sector):
 
     #: If ``True``, grid points lying on the sector border are included in the sector. Default is
     #: ``True``.
-    include_border = Bool(True, desc='include points on the border')
+    include_border = Bool(True)
 
     #: The absolute tolerance to apply when determining if a grid point lies on the sector border.
     #: Default is ``1e-12``.
-    abs_tol = Float(1e-12, desc='absolute tolerance for sector border')
+    abs_tol = Float(1e-12)
 
     #: If ``True``, the ``contains`` method (as in :meth:`RectSector.contains`,
     #: :meth:`RectSector3D.contains`, :meth:`CircSector.contains`, and :meth:`PolySector.contains`)
     #: returns the nearest grid point if no grid points are inside the sector. Default is ``True``.
-    default_nearest = Bool(True, desc='``contains`` method return nearest grid point to center if none inside sector')
+    default_nearest = Bool(True)
 
 
 class RectSector(SingleSector):
@@ -1276,16 +1110,16 @@ class RectSector(SingleSector):
     """
 
     #: The minimum x position of the rectangle. Default is ``-1.0``.
-    x_min = Float(-1.0, desc='minimum x position of the rectangle')
+    x_min = Float(-1.0)
 
     #: The maximum x position of the rectangle. Default is ``1.0``.
-    x_max = Float(1.0, desc='maximum x position of the rectangle')
+    x_max = Float(1.0)
 
     #: The minimum y position of the rectangle. Default is ``-1.0``.
-    y_min = Float(-1.0, desc='minimum y position of the rectangle')
+    y_min = Float(-1.0)
 
     #: The maximum y position of the rectangle. Default is ``1.0``.
-    y_max = Float(1.0, desc='maximum y position of the rectangle')
+    y_max = Float(1.0)
 
     def contains(self, pos):
         """
@@ -1360,10 +1194,10 @@ class RectSector3D(RectSector):
     """
 
     #: The lower z position of the cuboid. Default is ``-1.0``.
-    z_min = Float(-1.0, desc='minimum z position of the cuboid')
+    z_min = Float(-1.0)
 
     #: The upper z position of the cuboid.  Default is ``1.0``.
-    z_max = Float(1.0, desc='maximum z position of the cuboid')
+    z_max = Float(1.0)
 
     def contains(self, pos):
         """
@@ -1449,13 +1283,13 @@ class CircSector(SingleSector):
     """
 
     #: The x position of the circle center. Default is ``0.0``.
-    x = Float(0.0, desc='x position of the circle center')
+    x = Float(0.0)
 
     #: The y position of the circle center. Default is ``0.0``.
-    y = Float(0.0, desc='y position of the circle center')
+    y = Float(0.0)
 
     #: Radius of the circle. Default is ``1.0``.
-    r = Float(1.0, desc='radius of the circle')
+    r = Float(1.0)
 
     def contains(self, pos):
         """

acoular/microphones.py

@@ -137,32 +137,32 @@ class MicGeom(HasStrictTraits):
 
     #: Path to the XML file containing microphone positions. The XML file should have elements with
     #: the tag ``pos`` and attributes ``Name``, ``x``, ``y``, and ``z``.
-    file = Union(None, File(filter=['*.xml'], exists=True), desc='name of the xml file to import')
+    file = Union(None, File(filter=['*.xml'], exists=True))
 
     #: Array containing the ``x, y, z`` positions of all microphones, including invalid ones, shape
     #: ``(3,`` :attr:`num_mics` ``)``. This is set automatically when :attr:`file` changes or
     #: explicitly by assigning an array of floats. All coordinates are in meters by default
     #: (:ref:`see here <units_note_microphones>`).
-    pos_total = CArray(dtype=float, shape=(3, None), desc='x, y, z position of all microphones')
+    pos_total = CArray(dtype=float, shape=(3, None))
 
     #: Array containing the ``x, y, z`` positions of valid microphones (i.e., excluding those in
     #: :attr:`invalid_channels`), shape ``(3,`` :attr:`num_mics` ``)``. (read-only)
     #: All coordinates are in meters by default (:ref:`see here <units_note_microphones>`).
-    pos = Property(depends_on=['pos_total', 'invalid_channels'], desc='x, y, z position of used microphones')
+    pos = Property(depends_on=['pos_total', 'invalid_channels'])
 
     #: List of indices indicating microphones to be excluded from calculations and results.
     #: Default is ``[]``.
-    invalid_channels = List(int, desc='list of invalid channels')
+    invalid_channels = List(int)
 
     #: Number of valid microphones in the array. (read-only)
-    num_mics = Property(depends_on=['pos'], desc='number of microphones in the geometry')
+    num_mics = Property(depends_on=['pos'])
 
     #: The geometric center of the array, calculated as the arithmetic mean of the positions of all
     #: valid microphones. (read-only)
-    center = Property(depends_on=['pos'], desc='array center')
+    center = Property(depends_on=['pos'])
 
     #: The maximum distance between any two valid microphones in the array. (read-only)
-    aperture = Property(depends_on=['pos'], desc='array aperture')
+    aperture = Property(depends_on=['pos'])
 
     #: A unique identifier for the geometry, based on its properties. (read-only)
     digest = Property(depends_on=['pos'])
@@ -270,6 +270,6 @@ class MicGeom(HasStrictTraits):
             f.write(f'<?xml version="1.1" encoding="utf-8"?><MicArray name="{basename}">\n')
             for i in range(self.pos.shape[-1]):
                 f.write(
-                    f'  <pos Name="Point {i+1}" x="{self.pos[0, i]}" y="{self.pos[1, i]}" z="{self.pos[2, i]}"/>\n',
+                    f'  <pos Name="Point {i + 1}" x="{self.pos[0, i]}" y="{self.pos[1, i]}" z="{self.pos[2, i]}"/>\n',
                 )
             f.write('</MicArray>')

acoular/process.py

@@ -116,7 +116,7 @@ class Average(InOut):
 
     #: The number of samples (time domain source) or snapshots (frequency domain source)
     #: to average over. Default is ``64``.
-    num_per_average = Int(64, desc='number of samples/snapshots to average over')
+    num_per_average = Int(64)
 
     #: The sampling frequency of the output signal. It is set automatically as
     #: (:attr:`~acoular.base.Generator.sample_freq` ``/`` :attr:`num_per_average`).
@@ -479,7 +479,6 @@ class SampleSplitter(InOut):
     buffer_overflow_treatment = Dict(
         key_trait=Instance(Generator),
         value_trait=Enum('error', 'warning', 'none'),
-        desc='defines buffer overflow behaviour.',
     )
 
     # A shadow trait to monitor if source deliver samples or is empty.
@@ -728,7 +727,7 @@ class SamplesBuffer(InOut):
     """  # noqa: W505
 
     #: The number of samples that the buffer can hold.
-    length = Int(desc='number of samples that fit in the buffer')
+    length = Int()
 
     #: The number of samples per block to obtain from the source. If set to ``None``, the number of
     #: samples will be determined by the ``num`` argument of the :meth:`result` method.
@@ -736,7 +735,6 @@ class SamplesBuffer(InOut):
         None,
         Int(),
         default_value=None,
-        desc='number of samples to return from the source. If "None", use "num" argument of result method',
     )
 
     #: The number of samples to return from the buffer. If set to ``None``, the number of
@@ -745,7 +743,6 @@ class SamplesBuffer(InOut):
         None,
         Int(),
         default_value=None,
-        desc="number of samples to return from the buffer. If 'None', use 'num' argument of result method",
     )
 
     #: Index shift value for the buffer.
@@ -755,26 +752,22 @@ class SamplesBuffer(InOut):
     #:   samples.
     shift_index_by = Enum(
         ('result_num', 'num'),
-        desc=(
-            'index shift value for the buffer. If "result_num", use "result_num" trait.'
-            ' If "num", use "num" argument of result method'
-        ),
     )
 
     #: The current filling level of the buffer, i.e., how many samples are currently available.
-    level = Property(desc='current filling level of buffer')
+    level = Property()
 
     #: The data type of the elements in the buffer.
-    dtype = Any(desc='data type of the buffer')
+    dtype = Any()
 
     # Flag indicating if the source is empty (for internal use).
-    _empty_source = Bool(False, desc='flag to indicate that the source is empty')
+    _empty_source = Bool(False)
 
     # The actual buffer holding the samples for processing.
-    _buffer = Array(shape=(None, None), desc='buffer for block processing')
+    _buffer = Array(shape=(None, None))
 
     # The current index position in the buffer.
-    _index = Int(desc='current index in buffer')
+    _index = Int()
 
     def _get_level(self):
         return self._buffer.shape[0] - self._index

acoular/sdinput.py

@@ -35,36 +35,36 @@ class SoundDeviceSamplesGenerator(SamplesGenerator):
             raise ImportError(msg)
 
     #: input device index, refers to sounddevice list
-    device = Int(0, desc='input device index')
+    device = Int(0)
 
     #: Number of input channels, maximum depends on device
-    num_channels = Int(1, desc='number of analog input channels that collects data')
+    num_channels = Int(1)
 
     #: Number of samples to collect; defaults to -1. If is set to -1 device collects until user
     # breaks streaming by setting Trait: collect_samples = False.
-    num_samples = Int(-1, desc='number of samples to collect')
+    num_samples = Int(-1)
 
     #: Indicates if samples are collected, helper trait to break result loop
-    collect_samples = Bool(True, desc='Indicates if samples are collected')
+    collect_samples = Bool(True)
 
     #: Sampling frequency of the signal, changes with sinusdevices
-    sample_freq = Property(desc='sampling frequency')
+    sample_freq = Property()
 
     _sample_freq = Float(default_value=None)
 
     #: Datatype (resolution) of the signal, used as `dtype` in a sd `Stream` object
-    precision = Enum('float32', 'float16', 'int32', 'int16', 'int8', 'uint8', desc='precision (resolution) of signal')
+    precision = Enum('float32', 'float16', 'int32', 'int16', 'int8', 'uint8')
 
     #: Indicates that the sounddevice buffer has overflown
-    overflow = Bool(False, desc='Indicates if sounddevice buffer overflow')
+    overflow = Bool(False)
 
     #: Indicates that the stream is collecting samples
-    running = Bool(False, desc='Indicates that the stream is collecting samples')
+    running = Bool(False)
 
     #: The sounddevice InputStream object for inspection
     stream = Any
 
-    # internal identifier
+    #: A unique identifier for the generator, based on its properties. (read-only)
     digest = Property(depends_on=['device', 'num_channels', 'num_samples'])
 
     @cached_property