Struct Sp3 

pub struct Sp3 {
    pub header: Sp3Header,
    pub epochs: Vec<Instant>,
    pub comments: Vec<String>,
    pub skipped_records: usize,
    /* private fields */
}

A parsed SP3 precise-ephemeris product.

Construct with Sp3::parse. Epochs are stored in file order; exact-product consumers can use validate_exact_sp3 to require a strictly increasing, regular requested-cadence grid. Each epoch maps satellite -> Sp3State. Per-satellite/per-epoch access is via Sp3::state; arbitrary-epoch interpolation is built separately to match the parity reference and is not part of this parser.

Fields

header: Sp3Header

The parsed header.

epochs: Vec<Instant>

Epochs in file order, tagged with the header time scale.

comments: Vec<String>

Free-form /* comment lines (notice retained for provenance).

skipped_records: usize

Count of entries skipped because their satellite token did not parse to a representable GnssSatelliteId (e.g. an extended GLONASS slot like R28 beyond the engine’s PRN cap): position/velocity records, plus +-header satellite declarations. Lets callers tell a clean file (skipped_records == 0) apart from one carrying unsupported satellites, without aborting the whole parse on one such entry. Mirrors crate::astro::sgp4::TleFile::skipped.

Implementations

impl Sp3

pub fn epochs_j2000_seconds(&self) -> Vec<f64>

The product’s parsed epochs as seconds since J2000, in the file’s own time scale, ascending.

This is the exact query axis Sp3::position_at_j2000_seconds uses for parsed record nodes, so a caller can read the grid here, form query times on it, and feed them straight back without a Julian-date round trip. An unmodified parsed product returns one value per epoch.

pub fn position(&self, sat: GnssSatelliteId, epoch: Instant) -> Result<Sp3State>

Interpolate the state of sat at an arbitrary epoch.

Reproduces the pinned scipy.interpolate.CubicSpline recipe (see module docs) bit-for-bit: a per-axis not-a-knot cubic spline over the J2000-integer-second node axis, evaluated at epoch, with the unit conversion as a single final multiply.

• position is always returned (interpolated from all position nodes of sat), in meters, ITRF/IGS ECEF.
• clock_s is Some when sat has at least two clock nodes in the clock sub-arc containing epoch (after clock-event splitting); None otherwise.
• velocity / clock_rate_s_s are None (this API interpolates the position/clock product; velocity products are a separate concern).
• flags are defaulted (an interpolated state is synthetic, not a record).

Errors:

• Error::UnknownSatellite if sat has no position nodes.
• Error::EpochOutOfRange if fewer than two position nodes exist (a spline needs at least two points) or the epoch is not representable.
• Error::InvalidInput if epoch is tagged with a different time scale than the SP3 product.

pub fn position_at_j2000_seconds( &self, sat: GnssSatelliteId, query: f64, ) -> Result<Sp3State>

Interpolate the state of sat at an arbitrary J2000-second epoch supplied directly as an f64.

Identical to Sp3::position except the query is the seconds-since-J2000 value as already computed by the caller, rather than derived from an Instant. The transmit-time iteration of the SPP residual carries the epoch as a J2000-second f64 (t_tx = t_rx - rho/c) and must feed that exact value to the spline, with no Julian-date round-trip in the loop, so the interpolated position/clock match the reference recipe bit-for-bit. The real-product decimation hold-out oracle pins the parsed-text versus sample-backed 3D difference at no more than 4.020965667248365e-8 m over interior held-out 5-minute records bracketed by 15-minute nodes.

Errors:

• Error::InvalidInput if query is NaN or infinite.

impl Sp3

pub fn precise_interpolant_store_bytes( &self, ) -> Result<Vec<u8>, PreciseInterpolantStoreError>

Build the fitted precise-ephemeris interpolant artifact for this product.

pub fn write_precise_interpolant_store( &self, output_path: impl AsRef<Path>, ) -> Result<(), PreciseInterpolantStoreError>

Build and write the fitted precise-ephemeris interpolant artifact for this product.

impl Sp3

pub fn precise_ephemeris_samples(&self) -> Vec<PreciseEphemerisSample>

Extract this product as the canonical precise-ephemeris samples, in SI units, one per real position record in ascending epoch order.

Round-tripping PreciseEphemerisSamples::from_samples(sp3. precise_ephemeris_samples()) rebuilds the same interpolatable source (byte-identical for samples whose meters are the faithful image of the fit km; see the module docs).

pub fn precise_ephemeris_state_samples( &self, ) -> Vec<PreciseEphemerisStateSample>

Extract this product as ECEF position and velocity samples.

Samples are emitted only for epochs where the parsed product carries a real velocity record. Position-only SP3 products therefore return an empty vector rather than fabricating zero velocity.

impl Sp3

pub fn to_sp3_string(&self) -> String

Serialize this product to standard SP3 text (the format named by its header version, c or d).

Pure and deterministic. See this module’s docs for the round-trip and missing-satellite guarantees.

impl Sp3

pub fn parse(bytes: &[u8]) -> Result<Self>

Parse an SP3-c or SP3-d byte buffer into a typed product.

bytes is the full file content (already decompressed; this crate does not do gzip - that is a caller-layer I/O concern). Returns Error::Parse with a human-readable reason on malformed input.

pub fn parse_str(text: &str) -> Result<Self>

Parse from a &str (the UTF-8 fast path used by Sp3::parse).

pub fn satellites(&self) -> &[GnssSatelliteId]

The satellites present in this product (from the header satellite list).

pub fn epoch_count(&self) -> usize

Number of parsed epochs.

pub fn declared_epoch_count(&self) -> u64

Epoch count written in SP3 header line 1.

This can differ from Sp3::epoch_count when a truncated or otherwise inconsistent file is parsed through the deliberately permissive base parser. Use validate_exact_sp3 when those fields must agree.

pub fn declared_start_j2000_s(&self) -> Option<f64>

Start epoch written in SP3 header line 1, as seconds since J2000 in the product time scale.

The base parser historically ignored these civil fields, so malformed values are represented as None rather than changing Sp3::parse compatibility. Exact product validation requires Some and checks it against both the request and the first parsed epoch.

pub fn state( &self, sat: GnssSatelliteId, epoch_index: usize, ) -> Result<Sp3State>

The state of sat at the parsed epoch with index epoch_index.

Returns Error::EpochOutOfRange if the index is past the end, or Error::UnknownSatellite if the satellite has no record at that epoch.

pub fn states_at( &self, epoch_index: usize, ) -> Result<&BTreeMap<GnssSatelliteId, Sp3State>>

All (satellite, state) pairs recorded at epoch_index, in ascending satellite order.

pub fn prediction_summary(&self) -> Sp3PredictionSummary

Aggregate the per-record SP3 orbit/clock prediction flags by epoch and compute the contiguous observed-through boundary.

This uses the actual P flags carried by position records; it never assumes a fixed ultra-rapid observed duration. Individual cell flags remain available through Sp3::state and Sp3::states_at.

Trait Implementations

impl Clone for Sp3

fn clone(&self) -> Sp3

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Sp3

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EphemerisSource for Sp3

fn position_clock_at_j2000_s( &self, sat: GnssSatelliteId, t_j2000_s: f64, ) -> Option<([f64; 3], f64)>

ECEF position (m) and satellite clock offset (s) for sat at t_j2000_s.

impl FromStr for Sp3

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl ObservableEphemerisSource for Sp3

fn observable_state_at_j2000_s( &self, sat: GnssSatelliteId, t_j2000_s: f64, ) -> Result<ObservableState, ObservablesError>

ECEF position and optional satellite clock at seconds since J2000.

fn observable_states_at_j2000_s( &self, satellites: &[GnssSatelliteId], epochs_j2000_s: &[f64], ) -> Result<ObservableStateBatch, ObservablesError>

ECEF states for parallel satellite and epoch arrays.

fn observable_states_at_shared_j2000_s( &self, satellites: &[GnssSatelliteId], epoch_j2000_s: f64, ) -> ObservableStateBatch

ECEF states for many satellites at one shared epoch.

impl PartialEq for Sp3

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl RinexSppAssemblySource for Sp3

fn rinex_spp_broadcast_corrections(&self) -> RinexSppBroadcastCorrections

Broadcast correction metadata available to RINEX SPP assembly.