satkit 0.3.6__tar.gz → 0.3.8__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.3.6
+Version: 0.3.8
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy>=1.20.0
+Requires-Dist: numpy>=1.0.0
 
 # Satellite Toolkit with Rust
 

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.3.6
+Version: 0.3.8
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy>=1.20.0
+Requires-Dist: numpy>=1.0.0
 
 # Satellite Toolkit with Rust
 

satkit-0.3.8/python/satkit.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.0.0

{satkit-0.3.6 → satkit-0.3.8}/src/earthgravity.rs

@@ -330,13 +330,13 @@ impl Gravity {
         } else if order == 36 {
             self.accel_and_partials_t::<36, 40>(pos)
         } else if order == 37 {
-            self.accel_and_partials_t::<37, 15>(pos)
+            self.accel_and_partials_t::<37, 41>(pos)
         } else if order == 38 {
-            self.accel_and_partials_t::<38, 16>(pos)
+            self.accel_and_partials_t::<38, 42>(pos)
         } else if order == 39 {
-            self.accel_and_partials_t::<39, 17>(pos)
+            self.accel_and_partials_t::<39, 43>(pos)
         } else {
-            self.accel_and_partials_t::<40, 20>(pos)
+            self.accel_and_partials_t::<40, 44>(pos)
         }
     }
 
