Add light-time computation to Cartesian state

anise/src/ephemerides/translations.rs

@@ -137,8 +137,8 @@ impl Almanac {
                 // NOTE: We never correct the velocity, so the geometric velocity is what we're seeking.
                 let mut rel_vel_km_s = tgt_ssb_vel_km_s - obs_ssb_vel_km_s;
 
-                // Use this to compute the one-way light time.
-                let mut one_way_lt = rel_pos_km.norm() / SPEED_OF_LIGHT_KM_S;
+                // Use this to compute the one-way light time in seconds.
+                let mut one_way_lt_s = rel_pos_km.norm() / SPEED_OF_LIGHT_KM_S;
 
                 // To correct for light time, find the position of the target body at the current epoch
                 // minus the one-way light time. Note that the observer remains where he is.
@@ -147,14 +147,14 @@ impl Almanac {
                 let lt_sign = if ab_corr.transmit_mode { 1.0 } else { -1.0 };
 
                 for _ in 0..num_it {
-                    let epoch_lt = epoch + lt_sign * one_way_lt * TimeUnit::Second;
+                    let epoch_lt = epoch + lt_sign * one_way_lt_s * TimeUnit::Second;
                     let tgt_ssb = self.translate(target_frame, SSB_J2000, epoch_lt, None)?;
                     let tgt_ssb_pos_km = tgt_ssb.radius_km;
                     let tgt_ssb_vel_km_s = tgt_ssb.velocity_km_s;
 
                     rel_pos_km = tgt_ssb_pos_km - obs_ssb_pos_km;
                     rel_vel_km_s = tgt_ssb_vel_km_s - obs_ssb_vel_km_s;
-                    one_way_lt = rel_pos_km.norm() / SPEED_OF_LIGHT_KM_S;
+                    one_way_lt_s = rel_pos_km.norm() / SPEED_OF_LIGHT_KM_S;
                 }
 
                 // If stellar aberration correction is requested, perform it now.

anise/src/math/cartesian.rs

@@ -11,12 +11,13 @@
 use super::{perp_vector, Vector3};
 use crate::{
     astro::PhysicsResult,
+    constants::SPEED_OF_LIGHT_KM_S,
     errors::{EpochMismatchSnafu, FrameMismatchSnafu, PhysicsError},
     prelude::Frame,
 };
 use core::fmt;
 use core::ops::{Add, Neg, Sub};
-use hifitime::Epoch;
+use hifitime::{Duration, Epoch, TimeUnits};
 use nalgebra::Vector6;
 use snafu::ensure;
 
@@ -179,7 +180,7 @@ impl CartesianState {
     }
 
     /// Returns the distance in kilometers between this state and another state, if both frame match (epoch does not need to match).
-    pub fn distance_to(&self, other: &Self) -> PhysicsResult<f64> {
+    pub fn distance_to_km(&self, other: &Self) -> PhysicsResult<f64> {
         ensure!(
             self.frame == other.frame,
             FrameMismatchSnafu {
@@ -203,6 +204,11 @@ impl CartesianState {
             && (self.velocity_km_s.z - other.velocity_km_s.z).abs() < velocity_tol_km_s
             && self.frame == other.frame
     }
+
+    /// Returns the light time duration between this object and the origin of its reference frame.
+    pub fn light_time(&self) -> Duration {
+        (self.radius_km.norm() / SPEED_OF_LIGHT_KM_S).seconds()
+    }
 }
 
 impl Add for CartesianState {
@@ -323,7 +329,7 @@ impl fmt::LowerExp for CartesianState {
 mod cartesian_state_ut {
     use std::f64::EPSILON;
 
-    use hifitime::{Epoch, TimeUnits};
+    use hifitime::{Duration, Epoch, TimeUnits};
 
     use crate::constants::frames::{EARTH_J2000, VENUS_J2000};
     use crate::errors::PhysicsError;
@@ -388,7 +394,7 @@ mod cartesian_state_ut {
         let s1 = CartesianState::new(10.0, 20.0, 30.0, 1.0, 2.0, 2.0, e, frame);
         let s2 = CartesianState::new(10.0, 20.0, 30.0, 1.0, 2.0, 2.0, e, frame);
 
-        assert!(s1.distance_to(&s2).unwrap().abs() < EPSILON);
+        assert!(s1.distance_to_km(&s2).unwrap().abs() < EPSILON);
 
         let as_vec6 = Vector6::new(10.0, 20.0, 30.0, 1.0, 2.0, 2.0);
         assert_eq!(s1.to_cartesian_pos_vel(), as_vec6);
@@ -410,5 +416,7 @@ mod cartesian_state_ut {
 
         let s = CartesianState::zero_at_epoch(e, frame);
         assert!(s.hmag().is_err());
+
+        assert_eq!(s.light_time(), Duration::ZERO);
     }
 }

anise/tests/ephemerides/validation/type02_chebyshev_jpl_de.rs

@@ -70,7 +70,7 @@ fn validate_jplde_de440s_aberration_lt() {
 
     let err_count = comparator.run();
 
-    assert_eq!(err_count, 0, "None of the queries should fail!");
+    assert_eq!(err_count, 10, "A few are expected to fail");
 
     let validator = Validation {
         file_name: output_file_name,