satkit 0.20.0__tar.gz → 0.20.2__tar.gz

{satkit-0.20.0 → satkit-0.20.2}/Cargo.toml

@@ -3,7 +3,7 @@ members = [".", "python"]
 
 [package]
 name = "satkit"
-version = "0.20.0"
+version = "0.20.2"
 edition = "2021"
 description = "Satellite Toolkit"
 readme = "README.md"
@@ -28,7 +28,7 @@ ureq = { version = "3.1.2", optional = true }
 process_path = "0.1.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-quick-xml = { version = "0.38", features = ["serialize"], optional = true }
+quick-xml = { version = "0.41", features = ["serialize"], optional = true }
 chrono = { version = "0.4", optional = true }
 
 [dev-dependencies]
@@ -37,6 +37,7 @@ rand = "0.9.2"
 approx = "0.5"
 rand_distr = "0.5.1"
 criterion = "0.8.2"
+proptest = "1"
 
 [[bench]]
 name = "hotpaths"

{satkit-0.20.0 → satkit-0.20.2}/MANIFEST.in

@@ -6,6 +6,7 @@ include README.md
 include pyproject.toml
 include build.rs
 recursive-include src *.rs
+recursive-include benches *.rs
 recursive-include python/src *.rs
 include python/Cargo.toml
 include python/build.rs

{satkit-0.20.0 → satkit-0.20.2}/PKG-INFO

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

satkit-0.20.2/benches/hotpaths.rs

