acoular 23.6__py3-none-any.whl → 24.3__py3-none-any.whl

acoular/tests/test_tprocess.py

@@ -1,4 +1,6 @@
 import unittest
+from os.path import join
+import re
 import numpy as np
 from acoular import (
     config,
@@ -6,11 +8,46 @@ from acoular import (
     WNoiseGenerator,
     PointSource,
     MicGeom,
+    MaskedTimeSamples,
     tools
 )
+from acoular.tprocess import *
+
+WRITE_NEW_REFERENCE_DATA = False
 
 config.global_caching = "none"
+datafile = join('..','..','examples','example_data.h5')
+t1 = MaskedTimeSamples(name=datafile)
+t1.start = 0 # first sample, default
+t1.stop = 500 # last valid sample = 15999
+invalid = list(range(4,64)) # list of invalid channels 
+t1.invalid_channels = invalid # use four channels
+
+# these are tested 
+test_list = (
+    "TimeInOut()",
+    "TimePower()",
+    "TimeAverage()",
+    "TimeCumAverage()",
+    "TimeReverse()",
+    "Filter()",
+    "FiltFiltOctave(band = 100.0, fraction = 'Third octave')",
+    "FiltFiltOctave()",
+    "FiltOctave(band = 100.0, fraction = 'Third octave')",
+    "FiltOctave()",
+    "TimeExpAverage(weight = 'F')",
+    "TimeExpAverage(weight = 'S')",
+    "TimeExpAverage(weight = 'I')",
+    "FiltFreqWeight(weight = 'A')",
+    "FiltFreqWeight(weight = 'C')",
+    "FiltFreqWeight(weight = 'Z')",
+    "OctaveFilterBank()"
+)
 
+def fname(s):
+    """converts string to file name removing unsafe characters"""
+    s1 = re.sub(r'[,.()=]', '_', s)
+    return re.sub(r'[/\\:*?"<>|\' ]', '', s1)
 
 class TprocessTest(unittest.TestCase):
     """
@@ -34,5 +71,20 @@ class TprocessTest(unittest.TestCase):
             REF = np.convolve(np.squeeze(KERNEL), np.squeeze(SIG[:,i]))
             np.testing.assert_allclose(np.squeeze(RES[:,i]), REF, rtol=1e-5, atol=1e-8)
 
+    #@unittest.skip
+    def test_tprocess_results(self):
+        """compare results with reference results"""
+        for s in test_list:
+            b = eval(s)
+            with self.subTest(s):
+                name = join('reference_data',f'{fname(s)}.npy')
+                b.source = t1
+                # compute with block size 64 and add some extra 
+                actual_data = tools.return_result(b, nmax=70, num=64)
+                if WRITE_NEW_REFERENCE_DATA:
+                    np.save(name,actual_data)
+                ref_data = np.load(name)
+                np.testing.assert_allclose(actual_data, ref_data, rtol=1e-5, atol=1e-8)
+
 if __name__ == "__main__":
     unittest.main()

acoular/tests/test_traj_beamformer_results.py

@@ -145,7 +145,7 @@ class BeamformerTimeTest(unittest.TestCase):
                 if WRITE_NEW_REFERENCE_DATA:
                     np.save(name,actual_data)
                 ref_data = np.load(name)
-                np.testing.assert_allclose(actual_data, ref_data, rtol=1e-5, atol=1e-8)
+                np.testing.assert_allclose(actual_data, ref_data, rtol=5e-5, atol=5e-6)
 
     def test_beamformer_time_result(self):
         """compare results of time beamformers with fixed focus against previous
@@ -157,7 +157,7 @@ class BeamformerTimeTest(unittest.TestCase):
                 if WRITE_NEW_REFERENCE_DATA:
                     np.save(name,actual_data)
                 ref_data = np.load(name)
-                np.testing.assert_allclose(actual_data, ref_data, rtol=1e-5, atol=1e-8)
+                np.testing.assert_allclose(actual_data, ref_data, rtol=5e-5, atol=5e-6)
 
     
 if __name__ == '__main__':

acoular/tfastfuncs.py

@@ -13,14 +13,11 @@ import numpy as np
 cachedOption = True  # if True: saves the numba func as compiled func in sub directory
 fastOption = True # fastmath options 
 
-@nb.njit([(nb.float64[:,:], nb.int64[:,:], nb.float64[:,:], nb.float64[:,:], nb.float64[:,:], nb.float64[:,:])],
+@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
-    
-    **Note**: parallel could be set to true, but unless the number of gridpoints gets huge, it
-    will be _slower_ in parallel mode
-    
+      
     Parameters
     ----------
     data : float64[nSamples, nMics] 
@@ -38,26 +35,25 @@ def _delayandsum4(data, offsets, ifactor2, steeramp, out, autopower):
     """
     gridsize, numchannels = offsets.shape
     num = out.shape[0]
+    ZERO = data.dtype.type(0.)
+    ONE = data.dtype.type(1.)    
     for n in nb.prange(num):
         for gi in nb.prange(gridsize):
-            out[n,gi] = 0
-            autopower[n,gi] = 0
+            out[n,gi] = ZERO
+            autopower[n,gi] = ZERO
             for mi in range(numchannels):
-                ind = offsets[gi,mi]
-                r = (data[ind+n,mi] * (1-ifactor2[gi,mi]) \
-                    + data[ind+n+1,mi] * ifactor2[gi,mi]) * steeramp[gi,mi]
+                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[:,:], nb.int32[:,:,:], nb.float32[:,:,:], nb.float32[:,:,:], nb.float32[:,:], nb.float32[:,:]),
-            (nb.float64[:,:], nb.int64[:,:,:], nb.float64[:,:,:], nb.float64[:,:,:], nb.float64[:,:], nb.float64[:,:])],
+@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
-    
-    **Note**: parallel could be set to true, but unless the number of gridpoints gets huge, it
-    will be _slower_ in parallel mode
-    
+        
     Parameters
     ----------
     data : float64[nSamples, nMics] 
@@ -75,13 +71,15 @@ def _delayandsum5(data, offsets, ifactor2, steeramp, out, autopower):
     """
     num, gridsize, numchannels = offsets.shape
     num = out.shape[0]
+    #ZERO = data.dtype.type(0.)
+    ONE = data.dtype.type(1.)
     for n in nb.prange(num):
         for gi in nb.prange(gridsize):
             out[n,gi] = 0
             autopower[n,gi] = 0
             for mi in range(numchannels):
-                ind = offsets[n,gi,mi] + n
-                r = (data[ind,mi] * (1-ifactor2[n,gi,mi]) \
+                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 
@@ -145,18 +143,19 @@ def _steer_IV(rm, r0, amp):
             for mi in nb.prange(numchannels):
                 amp[n,gi,mi] = np.divide(Nr,rm[n,gi,mi]*rm2)
 
-@nb.njit([(nb.float32[:,:,:],  nb.float32[:,:,:], nb.float32, nb.float32[:,:,:], nb.int32[:,:,:]),
-            (nb.float64[:,:,:],  nb.float64[:,:,:], nb.float64, nb.float64[:,:,:], nb.int64[:,:,:])],
+@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, delays, c, interp2, index):
+def _delays(rm, c, interp2, index):
     num, gridsize, numchannels = rm.shape
+    invc = 1/c
+    intt = index.dtype.type
     for n in nb.prange(num):  
         for gi in nb.prange(gridsize):
             for mi in nb.prange(numchannels):
-                delays[n,gi,mi] = np.divide(rm[n,gi,mi],c)
-                index[n,gi,mi] = int(delays[n,gi,mi])
-                interp2[n,gi,mi] = delays[n,gi,mi] - index[n,gi,mi]
-
+                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[:,:,:])],

acoular/tools.py

@@ -9,6 +9,7 @@ Implements tools for Acoular.
 .. autosummary::
     :toctree: generated/
     
+    MetricEvaluator
     return_result
     spherical_hn1
     get_radiation_angles
@@ -17,13 +18,154 @@ Implements tools for Acoular.
     bardata
 """
 
-from traits.api import HasStrictTraits
-from numpy import array, concatenate, newaxis, where,arctan2,sqrt,pi,mod,zeros,complex128
+import acoular as ac
+from numpy import array, concatenate, newaxis, where,arctan2,sqrt,pi,mod,zeros,\
+    complex128, ones, inf, minimum, empty
 from numpy.linalg import norm
 from numpy.ma import masked_where
 from .spectra import synthetic
+from traits.api import Bool, CArray, HasPrivateTraits, Instance, Property, Any
 
 from scipy.special import spherical_yn, spherical_jn, sph_harm
+from scipy.spatial.distance import cdist
+from copy import copy
+
+class MetricEvaluator(HasPrivateTraits):
+    """Evaluate the reconstruction performance of source mapping methods.
+
+    This class can be used to calculate the following performance metrics
+    according to Herold and Sarradj (2017):
+    * Specific level error
+    * Overall level error
+    * Inverse level error
+    """
+
+    #: an array of shape=(nf,ng) containing the squared sound pressure data of the   
+    #: source mapping. (nf: number of frequencies, ng: number of grid points)
+    data = CArray(shape=(None,None),
+        desc="Contains the calculated squared sound pressure values in Pa**2.")
+
+    #: an array of shape=(nf,ns) containing the squared sound pressure data of the
+    #: ground-truth sources. (nf: number of frequencies, ns: number of sources)
+    target_data = CArray(shape=(None,None),
+        desc="Contains the ground-truth squared sound pressure values in Pa**2.")
+
+    #: :class:`~acoular.grids.Grid`-derived object that provides the grid locations
+    #: for the calculated source mapping data.
+    grid = Instance(ac.Grid,
+        desc="Grid instance that belongs to the calculated data")
+
+    #: :class:`~acoular.grids.Grid`-derived object that provides the grid locations
+    #: for the ground-truth data.
+    target_grid = Instance(ac.Grid,
+        desc="Grid instance that belongs to the ground-truth data")
+
+    #: sector type. Currently only circular sectors are supported.
+    sector = Instance(ac.CircSector, default=ac.CircSector(),)
+
+    #: if set True: use shrink integration area if two sources are closer
+    #: than 2*r. The radius of the integration area is then set to half the
+    #: distance between the two sources.
+    adaptive_sector_size = Bool(True,
+        desc="adaptive integration area")
+
+    #: if set `True`, the same amplitude can be assigned to multiple targets if
+    #: the integration area overlaps. If set `False`, the amplitude is assigned
+    #: to the first target and the other targets are ignored.
+    multi_assignment = Bool(True,
+        desc="if set True, the same amplitude can be assigned to multiple targets if the integration area overlaps")
+
+    #: returns the determined sector sizes for each ground-truth source position
+    sectors = Property()
+
+    def _validate_shapes(self):
+        if self.data.shape[0] != self.target_data.shape[0]:
+            raise ValueError("data and target_data must have the same number of frequencies!")
+        if self.data.shape[1] != self.grid.size:
+            raise ValueError("data and grid must have the same number of grid points!")
+        if self.target_data.shape[1] != self.target_grid.size:
+            raise ValueError("target_data and target_grid must have the same number of grid points!")
+
+    def _get_sector_radii(self):
+        ns = self.target_data.shape[1]
+        radii = ones(ns)*self.sector.r
+        if self.adaptive_sector_size:
+            locs = self.target_grid.gpos.T
+            intersrcdist = cdist(locs, locs)
+            intersrcdist[intersrcdist == 0] = inf
+            intersrcdist = intersrcdist.min(0)/2
+            radii = minimum(radii,intersrcdist)
+        return radii
+
+    def _get_sectors(self):
+        """Returns a list of CircSector objects for each target location."""
+        r = self._get_sector_radii()
+        ns = self.target_data.shape[1]
+        sectors = []
+        for i in range(ns):
+            loc = self.target_grid.gpos[:,i]
+            sector = copy(self.sector)
+            sector.r = r[i]
+            sector.x = loc[0]
+            sector.y = loc[1]
+            sectors.append(sector)
+        return sectors
+
+    def _integrate_sectors(self):
+        """Integrates over target sectors.
+
+        Returns
+        -------
+        array (num_freqs,num_sources)
+            returns the integrated Pa**2 values for each sector
+        """
+        sectors = self.sectors
+        results = empty(shape=self.target_data.shape)
+        for f in range(self.target_data.shape[0]):
+            data = self.data[f]
+            for i in range(self.target_data.shape[1]):
+                sector = sectors[i]
+                results[f,i] = ac.integrate(data,self.grid,sector)
+                if not self.multi_assignment:
+                    indices = self.grid.subdomain(sector)
+                    data[indices] = 0 # set values to zero (can not be assigned again)
+        return results
+
+    def get_overall_level_error(self):
+        """Returns the overall level error (Herold and Sarradj, 2017).
+
+        Returns
+        -------
+        numpy.array
+            overall level error of shape=(nf,)
+        """
+        self._validate_shapes()
+        return ac.L_p(self.data.sum(axis=1)) - ac.L_p(self.target_data.sum(axis=1))
+
+    def get_specific_level_error(self):
+        """Returns the specific level error (Herold and Sarradj, 2017).
+
+        Returns
+        -------
+        numpy.array
+            specific level error of shape=(nf,ns). nf: number of frequencies, ns: number of sources
+        """
+        self._validate_shapes()
+        sector_result = self._integrate_sectors()
+        return ac.L_p(sector_result) - ac.L_p(self.target_data)
+
+    def get_inverse_level_error(self):
+        """Returns the inverse level error (Herold and Sarradj, 2017).
+
+        Returns
+        -------
+        numpy.array
+            inverse level error of shape=(nf,1)
+        """
+        self._validate_shapes()
+        sector_result = self._integrate_sectors()
+        return ac.L_p(sector_result.sum(axis=1)) - ac.L_p(self.data.sum(axis=1))
+
 
 
 def return_result(source, nmax=-1, num=128):