@@ -481,38 +481,57 @@ impl Gravity {
 
     fn compute_legendre<const NP4: usize>(&self, pos: &Vec3) -> (Legendre<NP4>, Legendre<NP4>) {
         let rsq = pos.norm_squared();
-        let xfac = pos[0] * self.radius / rsq;
-        let yfac = pos[1] * self.radius / rsq;
-        let zfac = pos[2] * self.radius / rsq;
-        let rfac = self.radius * self.radius / rsq;
+        let scale = self.radius / rsq;
+        let xfac = pos[0] * scale;
+        let yfac = pos[1] * scale;
+        let zfac = pos[2] * scale;
+        let rfac = self.radius * scale;
 
         let mut v = Legendre::<NP4>::zeros();
         let mut w = Legendre::<NP4>::zeros();
 
-        v[(0, 0)] = self.radius / rsq.sqrt();
-        w[(0, 0)] = 0.0;
+        let mut vmm1mm1 = self.radius / rsq.sqrt();
+        let mut wmm1mm1 = 0.0;
+        v[(0, 0)] = vmm1mm1;
+        w[(0, 0)] = wmm1mm1;
 
-        for m in 0..(NP4 - 1) {
-            // Along diagnoals
+        for m in 0..NP4 {
             if m > 0 {
-                v[(m, m)] = self.divisor_table[(m, m)]
-                    * (xfac * v[(m - 1, m - 1)] - yfac * w[(m - 1, m - 1)]);
-                w[(m, m)] = self.divisor_table[(m, m)]
-                    * (xfac * w[(m - 1, m - 1)] + yfac * v[(m - 1, m - 1)]);
+                let d = self.divisor_table[(m, m)];
+                v[(m, m)] = d * (xfac * vmm1mm1 - yfac * wmm1mm1);
+                w[(m, m)] = d * (xfac * wmm1mm1 + yfac * vmm1mm1);
             }
-            // Work down tree
-            let n = m + 1;
-            v[(n, m)] = self.divisor_table[(n, m)] * zfac * v[(n - 1, m)];
-            w[(n, m)] = self.divisor_table[(n, m)] * zfac * w[(n - 1, m)];
 
-            for n in (m + 2)..(NP4 - 1) {
-                v[(n, m)] = self.divisor_table[(n, m)] * zfac * v[(n - 1, m)]
-                    - self.divisor_table2[(n, m)] * rfac * v[(n - 2, m)];
+            vmm1mm1 = v[(m, m)];
+            wmm1mm1 = w[(m, m)];
+            let mut vnm2m = vmm1mm1;
+            let mut wnm2m = wmm1mm1;
 
-                w[(n, m)] = self.divisor_table[(n, m)] * zfac * w[(n - 1, m)]
-                    - self.divisor_table2[(n, m)] * rfac * w[(n - 2, m)];
+            let n = m + 1;
+            if n >= NP4 {
+                continue;
+            }
+            let d = self.divisor_table[(n, m)] * zfac;
+            let mut vnm1m = d * vnm2m;
+            let mut wnm1m = d * wnm2m;
+            v[(n, m)] = vnm1m;
+            w[(n, m)] = wnm1m;
+
+            for n in (m + 2)..NP4 {
+                let d = self.divisor_table[(n, m)] * zfac;
+                let d2 = self.divisor_table2[(n, m)] * rfac;
+                let vnm = d * vnm1m - d2 * vnm2m;
+                let wnm = d * wnm1m - d2 * wnm2m;
+                v[(n, m)] = vnm;
+                w[(n, m)] = wnm;
+                vnm2m = vnm1m;
+                vnm1m = vnm;
+
+                wnm2m = wnm1m;
+                wnm1m = wnm;
             }
         }
+
         (v, w)
     }
 
@@ -609,35 +628,28 @@ impl Gravity {
             }
         }
 
+        let mut d1 = DivisorTable::zeros();
+        let mut d2 = DivisorTable::zeros();
+        for m in 0..43 {
+            if m > 0 {
+                d1[(m, m)] = (2 * m - 1) as f64
+            }
+            let n = m + 1;
+            d1[(n, m)] = (2 * n - 1) as f64 / (n - m) as f64;
+            for n in (m + 2)..43 {
+                d1[(n, m)] = (2 * n - 1) as f64 / (n - m) as f64;
+                d2[(n, m)] = (n + m - 1) as f64 / (n - m) as f64;
+            }
+        }
+
         Ok(Gravity {
             name: String::from(name),
             gravity_constant: gravity_constant,
             radius: radius,
             max_degree: max_degree,
             coeffs: cs,
-            divisor_table: {
-                let mut dt: DivisorTable = DivisorTable::zeros();
-                for m in 0..43 {
-                    if m > 0 {
-                        dt[(m, m)] = 2.0 * m as f64 - 1.0;
-                    }
-                    let n = m + 1;
-                    dt[(n, m)] = (2.0 * n as f64 - 1.0) / (n - m) as f64;
-                    for n in (m + 2)..19 {
-                        dt[(n, m)] = (2.0 * n as f64 - 1.0) / (n - m) as f64;
-                    }
-                }
-                dt
-            },
-            divisor_table2: {
-                let mut dt: DivisorTable = DivisorTable::zeros();
-                for m in 0..19 {
-                    for n in (m + 2)..19 {
-                        dt[(n, m)] = (n as f64 + m as f64 - 1.0) / (n - m) as f64;
-                    }
-                }
-                dt
-            },
+            divisor_table: d1,
+            divisor_table2: d2,
         })
     }
 }

{satkit-0.3.6 → satkit-0.3.8}/src/lpephem/sun.rs

@@ -105,13 +105,14 @@ pub fn shadowfunc(psun: &Vec3, psat: &Vec3) -> f64 {
     let c = (-psat.dot(&(psun - psat)) / snorm / (psun - psat).norm()).acos();
     if a + b <= c {
         1.0
-    } else if c < b - a {
+    } else if c < (b - a) {
         0.0
     } else {
         let x = (c * c + a * a - b * b) / 2.0 / c;
         let y = (a * a - x * x).sqrt();
         let big_a = a * a * (x / a).acos() + b * b * ((c - x) / b).acos() - c * y;
-        1.0 - big_a / std::f64::consts::PI / a / a
+        let frac = 1.0 - big_a / std::f64::consts::PI / a / a;
+        frac
     }
 }
 

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

