shipgrav 1.0.0__py2.py3-none-any.whl

shipgrav/tests/ex_files/IXBlue.yaml

@@ -0,0 +1,160 @@
+################################################################################
+# IXBlue PHINS III MRU GPS [from the ABX-Two], attitude, and heading
+#
+# See README.md in this directory
+######################################
+IXBlueHydrins:
+  category: "device_type"
+  description: "IXBlue Hydrins MRU GPS"
+
+  format:
+    PHZDA: '${:.2}ZDA,{GPSTime:g},{GPSDay:d},{GPSMonth:d},{GPSYear:d},{LocalHours:od},{LocalZone:od}*{CheckSum:x}'
+    PHGGA: '${:.2}GGA,{GPSTime:g},{Latitude:nlat_dir},{Longitude:nlat_dir},{FixQuality:d},{NumSats:d},{HDOP:of},{AntennaHeight:of},M,{GeoidHeight:of},M,{LastDGPSUpdate:of},{DGPSStationID:od}*{CheckSum:x}'
+    PHVTG: '${:.2}VTG,{CourseTrue:of},T,{CourseMag:of},M,{SpeedKt:of},N,{SpeedKm:of},K,{Mode:w}*{CheckSum:x}'
+    PHGST: '${:.2}GST,{GPSTime:g},{ResidualRMS:g},{ErrorEllipseSemiMajor:g},{ErrorEllipseSemiMinor:g},{ErrorEllipseOrientation:g},{LatitudeError:g},{LongitudeError:g},{HeightError:g}*{CheckSum:x}'
+    HEHDT: '${:.2}HDT,{HeadingTrue:og},T*{CheckSum:x}'
+    PASHR: '$PASHR,{GPSTime:g},{HeadingTrue:g},T,{Pitch:g},{Roll:g},{Heave:g},{AccuracyPitch:g},{AccuracyRoll:g},{AccuracyHeave:g},{FlagAccuracyHeading:d},{FlagIMU:d}*{Checksum:x}'
+
+  ########
+  # Optional metadata to help make sense of the parsed values.
+  fields:
+    # GPZDA
+    GPSTime:
+      units: ""
+      description: "UTC of position fix in hhmmss.ss"
+    GPSDay:
+      units: ""
+      description: ""
+    GPSMonth:
+      units: ""
+      description: ""
+    GPSYear:
+      units: ""
+      description: ""
+    LocalHours:
+      units: ""
+      description: ""
+    LocalZone:
+      description: "Local time zone"
+
+    # GPGLL
+    Latitude:
+      units: "degrees"
+      description: "Latitude in degrees north; negative for south latitude"
+    Longitude:
+      units: "degrees"
+      description: "Longitude in degrees east; negative for west longitude"
+    FixTime:
+      description: "UTC of position fix in hhmmss.ss format"
+    DataValid:
+      description: "A = data valid V = data invalid"
+    Mode:
+      description: "Mode Indicator: A-Autonomous, M-Manual, D-Differential, S-Simulator, E-Dead Reckoning, N-Data Not Valid"
+
+    # $GPGGA
+    FixQuality:
+      Description: "GPS quality indicator: 0 = fix not available or invalid, 1 = GPS SPS mode, fix valid, 2 = differential GPS, SPS mode, fix valid, 3 = GPS PPS mode, fix valid, 4 = Real Time Kinematic. Satellite system used in RTK mode with fixed integers, 5 = Float RTK. Satellite system used in RTK mode with floating integers, 6 = Estimated (dead reckoning) mode, 7 = Manual input mode"
+    NumSats:
+      description: "Number of satellites in use (00-12)"
+    HDOP:
+      description: "Horizontal DOP"
+    AntennaHeight:
+      units: "Meters"
+      description: "Antenna height above/below MSL (mean sea level) reference"
+    GeoidHeight:
+      units: "Meters"
+      description: "Geoidal separation (e.g. -33.81 m)"
+    LastDGPSUpdate:
+      description: "Age of differential GPS data record"
+    DGPSStationID:
+      description: "Differential Reference Station ID (0000-1023)"
+
+    # GPRMC
+    SpeedKt:
+      units: "Knots"
+      description: "Speed over ground in knots"
+    CourseTrue:
+      units: "Degrees"
+      description: "Course over ground, True"
+    MagneticVar:
+      units: "Degrees"
+      description: "Magnetic variation"
+    MagneticVarEorW:
+      description: "Direction of magnetic variation (E - East, W - West)"
+
+    # GPVTG
+    CourseMag:
+      units: "Degrees"
+      description: "Course over ground, Magnetic"
+    SpeedKm:
+      units: "Km/hour"
+      description: "Speed over ground in Km/hour"
+
+    # GNGST
+    ResidualRMS:
+      units: ""
+      description: "RMS of pseudo-range residuals"
+    ErrorEllipseSemiMajor:
+      units: "Meters"
+      description: "Error ellipse semi-major axis 1 sigma error"
+    ErrorEllipseSemiMinor:
+      units: "Meters"
+      description: "Error ellipse semi-minor axis 1 sigma error"
+    ErrorEllipseOrientation:
+      units: "Degrees"
+      description: "Error ellipse orientation"
+    LatitudeError:
+      units: "Meters"
+      description: "Latitude 1 sigma error"
+    LongitudeError:
+      units: "Meters"
+      description: "Longitude 1 sigma error"
+    HeightError:
+      units: "Meters"
+      description: "Height 1 sigma error"
+
+    # GPHDT
+    HeadingTrue:
+      units: "Degrees"
+      description: "Heading, True"
+
+    # PASHR_VEL
+    EastingVelocity:
+      units: "Meters/sec"
+      description: "Easting velocity"
+    EastingVelocity:
+      units: "Meters/sec"
+      description: "Easting velocity"
+    NorthingVelocity:
+      units: "Meters/sec"
+      description: "Northing velocity"
+    VerticalVelocity:
+      units: "Meters/sec"
+      description: "Vertical velocity"
+    EastingVelocityRMS:
+      units: "MM/sec"
+      description: "Easting velocity RMS"
+    NorthingVelocityRMS:
+      units: "MM/sec"
+      description: "Northing velocity RMS"
+    VerticalVelocityRMS:
+      units: "MM/sec"
+      description: "Vertical velocityRMS"
+
+    # PASHR POSMV
+    Pitch:
+      units: "Degrees"
+    Roll:
+      units: "Degrees"
+    Heave:
+      units: "Meters"
+    AccuracyPitch:
+      units: "Degrees"
+    AccuracyRoll:
+      units: "Degrees"
+    AccuracyHeave:
+      units: "Meters"
+    FlagAccuracyHeading:
+      description: "0 = no aiding, 1 = GNSS aiding, 2 = GNSS & GAMS aiding"
+    FlagIMU:
+      description: "0 = IMU out, 1 = satisfactory"

