acoular 23.11__py3-none-any.whl → 24.5__py3-none-any.whl

acoular/tfastfuncs.py

@@ -1,173 +1,250 @@
-# -*- coding: utf-8 -*-
-#pylint: disable-msg=E0611, E1101, C0103, R0901, R0902, R0903, R0904, W0232
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # Copyright (c) Acoular Development Team.
-#------------------------------------------------------------------------------
-"""
-This file contains NUMBA accelerated functions for time-domain beamformers
-"""
+# ------------------------------------------------------------------------------
+"""Contains NUMBA accelerated functions for time-domain beamformers."""
+
 import numba as nb
 import numpy as np
 
-
 cachedOption = True  # if True: saves the numba func as compiled func in sub directory
-fastOption = True # fastmath options 
+fastOption = True  # fastmath options
+
 
-@nb.njit([(nb.float64[:,::1], nb.int64[:,::1], nb.float64[:,::1], nb.float64[:,::1], nb.float64[:,::1], nb.float64[:,::1])],
-                cache=True, parallel=True, fastmath=True)
+@nb.njit(
+    [
+        (
+            nb.float64[:, ::1],
+            nb.int64[:, ::1],
+            nb.float64[:, ::1],
+            nb.float64[:, ::1],
+            nb.float64[:, ::1],
+            nb.float64[:, ::1],
+        ),
+    ],
+    cache=True,
+    parallel=True,
+    fastmath=True,
+)
 def _delayandsum4(data, offsets, ifactor2, steeramp, out, autopower):
-    """ Performs one time step of delay and sum with output and additional autopower removal
-      
+    """Performs one time step of delay and sum with output and additional autopower removal.
+
     Parameters
     ----------
-    data : float64[nSamples, nMics] 
+    data : float64[nSamples, nMics]
         The time history for all channels.
-    offsets : int64[gridSize, nMics] 
+    offsets : int64[gridSize, nMics]
         Indices for each grid point and each channel.
-    ifactor2: float64[gridSize, nMics] 
+    ifactor2: float64[gridSize, nMics]
         Second interpolation factor, the first one is computed internally.
-    steeramp: float64[gridSize, nMics] 
-        Amplitude factor from steering vector.        
-    
+    steeramp: float64[gridSize, nMics]
+        Amplitude factor from steering vector.
+
     Returns
     -------
     None : as the inputs out and autopower get overwritten.
