Changed use_tx_time to sv_rx_time

Changed the keyword name for readability

Author: kanhereashwin

gnss_lib_py/algorithms/snapshot.py

@@ -19,7 +19,7 @@
 
 def solve_wls(measurements, weight_type = None, only_bias = False,
               receiver_state=None, tol = 1e-7, max_count = 20,
-              use_tx_time=False, delta_t_decimals=-2):
+              sv_rx_time=False, delta_t_decimals=-2):
     """Runs weighted least squares across each timestep.
 
     Runs weighted least squares across each timestep and adds a new
@@ -51,11 +51,14 @@ def solve_wls(measurements, weight_type = None, only_bias = False,
     max_count : int
         Number of maximum iterations before process is aborted and
         solution returned.
-    use_tx_time : bool
-        Flag that specifies whether the SV positions at transmit time
-        should be used as is or if they should be transformed to the
-        corresponding ECEF coordinates when the signal is received. If
-        True, the SV positions will not be modified.
+    sv_rx_time : bool
+        Flag that specifies whether the input SV positions are in the ECEF
+        frame of reference corresponding to when the measurements were
+        received. If set to `True`, the satellite positions are used as
+        is. The default value is `False`, in which case the ECEF positions
+        are assumed to in the ECEF frame at the time of signal transmission
+        and are converted to the ECEF frame at the time of signal reception,
+        while solving the WLS problem.
     delta_t_decimals : int
             Decimal places after which times are considered equal.
 
@@ -119,7 +122,7 @@ def solve_wls(measurements, weight_type = None, only_bias = False,
                                               ,0].reshape(-1,1),
                                              position[3])) # clock bias
             position = wls(position, pos_sv_m, corr_pr_m, weights,
-                           only_bias, tol, max_count, use_tx_time)
+                           only_bias, tol, max_count, sv_rx_time=sv_rx_time)
             states.append([timestamp] + np.squeeze(position).tolist())
         except RuntimeError as error:
             if str(error) not in runtime_error_idxs:
@@ -156,7 +159,7 @@ def solve_wls(measurements, weight_type = None, only_bias = False,
     return state_estimate
 
 def wls(rx_est_m, pos_sv_m, corr_pr_m, weights = None,
-        only_bias = False, tol = 1e-7, max_count = 20, use_tx_time=False):
+        only_bias = False, tol = 1e-7, max_count = 20, sv_rx_time=False):
     """Weighted least squares solver for GNSS measurements.
 
     The option for only_bias allows the user to only calculate the clock
