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 ascending order; 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 ascending time 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 interpolates against (each epoch converted by the same [instant_to_j2000_seconds] used for the spline nodes, NOT floored), 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 epoch whose representation cannot be mapped to J2000 seconds is skipped (SP3 epochs are always Julian-date, so on real data this 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.

Errors:

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

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).

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 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.

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: &Sp3) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Sp3