+
     """
     gridsize, numchannels = offsets.shape
     num = out.shape[0]
-    ZERO = data.dtype.type(0.)
-    ONE = data.dtype.type(1.)    
+    ZERO = data.dtype.type(0.0)
     for n in nb.prange(num):
         for gi in nb.prange(gridsize):
-            out[n,gi] = ZERO
-            autopower[n,gi] = ZERO
+            out[n, gi] = ZERO
+            autopower[n, gi] = ZERO
             for mi in range(numchannels):
-                ind = (gi,mi)
-                r = (data[offsets[ind]+n,mi] * (1.-ifactor2[ind]) \
-                    + data[offsets[ind]+n+1,mi] * ifactor2[ind]) * steeramp[ind]
-                out[n,gi] += r
-                autopower[n,gi] += r*r
-
-@nb.njit([(nb.float32[:,::1], nb.int32[:,:,::1], nb.float32[:,:,::1], nb.float32[:,:,::1], nb.float32[:,::1], nb.float32[:,::1]),
-            (nb.float64[:,::1], nb.int64[:,:,::1], nb.float64[:,:,::1], nb.float64[:,:,::1], nb.float64[:,::1], nb.float64[:,::1])],
-                cache=True, parallel=True, fastmath=True)
+                ind = (gi, mi)
+                r = (
+                    data[offsets[ind] + n, mi] * (1.0 - ifactor2[ind]) + data[offsets[ind] + n + 1, mi] * ifactor2[ind]
+                ) * steeramp[ind]
+                out[n, gi] += r
+                autopower[n, gi] += r * r
+
+
+@nb.njit(
+    [
+        (
+            nb.float32[:, ::1],
+            nb.int32[:, :, ::1],
+            nb.float32[:, :, ::1],
+            nb.float32[:, :, ::1],
+            nb.float32[:, ::1],
+            nb.float32[:, ::1],
+        ),
+        (
+            nb.float64[:, ::1],
+            nb.int64[:, :, ::1],
+            nb.float64[:, :, ::1],
+            nb.float64[:, :, ::1],
+            nb.float64[:, ::1],
+            nb.float64[:, ::1],
+        ),
+    ],
+    cache=True,
+    parallel=True,
+    fastmath=True,
+)
 def _delayandsum5(data, offsets, ifactor2, steeramp, out, autopower):
-    """ Performs one time step of delay and sum with output and additional autopower removal
-        
+    """Performs one time step of delay and sum with output and additional autopower removal.
+
     Parameters
     ----------
-    data : float64[nSamples, nMics] 
+    data : float64[nSamples, nMics]
         The time history for all channels.
-    offsets : int64[nBlockSamples, gridSize, nMics] 
+    offsets : int64[nBlockSamples, gridSize, nMics]
         Indices for each grid point and each channel.
-    ifactor2: float64[nBlockSamples,gridSize, nMics] 
+    ifactor2: float64[nBlockSamples,gridSize, nMics]
         Second interpolation factor, the first one is computed internally.
-    steeramp: float64[nBlockSamples,gridSize, nMics] 
-        Amplitude factor from steering vector.        
-    
+    steeramp: float64[nBlockSamples,gridSize, nMics]
+        Amplitude factor from steering vector.
+
     Returns
     -------
     None : as the inputs out and autopower get overwritten.
+
     """
     num, gridsize, numchannels = offsets.shape
     num = out.shape[0]
-    #ZERO = data.dtype.type(0.)
-    ONE = data.dtype.type(1.)
+    # ZERO = data.dtype.type(0.)
+    ONE = data.dtype.type(1.0)
     for n in nb.prange(num):
         for gi in nb.prange(gridsize):
-            out[n,gi] = 0
-            autopower[n,gi] = 0
+            out[n, gi] = 0
+            autopower[n, gi] = 0
             for mi in range(numchannels):
-                ind = offsets[n,gi,mi]+n
-                r = (data[ind,mi] * (ONE - ifactor2[n,gi,mi]) \
-                    + data[ind+1,mi] * ifactor2[n,gi,mi]) * steeramp[n,gi,mi]
-                out[n,gi] += r
-                autopower[n,gi] += r*r 
-
-@nb.njit([(nb.float32[:,:,:], nb.float32[:,:], nb.float32[:,:,:]),
-            (nb.float64[:,:,:], nb.float64[:,:], nb.float64[:,:,:])],
-                cache=True, parallel=True, fastmath=True)
-def _steer_I(rm, r0, amp):
+                ind = offsets[n, gi, mi] + n
+                r = (data[ind, mi] * (ONE - ifactor2[n, gi, mi]) + data[ind + 1, mi] * ifactor2[n, gi, mi]) * steeramp[
+                    n,
+                    gi,
+                    mi,
+                ]
+                out[n, gi] += r
+                autopower[n, gi] += r * r
+
+
+@nb.njit(
+    [
+        (nb.float32[:, :, :], nb.float32[:, :], nb.float32[:, :, :]),
+        (nb.float64[:, :, :], nb.float64[:, :], nb.float64[:, :, :]),
+    ],
+    cache=True,
+    parallel=True,
+    fastmath=True,
+)
+def _steer_I(rm, r0, amp):  # noqa: ARG001
     num, gridsize, numchannels = rm.shape
-    amp[0,0,0] = 1.0/numchannels# to get the same type for rm2 as for rm
-    Nr = amp[0,0,0]
-    for n in nb.prange(num): 
+    amp[0, 0, 0] = 1.0 / numchannels  # to get the same type for rm2 as for rm
+    Nr = amp[0, 0, 0]
+    for n in nb.prange(num):
         for gi in nb.prange(gridsize):
             for mi in nb.prange(numchannels):