@@ -187,14 +190,17 @@ def wls(rx_est_m, pos_sv_m, corr_pr_m, weights = None,
     max_count : int
         Number of maximum iterations before process is aborted and
         solution returned.
-    use_tx_time : bool
+    sv_rx_time : bool
         Flag to indicate if the satellite positions at the time of
         transmission should be used as is or if they should be transformed
         to the ECEF frame of reference at the time of reception. For real
-        measurements, use ``use_tx_time=False`` to account for the Earth's
-        rotation. For simulations, ``use_tx_time=True`` can be used to
-        simplify the simulation and estimation. By default,
-        ``use_tx_time=True``.
+        measurements, use ``sv_rx_time=False`` to account for the Earth's
+        rotation and convert SV positions from the ECEF frame at the time
+        of signal transmission to the ECEF frame at the time of signal
+        reception. If the SV positions should be used as is, set
+        ``sv_rx_time=True`` to indicate that the given positions are in
+        the ECEF frame of reference for when the signals are received.
+        By default, ``sv_rx_time=False``.
 
     Returns
     -------
@@ -278,11 +284,11 @@ def wls(rx_est_m, pos_sv_m, corr_pr_m, weights = None,
         else:
             rx_est_m += pos_x_delta
 
-        if not use_tx_time:
+        if not sv_rx_time:
             # Update the satellite positions based on the time taken for
             # the signal to reach the Earth and the satellite clock bias.
-            tx_time = (corr_pr_m.reshape(-1) - rx_est_m[3,0])/consts.C
-            dtheta = consts.OMEGA_E_DOT*tx_time
+            delta_t = (corr_pr_m.reshape(-1) - rx_est_m[3,0])/consts.C
+            dtheta = consts.OMEGA_E_DOT*delta_t
             pos_sv_m[:, 0] = np.cos(dtheta)*rx_time_pos_sv_m[:,0] + \
                              np.sin(dtheta)*rx_time_pos_sv_m[:,1]
             pos_sv_m[:, 1] = -np.sin(dtheta)*rx_time_pos_sv_m[:,0] + \

notebooks/tutorials/algorithms.ipynb

@@ -40,7 +40,7 @@
     "When obtaining WLS estimates for real measurements, the rotation of the Earth between the signal transmission and reception has to be accounted for.\n",
     "`solve_wls` accounts for this by default and rotates the given SV positions into the ECEF frame of reference when the signals were received rather using the ECEF frame of reference of when the signals were transmitted.\n",
     "\n",
-    "If you assume that the satellite positions are given in the ECEF frame of reference when the signals were received (and not transmitted), set the parameter `tx_time = False` in the function call."
+    "If you assume that the satellite positions are given in the ECEF frame of reference when the signals were received (and not transmitted), set the parameter `sv_rx_time = True` in the function call."
    ]
   },
   {
@@ -52,7 +52,7 @@
    "source": [
     "state_wls = glp.solve_wls(derived_data)\n",
     "# When assuming that SV positions are given in the ECEF frame when signals are received use\n",
-    "# state_wls = glp.solve_wls(derived_data, use_tx_time=True)"
+    "# state_wls = glp.solve_wls(derived_data, sv_rx_time=True)"
    ]
   },
   {
@@ -108,34 +108,7 @@
    "id": "0387e03e",
    "metadata": {},
    "source": [
-    "Solve for the extended Kalman filter position estimate simply by passing the measurement data.\n",
-    "\n",
-    "The implemented EKF also assumes that the satellite positions are given for when the signals were transmitted (and not received), so the satellite positions must be rotated to account for the change in the ECEF frame of reference due to the rotation of the Earth between transmission time and received time.\n",
-    "\n",
-    "In this case, to change this default behaviour, pass a dictionary `init_dict` with the key-value pair `\"use_tx_time\": True`."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "31e7b493",
-   "metadata": {},
-   "source": [
-    "To prevent accidental usage of untuned process and measurement noises, `solve_gnss_ekf` requires an initialization \\\n",
-    "dictionary containing values for the process noise `\"Q\"` and the measurement noise `\"R\"`.\n",
-    "\n",
-    "In the naive implementation, the noise matrix is set to the size of the measurement vector using the scalar value `\"R\"`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2dfb8d75",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "init_dict = {\"Q\": np.eye(7),\n",
-    "             \"R\" : np.eye(1)}"
+    "Solve for the extended Kalman filter position estimate simply by passing the measurement data."
    ]
   },
   {
@@ -147,7 +120,7 @@
    },
    "outputs": [],
    "source": [
-    "state_ekf = glp.solve_gnss_ekf(derived_data, init_dict)"
+    "state_ekf = glp.solve_gnss_ekf(derived_data)"
    ]
   },
   {

tests/algorithms/test_snapshot.py

@@ -101,7 +101,7 @@ def test_wls(set_user_states, set_sv_states, tolerance):
                              keepdims = True) + rx_truth_m[3,0]
 
     rx_est_m = np.zeros((4,1))
