Models

What the API answers, as small frozen dataclasses. Each keeps the whole answer in raw, for what is not modelled. Runs, comparisons, plans, passes, orbit events, TLEs and orbit files are made in the background: their wait() asks until they have finished (see Errors, waiting and limits).

class lunaspace.Organisation

The organisation of the API key, its tier (None: every feature and the default limits) and the features the tier includes.

id: str
name: str
tier: str | None = None
features: list[str]
raw: dict[str, Any]
__init__(id, name, tier=None, features=<factory>, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Asset

A satellite.

id: str
name: str
kind: str
created_at: datetime
external_id: str | None = None
group: str | None = None
norad_id: int | None = None
international_designator: str | None = None
tle_enabled: bool = False
orbit_events_enabled: bool = False
raw: dict[str, Any]
__init__(id, name, kind, created_at, external_id=None, group=None, norad_id=None, international_designator=None, tle_enabled=False, orbit_events_enabled=False, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.SpacecraftProperties

What the orbit determination needs to know of the spacecraft, from valid_from.

id: str
mass_kg: float
drag_area_m2: float
srp_area_m2: float
created_at: datetime
drag_coefficient: float | None = None
reflectivity_coefficient: float | None = None
valid_from: datetime | None = None
raw: dict[str, Any]
__init__(id, mass_kg, drag_area_m2, srp_area_m2, created_at, drag_coefficient=None, reflectivity_coefficient=None, valid_from=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.TrackingFile

An uploaded file of navigation fixes, as the API checked and described it.

id: str
asset_id: str
format: str
fix_count: int
first_epoch: datetime
last_epoch: datetime
time_scale: str
has_velocities: bool
sha256: str
bytes: int
uploaded_at: datetime
filename: str | None = None
satellite: str | None = None
raw: dict[str, Any]
__init__(id, asset_id, format, fix_count, first_epoch, last_epoch, time_scale, has_velocities, sha256, bytes, uploaded_at, filename=None, satellite=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Product

A file a run made: oem (the ephemeris), residuals, uncertainty, result. The ephemeris says its first and last time tag: it holds the fitted arc and the prediction.

name: str
filename: str
bytes: int
sha256: str
start: datetime | None = None
stop: datetime | None = None
raw: dict[str, Any]
__init__(name, filename, bytes, sha256, start=None, stop=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.RunManoeuvre

A reported manoeuvre in a run: determined from the tracking data where it lies inside the arc, applied as reported where it is planned after it. Its velocity change in the orbit’s axes [m/s]; its mass change and the mass after it where the run models one (the burn was reported with delta_mass_kg or specific_impulse_s).

epoch: datetime
radial_m_s: float
along_track_m_s: float
cross_track_m_s: float
planned: bool = False
sigma_radial_m_s: float | None = None
sigma_along_track_m_s: float | None = None
sigma_cross_track_m_s: float | None = None
delta_mass_kg: float | None = None
mass_kg: float | None = None
raw: dict[str, Any]
__init__(epoch, radial_m_s, along_track_m_s, cross_track_m_s, planned=False, sigma_radial_m_s=None, sigma_along_track_m_s=None, sigma_cross_track_m_s=None, delta_mass_kg=None, mass_kg=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Run

An orbit determination: queued, running, then succeeded or failed. A succeeded run that is over a limit of its profile is not accepted; its products are there all the same.

id: str
asset_id: str
name: str
status: str
trigger: str
engine: str
created_at: datetime
profile: str | None = None
setting: str | None = None
custom: dict[str, Any] | None = None
engine_version: str | None = None
finished_at: datetime | None = None
arc_start: datetime | None = None
arc_end: datetime | None = None
mass_kg: float | None = None
accepted: bool | None = None
weighted_rms: float | None = None
flags: list[str]
manoeuvres: list[RunManoeuvre]
products: list[Product]
error: dict[str, Any] | None = None
raw: dict[str, Any]
property finished: bool
product(name)
Parameters:

name (str)

Return type:

Product | None

refresh()

The run as it is now.

Return type:

Run

wait(timeout=1800.0, poll=5.0, raise_on_failure=True)

The run once it has finished (see Runs.wait).

Parameters:
Return type:

Run

download(name, to=None)

A product: written to to (a file, or a directory for its own file name), or returned as bytes.

Parameters:
Return type:

Path | bytes

diagnostics()

The run’s diagnostics (a finished run’s; the feature od_diagnostics).

Return type:

Diagnostics

report(to=None)

The run as a report to read and pass on (one HTML page): see Runs.report.

Parameters:

to (str | Path | None)

Return type:

Path | bytes

orbit_file(format='oem', **settings)

The run’s orbit in another form (see OrbitFiles.request); .wait() waits for it.

Parameters:
Return type:

OrbitFile

residuals()

The residuals of every fix as a pandas data frame, in metres (lunaspace.frames.residuals; needs pandas).

Return type:

Any

__init__(id, asset_id, name, status, trigger, engine, created_at, profile=None, setting=None, custom=None, engine_version=None, finished_at=None, arc_start=None, arc_end=None, mass_kg=None, accepted=None, weighted_rms=None, flags=<factory>, manoeuvres=<factory>, products=<factory>, error=None, raw=<factory>, _client=None)
Parameters:
Return type:

None

class lunaspace.Schedule

A satellite’s automatic runs: one arc every interval_hours.

enabled: bool
profile: str
arc_hours: float
interval_hours: float
max_wait_hours: float
prior_covariance: bool
updated_at: datetime
setting: str | None = None
custom: dict[str, Any] | None = None
last_run_id: str | None = None
raw: dict[str, Any]
__init__(enabled, profile, arc_hours, interval_hours, max_wait_hours, prior_covariance, updated_at, setting=None, custom=None, last_run_id=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Profile

A kind of orbit determination, with its settings (other ways to run it) and the custom settings an expert may give. default: the one a request takes when it names none.

name: str
description: str
min_arc_hours: float
max_arc_hours: float
prediction_hours: float
default: bool = False
settings: list[str]
custom_settings: list[CustomSetting]
raw: dict[str, Any]
__init__(name, description, min_arc_hours, max_arc_hours, prediction_hours, default=False, settings=<factory>, custom_settings=<factory>, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Orbit

A satellite’s current orbit: the accepted run it comes from and its ephemeris.

od_run_id: str
updated_at: datetime
arc_start: datetime
arc_end: datetime
ephemeris_start: datetime
ephemeris_end: datetime
ephemeris_sha256: str
raw: dict[str, Any]
__init__(od_run_id, updated_at, arc_start, arc_end, ephemeris_start, ephemeris_end, ephemeris_sha256, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Station

A ground station of the organisation’s.

id: str
name: str
latitude_deg: float
longitude_deg: float
height_m: float
created_at: datetime
mask_deg: float | None = None
raw: dict[str, Any]
__init__(id, name, latitude_deg, longitude_deg, height_m, created_at, mask_deg=None, downlink_frequency_hz=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.CatalogueStation

A site of the service’s catalogue, to fill a new station in from.

id: str
name: str
provider: str
latitude_deg: float
longitude_deg: float
source: str
precision: str
bands: list[str]
height_m: float | None = None
raw: dict[str, Any]
__init__(id, name, provider, latitude_deg, longitude_deg, source, precision, bands=<factory>, height_m=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Pass

A pass over a station: from its start to its end above the mask (AOS and LOS where it rises and sets inside the prediction), the closest approach (TCA).

start: datetime
end: datetime
tca: datetime
max_elevation_deg: float
duration_s: float
min_range_m: float
start_azimuth_deg: float
tca_azimuth_deg: float
end_azimuth_deg: float
aos: datetime | None = None
los: datetime | None = None
raw: dict[str, Any]
__init__(start, end, tca, max_elevation_deg, duration_s, min_range_m, start_azimuth_deg, tca_azimuth_deg, end_azimuth_deg, aos=None, los=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.StationPasses

StationPasses(name: ‘str’, passes: ‘list[Pass]’ = <factory>, station_id: ‘str | None’ = None, raw: ‘dict[str, Any]’ = <factory>)

name: str
passes: list[Pass]
station_id: str | None = None
raw: dict[str, Any]
__init__(name, passes=<factory>, station_id=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Passes

A satellite’s passes over its stations, computed on an orbit: products passes (JSON), pointing (CSV) and, beyond a day, oem.

id: str
asset_id: str
run_id: str
status: str
trigger: str
days: int
light_time: str
created_at: datetime
finished_at: datetime | None = None
stations: list[StationPasses]
products: list[str]
error: dict[str, Any] | None = None
raw: dict[str, Any]
__init__(id, asset_id, run_id, status, trigger, days, light_time, created_at, finished_at=None, stations=<factory>, products=<factory>, error=None, raw=<factory>, _client=None)
Parameters:
Return type:

None

class lunaspace.TleElements

SGP4’s mean elements as the TLE carries them.

epoch: datetime
mean_motion_rev_day: float
eccentricity: float
inclination_deg: float
raan_deg: float
argument_of_perigee_deg: float
mean_anomaly_deg: float
bstar: float
raw: dict[str, Any]
__init__(epoch, mean_motion_rev_day, eccentricity, inclination_deg, raan_deg, argument_of_perigee_deg, mean_anomaly_deg, bstar, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.TleFit

How well the TLE holds the orbit it was fitted to, in metres.

start: datetime
end: datetime
rms_m: float
largest_m: float
at_end_m: float
rms_rtn_m: list[float]
raw: dict[str, Any]
__init__(start, end, rms_m, largest_m, at_end_m, rms_rtn_m=<factory>, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Tle

A TLE and an OMM fitted to an orbit: products tle, omm (CCSDS KVN), document.

id: str
asset_id: str
run_id: str
status: str
trigger: str
created_at: datetime
finished_at: datetime | None = None
lines: list[str]
elements: TleElements | None = None
fit: TleFit | None = None
products: list[str]
error: dict[str, Any] | None = None
raw: dict[str, Any]
__init__(id, asset_id, run_id, status, trigger, created_at, finished_at=None, lines=<factory>, elements=None, fit=None, products=<factory>, error=None, raw=<factory>, _client=None)
Parameters:
Return type:

None

class lunaspace.PlanBurn

A burn of a plan, in the orbit’s axes [m/s].

epoch: datetime
radial_m_s: float
along_track_m_s: float
cross_track_m_s: float
argument_of_latitude_deg: float
raw: dict[str, Any]
__init__(epoch, radial_m_s, along_track_m_s, cross_track_m_s, argument_of_latitude_deg, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.PlanTarget

A target of a plan: what was wanted, before and after the burns, and its sigma.

name: str
wanted: float
before: float
after: float
met: bool
tolerance: float
sigma: float
raw: dict[str, Any]
__init__(name, wanted, before, after, met, tolerance, sigma, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Plan

A manoeuvre plan from the satellite’s current orbit: advice only, adopted by reporting its burns as planned manoeuvres. Products plan (JSON) and oem.

id: str
asset_id: str
start_run_id: str
status: str
profile: str
window_start: datetime
window_end: datetime
created_at: datetime
finished_at: datetime | None = None
burns: list[PlanBurn]
targets: list[PlanTarget]
total_delta_v_m_s: float | None = None
products: list[str]
error: dict[str, Any] | None = None
raw: dict[str, Any]
__init__(id, asset_id, start_run_id, status, profile, window_start, window_end, created_at, finished_at=None, burns=<factory>, targets=<factory>, total_delta_v_m_s=None, products=<factory>, error=None, raw=<factory>, _client=None)
Parameters:
Return type:

None

class lunaspace.ComparisonSetting

One setting of a comparison: its run and figures.

setting: str
status: str
description: str
run_id: str | None = None
engine: str | None = None
gate_passed: bool | None = None
weighted_rms: float | None = None
drag_coefficient: float | None = None
skipped_reason: str | None = None
raw: dict[str, Any]
__init__(setting, status, description, run_id=None, engine=None, gate_passed=None, weighted_rms=None, drag_coefficient=None, skipped_reason=None, raw=<factory>)
Parameters:
  • setting (str)

  • status (str)

  • description (str)

  • run_id (str | None)

  • engine (str | None)

  • gate_passed (bool | None)

  • weighted_rms (float | None)

  • drag_coefficient (float | None)

  • skipped_reason (str | None)

  • raw (dict[str, Any])

Return type:

None

class lunaspace.Comparison

One arc determined with several settings (or engines), set side by side. It never changes the satellite’s orbit; acting on its recommendation is the customer’s step.

id: str
asset_id: str
profile: str
complete: bool
created_at: datetime
arc_start: datetime
arc_end: datetime
settings: list[ComparisonSetting]
reference: str | None = None
recommended: str | None = None
recommended_reason: str | None = None
raw: dict[str, Any]
wait(timeout=3600.0, poll=10.0)

The comparison once every setting has finished.

Parameters:
Return type:

Comparison

__init__(id, asset_id, profile, complete, created_at, arc_start, arc_end, settings=<factory>, reference=None, recommended=None, recommended_reason=None, raw=<factory>, _client=None)
Parameters:
Return type:

None

class lunaspace.Manoeuvre

A manoeuvre the customer reported: inside a run’s arc it is estimated, after it applied in the prediction.

id: str
asset_id: str
epoch: datetime
created_at: datetime
radial_m_s: float = 0.0
along_track_m_s: float = 0.0
cross_track_m_s: float = 0.0
sigma_m_s: float | None = None
delta_mass_kg: float | None = None
specific_impulse_s: float | None = None
raw: dict[str, Any]
__init__(id, asset_id, epoch, created_at, radial_m_s=0.0, along_track_m_s=0.0, cross_track_m_s=0.0, sigma_m_s=None, delta_mass_kg=None, specific_impulse_s=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Eclipse

An eclipse by the Earth, with the contacts it has; one under way at the orbit’s start or end is cut there (cut_start, cut_end).

start: datetime
end: datetime
duration_s: float
umbra_duration_s: float
cut_start: bool
cut_end: bool
penumbra_start: datetime | None = None
umbra_start: datetime | None = None
umbra_end: datetime | None = None
penumbra_end: datetime | None = None
raw: dict[str, Any]
__init__(start, end, duration_s, umbra_duration_s, cut_start, cut_end, penumbra_start=None, umbra_start=None, umbra_end=None, penumbra_end=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.NodeCrossing

A crossing of the equator: where, at what local solar time, and the Sun’s elevation above the orbit’s plane (the beta angle) then.

epoch: datetime
ascending: bool
longitude_deg: float
local_solar_time_h: float
beta_deg: float
orbit: int
raw: dict[str, Any]
__init__(epoch, ascending, longitude_deg, local_solar_time_h, beta_deg, orbit, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Revolution

An orbit from an ascending node to the next: its period and its time in eclipse.

number: int
start: datetime
end: datetime
period_s: float
eclipse_s: float
umbra_s: float
sunlit_share: float
beta_deg: float
raw: dict[str, Any]
__init__(number, start, end, period_s, eclipse_s, umbra_s, sunlit_share, beta_deg, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.OrbitEvents

A satellite’s orbit events, computed on an orbit: its eclipses, its crossings of the equator, its orbits one by one; products events (JSON), ground_track (CSV) and, beyond the run’s own ephemeris, oem.

id: str
asset_id: str
run_id: str
status: str
trigger: str
days: int
created_at: datetime
finished_at: datetime | None = None
orbit_source: str | None = None
orbit_start: datetime | None = None
orbit_end: datetime | None = None
eclipses: list[Eclipse]
nodes: list[NodeCrossing]
orbits: list[Revolution]
ground_points: int = 0
products: list[str]
error: dict[str, Any] | None = None
raw: dict[str, Any]
ground_track()

The ground track as a pandas data frame (lunaspace.frames.ground_track; needs pandas): a row a point, indexed by its epoch (UTC).

Return type:

Any

__init__(id, asset_id, run_id, status, trigger, days, created_at, finished_at=None, orbit_source=None, orbit_start=None, orbit_end=None, eclipses=<factory>, nodes=<factory>, orbits=<factory>, ground_points=0, products=<factory>, error=None, raw=<factory>, _client=None)
Parameters:
Return type:

None

class lunaspace.OrbitPiece

A piece of a reconstructed orbit: the stretch one run’s fitted arc gives.

run_id: str
start: datetime
end: datetime
raw: dict[str, Any]
__init__(run_id, start, end, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.OrbitGap

A stretch of the span asked for that no accepted run’s arc covers.

start: datetime
end: datetime
raw: dict[str, Any]
__init__(start, end, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.OrbitFile

An orbit file, made on request: a run’s ephemeris written again (format “oem”: in another frame, at another step, over a part of its span, without its covariances), one state of it as a CCSDS OPM (“opm”), or a satellite’s reconstructed orbit (“reconstructed”: the fitted arcs of its accepted runs joined, pieces and gaps). What was asked for, and, once it is made, what was written.

id: str
asset_id: str
format: str
status: str
frame: str
covariance: bool
created_at: datetime
run_id: str | None = None
finished_at: datetime | None = None
step_s: int | None = None
start: datetime | None = None
end: datetime | None = None
epoch: datetime | None = None
ref_frame: str | None = None
first_epoch: datetime | None = None
last_epoch: datetime | None = None
states: int | None = None
covariances: int | None = None
segments: int | None = None
elements: bool | None = None
manoeuvres: int | None = None
pieces: list[OrbitPiece]
gaps: list[OrbitGap]
file_name: str | None = None
error: dict[str, Any] | None = None
raw: dict[str, Any]
download(to=None)

The file, once it is made: written to to (a file, or a directory for the name the API gives it), or returned as bytes.

Parameters:

to (str | Path | None)

Return type:

Path | bytes

__init__(id, asset_id, format, status, frame, covariance, created_at, run_id=None, finished_at=None, step_s=None, start=None, end=None, epoch=None, ref_frame=None, first_epoch=None, last_epoch=None, states=None, covariances=None, segments=None, elements=None, manoeuvres=None, pieces=<factory>, gaps=<factory>, file_name=None, error=None, raw=<factory>, _client=None)
Parameters:
  • id (str)

  • asset_id (str)

  • format (str)

  • status (str)

  • frame (str)

  • covariance (bool)

  • created_at (datetime)

  • run_id (str | None)

  • finished_at (datetime | None)

  • step_s (int | None)

  • start (datetime | None)

  • end (datetime | None)

  • epoch (datetime | None)

  • ref_frame (str | None)

  • first_epoch (datetime | None)

  • last_epoch (datetime | None)

  • states (int | None)

  • covariances (int | None)

  • segments (int | None)

  • elements (bool | None)

  • manoeuvres (int | None)

  • pieces (list[OrbitPiece])

  • gaps (list[OrbitGap])

  • file_name (str | None)

  • error (dict[str, Any] | None)

  • raw (dict[str, Any])

  • _client (Client | None)

Return type:

None

class lunaspace.DragCoefficient

The drag coefficient one accepted run estimated over its arc.

run_id: str
arc_start: datetime
arc_end: datetime
drag_coefficient: float
engine: str
sigma: float | None = None
raw: dict[str, Any]
__init__(run_id, arc_start, arc_end, drag_coefficient, engine, sigma=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Webhook

An address told when a run finishes (od.completed) or wants a look (od.flagged).

id: str
url: str
created_at: datetime
events: list[str]
last_delivery_at: datetime | None = None
last_error: str | None = None
raw: dict[str, Any]
__init__(id, url, created_at, events=<factory>, last_delivery_at=None, last_error=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.NewWebhook

A webhook just made, with the secret its deliveries are signed with: shown once; keep it to verify them (lunaspace.webhooks.verify).

id: str
url: str
secret: str
created_at: datetime
events: list[str]
raw: dict[str, Any]
__init__(id, url, secret, created_at, events=<factory>, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Engine

An orbit determination engine a run can name.

name: str
title: str
description: str
available: bool
raw: dict[str, Any]
__init__(name, title, description, available, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Rtn

A figure per axis of the orbit: radial, along-track, cross-track.

radial: float | None = None
along_track: float | None = None
cross_track: float | None = None
raw: dict[str, Any]
__init__(radial=None, along_track=None, cross_track=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Quantile

Quantile(p: ‘float’, normal: ‘float’, value: ‘float’, raw: ‘dict[str, Any]’ = <factory>)

p: float
normal: float
value: float
raw: dict[str, Any]
__init__(p, normal, value, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.RatioStatistics

One axis’s residuals over the fixes’ sigma: against N(0, 1), an sd above 1 says the fixes are noisier than weighted, below 1 weighted too loosely.

count: int
mean: float
sd: float
edges: list[float]
counts: list[int]
below: int = 0
above: int = 0
quantiles: list[Quantile]
raw: dict[str, Any]
__init__(count, mean, sd, edges=<factory>, counts=<factory>, below=0, above=0, quantiles=<factory>, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.SegmentResiduals

The residuals’ RMS and mean over one segment, in metres.

start: datetime | None = None
end: datetime | None = None
fixes: int | None = None
rms_m: Rtn | None = None
mean_m: Rtn | None = None
raw: dict[str, Any]
__init__(start=None, end=None, fixes=None, rms_m=None, mean_m=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.EstimateValue

One value of an estimate (one per segment for the empirical accelerations).

value: float
start: datetime | None = None
end: datetime | None = None
sigma: float | None = None
raw: dict[str, Any]
__init__(value, start=None, end=None, sigma=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.EstimatedParameter

An estimate but the state, in SI units, with its sigma after the fit; for the empirical accelerations also the a priori sigma (a posterior sigma near it: the data did not determine the value) and the flag’s scale.

name: str
per_segment: bool
unit: str | None = None
a_priori_sigma: float | None = None
flag_scale: float | None = None
values: list[EstimateValue]
raw: dict[str, Any]
__init__(name, per_segment, unit=None, a_priori_sigma=None, flag_scale=None, values=<factory>, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.CorrelationPair

CorrelationPair(a: ‘str’, b: ‘str’, correlation: ‘float’, raw: ‘dict[str, Any]’ = <factory>)

a: str
b: str
correlation: float
raw: dict[str, Any]
__init__(a, b, correlation, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Correlations

The correlation matrix of the estimated columns: near ±1, two columns the data cannot tell apart.

columns: list[str]
matrix: list[list[float]]
strongest: list[CorrelationPair]
raw: dict[str, Any]
between(a, b)

The correlation of two columns by name.

Parameters:
Return type:

float

__init__(columns=<factory>, matrix=<factory>, strongest=<factory>, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Iteration

Iteration(iteration: ‘int’, weighted_rms: ‘float’, edited: ‘int | None’ = None, step: ‘float | None’ = None, raw: ‘dict[str, Any]’ = <factory>)

iteration: int
weighted_rms: float
edited: int | None = None
step: float | None = None
raw: dict[str, Any]
__init__(iteration, weighted_rms, edited=None, step=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.HorizonCheck

The run before’s prediction at a horizon against this run’s fit: the error, the sigma it predicted, and their quotient z (mostly within ±1 where the predicted uncertainty is honest).

after_hours: float
position_error_m: float
error_m: Rtn
sigma_m: Rtn | None = None
z: Rtn | None = None
raw: dict[str, Any]
__init__(after_hours, position_error_m, error_m, sigma_m=None, z=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.PredictionPoint

The run before’s prediction against this run’s fit at one moment (every five minutes of the hours the two share): this orbit minus that prediction along the orbit’s axes, and the standard deviations that run predicted there.

epoch: datetime
after_hours: float
error_m: Rtn
sigma_m: Rtn | None = None
raw: dict[str, Any]
__init__(epoch, after_hours, error_m, sigma_m=None, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Diagnostics

What an analyst looks at to judge a run beyond its gate (the API’s diagnostics).

run_id: str
flag_limit: float | None = None
fixes_sigma_m: float | None = None
edit_threshold: float | None = None
radial: RatioStatistics | None = None
along_track: RatioStatistics | None = None
cross_track: RatioStatistics | None = None
segments: list[SegmentResiduals]
parameters: list[EstimatedParameter]
correlations: Correlations | None = None
convergence: list[Iteration]
prediction_check: list[HorizonCheck]
prediction_series: list[PredictionPoint]
raw: dict[str, Any]
parameter(name)

An estimate by name: drag_coefficient, along_track_acceleration, …; for a run whose profile estimates the drag coefficient in steps (leo-gnss-v3), drag_coefficient is the one its prediction runs on and drag_coefficient_steps the steps.

Parameters:

name (str)

Return type:

EstimatedParameter | None

prediction()

The run before’s prediction against this fit every five minutes as a pandas data frame (lunaspace.frames.prediction_series; needs pandas).

Return type:

Any

__init__(run_id, flag_limit=None, fixes_sigma_m=None, edit_threshold=None, radial=None, along_track=None, cross_track=None, segments=<factory>, parameters=<factory>, correlations=None, convergence=<factory>, prediction_check=<factory>, prediction_series=<factory>, raw=<factory>)
Parameters:
Return type:

None

class lunaspace.Trend

One run’s figures among its satellite’s.

run_id: str
trigger: str
accepted: bool
flagged: bool
arc_start: datetime | None = None
arc_end: datetime | None = None
profile: str | None = None
engine: str | None = None
weighted_rms: float | None = None
variance_factor: float | None = None
edited_share: float | None = None
drag_coefficient: float | None = None
drag_coefficient_sigma: float | None = None
empirical_along_track: float | None = None
empirical_cross_track: float | None = None
prediction: list[HorizonCheck]
raw: dict[str, Any]
at(hours)

The run before’s prediction checked at hours (1, 6, 12, 24), if it was.

Parameters:

hours (float)

Return type:

HorizonCheck | None

__init__(run_id, trigger, accepted, flagged, arc_start=None, arc_end=None, profile=None, engine=None, weighted_rms=None, variance_factor=None, edited_share=None, drag_coefficient=None, drag_coefficient_sigma=None, empirical_along_track=None, empirical_cross_track=None, prediction=<factory>, raw=<factory>)
Parameters:
Return type:

None