satkit 0.3.8__tar.gz → 0.3.9__tar.gz

{satkit-0.3.8 → satkit-0.3.9}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satkit"
-version = "0.3.8"
+version = "0.3.9"
 edition = "2021"
 description = "Satellite Toolkit"
 readme = "README.md"

{satkit-0.3.8/python/satkit.egg-info → satkit-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.3.8
+Version: 0.3.9
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>

{satkit-0.3.8 → satkit-0.3.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "satkit"
-version = "0.3.8"
+version = "0.3.9"
 dependencies = ["numpy>=1.0.0"]
 requires-python = ">= 3.8"
 authors = [{ name = "Steven Michael", email = "ssmichael@gmail.com" }]

{satkit-0.3.8 → satkit-0.3.9}/python/satkit/satkit.pyi

@@ -1694,9 +1694,9 @@ def propagate(
         duration (satkit.duration): duration from "tm" at which new position & velocity will be computed.
         output_phi (bool): Output 6x6 state transition matrix between "starttime" and "stoptime" (and at intervals, if specified)
         propsettings (propsettings): "propsettings" object with input settings for the propagation. if left out, default will be used.
-        satproperties (satproperties_static): "SatPropertiesStatic" object with drag and radiation pressure succeptibility of satellite. If left out, drag and radiation pressure are neglected
-        output_dense: boolean indicting whether or not dense output should be recorded.  Default is false.  If true, this will allow for calling the "interp" function to query states at arbitrary times between the start time and the stop time
-
+        satproperties (satproperties_static): "SatPropertiesStatic" object with drag and radiation pressure succeptibility of satellite. 
+        output_dense: boolean indicting whether or not dense output should be recorded.  Default is false.  
+        
     Returns:
         (propresult): Propagation result object holding state outputs, statistics, and dense output if requested
     """

{satkit-0.3.8 → satkit-0.3.9/python/satkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.3.8
+Version: 0.3.9
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>

{satkit-0.3.8 → satkit-0.3.9}/python/test/test.py

@@ -575,6 +575,27 @@ class TestGeodesicDistance:
 
 class TestHighPrecisionPropagation:
 
+    def test_interp(self):
+        starttime = sk.time(2015, 3, 20, 0, 0, 0)
+        
+        pos = np.array([sk.consts.geo_r, 0, 0])
+        vel = np.array([0, m.sqrt(sk.consts.mu_earth/sk.consts.geo_r), 0])
+        stoptime = starttime + sk.duration.from_days(1.0)
+        
+        # Propagate forward
+        res1 = sk.propagate(pos, vel, starttime, stoptime=stoptime, output_dense=True)
+        # Propagate backward and see if we recover original result
+        res2 = sk.propagate(res1.state[0:3], res1.state[3:6], stoptime, stoptime=starttime, output_dense=True)
+    
+        assert res2.state[0:3] == pytest.approx(pos, abs=0.5)
+        assert res2.state[3:6] == pytest.approx(vel, abs=1e-5)
+
+        newtime = starttime + sk.duration.from_hours(4.332)
+        istate1 = res1.interp(newtime)
+        istate2 = res2.interp(newtime)
+      
+        assert(istate1 == pytest.approx(istate2, rel=1e-8))
+
     def test_gps(self):
 
         # File contains test calculation vectors provided by NASA

{satkit-0.3.8 → satkit-0.3.9}/src/ode/rk_adaptive.rs

@@ -18,15 +18,31 @@ pub trait RKAdaptive<const N: usize, const NI: usize> {
     /// (first compute of next iteration is same as last compute of last iteration)
     const FSAL: bool;
 
+    fn interpolate<S: ODEState>(xinterp: f64, sol: &ODESolution<S>) -> ODEResult<S> {
+        if sol.dense.is_none() {
+            return Err(Box::new(ODEError::NoDenseOutputInSolution));
+        }
+        let dense = sol.dense.as_ref().unwrap();
+
+        // These could probably be combined into a single function, but...
+        // keeping forward and backward separate makes it simpler in my mind
+        if sol.x > dense.x[0] {
+            return Self::interpolate_forward(xinterp, sol);
+        } else {
+            return Self::interpolate_backward(xinterp, sol);
+        }
+    }
+
     /// Interpolate densely calculated solution onto
     /// values that are evenly spaced in "x"
-    ///
-    fn interpolate<S: ODEState>(xinterp: f64, sol: &ODESolution<S>) -> ODEResult<S> {
+    /// for forward direction
+    fn interpolate_forward<S: ODEState>(xinterp: f64, sol: &ODESolution<S>) -> ODEResult<S> {
         if sol.dense.is_none() {
             return Err(Box::new(ODEError::NoDenseOutputInSolution));
         }
         let dense = sol.dense.as_ref().unwrap();
 
+        // Check if interpolation point is within bounds
         if sol.x < xinterp {
             return Err(Box::new(ODEError::InterpExceedsSolutionBounds {
                 interp: xinterp,
@@ -93,6 +109,82 @@ pub trait RKAdaptive<const N: usize, const NI: usize> {
         Ok(y)
     }
 
+    /// Interpolate densely calculated solution onto
+    /// values that are evenly spaced in "x"
+    /// for backward direction
+    fn interpolate_backward<S: ODEState>(xinterp: f64, sol: &ODESolution<S>) -> ODEResult<S> {
+        if sol.dense.is_none() {
+            return Err(Box::new(ODEError::NoDenseOutputInSolution));
+        }
+        let dense = sol.dense.as_ref().unwrap();
+
+        // Check if interpolation point is within bounds
+        if sol.x > xinterp {
+            return Err(Box::new(ODEError::InterpExceedsSolutionBounds {
+                interp: xinterp,
+                start: dense.x[0],
+                stop: sol.x,
+            }));
+        }
+        if xinterp > dense.x[0] {
+            return Err(Box::new(ODEError::InterpExceedsSolutionBounds {
+                interp: xinterp,
+                start: dense.x[0],
+                stop: sol.x,
+            }));
+        }
+
+        // We know indices are monotonically increasing, so only search from
+        // last found position in the array forward
+        let mut idx = match dense.x.iter().position(|x| *x <= xinterp) {
+            Some(v) => v,
+            None => dense.x.len(),
+        };
+        if idx > 0 {
+            idx -= 1;
+        }
+
+        // t is fractional distance beween x at idx and idx+1
+        // and is in range [0,1]
+        let t = (xinterp - dense.x[idx]) / dense.h[idx];
+
+        // Compute interpolant coefficient as funciton of t
+        // note that t is in range [0,1]
+        //
+        // This is equation (6) of
+        // https://link.springer.com/article/10.1023/A:1021190918665
+        //
+        // Note: equation (6) of paper incorrectly has sum index "j"
+        //       starting from 0.  It should start from 1.
+        //
+        let bi: Vec<f64> = Self::BI
+            .iter()
+            .map(|biarr| {
+                // Coefficients multiply increasing powers of t
+                let mut tj = 1.0;
+                biarr.iter().fold(0.0, |acc, bij| {
+                    tj = tj * t;
+                    acc + bij * tj
+                })
+            })
+            .collect();
+
+        //
+        // Compute interpolated value
+        //
+        // This is equation(5) of:
+        // https://link.springer.com/article/10.1023/A:1021190918665
+        //
+        let mut y = dense.yprime[idx]
+            .iter()
+            .enumerate()
+            .fold(dense.y[idx].clone() / dense.h[idx], |acc, (ix, k)| {
+                acc + k.clone() * bi[ix]
+            });
+        y = y * dense.h[idx];
+        Ok(y)
+    }
+
     ///
     /// Runga-Kutta integration
     /// with Proportional-Integral controller

{satkit-0.3.8 → satkit-0.3.9}/src/orbitprop/propagator.rs

@@ -525,7 +525,7 @@ mod tests {
     #[test]
     fn test_interp() -> SKResult<()> {
         let starttime = AstroTime::from_datetime(2015, 3, 20, 0, 0, 0.0);
-        let stoptime = starttime + Duration::Days(0.5);
+        let stoptime = starttime + Duration::Days(1.0);
 
         let mut state: SimpleState = SimpleState::zeros();
 
@@ -539,10 +539,23 @@ mod tests {
         settings.gravity_interp_dt_secs = 300.0;
         settings.use_jplephem = false;
 
+        // Propagate forward
         let res = propagate(&state, &starttime, &stoptime, &settings, None, true)?;
+        // propagate backward to original time
+        let res2 = propagate(&res.state_end, &stoptime, &starttime, &settings, None, true)?;
+        // Check that we recover the original state
+        for ix in 0..6 as usize {
+            assert!((state[ix] - res2.state_end[ix]).abs() < 1.0e-3);
+        }
 
-        let newtime = starttime + Duration::Days(0.25);
-        let _interp = res.interp(&newtime)?;
+        // Check interpolation forward and backward return the same result
+        let newtime = starttime + Duration::Days(0.45);
+        let interp = res.interp(&newtime)?;
+        let interp2 = res2.interp(&newtime)?;
+
+        for ix in 0..6 as usize {
+            assert!((interp[ix] - interp2[ix]).abs() < 1e-3);
+        }
         Ok(())
     }