-    user_fix = wls(rx_est_m, pos_sv_m, gt_pr_m, use_tx_time=True)
+    user_fix = wls(rx_est_m, pos_sv_m, gt_pr_m, sv_rx_time=True)
     truth_fix = rx_truth_m
 
     np.testing.assert_array_almost_equal(user_fix, truth_fix,
@@ -229,15 +229,15 @@ def test_wls_only_bias(set_user_states, set_sv_states, tolerance):
 
     # check that position doesn't change but clock bias does change
     rx_est_m = np.zeros((4,1))
-    user_fix = wls(rx_est_m, pos_sv_m, gt_pr_m, None, True, use_tx_time=True)
+    user_fix = wls(rx_est_m, pos_sv_m, gt_pr_m, None, True, sv_rx_time=True)
     np.testing.assert_array_almost_equal(user_fix[:3], np.zeros((3,1)),
                                          decimal=tolerance)
     assert abs(user_fix[3]) >= 1E5
 
     # check that correct clock bias is calculated
     rx_est_m = np.zeros((4,1))
     rx_est_m[:3] = rx_truth_m[:3]
-    user_fix = wls(rx_est_m, pos_sv_m, gt_pr_m, None, True, use_tx_time=True)
+    user_fix = wls(rx_est_m, pos_sv_m, gt_pr_m, None, True, sv_rx_time=True)
     truth_fix = rx_truth_m
 
     np.testing.assert_array_almost_equal(user_fix, truth_fix,
@@ -362,7 +362,7 @@ def test_solve_wls(derived):
         Instance of AndroidDerived2021 for testing.
 
     """
-    state_estimate = solve_wls(derived, use_tx_time=False)
+    state_estimate = solve_wls(derived, sv_rx_time=False)
 
     # result should be a NavData Class instance
     assert isinstance(state_estimate,type(NavData()))
@@ -403,12 +403,12 @@ def test_solve_wls_weights(derived, tolerance):
         Error threshold for test pass/fail
     """
 
-    state_estimate_1 = solve_wls(derived, use_tx_time=False)
-    state_estimate_2 = solve_wls(derived, None, use_tx_time=False)
+    state_estimate_1 = solve_wls(derived, sv_rx_time=False)
+    state_estimate_2 = solve_wls(derived, None, sv_rx_time=False)
 
     # create new column of unity weights
     derived["unity_weights"] = 1
-    state_estimate_3 = solve_wls(derived, "unity_weights",  use_tx_time=False)
+    state_estimate_3 = solve_wls(derived, "unity_weights",  sv_rx_time=False)
 
     # all of the above should be the same
     np.testing.assert_array_almost_equal(state_estimate_1.array,
@@ -418,7 +418,7 @@ def test_solve_wls_weights(derived, tolerance):
                                          state_estimate_3.array,
                                          decimal=tolerance)
 
-    state_estimate_4 = solve_wls(derived, "raw_pr_sigma_m",  use_tx_time=False)
+    state_estimate_4 = solve_wls(derived, "raw_pr_sigma_m",  sv_rx_time=False)
     with np.testing.assert_raises(AssertionError):
         np.testing.assert_array_almost_equal(state_estimate_1.array,
                                              state_estimate_4.array,
@@ -464,10 +464,10 @@ def test_wls_weights(set_user_states, set_sv_states, tolerance,
 
     # should work if None is passed
     user_fix_1 = wls(rx_est_m, pos_sv_m, noisy_pr_m, weights=None,
-                     use_tx_time=True)
+                     sv_rx_time=True)
     user_fix_2 = wls(rx_est_m, pos_sv_m, noisy_pr_m,
                      weights=np.ones((pos_sv_m.shape[0],1)),
-                     use_tx_time=True)
+                     sv_rx_time=True)
     # both should be unity weights and return the same result
     np.testing.assert_array_almost_equal(user_fix_1,
                                          user_fix_2,
@@ -476,7 +476,7 @@ def test_wls_weights(set_user_states, set_sv_states, tolerance,
     # result should be different if different weights are used
     user_fix_3 = wls(rx_est_m, pos_sv_m, noisy_pr_m,
                      weights=np.arange(pos_sv_m.shape[0]).reshape(-1,1),
-                     use_tx_time=True)
+                     sv_rx_time=True)
     with np.testing.assert_raises(AssertionError):
         np.testing.assert_array_almost_equal(user_fix_1,
                                              user_fix_3,
@@ -531,7 +531,7 @@ def test_solve_wls_bias_only(derived_2022):
             input_position[row, col] = measure_frame[row, 0]
         col += 1
     state_estimate = solve_wls(derived_2022, only_bias=True,
-                               receiver_state=derived_2022, use_tx_time=False)
+                               receiver_state=derived_2022, sv_rx_time=False)
     # Verify that both structures have the same length
     assert len(input_position) == len(state_estimate)
     # Verify that solved positions are the same as input positions
@@ -560,11 +560,11 @@ def test_solve_wls_bias_only(derived_2022):
     derived_2022.remove(ecef_rows, inplace=True)
     with pytest.raises(KeyError):
         solve_wls(derived_2022, only_bias=True,
-                receiver_state=derived_2022, use_tx_time=False)
+                receiver_state=derived_2022, sv_rx_time=False)
 
     # check error raised when receiver_state is not present in only_bias
     with pytest.raises(RuntimeError):
-        solve_wls(derived_2022, only_bias=True, use_tx_time=False)
+        solve_wls(derived_2022, only_bias=True, sv_rx_time=False)
 
 
 def test_wls_fails(capsys):
@@ -632,13 +632,13 @@ def test_rotation_of_earth_fix(derived_2022):
         google_wls[:, idx] = frame[['x_rx_m', 'y_rx_m', 'z_rx_m'], 0]
     derived_2022['wls_weights'] = 1/derived_2022['raw_pr_sigma_m']
     state_with_rotn = solve_wls(derived_2022, weight_type='wls_weights',
-                               use_tx_time=False)
+                               sv_rx_time=False)
     glp_wls = state_with_rotn[['x_rx_wls_m', 'y_rx_wls_m', 'z_rx_wls_m']]
     # Verify that the mean error between both estimates is less than 10m
     for idx in range(3):
         assert np.mean(np.abs(google_wls[idx, :] - glp_wls[idx, :])) < 30
     state_without_rotn = solve_wls(derived_2022, weight_type='wls_weights',
-                                   use_tx_time=True)
+                                   sv_rx_time=True)
     glp_wls_no_rotn = state_without_rotn[['x_rx_wls_m',
                                           'y_rx_wls_m',
                                           'z_rx_wls_m']]