-                amp[n,gi,mi] = Nr
+                amp[n, gi, mi] = Nr
+
 
-@nb.njit([(nb.float32[:,:,:], nb.float32[:,:], nb.float32[:,:,:]),
-            (nb.float64[:,:,:], nb.float64[:,:], nb.float64[:,:,:])],
-                cache=True, parallel=True, fastmath=True)
+@nb.njit(
+    [
+        (nb.float32[:, :, :], nb.float32[:, :], nb.float32[:, :, :]),
+        (nb.float64[:, :, :], nb.float64[:, :], nb.float64[:, :, :]),
+    ],
+    cache=True,
+    parallel=True,
+    fastmath=True,
+)
 def _steer_II(rm, r0, amp):
     num, gridsize, numchannels = rm.shape
-    amp[0,0,0] = 1.0/numchannels# to get the same type for rm2 as for rm
-    Nr = amp[0,0,0]    
-    for n in nb.prange(num): 
+    amp[0, 0, 0] = 1.0 / numchannels  # to get the same type for rm2 as for rm
+    Nr = amp[0, 0, 0]
+    for n in nb.prange(num):
         for gi in nb.prange(gridsize):
-            rm2 = np.divide(Nr,r0[n,gi])
+            rm2 = np.divide(Nr, r0[n, gi])
             for mi in nb.prange(numchannels):
-                amp[n,gi,mi] = rm[n,gi,mi]*rm2
+                amp[n, gi, mi] = rm[n, gi, mi] * rm2
+
 
-@nb.njit([(nb.float32[:,:,:], nb.float32[:,:], nb.float32[:,:,:]),
-            (nb.float64[:,:,:], nb.float64[:,:], nb.float64[:,:,:])],
-                cache=True, parallel=True, fastmath=True)
+@nb.njit(
+    [
+        (nb.float32[:, :, :], nb.float32[:, :], nb.float32[:, :, :]),
+        (nb.float64[:, :, :], nb.float64[:, :], nb.float64[:, :, :]),
+    ],
+    cache=True,
+    parallel=True,
+    fastmath=True,
+)
 def _steer_III(rm, r0, amp):
     num, gridsize, numchannels = rm.shape
-    rm20 = rm[0,0,0]-rm[0,0,0] # to get the same type for rm2 as for rm
-    rm1 = rm[0,0,0]/rm[0,0,0]
-    for n in nb.prange(num): 
+    rm20 = rm[0, 0, 0] - rm[0, 0, 0]  # to get the same type for rm2 as for rm
+    rm1 = rm[0, 0, 0] / rm[0, 0, 0]
+    for n in nb.prange(num):
         for gi in nb.prange(gridsize):
             rm2 = rm20
             for mi in nb.prange(numchannels):
-                rm2 += np.divide(rm1,np.square(rm[n,gi,mi]))
-            rm2 *= r0[n,gi]
+                rm2 += np.divide(rm1, np.square(rm[n, gi, mi]))
+            rm2 *= r0[n, gi]
             for mi in nb.prange(numchannels):
-                amp[n,gi,mi] = np.divide(rm1,rm[n,gi,mi]*rm2)
+                amp[n, gi, mi] = np.divide(rm1, rm[n, gi, mi] * rm2)
 
-@nb.njit([(nb.float32[:,:,:], nb.float32[:,:], nb.float32[:,:,:]),
-            (nb.float64[:,:,:], nb.float64[:,:], nb.float64[:,:,:])],
-                cache=True, parallel=True, fastmath=True)
-def _steer_IV(rm, r0, amp):
+
+@nb.njit(
+    [
+        (nb.float32[:, :, :], nb.float32[:, :], nb.float32[:, :, :]),
+        (nb.float64[:, :, :], nb.float64[:, :], nb.float64[:, :, :]),
+    ],
+    cache=True,
+    parallel=True,
+    fastmath=True,
+)
+def _steer_IV(rm, r0, amp):  # noqa: ARG001
     num, gridsize, numchannels = rm.shape