shipgrav/tests/ex_files/SR2312_dgs_raw.txt

@@ -0,0 +1,2 @@
+2023-06-16T00:00:00.857719Z $AT1M_3.64_198247,-218747,30292,-80876,4614745,236,483,200,7687710,711267,-1160673,-397137,330,11187500,0.0000000000,0.0000000000,0.0000,0.0000,1686873601
+2023-06-16T00:00:02.856681Z $AT1M_3.64_198249,211924,-115826,-224438,4609755,236,483,204,7960237,791445,-1288380,-864564,330,11081076,0.0000000000,0.0000000000,0.0000,0.0000,1686873603

shipgrav/tests/ex_files/SR2312_mru.txt

@@ -0,0 +1,12 @@
+2023-06-16T00:00:00.089227Z $PHGGA,000000.08,4419.27616746,N,12500.33483564,W,2,10,0.828,-31.369,M,-27.243,M,4.000,0135*6D
+2023-06-16T00:00:00.089227Z $PHGST,000000.08,0.000,0.586,0.585,156.604,0.586,0.585,0.567*54
+2023-06-16T00:00:00.089227Z $PHVTG,150.616,T,150.616,M,0.160,N,0.297,K,D*22
+2023-06-16T00:00:00.089227Z $HEHDT,353.12,T*19
+2023-06-16T00:00:00.089227Z $PASHR,000000.085,353.12,T,-0.41,+2.03,-0.60,0.004,0.004,0.083,1,0*38
+2023-06-16T00:00:00.589236Z $PHGGA,000000.58,4419.27613524,N,12500.33480248,W,2,10,0.828,-31.275,M,-27.243,M,4.400,0135*69
+2023-06-16T00:00:00.589236Z $PHGST,000000.58,0.000,0.586,0.585,156.604,0.586,0.585,0.567*51
+2023-06-16T00:00:00.589236Z $PHVTG,140.298,T,140.298,M,0.413,N,0.766,K,D*28
+2023-06-16T00:00:00.589236Z $HEHDT,353.20,T*18
+2023-06-16T00:00:00.589236Z $PASHR,000000.585,353.20,T,+0.18,+1.59,-0.69,0.004,0.004,0.083,1,0*33
+2023-06-16T00:00:01.039256Z $PHZDA,000001.03,16,06,2023,00,00*69
+2023-06-16T00:00:01.089253Z $PHGGA,000001.08,4419.27608228,N,12500.33473623,W,2,10,0.828,-31.289,M,-27.243,M,5.000,0135*6F

