class SaveTests(unittest.TestCase):
    def setUp(self):
        self.s = Signal()
        self.x = np.array([0, 1, 2, 3])
        self.y = np.array([0, 1, 0, -1])
        self.s.load_nparray([0, 1, 0, -1], 'signal', 'm', 1)
        self.s.fft()
        self.s.freq_filter_Hilbert_complex()
        self.s.ifft()
        self.s.f.attrs['two'] = 2  # test attribute to verify attrs copied
        self.f_dst = h5py.File('.test2.h5', backing_store=False, driver='core')

    def test_save_pass_list_datasets(self):
        self.s.save(self.f_dst, ['x', 'y'])
        assert_array_equal(self.f_dst['x'][:], self.x)
        assert_array_equal(self.f_dst['y'][:], self.y)
        self.assertEqual(self.f_dst.attrs['two'], 2)

    def test_save_pass_string(self):
        self.s.save(self.f_dst, 'input')
        assert_array_equal(self.f_dst['x'][:], self.x[:])
        assert_array_equal(self.f_dst['y'][:], self.y)
        self.assertEqual(self.f_dst.attrs['two'], 2)

    def tearDown(self):
        self.f_dst.close()
        self.s.close()
Exemple #2
0
class SaveTests(unittest.TestCase):
    def setUp(self):
        self.s = Signal()
        self.x = np.array([0, 1, 2, 3])
        self.y = np.array([0, 1, 0, -1])
        self.s.load_nparray([0, 1, 0, -1], 'signal', 'm', 1)
        self.s.fft()
        self.s.freq_filter_Hilbert_complex()
        self.s.ifft()
        self.s.f.attrs['two'] = 2  # test attribute to verify attrs copied
        self.f_dst = h5py.File('.test2.h5', backing_store=False, driver='core')

    def test_save_pass_list_datasets(self):
        self.s.save(self.f_dst, ['x', 'y'])
        assert_array_equal(self.f_dst['x'][:], self.x)
        assert_array_equal(self.f_dst['y'][:], self.y)
        self.assertEqual(self.f_dst.attrs['two'], 2)

    def test_save_pass_string(self):
        self.s.save(self.f_dst, 'input')
        assert_array_equal(self.f_dst['x'][:], self.x[:])
        assert_array_equal(self.f_dst['y'][:], self.y)
        self.assertEqual(self.f_dst.attrs['two'], 2)

    def tearDown(self):
        self.f_dst.close()
        self.s.close()
class FFTTests(unittest.TestCase):
    
    def setUp(self):
        """
        Create an trial *Signal* object
        """
        
        fd = 50.0E3    # digitization frequency
        f0 = 5.00E3    # signal frequency
        nt = 512     # number of signal points    

        self.dt = dt = 1/fd
        t = dt*np.arange(nt)
        s = 1.0*np.sin(2*np.pi*f0*t) 

        self.s = Signal('.FFTTests_1.h5')
        self.s.load_nparray(s,"x","nm",dt)
        self.s.time_mask_binarate("middle")
        self.s.time_window_cyclicize(10*dt)
        self.s.fft()
        self.s.freq_filter_Hilbert_complex()
        
    def testfft_1(self):
        """FFT: test that the resulting data is complex"""
        
        first_point = self.s.f['workup/freq/FT'][0]
        self.assertEqual(isinstance(first_point, complex),True)
        
    def testfft_2(self):
        """FFT: test that the complex Hilbert transform filter is real"""
        
        first_point = self.s.f['workup/freq/filter/Hc'][0]
        self.assertEqual(isinstance(first_point, complex),False)
        
    def testfft_3(self):
        """FFT: test the complex Hilbert transform filter near freq = 0"""
        
        freq = self.s.f['workup/freq/freq'][:]
        index = np.roll(freq == 0,-1) + np.roll(freq == 0,0) + np.roll(freq == 0,1)
        filt = self.s.f['workup/freq/filter/Hc'][index]
        
        self.assertTrue(np.allclose(filt,np.array([0, 1, 2])))

    def test_phase_fit_rounding(self):
        self.s.ifft()
        # T_chunk_goal set to cause problem due to incorrect rounding
        T_chunk_goal = self.dt*26
        self.s.fit_phase(T_chunk_goal)
                           
    def tearDown(self):
        """Close the h5 files before the next iteration."""
        try:
            self.s.f.close()
        except:
            pass                
Exemple #4
0
class FFTTests(unittest.TestCase):
    def setUp(self):
        """
        Create an trial *Signal* object
        """

        fd = 50.0E3  # digitization frequency
        f0 = 5.00E3  # signal frequency
        nt = 512  # number of signal points

        self.dt = dt = 1 / fd
        t = dt * np.arange(nt)
        s = 1.0 * np.sin(2 * np.pi * f0 * t)

        self.s = Signal('.FFTTests_1.h5')
        self.s.load_nparray(s, "x", "nm", dt)
        self.s.time_mask_binarate("middle")
        self.s.time_window_cyclicize(10 * dt)
        self.s.fft()
        self.s.freq_filter_Hilbert_complex()

    def testfft_1(self):
        """FFT: test that the resulting data is complex"""

        first_point = self.s.f['workup/freq/FT'][0]
        self.assertEqual(isinstance(first_point, complex), True)

    def testfft_2(self):
        """FFT: test that the complex Hilbert transform filter is real"""

        first_point = self.s.f['workup/freq/filter/Hc'][0]
        self.assertEqual(isinstance(first_point, complex), False)

    def testfft_3(self):
        """FFT: test the complex Hilbert transform filter near freq = 0"""

        freq = self.s.f['workup/freq/freq'][:]
        index = np.roll(freq == 0, -1) + np.roll(freq == 0, 0) + np.roll(
            freq == 0, 1)
        filt = self.s.f['workup/freq/filter/Hc'][index]

        self.assertTrue(np.allclose(filt, np.array([0, 1, 2])))

    def test_phase_fit_rounding(self):
        self.s.ifft()
        # T_chunk_goal set to cause problem due to incorrect rounding
        T_chunk_goal = self.dt * 26
        self.s.fit_phase(T_chunk_goal)

    def tearDown(self):
        """Close the h5 files before the next iteration."""
        try:
            self.s.f.close()
        except:
            pass
class FFTOddPoints(unittest.TestCase):
    def setUp(self):
        self.x = np.array([0, 1, 0, -1, 0, 1, 0, -1, 0])
        self.s = Signal()
        self.s.load_nparray(self.x, 'x', 'nm', 1)

    def test_ifft_odd_pts(self):
        self.s.fft()
        self.s.ifft()
        x_ifft_fft = self.s.f['workup/time/z'][:]
        x = self.x
        # Should give x back to within numerical rounding errors
        assert_allclose(x.real, x_ifft_fft.real, atol=1e-15)
        assert_allclose(x.imag, x_ifft_fft.imag, atol=1e-15)

    def tearDown(self):
        self.s.close()
Exemple #6
0
class FFTOddPoints(unittest.TestCase):
    def setUp(self):
        self.x = np.array([0, 1, 0, -1, 0, 1, 0, -1, 0])
        self.s = Signal()
        self.s.load_nparray(self.x, 'x', 'nm', 1)

    def test_ifft_odd_pts(self):
        self.s.fft()
        self.s.ifft()
        x_ifft_fft = self.s.f['workup/time/z'][:]
        x = self.x
        # Should give x back to within numerical rounding errors
        assert_allclose(x.real, x_ifft_fft.real, atol=1e-15)
        assert_allclose(x.imag, x_ifft_fft.imag, atol=1e-15)

    def tearDown(self):
        self.s.close()