Ejemplo n.º 1
0
    def test_find_peaks(self):
        # amp as 1d array - single peak
        frq = np.array([1, 2, 3, 4, 5])
        amp = np.array([[1, 1, 2, 1, 1]])
        myhvsr = hvsrpy.Hvsr(amp, frq)
        self.assertNestedListEqual([[2]],
                                   hvsrpy.Hvsr.find_peaks(myhvsr.amp)[0])

        # amp as 2d array - single peak
        frq = np.array([1, 2, 3, 4, 5])
        amp = np.array([[1, 1, 2, 1, 1], [1, 2, 1, 1, 1], [1, 1, 2, 1, 1]])
        myhvsr = hvsrpy.Hvsr(amp, frq)
        self.assertNestedListEqual([[2], [1], [2]],
                                   hvsrpy.Hvsr.find_peaks(myhvsr.amp)[0])

        # amp as 1d array - multiple peak
        frq = np.array([1, 2, 3, 4, 5])
        amp = np.array([[1, 2, 1, 2, 1]])
        myhvsr = hvsrpy.Hvsr(amp, frq)
        self.assertNestedListEqual([[1, 3]],
                                   hvsrpy.Hvsr.find_peaks(myhvsr.amp)[0])

        # amp as 2d array - multiple peak
        frq = np.array([1, 2, 3, 4, 5, 6, 7])
        amp = np.array([[1, 2, 1, 2, 1, 6, 1], [1, 3, 7, 6, 1, 1, 1],
                        [1, 1, 8, 7, 9, 1, 1]])
        myhvsr = hvsrpy.Hvsr(amp, frq)
        self.assertNestedListEqual([[1, 3, 5], [2], [2, 4]],
                                   hvsrpy.Hvsr.find_peaks(myhvsr.amp)[0])
Ejemplo n.º 2
0
    def test_find_peaks(self):
        # amp as 1d array - single peak
        frq = np.array([1, 2, 3, 4, 5])
        amp = np.array([0, 0, 1, 0, 0])
        myhvsr = hvsrpy.Hvsr(amp, frq)
        self.assertListEqual(
            [2], hvsrpy.Hvsr.find_peaks(myhvsr.amp)[0].tolist())

        # amp as 2d array - single peak
        frq = np.array([1, 2, 3, 4, 5])
        amp = np.array([[0, 0, 1, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0]])
        myhvsr = hvsrpy.Hvsr(amp, frq)
        self.assertListEqual(
            [[2], [1], [2]], hvsrpy.Hvsr.find_peaks(myhvsr.amp)[0])

        # amp as 1d array - multiple peak
        frq = np.array([1, 2, 3, 4, 5])
        amp = np.array([0, 1, 0, 1, 0])
        myhvsr = hvsrpy.Hvsr(amp, frq)
        self.assertListEqual(
            [1, 3], hvsrpy.Hvsr.find_peaks(myhvsr.amp)[0].tolist())

        # amp as 2d array - multiple peak
        frq = np.array([1, 2, 3, 4, 5, 6, 7])
        amp = np.array([[0, 1, 0, 1, 0, 5, 0],
                        [0, 2, 6, 5, 0, 0, 0],
                        [0, 0, 7, 6, 8, 0, 0]])
        myhvsr = hvsrpy.Hvsr(amp, frq)
        for known, test in zip([[1, 3, 5], [2], [2, 4]],
                               hvsrpy.Hvsr.find_peaks(myhvsr.amp)[0]):
            self.assertListEqual(known, test.tolist())
Ejemplo n.º 3
0
    def test_mean_std_curve(self):
        frq = np.array([0, 1])
        amp = np.array([[1, 1], [3, 4], [5, 7]])
        myhv = hvsrpy.Hvsr(amp, frq, find_peaks=False)

        # Lognormal
        mean_curve = myhv.mean_curve(distribution='lognormal')
        std_curve = myhv.std_curve(distribution='lognormal')
        for col in range(amp.shape[1]):
            self.assertEqual(np.exp(np.mean(np.log(amp[:, col]))),
                             mean_curve[col])
            self.assertEqual(np.std(np.log(amp[:, col]), ddof=1),
                             std_curve[col])

        # Normal
        mean_curve = myhv.mean_curve(distribution='normal')
        std_curve = myhv.std_curve(distribution='normal')
        for col in range(amp.shape[1]):
            self.assertEqual(np.mean(amp[:, col]), mean_curve[col])
            self.assertEqual(np.std(amp[:, col], ddof=1), std_curve[col])

        # Single-Window
        frq = [1, 2]
        amp = [1, 2]
        _hv = hvsrpy.Hvsr(amp, frq, find_peaks=False)
        self.assertRaises(ValueError, _hv.std_curve)
        self.assertListEqual(amp, _hv.mean_curve().tolist())