@@ -25,12 +25,21 @@ pub trait RKAdaptive<const N: usize, const NI: usize> {
         if sol.dense.is_none() {
             return Err(Box::new(ODEError::NoDenseOutputInSolution));
         }
+        let dense = sol.dense.as_ref().unwrap();
+
         if sol.x < xinterp {
-            return Err(Box::new(ODEError::InterpExceedsSolutionBounds));
+            return Err(Box::new(ODEError::InterpExceedsSolutionBounds {
+                interp: xinterp,
+                start: dense.x[0],
+                stop: sol.x,
+            }));
         }
-        let dense = sol.dense.as_ref().unwrap();
-        if sol.x < dense.x[0] {
-            return Err(Box::new(ODEError::InterpExceedsSolutionBounds));
+        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
@@ -137,11 +146,9 @@ pub trait RKAdaptive<const N: usize, const NI: usize> {
         };
 
         // OK ... lets integrate!
-        let mut runloop: bool = true;
-        while runloop {
-            if (tdir > 0.0 && x + h >= xend) || (tdir < 0.0 && x + h <= xend) {
+        loop {
+            if (tdir > 0.0 && (x + h) >= xend) || (tdir < 0.0 && (x + h) <= xend) {
                 h = xend - x;
-                runloop = false;
             }
             let mut karr = Vec::new();
             karr.push(system.ydot(x, &y)?);
@@ -223,7 +230,9 @@ pub trait RKAdaptive<const N: usize, const NI: usize> {
                 h = h / q;
 
                 naccept += 1;
-                // If dense output, limit step size
+                if (tdir > 0.0 && x >= xend) || (tdir < 0.0 && x <= xend) {
+                    break;
+                }
             } else {
                 nreject += 1;
                 h = h / f64::min(1.0 / settings.minfac, q11 / settings.gamma);

{satkit-0.3.6 → satkit-0.3.8}/src/ode/types.rs

@@ -53,8 +53,8 @@ pub enum ODEError {
     StepErrorToSmall,
     #[error("No Dense Output in Solution")]
     NoDenseOutputInSolution,
-    #[error("Interpolation exceeds solution bounds")]
-    InterpExceedsSolutionBounds,
+    #[error("Interpolation exceeds solution bounds: {interp} not in [{start}, {stop}]")]
+    InterpExceedsSolutionBounds { interp: f64, start: f64, stop: f64 },
     #[error("Interpolation not implemented for this integrator")]
     InterpNotImplemented,
 }

{satkit-0.3.6 → satkit-0.3.8}/src/pybindings/pypropagate.rs

@@ -175,6 +175,28 @@ pub fn propagate(
     }
     // Propagate with state transition matrix
     else {
-        pyo3::Python::with_gil(|py| -> PyResult<PyObject> { Ok(py.None()) })
+        // Create the state to propagate
+        let mut pv = na::SMatrix::<f64, 6, 7>::zeros();
+        pv.fixed_view_mut::<3, 1>(0, 0)
+            .copy_from_slice(unsafe { pos.as_slice().unwrap() });
+        pv.fixed_view_mut::<3, 1>(3, 0)
+            .copy_from_slice(unsafe { vel.as_slice().unwrap() });
+        pv.fixed_view_mut::<6, 6>(0, 1)
+            .copy_from(&na::Matrix6::<f64>::identity());
+        let res = crate::orbitprop::propagate(
+            &pv,
+            &start.inner,
+            &stoptime,
+            &propsettings,
+            satproperties,
+            output_dense,
+        )
+        .unwrap();
+        pyo3::Python::with_gil(|py| -> PyResult<PyObject> {
+            Ok(PyPropResult {
+                inner: PyPropResultType::R7(res),
+            }
+            .into_py(py))
+        })
     }
 }

satkit-0.3.6/python/satkit.egg-info/requires.txt

@@ -1 +0,0 @@
-numpy>=1.20.0