Esempio n. 1
0
class TestRadarDataMethods(unittest.TestCase):
    def setUp(self):
        self.data = RadarData(
            os.path.join(THIS_DIR, 'input_data', 'small_data.mat'))
        self.data.x_coord = np.arange(40)
        self.data.nmo_depth = None
        self.data.travel_time = np.arange(0, 0.2, 0.01)
        self.data.dt = 1.0e-8
        self.data.trig = self.data.trig * 0.

    def test_Reverse(self):
        data_unrev = self.data.data.copy()
        self.data.reverse()
        self.assertTrue(np.allclose(self.data.data, np.fliplr(data_unrev)))
        self.assertTrue(np.allclose(self.data.x_coord, np.arange(39, -1, -1)))
        self.data.reverse()
        self.assertTrue(np.allclose(self.data.data, data_unrev))
        self.assertTrue(np.allclose(self.data.x_coord, np.arange(40)))

    def test_CropTWTT(self):
        self.data.crop(0.165, 'bottom', dimension='twtt')
        self.assertTrue(self.data.data.shape == (17, 40))
        self.data.crop(0.055, 'top', dimension='twtt')
        self.assertTrue(self.data.data.shape == (11, 40))

        # do not fail on bad flags
        self.data.flags.crop = False
        self.data.crop(0.055, 'top', dimension='twtt')
        self.assertTrue(self.data.flags.crop.shape == (3, ))
        self.assertTrue(self.data.flags.crop[0])

    def test_CropErrors(self):
        with self.assertRaises(ValueError):
            self.data.crop(0.165, 'bottom', dimension='dummy')
        with self.assertRaises(ValueError):
            self.data.crop(0.165, 'dummy', dimension='twtt')

    def test_CropSNUM(self):
        self.data.crop(17, 'bottom', dimension='snum')
        self.assertTrue(self.data.data.shape == (17, 40))
        self.data.crop(6, 'top', dimension='snum')
        self.assertTrue(self.data.data.shape == (11, 40))

    def test_CropTrigInt(self):
        self.data.trig = 2
        with self.assertRaises(ValueError):
            self.data.crop(17, 'bottom', dimension='pretrig')
        self.data.crop(6, 'top', dimension='pretrig')
        self.assertTrue(self.data.data.shape == (18, 40))

    def test_CropTrigMat(self):
        self.data.trig = np.ones((40, ), dtype=int)
        self.data.trig[20:] = 2
        self.data.crop(6, 'top', dimension='pretrig')
        self.assertTrue(self.data.data.shape == (19, 40))

    def test_CropDepthOnTheFly(self):
        self.data.crop(0.165, 'bottom', dimension='depth', uice=2.0e6)
        self.assertTrue(self.data.data.shape == (17, 40))
        self.data.crop(0.055, 'top', dimension='depth', uice=2.0e6)
        self.assertTrue(self.data.data.shape == (11, 40))

    def test_CropDepthWithNMO(self):
        self.data.nmo(0., uice=2.0e6, uair=2.0e6)
        self.data.crop(0.165, 'bottom', dimension='depth')
        self.assertTrue(self.data.data.shape == (17, 40))
        self.data.crop(0.055, 'top', dimension='depth')
        self.assertTrue(self.data.data.shape == (11, 40))

    def test_HCropTnum(self):
        self.data.hcrop(2, 'left', dimension='tnum')
        self.assertTrue(self.data.data.shape == (20, 39))
        self.data.hcrop(15, 'right', dimension='tnum')
        self.assertTrue(self.data.data.shape == (20, 14))
        # Make sure we can ditch the last one
        self.data.hcrop(14, 'right', dimension='tnum')
        self.assertTrue(self.data.data.shape == (20, 13))

    def test_HCropInputErrors(self):
        with self.assertRaises(ValueError):
            self.data.hcrop(2, 'left', dimension='dummy')
        with self.assertRaises(ValueError):
            self.data.hcrop(2, 'dummy', dimension='tnum')

    def test_HCropBoundsErrors(self):
        # There are lots of bad inputs for tnum
        with self.assertRaises(ValueError):
            self.data.hcrop(44, 'right', dimension='tnum')
        with self.assertRaises(ValueError):
            self.data.hcrop(-44, 'right', dimension='tnum')
        with self.assertRaises(ValueError):
            self.data.hcrop(0, 'right', dimension='tnum')
        with self.assertRaises(ValueError):
            self.data.hcrop(1, 'right', dimension='tnum')
        with self.assertRaises(ValueError):
            self.data.hcrop(-1, 'right', dimension='tnum')
        with self.assertRaises(ValueError):
            self.data.hcrop(41, 'right', dimension='tnum')

        # Fewer ways to screw up distance
        with self.assertRaises(ValueError):
            self.data.hcrop(1.6, 'right', dimension='dist')
        with self.assertRaises(ValueError):
            self.data.hcrop(0, 'right', dimension='dist')
        with self.assertRaises(ValueError):
            self.data.hcrop(-1, 'right', dimension='dist')

    def test_HCropDist(self):
        self.data.hcrop(0.01, 'left', dimension='dist')
        self.assertTrue(self.data.data.shape == (20, 39))
        self.data.hcrop(1.4, 'right', dimension='dist')
        self.assertTrue(self.data.data.shape == (20, 38))

    def test_agc(self):
        self.data.agc()
        self.assertTrue(self.data.flags.agc)

    def test_rangegain(self):
        self.data.rangegain(1.0)
        self.assertTrue(self.data.flags.rgain)
        self.data.flags.rgain = False

        self.data.trig = np.zeros((self.data.tnum, ))
        self.data.rangegain(1.0)
        self.assertTrue(self.data.flags.rgain)

        # Deprecated for trig not to be a vector, but check it anyway
        self.data.trig = 0.0
        self.data.rangegain(1.0)
        self.assertTrue(self.data.flags.rgain)

    def test_NMO(self):
        # If velocity is 2
        self.data.nmo(0., uice=2.0, uair=2.0)
        self.assertTrue(
            np.allclose(self.data.travel_time * 1.0e-6, self.data.nmo_depth))

        # shouldn't care about uair if offset=0
        self.setUp()
        self.data.nmo(0., uice=2.0, uair=200.0)
        self.assertTrue(
            np.allclose(self.data.travel_time * 1.0e-6, self.data.nmo_depth))

        self.setUp()
        self.data.nmo(0., uice=2.0, uair=200.0)
        self.assertEqual(self.data.flags.nmo.shape, (2, ))
        self.assertTrue(self.data.flags.nmo[0])

        self.setUp()
        self.data.nmo(0., uice=2.0, uair=2.0, const_firn_offset=3.0)
        self.assertTrue(
            np.allclose(self.data.travel_time * 1.0e-6 + 3.0,
                        self.data.nmo_depth))

        self.setUp()
        self.data.trig = np.ones((self.data.tnum, ))
        with self.assertRaises(ImpdarError):
            self.data.nmo(0., uice=2.0, uair=2.0)

        # Good rho profile
        self.setUp()
        self.data.nmo(0.,
                      rho_profile=os.path.join(THIS_DIR, 'input_data',
                                               'rho_profile.txt'))

        # bad rho profile
        self.setUp()
        with self.assertRaises(Exception):
            self.data.nmo(0.,
                          rho_profile=os.path.join(THIS_DIR, 'input_data',
                                                   'velocity_layers.txt'))

    def test_optimize_moveout_depth(self):
        d = _RadarDataProcessing.optimize_moveout_depth(
            100.0, 100.0 / 1.68e8 * 2., 10.0, np.array([0., 10., 50., 1000.]),
            np.array([2.5e8, 2.0e8, 1.8e8, 1.68e8]))
        self.assertFalse(np.isnan(d))

        d = _RadarDataProcessing.optimize_moveout_depth(
            2000.0, 100.0 / 1.68e8 * 2., 10.0, np.array([0., 10., 50., 1000.]),
            np.array([2.5e8, 2.0e8, 1.8e8, 1.68e8]))
        self.assertFalse(np.isnan(d))

        with self.assertRaises(ValueError):
            d = _RadarDataProcessing.optimize_moveout_depth(
                -2000.0, 100.0 / 1.68e8 * 2., 10.0,
                np.array([0., 10., 50., 1000.]),
                np.array([2.5e8, 2.0e8, 1.8e8, 1.68e8]))

    def test_restack_odd(self):
        self.data.restack(5)
        self.assertTrue(self.data.data.shape == (20, 8))

    def test_restack_even(self):
        self.data.restack(4)
        self.assertTrue(self.data.data.shape == (20, 8))

    def test_elev_correct(self):
        self.data.elev = np.arange(self.data.data.shape[1]) * 0.002
        with self.assertRaises(ValueError):
            self.data.elev_correct()
        self.data.nmo(0, 2.0e6)
        self.data.elev_correct(v_avg=2.0e6)
        self.assertTrue(self.data.data.shape == (27, 40))

    def test_constant_space_real(self):
        # Basic check where there is movement every step
        distlims = (self.data.dist[0], self.data.dist[-1])
        space = 100.
        targ_size = np.ceil((distlims[-1] - distlims[0]) * 1000. / space)
        self.data.constant_space(space)
        self.assertTrue(self.data.data.shape == (20, targ_size))
        self.assertTrue(self.data.x_coord.shape == (targ_size, ))
        self.assertTrue(self.data.y_coord.shape == (targ_size, ))
        self.assertTrue(self.data.lat.shape == (targ_size, ))
        self.assertTrue(self.data.long.shape == (targ_size, ))
        self.assertTrue(self.data.elev.shape == (targ_size, ))
        self.assertTrue(self.data.decday.shape == (targ_size, ))

        # Make sure we can have some bad values from no movement
        # This will delete some distance so, be careful with checks
        self.setUp()
        self.data.constant_space(space, min_movement=35.)
        self.assertEqual(self.data.data.shape[0], 20)
        self.assertLessEqual(self.data.data.shape[1], targ_size)
        self.assertLessEqual(self.data.x_coord.shape[0], targ_size)
        self.assertLessEqual(self.data.y_coord.shape[0], targ_size)
        self.assertLessEqual(self.data.lat.shape[0], targ_size)
        self.assertLessEqual(self.data.long.shape[0], targ_size)
        self.assertLessEqual(self.data.elev.shape[0], targ_size)
        self.assertLessEqual(self.data.decday.shape[0], targ_size)

        # do not fail because flags structure is weird from matlab
        self.setUp()
        self.data.flags.interp = False
        self.data.constant_space(space)
        self.assertTrue(self.data.flags.interp.shape == (2, ))
        self.assertTrue(self.data.flags.interp[0])
        self.assertEqual(self.data.flags.interp[1], space)

        # Want to be able to do picks too
        self.setUp()
        self.data.pick = Picks(self.data)
        self.data.picks.samp1 = np.ones((2, self.data.tnum))
        self.data.picks.samp2 = np.ones((2, self.data.tnum))
        self.data.picks.samp3 = np.ones((2, self.data.tnum))
        self.data.picks.power = np.ones((2, self.data.tnum))
        self.data.picks.time = np.ones((2, self.data.tnum))
        self.data.constant_space(space)
        self.assertTrue(self.data.data.shape == (20, targ_size))
        self.assertTrue(self.data.x_coord.shape == (targ_size, ))
        self.assertTrue(self.data.y_coord.shape == (targ_size, ))
        self.assertTrue(self.data.lat.shape == (targ_size, ))
        self.assertTrue(self.data.long.shape == (targ_size, ))
        self.assertTrue(self.data.elev.shape == (targ_size, ))
        self.assertTrue(self.data.decday.shape == (targ_size, ))
        self.assertTrue(self.data.picks.samp1.shape == (2, targ_size))
        self.assertTrue(self.data.picks.samp2.shape == (2, targ_size))
        self.assertTrue(self.data.picks.samp3.shape == (2, targ_size))
        self.assertTrue(self.data.picks.power.shape == (2, targ_size))
        self.assertTrue(self.data.picks.time.shape == (2, targ_size))

    def test_constant_space_complex(self):
        # One of the few functions that really differs with complex data.
        self.data.data = self.data.data + 1.0j * self.data.data
        distlims = (self.data.dist[0], self.data.dist[-1])
        space = 100.
        targ_size = np.ceil((distlims[-1] - distlims[0]) * 1000. / space)
        self.data.constant_space(space)
        self.assertTrue(self.data.data.shape == (20, targ_size))
        self.assertTrue(self.data.x_coord.shape == (targ_size, ))
        self.assertTrue(self.data.y_coord.shape == (targ_size, ))
        self.assertTrue(self.data.lat.shape == (targ_size, ))
        self.assertTrue(self.data.long.shape == (targ_size, ))
        self.assertTrue(self.data.elev.shape == (targ_size, ))
        self.assertTrue(self.data.decday.shape == (targ_size, ))

    def test_constant_sample_depth_spacing(self):
        # first check that it fails if we are not set up
        self.data.nmo_depth = None
        with self.assertRaises(AttributeError):
            self.data.constant_sample_depth_spacing()

        # Spoof variable nmo depths
        self.data.nmo_depth = np.hstack(
            (np.arange(self.data.snum // 2),
             self.data.snum // 2 + 2. * np.arange(self.data.snum // 2)))
        self.data.constant_sample_depth_spacing()
        self.assertTrue(
            np.allclose(
                np.diff(self.data.nmo_depth),
                np.ones(
                    (self.data.snum - 1, )) * np.diff(self.data.nmo_depth)[0]))

        # So now if we call again, it should do nothing and return 1
        rv = self.data.constant_sample_depth_spacing()
        self.assertEqual(1, rv)

    def test_traveltime_to_depth(self):
        # We are not constant
        depths = self.data.traveltime_to_depth(
            np.arange(10) - 1., (np.arange(10) + 1) * 91.7)
        self.assertFalse(
            np.allclose(np.diff(depths),
                        np.ones(
                            (len(depths) - 1, )) * (depths[1] - depths[0])))

        # We are constant
        depths = self.data.traveltime_to_depth(
            np.arange(10) - 1., (np.ones((10, )) * 91.7))
        self.assertTrue(
            np.allclose(np.diff(depths),
                        np.ones(
                            (len(depths) - 1, )) * (depths[1] - depths[0])))

        # we have negative travel times
        self.data.travel_time = self.data.travel_time - 0.01
        depths = self.data.traveltime_to_depth(
            np.arange(10) - 1., (np.arange(10) + 1) * 91.7)
        self.assertFalse(
            np.allclose(np.diff(depths),
                        np.ones(
                            (len(depths) - 1, )) * (depths[1] - depths[0])))

    def tearDown(self):
        if os.path.exists(os.path.join(THIS_DIR, 'input_data',
                                       'test_out.mat')):
            os.remove(os.path.join(THIS_DIR, 'input_data', 'test_out.mat'))
Esempio n. 2
0
class TestRadarDataMethods(unittest.TestCase):
    def setUp(self):
        self.data = RadarData(
            os.path.join(THIS_DIR, 'input_data', 'small_data.mat'))
        self.data.x_coord = np.arange(40)
        self.data.nmo_depth = None
        self.data.travel_time = np.arange(0, 0.2, 0.01)
        self.data.dt = 1.0e-8
        self.data.trig = 0.

    def test_Reverse(self):
        data_unrev = self.data.data.copy()
        self.data.reverse()
        self.assertTrue(np.allclose(self.data.data, np.fliplr(data_unrev)))
        self.assertTrue(np.allclose(self.data.x_coord, np.arange(39, -1, -1)))
        self.data.reverse()
        self.assertTrue(np.allclose(self.data.data, data_unrev))
        self.assertTrue(np.allclose(self.data.x_coord, np.arange(40)))

    def test_process_Reverse(self):
        data_unrev = self.data.data.copy()
        process.process([self.data], rev=True)
        self.assertTrue(np.allclose(self.data.data, np.fliplr(data_unrev)))
        self.assertTrue(np.allclose(self.data.x_coord, np.arange(39, -1, -1)))
        process.process([self.data], rev=True)
        self.assertTrue(np.allclose(self.data.data, data_unrev))
        self.assertTrue(np.allclose(self.data.x_coord, np.arange(40)))

    def test_CropTWTT(self):
        self.data.crop(0.165, 'bottom', dimension='twtt')
        self.assertTrue(self.data.data.shape == (17, 40))
        self.data.crop(0.055, 'top', dimension='twtt')
        self.assertTrue(self.data.data.shape == (11, 40))

        # do not fail on bad flags
        self.data.flags.crop = False
        self.data.crop(0.055, 'top', dimension='twtt')
        self.assertTrue(self.data.flags.crop.shape == (3, ))
        self.assertTrue(self.data.flags.crop[0])

    def test_CropErrors(self):
        with self.assertRaises(ValueError):
            self.data.crop(0.165, 'bottom', dimension='dummy')
        with self.assertRaises(ValueError):
            self.data.crop(0.165, 'dummy', dimension='twtt')

    def test_CropSNUM(self):
        self.data.crop(17, 'bottom', dimension='snum')
        self.assertTrue(self.data.data.shape == (17, 40))
        self.data.crop(6, 'top', dimension='snum')
        self.assertTrue(self.data.data.shape == (11, 40))

    def test_CropTrigInt(self):
        self.data.trig = 2
        with self.assertRaises(ValueError):
            self.data.crop(17, 'bottom', dimension='pretrig')
        self.data.crop(6, 'top', dimension='pretrig')
        self.assertTrue(self.data.data.shape == (18, 40))

    def test_CropTrigMat(self):
        self.data.trig = np.ones((40, ), dtype=int)
        self.data.trig[20:] = 2
        self.data.crop(6, 'top', dimension='pretrig')
        self.assertTrue(self.data.data.shape == (19, 40))

    def test_CropDepthOnTheFly(self):
        self.data.crop(0.165, 'bottom', dimension='depth', uice=2.0e6)
        self.assertTrue(self.data.data.shape == (17, 40))
        self.data.crop(0.055, 'top', dimension='depth', uice=2.0e6)
        self.assertTrue(self.data.data.shape == (11, 40))

    def test_CropDepthWithNMO(self):
        self.data.nmo(0., uice=2.0e6, uair=2.0e6)
        self.data.crop(0.165, 'bottom', dimension='depth')
        self.assertTrue(self.data.data.shape == (17, 40))
        self.data.crop(0.055, 'top', dimension='depth')
        self.assertTrue(self.data.data.shape == (11, 40))

    def test_process_Crop(self):
        with self.assertRaises(TypeError):
            process.process([self.data], crop=True)
        with self.assertRaises(ValueError):
            process.process([self.data], crop=(1.0, 'top', 'dum'))
        with self.assertRaises(ValueError):
            process.process([self.data], crop=(1.0, 'bot', 'snum'))
        with self.assertRaises(ValueError):
            process.process([self.data], crop=('ugachacka', 'top', 'snum'))
        process.process([self.data], crop=(17, 'bottom', 'snum'))
        self.assertTrue(self.data.data.shape == (17, 40))
        process.process([self.data], crop=(6, 'top', 'snum'))
        self.assertTrue(self.data.data.shape == (11, 40))

    def test_HCropTnum(self):
        self.data.hcrop(2, 'left', dimension='tnum')
        self.assertTrue(self.data.data.shape == (20, 39))
        self.data.hcrop(15, 'right', dimension='tnum')
        self.assertTrue(self.data.data.shape == (20, 14))
        # Make sure we can ditch the last one
        self.data.hcrop(14, 'right', dimension='tnum')
        self.assertTrue(self.data.data.shape == (20, 13))

    def test_HCropInputErrors(self):
        with self.assertRaises(ValueError):
            self.data.hcrop(2, 'left', dimension='dummy')
        with self.assertRaises(ValueError):
            self.data.hcrop(2, 'dummy', dimension='tnum')

    def test_HCropBoundsErrors(self):
        # There are lots of bad inputs for tnum
        with self.assertRaises(ValueError):
            self.data.hcrop(44, 'right', dimension='tnum')
        with self.assertRaises(ValueError):
            self.data.hcrop(-44, 'right', dimension='tnum')
        with self.assertRaises(ValueError):
            self.data.hcrop(0, 'right', dimension='tnum')
        with self.assertRaises(ValueError):
            self.data.hcrop(1, 'right', dimension='tnum')
        with self.assertRaises(ValueError):
            self.data.hcrop(-1, 'right', dimension='tnum')
        with self.assertRaises(ValueError):
            self.data.hcrop(41, 'right', dimension='tnum')

        # Fewer ways to screw up distance
        with self.assertRaises(ValueError):
            self.data.hcrop(1.6, 'right', dimension='dist')
        with self.assertRaises(ValueError):
            self.data.hcrop(0, 'right', dimension='dist')
        with self.assertRaises(ValueError):
            self.data.hcrop(-1, 'right', dimension='dist')

    def test_HCropDist(self):
        self.data.hcrop(0.01, 'left', dimension='dist')
        self.assertTrue(self.data.data.shape == (20, 39))
        self.data.hcrop(1.4, 'right', dimension='dist')
        self.assertTrue(self.data.data.shape == (20, 38))

    def test_agc(self):
        self.data.agc()
        self.assertTrue(self.data.flags.agc)

    def test_rangegain(self):
        self.data.rangegain(1.0)
        self.assertTrue(self.data.flags.rgain)
        self.data.flags.rgain = False

        self.data.trig = np.zeros((self.data.tnum, ))
        self.data.rangegain(1.0)
        self.assertTrue(self.data.flags.rgain)

    def test_NMO_noexcpetion(self):
        # If velocity is 2
        self.data.nmo(0., uice=2.0, uair=2.0)
        self.assertTrue(
            np.allclose(self.data.travel_time * 1.0e-6, self.data.nmo_depth))
        # shouldn't care about uair if offset=0
        self.data.nmo(0., uice=2.0, uair=200.0)
        self.assertTrue(
            np.allclose(self.data.travel_time * 1.0e-6, self.data.nmo_depth))

        self.data.flags.nmo = False
        self.data.nmo(0., uice=2.0, uair=200.0)
        self.assertEqual(self.data.flags.nmo.shape, (2, ))
        self.assertTrue(self.data.flags.nmo[0])

    def test_process_NMO(self):
        # If velocity is 2
        process.process([self.data], nmo=(0., 2.0, 2.0))
        self.assertTrue(
            np.allclose(self.data.travel_time * 1.0e-6, self.data.nmo_depth))
        # shouldn't care about uair if offset=0
        process.process([self.data], nmo=(0., 2.0, 200.0))
        self.assertTrue(
            np.allclose(self.data.travel_time * 1.0e-6, self.data.nmo_depth))

        # Just make sure we can use one arg
        process.process([self.data], nmo=0.)

    def test_restack_odd(self):
        self.data.restack(5)
        self.assertTrue(self.data.data.shape == (20, 8))

    def test_restack_even(self):
        self.data.restack(4)
        self.assertTrue(self.data.data.shape == (20, 8))

    def test_process_restack(self):
        process.process([self.data], restack=3)
        self.assertTrue(self.data.data.shape == (20, 13))
        process.process([self.data], restack=[3])
        self.assertTrue(self.data.data.shape == (20, 4))

    def test_elev_correct(self):
        self.data.elev = np.arange(self.data.data.shape[1]) * 0.002
        with self.assertRaises(ValueError):
            self.data.elev_correct()
        self.data.nmo(0, 2.0e6)
        self.data.elev_correct(v_avg=2.0e6)
        self.assertTrue(self.data.data.shape == (27, 40))

    def test_constant_space(self):
        distlims = (self.data.dist[0], self.data.dist[-1])
        space = 100.
        self.data.constant_space(space)
        self.assertTrue(
            self.data.data.shape == (20,
                                     np.ceil((distlims[-1] - distlims[0]) *
                                             1000. / space)))
        self.assertTrue(
            self.data.x_coord.shape == (np.ceil((distlims[-1] - distlims[0]) *
                                                1000. / space), ))
        self.assertTrue(
            self.data.y_coord.shape == (np.ceil((distlims[-1] - distlims[0]) *
                                                1000. / space), ))
        self.assertTrue(
            self.data.lat.shape == (np.ceil((distlims[-1] - distlims[0]) *
                                            1000. / space), ))
        self.assertTrue(
            self.data.long.shape == (np.ceil((distlims[-1] - distlims[0]) *
                                             1000. / space), ))
        self.assertTrue(
            self.data.elev.shape == (np.ceil((distlims[-1] - distlims[0]) *
                                             1000. / space), ))
        self.assertTrue(
            self.data.decday.shape == (np.ceil((distlims[-1] - distlims[0]) *
                                               1000. / space), ))

        # do not fail because flags structure is weird from matlab
        space = 100.
        self.data.flags.interp = False
        self.data.constant_space(space)
        self.assertTrue(self.data.flags.interp.shape == (2, ))
        self.assertTrue(self.data.flags.interp[0])
        self.assertEqual(self.data.flags.interp[1], space)

    def test_constant_sample_depth_spacing(self):
        # first check that it fails if we are not set up
        self.data.nmo_depth = None
        with self.assertRaises(AttributeError):
            self.data.constant_sample_depth_spacing()

        # Spoof variable nmo depths
        self.data.nmo_depth = np.hstack(
            (np.arange(self.data.snum // 2),
             self.data.snum // 2 + 2. * np.arange(self.data.snum // 2)))
        self.data.constant_sample_depth_spacing()
        self.assertTrue(
            np.allclose(
                np.diff(self.data.nmo_depth),
                np.ones(
                    (self.data.snum - 1, )) * np.diff(self.data.nmo_depth)[0]))

        # So now if we call again, it should do nothing and return 1
        rv = self.data.constant_sample_depth_spacing()
        self.assertEqual(1, rv)

    def test_traveltime_to_depth(self):
        # We are not constant
        depths = self.data.traveltime_to_depth(
            np.arange(10) - 1., (np.arange(10) + 1) * 91.7)
        self.assertFalse(
            np.allclose(np.diff(depths),
                        np.ones(
                            (len(depths) - 1, )) * (depths[1] - depths[0])))

        # We are constant
        depths = self.data.traveltime_to_depth(
            np.arange(10) - 1., (np.ones((10, )) * 91.7))
        self.assertTrue(
            np.allclose(np.diff(depths),
                        np.ones(
                            (len(depths) - 1, )) * (depths[1] - depths[0])))

        # we have negative travel times
        self.data.travel_time = self.data.travel_time - 0.01
        depths = self.data.traveltime_to_depth(
            np.arange(10) - 1., (np.arange(10) + 1) * 91.7)
        self.assertFalse(
            np.allclose(np.diff(depths),
                        np.ones(
                            (len(depths) - 1, )) * (depths[1] - depths[0])))

    def tearDown(self):
        if os.path.exists(os.path.join(THIS_DIR, 'input_data',
                                       'test_out.mat')):
            os.remove(os.path.join(THIS_DIR, 'input_data', 'test_out.mat'))