Ejemplo n.º 4
0
    def test_init(self):
        # amp as 1d array
        frq = np.linspace(1, 10, 20)
        amp = np.sin(2*np.pi*5*np.linspace(0, 10, 20))+10
        myhvsr = hvsrpy.Hvsr(amp, frq)
        self.assertArrayEqual(frq, myhvsr.frq)
        self.assertArrayEqual(amp, myhvsr.amp)

        # amp as 2d array
        frq = np.linspace(1, 10, 20)
        amp = (np.sin(2*np.pi*5*np.linspace(0, 10, 20))+10)*np.ones((20, 20))
        myhvsr = hvsrpy.Hvsr(amp, frq)
        self.assertArrayEqual(frq, myhvsr.frq)
        self.assertArrayEqual(amp, myhvsr.amp)

        # amp as string
        frq = np.ndarray([1, 2, 3])
        amp = "abc"
        self.assertRaises(TypeError, hvsrpy.Hvsr, amp, frq)

        # negative amplitude
        frq = np.array([1, 2, 3])
        amp = np.array([1, -1, 3])
        self.assertRaises(ValueError, hvsrpy.Hvsr, amp, frq)

        # nan value
        frq = np.array([1, 2, 3])
        amp = np.array([1, 2, np.nan])
        self.assertRaises(ValueError, hvsrpy.Hvsr, amp, frq)
Ejemplo n.º 5
0
    def setUpClass(cls):
        cls.frq = np.array([1, 2, 3, 4, 5])
        cls.hv1 = np.array([[1, 1, 2, 1, 1],
                            [1, 4, 1, 5, 1],
                            [1, 1, 3, 1, 1],
                            [1, 2, 4, 5, 1]])
        hv1 = hvsrpy.Hvsr(cls.hv1, cls.frq)

        cls.hv2 = np.array([[1, 1, 2, 1, 1],
                            [1, 1, 1, 3, 1],
                            [4, 5, 6, 7, 5]])
        hv2 = hvsrpy.Hvsr(cls.hv2, cls.frq)

        cls.hv3 = np.array([[1, 1, 2, 1, 1],
                            [1, 1, 2, 1, 1],
                            [1, 1, 2, 1, 1],
                            [1, 3, 1, 1, 1]])
        hv3 = hvsrpy.Hvsr(cls.hv3, cls.frq)

        cls.hv4 = np.array([[1, 1, 1, 2, 1],
                            [1, 2, 1, 3, 1],
                            [1, 2, 1, 1, 1]])
        hv4 = hvsrpy.Hvsr(cls.hv4, cls.frq)

        cls.azi = [0, 45, 90, 135]
        cls.hvrot = hvsrpy.HvsrRotated.from_iter([hv1, hv2, hv3, hv4],
                                                 cls.azi)
        cls.hvrot_for_rej = hvsrpy.HvsrRotated.from_iter([hv1, hv2, hv3, hv4],
                                                         cls.azi)
        cls.full_path = get_full_path(__file__)
Ejemplo n.º 6
0
 def test_mc_peak_frq(self):
     frq = np.arange(0, 10, 1)
     amp = np.ones((10, 10))
     col = np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 7])
     amp[np.arange(10), col] = 2
     myhv = hvsrpy.Hvsr(amp, frq)
     self.assertEqual(1., myhv.mc_peak_frq())
Ejemplo n.º 7
0
    def test_update_peaks(self):
        frq = np.arange(1, 2, 0.1)
        amp = np.ones((10, 10))
        peak_ids = np.array([1, 2, 4, 6, 8, 1, 3, 5, 7, 6])
        amp[np.arange(10), peak_ids] = 2
        myhv = hvsrpy.Hvsr(amp, frq)

        self.assertArrayEqual(myhv.peak_frq, frq[peak_ids])
