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

acoular/sources.py

@@ -19,12 +19,13 @@
     MovingLineSource
     UncorrelatedNoiseSource
     SourceMixer
+    PointSourceConvolve
 """
 
 # imports from other packages
 
 from numpy import array, sqrt, ones, empty, newaxis, uint32, arange, dot, int64 ,real, pi, tile,\
-cross, zeros, ceil
+cross, zeros, ceil, repeat
 from numpy import min as npmin
 from numpy import any as npany
 
@@ -45,7 +46,7 @@ from .trajectory import Trajectory
 from .internal import digest, ldigest
 from .microphones import MicGeom
 from .environments import Environment
-from .tprocess import SamplesGenerator
+from .tprocess import SamplesGenerator, TimeConvolve
 from .signals import SignalGenerator
 from .h5files import H5FileBase, _get_h5file_class
 from .tools import get_modes
@@ -1236,7 +1237,10 @@ class UncorrelatedNoiseSource( SamplesGenerator ):
             yield signal[n-num:n,:]
             n += num
         else:
-            yield signal[n-num:,:]
+            if (n-num) < self.numsamples:
+                yield signal[n-num:,:]
+            else:
+                return
 
 
 
@@ -1348,3 +1352,73 @@ class SourceMixer( SamplesGenerator ):
             yield temp
             if sh > temp.shape[0]:
                 break
+
+
+class PointSourceConvolve( PointSource ):
+    """
+    Class to blockwise convolve an arbitrary source signal with a spatial room impulse response
+    """
+
+    #: Convolution kernel in the time domain.
+    #: The second dimension of the kernel array has to be either 1 or match :attr:`~SamplesGenerator.numchannels`.
+    #: If only a single kernel is supplied, it is applied to all channels.
+    kernel = CArray(dtype=float, desc="Convolution kernel.")
+
+    # ------------- overwrite traits that are not supported by this class -------------
+    
+    #: Start time of the signal in seconds, defaults to 0 s.
+    start_t = Enum(0.0,
+        desc="signal start time")
+    
+    #: Start time of the data aquisition at microphones in seconds, 
+    #: defaults to 0 s.
+    start = Enum(0.0,
+        desc="sample start time")
+
+    #: Signal behaviour for negative time indices, i.e. if :attr:`start` < :attr:start_t.
+    #: `loop` take values from the end of :attr:`signal.signal()` array.
+    #: `zeros` set source signal to zero, advisable for deterministic signals.
+    #: defaults to `loop`.
+    prepadding = Enum(None, desc="Behaviour for negative time indices.")
+
+    #: Upsampling factor, internal use, defaults to 16.
+    up = Enum(None, desc="upsampling factor") 
+            
+    # internal identifier
+    digest = Property( 
+        depends_on = ['mics.digest', 'signal.digest', 'loc', 'kernel', '__class__'], 
+        )
+               
+    @cached_property
+    def _get_digest( self ):
+        return digest(self)
+
+    def result(self, num=128):
+        """
+        Python generator that yields the output at microphones block-wise.
+
+        Parameters
+        ----------
+        num : integer, defaults to 128
+            This parameter defines the size of the blocks to be yielded
+            (i.e. the number of samples per block) .
+
+        Returns
+        -------
+        Samples in blocks of shape (num, numchannels). 
+            The last block may be shorter than num.
+        """
+        data = repeat(
+            self.signal.signal()[:,newaxis],self.mics.num_mics,axis=1)
+        source = TimeSamples(
+            data=data,
+            sample_freq=self.sample_freq,
+            numsamples=self.numsamples,
+            numchannels=self.mics.num_mics,
+        )
+        time_convolve = TimeConvolve(
+            source = source,
+            kernel = self.kernel,
+        )
+        for block in time_convolve.result(num):
+            yield block

acoular/spectra.py

@@ -18,8 +18,9 @@
 from warnings import warn
 
 from numpy import array, ones, hanning, hamming, bartlett, blackman, \
-dot, newaxis, zeros, empty, fft, linalg, sqrt,real, imag,\
+dot, newaxis, zeros, empty, linalg, sqrt,real, imag,\
 searchsorted, isscalar, fill_diagonal, arange, zeros_like, sum, ndarray
+from scipy import fft
 from traits.api import HasPrivateTraits, Int, Property, Instance, Trait, \
 Bool, cached_property, property_depends_on, Delegate, Float, Enum, \
     CArray
@@ -658,7 +659,6 @@ class PowerSpectraImport( PowerSpectra ):
 
     #: The cross spectral matrix, 
     #: (number of frequencies, numchannels, numchannels) array of complex;
-    #: readonly.
     csm = Property( 
         desc="cross spectral matrix")
 

acoular/tbeamform.py

@@ -245,13 +245,13 @@ class BeamformerTime( TimeInOut ):
         n_index = arange(0,num+1)[:,newaxis]
         c = self.steer.env.c/self.source.sample_freq
         amp = empty((1,self.grid.size,numMics),dtype=fdtype)
-        delays = empty((1,self.grid.size,numMics),dtype=fdtype)
+        #delays = empty((1,self.grid.size,numMics),dtype=fdtype)
         d_index = empty((1,self.grid.size,numMics),dtype=idtype)
         d_interp2 = empty((1,self.grid.size,numMics),dtype=fdtype)
         _steer_III(self.rm[newaxis,:,:],self.r0[newaxis,:],amp)
-        _delays(self.rm[newaxis,:,:], delays, c, d_interp2, d_index)
+        _delays(self.rm[newaxis,:,:], c, d_interp2, d_index)
         amp.shape = amp.shape[1:]
-        delays.shape = delays.shape[1:]
+        #delays.shape = delays.shape[1:]
         d_index.shape = d_index.shape[1:]
         d_interp2.shape = d_interp2.shape[1:]
         maxdelay = int((self.rm/c).max())+2 + num # +2 because of interpolation
@@ -295,7 +295,7 @@ class BeamformerTime( TimeInOut ):
                     else:
                         powPhi = (Phi[:num]**2).sum(0)
                     imax = argmax(powPhi)
-                    t_float = delays[imax]+n_index
+                    t_float = d_interp2[imax] + d_index[imax] + n_index
                     t_ind = t_float.astype(int64)
                     for m in range(numMics): 
                         p_res[t_ind[:num+1,m],m] -= self.damp*interp(t_ind[:num+1,m],
@@ -485,7 +485,7 @@ class BeamformerTimeTraj( BeamformerTime ):
         blockrm = empty((num,self.grid.size,numMics),dtype=fdtype)
         blockrmconv = empty((num,self.grid.size,numMics),dtype=fdtype)
         amp = empty((num,self.grid.size,numMics),dtype=fdtype)
-        delays = empty((num,self.grid.size,numMics),dtype=fdtype)
+        #delays = empty((num,self.grid.size,numMics),dtype=fdtype)
         d_index = empty((num,self.grid.size,numMics),dtype=idtype)
         d_interp2 = empty((num,self.grid.size,numMics),dtype=fdtype)
         blockr0 = empty((num,self.grid.size),dtype=fdtype)
@@ -521,7 +521,7 @@ class BeamformerTimeTraj( BeamformerTime ):
                 steer_func(blockrmconv, blockr0, amp)
             else:
                 steer_func(blockrm, blockr0, amp)
-            _delays(blockrm, delays, c, d_interp2, d_index)
+            _delays(blockrm, c, d_interp2, d_index)
             #_modf(delays, d_interp2, d_index)
             maxdelay = (d_index.max((1,2)) + arange(0,num)).max()+2 # + because of interpolation
             # increase buffer size because of greater delays
@@ -548,6 +548,11 @@ class BeamformerTimeTraj( BeamformerTime ):
                 else:
                     yield Phi[:num]**2
             else:
+                # choose correct distance
+                if self.conv_amp: 
+                    blockrm1 = blockrmconv
+                else:
+                    blockrm1 = blockrm
                 Gamma = zeros(Phi.shape,dtype=fdtype)
                 Gamma_autopow = zeros(Phi.shape,dtype=fdtype)
                 J = 0
@@ -562,7 +567,9 @@ class BeamformerTimeTraj( BeamformerTime ):
                     # find index of max power focus point
                     imax = argmax(powPhi)
                     # find backward delays
-                    t_float = (delays[:num,imax,m_index]+n_index).astype(fdtype)
+                    t_float = (d_interp2[:num,imax,m_index] + \
+                               d_index[:num,imax,m_index] + \
+                               n_index).astype(fdtype)
                     # determine max/min delays in sample units
                     # + 2 because we do not want to extrapolate behind the last sample
                     ind_max = t_float.max(0).astype(idtype)+2 
@@ -574,7 +581,7 @@ class BeamformerTimeTraj( BeamformerTime ):
                         p_res[ind_min[m]:ind_max[m],m] -= self.damp*interp(
                             t_ind[ind_min[m]:ind_max[m]], 
                             t_float[:num,m],
-                            h/blockrm[:num,imax,m],
+                            h/blockrm1[:num,imax,m],
                                 )
                     nextPhi, nextAutopow = self.delay_and_sum(num,p_res,d_interp2,d_index,amp)
                     if self.r_diag:

acoular/tests/test_beamformer_results.py

@@ -21,7 +21,14 @@ RectGrid, BeamformerBase, BeamformerEig, BeamformerOrth, BeamformerCleansc, \
 MaskedTimeSamples, BeamformerCMF, \
 BeamformerCapon, BeamformerMusic, BeamformerDamas, BeamformerClean, \
 BeamformerFunctional, BeamformerDamasPlus, BeamformerGIB, BeamformerGridlessOrth,\
-SteeringVector, Environment
+SteeringVector, Environment, BeamformerSODIX
+
+# copy CMF classes as workaround so that reference data name is unique later
+class BeamformerCMFLassoLarsBIC (BeamformerCMF):
+    pass
+
+class BeamformerCMFNNLS (BeamformerCMF):
+    pass
 
 # if this flag is set to True
 WRITE_NEW_REFERENCE_DATA = False
@@ -68,14 +75,16 @@ def fbeamformers():
     bm = BeamformerMusic(freq_data=f, steer=st, n=6, cached = False)
     bd = BeamformerDamas(beamformer=bb, n_iter=10, cached = False)
     bdp = BeamformerDamasPlus(beamformer=bb, n_iter=100, cached = False)
-    bo = BeamformerOrth(beamformer=be, eva_list=list(range(38,54)), cached = False)
+    bo = BeamformerOrth(freq_data=f, steer=st, r_diag=True, eva_list=list(range(38,54)), cached = False)
     bs = BeamformerCleansc(freq_data=f, steer=st, r_diag=True, cached = False)
-    bcmf = BeamformerCMF(freq_data=f, steer=st, method='LassoLarsBIC', cached = False)
+    bcmflassobic = BeamformerCMFLassoLarsBIC(freq_data=f, steer=st, method='LassoLarsBIC', cached = False)
+    bcmfnnls = BeamformerCMFNNLS(freq_data=f, steer=st, method='NNLS', cached = False)
     bl = BeamformerClean(beamformer=bb, n_iter=10, cached = False)
     bf = BeamformerFunctional(freq_data=f, steer=st, r_diag=False, gamma=3, cached = False)
     bgib = BeamformerGIB(freq_data=f, steer=st, method= 'LassoLars', n=2, cached = False)
     bgo = BeamformerGridlessOrth(freq_data=f, steer=st, r_diag=False, n=1,  shgo={'n':16}, cached = False)
-    return (bbase, bc, beig, bm, bl, bo, bs, bd, bcmf, bf, bdp, bgib, bgo)
+    bsodix = BeamformerSODIX(freq_data=f, steer=st,max_iter=10, cached = False)
+    return (bbase, bc, beig, bm, bl, bo, bs, bd, bcmflassobic, bcmfnnls, bf, bdp, bgib, bgo,bsodix)
 
 class acoular_beamformer_test(unittest.TestCase):
 
@@ -90,7 +99,7 @@ class acoular_beamformer_test(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-8)
         # we expect the results to be computed and written to cache
         acoular.config.global_caching = 'individual'
         for b in fbeamformers():
@@ -99,7 +108,7 @@ class acoular_beamformer_test(unittest.TestCase):
                 name = join('reference_data',f'{b.__class__.__name__}.npy')
                 actual_data = np.array([b.synthetic(cf,1) for cf in cfreqs],dtype=np.float32)
                 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-8)
         # we expect the results to be read from cache
         acoular.config.global_caching = 'all'
         for b in fbeamformers():
@@ -108,7 +117,7 @@ class acoular_beamformer_test(unittest.TestCase):
                 name = join('reference_data',f'{b.__class__.__name__}.npy')
                 actual_data = np.array([b.synthetic(cf,1) for cf in cfreqs],dtype=np.float32)
                 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-8)
         # we expect the cached results to be overwritten
         acoular.config.global_caching = 'overwrite'
         for b0,b1 in zip(fbeamformers(),fbeamformers()):
@@ -123,7 +132,7 @@ class acoular_beamformer_test(unittest.TestCase):
                 name = join('reference_data',f'{b1.__class__.__name__}.npy')
                 actual_data = np.array([b1.synthetic(cf,1) for cf in cfreqs],dtype=np.float32)
                 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-8)
 
     def test_beamformer_caching(self):
         # within each subcase, we need new beamformer objects because result is not updated when
@@ -174,6 +183,28 @@ class Test_PowerSpectra(unittest.TestCase):
         np.testing.assert_allclose(actual_data, ref_data, rtol=1e-5, atol=1e-8)
 
 
+class TestSteerFormulation(unittest.TestCase):
+
+    def test_all_steer_formulation(self):
+        """ tests all variants of beamformerFreq subroutines
+        """
+        st = SteeringVector(grid=g, mics=m, env=env)
+        b0 = BeamformerBase(freq_data=f, steer=st, cached = False)
+        b1 = BeamformerEig(freq_data=f, steer=st, n=54, cached = False)
+        for ki,kind in enumerate(('classic', 'inverse','true level', 'true location')):
+            st.steer_type = kind
+            for b in (b0,b1):
+                for dr in (True,False):
+                    b.r_diag = dr
+                    with self.subTest(f"{b.__class__.__name__} r_diag:{dr} steer:{kind}"):
+                        name = join('reference_data',f"{b.__class__.__name__}{dr}{ki+1}.npy")
+                        actual_data = np.array([b.synthetic(cf,1) for cf in cfreqs],dtype=np.float32)
+                        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() #exit=False
 

acoular/tests/test_grid.py

@@ -0,0 +1,92 @@
+import unittest
+import acoular as ac
+from copy import deepcopy
+class GridTest(unittest.TestCase):
+   
+    @staticmethod
+    def get_sector_classes():
+        # for later testing condition: sector only includes (0,0,1) point 
+        sectors = [
+            ac.CircSector(x=0,y=0,r=0.2), 
+            ac.RectSector(x_min=-0.2,x_max=0.2,y_min=-0.2,y_max=0.2),
+            ac.RectSector3D(x_min=-0.2,x_max=0.2,y_min=-0.2,y_max=0.2,z_min=1,z_max=1),
+            ac.PolySector(edges=[0.2,0.2,-0.2,0.2,-0.2,-0.2,0.2,-0.2]),
+            ac.ConvexSector(edges=[0.2,0.2,-0.2,0.2,-0.2,-0.2,0.2,-0.2]),            
+            ]
+        multi_sector = ac.MultiSector(sectors=deepcopy(sectors))
+        return sectors + [multi_sector]
+
+    @staticmethod
+    def get_emtpy_sector_classes():
+        # for later testing condition: sector should not cover any grid point
+        off = 10
+        sectors = [
+            ac.CircSector(x=off,y=off,r=0.2, include_border=False, default_nearest=False),
+            ac.RectSector(
+                x_min=-0.2+off,x_max=0.2+off,y_min=-0.2+off,y_max=0.2+off, 
+                include_border=False, default_nearest=False), 
+            ac.RectSector3D(
+                x_min=-0.2+off,x_max=0.2+off,y_min=-0.2+off,y_max=0.2+off,z_min=1+off,z_max=1+off, 
+                include_border=False, default_nearest=False),               
+            ac.PolySector(
+                edges=[0.2+off,0.2+off,-0.2+off,0.2+off,-0.2+off,-0.2+off,0.2+off,-0.2+off], 
+                include_border=False, default_nearest=False),
+            ac.ConvexSector(
+                edges=[0.2+off,0.2+off,-0.2+off,0.2+off,-0.2+off,-0.2+off,0.2+off,-0.2+off], 
+                include_border=False, default_nearest=False)]
+        multi_sector = ac.MultiSector(
+            sectors=deepcopy(sectors))
+        return sectors + [multi_sector]
+
+    @staticmethod
+    def get_rectgrid():
+        return ac.RectGrid(x_min=-1,x_max=1,y_min=-1,y_max=1,z=1,increment=1)
+        
+    @staticmethod
+    def get_rectgrid3D():
+        return ac.RectGrid3D(x_min=-1,x_max=1,y_min=-1,y_max=1,z_min=1, z_max=1,increment=1)
+
+    @staticmethod
+    def get_linegrid():
+        return ac.LineGrid(loc=(-1,0,1), length=2, numpoints=3)
+
+    @staticmethod
+    def get_importgrid():
+        return ac.ImportGrid(gpos_file=GridTest.get_rectgrid().gpos)
+
+    @staticmethod
+    def get_mergegrid():
+        return ac.MergeGrid(grids=[GridTest.get_rectgrid(), GridTest.get_linegrid()])
+    
+    @staticmethod
+    def get_all_grids():
+        for grid in [GridTest.get_rectgrid, GridTest.get_rectgrid3D,
+            GridTest.get_linegrid, GridTest.get_importgrid, GridTest.get_mergegrid]:
+            yield grid()
+
+    def test_size(self):
+        for grid in self.get_all_grids():
+            with self.subTest(grid.__class__.__name__):
+                self.assertEqual(grid.size, grid.gpos.shape[-1])
+
+    def test_existing_subdomain(self):
+        for grid in self.get_all_grids():
+            for sector in self.get_sector_classes():
+                with self.subTest(f"Grid: {grid.__class__.__name__} Sector:{sector.__class__.__name__}"):
+                    indices = grid.subdomain(sector)
+                    self.assertEqual(indices[0].shape[0], 1)
+
+    def test_empty_subdomain(self):
+        for grid in self.get_all_grids():
+            for sector in self.get_emtpy_sector_classes():
+                with self.subTest(f"Grid: {grid.__class__.__name__} Sector:{sector.__class__.__name__}"):
+                    indices = grid.subdomain(sector)
+                    self.assertEqual(indices[0].shape[0], 0)
+                    if hasattr(sector, 'default_nearest'):
+                        sector.default_nearest = True
+                        indices = grid.subdomain(sector)
+                        self.assertEqual(indices[0].shape[0], 1)
+                   
+
+if __name__ == "__main__":
+    unittest.main()

acoular/tests/test_integrate.py

@@ -0,0 +1,102 @@
+import unittest
+import acoular as ac
+ac.config.global_caching = "none"
+import numpy as np
+from test_grid import GridTest
+from functools import partial
+
+class TestIntegrate(unittest.TestCase):
+    
+    f = [1000,2000]
+
+    @staticmethod
+    def get_sector_args():
+        # for later testing condition: sector only includes (0,0,1) point 
+        return {'RectGrid': np.array([0,0,0.2]),
+                'RectGrid3D' : np.array([0,0,1,0,0,1]),}
+
+    def get_beamformer(self, grid):
+        rng1 = np.random.RandomState(1)
+        src_pos = np.array([[0],[0],[1]])
+        mics = ac.MicGeom(mpos_tot=rng1.normal(size=3*5).reshape((3,5)))
+        steer = ac.SteeringVector(
+                        grid=ac.ImportGrid(
+                            gpos_file=src_pos), 
+                        mics=mics)
+        H = np.empty((len(self.f),mics.num_mics, 1),dtype=complex)
+        for i,_f in enumerate(self.f): # calculate only the indices that are needed
+            H[i] = steer.transfer(_f).T # transfer functions
+        csm = H@H.swapaxes(2,1).conjugate()
+        freq_data = ac.PowerSpectraImport(csm = csm, frequencies=self.f)
+        steer.grid = grid
+        return ac.BeamformerBase(freq_data=freq_data, steer=steer)
+
+    def test_sector_class_integration_functional(self):
+        for sector in GridTest.get_sector_classes():
+            for grid in GridTest.get_all_grids():
+                bf = self.get_beamformer(grid)
+                with self.subTest(
+                    f"Grid: {grid.__class__.__name__} Sector: {sector.__class__.__name__}"):
+                    for i,f in enumerate(self.f):
+                        bf_res = bf.synthetic(f)
+                        bf_max = bf_res.max()
+                        integration_res = ac.integrate(
+                            data=bf_res,sector=sector,grid=grid)
+                        self.assertEqual(integration_res.shape, ())
+                        self.assertEqual(integration_res, bf_max)
+
+    def test_sector_class_integration_class(self):
+        for sector in GridTest.get_sector_classes():
+            for grid in GridTest.get_all_grids():
+                bf = self.get_beamformer(grid)
+                with self.subTest(
+                    f"Grid: {grid.__class__.__name__} Sector:{sector.__class__.__name__}"):                   
+                    for i,f in enumerate(self.f):
+                        bf_res = bf.synthetic(f)
+                        bf_max = bf_res.max()
+                        integration_res = bf.integrate(sector)
+                        self.assertEqual(integration_res.shape, (len(self.f),))
+                        self.assertEqual(integration_res[i], bf_max)
+
+    def test_sector_args_integration_functional(self):
+        for grid in GridTest.get_all_grids():
+            bf = self.get_beamformer(grid)
+            with self.subTest(
+                f"Grid: {grid.__class__.__name__}"):                   
+                for i,f in enumerate(self.f):
+                    sector = self.get_sector_args().get(grid.__class__.__name__)
+                    bf_res = bf.synthetic(f)
+                    bf_max = bf_res.max()
+                    if sector is None: # not allowed grid for simple sector args
+                        sector = np.array([0,0,0.2]) # some random circ sector arguments
+                        integrate = partial(
+                            ac.integrate, data=bf_res, grid=grid, sector=sector)
+                        self.assertRaises(NotImplementedError, integrate)
+                    else:
+                        integration_res = ac.integrate(
+                            data=bf_res,sector=sector,grid=grid)
+                        self.assertEqual(integration_res.shape, ())
+                        self.assertEqual(integration_res, bf_max)
+
+    def test_sector_args_integration_class(self):
+        for grid in GridTest.get_all_grids():
+            bf = self.get_beamformer(grid)
+            with self.subTest(
+                f"Grid: {grid.__class__.__name__}"):                   
+                for i,f in enumerate(self.f):
+                    sector = self.get_sector_args().get(grid.__class__.__name__)
+                    bf_res = bf.synthetic(f)
+                    bf_max = bf_res.max()
+                    if sector is None: # not allowed grid for simple sector args
+                        sector = np.array([0,0,0.2]) # some random circ sector arguments
+                        integrate = partial(
+                            bf.integrate, sector=sector)
+                        self.assertRaises(NotImplementedError, integrate)
+                    else:
+                        integration_res = bf.integrate(sector)
+                        self.assertEqual(integration_res.shape, (len(self.f),))
+                        self.assertEqual(integration_res[i], bf_max)  
+
+if __name__ == "__main__":
+
+    unittest.main()