Skip to content

PROGRESS.md

Latest commit

 

History

History
332 lines (326 loc) · 48.9 KB

PROGRESS.md

File metadata and controls

332 lines (326 loc) · 48.9 KB

DSST Python Port Progress

Current Baseline

  • Source identified: Orekit 13.1.6 org.orekit.propagation.semianalytical.dsst
  • Generated Python source map: 68 implementation classes
  • Package layout: src/dsst
  • Tests: pytest (261 tests passing, including the generated Orekit Java reference fixture with propagator configuration/bookkeeping, harvester setup, attitude-provider registration, mapper mean/osculating array conversion, scalar/field propagator initial/event integration-state conversion, scalar/field force mean-rate, drag/SRP Gaussian L-limit bounds, field/Gaussian/combined short-period value and conversion, two-hour propagator perturbation, two-hour osculating propagation, scalar/field short-period coefficient export, scalar/field CoefficientsFactory/interpolation/CjSj/Gamma/Lns/GHIJ/GHmsj utility, HansenUtilities polynomial generation, UpperBounds/Newcomb/Jacobi utility, scalar/field Hansen recurrence, and SRP root-helper parity rows)
  • Port metadata refreshed: PORTING_MANIFEST.json and generated provenance docstrings now describe the current implemented/parity-tested native DSST port instead of the original first-stage incomplete scaffold
  • Propagator mapper parity: mapper creation without an explicit central attraction now preserves mu learned from the initial state and carries it into mapped orbit states
  • Gravity date adapters: rotating-frame sampling and dated spherical harmonics now accept Orekit-like toAbsoluteDate wrappers
  • Short-period coefficient date adapters: Gaussian, zonal, tesseral, third-body, and shared short-period interpolation coefficient exports now accept Orekit-like nested toAbsoluteDate wrappers
  • Short-period value date adapters: Gaussian and zonal short-period value reconstruction is regression-tested with nested toAbsoluteDate wrappers
  • Formula-level utilities ported: abstract InterpolationGrid/FieldInterpolationGrid contracts, FixedNumberInterpolationGrid, MaxGapInterpolationGrid, FieldFixedNumberInterpolationGrid, FieldMaxGapInterpolationGrid, CoefficientsFactory, CjSjCoefficient, FieldCjSjCoefficient, GHIJjsPolynomials, GHmsjPolynomials, FieldGHIJjsPolynomials, FieldGHmsjPolynomials, UpperBounds, NewcombOperators, PolynomialFunctionMatrix, HansenUtilities, JacobiPolynomials, HansenThirdBodyLinear, HansenZonalLinear, HansenTesseralLinear, FieldHansenThirdBodyLinear, FieldHansenZonalLinear, FieldHansenTesseralLinear, LnsCoefficients, FieldLnsCoefficients, GammaMnsFunction, FieldGammaMnsFunction, ShortPeriodicsInterpolatedCoefficient, FieldShortPeriodicsInterpolatedCoefficient
  • Field CjSjCoefficient gradient plumbing extended: field complex powers and helper multiplication now preserve GradientValue derivatives for downstream field zonal, tesseral, and third-body formulas
  • Field third-body Hansen gradient plumbing extended: FieldHansenThirdBodyLinear now evaluates its roots, slice recurrences, and polynomial lookups with field arithmetic instead of scalar delegates
  • Field coefficient-factory gradient plumbing extended: computeQns and computeGsHs preserve GradientValue derivatives for downstream field third-body and zonal/tesseral potential builders
  • Field zonal/tesseral Hansen gradient plumbing extended: FieldHansenZonalLinear and FieldHansenTesseralLinear now evaluate roots, recurrences, and tesseral kernel series with field arithmetic instead of scalar delegates
  • Field polynomial gradient plumbing extended: FieldGHIJjsPolynomials and FieldGHmsjPolynomials now build on FieldCjSjCoefficient so G/H/I/J and G/H_msj values preserve GradientValue derivatives
  • Field GammaMns gradient plumbing extended: FieldGammaMnsFunction now evaluates Orekit's field Gamma recurrence directly, preserving GradientValue derivatives while retaining Orekit's retrograde derivative convention
  • Field Lns gradient plumbing extended: FieldLnsCoefficients now evaluates Lns and dLns/dGamma tables with field Qns/Vns/roa arithmetic instead of scalar delegates
  • Field interpolation grid gradient plumbing extended: FieldFixedNumberInterpolationGrid and FieldMaxGapInterpolationGrid now compute grid points with field start/end arithmetic instead of scalar delegates
  • Field short-period interpolation gradient plumbing extended: FieldShortPeriodicsInterpolatedCoefficient now stores field samples/dates directly and evaluates Lagrange weights with field arithmetic
  • Force-model context helpers ported: ForceModelContext, FieldForceModelContext, DSSTNewtonianAttractionContext, FieldDSSTNewtonianAttractionContext, AbstractGaussianContributionContext, FieldAbstractGaussianContributionContext, DSSTGravityContext, FieldDSSTGravityContext, DSSTZonalContext, FieldDSSTZonalContext, DSSTTesseralContext, FieldDSSTTesseralContext, DSSTThirdBodyStaticContext, DSSTThirdBodyDynamicContext, FieldDSSTThirdBodyDynamicContext, DSSTJ2SquaredClosedFormContext, FieldDSSTJ2SquaredClosedFormContext
  • Field third-body dynamic context gradient plumbing extended: FieldDSSTThirdBodyDynamicContext preserves gradient-valued A/B/X, direction-cosine, mean-motion, and third-body ratio helpers for future analytic third-body STM paths
  • Gravity provider adapter extended: SphericalHarmonicsProviderData.from_shm_file loads Orekit SHM-format gravity fields, converts fully-normalized coefficients to unnormalized harmonics, applies GRDOTA secular trends from explicit elapsed Julian years or target ISO dates using the SHM noon-TT reference convention, and supports dynamic trend sampling through onDate
  • Body-frame transform adapter extended: RotatingFrameData samples simple z-axis body-fixed rotations at scalar/ISO orbit dates, TransformProviderData samples callable transform providers at (date, frame), StaticTransformData.transformVector applies arbitrary vectors by linear basis composition, and date-resolved transforms feed scalar/field gravity, zonal, and tesseral contexts
  • Force-model scalar helpers ported: DSSTSolarRadiationPressure real quadratic/cubic/quartic roots
  • Parameter driver adapter expanded: lightweight drivers expose scalar, selection, span-name, span-count, span construction, span-map copying, clamped value mutation, reference-value, scale, normalized-value helpers, generated span renaming, and Orekit-style value/metadata observer callbacks used by DSST force models
  • Parameter driver date coercion aligned: span insertion and lookup now use shared nested toAbsoluteDate and ISO-8601 timestamp parsing, storing added boundaries as scalar seconds so force-model span selection matches C++ adapter behavior
  • Parameter driver periodic-span date adapters covered: addSpans now has Python/C++ regression coverage for ISO-8601 and nested toAbsoluteDate boundaries used by force-model parameter spans
  • ISO date-only parameter spans covered: Python/C++ regression coverage now treats YYYY-MM-DD as midnight UTC during force-parameter span insertion and lookup
  • Force-model interface defaults ported: DSSTForceModel no-op init, empty scalar/field event detectors, empty scalar/field short-period lifecycle hooks, zero mean-rate default, attitude-provider hook, driver access, and span-aware parameter extraction
  • Force-model parameter provider helpers extended: base models expose getParameters(date) and getParametersAllValues() from lightweight parameter drivers, and Gaussian/zonal/tesseral/third-body short-period updates extract active parameter spans at each sample date
  • Force-model shells ported: DSSTNewtonianAttraction parameter-driver storage, date-aware getMu, empty scalar/field short-period terms, context initialization, and no-op update/attitude hooks; DSSTAtmosphericDrag drag/spacecraft/atmosphere accessors, rbar, scalar/field event and driver forwarding, scalar/field L-limit branches, and isotropic data-backed acceleration; DSSTSolarRadiationPressure spacecraft/radius/driver accessors, scalar/field shadow L-limit branch logic, and isotropic data-backed acceleration
  • Atmospheric-drag atmosphere provider coverage extended: Orekit-style getDensity(date, position, frame) and getVelocity(date, position, frame) providers are regression-tested through Gaussian drag acceleration using the sampled state date/frame
  • Solar-radiation-pressure spacecraft adapter coverage extended: spacecraft-provided radiation drivers are regression-tested through the Orekit-style spacecraft constructor and feed SRP acceleration parameter selection
  • Solar-radiation-pressure Sun-provider coverage extended: Orekit-style sun.getPosition(date, frame) providers and callable sun(date, frame) providers are regression-tested through SRP L-limit and acceleration calls using the propagated state date/frame
  • Third-body body adapter coverage extended: CelestialBodyData now samples date/frame-dependent positions and callable body(date, frame) providers through scalar and field dynamic contexts with an Orekit-style frame guard
  • Force-model mean rates started: DSSTNewtonianAttraction returns the central Keplerian mean longitude rate from scalar/field auxiliary semi-major axes or an orbit adapter
  • Newtonian field mean-rate gradient plumbing extended: field GM parameters and field semi-major axes now propagate GradientValue derivatives through the central Keplerian mean longitude rate
  • Field propagator gradient bridge added: FieldDSSTPropagator now preserves GradientValue derivatives through lightweight field-orbit and field spacecraft-state propagation by finite-differencing the native scalar RK4 path
  • Newtonian Orekit parity regression added: scalar and field DSSTNewtonianAttraction rates reproduce Orekit's Java fixture for the 2007 equinoctial test orbit
  • Orekit force mean-rate parity regression added: Java-generated fixture rows now compare DSSTNewtonianAttraction, DSSTJ2SquaredClosedForm, DSSTZonal, DSSTThirdBody, DSSTTesseral, DSSTSolarRadiationPressure, and DSSTAtmosphericDrag scalar/field native mean-rate outputs against Orekit-generated rates for the 2003 Moon third-body and 2007 equinoctial SHM gravity/SRP/drag cases
  • Orekit Gaussian L-limit parity regression added: Java-generated scalar and Binary64 fixture rows now compare DSSTAtmosphericDrag outside-atmosphere, full-atmosphere, and partial-atmosphere longitude bounds plus DSSTSolarRadiationPressure default and shadow-clipped bounds against the native Python getLLimits implementations
  • Orekit field short-period parity regression expanded: Java-generated Binary64 fixture rows now compare direct FieldShortPeriodTerms.value output for DSSTZonal, DSSTTesseral, DSSTThirdBody, DSSTSolarRadiationPressure, and DSSTAtmosphericDrag against native Python field short-period lifecycle updates
  • Orekit propagator perturbation parity regression added: Java-generated fixture rows now compare individual-force and combined-force mean DSSTPropagator integration with DSSTZonal, DSSTJ2SquaredClosedForm, DSSTTesseral, static-body DSSTThirdBody, DSSTSolarRadiationPressure, and DSSTAtmosphericDrag plus Newtonian attraction against native Python propagation for SHM gravity, 2003 Moon third-body, 2007 Gaussian SRP/drag, and 2007 all-force-stack cases
  • Orekit field propagator parity regression expanded: Java-generated Binary64 fixture rows now compare FieldDSSTPropagator.propagate zonal, J2-squared, tesseral, third-body, SRP, drag, and combined-force propagation against the native Python field propagator wrapper across the shared propagation horizon
  • Field propagator double-backed propagation routing fixed: non-gradient FieldEquinoctialOrbitData inputs now propagate through a scalar shadow state and rewrap the propagated result instead of preserving the original field orbit through osculating output conversion
  • Orekit propagator configuration parity regression added: Java-generated fixture rows now compare DSSTPropagator defaults, osculating initial-state flagging, state-derived Newtonian attraction insertion, selected-coefficient copy/null semantics, force-model ordering, Newtonian replacement, and remove-force-model preservation against the native Python shell
  • Orekit propagator reset parity regression added: Java-generated scalar and Binary64 fixture rows now compare resetInitialState(state) flag preservation and resetInitialState(state, PropagationType) mean/osculating flag toggling while retaining state-derived Newtonian attraction
  • Orekit propagator integration-state parity regression added: Java-generated fixture rows now compare getInitialIntegrationState and resetIntegrationStateAtEvent mean/osculating conversion with DSSTZonal short-period updates against the native Python propagator shell
  • Orekit field propagator integration-state parity regression added: Java-generated Binary64 fixture rows now compare FieldDSSTPropagator.getInitialIntegrationState and resetIntegrationStateAtEvent mean/osculating conversion with DSSTZonal short-period updates against the native Python field propagator shell
  • Orekit harvester setup parity regression added: Java-generated fixture rows now compare DSSTPropagator.setupMatricesComputation STM name/dimension, initial STM and Jacobian columns, dynamic selected-parameter column names before freeze, Orekit-generated single-span parameter names, and frozen column-name preservation against the native Python harvester
  • Orekit attitude-provider registration parity added: Java-generated scalar and Binary64 fixture rows now compare DSSTPropagator.setAttitudeProvider force-model registration on initial force insertion, provider replacement, later force insertion, shared provider identity, and retained force ordering against the native Python propagator plumbing
  • Orekit propagator mapper parity regression added: Java-generated fixture rows now compare DSSTPropagator mean/osculating StateMapper.mapArrayToState and mapStateToArray behavior, including mass/date offsets, element derivatives, short-period element offsets, and selected coefficient export, against the native Python mapper shell
  • Native map-state propagation adapters extended: dict-backed spacecraft states now regression-test duration-date target preservation, frame/mass/additional-data carry-through, derivative summation from orbit-derived auxiliary elements, embedded/explicit auxiliary override precedence, short-period lifecycle updates, auxiliary-only map states, and osculating initial/event conversion
  • Native STM/Jacobian map-state adapters extended: dict-backed state-transition and selected-parameter Jacobian helpers now regression-test top-level additional data, nested additional_data, Orekit-style nested additionalData, snake/camel additional-state derivative blockers, and auxiliary-only osculating lifecycle initialization
  • Native map-state mass adapters extended: Python/C++ regression coverage now confirms numeric-string spacecraft masses flow through field propagation and gradient-converter map-state adapters without confusing mass parsing with date parsing
  • Scalar map-state mass adapter coverage extended: Python scalar mapper conversion, propagation, interpolation-grid lifecycle updates, and osculating initial/event reset paths now regression-test numeric-string spacecraft masses
  • Final native-adapter propagation audit completed: all non-package Orekit DSST propagator, force, context, utility, and Hansen source classes are represented in the manifest; scalar/field force mean-rate, short-period, mapper, propagation, STM/Jacobian, and native orbit/date/frame adapter paths are covered by native tests and Orekit Java fixture comparisons, with external Orekit ecosystem objects intentionally represented by lightweight adapters/data records
  • Orekit osculating propagation parity regression expanded: Java-generated fixture rows now compare PropagationType.OSCULATING DSSTZonal, DSSTTesseral, DSSTThirdBody, DSSTSolarRadiationPressure, DSSTAtmosphericDrag, and combined-force-stack propagation from mean initial states at 0/60/120/600/1800/3600/7200 seconds, including Orekit's zero-duration initial-state boundary behavior and derived true/eccentric longitude fields
  • Orekit propagation horizon extended: the Java fixture generator now emits shared propagation target rows through 7200 seconds for Newtonian, zonal, J2-squared, tesseral, third-body, SRP, drag, and combined-force mean/osculating comparisons
  • Orekit utility parity regression added: Java-generated fixture rows now compare ported fixed-count/max-gap interpolation grids, CjSjCoefficient, and GammaMnsFunction behavior against Orekit at test time
  • Orekit CoefficientsFactory parity regression added: Java-generated fixture rows now compare scalar/Binary64 Qns and Gs/Hs tables plus sampled Vns and Vmns coefficients against the native Python coefficient factory
  • Orekit field interpolation grid parity regression added: Java-generated Binary64 fixture rows now compare FieldFixedNumberInterpolationGrid and FieldMaxGapInterpolationGrid behavior against the native Python field-grid utilities
  • Orekit field CjSj/Gamma parity regression added: Java-generated Binary64 fixture rows now compare FieldCjSjCoefficient and FieldGammaMnsFunction behavior against the native Python field utility wrappers
  • Orekit scalar/field Lns parity regression added: Java-generated fixture rows now compare LnsCoefficients and FieldLnsCoefficients tables built from Orekit CoefficientsFactory.computeQns/computeVns against the native Python wrappers
  • Orekit scalar/field GHIJ/GHmsj parity regression added: Java-generated fixture rows now compare GHIJjsPolynomials, GHmsjPolynomials, and their Binary64 field wrappers across derivative branches against the native Python utilities
  • Orekit HansenUtilities parity regression added: Java-generated fixture rows now compare generateZonalPolynomials, generateTesseralPolynomials, and generateThirdBodyPolynomials polynomial and derivative coefficient vectors against the native Python Hansen utility generator
  • Orekit recurrence utility parity expanded: Java-generated fixture rows now compare UpperBounds.getDnl/getRnml, NewcombOperators.getValue, and JacobiPolynomials.getValueAndDerivative against the native Python utilities
  • Orekit propagator tolerance parity added: Java-generated fixture rows now compare DSSTPropagator.tolerances(dP, orbit) and tolerances(dP, dV, orbit) against the exact Orekit equinoctial mean-angle Jacobian tolerance projection
  • Orekit Hansen parity regression added: Java-generated fixture rows now compare ported HansenThirdBodyLinear, HansenZonalLinear, and HansenTesseralLinear value/derivative recurrences against Orekit at test time
  • Orekit field Hansen parity regression added: Java-generated Binary64 fixture rows now compare FieldHansenThirdBodyLinear, FieldHansenZonalLinear, and FieldHansenTesseralLinear value/derivative recurrences against the native Python field Hansen wrappers
  • Orekit SRP helper parity regression added: Java-generated fixture rows now reflectively sample Orekit's private DSSTSolarRadiationPressure real quadratic/cubic/quartic root helpers and compare the ported Python behavior against those counts and roots
  • Orekit selected short-period coefficient parity regression expanded: Java-generated fixture rows now compare ShortPeriodTerms.getCoefficients selected coefficient vectors for DSSTZonal, DSSTTesseral, DSSTThirdBody, DSSTSolarRadiationPressure, and DSSTAtmosphericDrag against the native Python short-period coefficient exports
  • Orekit field selected short-period coefficient parity regression added: Java-generated Binary64 fixture rows now compare FieldShortPeriodTerms.getCoefficients selected coefficient vectors for DSSTZonal, DSSTTesseral, DSSTThirdBody, DSSTSolarRadiationPressure, and DSSTAtmosphericDrag against the native Python field short-period coefficient exports
  • Orekit Gaussian short-period conversion parity expanded: Java-generated fixture rows now compare SRP and atmospheric-drag getShortPeriodTermsValue, computeOsculatingState, and fixed-point computeMeanState behavior against the native Python propagator using Gaussian-specific recovery tolerances
  • Orekit combined short-period conversion parity added: Java-generated fixture rows now compare summed zonal, J2-squared, tesseral, third-body, SRP, and atmospheric-drag short-period vectors plus mean/osculating conversion against native Python propagator accumulation
  • Orekit third-body Fourier/generating parity regression added: Java-generated fixture rows now reflectively compare DSSTThirdBody Fourier Cj/Sj coefficients and generating-function coefficient families against the native Python third-body helpers
  • Zonal field mean-rate gradient bridge added: DSSTZonal.getMeanElementRate now preserves GradientValue dimensions and finite-difference derivatives for field auxiliary elements and field GM parameters while retaining the scalar Orekit-derived zonal rate path
  • Third-body field mean-rate gradient bridge added: DSSTThirdBody.getMeanElementRate now preserves GradientValue dimensions and finite-difference derivatives for field auxiliary elements and third-body/central GM parameters while retaining the scalar Orekit-derived third-body rate path
  • Tesseral field mean-rate gradient bridge added: DSSTTesseral.getMeanElementRate now preserves GradientValue dimensions and finite-difference derivatives for field auxiliary elements and field GM parameters while retaining the scalar Orekit-derived tesseral rate path
  • Higher-order force shell constructors ported: DSSTZonal, DSSTTesseral, and DSSTThirdBody retain provider/body metadata, driver lists, truncation settings, and context initialization hooks
  • Gaussian contribution helper shell ported: constructor state, parameter driver aggregation, context initialization, anomaly conversions, rate-difference check, velocity derivative vector helpers, Gauss-Legendre quadrature, scalar/field mean-rate integration, rho/sigma coefficients, Fourier coefficients, U/V short-period coefficients, K20 helper, scalar/field short-period coefficient storage/export/value reconstruction, and lifecycle update wiring
  • Gaussian field context gradient plumbing extended: FieldAbstractGaussianContributionContext now preserves gradient-valued GM, semi-major-axis, mean-motion, A, reciprocal-mu, and ton2a helpers
  • Gaussian field mean-rate gradient bridge added: AbstractGaussianContribution.getMeanElementRate now preserves GradientValue dimensions and finite-difference derivatives for field auxiliary elements and Gaussian parameters while retaining the scalar Orekit-derived quadrature path
  • Gaussian helper wrappers exposed: the outer contribution shell delegates typed Fourier, U/V, and Gaussian short-period coefficient accessors/mutators to the ported nested implementations, with missing-receiver calls, abstract L-limit hooks, and invalid acceleration configuration treated as contract errors rather than incomplete ports
  • Gaussian lifecycle adapters extended: scalar/field short-period updates can derive auxiliary elements from lightweight orbit and spacecraft-state wrappers passed through the propagator
  • Gaussian lifecycle self-delegation fixed: SRP-as-Gaussian-contribution initialization now behaves as a no-op instead of recursing through the outer force shell during propagation setup
  • Zonal/tesseral lifecycle adapters extended: short-period updates can derive auxiliary elements from lightweight orbit and spacecraft-state wrappers passed through the propagator
  • J2-squared models ported: ZeisModel C2Z constant and mean equinoctial second-order terms
  • J2-squared force wrapper ported: DSSTJ2SquaredClosedForm mean rates, scalar/field short-period lifecycle delegation, empty parameter drivers, and no-op attitude/update hooks; J2SquaredModel abstract mean-term contract plus default empty/no-op scalar/field short-period behavior
  • J2-squared field context gradient coverage extended: FieldDSSTJ2SquaredClosedFormContext now regression-tests gradient-valued A4, eta, inclination-cosine, and sin-squared helpers
  • J2-squared Orekit parity regression added: scalar and field DSSTJ2SquaredClosedForm rates reproduce Orekit's Zeis mean-rate fixture for the 200 km x 210 km Java test orbit using the native SHM reader's dated C20 coefficient
  • Orbit support helpers ported: AuxiliaryElements, FieldAuxiliaryElements
  • Short-period term interfaces ported: ShortPeriodTerms and FieldShortPeriodTerms expose value, key-prefix, and coefficient filtering adapters
  • Propagator support shells ported: DSSTPropagator force-model container, central attraction management, interpolation grid selection, initial-state flags, satellite revolution, selected coefficient storage, short-period term storage/value aggregation, matrices-harvester setup, and lightweight state-transition/Jacobian column derivative helpers
  • Field propagator shell ported: FieldDSSTPropagator preserves field-class provenance while reusing the native DSST force-container, interpolation, short-period, derivative, and lightweight propagation plumbing
  • Field propagator state-wrapper coverage extended: field equinoctial spacecraft states seed central attraction from mu and round-trip through osculating propagation while preserving FieldEquinoctialOrbitData
  • Field propagator selected-coefficient coverage extended: field osculating orbit/state propagation now verifies selected short-period coefficients survive on both field orbit and spacecraft-state adapters
  • Field propagator configured-orbit coverage extended: direct FieldEquinoctialOrbitData initial states are regression-tested through no-arg propagation with selected coefficients and derivative payloads preserved
  • Source inventory guard added: the Python manifest test now compares PORTING_MANIFEST.json against the live Orekit 13.1.6 DSST Java source tree and verifies every listed Python port file exists
  • Propagator derivative flow started: DSSTPropagator.computeDerivatives now sums native force-model mean rates for lightweight auxiliary-state adapters
  • Propagator generic force hook covered: custom DSSTForceModel mean-rate implementations participate in derivative summation and lightweight propagation
  • Propagator derivative flow extended: closed-form J2-squared force rates are included alongside Newtonian central-attraction rates
  • Lightweight propagation started: propagate integrates numeric-date equinoctial state adapters with a native RK4 loop driven by computeDerivatives
  • Propagator lifecycle hooks started: beforeIntegration initializes short-period terms and triggers osculating short-period updates; afterIntegration clears the handler state
  • Lightweight propagation lifecycle extended: propagate now runs force-model init/before/after integration hooks, refreshes osculating short-period terms on configured interpolation-grid samples, and preserves manual short-period terms when no force generates replacements
  • Propagator lifecycle override coverage added: beforeIntegration raw orbit and spacecraft-state inputs honor explicit auxiliary elements when initializing short-period terms
  • Short-period value adapters covered: aggregate short-period evaluation unwraps lightweight spacecraft-state wrappers to their equinoctial orbit before evaluating terms
  • Force short-period value adapters extended: Gaussian, zonal, tesseral, and third-body force-created short-period terms unwrap lightweight spacecraft-state wrappers directly before evaluating coefficient grids
  • Interpolation grid interfaces completed: base and field grid contracts expose getGridPoints, and concrete fixed-count/max-gap grids inherit those shared interfaces
  • Short-period orbit conversion started: computeOsculatingOrbit/computeOsculatingState apply equinoctial short-period terms and computeMeanState provides the matching single-step inverse
  • Mapper integration-state flow started: getInitialIntegrationState and resetIntegrationStateAtEvent now use the short-period mean/osculating conversion shell
  • Mean-state conversion extended: lightweight osculating-to-mean conversion now uses an Orekit-style fixed-point iteration over short-period terms
  • Mapper array conversion started: mapArrayToState and mapStateToArray convert DSST equinoctial arrays with mass, derived lightweight orbit scalars, and optional short-period osculating terms
  • Mapper validation extended: mapArrayToState now enforces Orekit's positive spacecraft-mass requirement for integration arrays
  • Mapper spacecraft-state output added: mapArrayToSpacecraftState now wraps mapped arrays into lightweight states preserving date, orbit, mass, and selected short-period coefficients
  • Mapper derivative output added: mapper array/state conversion now preserves the six equinoctial element derivatives from yDot and fills them back through the native output-list adapter
  • Mapper creation ported: createMapper preserves DSST mapper settings while refreshing common mapping metadata and mapped osculating states carry selected short-period coefficients
  • Osculating output coefficient capture extended: direct osculating conversion and lightweight propagation now attach selected short-period coefficients to orbit/state outputs
  • Spacecraft-state coefficient capture extended: SimpleSpacecraftState osculating conversion and propagation preserve selected short-period coefficients in additional data
  • Lightweight propagation conversion extended: propagate now converts osculating initial states to mean integration elements and converts propagated mean states back to osculating output when requested
  • Lightweight spacecraft-state propagation started: SimpleSpacecraftState can carry orbit/date/mass and the Python propagator preserves that wrapper through mean and osculating propagation
  • Lightweight spacecraft-state derivative parity extended: SimpleSpacecraftState exposes Orekit-style additional state derivative add/get helpers, and propagator STM/Jacobian derivative handoff now uses the immutable helper path
  • Tolerance helper ported: DSSTPropagator.tolerances returns deterministic absolute/relative equinoctial tolerance vectors from position and optional velocity error
  • Short-period step hook started: updateOnStep refreshes force-model short-period terms from mean-state adapters and handleStep preserves Orekit's no-op behavior
  • Lightweight propagation step sampling extended: osculating RK4 propagation forwards configured interpolation-grid mean-state batches to force-model short-period updates
  • STM/Jacobian setup ported: propagator setup now creates or reuses STM and selected-parameter column providers, seeds missing initial additional data, and freezes harvester columns
  • Newtonian parameter observer hooks ported: ParameterDriver.addObserver, valueChanged, and valueSpanMapChanged now refresh the propagator gravitational parameter from scalar and dated driver values
  • Zonal mean-elements truncation ported: computeMeanElementsTruncations now evaluates Orekit's upper-bound eccentricity-power selector for lightweight harmonics providers
  • Zonal mean-rate equation ported: computeMeanElementRates now maps supplied gravitational potential derivatives into DSST equinoctial mean-element rates
  • Zonal D_i coefficient generation ported: computeDiCoefficients now normalizes mean-element rates by mean motion and stores the Orekit potential correction on the slot grid
  • Zonal rho/sigma auxiliary coefficients ported: computeRhoSigmaCoefficients now evaluates the Danielson short-period helper from Orekit's CjSjCoefficient
  • Zonal short-period coefficient slot/export helpers ported: SlotData, createSlot, getCoefficientsKeyPrefix, storeIfSelected, and getCoefficients now use the existing interpolation coefficient utility
  • Zonal short-period value reconstruction ported: value now evaluates the stored D_i, C_i^j, and S_i^j grids for an explicit coefficient slot and mean orbit
  • Zonal C_i^j/S_i^j coefficient generation ported: computeCijSijCoefficients now evaluates Orekit's scalar short-period algebra for a supplied Fourier coefficient bundle
  • Zonal Hansen object holder ported: HansenObjects, createHansenObjects, computeHansenObjectsInitValues, and getHansenObjects now wrap initialized HansenZonalLinear series
  • Zonal Fourier coefficient accessors ported: FourierCjSjData and the getCj/getSj derivative accessors now expose generated coefficient bundles
  • Zonal potential derivative engine ported: createUAnddU now evaluates Orekit's scalar gravitational potential and derivative sums over Gs/Hs, Qns, Vns, and Hansen coefficients
  • Zonal generated mean-rate path ported: getMeanElementRate now builds context, Hansen objects, U derivatives, and returns the DSST mean-element rates
  • Zonal Orekit parity regression added: scalar and field DSSTZonal rates reproduce Orekit's SHM 4x4 Java fixture for the 2007 equinoctial test orbit using the native SHM reader with normalized-to-unnormalized coefficients and secular trend applied
  • Third-body Orekit parity regression added: scalar and field DSSTThirdBody rates reproduce Orekit's Moon fixture using Java-generated inertial body position and GM metadata
  • Tesseral Orekit parity regression added: scalar and field DSSTTesseral rates reproduce Orekit's SHM 4x4 Java fixture with matching lightweight body-frame metadata and tesseral truncation settings
  • SRP Orekit parity regression added: scalar and field DSSTSolarRadiationPressure rates reproduce Orekit's Java fixture using fixed-Sun metadata, spherical Earth radius, spacecraft area/CR, mass, and true/eccentric longitude fixture columns
  • Atmospheric-drag Orekit parity regression added: scalar and field DSSTAtmosphericDrag rates reproduce Orekit's Java fixture using constant-density/zero-velocity atmosphere metadata, spacecraft area/CD, mass, and true/eccentric longitude fixture columns
  • Zonal field short-period lifecycle adapters ported: initializeFieldShortPeriodTerms/updateFieldShortPeriodTerms now maintain field coefficient slots backed by the scalar zonal engine
  • Zonal field mean-rate path ported: field auxiliary inputs now unwrap through the scalar zonal engine and match scalar rates for double-backed field states
  • Tesseral short-period engine ported: slot storage/export, Hansen object initialization, n-sum kernel, Fourier builder/generator, short-period update, and resonant mean-rate path are implemented for lightweight harmonics providers
  • Tesseral field short-period lifecycle adapters ported: initializeFieldShortPeriodTerms/updateFieldShortPeriodTerms now maintain field coefficient slots backed by the scalar tesseral engine
  • Tesseral field mean-rate path ported: field auxiliary inputs now unwrap through the scalar tesseral engine and match scalar rates for double-backed field states
  • Third-body engine ported: short-period container, Gns, ABDE, Wnsj, Fourier, generating-function coefficients, typed coefficient helper wrappers, short-period update, and mean-rate path are implemented for lightweight body/state providers; missing-receiver helper calls are treated as usage errors rather than incomplete ports
  • Third-body lifecycle adapters extended: short-period updates can derive auxiliary elements from lightweight orbit and spacecraft-state wrappers passed through the propagator
  • Third-body field short-period lifecycle adapters ported: initializeFieldShortPeriodTerms/updateFieldShortPeriodTerms now maintain field coefficient slots backed by the scalar third-body engine
  • Third-body field mean-rate path ported: field auxiliary inputs now unwrap through the scalar third-body engine and match scalar rates for double-backed field states
  • Propagator force integration extended: third-body, tesseral, Gaussian, data-backed drag, and data-backed SRP forces participate in native derivative summation and short-period lifecycle coverage
  • Lightweight propagation force coverage extended: Gaussian mean rates now have short-step propagation coverage in addition to derivative summation tests
  • Matrices harvester shell ported: DSSTHarvester stores STM metadata, initial STM/Jacobian columns, frozen column names, orbit/angle type, state-carried STM/Jacobian readback, Orekit-style B1/B2/B3/B4 accessors, and short-period derivative accumulator matrices
  • Gradient converter shell ported: DSSTGradientConverter builds six free equinoctial state gradients from dict, orbit, and spacecraft-state adapters and selected parameter-span gradients for DSST Jacobian plumbing
  • Gradient primitive arithmetic ported: lightweight GradientValue now supports scalar/gradient add, subtract, multiply, divide, and unary negation with product/quotient-rule derivative propagation
  • Gradient primitive elementary functions ported: lightweight GradientValue now supports sqrt, sin, cos, and scalar powers for field/Jacobian formulas
  • Gradient primitive geometry functions ported: lightweight GradientValue now supports atan, atan2, and hypot derivative propagation for anomaly and vector-geometry formulas
  • Field/J2 gradient path extended: FieldAuxiliaryElements preserves gradient-backed equinoctial scalars through B/C/vector helpers and DSSTJ2SquaredClosedForm now feeds analytic Zeis-model J2-squared gradients into STM partials
  • Field gravity/zonal context gradient plumbing extended: FieldDSSTGravityContext and FieldDSSTZonalContext now preserve gradient-valued scalar helpers instead of collapsing them to floats
  • Field tesseral context gradient plumbing extended: FieldDSSTTesseralContext now preserves gradient-valued eccentricity, orbit-period, resonant-ratio, and body-angle helpers
  • Harvester field-gradient bridge started: DSSTHarvester initializes/updates field short-period terms with gradient state parameters and reconstructs B1/B4 short-period derivative matrices from gradient-valued field terms
  • Field short-period gradient callbacks covered: harvester B1/B4 reconstruction now exercises orbit-dependent gradient-valued short-period term callbacks
  • Native propagation date adapters extended: lightweight RK4 propagation now unwraps Orekit-like toAbsoluteDate/durationFrom date adapters for integration while preserving the requested target date object on returned orbit/state adapters
  • Field propagation date adapter coverage extended: FieldDSSTPropagator now has regression coverage for date-adapter targets through lightweight field spacecraft-state propagation
  • Field propagation mapping coverage extended: FieldDSSTPropagator now regression-tests dict states carrying field equinoctial orbits, preserving mapping shape, date/frame adapters, additional data, and gradient derivatives through direct propagation
  • Field mean/osculating conversion gradient bridge extended: FieldDSSTPropagator now preserves GradientValue field derivatives through lightweight spacecraft-state mean-to-osculating and osculating-to-mean conversion using the scalar DSST conversion path as the finite-difference reference
  • Field integration-state coverage extended: FieldDSSTPropagator now regression-tests field spacecraft-state wrappers and gradient orbit derivatives through getInitialIntegrationState and resetIntegrationStateAtEvent
  • Native propagation frame adapters extended: initial orbit/spacecraft-state frames now seed the propagator mapper and are preserved by default array-to-state mapping unless createMapper receives an explicit frame override
  • Propagation-type adapters extended: DSSTPropagator now normalizes Orekit-like dotted/case-varied propagation type strings before lifecycle, initial-state, reset, and map-array decisions, matching the C++ enum-like adapter path
  • Lightweight propagation frame continuity coverage extended: osculating interpolation-grid short-period update batches now regression-test that native orbit frames survive through propagated mean-state samples and final outputs
  • Mapper state-to-array adapter coverage extended: Python mapStateToArray now explicitly regression-tests lightweight SimpleSpacecraftState wrappers alongside dict states, matching the C++ state adapter path
  • Orekit regression harness started: optional Java-generated Newtonian DSST reference fixture schema/generator and native comparison test are in place; fixture generation requires a JDK and Maven