-    amp[0,0,0] = np.sqrt(1.0/numchannels)# to get the same type for rm2 as for rm
-    Nr = amp[0,0,0]
-    rm1 = rm[0,0,0]/rm[0,0,0]
-    rm20 = rm[0,0,0]-rm[0,0,0] # to get the same type for rm2 as for rm
-    for n in nb.prange(num): 
+    amp[0, 0, 0] = np.sqrt(1.0 / numchannels)  # to get the same type for rm2 as for rm
+    Nr = amp[0, 0, 0]
+    rm1 = rm[0, 0, 0] / rm[0, 0, 0]
+    rm20 = rm[0, 0, 0] - rm[0, 0, 0]  # to get the same type for rm2 as for rm
+    for n in nb.prange(num):
         for gi in nb.prange(gridsize):
             rm2 = rm20
             for mi in nb.prange(numchannels):
-                rm2 += np.divide(rm1,np.square(rm[n,gi,mi]))
+                rm2 += np.divide(rm1, np.square(rm[n, gi, mi]))
             rm2 = np.sqrt(rm2)
             for mi in nb.prange(numchannels):
-                amp[n,gi,mi] = np.divide(Nr,rm[n,gi,mi]*rm2)
+                amp[n, gi, mi] = np.divide(Nr, rm[n, gi, mi] * rm2)
+
 
-@nb.njit([(nb.float32[:,:,::1],  nb.float32, nb.float32[:,:,::1], nb.int32[:,:,::1]),
-            (nb.float64[:,:,::1], nb.float64, nb.float64[:,:,::1], nb.int64[:,:,::1])],
-                cache=True, parallel=True, fastmath=True)
+@nb.njit(
+    [
+        (nb.float32[:, :, ::1], nb.float32, nb.float32[:, :, ::1], nb.int32[:, :, ::1]),
+        (nb.float64[:, :, ::1], nb.float64, nb.float64[:, :, ::1], nb.int64[:, :, ::1]),
+    ],
+    cache=True,
+    parallel=True,
+    fastmath=True,
+)
 def _delays(rm, c, interp2, index):
     num, gridsize, numchannels = rm.shape
-    invc = 1/c
+    invc = 1 / c
     intt = index.dtype.type
-    for n in nb.prange(num):  
+    for n in nb.prange(num):
         for gi in nb.prange(gridsize):
             for mi in nb.prange(numchannels):
-                delays = invc * rm[n,gi,mi]
-                index[n,gi,mi] = intt(delays)
-                interp2[n,gi,mi] = delays - nb.int64(delays)
+                delays = invc * rm[n, gi, mi]
+                index[n, gi, mi] = intt(delays)
+                interp2[n, gi, mi] = delays - nb.int64(delays)
+
 
-@nb.njit([(nb.float32[:,:,:], nb.float32[:,:,:], nb.int32[:,:,:]),
-            (nb.float64[:,:,:], nb.float64[:,:,:], nb.int64[:,:,:])],
-                cache=True, parallel=True, fastmath=True)
+@nb.njit(
+    [
+        (nb.float32[:, :, :], nb.float32[:, :, :], nb.int32[:, :, :]),
+        (nb.float64[:, :, :], nb.float64[:, :, :], nb.int64[:, :, :]),
+    ],
+    cache=True,
+    parallel=True,
+    fastmath=True,
+)
 def _modf(delays, interp2, index):
     num, gridsize, numchannels = delays.shape
-    for n in nb.prange(num): 
+    for n in nb.prange(num):
         for gi in nb.prange(gridsize):
             for mi in nb.prange(numchannels):