shipgrav/tests/ex_files/TN400_bgm.Raw

@@ -0,0 +1,2 @@
+03/13/2022,00:00:02.449,04:025529 00
+03/13/2022,00:00:03.449,04:025706 00

shipgrav/tests/ex_files/TN400_nav.Raw

@@ -0,0 +1,2 @@
+03/13/2022,00:00:02.105,$INGGA,000003.560,3217.33152,N,11839.14935,W,5,26,0.8,0.19,M,,,7,1015*06
+03/13/2022,00:00:02.652,$INGGA,000004.060,3217.33129,N,11839.14969,W,5,26,0.8,0.26,M,,,7,1015*0D

shipgrav/tests/test_grav_data.py

@@ -0,0 +1,75 @@
+"""
+Tests for shipgrav.grav
+These use 1000 seconds of sample data to calculate corrections and check values
+ccp coeffs are not objectively good because the time series is short but it works for tests
+Not bothering with the leveling correction here because exactly how to calculate it
+is left to the user
+"""
+import unittest
+import numpy as np
+import shipgrav.grav as sgg
+import shipgrav.io as sgi
+import shipgrav.nav as sgn
+from glob import glob
+
+
+class gravDataTestCase(unittest.TestCase):
+    def setUp(self):  # actions to take before running each test: load in some test data
+        # test data is part of one of the files supplied by DGS (original file is 30M/86400
+        # lines for 24 hr; we cut to 1 hr?)
+        gfiles = glob('ex_files/DGStest*.dat')
+        data = sgi.read_dgs_laptop(gfiles, 'DGStest')
+        data['tsec'] = [e.timestamp()
+                        for e in data['date_time']]  # get posix timestamps
+        data['grav'] = data['rgrav'] + 969143
+        self.data = data
+
+    def test_longman(self):
+        lt = sgg.longman_tide_prediction(
+            self.data['lon'], self.data['lat'], self.data['date_time'])
+        self.assertTrue(lt[0] + 0.079599 < 0.001)
+
+    def test_eotvos(self):
+        eotvos = sgg.eotvos_full(self.data['lon'].values, self.data['lat'].values,
+                                 np.zeros(len(self.data)), 1)
+        self.assertTrue(eotvos[0] + 56.90367 < 0.001)
+
+    def test_fa2ord(self):
+        fa2 = sgg.free_air_second_order(
+            self.data['lat'], np.zeros(len(self.data)))
+        self.assertEqual(fa2.iloc[0], 0.)
+
+    def test_up_vecs(self):
+        lat_corr = sgg.wgs_grav(self.data['lat']) + sgg.free_air_second_order(self.data['lat'],
+                                                                              np.zeros(len(self.data)))
+        ve, vn = sgn.latlon_to_EN(
+            self.data['lon'].values, self.data['lat'].values)
+        eacc = 1e5*np.convolve(ve, sgn.tay10, 'same')
+        nacc = 1e5*np.convolve(vn, sgn.tay10, 'same')
+        crse, vel = sgn.ENvel_to_course_heading(ve, vn)
+        acrss, along = sgn.rotate_acceleration_EN_to_cl(crse, eacc, nacc)
+        up_vecs = sgg.up_vecs(1, lat_corr, acrss, along,
+                              0, 240, 0.7071, 240, 0.7071)
+        self.assertEqual(up_vecs[0, 0], 0.)
+        self.assertEqual(up_vecs[2, 0], 1.)
+
+    def test_ccpcalc(self):
+        lt = sgg.longman_tide_prediction(
+            self.data['lon'], self.data['lat'], self.data['date_time'])
+        eotvos = sgg.eotvos_full(self.data['lon'].values, self.data['lat'].values,
+                                 np.zeros(len(self.data)), 1)
+        lat_corr = sgg.wgs_grav(self.data['lat']) + sgg.free_air_second_order(self.data['lat'],
+                                                                              np.zeros(len(self.data)))
+        faa = self.data['grav'] - lat_corr + eotvos + lt
+        _, model = sgg.calc_cross_coupling_coefficients(faa, self.data['vcc'].values, self.data['ve'].values,
+                                                        self.data['al'].values, self.data['ax'].values, np.zeros(len(self.data)))
+        self.assertTrue(model.params.ax + 3.428237 < 0.0001)
+        self.assertTrue(model.params.ve - 0.055732 < 0.0001)
+
+
+def suite():
+    return unittest.makeSuite(gravDataTestCase, 'test')
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')