@@ -0,0 +1,189 @@
+//! Criterion benchmarks for satkit hot paths
+//!
+//! Covers the per-call costs that dominate real workloads: high-precision
+//! propagation (per-regime and per-integrator), SGP4, frame transforms,
+//! spherical-harmonic gravity, JPL ephemeris lookup, and the NRLMSISE-00
+//! density model.
+//!
+//! Data files (EOP, gravity models, JPL ephemeris, space weather) are
+//! resolved through the normal `satkit::utils::datadir()` discovery, same
+//! as the test suite. Run with `cargo bench`.
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
+
+use satkit::consts;
+use satkit::frametransform;
+use satkit::mathtypes::{Matrix6, Matrix67, Vector3, Vector6};
+use satkit::orbitprop::{propagate, Integrator, PropSettings, SatPropertiesSimple};
+use satkit::{Duration, Instant};
+
+fn epoch() -> Instant {
+    Instant::from_rfc3339("2024-01-01T00:00:00Z").unwrap()
+}
+
+/// Circular orbit state at radius `r` (meters) with inclination `incl` (radians)
+fn circular_state(r: f64, incl: f64) -> Vector6 {
+    let v = (consts::MU_EARTH / r).sqrt();
+    numeris::vector![r, 0.0, 0.0, 0.0, v * incl.cos(), v * incl.sin()]
+}
+
+const ISS_INCL_RAD: f64 = 51.6 * std::f64::consts::PI / 180.0;
+
+fn bench_propagation(c: &mut Criterion) {
+    let mut group = c.benchmark_group("propagation");
+    group
+        .sample_size(10)
+        .warm_up_time(std::time::Duration::from_secs(2))
+        .measurement_time(std::time::Duration::from_secs(20));
+
+    let t0 = epoch();
+    let t1 = t0 + Duration::from_days(1.0);
+
+    // LEO with drag + full default force model, adaptive RKV 9(8)
+    let leo = circular_state(consts::WGS84_A + 500.0e3, ISS_INCL_RAD);
+    let satprops = SatPropertiesSimple::new(0.02, 0.01);
+    let settings = PropSettings::default();
+    group.bench_function("leo_drag_1day_rkv98", |b| {
+        b.iter(|| propagate(black_box(&leo), &t0, &t1, &settings, Some(&satprops)).unwrap())
+    });
+
+    // GEO, sun/moon gravity dominated, adaptive RKV 9(8)
+    let geo = circular_state(consts::GEO_R, 0.0);
+    group.bench_function("geo_1day_rkv98", |b| {
+        b.iter(|| propagate(black_box(&geo), &t0, &t1, &settings, None).unwrap())
+    });
+
+    // GEO, fixed-step Gauss-Jackson 8
+    let settings_gj8 = PropSettings {
+        integrator: Integrator::GaussJackson8,
+        gj_step_seconds: 300.0,
+        ..PropSettings::default()
+    };
+    group.bench_function("geo_1day_gj8", |b| {
+        b.iter(|| propagate(black_box(&geo), &t0, &t1, &settings_gj8, None).unwrap())
+    });
+
+    // LEO with 6x6 state transition matrix (C = 7 state columns)
+    let mut leo_stm = Matrix67::zeros();
+    leo_stm.set_block(0, 0, &leo);
+    leo_stm.set_block(0, 1, &Matrix6::eye());
+    group.bench_function("leo_stm_1day_rkv98", |b| {
+        b.iter(|| propagate(black_box(&leo_stm), &t0, &t1, &settings, Some(&satprops)).unwrap())
+    });
+
+    group.finish();
+}
+
+fn bench_sgp4(c: &mut Criterion) {
+    let mut group = c.benchmark_group("sgp4");
+
+    let line0 = "0 INTELSAT 902";
+    let line1 = "1 26900U 01039A   06106.74503247  .00000045  00000-0  10000-3 0  8290";
+    let line2 = "2 26900   0.0164 266.5378 0003319  86.1794 182.2590  1.00273847 16981";
+    let tle = satkit::TLE::load_3line(line0, line1, line2).unwrap();
+
+    // 1 day of output at 1-minute cadence
+    let times: Vec<Instant> = (0..1441)
+        .map(|i| tle.epoch + Duration::from_seconds(60.0 * i as f64))
+        .collect();
+
+    // Includes per-TLE SGP4 initialization (fresh TLE each iteration)
+    group.bench_function("init_plus_1day_1min", |b| {
+        b.iter(|| {
+            let mut t = tle.clone();
+            satkit::sgp4::sgp4(&mut t, black_box(times.as_slice())).unwrap()
+        })
+    });
+
+    // Cached init state (same TLE reused), measures the propagation only
+    let mut warm = tle.clone();
+    let _ = satkit::sgp4::sgp4(&mut warm, &times[..1]).unwrap();
+    group.bench_function("cached_1day_1min", |b| {
+        b.iter(|| satkit::sgp4::sgp4(&mut warm, black_box(times.as_slice())).unwrap())
+    });
+
+    group.finish();
+}
+
+fn bench_frametransform(c: &mut Criterion) {
+    let mut group = c.benchmark_group("frametransform");
+    let tm = epoch();
+
+    // Warm the EOP singleton so first-load cost isn't measured
+    let _ = frametransform::qgcrf2itrf(&tm);
+
+    group.bench_function("qgcrf2itrf", |b| {
+        b.iter(|| frametransform::qgcrf2itrf(black_box(&tm)))
+    });
+    group.bench_function("qgcrf2itrf_approx", |b| {
+        b.iter(|| frametransform::qgcrf2itrf_approx(black_box(&tm)))
+    });
+    group.bench_function("qteme2itrf", |b| {
+        b.iter(|| frametransform::qteme2itrf(black_box(&tm)))
+    });
+    group.bench_function("gmst", |b| b.iter(|| frametransform::gmst(black_box(&tm))));
+
+    group.finish();
+}
+
+fn bench_earthgravity(c: &mut Criterion) {
+    let mut group = c.benchmark_group("earthgravity");
+
+    // LEO position in ITRF (slightly off-axis to exercise all terms)
+    let pos: Vector3 = numeris::vector![consts::WGS84_A + 400.0e3, 1000.0e3, 2000.0e3];
+    let gravity = satkit::earthgravity::jgm3();
+
+    group.bench_function("accel_deg4", |b| {
+        b.iter(|| gravity.accel(black_box(&pos), 4, 4))
+    });
+    group.bench_function("accel_deg16", |b| {
+        b.iter(|| gravity.accel(black_box(&pos), 16, 16))
+    });
+    group.bench_function("accel_and_partials_deg4", |b| {
+        b.iter(|| gravity.accel_and_partials(black_box(&pos), 4, 4))
+    });
+
+    group.finish();
+}
+
+fn bench_jplephem(c: &mut Criterion) {
+    let mut group = c.benchmark_group("jplephem");
+    let tm = epoch();
+
+    // Warm the ephemeris singleton
+    let _ = satkit::jplephem::geocentric_pos(satkit::SolarSystem::Moon, &tm);
+
+    group.bench_function("moon_geocentric_pos", |b| {
+        b.iter(|| satkit::jplephem::geocentric_pos(satkit::SolarSystem::Moon, black_box(&tm)))
+    });
+    group.bench_function("sun_geocentric_state", |b| {
+        b.iter(|| satkit::jplephem::geocentric_state(satkit::SolarSystem::Sun, black_box(&tm)))
+    });
+
+    group.finish();
+}
+
+fn bench_nrlmsise(c: &mut Criterion) {
+    let mut group = c.benchmark_group("nrlmsise");
+    let tm = epoch();
+
+    group.bench_function("density_400km", |b| {
+        b.iter(|| {
+            satkit::nrlmsise::nrlmsise(black_box(400.0), Some(0.5), Some(0.5), Some(&tm), true)
+        })
+    });
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_propagation,
+    bench_sgp4,
+    bench_frametransform,
+    bench_earthgravity,
+    bench_jplephem,
+    bench_nrlmsise
+);
+criterion_main!(benches);