Ejemplo n.º 8
0
    def test_reject_windows(self):
        # Reject single window, end due to zero std
        frq = np.arange(0, 10, 1)
        amp = np.ones((10, 10))
        col = np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 7])
        amp[np.arange(10), col] = 2
        myhv = hvsrpy.Hvsr(amp, frq)
        myhv.reject_windows(n=2)
        self.assertEqual(myhv.mean_f0_frq(), 1.0)

        # Reject single window, end due to convergence criteria
        frq = np.arange(0, 10, 1, dtype=np.double)
        amp = np.ones((10, 10))
        col = np.array([1, 2, 2, 2, 2, 1, 2, 2, 1, 9])
        amp[np.arange(10), col] = 2
        myhv = hvsrpy.Hvsr(amp, frq, find_peaks=False, meta={})
        myhv.reject_windows(n=2)
        self.assertArrayEqual(myhv.peak_frq, frq[col[:-1]])
Ejemplo n.º 9
0
    def test_init(self):
        # Simple case
        frq = np.array([1, 2, 3])
        hv = hvsrpy.Hvsr(np.array([1, 2, 1]), frq)
        az = 20
        hvrot = hvsrpy.HvsrRotated(hv, az)
        self.assertEqual(hv, hvrot.hvsrs[0])
        self.assertEqual(az, hvrot.azimuths[0])
        self.assertEqual(1, hvrot.azimuth_count)

        # Bad hv
        hv = np.array([1, 2, 1])
        self.assertRaises(TypeError, hvsrpy.HvsrRotated, hv, az)

        # Bad azimuths
        hv = hvsrpy.Hvsr(np.array([1, 2, 1]), frq)
        bad_azs = [-5, 181, 190]
        for az in bad_azs:
            self.assertRaises(ValueError, hvsrpy.HvsrRotated, hv, az)
Ejemplo n.º 10
0
 def test_mean_std_f0_frq(self):
     frq = np.arange(0, 10, 1)
     amp = np.zeros((10, 10))
     col = np.array([1, 2, 4, 6, 8, 1, 3, 5, 7, 6])
     amp[np.arange(10), col] = 1
     myhv = hvsrpy.Hvsr(amp, frq)
     self.assertEqual(myhv.mean_f0_frq(distribution='log-normal'),
                      np.exp(np.mean(np.log(col))))
     self.assertEqual(myhv.mean_f0_frq(distribution='normal'), np.mean(col))
     self.assertEqual(myhv.std_f0_frq(distribution='log-normal'),
                      np.std(np.log(col), ddof=1))
     self.assertEqual(myhv.std_f0_frq(distribution='normal'),
                      np.std(col, ddof=1))
Ejemplo n.º 11
0
    def test_mc_peak(self):
        frq = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
        amp = np.array([[1, 1, 2, 3, 2, 1, 1, 1, 1],
                        [1, 1.5, 3, 5, 3, 1.5, 1, 1, 1],
                        [1, 1, 5, 1, 1, 1, 1, 1, 1]])
        hv = hvsrpy.Hvsr(amp, frq)

        distribution = "normal"
        expected = np.mean(amp, axis=0)
        returned = hv.mean_curve(distribution=distribution)
        self.assertArrayEqual(expected, returned)

        self.assertEqual(10 / 3, hv.mc_peak_amp(distribution=distribution))
        self.assertEqual(3, hv.mc_peak_frq(distribution=distribution))