shipgrav/tests/test_grav_nodata.py

@@ -0,0 +1,47 @@
+"""
+Tests for shipgrav.grav
+"""
+import unittest
+import numpy as np
+import shipgrav.grav as sgg
+
+
+class gravNoDataTestCase(unittest.TestCase):
+    def test_grav1d(self):
+        # arbitrary numbers here, not real
+        test_grav = sgg.grav1d_padded(np.linspace(
+            0, 100, 10), np.linspace(10, 15, 10), 1, 0.4)
+        self.assertTrue(test_grav[1] - 0.000157 < 0.001)
+
+    def test_halfspace_T(self):
+        T, W = sgg.therm_halfspace(np.array([20e3]), np.array([1e3]), u=0.02)
+        self.assertTrue(T[0] - 135.2263 < 0.001)
+        self.assertTrue(W[0] - 368.3393 < 0.001)
+
+    def test_halfspace_Z(self):
+        Z, W = sgg.therm_Z_halfspace(np.array([20e3]), 135.2263, u=0.02)
+        self.assertTrue(Z[0] - 1e3 < 0.001)
+        self.assertTrue(W[0] - 368.3393 < 0.001)
+
+    def test_plate_T(self):
+        T, W = sgg.therm_plate(np.array([20e3]), np.array([1e3]), u=0.02)
+        self.assertTrue(T[0] - 134.0867 < 0.001)
+        self.assertTrue(W[0] - 381.6513 < 0.001)
+
+    def test_plate_Z(self):
+        Z = sgg.therm_Z_plate(
+            np.array([20e3]), np.array([134.0867]), u=0.02)
+        self.assertEqual(Z[0], 1000.)
+
+    def test_crustalthickness(self):
+        rng = np.random.default_rng(123)  # seeded
+        C = sgg.crustal_thickness_2D(10*rng.random(1000))
+        self.assertTrue(np.real(C[0])[0] - 0.04019 < 0.001)
+
+
+def suite():
+    return unittest.makeSuite(gravNoDataTestCase, 'test')
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')

shipgrav/tests/test_io.py