Verification Commands

$env:PYTHONPATH = "D:\orekit\DSST-python\src"
python -m pytest

Milestones

  • Create native Python project directory.
  • Preserve Orekit DSST package/class provenance.
  • Preserve field spacecraft-state wrappers through lightweight propagation.
  • Preserve selected short-period coefficients on field propagation outputs.
  • Add pytest unit/functionality smoke coverage for manifest imports and incomplete-port boundary.
  • Port first Orekit/Hipparchus-independent math utilities.
  • Port DSST polynomial and upper-bound utility helpers.
  • Port field polynomial helper wrappers.
  • Port field interpolation grid wrappers.
  • Port interpolation grid interface contracts.
  • Port modified Newcomb operators.
  • Port Hansen polynomial matrix and generator utilities.
  • Port Jacobi polynomial provider.
  • Port third-body Hansen coefficient class.
  • Port zonal Hansen coefficient class.
  • Port tesseral Hansen coefficient class.
  • Port field Hansen coefficient wrappers.
  • Expose field tesseral Hansen series helper methods.
  • Port Lns coefficient table.
  • Port GammaMns function.
  • Port field Lns and Gamma wrappers.
  • Port short-period interpolated coefficient utility.
  • Port field short-period interpolated coefficient wrapper.
  • Port first central-attraction force context carrier.
  • Port field central-attraction force context carrier.
  • Port Gaussian contribution scalar context carriers.
  • Port gravity scalar context carriers with transform adapter.
  • Add date-aware rotating-frame sampling for gravity and tesseral contexts.
  • Port zonal scalar context carriers.
  • Port tesseral scalar context carriers.
  • Port third-body static truncation context.
  • Port third-body dynamic scalar context carriers.
  • Port J2-squared closed-form context carriers.
  • Port SRP scalar polynomial root helpers.
  • Port SRP data-backed Gaussian acceleration path.
  • Port Newtonian attraction force shell and parameter driver.
  • Port atmospheric drag force shell and L-limit formula.
  • Port atmospheric drag data-backed Gaussian acceleration path and atmosphere provider sampling.
  • Port solar radiation pressure shell, shadow L-limit formula, and Sun-provider sampling.
  • Port Zeis J2-squared second-order model.
  • Port DSST J2-squared closed-form force wrapper.
  • Port DSST force-model default methods.
  • Port DSST force-model field short-period lifecycle defaults.
  • Add force-model parameter provider helpers.
  • Cover generic DSSTForceModel mean-rate propagation.
  • Expand lightweight ParameterDriver accessor parity.
  • Align Python ParameterDriver date coercion with C++.
  • Cover ParameterDriver periodic span date adapters.
  • Cover ISO date-only ParameterDriver span boundaries.
  • Port auxiliary equinoctial element container.
  • Port field auxiliary equinoctial element container.
  • Port zonal/tesseral/third-body force constructor shells.
  • Port DSST propagator force container shell.
  • Port FieldDSSTPropagator container and derivative shell.
  • Cover FieldDSSTPropagator lightweight propagation inheritance.
  • Port Gaussian contribution helper shell.
  • Port Gaussian quadrature and scalar mean-rate integration.
  • Wire Gaussian forces into propagator derivative summation.
  • Port Gaussian rho/sigma, Fourier, U/V, and K20 short-period helpers.
  • Port Gaussian short-period coefficient storage, export, value reconstruction, and lifecycle update wiring.
  • Port Gaussian field short-period lifecycle adapters.
  • Port state-transition and Jacobian column helper shells.
  • Port DSST gradient converter shell.
  • Port short-period term interfaces and propagator mapper aggregation.
  • Port matrices harvester shell and propagator matrix setup plumbing.
  • Add lightweight Gradient arithmetic for field/Jacobian plumbing.
  • Add lightweight Gradient elementary functions for field/Jacobian plumbing.
  • Add lightweight Gradient geometry functions for field/Jacobian plumbing.
  • Preserve field auxiliary gradients and feed J2-squared gradient rates into STM partials.
  • Preserve field gravity/zonal context gradients for future analytic STM force paths.
  • Preserve field tesseral context gradients for future analytic tesseral STM paths.
  • Wire harvester field short-period gradients into B1/B4 reconstruction.
  • Port Newtonian central attraction mean-element rate.
  • Port propagator mean-rate summation shell.
  • Wire closed-form J2-squared mean rates into propagator derivative summation.
  • Add lightweight numeric-date propagation over native equinoctial state adapters.
  • Accept Orekit-like date adapters at the lightweight propagation boundary.
  • Cover field propagator date-adapter propagation.
  • Cover field propagator mapping-state adapters in Python.
  • Preserve field mean/osculating conversion gradients in Python.
  • Cover field integration-state adapters in Python.
  • Cover numeric-string mass map-state adapters.
  • Cover scalar numeric-string mass map-state adapters in Python.
  • Seed mapper frame from native initial orbit and spacecraft-state adapters.
  • Run short-period lifecycle hooks during lightweight propagation.
  • Wire short-period mean/osculating conversion into lightweight propagation.
  • Port propagator short-period lifecycle hooks.
  • Port short-period osculating/mean orbit mapping shell.
  • Port lightweight fixed-point osculating-to-mean conversion.
  • Port initial and event-reset integration-state conversion shell.
  • Port mapper array/state conversion shell.
  • Port mapper positive-mass validation.
  • Add lightweight mapper spacecraft-state output.
  • Preserve mapper equinoctial element derivatives.
  • Port mapper creation and selected short-period coefficient capture.
  • Attach selected short-period coefficients to osculating propagation outputs.
  • Preserve selected short-period coefficients on lightweight spacecraft-state outputs.
  • Add lightweight Python spacecraft-state propagation adapter.
  • Add Orekit-style spacecraft-state derivative helper parity.
  • Port DSST tolerance helper shell.
  • Port short-period step update hook shell.
  • Forward Python lightweight propagation short-period updates as interpolation-grid batches.
  • Port STM and selected-parameter Jacobian setup shell.
  • Preserve Python STM/Jacobian map-state adapters.
  • Port Newtonian parameter observer hooks.
  • Port DSSTZonal mean-elements truncation selector.
  • Port DSSTZonal mean-rate equation from supplied U derivatives.
  • Port DSSTZonal D_i short-period coefficient generation.
  • Port DSSTZonal rho/sigma short-period helper coefficients.
  • Port DSSTZonal short-period coefficient slot and export helpers.
  • Port DSSTZonal short-period value reconstruction.
  • Port DSSTZonal C_i^j/S_i^j short-period coefficient generation.
  • Port DSSTZonal Hansen object holder.
  • Port DSSTZonal Fourier coefficient accessors.
  • Port DSSTZonal U and dU potential derivative engine.
  • Port DSSTZonal generated mean-rate path.
  • Port DSSTZonal field short-period lifecycle adapters.
  • Port DSSTZonal field mean-rate path.
  • Port DSSTTesseral short-period containers and coefficient generation.
  • Port DSSTTesseral generated mean-rate path.
  • Port DSSTTesseral field short-period lifecycle adapters.
  • Port DSSTTesseral field mean-rate path.
  • Port DSSTThirdBody coefficient families, short-period update, and generated mean-rate path.
  • Port DSSTThirdBody field short-period lifecycle adapters.
  • Port DSSTThirdBody field mean-rate path.
  • Wire third-body, tesseral, and concrete Gaussian drag/SRP forces into propagator-level coverage.
  • Cover Gaussian mean-rate participation in lightweight propagation.
  • Start optional Orekit Java numerical regression harness.
  • Add numerical regression tests against Orekit Java outputs.
  • Add Orekit Java parity for DSSTPropagator configuration and force-model bookkeeping.
  • Add Orekit Java parity for DSSTPropagator mean/osculating mapper array conversion.
  • Add Orekit Java parity for field interpolation grid utility wrappers.
  • Add Orekit Java parity for field CjSj/Gamma utility wrappers.
  • Add Orekit Java parity for scalar/field Lns coefficient tables.
  • Add Orekit Java parity for scalar/field GHIJ/GHmsj polynomial helpers.
  • Add Orekit Java parity for HansenUtilities generated polynomial vectors.
  • Add Orekit Java parity for CoefficientsFactory Qns/GsHs/Vns/Vmns helpers.
  • Add Orekit Java parity for field Hansen recurrence wrappers.
  • Add Orekit Java parity for scalar/field Zonal, Tesseral, ThirdBody, SRP, and atmospheric-drag short-period values and mean/osculating conversion.
  • Add Orekit Java parity for combined-force short-period value and mean/osculating conversion.
  • Add Orekit Java parity for DSSTPropagator attitude-provider registration behavior.
  • Add Orekit Java parity for drag/SRP Gaussian L-limit bounds.
  • Add Orekit Java parity for FieldDSSTPropagator initial/event integration-state conversion.
  • Port full force models and propagator integration flow against native orbit/date/frame adapters.