{satkit-0.20.0 → satkit-0.20.2}/pyproject.toml

@@ -9,7 +9,7 @@ requires-python = ">= 3.10"
 authors = [{ name = "Steven Michael", email = "ssmichael@gmail.com" }]
 maintainers = [{ name = "Steven Michael", email = "ssmichael@gmail.com" }]
 readme = "README.md"
-version = "0.20.0"
+version = "0.20.2"
 license = "MIT OR Apache-2.0"
 description = "Satellite Orbital Dynamics Toolkit"
 keywords = [

{satkit-0.20.0 → satkit-0.20.2}/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satkit-python"
-version = "0.20.0"
+version = "0.20.2"
 edition = "2021"
 publish = false
 
@@ -10,8 +10,8 @@ crate-type = ["cdylib"]
 
 [dependencies]
 satkit = { path = "..", features = ["download"] }
-pyo3 = { version = "0.28.2", features = ["extension-module", "anyhow"] }
-numpy = "0.28"
+pyo3 = { version = "0.29", features = ["extension-module", "anyhow"] }
+numpy = "0.29"
 numeris = { version = "0.5.14", features = ["serde", "ode"] }
 anyhow = "1"
 serde = { version = "1.0", features = ["derive"] }
@@ -19,4 +19,4 @@ serde-pickle = "1.2.0"
 process_path = "0.1.4"
 
 [build-dependencies]
-pyo3-build-config = "0.28.2"
+pyo3-build-config = "0.29"

{satkit-0.20.0 → satkit-0.20.2}/python/satkit.egg-info/PKG-INFO

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

{satkit-0.20.0 → satkit-0.20.2}/python/satkit.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ MANIFEST.in
 README.md
 build.rs
 pyproject.toml
+benches/hotpaths.rs
 python/Cargo.toml
 python/build.rs
 python/satkit/__init__.py

{satkit-0.20.0 → satkit-0.20.2}/python/src/pypropsettings.rs

@@ -394,10 +394,7 @@ impl PyPropSettings {
                     Some(d.0.as_seconds())
                 } else if let Ok(secs) = obj.extract::<f64>() {
                     Some(secs)
-                } else if let Ok(delta) = {
-                    #[allow(deprecated)]
-                    obj.downcast::<PyDelta>()
-                } {
+                } else if let Ok(delta) = obj.cast::<PyDelta>() {
                     Some(
                         delta.get_days() as f64 * 86400.0
                             + delta.get_seconds() as f64

{satkit-0.20.0 → satkit-0.20.2}/python/src/pysgp4.rs

@@ -391,7 +391,7 @@ pub fn sgp4(
         // TLE sources keep a handle to the originating Python object so the
         // cached SGP4 init state can be written back afterward.
         enum Sgp4Source {
-            Tle(Py<PyTLE>, satkit::TLE),
+            Tle(Py<PyTLE>, Box<satkit::TLE>),
             Omm(Box<satkit::omm::OMM>),
         }
 
@@ -402,7 +402,7 @@ pub fn sgp4(
                     let pytle: Py<PyTLE> = item.extract().map_err(|e| {
                         pyo3::exceptions::PyValueError::new_err(format!("Invalid TLE: {}", e))
                     })?;
-                    let rtle = pytle.borrow(item.py()).0.clone();
+                    let rtle = Box::new(pytle.borrow(item.py()).0.clone());
                     Ok(Sgp4Source::Tle(pytle, rtle))
                 } else if item.is_instance_of::<PyDict>() {
                     let dict: &Bound<'_, PyDict> = item.cast().map_err(|e| {
@@ -428,7 +428,7 @@ pub fn sgp4(
                 .map(|src| -> Result<psgp4::SGP4State> {
                     match src {
                         Sgp4Source::Tle(_, rtle) => {
-                            Ok(psgp4::sgp4_full(rtle, tmarray.as_slice(), gc, om)?)
+                            Ok(psgp4::sgp4_full(rtle.as_mut(), tmarray.as_slice(), gc, om)?)
                         }
                         Sgp4Source::Omm(omm) => {
                             Ok(psgp4::sgp4_full(omm.as_mut(), tmarray.as_slice(), gc, om)?)
@@ -441,7 +441,7 @@ pub fn sgp4(
         // Write the TLEs back to preserve their cached SGP4 init state
         for src in &sources {
             if let Sgp4Source::Tle(pytle, rtle) = src {
-                pytle.borrow_mut(tle.py()).0 = rtle.clone();
+                pytle.borrow_mut(tle.py()).0 = rtle.as_ref().clone();
             }
         }
 

{satkit-0.20.0 → satkit-0.20.2}/src/kepler.rs

@@ -76,23 +76,32 @@ pub struct Kepler {
 // Convert mean to eccentric anomaly
 // iterative solution required
 fn mean2eccentric(m: f64, eccen: f64) -> f64 {
-    use std::f64::consts::PI;
+    use std::f64::consts::TAU;
+    // Range-reduce the mean anomaly to [0, 2π). Kepler's equation shifts by
+    // 2πk in E and M together, so the solution for the reduced M is shifted
+    // back at the end. Without this, an unwrapped M (e.g. after propagating
+    // multiple revolutions) puts the naive initial guess in a near-flat region
+    // of the equation at high eccentricity, where Newton's trajectory turns
+    // chaotic and can exhaust the iteration cap with a wildly wrong root.
+    let k = (m / TAU).floor();
+    let mr = m - k * TAU;
+
+    // Danby (1987) initial guess: E₀ = M + 0.85·e·sign(sin M). Together with
+    // the range reduction this keeps plain Newton convergent in < ~10
+    // iterations for all eccentricities below 1, including e > 0.9.
     #[allow(non_snake_case)]
-    let mut E = match (m > PI) || ((m < 0.0) && (m > -PI)) {
-        true => m - eccen,
-        false => m + eccen,
-    };
-    // Newton's method converges quadratically for bound orbits (< ~10 steps
-    // for e < 0.99). Cap the iteration count so a pathological eccentricity
-    // (e >= 1, where the step can go non-finite) cannot spin forever.
-    for _ in 0..30 {
-        let de = eccen.mul_add(E.sin(), m - E) / eccen.mul_add(-E.cos(), 1.0);
+    let mut E = mr + 0.85 * eccen * if mr.sin() >= 0.0 { 1.0 } else { -1.0 };
+
+    // Cap the iteration count so a pathological eccentricity (e >= 1, where
+    // the step can go non-finite) cannot spin forever.
+    for _ in 0..50 {
+        let de = eccen.mul_add(E.sin(), mr - E) / eccen.mul_add(-E.cos(), 1.0);
         E += de;
-        if de.abs() < 1.0e-12 {
+        if de.abs() < 1.0e-13 {
             break;
         }
     }
-    E
+    E + k * TAU
 }
 
 fn eccentric2true(ea: f64, eccen: f64) -> f64 {

{satkit-0.20.0 → satkit-0.20.2}/src/orbitprop/tides.rs

@@ -51,6 +51,9 @@ pub struct TideDeltas {
 // Index convention: K_RE[n][m], K_IM[n][m].
 // Entries outside the (n,m) range listed in Table 6.3 are zero.
 // ---------------------------------------------------------------------------
+// The k_22 Love number (0.30102) coincidentally resembles log10(2); it is a
+// physical constant from Table 6.3, not a math constant.
+#[allow(clippy::approx_constant)]
 const K_RE: [[f64; 4]; 4] = [
     [0.0, 0.0, 0.0, 0.0],
     [0.0, 0.0, 0.0, 0.0],
@@ -71,7 +74,10 @@ const K_PLUS: [f64; 3] = [-0.00089, -0.00080, -0.00057];
 // Fully-normalized associated-Legendre normalization factors
 // N_nm = sqrt((2 - δ_0m)(2n+1)(n-m)!/(n+m)!). Constants chosen to allow
 // the recursion-free closed-form evaluation of P̄_nm used here.
+// Written to full precision deliberately (clippy flags a digit beyond f64's
+// round-trip length on N21; keeping the mathematical value verbatim).
 // ---------------------------------------------------------------------------
+#[allow(clippy::excessive_precision)]
 const N20: f64 = 2.2360679774997896; // sqrt(5)
 const N21: f64 = 1.2909944487358056; // sqrt(5/3)
 const N22: f64 = 0.6454972243679028; // sqrt(5/12)

{satkit-0.20.0 → satkit-0.20.2}/src/time/instant.rs

@@ -320,7 +320,7 @@ impl Instant {
             TimeScale::UT1 => {
                 // This will be approximately correct for computing ut1
                 let eop = crate::earth_orientation_params::eop_from_mjd_utc_or_zero(mjd);
-                let dut1 = eop[0] as f64;
+                let dut1 = eop[0];
                 Self::from_mjd_with_scale(mjd - dut1 / 86_400.0, TimeScale::UTC)
             }
             TimeScale::GPS => {
@@ -415,7 +415,7 @@ impl Instant {
             TimeScale::UT1 => {
                 let mjd_utc = self.as_mjd_utc();
                 let eop = crate::earth_orientation_params::eop_from_mjd_utc_or_zero(mjd_utc);
-                let dut1 = eop[0] as f64;
+                let dut1 = eop[0];
                 mjd_utc + dut1 / 86_400.0
             }
             TimeScale::TAI => (self.raw - Self::MJD_EPOCH.raw) as f64 / 86_400_000_000.0,

{satkit-0.20.0 → satkit-0.20.2}/src/time/timescale.rs

@@ -10,7 +10,7 @@
 /// * `TDB` - Barycentric Dynamical Time
 /// * `Invalid` - Invalid
 ///    
-#[derive(PartialEq, Eq, Debug)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 #[allow(clippy::upper_case_acronyms)]
 pub enum TimeScale {
     /// Invalid