-                index[n,gi,mi] = int(delays[n,gi,mi])
-                interp2[n,gi,mi] = delays[n,gi,mi] - index[n,gi,mi]
-     
+                index[n, gi, mi] = int(delays[n, gi, mi])
+                interp2[n, gi, mi] = delays[n, gi, mi] - index[n, gi, mi]
 
 
 if __name__ == '__main__':

acoular/tools/__init__.py

@@ -0,0 +1,25 @@
+# ------------------------------------------------------------------------------
+# Copyright (c) Acoular Development Team.
+# ------------------------------------------------------------------------------
+"""Useful tools for Acoular.
+
+.. autosummary::
+    :toctree: generated/
+
+    aiaa
+    helpers
+    metrics
+"""
+
+from .aiaa import (
+    CsmAIAABenchmark,
+    MicAIAABenchmark,
+    TimeSamplesAIAABenchmark,
+    TriggerAIAABenchmark,
+)
+from .helpers import (
+    bardata,
+    barspectrum,
+    return_result,
+)
+from .metrics import MetricEvaluator

acoular/tools/aiaa.py

@@ -0,0 +1,186 @@
+# ------------------------------------------------------------------------------
+# Copyright (c) Acoular Development Team.
+# ------------------------------------------------------------------------------
+"""Classes for importing AIAA Array Benchmarks
+from . import aiaa
+These classes allow importing data from HDF5 files following the specifications of
+the AIAA microphone array methods benchmarking effort:
+https://www-docs.b-tu.de/fg-akustik/public/veroeffentlichungen/ArrayMethodsFileFormatsR2P4Release.pdf .
+
+The classes are derived from according Acoular classes so that they can be used directly within
+the framework.
+
+Examples
+--------
+>>> micgeom = MicAIAABenchmark(name='some_benchmarkdata.h5')
+>>> timedata = TimeSamplesAIAABenchmark(name='some_benchmarkdata.h5')
+
+
+.. autosummary::
+    :toctree: generated/
+
+    TimeSamplesAIAABenchmark
+    TriggerAIAABenchmark
+    CsmAIAABenchmark
+    MicAIAABenchmark
+"""
+
+from os import path
+
+from numpy import array
+from traits.api import (
+    File,
+    Instance,
+    Property,
+    cached_property,
+    on_trait_change,
+    property_depends_on,
+)
+
+from acoular.h5files import H5FileBase, _get_h5file_class
+from acoular.internal import digest
+from acoular.microphones import MicGeom
+from acoular.sources import TimeSamples
+from acoular.spectra import PowerSpectraImport
+
+
+class TimeSamplesAIAABenchmark(TimeSamples):
+    """Container for AIAA benchmark data in `*.h5` format.
+
+    This class loads measured data from h5 files in AIAA benchmark format
+    and and provides information about this data.
+    Objects of this class behave similar to :class:`~acoular.sources.TimeSamples`
+    objects.
+    """
+
+    def load_timedata(self):
+        """Loads timedata from .h5 file. Only for internal use."""
+        self.data = self.h5f.get_data_by_reference('MicrophoneData/microphoneDataPa')
+        self.sample_freq = self.h5f.get_node_attribute(self.data, 'sampleRateHz')
+        (self.numsamples, self.numchannels) = self.data.shape
+
+    def load_metadata(self):
+        """Loads metadata from .h5 file. Only for internal use."""
+        self.metadata = {}
+        if '/MetaData' in self.h5f:
+            self.metadata = self.h5f.node_to_dict('/MetaData')
+
+
+class TriggerAIAABenchmark(TimeSamplesAIAABenchmark):
+    """Container for tacho data in  `*.h5` format.
+
+    This class loads tacho data from h5 files as specified in
+    "Microphone Array Benchmark b11: Rotating Point Sources"
+    (https://doi.org/10.14279/depositonce-8460)
+    and and provides information about this data.
+    """
+
+    def load_timedata(self):
+        """Loads timedata from .h5 file. Only for internal use."""
+        self.data = self.h5f.get_data_by_reference('TachoData/tachoDataV')
+        self.sample_freq = self.h5f.get_node_attribute(self.data, 'sampleRateHz')
+        (self.numsamples, self.numchannels) = self.data.shape
+
+
+class CsmAIAABenchmark(PowerSpectraImport):
+    """Class to load the CSM that is stored in AIAA Benchmark HDF5 file."""
+
+    #: Full name of the .h5 file with data
+    name = File(filter=['*.h5'], desc='name of data file')
+
+    #: Basename of the .h5 file with data, is set automatically.
+    basename = Property(
+        depends_on='name',
+        desc='basename of data file',
+    )
+
+    #: number of channels
+    numchannels = Property()
+
+    #: HDF5 file object
+    h5f = Instance(H5FileBase, transient=True)
+
+    # internal identifier
+    digest = Property(depends_on=['basename', '_csmsum'])
+
+    @cached_property
+    def _get_digest(self):
+        return digest(self)
+
+    @cached_property
+    def _get_basename(self):
+        return path.splitext(path.basename(self.name))[0]
+
+    @on_trait_change('basename')
+    def load_data(self):
+        """Open the .h5 file and set attributes."""
+        if not path.isfile(self.name):
+            # no file there
+            raise OSError('No such file: %s' % self.name)
+        if self.h5f is not None:
+            try:
+                self.h5f.close()
+            except OSError:
+                pass
+        file = _get_h5file_class()
+        self.h5f = file(self.name)
+
+    # @property_depends_on( 'block_size, ind_low, ind_high' )
+    def _get_indices(self):
+        try:
+            return range(self.fftfreq().shape[0])  # [ self.ind_low: self.ind_high ]
+        except IndexError:
+            return range(0)
+
+    @property_depends_on('digest')
+    def _get_numchannels(self):
+        try:
+            attrs = self.h5f.get_data_by_reference('MetaData/ArrayAttributes')
+            return self.h5f.get_node_attribute(attrs, 'microphoneCount')
+        except IndexError:
+            return 0
+
+    @property_depends_on('digest')
+    def _get_csm(self):
+        """Loads cross spectral matrix from file."""
+        csmre = self.h5f.get_data_by_reference('/CsmData/csmReal')[:].transpose((2, 0, 1))
+        csmim = self.h5f.get_data_by_reference('/CsmData/csmImaginary')[:].transpose((2, 0, 1))
+        csmdatagroup = self.h5f.get_data_by_reference('/CsmData')
+        sign = self.h5f.get_node_attribute(csmdatagroup, 'fftSign')
+        return csmre + sign * 1j * csmim
+
+    def fftfreq(self):
+        """Return the Discrete Fourier Transform sample frequencies.
+
+        Returns
+        -------
+        ndarray
+            Array of length *block_size/2+1* containing the sample frequencies.
+        """
+        return array(self.h5f.get_data_by_reference('/CsmData/binCenterFrequenciesHz')[:].flatten(), dtype=float)
+
+
+class MicAIAABenchmark(MicGeom):
+    """Provides the geometric arrangement of microphones in the array.
+
+    In contrast to standard Acoular microphone geometries, the AIAA
+    benchmark format includes the array geometry as metadata in the
+    file containing the measurement data.
+    """
+
+    #: Name of the .h5-file from wich to read the data.
+    from_file = File(filter=['*.h5'], desc='name of the h5 file containing the microphone geometry')
+
+    @on_trait_change('basename')
+    def import_mpos(self):
+        """Import the microphone positions from .h5 file.
+        Called when :attr:`basename` changes.
+        """
+        if not path.isfile(self.from_file):
+            # no file there
+            raise OSError('No such file: %s' % self.from_file)
+
+        file = _get_h5file_class()
+        h5f = file(self.from_file, mode='r')
+        self.mpos_tot = h5f.get_data_by_reference('MetaData/ArrayAttributes/microphonePositionsM')[:].swapaxes(0, 1)
+        h5f.close()