Ejemplo n.º 12
0
    def test_peaks_with_limits(self):
        # amp as 1d array - two peak
        frq = np.array([1, 2, 3, 4, 5, 6, 7, 8])
        amp = np.array([[1, 1, 2, 1, 1, 5, 1, 1]])
        hvsr = hvsrpy.Hvsr(amp, frq, f_low=None, f_high=4, find_peaks=True)
        self.assertArrayEqual(np.array([3.0]), hvsr.peak_frq)

        # amp as 1d array - two peak
        frq = np.array([1, 2, 3, 4, 5, 6, 7, 8])
        amp = np.array([[1, 1, 2, 1, 1, 5, 1, 1]])
        hvsr = hvsrpy.Hvsr(amp, frq, f_low=4, f_high=None, find_peaks=True)
        self.assertArrayEqual(np.array([6.0]), hvsr.peak_frq)

        # amp as 1d array - two peak
        frq = np.array([1, 2, 3, 4, 5, 6, 7, 8])
        amp = np.array([[1, 1, 2, 1, 1, 5, 1, 1]])
        hvsr = hvsrpy.Hvsr(amp, frq, f_low=1, f_high=8, find_peaks=True)
        self.assertArrayEqual(np.array([6.0]), hvsr.peak_frq)

        # amp as 1d array - two peak
        frq = np.array([1, 2, 3, 4, 5, 6, 7, 8])
        amp = np.array([[1, 1, 2, 1, 1, 5, 1, 1]])
        hvsr = hvsrpy.Hvsr(amp, frq, f_low=None, f_high=None, find_peaks=True)
        self.assertArrayEqual(np.array([6.0]), hvsr.peak_frq)
Ejemplo n.º 13
0
    def test_nstd_f0(self):
        frq = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
        amp = np.array([[1, 1, 2, 3, 5, 1, 1, 1, 1],
                        [1, 2, 3, 7, 3, 1, 1, 1, 1],
                        [1, 1, 12, 1, 1, 1, 1, 1, 1]])
        hv = hvsrpy.Hvsr(amp, frq)

        distribution = "normal"
        n = 1.5

        # nstd_f0_frq
        f0s = [3, 4, 5]
        expected = np.mean(f0s) + n * np.std(f0s, ddof=1)
        returned = hv.nstd_f0_frq(n=n, distribution=distribution)
        self.assertEqual(expected, returned)

        # nstd_f0_amp
        amps = [5, 7, 12]
        expected = np.mean(amps) + n * np.std(amps, ddof=1)
        returned = hv.nstd_f0_amp(n=n, distribution=distribution)
        self.assertEqual(expected, returned)
Ejemplo n.º 14
0
    def test_nstd_curve(self):
        frq = np.array([1, 2, 3, 4, 5])
        amp = np.array([[1, 6, 1, 1, 1], [6, 1, 1, 1, 1], [1, 1, 6, 1, 1],
                        [1, 1, 1, 1, 6], [1, 1, 1, 6, 1]])
        hv = hvsrpy.Hvsr(amp, frq)

        # Curve - normal
        distribution = "normal"
        mean_curve = hv.mean_curve(distribution=distribution)
        std_curve = hv.std_curve(distribution=distribution)
        expected = mean_curve + 2 * std_curve
        returned = hv.nstd_curve(2, distribution=distribution)
        self.assertArrayEqual(expected, returned)

        # Curve - lognormal
        distribution = "lognormal"
        mean_curve = hv.mean_curve(distribution=distribution)
        std_curve = hv.std_curve(distribution=distribution)
        expected = np.exp(np.log(mean_curve) + 2 * std_curve)
        returned = hv.nstd_curve(2, distribution=distribution)
        self.assertArrayEqual(expected, returned)
Ejemplo n.º 15
0
    def test_mean_std_f0_frq(self):
        frq = np.arange(0, 10, 1)
        amp = np.ones((10, 10))
        col = np.array([1, 2, 4, 6, 8, 1, 3, 5, 7, 6])
        amp[np.arange(10), col] = 2
        myhv = hvsrpy.Hvsr(amp, frq)

        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            for distribution in ["log-normal", "lognormal"]:
                self.assertEqual(myhv.mean_f0_frq(distribution=distribution),
                                 np.exp(np.mean(np.log(col))))
        self.assertEqual(myhv.mean_f0_frq(distribution='normal'), np.mean(col))

        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            for distribution in ["log-normal", "lognormal"]:
                self.assertEqual(myhv.std_f0_frq(distribution=distribution),
                                 np.std(np.log(col), ddof=1))
        self.assertEqual(myhv.std_f0_frq(distribution='normal'),
                         np.std(col, ddof=1))
Ejemplo n.º 16
0
 def setUpClass(cls):
     frq = [1, 2, 3, 4]
     amp = [[1, 2, 1, 1], [1, 2, 4, 1], [1, 1, 5, 1]]
     cls.hv = hvsrpy.Hvsr(amp, frq)
     cls.full_path = get_full_path(__file__)