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

acoular/tests/test_example1.py

@@ -1,124 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on Thu Jan 24 09:58:04 2019
-
-@author: newuser
-"""
-#standard testing suite from python
-import unittest
-
-#acoular imports
-import acoular
-
-from acoular import L_p, Calib, MicGeom, PowerSpectra, Environment, \
-RectGrid, BeamformerBase, BeamformerEig, BeamformerOrth, BeamformerCleansc, \
-MaskedTimeSamples, FiltFiltOctave, BeamformerTimeSq, TimeAverage, \
-TimeCache, BeamformerTime, TimePower, BeamformerCMF, \
-BeamformerCapon, BeamformerMusic, BeamformerDamas, BeamformerClean, \
-BeamformerFunctional, BeamformerDamasPlus, BeamformerGIB, SteeringVector
-
-from numpy import zeros, empty
-from os import path
-import tables
-
-#load numerical values from Examples
-h5file_num = tables.open_file('reference_data/Example1_numerical_values_testsum.h5', 'r')
-
-mpos_num = h5file_num.get_node('/mpos_values').read()
-grid_pos_num = h5file_num.get_node('/grid_pos_values').read()
-transfer_num = h5file_num.get_node('/transfer_values').read()
-csm_num = h5file_num.get_node('/csm_values').read()
-eve_num = h5file_num.get_node('/eva_values').read()
-eva_num = h5file_num.get_node('/eve_values').read()
-
-d={}
-for b in ('bb', 'bc', 'be', 'bm', 'bl', 'bo', 'bs', 'bd', 'bcmf', 'bf', 'bdp', 'bgib'):
-    d[b+'num'] = h5file_num.get_node('/'+str(b)+'_values').read()
-
-
-#load exampledata
-datafile = '../../examples/example_data.h5'
-calibfile = '../../examples/example_calib.xml'
-micgeofile = path.join( path.split(acoular.__file__)[0],'xml','array_56.xml')
-
-#calc all values from example 1
-cfreq = 4000
-t1 = MaskedTimeSamples(name= datafile)
-t1.start = 0 # first sample, default
-t1.stop = 16000 # last valid sample = 15999
-invalid = [1,7] # list of invalid channels (unwanted microphones etc.)
-t1.invalid_channels = invalid 
-t1.calib = Calib(from_file=calibfile)
-m = MicGeom(from_file=micgeofile)
-m.invalid_channels = invalid
-
-g = RectGrid(x_min=-0.6, x_max=-0.0, y_min=-0.3, y_max=0.3, z=0.68,
-             increment=0.05 )
-
-env=Environment(c=346.04)
-
-st = SteeringVector(grid=g, mics=m, env=env)
-
-f = PowerSpectra(time_data=t1, 
-               window='Hanning', overlap='50%', block_size=128, #FFT-parameters
-               cached = False )  #cached = False
-
-
-bb = BeamformerBase(freq_data=f, steer=st, r_diag=True, cached = False)
-bc = BeamformerCapon(freq_data=f, steer=st, cached=False)
-be = BeamformerEig(freq_data=f, steer=st, r_diag=True, n=54, cached = False)
-bm = BeamformerMusic(freq_data=f, steer=st, n=6, cached = False)
-bd = BeamformerDamas(beamformer=bb, n_iter=100, cached = False)
-bdp = BeamformerDamasPlus(beamformer=bb, n_iter=100, cached = False)
-bo = BeamformerOrth(beamformer=be, 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)
-bl = BeamformerClean(beamformer=bb, n_iter=100, cached = False)
-bf = BeamformerFunctional(freq_data=f, steer=st, r_diag=False, gamma=4, cached = False)
-bgib = BeamformerGIB(freq_data=f, steer=st, method= 'LassoLars', n=10, cached = False)
-
-class acoular_test(unittest.TestCase):  
-    
-    #test if microfon positions are correct
-    def test_mic_positions(self):
-        self.assertAlmostEqual(m.mpos.sum()/mpos_num.sum(),1,3) 
-    
-    #test if grid points are correct
-    def test_grid_positions(self):
-        self.assertAlmostEqual(g.gpos.sum()/grid_pos_num.sum(),1,3) 
-        
-    #test steering vector calculation
-    def test_steering(self):
-        ind=0
-        checktrans=0
-        for freq in f.fftfreq()[1:-1]:
-            checktrans=checktrans+st.transfer(freq)
-            ind+=1
-        self.assertAlmostEqual(checktrans.sum()/transfer_num.sum(),1,3)             
-        
-    #test if csm values are correct
-    @unittest.skip
-    def test_csm_calculation(self):
-        self.assertAlmostEqual(f.csm[:].sum()/csm_num.sum(),1,3)    
-        
-    #test eve/eva
-    @unittest.skip    
-    def test_eigenvalue_calculation(self):
-        self.assertAlmostEqual(f.eva[:].sum()/eve_num.sum(),1,3)
-        print(f.eve[:].sum(),eva_num)      
-        self.assertAlmostEqual(f.eve[:].sum()/eva_num.sum(),1,3) 
-     
-    #test beamformer results
-    @unittest.skip  
-    def test_beamformer_calculation(self):
-        for beam,bfname in zip((bb, bc, be, bm, bl, bo, bs, bd, bcmf, bf, bdp, bgib),('bb', 'bc', 'be', 'bm', 'bl', 'bo', 'bs', 'bd', 'bcmf', 'bf', 'bdp', 'bgib')):   
-            with self.subTest(bfname):
-                self.assertAlmostEqual(beam.synthetic(cfreq,1).sum()/d[bfname+'num'].sum(),1,3)      
-            
-if "__main__" == __name__:
-    unittest.main() #exit=False
-
-
-                            
-        

acoular/tests/test_grid.py

@@ -1,92 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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()

acoular/tests/test_signals.py

@@ -1,60 +0,0 @@
-import unittest
-from acoular import FiltWNoiseGenerator
-from numpy.random import RandomState
-from numpy import array
-#from parameterized import parameterized
-
-# some FIR/MA filter coefficients of a low pass
-MA_COEFF = array([-1.43784223e-04, -8.36125348e-05,  1.19173505e-04,  4.25496657e-04,
-        6.94633526e-04,  7.24177306e-04,  3.49521545e-04, -4.34584932e-04,
-       -1.39563577e-03, -2.09179948e-03, -2.03164747e-03, -9.23555283e-04,
-        1.09077195e-03,  3.35008833e-03,  4.82910680e-03,  4.53234580e-03,
-        1.99921968e-03, -2.29961235e-03, -6.90182084e-03, -9.75295479e-03,
-       -9.00084038e-03, -3.91590949e-03,  4.45649391e-03,  1.32770185e-02,
-        1.86909952e-02,  1.72542180e-02,  7.54398817e-03, -8.67689478e-03,
-       -2.63091689e-02, -3.80338221e-02, -3.64895345e-02, -1.68613380e-02,
-        2.10120036e-02,  7.18301706e-02,  1.25749185e-01,  1.70866876e-01,
-        1.96551032e-01,  1.96551032e-01,  1.70866876e-01,  1.25749185e-01,
-        7.18301706e-02,  2.10120036e-02, -1.68613380e-02, -3.64895345e-02,
-       -3.80338221e-02, -2.63091689e-02, -8.67689478e-03,  7.54398817e-03,
-        1.72542180e-02,  1.86909952e-02,  1.32770185e-02,  4.45649391e-03,
-       -3.91590949e-03, -9.00084038e-03, -9.75295479e-03, -6.90182084e-03,
-       -2.29961235e-03,  1.99921968e-03,  4.53234580e-03,  4.82910680e-03,
-        3.35008833e-03,  1.09077195e-03, -9.23555283e-04, -2.03164747e-03,
-       -2.09179948e-03, -1.39563577e-03, -4.34584932e-04,  3.49521545e-04,
-        7.24177306e-04,  6.94633526e-04,  4.25496657e-04,  1.19173505e-04,
-       -8.36125348e-05, -1.43784223e-04])
-
-# some IIR/AR coefficients
-AR_COEFF = array([1, -0.20514344, -0.00257561,  0.04522058,  0.01972377, -0.04087183,
-        -0.05474943, -0.02935448, -0.00917827, -0.02703312, -0.04541416,
-        -0.01972302,  0.04305152,  0.07187778,  0.02216658, -0.07962289])
-
-
-class Test_FiltWNoiseGenerator(unittest.TestCase):
-
-    def setUp(self):
-        self.fwn = FiltWNoiseGenerator(sample_freq=100,numsamples=400,seed=1) 
-
-    def test_no_coefficients(self):
-        """test that white noise and filtered white noise is equal when no coefficients are
-        specified"""
-        wn_signal = RandomState(seed=1).standard_normal(400)
-        signal = self.fwn.signal()
-        self.assertEqual(wn_signal.sum(),signal.sum())
-
-    # @parameterized.expand([ 
-    #     [MA_COEFF,array([]),400],
-    #     [array([]),AR_COEFF,400]
-    # ])
-    def test_correct_signal_length(self):
-        """test that signal retains correct length after filtering"""
-        parameters = [(MA_COEFF,array([]),400),(array([]),AR_COEFF,400)]     
-        for ma,ar,expected_length in parameters: 
-            self.fwn.ar=ar
-            self.fwn.ma=ma
-            self.assertEqual(self.fwn.signal().shape[0],expected_length)
-
-if __name__ == '__main__':
-    unittest.main()
-

acoular/tests/test_sources.py

@@ -1,65 +0,0 @@
-import unittest
-from os.path import join
-import numpy as np
-from acoular import __file__ as bpath, config, WNoiseGenerator, PointSource, MicGeom
-
-config.global_caching = "none"
-
-# if this flag is set to True, new data will be simulated and
-WRITE_NEW_REFERENCE_DATA = False
-# new source results are generated for comparison during testing. Should always be False. Only set to
-# true, if it is necessary to recalculate the data, due to wanted changes of the sources.
-
-# Parameters
-SFREQ = 1000
-SEED = 1
-NSAMPLES = 100
-N1 = WNoiseGenerator(sample_freq=SFREQ, numsamples=NSAMPLES, seed=SEED)
-MGEOM = MicGeom(mpos_tot=[[1],[1],[1]])
-
-
-def get_source_result(Source, num=32):
-    """
-    returns the result for a given source
-
-    Parameters
-    ----------
-    source : cls
-        source class that is tested.
-    num : int, optional
-        number of samples to return. The default is 32.
-
-    Returns
-    -------
-    array
-        first block returned by the source result() function.
-
-    """
-    if Source == PointSource:
-        source = Source(signal=N1, mics=MGEOM)
-
-    return next(source.result(num)).astype(np.float32)
-
-
-class SourcesTest(unittest.TestCase):
-    """
-    A simple test case that verifies that the results of sources are not changing across different versions of code.
-    """
-
-    sources = [PointSource]
-
-    def test_sources_result(self):
-        """compare results of sources against previous
-        results from .npy file"""
-        for source in self.sources:
-            with self.subTest(source.__name__):
-                name = join("reference_data", f"{source.__name__}.npy")
-                actual_data = get_source_result(source)
-                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_spectra.py

@@ -1,38 +0,0 @@
-
-from os import path
-import numpy as np
-import acoular
-import unittest
-
-rng = np.random.RandomState(2)
-# test array
-#np.abs(np.imag(ps.csm)).sum() + np.real(ps.csm).sum()
-csm_sum = 0.5613882842200368
-fft_sum = 0.3690552444079589+0.05264645224899272j
-
-mg = acoular.MicGeom( mpos_tot=rng.normal(0,1,3*2).reshape(3,2))
-sig = acoular.WNoiseGenerator(seed=1,numsamples=1010,sample_freq=1000)
-p = acoular.PointSource(signal=sig,loc=(0,0,0),mics=mg)
-ps = acoular.PowerSpectra( source=p, block_size=128, window='Hanning',cached=False )
-fft = acoular.FFTSpectra(source=p,window='Hanning',block_size=128)
-
-class Test_PowerSpectra(unittest.TestCase):
-
-    def test_calc_csm(self):
-        """ test that csm result has not changed over different releases"""
-        test_csm_sum = np.abs(np.imag(ps.csm)).sum() + np.real(ps.csm).sum()
-        self.assertAlmostEqual(test_csm_sum,csm_sum)
-
-class Test_FFTSpectra(unittest.TestCase):
-
-    def test_calc_fft(self):
-        """ test that fft result has not changed over different releases"""
-        test_fft_sum = 0
-        for temp in fft.result():
-            test_fft_sum += temp.sum()
-        self.assertAlmostEqual(test_fft_sum,fft_sum)
-
-
-if __name__ == '__main__':
-    unittest.main()
-

acoular/tests/test_timecache.py

@@ -1,35 +0,0 @@
-from acoular import *
-import numpy as np
-from acoular import __file__ as bpath
-from os import path
-import unittest
-
-# load some array geometry
-micgeofile = path.join(path.split(bpath)[0], 'xml', 'array_64.xml')
-micgeom = MicGeom(from_file=micgeofile)
-
-num_samples = 7
-block_size = 5
-
-class TimeCacheTest(unittest.TestCase):
-    global_caching_configs= ['individual','all','none','readonly','overwrite']
-    def test_valid_cache_result(self):
-        """
-        manually create an incomplete cash file and then read it 
-        """
-        for conf in self.global_caching_configs:
-            config.global_caching= conf
-            with self.subTest(conf):
-                sig = WNoiseGenerator(numsamples=num_samples)
-                ps = PointSource(signal=sig, mics=micgeom)
-                tc = TimeCache(source=ps)
-                for i,(block_c, block_nc) in enumerate(zip(tc.result(block_size), ps.result(block_size))):
-                    np.testing.assert_array_almost_equal(block_c,block_nc)
-                    if i == 0: break
-      
-                for (block_c, block_nc) in zip(tc.result(block_size), ps.result(block_size)):
-                    np.testing.assert_array_almost_equal(block_c,block_nc)
-
-
-if __name__=="__main__":
-    unittest.main()

acoular/tests/test_tprocess.py

@@ -1,90 +0,0 @@
-import unittest
-from os.path import join
-import re
-import numpy as np
-from acoular import (
-    config,
-    TimeConvolve,
-    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):
-    """
-    A simple test case that verifies that the results of tprocess are not changing across different versions of code.
-    """
-
-    def test_timeconvolve(self):
-        """compare results of timeconvolve with numpy convolve"""
-        # Parameters
-        NSAMPLES = 25
-        N1 = WNoiseGenerator(sample_freq=1000, numsamples=NSAMPLES, seed=1)
-        MGEOM = MicGeom(mpos_tot=[[1], [1], [1]])
-        P1 = PointSource(signal=N1, mics=MGEOM)
-        KERNEL = np.random.rand(20)
-        CONV = TimeConvolve(kernel=KERNEL, source=P1)
-
-        SIG = tools.return_result(P1, num=NSAMPLES)
-        RES = tools.return_result(CONV, num=100)
-        
-        for i in range(P1.numchannels):
-            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()