@@ -0,0 +1,55 @@
+"""
+Tests for shipgrav.io
+This does not test every option for read (because there are many ships)
+but for each overall read function it reads a snippet of an example file
+and checks that the values in key columns are correct
+"""
+import unittest
+import shipgrav.io as sgi
+
+
+class ioTestCase(unittest.TestCase):
+    def test_read_nav(self):  # NOTE only tests one of the ship functions
+        # but it does include extracting clock time -> datetime -> posix
+        nav = sgi.read_nav('Thompson', 'ex_files/TN400_nav.Raw')
+        self.assertEqual(nav.iloc[0].time_sec, 1647129603)
+        self.assertTrue(nav.iloc[0].lon + 118.6524 < 0.001)
+
+    def test_read_bgm_rgs(self):
+        bgm = sgi.read_bgm_rgs('ex_files/AT05_01_bgm.RGS', 'Atlantis')
+        self.assertEqual(bgm.iloc[0]['date_time'].timestamp(), 1656633600.445)
+        self.assertEqual(bgm.iloc[0]['grav'], 980329.272)
+
+    def test_read_bgm_raw(self):
+        bgm = sgi.read_bgm_raw('ex_files/TN400_bgm.Raw', 'Thompson')
+        self.assertEqual(bgm.iloc[0]['date_time'].timestamp(), 1647129602.449)
+        self.assertEqual(bgm.iloc[0]['counts'], 25529)
+        self.assertEqual(bgm.iloc[0]['rgrav'], 127730.60800402702)
+
+    def test_read_dgs_dat(self):
+        dgs = sgi.read_dgs_laptop('ex_files/DGStest_laptop.dat', 'DGStest')
+        self.assertEqual(dgs.iloc[0]['date_time'].timestamp(), 1562803200.0)
+        self.assertEqual(dgs.iloc[0]['ve'], 0.81098)
+        self.assertTrue(dgs.iloc[0]['rgrav'] - 12295.691114 < 0.0001)
+
+    def test_read_dgs_raw(self):
+        dgs = sgi.read_dgs_raw('ex_files/SR2312_dgs_raw.txt', 'Ride')
+        self.assertEqual(
+            dgs.iloc[0]['date_time'].timestamp(), 1686873600.857719)
+        self.assertEqual(dgs.iloc[0]['Gravity'], -218747)
+        self.assertTrue(dgs.iloc[0]['vcc'] - 76.8771 < 0.0001)
+
+    def test_read_mru(self):
+        mru, cols = sgi.read_other_stuff(
+            'ex_files/IXBlue.yaml', 'ex_files/SR2312_mru.txt', 'PASHR')
+        self.assertEqual(mru.iloc[0]['Pitch:g'], -0.41)
+        self.assertEqual(mru.iloc[0]['Roll:g'], 2.03)
+        self.assertEqual(mru.iloc[0]['Heave:g'], -0.6)
+
+
+def suite():
+    return unittest.makeSuite(ioTestCase, 'test')
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')

shipgrav/tests/test_nav.py

@@ -0,0 +1,41 @@
+"""
+Tests for shipgrav.nav
+"""
+import unittest
+import shipgrav.nav as sgn
+import numpy as np
+
+
+class navTestCase(unittest.TestCase):
+    def setUp(self):
+        lons = np.ones(100)*70
+        lats = np.linspace(40, 41, 100)
+        # lat/lon to easting and northing *velocities*
+        ve, vn = sgn.latlon_to_EN(lons, lats)
+        self.ve = ve
+        self.vn = vn
+
+    def test_ll2en(self):
+        self.assertTrue(self.ve[5] - 1121.5717 < 0.001)
+        self.assertTrue(self.vn[5] < 1e-7)
+
+    def test_en2cv(self):
+        course, vel = sgn.ENvel_to_course_heading(self.ve, self.vn)
+        self.assertTrue(course[5] - 90. < 0.001)
+        self.assertEqual(vel[5], self.ve[5])
+
+    def test_rot_acc(self):
+        course, vel = sgn.ENvel_to_course_heading(self.ve, self.vn)
+        eacc = 1e5*np.convolve(self.ve, sgn.tay10, 'same')
+        nacc = 1e5*np.convolve(self.vn, sgn.tay10, 'same')
+        cross, long = sgn.rotate_acceleration_EN_to_cl(course, eacc, nacc)
+        self.assertTrue(cross[10] < 1e-7)
+        self.assertEqual(long[10], eacc[10])
+
+
+def suite():
+    return unittest.makeSuite(navTestCase, 'test')
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')

shipgrav/tests/test_utils.py

@@ -0,0 +1,33 @@
+"""
+Tests for shipgrav.utils
+"""
+import unittest
+import shipgrav.utils as sgu
+import numpy as np
+
+
+class utilsTestCase(unittest.TestCase):
+    def test_gaussian_filter(self):
+        # make a spike, filtfilt for no shift, check amplitude
+        test = np.zeros(101)
+        test[50] = 1
+        test_fl = sgu.gaussian_filter(test, 10)
+        test_ffll = sgu.gaussian_filter(test_fl[::-1], 10)
+        self.assertTrue(test_ffll[50] - 0.12975 < 0.001)
+
+    def test_status_decode(self):
+        # make a code, decode it, check a few of the 16 status bits
+        stat = 12345
+        decoded = sgu.decode_dgs_status_bits(stat)
+        self.assertEqual(decoded['clamp status'], '0')
+        self.assertEqual(decoded['GPSsync'], '0')
+        self.assertEqual(decoded['GPStime'], '1')
+        self.assertEqual(decoded['feedback'], '1')
+
+
+def suite():
+    return unittest.makeSuite(utilsTestCase, 'test')
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')