Scarabaeus 2.0.0 Release Notes#
Release Notes#
Highlights#
User-extensible framework: force models (CustomDynamicModel), solve-for parameters (CustomParameter), measurement models (CustomMeasurement) and whole estimators (CustomFilter) can be defined from a script, without changing the library source.
New dynamics: polyhedral shape-model gravity, several spherical-harmonic fields per spacecraft, thermal and antenna radiation recoil, Fourier and piecewise polynomial empirical accelerations, smoothed impulsive burns, and empirical accelerations given in RTN or body-fixed frames.
Station and planet orientation modelling: solid, pole and ocean-loading tides, Earth orientation parameters, body orientation corrections and IAU pole parameters, all estimable with analytical partials.
Measurements: MeasurementScheduler builds synthetic tracking from requests; MeasurementRegistry, MeasurementStream and MeasurementConfig describe real data streams; the real DSN radiometric models gain analytical (Moyer) partials and many precision fixes.
Performance: the Rust extension, now imported as
scarabaeus.rust, carries the spherical-harmonics, n-plate SRP and polyhedron gravity kernels and a Chebyshev ephemeris cache for third bodies, and the package imports its classes lazily.Process noise per body, with interval caps, and OD solutions saved with full metadata, convertible to Keplerian elements and comparable through SolutionCloseness.
Added#
EphemerisCache:
Rust module that saves the Chebyshev polynomials representing the trajectory of a body or bodies.
Computes third body accelerations using its cached ephemerides.
User-defined models, all built from a script:
CustomDynamicModel: a force model given as a Python acceleration function, summed into the equations of motion and passed to ForceModelTranslation through
custom_models. Partials it does not supply are filled by central finite differences.CustomParameter: a user-defined solve-for parameter, static or with its own dynamics, registered with StateDefinition.register_custom_parameter() so it passes state-vector validation and can be estimated like
eta_srp.CustomMeasurement: a measurement given as a Python observable function and its Jacobian, with its own biases and calibration terms.
CustomFilter: an estimator whose whole algorithm (sequential, batch or sigma-point) is supplied by the user; the library provides the reference trajectory, residuals, partials, STMs and process noise, and packages the result as a SolutionOD.
CustomCallable: binds a user function to a fixed keyword vocabulary at construction, so a misspelt argument is reported immediately, and carries the shared central finite-difference helpers.
PolyhedralGravity: the gravity of a constant-density polyhedral shape model (Werner & Scheeres), valid down to the surface, with its Rust kernel PolyhedronGravityCore. Enabled in ForceModelTranslation by
polyhedral_gravity=True.ShapeHarmonics: converts a polyhedral shape model into spherical-harmonic coefficients by Werner’s exact recursion (Rust class
PolyhedronHarmonics), written in the JSON layoutsph_harm_cs_filereads.ForceModelTranslation
sph_harm_bodies: several spherical-harmonic fields for one spacecraft, one per body (Jupiter and its moons, for instance), each with its own degree, order and coefficient file, and each field’s coefficient, GM and pole partials keyed by its own body.SmoothedImpulsiveBurn: an impulsive maneuver modelled as a narrow sech² (tanh-product) acceleration pulse, so one uninterrupted propagation and its variational equations can carry the burn without splitting the trajectory into legs.
PiecewisePolynomialAcceleration: an empirical acceleration held constant (order 0) or interpolated linearly (order 1) over a fixed batch grid, as in PiecewiseFirstOrderGaussMarkov.
Station displacement models, attached to GroundStation.surface_displacement (a model or a list of them, summed):
SolidTide: solid Earth tide displacement, the degree-2 in-phase IERS 2010 term by default or the complete IERS routine with
model="IERS2010". The same model serves SphericalHarmonicsGravity.PoleTide: pole-tide displacement (Moyer; IERS 2010 eq. 7.26).
OceanLoading: ocean-loading displacement from BLQ coefficients with nodal corrections.
BodyOrientation: a small rotation correction to a loaded body-fixed frame, Earth orientation deltas (polar motion, UT1, celestial pole offsets), absolute Earth orientation inputs, or another body’s orientation law. A station carries one through GroundStation.body_orientation and every radiometric model applies it to the station position and velocity.
StateDefinition: new estimable parameters, all with analytical partials in the radiometric models:
gs_delta_location_CYL: a station location offset in cylindrical coordinates.
eop_delta_pole_x, eop_delta_pole_y, eop_delta_ut1, eop_delta_celestial_pole_x, eop_delta_celestial_pole_y: Earth orientation parameter corrections.
body_orientation_delta: a small rotation of a body-fixed frame.
love_h2, shida_l2 and love_k_n_m: tidal Love and Shida numbers.
tropo_zenith_delay_[tag] and iono_zenith_delay_[tag]: zenith media delays per station.
pole_ra, pole_dec, pole_pm and pole_w0: IAU pole orientation of a spherical-harmonics body.
Measurement setup:
MeasurementScheduler: builds measurement models and their synthetic observations from tracking requests, each with its own observer, measurement type and window, including recurring passes and elevation masks, and hands them to a filter as one MeasurementSpec.
MeasurementRegistry and MeasurementType: the table of measurement types a scenario is built from, mapping a short name such as “SeqRange” to its model class, data block and units.
MeasurementStream: one tracking-data stream, normally written as a
(file, meas_type, station)tuple.MeasurementConfig: the settings shared by every stream in a scenario, each overridable per stream.
ObsData: the observations read from one tracking file (epochs, values, outlier flags and auxiliary data), returned by Measurement.observed_measurements().
SolutionCloseness: the statistical distance between two OD solutions (Bhaskaran & Rush), the number of sigma at which their uncertainty ellipsoids first touch.
MCMC: samples the linearized posterior of a converged filter (LKF, SRIF, LSB or SRIFB) with the emcee affine-invariant ensemble, through the filter’s STMs and measurement partials; considered states keep the linear Schmidt spread, and an optional
log_priorreplaces the Gaussian a-priori.sample()returns a SolutionOD whose particles, mapped to every epoch, feed its uncertainty-quantification metrics. Adds theemceedependency.Plotting.plot_corner(): corner plot of samples (MonteCarloSamples, an MCMC run or an array), optionally overlaid with the n-sigma ellipses and Gaussian marginals of a covariance. Adds the
cornerdependency.SolutionOD.state_covariance_to_elements(): the estimate and its covariance in Keplerian elements.
SolutionOD.save(fmt=…): JSON or pickle output, with metadata describing the state (frame, units, labels), the a-priori state and covariance, the convergence test and the provenance, and either full or diagonal final covariances (
output_settings.save_full_covariance).Serialization: shared helpers for writing and reading library objects as JSON or pickle (format inferred from the extension or given as
fmt=), used by the save() / load() methods.Trajectory / SpiceManager: a state vector with several propagated bodies can be written to, and read back from, one SPK per body.
ProcessNoise (StateNoiseCompensation, DynamicalModelCompensation):
body: the body whose position and velocity the noise drives, so several bodies can each carry their own process noise.max_interval: caps the interval the noise is accumulated over, so a data gap does not receive an unbounded noise.
nPlateSRP: optional
double sidedplates, lit from either face, and a per-plateframesentry naming the SPICE frame a fixed plate’s normal is given in.CelestialBody: mass and grav_param are each optional and derived from the other; CelestialBody.from_constants() accepts a list of names and returns one body per name.
ForceModel.list_forces() / ForceModelTranslation.list_forces(): readable labels of the forces a model applies, e.g.
['ThreeBodyGravity(SUN, MOON)', 'CannonballSRP', ...].Rust extension (
scarabaeus.rust): SphericalHarmonicsCore, NPlateSRPCore and PolyhedronGravityCore kernels, with their partials checked by dual-number automatic differentiation.Update Propagator to return a Trajectory object as solution.
OpNavManager: stateless pinhole calibration matrix, projection and projection Jacobian, shared by the optical measurement models.
Measurement.set_trajectory(): attaches the reference trajectory whose STMs the analytical light-time partials use to map a deviation between the endpoints of an observable. FilterOD attaches it automatically, and models that do not read it ignore it.
Camera.camera_frame_object: the camera frame as a Frame object, built lazily from the frame name and cached.
ForceModelTranslation: third_bodies accepts plain body names alongside CelestialBody objects. Names resolve through CelestialBody.from_constants(), and a BARYCENTER suffix (“MARS BARYCENTER”, “MARS_BARYCENTER”, “MARSBARYCENTER”) resolves to the system barycentre.
Cost-function convergence test in FilterOD.fit() and MultiFilterOD.fit(): alongside the RMS of the estimated deviation, the iterations now also track the weighted least-squares cost J = Σ(r/σ)² of the post-fit residuals and test the relative change of J/n (normalised by the residual count, so measurement editing does not look like a cost change). Controlled by convergence_threshold_cost and convergence_criterion (“any” | “deviation” | “cost” | “both”); “deviation” reproduces the previous behaviour, and “cost” is the criterion for weakly observable problems, where the deviation keeps moving along the unobservable directions while the fit no longer improves. Per-iteration history in FilterOD.cost_history, last test in FilterOD.convergence_info, outer-loop values in MultiFilterOD’s multi_arc_global.
MissionSequence legs given only a (t0, tf) tuple tspan: the leg is integrated between its bounds and adopts the grid the integrator’s own steps produced, through the new MissionSequence.adopt_propagated_grid(), so SPK segments, measurements, process noise and filter leg boundaries all see the epochs the states actually sit on. MissionSequence.deferred_grids flags which segments work this way, and MissionSequence.grid_bound_tol (constructor argument and settable attribute, default 1e-6 s) sets how far such a grid may sit from the bounds its segment declared. Both integrators place their own output times, so either can carry such a segment; how fine the grid is, is the error control’s call, so declare
epochsorperiod+dtwhen the output density matters.SpiceManager.sidecar_files(location, kind): resolves where a sidecar lookup reads from, so sidecars are found by where they are rather than by a folder layout the library imposes.
locationaccepts an SPK (its own sidecars first, then its folder), a file of any name, a folder (this library’s suffix for that payload first, then any other .json/.pkl), an iterable of those for payloads split across locations, or None for the previous default (kernel_folder, else<cwd>/data/kernels/scenario). get_parameters(), get_STMs() and get_propagator_settings() take it assidecar_path;folder_path_overridekeeps working.Propagator.tspan is settable:
prop.tspan = (t0, tf)(a two-element list works too, as does an EpochArray grid) is shorthand forprop.reinitialize(tspan=...), e.g. to run a propagator reloaded with Propagator.load() over a longer span. The first epoch stays the state epoch; pass state_vector to reinitialize() to start from another state.Every Propagator setting is now settable, so a propagator reloaded with Propagator.load() / from_dict() can be changed in place. New Propagator.state_vector property (the initial state in its original frames, which MissionSequence already looked for). Settings that shape the integration route through reinitialize(): state_vector / full_state_vector, primary_body, base_frame, force_models, STM0 (None restores the identity), propagate_STM, integrator, n_densifier, backward. Changing base_frame re-converts from the original-frame state, so switching frames back and forth never compounds. Settings only read by propagate() are stored directly: atol, rtol, look_event (None turns it off), convert_to_original_frame, display_progress, and mass_is_variable (which still refuses a non-Spacecraft primary_body).
ForceModelTranslation.save() / load(): write a force model configuration to JSON or pickle (inferred from the extension, or
fmt=) and rebuild it without a Propagator. The file carries the primary body; passprimary_body=to load() to share the spacecraft your state is built on instead.DopplerReal / SequentialRangingReal:
rlt_bodies: the (spice_id, GM) pairs of the bodies other than the Sun in the relativistic light-time delay. Defaults to the new Constants.RLT_BODIES; an empty tuple leaves only the Sun.
solar_corona and electronic_delays (both default True) turn off the solar-corona delay, and the time-tag, z-height, transponder and arraying delays, one at a time. media_corrections=None already turns off the troposphere and ionosphere.
default_doppler_aux() / default_seqranging_aux() now return every key computed_measurements() reads (exciter scalars for the chosen band, and a linear ramp table that extends ramp_margin, one hour by default, beyond each end of the span), so synthetic measurements no longer need fields that only a real tracking file has.
computed_measurements_dict accepts ‘ramp_year’ (the SFDU 9 year of each ramp record), which lets a ramp table or a round trip cross a new year. observed_measurements() fills it from the tracking file.
light_time_frame: “barycentric” (the default, Moyer 2000 Sec. 8.3.6) solves the round-trip light time in the Solar-System barycentric frame and is valid for any spacecraft; “geocentric” (Sec. 8.3.1) solves it in the local geocentric frame, with the Earth as the only relativistic body, for spacecraft near the Earth. Another name raises Measurement.LightTimeFrameError.
light_time_settings: the convergence tolerance of each light-time leg (1e-12 s by default), its iteration cap and the number of ET − TAI evaluations, with the defaults in Measurement.LIGHT_TIME_SETTINGS. Raise the tolerance for a spacecraft beyond about 8 AU, where 1e-12 s is below the float spacing of the light time and every leg runs to the cap. An unknown key or an invalid value raises Measurement.LightTimeSettingsError.
Measurement.align_aux_to_epochs(): samples one TRK-2-34 record at the time tags of another (zero-order hold), since each SFDU record has its own cadence and its rows do not line up with the measurement rows.
Measurement.transponder_delay_seconds(): converts a spacecraft transponder delay from range units to seconds.
Constants.km_to_m, the single km-to-m factor the measurement models now share, and Constants.RLT_BODIES, the default relativistic light-time bodies: Earth and the Moon at their centres, and the Mars, Jupiter and Saturn barycentres.
SpiceManager.spk_files_for_body(spice_id, epochs=None): with
epochs, lists only the files that resolve the body at those epochs. MeasurementSpec provenance passes the epochs of each measurement, sotrajectorynames every SPK a computation read (joined with “ + “) rather than only the last one loaded.RampTableManager.integrate(): optional years for the window ends (t1_q_year, t2_q_year) and the ramp records (a sixth ramp-table entry), and low parts for window ends given as (high, low) pairs (t1_q_sec_l, t2_q_sec_l).
FilterOD.set_measurement_sigmas(sigmas): sets the sigma of datasets by name on the models that build them, so
model.sigmareports it and every later iteration is built with it. An ArrayWUnits sigma is converted to the dataset’s units; a bare float is taken to be in them.FilterOD.fit(callback=…): called as
callback(filter, iteration, solution)after each iteration’s convergence test and before the filter is reinitialized, the place to reweight (set_measurement_sigmas) or edit the data between iterations.MeasurementScheduler.Window.pass_gap: the window’s pass gap as an ArrayWUnits, next to Window.cadence.
ArrayWUnits.values_in(quantity, units): strips an ArrayWUnits or ArrayWFrame to a float array in the given units (one for every element, one per element, or one per row), converting other units of the same dimension without a warning. Bare numbers are taken to be in those units already and None is returned as None; elements already in their units keep their numbers to the last bit. Public methods strip their inputs with it, compute on plain arrays and attach units to the result.
ArrayWUnits.from_row_units(values, row_units): attaches one unit to each row of a numeric array without validation, for states and Jacobians whose rows are km and km/s.
MultiFilterOD.fit(callback=…): called as
callback(multi_filter, outer, arc_solutions)after each outer iteration’s convergence test and before the arcs are reinitialized. With a callback every arc is rebuilt, even one with a zero correction, so a sigma or flag change takes effect on the next outer iteration. The arcs’ own fits run without it.MeasurementSpec: two-component streams (AngularIdeal, CentroidingIdeal, …) are reported per component dataset (
"<dataset_name>_<label>") by residuals() and summary(); edit() and flag() accept the stream’s name or a component’s, a flag lands on both components, and a refit becomes a sigma vector over them.MeasurementEditing.chi_squared_filter(), kurtosis_filter(), date_range_filter() and interactive_date_range() take a list of dataset names, like the other filters.
ThermalRadiation: the recoil of the heat the spacecraft radiates, after the OSIRIS-REx small-force models (Geeraert et al., 2019). Each surface radiates as a Lambertian emitter with its own area, emissivity and spacecraft-fixed normal. Its temperature is read from a table of temperature against off-Sun angle at a few Sun distances: a cubic spline in the angle, linear in the distance, and held at the nearest edge outside the table. A surface can carry a second table for when it faces away from the Sun. The acceleration is scaled by the estimable state entry
eta_thermal, with analytical position, velocity and scale-factor partials. Enabled in ForceModelTranslation bythermal_radiation=Truewiththermal_model(a dict, or the path of a JSON file holding one), and carried through save() / load().AntennaRadiationPressure: the recoil of the power the spacecraft transmits, from radio antennas or an active instrument such as a LIDAR. Each emitter has a radiated power, a half-power beamwidth (the boresight carries cos²(hpbw/4) of the beam’s momentum), a spacecraft-fixed boresight and optional
on_intervalswhen it transmits. The acceleration is scaled by the estimable state entryeta_antenna, with analytical partials. Enabled in ForceModelTranslation byantenna_radiation_pressure=Truewithantenna_emitters, and carried through save() / load().ThermalRadiation and AntennaRadiationPressure orient their surfaces and boresights by
Spacecraft.attitudeMode, as nPlateSRP does, and read the Sun position from a Chebyshev ephemeris cache when the propagation frame is J2000.FourierAcceleration: an empirical acceleration given as a truncated Fourier series on each axis, in a phase angle that is the time (with
period), the argument of latitude, or the solar longitude (McMahon and Scheeres, 2010). Degree 0 is a constant acceleration, sodegree=0in an RTN frame is the usual constant along-track push. The coefficients are the static state entrya_fourier, 3(2N+1) long and ordered axis by axis; the acceleration is linear in them, so their partial is exact, and a state-dependent frame or phase adds analytical position and velocity partials. Without that state entry,coefficientsapplies a known acceleration. Enabled in ForceModelTranslation byfourier_acceleration=Truewithfourier_degree,fourier_angle,fourier_periodandfourier_coefficients; the phase origin is thet0given to ForceModelTranslation, which every leg of a MissionSequence then shares; without one it is the start of each propagation.DynamicalUtils: the geometry the dynamics models share, as static and class methods. It turns
Spacecraft.attitudeMode(one of DynamicalUtils.ATTITUDE_MODES: “CK”, “nadirPointingSun”, “inertialFixedAttitude”) into the spacecraft-fixed to inertial rotation, with its position and velocity Jacobians, for nPlateSRP, ThermalRadiation and AntennaRadiationPressure, and rotates the empirical accelerations out of the frame their components are given in.FirstOrderGaussMarkov, PiecewiseFirstOrderGaussMarkov, PiecewisePolynomialAcceleration and FourierAcceleration:
frame= “inertial” (the default, as before), “RTN” (radial / along-track / cross-track) or “body_fixed”, withbody_fixed_framenaming the body-fixed frame and an optionalrelative_bodyfor an RTN triad about a body other than the propagation origin. The components are rotated into the propagation frame at every step, and an RTN frame adds the position and velocity partials of the triad. ForceModelTranslation takes the same settings asfogm_frame,pfogm_frame,ppoly_frameandfourier_frame, each with its_body_fixed_frameand_relative_body, and the coefficient labels follow the frame’s axes (DynamicalUtils.ACCELERATION_FRAME_AXES). With DMC process noise, the noise of an RTN or body-fixed FirstOrderGaussMarkov acceleration is rotated into the propagation frame along the reference trajectory.Licensing: Scarabaeus is ISC (LICENSE) and every source file states it in an SPDX header. The vendored numpydoc Sphinx extension keeps its BSD-2-Clause license (sphinxext/LICENSE.txt), and the third-party data and logos shipped so the tutorials, tests and documentation work out of the box stay under their owners’ terms (README, License section).
Documentation: API pages for the Rust extension classes (
scarabaeus.rust), with the equations each kernel evaluates and their references, and the equations of the ShapeHarmonics conversion.More descriptive error handling:
SPKNotLoadedError: raised when ThreeBodyGravity is unable to query the requested third bodies due to no loaded S(pacecraft) and P(lanet) Kernel.
MissingTrajectoryError: raised by Measurement when a deviation has to be mapped between two epochs and no reference trajectory has been attached.
MissingImageIndexError: raised by CentroidingIdeal and AngularIdeal when the state carries a stacked per-image centroid or angular bias but set_image_epochs() was never called, so the epoch cannot be mapped to an image slot.
UnknownThirdBodyError: raised by ForceModelTranslation when a third_bodies entry is neither a CelestialBody nor a name the constants library defines.
NotAForceModelFileError: raised by ForceModelTranslation.load() when the file was not written by ForceModelTranslation.save() (a Propagator file, for instance).
ConvergenceCriterionError: raised by FilterOD.fit() / MultiFilterOD.fit() when convergence_criterion is not one of “any”, “deviation”, “cost”, “both”.
TimeSpanError: raised by MissionSequence when the grid a segment’s (t0, tf) tuple tspan produced does not reach the bounds it declared.
GridToleranceError: raised by MissionSequence when grid_bound_tol is set to something other than a finite, non-negative number of seconds.
EvenDegreeError: raised by SpiceManager when an even interpolation degree is asked of an SPK segment, whose type-13 Hermite polynomials are built from a position and a velocity per node and so always have odd degree.
SidecarNotFoundError: raised by SpiceManager when no sidecar for the requested body, origin, and frame is found; the message lists every location that was searched.
AuxDataError: raised by Measurement when the aux dictionary of a real DSN model is missing, lacks a required key, or has a per-epoch entry whose length does not match the measurement count.
MissingSigmaError: raised by DopplerReal / SequentialRangingReal when noisy measurements are requested without a sigma.
RampCoverageError: raised by RampTableManager.integrate() when the ramp table is empty or the window starts before its first record. The Real models catch it and flag the measurement (see Changed).
RampTableYearError: raised by RampTableManager.integrate() when the ramp table or the window crosses a new year and no years were given, where days of year alone would integrate a year off.
Propagator.IAS15STMError: raised when
propagate_STM=Trueis combined withintegrator="IAS15", which integrates the state alone. Subclasses NotImplementedError.CelestialBody.InvalidMassError: raised when a body’s mass is not a constant ArrayWUnits, so no GM can be derived from it.
UnknownSerializationFormatError: raised by the save() / load() helpers when the requested file format is neither JSON nor pickle.
IncompleteTroposphereError, TroposphereFileTypeError, MissingIonosphereFrequencyError: raised by MediaCorrections when only one of the two troposphere files is set, when a seasonal troposphere file is given as non-seasonal or the reverse, or when an ionosphere file is set without a link frequency to scale it. The first and last cases used to be skipped silently.
Propagator(n_densifier=…): resamples every integration step into that many sub-intervals, drawn from the integrator’s dense output. Defaults to 10; pass 1 for the previous behaviour of returning the solver’s own steps unchanged. It applies to a (t0, tf) tuple tspan, where the output sits on the adaptive steps: those grow long wherever the dynamics are quiet, and an SPK written on them leaves SPICE interpolating across the gaps. Splitting each step ten ways keeps the grid fine where the steps are short and coarse where they are long, rather than imposing one fixed interval over the whole arc. The extra epochs are interpolated, not integrated: DOP853 carries a dedicated 7th-order dense output, so they cost no function evaluations beyond the ones dense_output already required, and they are a degree below the 8th-order steps they sit between. The step endpoints are reproduced exactly, making the densified grid a superset of the undensified one. Because the default is on, a tuple-tspan propagation now returns about ten times as many epochs as before, which costs memory in the propagated states and STMs and size in any SPK written from them; set n_densifier=1 on long arcs where that matters. An EpochArray tspan and
integrator="IAS15"cannot be densified: leaving n_densifier at its default there does nothing, while asking for a value explicitly raises Propagator.DensifierGridError or Propagator.DensifierIntegratorError rather than silently ignoring it. Carried through reinitialize(), to_dict() and from_dict(); a file written without the field takes the default.TooFewStatesError: raised by SpiceManager when an SPK type 13 segment holds fewer than (degree_poly + 1) // 2 states, in place of CSPICE’s SPICE(TOOFEWSTATES).
DensifierValueError, DensifierIntegratorError, DensifierGridError: raised by Propagator when n_densifier is not a whole number of at least 1, when it is asked of IAS15, which builds no dense output, or when it is combined with an EpochArray tspan that already fixes every output epoch.
UnknownSigmaDatasetError, MeasurementSigmaUnitsError, SharedSigmaModelError: raised by FilterOD when a measurement sigma names a dataset the filter does not have, cannot be converted to its dataset’s units, or would give the datasets of one model two different sigmas. All subclass ValueError.
SigmaUnitsError: raised by Measurement when the model’s sigma cannot be expressed in the units of the computed measurement.
MeasurementSpec.RefitSigmaUnitsError: raised by MeasurementSpec.flag(), flag_outliers() and edit() when a refitted sigma cannot be converted to the units asked for. Nothing is flagged then. Subclasses ValueError.
Measurement.ElevationMaskError: raised by Measurement.resolve_elevation_mask() for a mask that is not an angle, is outside 0 to 90 deg, or is a bare number that could be radians. Subclasses ValueError; MeasurementScheduler raises InvalidScheduleError from it.
DynamicalUtils.InvalidFrameError, MissingBodyFixedFrameError, MissingEpochError: raised when an acceleration
frameis not a key of DynamicalUtils.ACCELERATION_FRAME_AXES (“lvlh” included), when “body_fixed” is asked for without abody_fixed_frame, or when a body-fixed rotation or arelative_bodyoffset is needed without an epoch. All subclass ValueError.DynamicalUtils.InvalidAttitudeModeError, InvalidFixedAttitudeError, MissingVelocityError, DegenerateGeometryError: raised when
attitudeModeis not one of DynamicalUtils.ATTITUDE_MODES, when an “inertialFixedAttitude” spacecraft’sfixedInertialAttitudeis not a 3x3 array, when a “nadirPointingSun” attitude or an RTN frame meets a state without the spacecraft velocity (a KeyError), or when the orbital angular momentum vanishes and the RTN triad is undefined.ThermalRadiation.InvalidThermalModelError, InvalidTemperatureTableError, InvalidSurfaceError, UnknownTemperatureTableError: raised when
thermal_modelis not a dict (or a JSON file of one) with “temperature_tables” and “surfaces” entries, when a temperature table or a surface is malformed, or when a surface names a table that is not defined.AntennaRadiationPressure.InvalidEmitterError: raised when
antenna_emittersis not a non-empty list, or when an emitter lacks its name, power, beamwidth or boresight, gives its power or beamwidth without units, or has a negative power, a beamwidth outside [0, 360) degrees, a zero boresight oron_intervalsthat are not (start, end) pairs with start < end.ForceModelTranslation.MissingEmissionModelError: raised when thermal_radiation or antenna_radiation_pressure is enabled without its
thermal_modelorantenna_emitters. Subclasses ValueError.Propagator.MissingScaleFactorModelError: raised when the state holds a scale factor (
eta_srp,eta_thermaloreta_antenna) that no enabled force model applies, since it would be estimated with a zero partial. It replaces the bare ValueError raised foreta_srpand subclasses ValueError.FourierAcceleration.InvalidDegreeError, InvalidAngleError, MissingPeriodError, MissingEpochError, InvalidEpochError, CoefficientSizeError, DegenerateGeometryError: raised when the degree is not a non-negative integer, when the phase angle is not “time”, “argument_of_latitude” or “solar_longitude”, when a time phase has no positive
periodor not0, whent0is neither an EpochArray nor a number, when the coefficients are not 3(2N+1) long, or when the phase is undefined (an equatorial orbit for the argument of latitude, the Sun along the frame’s third axis for the solar longitude). InvalidEpochError subclasses TypeError, the others ValueError.
Changed#
The Rust extension module is now
scarabaeus.rust(it wasscarabaeus.scarabaeus_rust); its classes are still available at the package top level (scarabaeus.IAS15,scarabaeus.EphemerisCache, …).import scarabaeusloads its classes lazily, on first access, instead of importing every subpackage up front.SphericalHarmonicsGravity and nPlateSRP evaluate their accelerations and partials in the Rust kernels SphericalHarmonicsCore and NPlateSRPCore; nPlateSRP is vectorised over its plates.
The Sun-pointing nadir attitude mode is named “nadirPointingSun” everywhere: the
attitudeModestring, DynamicalUtils.nadirPointingSun and Spacecraft.inertial_to_body_DCM_nadirPointingSun (was inertial_to_body_DCM_nadir_pointing_to_sun).DopplerReal / SequentialRangingReal: the solar-corona delay is added last in the light-time solution and evaluated at the transmit frequency at t1 read from the ramp table (Moyer 11-7, 13.2.8), instead of at the time-tag uplink frequency. Without a ramp covering t1 it keeps the uplink frequency. Adds RampTableManager.frequency_at().
CelestialBody: a non-constant mass raises CelestialBody.InvalidMassError; mean_radius and base_frame may be None.
ThreeBodyGravity:
Caches non-propagated bodies by evaluating their SPK Chebyshev polynomials directly inside the integrator using EphemerisCache.
Notable performance improvements from EphemerisCache for non-propagated third body accelerations.
EphemerisCache: build_ephemeris_cache() and NoLoadedSPKError moved from scarabaeus.dynamics.EphemerisCaching to scarabaeus.utils.EphemerisCache.
Camera.camera_frame accepts either a SPICE frame name or a Frame, and always returns the name; use camera_frame_object where a Frame is needed.
CentroidingIdeal:
Pinhole projection and its Jacobian delegate to OpNavManager, so the projection and its derivative stay in step.
The returned ArrayWFrame carries the camera Frame object instead of the frame name.
FilterOD attaches the reference trajectory to each measurement model before generating its dataset.
Trajectory resolves its sidecars from its own SPK rather than from that SPK’s folder, so the files written beside it win over anything else sharing the folder.
SPK segments are written as SPICE type 13 (unequally spaced Hermite) rather than type 9 (unequally spaced Lagrange). Type 13 holds the same (epoch, position, velocity) records in the same number of bytes, but the sampled velocities constrain the position curve, so the velocity SPICE returns is the exact derivative of the position it returns and the curve no longer steps where the interpolation window moves. Type 9 fitted position and velocity with two independent polynomials over a window re-centred on the request time; halfway between two nodes, where that window switches, the position curve jumped — the spikes seen when a trajectory is written on the integrator’s own adaptive grid. At the default degree_poly=3 a type-13 window spans two nodes, making the segment a piecewise cubic Hermite spline, continuous across every node.
SpiceManager.write_spk_segment_type9() is now SpiceManager.write_spk_segment_type13(). No other signature changes; Trajectory.write_to_spk(), get_state() and the JSON sidecars are untouched, and .bsp files already on disk still read.
degree_poly must now be odd (the default, 3, already is), because a type-13 polynomial is built from a position and a velocity per node. An even degree raises the new SpiceManager.EvenDegreeError. Only degree_poly=3 gives a true spline: at 5, 7 and up the window spans 3, 4, … nodes and moves again, so prefer a finer output grid over a higher degree.
An SPK segment now needs (degree_poly + 1) // 2 states rather than degree_poly + 1, because each node carries a derivative as well as a value, so a Hermite window is half the width the same degree cost under type 9. Grids that SpiceManager.TooFewStatesError used to turn away are now written: in particular a default degree-3 segment writes from two nodes, so a leg that adopted only its (t0, tf) bounds no longer fails — though one cubic then spans the whole leg, so declaring
epochsorperiod+dtstill matters when the output density does.DopplerReal / SequentialRangingReal:
A light-time solution that fails now raises (Measurement.LightTimeConvergenceError) instead of returning a zero round-trip light time.
A measurement whose round trip starts before the first ramp record has no defined transmit frequency. It now gets a NaN computed value, one warning per model, and an outlier flag, instead of a zero transmit frequency (a silently wrong observable). Raising would lose the whole pass.
The relativistic light-time delay takes Mars, Jupiter and Saturn at their system barycentres with the system GM, instead of at the planet centres. For a Mars orbiter this moves the round-trip light time by at most 0.63 mm of path and the 60 s Doppler by less than 1e-6 mHz; a Jupiter or Saturn orbiter should pass the planet centres through rlt_bodies.
A target listed among the relativistic light-time bodies, where Moyer’s delay diverges, now raises Measurement.RLTBodyOnPathError instead of giving an infinite light time.
The partials default to
partials_method="analytical"(the Moyer partials of the forward model’s own light-time solution). The analytical partials give zero columns for eta_srp and dv_man, as the finite-difference ones do, instead of raising NotImplementedError; the filter maps both through the STM.The forward model is several times faster on real tracking data, with results unchanged to the last bit: each media-calibration file is parsed once and its time tags converted once, the light-time solution reads each SPICE state it needs once, and SpiceManager.get_state() / get_state_precise() build their result without validating its units again. A one-iteration multi-pass OD on real DSN data went from 68 s to 10 s.
SequentialRangingReal: rows whose range is not a phase in [0, M) range units are flagged as outliers when the tracking file is read. These are the placeholder rows (range -1) that a DSN file opens a pass with, which carry no outlier flag.
FilterOD.fit(): every iteration is written to the folder the filter was built with, as
<name>_it{n}.bspafter the name it was built with, instead of a new timestamped<body>_traj_<time>.bspindata/kernels/scenario/on each pass.Measurement models take their numbers from Constants rather than from class or module attributes: the defaults of the simulated auxiliary data, the Earth rotation rate of the EOP partials (Constants.omega_Earth), the scheduler edge tolerance, the pass gaps and point counts of MeasurementEditing, and the day/hour/minute and deg/day-to-rad/s factors. Data-format keys stay on the class that reads them: the auxiliary-data layout of DopplerReal and SequentialRangingReal is each model’s
AUX_KEYS, a Measurement.TrackingAuxKeys; the ramp-table keys are Measurement.RAMP_AUX_KEYS and RAMP_YEAR_KEY; the DSN complex antenna ranges are MediaCorrections.DSN_COMPLEX_ANTENNAS.Each measurement model lists the partials methods it implements in one PARTIALS_METHODS tuple; an unsupported partials_method raises a single ValueError naming that model’s methods.
Measurement: the sigma property, the per-pass grouping (set_pass_epochs) and the bias lookup are defined once on the base class instead of in each of RangeIdeal, RangeRateIdeal, DopplerIdeal, DiffOneWayRangeIdeal, AngularIdeal, CentroidingIdeal and CustomMeasurement. MissingPassIndexError is Measurement.MissingPassIndexError.
FilterSettings.measurement_sigmas is set once, when the filter is built and before the first editing pass, on the model behind each named dataset, instead of being written into the datasets’ sigma columns on every reinitialization.
model.sigmanow reports it, the construction-time editing is weighted by it, and a sigma set on the model later (FilterOD.set_measurement_sigmas(), MeasurementSpec.edit() / flag(),model.sigma = ...) takes over from the next iteration, where the override used to beat it, including the sigma refitted byedit("huber_mad_filter"). Changingsettings.measurement_sigmasafter construction has no effect; call set_measurement_sigmas().MeasurementScheduler.build_epochs() takes
start/endas an EpochArray, ET seconds or anything the scheduler’sstart/endaccept, andcadence,pass_cadence,pass_duration,pass_offsetas an ArrayWUnits time or bare seconds. MeasurementScheduler.split_passes() takesgapthe same way. The keywords dropped their_et/_secsuffixes (start_et→start,cadence_sec→cadence,gap_sec→gap, …); positional calls are unchanged. A zero or negative span, orpass_cadencewithoutpass_duration, raises MeasurementScheduler.InvalidScheduleError instead of dividing by zero.MeasurementScheduler:
elevation_mask, in the constructor and in visibility(), visible_epochs(), passes(), schedule(), generate() and visibility_on(), takes an ArrayWUnits angle, converted from its own units, or a bare number of degrees, through Measurement.resolve_elevation_mask(). A mask outside 0 to 90 deg or not an angle raises InvalidScheduleError. Theelevation_maskproperty returns an ArrayWUnits in degrees instead of a float, likecadenceandpass_gap.Measurement.resolve_elevation_mask() refuses a bare mask that is not a whole number of degrees and is no more than pi/2, such as 0.17, which could be degrees or radians; pass it as an ArrayWUnits. Whole degrees and anything above pi/2 are read as degrees, as before.
GroundStation and the station displacement models return quantities with units instead of bare arrays. GroundStation.nominal_state(), displacement_state(), state_correction(), tide_correction(), iau_pole_correction() and eop_displacement() return an ArrayWFrame in km and km/s in the requested axes. location_partials(), rotation_partials(), inertial_rotation_partials(), tide_partials(), pole_tide_partials() and iau_pole_partials() return an ArrayWUnits whose rows are km and km/s per unit of each column, and the derivative from cylindrical_basis() is an ArrayWUnits per second (the basis stays a unitless array, like any direction cosine matrix). displacement(), state_displacement() and the
*_partials()of SolidTide, PoleTide and OceanLoading, and BodyOrientation.displacement() / state_displacement(), return an ArrayWUnits. Read the numbers with.values(ArrayWUnits) or.quantity.values(ArrayWFrame). The measurement models call the numeric cores (_nominal_state,_state_correction, …), so their observables and partials are unchanged to the last bit.The same methods take positions, velocities, locations, rotation vectors, IAU pole values and the PoleTide pole_x / pole_y as an ArrayWUnits or ArrayWFrame in any units of the right dimension; bare numbers are still km, km/s, rad and, for pole_pm, deg/day. A location given as an ArrayWFrame is read in its own axes unless
location_frameis passed.Frame: two Frame objects for the same SPICE frame compare equal and hash alike, by frame ID, where they compared by identity. Arithmetic between ArrayWFrame quantities built with separate
Frame("J2000")objects used to raise ValueError.MeasurementSpec.edit(dataset_name=…) and flag() return entries only for the streams they address, instead of an empty array for every other stream, which overwrote real counts when results were merged with dict.update().
MeasurementConfig.sc_transponder_delay_RU, MeasurementSpec.flag_outliers() and MeasurementEditing.residual_filter() document why they stay plain floats: a range unit’s length depends on each pass’s band and exciter scalars, and the outlier bounds are in the units of the residuals.
LKF: with consider parameters the gain is the one of the estimate conditioned on the considered states’ a-priori values, K = Pxx Hxᵀ (Hx Pxx Hxᵀ + R)⁻¹, the consider analysis that SRIF, SRIFB and LSB run, instead of a gain built from the consider covariance Pc. The LKF and the SRIF now give the same estimate and consider covariance; consider sigmas change, and the postfit cost with consider parameters is no longer about 0. The innovation covariance saved for the NIS adds the considered states’ term Hy Pcc Hyᵀ, Hy = Hx Sx + Hc. On very precise data (Doppler) the covariance form can still be a few percent off the SRIF, whose square-root form keeps twice the digits.
DynamicalModelCompensation:
betais optional. The filters discretize the noise with the decay rates the dynamics propagate with, the body’sbeta_fogmstate when there is one, else thefogm_betaof its ForceModelTranslation, evaluated on every interval and iteration, so an estimated decay rate is followed.betais used only when no reference decay rates are given.Tutorial advanced_RealMSR_OSIRIS_REx_OD: rewritten as a multi-pass batch orbit determination on real DSN data (three OSIRIS-REx passes of June 2018 from DSS-65 and DSS-35): SRIFB with PFOGM stochastic accelerations, an estimated SRP scale factor and one range bias per pass, Huber + MAD editing with operational data weights, a three-day forward-prediction consistency test against the OD044 reconstruction, and the tuning of the PFOGM strength with that test. The two extra tracking files ship with the supplementary data.
Deprecated#
StateArray.from_components()
Removed#
DatabaseManager is no longer part of the package.
The
scarabaeus.scarabaeus_rustmodule name; importscarabaeus.rust.The misspelled read option
sc_transpoder_delay_RU; passsc_transponder_delay_RU.Measurement.PARTIALS_METHODS_SUPPORTED, now PARTIALS_METHODS on each model.
DopplerReal / SequentialRangingReal: the partials_finite_diff flag; pass
partials_method="fd".RangeIdeal / RangeRateIdeal: set_pass_index() and _build_pass_index(). Group the epochs with set_pass_epochs(), or schedule with MeasurementScheduler.add(…, per_pass_bias=True).
MeasurementDataSet.remove_outliers(), which nothing called; outliers are flagged and skipped through the dataset’s outlier_flag.
DopplerReal / SequentialRangingReal: the “ideal” partials (the geometric derivative of an ideal range or range rate, which ignored the media, relativistic and station terms of the real observable);
partials_method="ideal"raises ValueError. Use “analytical” or “fd”.DopplerReal / SequentialRangingReal OPTIONAL_AUX_KEYS and RECORD_FIELDS, now the
optionalandrecord_fieldsof the models’ AUX_KEYS (a Measurement.TrackingAuxKeys, whoserequiredis the old AUX_KEYS tuple); MeasurementScheduler.EDGE_TOLERANCE_SEC, and MeasurementEditing’s DEFAULT_PASS_GAP_SEC and DEFAULT_MIN_PASS_POINTS; use the Constants entries listed under Changed.
Fixed#
ForceModelTranslation dropped the central body’s point-mass gravity whenever a spherical-harmonics model was configured, even when the harmonic field belonged to another body.
ForceModelTranslation: a body configured both as a spherical-harmonics field and as a third body was attracted twice. It is now dropped from the point-mass list, and a field whose body is not the propagation origin carries the indirect (frame) term itself, with its partials.
SphericalHarmonicsGravity: the IAU body-to-J2000 rotation multiplied the three NAIF factors untransposed, so any run that estimated pole_ra, pole_dec or pole_pm rotated the field to the wrong orientation. It now matches SPICE pxform to 3e-12, and the RA and prime-meridian partial signs are corrected.
SRIF: the covariance-analysis update without consider parameters crashed on a shape mismatch.
MultiFilterOD: each arc’s deviation and covariance were mapped with the STM instead of its inverse, carrying them forward rather than back to the arc’s initial epoch, and SRIF arcs handed over the information matrix instead of the covariance.
nPlateSRP: CK plates now apply the transpose of the C-matrix and are no longer rotated by the body attitude a second time; a body CK attitude uses the model’s frame instead of J2000; the SPICE error state is reset after a failed CK lookup. Under nadirPointingSun, CK and named-frame plates mixed with body-frame plates (solar arrays on their own CK on a nadir-pointed bus) keep their SPICE orientation, and the partials hold them fixed in the frame rather than in the body.
MissionSequence: a segment
periodordtgiven in days or hours is converted to seconds before the grid is built; a duration that is not a time raises TimeSpanError.Documentation: the API reference no longer duplicates docstring sections or lists nested exceptions as methods, inherited members link to their own class, every public class has a page, docstrings across all packages were corrected for numpydoc and Sphinx, and the landing-page icons render again under Font Awesome 7.
Camera: the calibration matrix divided the focal length in pixels by the IFOV a second time, inflating the projected pixel coordinates by one factor of the pixel pitch.
Camera: passing a Frame as camera_frame made get_rotation_to_camera() fall through to the identity attitude; the frame is now normalised to its name in the constructor.
CentroidingIdeal: the observer body was handed to spkezr as a bare integer SPICE ID, which resolves to nothing; it is now passed as a string.
CentroidingIdeal / AngularIdeal: the position partials of an explicit state definition had the wrong sign for both bodies, so an estimated spacecraft or imaged body was pulled away from the optical data instead of towards it. CentroidingIdeal had the camera’s spacecraft and the imaged body swapped; AngularIdeal’s (RA, Dec) Jacobian was the negative of the derivative with respect to r_target − r_observer. Both now match central differences of the observable. Without a state definition AngularIdeal returns the target’s partials, as its documentation and CentroidingIdeal already did; it used to return the observer’s.
AngularIdeal: a stacked per-image
angular_bias(dimension 2·N) with no epoch-to-image mapping produced two partial columns instead of 2·N, so every later state component’s partials landed in the wrong column. It now raises MissingImageIndexError, as CentroidingIdeal already did.AngularIdeal / CentroidingIdeal: with a stacked per-image bias (more than two elements) and no epoch-to-image mapping,
computed_measurements()applied image 0’s pair to every epoch without a word, while the partials refused the same case. The forward model now raises MissingImageIndexError too.RangeIdeal / RangeRateIdeal: a stacked per-pass bias (dimension > 1) with no epoch-to-pass mapping got one partial column instead of one per pass, so every later state component’s partials landed in the wrong column, while the forward model failed on a generic ArrayWUnits shape error. Both now raise MissingPassIndexError, as the optical models do for a stacked bias without an image mapping.
Ideal measurement models (RangeIdeal, RangeRateIdeal, DopplerIdeal, DiffOneWayRangeIdeal, AngularIdeal): a numeric
meas_bias, as documented and asMeasurementSpec.build()passes it (0.0 by default), raisedAttributeErrorfrommeas_bias.quantityoncecomputed_measurements()ran without a reference state. A number is now taken in the observable’s units (km, km/sec, Hz, km, rad), as DopplerReal does; an ArrayWUnits or ArrayWFrame keeps its own.Ideal measurement models (RangeIdeal, RangeRateIdeal, DopplerIdeal, DiffOneWayRangeIdeal, AngularIdeal):
meas_biaswas dropped as soon as a reference state was attached, even one with no bias entry for this station, so an OD run modelled no bias where the simulation had one.meas_biasnow holds until the reference state carries this station’s bias, which then overrides it, as in DopplerReal.RangeIdeal, RangeRateIdeal, AngularIdeal, CentroidingIdeal: with a pass or image mapping set, a single bias (dimension 1, or 2 for the optical models) was sliced as if it were stacked, so only the first pass or image saw it in the forward model while the partials gave a column to a pass index the state did not have. A single bias is now global in both: it applies to every pass or image, with a unit partial everywhere.
CustomMeasurement / MeasurementScheduler: each defined its own MissingSigmaError, CustomMeasurement’s shadowing the one it inherits, so
except Measurement.MissingSigmaErrormissed a custom model built without units or sigma and a noisy schedule without a sigma. Both now raiseMeasurement.MissingSigmaError;CustomMeasurement.MissingSigmaErrorandMeasurementScheduler.MissingSigmaErrorare that same class.Ideal measurement models (RangeIdeal, RangeRateIdeal, DopplerIdeal, DiffOneWayRangeIdeal, AngularIdeal, CentroidingIdeal, CustomMeasurement):
computed_measurements(epoch_start=..., epoch_end=..., tstep=...)raisedTypeErrorfromEpochArray(..., timeFrame=...)instead of building the grid. They now useMeasurement._resolve_epoch_array, like the real models, and raiseValueError(wasRuntimeError) when neither epochs nor bounds are given.nPlateSRP: plate normals written as integers in a configuration (e.g. [1, 0, 0]) produced an int64 array that the Rust core rejects; the normals cache is now pinned to float.
MissionSequence: a propagator whose tspan is a (t0, tf) tuple was silently collapsed to a two-epoch grid, so the leg propagated to two states and only failed later, inside spkw09, with SPICE(TOOFEWSTATES). Such a leg is now integrated between its bounds and adopts the integrator’s own grid (see Added), on DOP853 as well as IAS15.
Propagator.propagate(): a (t0, tf) tuple tspan raised “Non-selective time steps currently unsupported for DOP853 integration” — the branch was a stub with its working lines commented out. DOP853 chooses its own steps like any adaptive integrator, so the tuple now passes t_eval=None to solve_ivp and the solver’s own output times are returned. States match an explicit-grid run bit for bit at shared epochs. The event-resume and convert_to_original_frame paths, which assumed tspan carried a grid, follow the produced epochs.
Propagator.reinitialize(): allocated the integration storage from tspan.size, which a (t0, tf) tuple does not have, so reinitializing onto a tuple raised AttributeError. It now mirrors the constructor and allocates the initial condition only.
ScenarioSetup: a segment left with a single sample after its endpoint was dropped at a node passed a scalar where an array was expected, raising TypeError while the totals were accumulated.
Trajectory: a sequence propagated with propagate_STM=False hands one None per leg, a truthy list, which was dereferenced as an STM; STM-free sequences now write normally.
SpiceManager.get_propagator_settings(): matched on
body_ID, which a settings sidecar does not carry — Propagator.to_dict() records no body, origin, or frame — so reading back the settings written by Trajectory.write_to_spk() raised KeyError. Settings are now identified by the SPK they sit beside, and any identifiers a writer did record are still honoured.SpiceManager: the sidecars written beside one SPK share body_ID / origin_ID / reference_frame, so a lookup could return a neighbour’s payload — an STM sidecar answering a settings query, for instance. Each lookup now also checks that the file holds the payload it asked for.
SpiceManager: a lookup pointed at a folder that does not exist raised a bare FileNotFoundError from os.listdir; missing locations are now skipped, and the failure names every location searched.
SpiceManager.write_spk_segment_type13(): a segment with fewer states than the interpolation degree needs is now reported before the SPK is opened, instead of leaving an open handle behind and failing inside CSPICE.
MultiFilterOD: _get_stm_final() indexed the measurement epochs with the length of the covariance history, which is a count, so every arc that was not a SRIF raised IndexError; the index is now derived correctly and clamped to the measurement epochs.
ForceModelTranslation.to_dict() / from_dict(): the configured t0 was not written, so a reloaded model took each leg’s start as the PFOGM batch-grid anchor and the Fourier phase origin. It is now recorded and restored unless from_dict() is given one.
ForceModelTranslation.to_dict() / from_dict(): only the polyhedral_gravity flag was written, so a reloaded model silently fell back to a point mass. The shape (its file path, or its vertices and facets), density, GM, body-fixed frame and scale are now recorded; a file carrying only the flag warns.
DopplerReal: the two ends of the count interval were converted to time tags separately, and each conversion rounds differently, so their difference could be off by ~860 cycles (~17 Hz on 60 s X-band Doppler). Both ends now come from one conversion of t3.
DopplerReal / RampTableManager: the transmit window ends were plain floats in seconds of day, which resolve only ~7e-12 s and moved the count in steps of ~0.5–1 mHz on 60 s X-band Doppler. They are now carried as (high, low) pairs through the ramp integration.
RampTableManager: ramp records and window ends are placed on one continuous time axis, so a window or ramp segment that crosses midnight, or a new year when the years are given, integrates correctly.
DopplerReal / SequentialRangingReal: noisy=True built a TypeError without raising it and added no noise, so the “noisy” values came back noise-free. White Gaussian noise of the model’s sigma is now added.
DopplerReal / SequentialRangingReal: an estimated range or range-rate bias was added to the float observable as an ArrayWUnits, which raised TypeError. It is now added as a float in RU or Hz.
DopplerReal / SequentialRangingReal: aux fields kept in their own SFDU records are aligned to the measurement epochs by time tag (Measurement.align_aux_to_epochs), and every per-epoch entry, the electronic delays included, is checked against the measurement count before use (AuxDataError) instead of being indexed by row whatever its length.
Trajectory / SpiceManager: the parameters sidecar kept only parameters owned by the propagated body. A parameter whose owner is not propagated, such as a ground station’s range bias, was left out of every sidecar. SolutionOD therefore reported it as its deviation about 0, or misaligned the parameter vector. Such parameters now go into the first propagated body’s sidecar, so every parameter in the state vector is written to exactly one sidecar.
SpiceManager: the STM sidecar’s parameters_def / parameters_body skipped the first two state entries and labelled everything after them a parameter. In a multi-body state, the second propagated body’s position and velocity were listed as parameters. The labels now list every entry that is not a position or a velocity.
SpiceManager: a sequence leg’s parameters sidecar kept only the first parameter of the leg, so a maneuver epoch next to its delta-v, or a station’s range bias, was lost. Every parameter is now written. get_parameters reads a leg holding several parameters, which used to fail on the concatenated unit blocks. The stacked vector is dimensionless when the units differ, and per_parameter=True gives each parameter’s own values and units, as for a flat sidecar.
SolutionOD: the parameter rows of the deviation were taken as dev[6:]. With a second propagated body, these rows held that body’s position and velocity, and the deviations were added to the wrong nominal parameters. The rows are now selected from the state definition, by the same rule that writes the sidecar, from a full, padded or estimated-only deviation.
CustomMeasurement: a pass_epochs argument raised AttributeError, because the set_pass_epochs it forwards to was only defined on RangeIdeal and RangeRateIdeal.
StateDefinition: range_bias_RU_[tag] and rangerate_bias_Hz_[tag] matched the range_bias_[tag] / rangerate_bias_[tag] patterns first and were validated as a length and a velocity.
MeasurementEditing: the Huber detrending fitted residuals against raw ET (~1e8 s), which left the solver ill-conditioned and it aborted. The fit now runs in normalised coordinates, and points are flagged by their distance from the median of the detrended residuals.
MeasurementSpec.summary(): counted only the flags of the observed data, missing the measurements the model could not compute.
Trajectory: a trajectory built with neither a state nor legs, over a body already in the SPICE pool, failed in get_state(); it now reads the state from SPICE.
MeasurementSpec.edit(): a refitted sigma, in the units of the dataset’s residuals, was labelled with the units of the model’s current sigma without conversion, so a model with
sigma=ArrayWUnits(5, m)on a range in km got a 0.005 km refit stored as 0.005 m. It is now converted tosigma_units, else to the model sigma’s units, else kept in the dataset’s units. The refit lookup also failed with StopIteration on two-component streams.Measurement.generate_measurement_dataset(): the sigma column took the bare value of the model’s sigma whatever its units, so
sigma=ArrayWUnits(4, m)on a range computed in km weighted the residuals by 4 km. The sigma is now converted to the units of the computed measurement.LKF: the consider sensitivity Sx was initialised from a gain on the first measurement, outside the loop that then processed that measurement again, and the a-priori correlation between estimated and considered states was dropped. It now starts from the a-priori, Sx = Pxc Pcc⁻¹ and Pxx = Pc − Sx Pxcᵀ, as at the sequence nodes.
LKF: the Joseph-form covariance is symmetrized after each measurement update. Rounding left it slightly asymmetric, and with data much more precise than the a-priori (Doppler) the next gain amplified the asymmetry into covariances several times too large.
StateNoiseCompensation: the constant acceleration was mapped into the position and velocity by Γ = [Δt³/2; Δt²] instead of [Δt²/2; Δt], one power of Δt too many, so the discrete noise Q_k was Δt² (in s²) times too large. SNC results change, and a Q tuned against the old form must be retuned.
Tutorials: the supplementary data download fetches the DSN station kernels earthstns_fx_201023.bsp and earthstns_itrf93_201023.bsp from generic_kernels/spk/stations/a_old_versions/, where NAIF moved them; the old links returned 404.