public class NumericalPropagator extends AbstractIntegratedPropagator
orbits using
numerical integration.
Numerical propagation is much more accurate than analytical propagation
like for example Keplerian or Eckstein-Hechler, but requires a few more steps to set up to be used properly.
Whereas analytical propagators are configured only thanks to their various
constructors and can be used immediately after construction, numerical propagators
configuration involve setting several parameters between construction time
and propagation time.
The configuration parameters that can be set are:
setInitialState(SpacecraftState))setMu(double))addForceModel(ForceModel),
removeForceModels())type of orbital parameters to be used for propagation
(setOrbitType(OrbitType)),type of position angle to be used in orbital parameters
to be used for propagation where it is relevant (setPositionAngleType(PositionAngle)),state transition matrices and Jacobians matrices
should be propagated along with orbital state (AbstractPropagator.setupMatricesComputation(String, RealMatrix, DoubleArrayDictionary)),additional derivatives
should be propagated along with orbital state (AbstractIntegratedPropagator.addAdditionalDerivativesProvider(AdditionalDerivativesProvider)),AbstractIntegratedPropagator.addEventDetector(EventDetector),
AbstractIntegratedPropagator.clearEventsDetectors())AbstractPropagator.getMultiplexer())From these configuration parameters, only the initial state is mandatory. The default
propagation settings are in equinoctial parameters with
true longitude argument. If the central attraction coefficient
is not explicitly specified, the one used to define the initial orbit will be used.
However, specifying only the initial state and perhaps the central attraction coefficient
would mean the propagator would use only Keplerian forces. In this case, the simpler KeplerianPropagator class would
perhaps be more effective.
The underlying numerical integrator set up in the constructor may also have its own configuration parameters. Typical configuration parameters for adaptive stepsize integrators are the min, max and perhaps start step size as well as the absolute and/or relative errors thresholds.
The state that is seen by the integrator is a simple seven elements double array. The six first elements are either:
equinoctial orbit parameters (a, ex,
ey, hx, hy, λM or λE
or λv) in meters and radians,Keplerian orbit parameters (a, e, i, ω, Ω,
M or E or v) in meters and radians,circular orbit parameters (a, ex, ey, i,
Ω, αM or αE or αv) in meters
and radians,Cartesian orbit parameters (x, y, z, vx,
vy, vz) in meters and meters per seconds.
The last element is the mass in kilograms and changes only during thrusters firings
The following code snippet shows a typical setting for Low Earth Orbit propagation in equinoctial parameters and true longitude argument:
final double dP = 0.001; final double minStep = 0.001; final double maxStep = 500; final double initStep = 60; final double[][] tolerance = NumericalPropagator.tolerances(dP, orbit, OrbitType.EQUINOCTIAL); AdaptiveStepsizeIntegrator integrator = new DormandPrince853Integrator(minStep, maxStep, tolerance[0], tolerance[1]); integrator.setInitialStepSize(initStep); propagator = new NumericalPropagator(integrator);
By default, at the end of the propagation, the propagator resets the initial state to the final state,
thus allowing a new propagation to be started from there without recomputing the part already performed.
This behaviour can be chenged by calling AbstractIntegratedPropagator.setResetAtEnd(boolean).
Beware the same instance cannot be used simultaneously by different threads, the class is not thread-safe.
SpacecraftState,
ForceModel,
OrekitStepHandler,
OrekitFixedStepHandler,
IntegratedEphemeris,
TimeDerivativesEquationsAbstractIntegratedPropagator.MainStateEquationsDEFAULT_MASS| Constructor and Description |
|---|
NumericalPropagator(ODEIntegrator integrator)
Create a new instance of NumericalPropagator, based on orbit definition mu.
|
NumericalPropagator(ODEIntegrator integrator,
AttitudeProvider attitudeProvider)
Create a new instance of NumericalPropagator, based on orbit definition mu.
|
| Modifier and Type | Method and Description |
|---|---|
void |
addForceModel(ForceModel model)
Add a force model.
|
protected void |
beforeIntegration(SpacecraftState initialState,
AbsoluteDate tEnd)
Method called just before integration.
|
protected AbstractMatricesHarvester |
createHarvester(String stmName,
RealMatrix initialStm,
DoubleArrayDictionary initialJacobianColumns)
Create the harvester suitable for propagator.
|
protected StateMapper |
createMapper(AbsoluteDate referenceDate,
double mu,
OrbitType orbitType,
PositionAngle positionAngleType,
AttitudeProvider attitudeProvider,
Frame frame)
Create a mapper between raw double components and spacecraft state.
|
List<ForceModel> |
getAllForceModels()
Get all the force models, perturbing forces and Newtonian attraction included.
|
protected AbstractIntegratedPropagator.MainStateEquations |
getMainStateEquations(ODEIntegrator integrator)
Get the differential equations to integrate (for main state only).
|
OrbitType |
getOrbitType()
Get propagation parameter type.
|
PositionAngle |
getPositionAngleType()
Get propagation parameter type.
|
TimeStampedPVCoordinates |
getPVCoordinates(AbsoluteDate date,
Frame frame)
Get the
PVCoordinates of the body in the selected frame. |
void |
removeForceModels()
Remove all force models (except central attraction).
|
void |
resetInitialState(SpacecraftState state)
Reset the propagator initial state.
|
void |
setIgnoreCentralAttraction(boolean ignoreCentralAttraction)
Set the flag to ignore or not the creation of a
NewtonianAttraction. |
void |
setInitialState(SpacecraftState initialState)
Set the initial state.
|
void |
setMu(double mu)
Set the central attraction coefficient μ.
|
void |
setOrbitType(OrbitType orbitType)
Set propagation orbit type.
|
void |
setPositionAngleType(PositionAngle positionAngleType)
Set position angle type.
|
protected void |
setUpStmAndJacobianGenerators()
Set up State Transition Matrix and Jacobian matrix handling.
|
static double[][] |
tolerances(double dP,
AbsolutePVCoordinates absPva)
Estimate tolerance vectors for integrators when propagating in absolute position-velocity-acceleration.
|
static double[][] |
tolerances(double dP,
double dV,
Orbit orbit,
OrbitType type)
Estimate tolerance vectors for integrators when propagating in orbits.
|
static double[][] |
tolerances(double dP,
Orbit orbit,
OrbitType type)
Estimate tolerance vectors for integrators when propagating in orbits.
|
addAdditionalDerivativesProvider, addAdditionalEquations, addEventDetector, afterIntegration, clearEventsDetectors, getAdditionalDerivativesProviders, getBasicDimension, getCalls, getEphemerisGenerator, getEventsDetectors, getInitialIntegrationState, getIntegrator, getManagedAdditionalStates, getMu, getPropagationType, initMapper, isAdditionalStateManaged, isMeanOrbit, propagate, propagate, setAttitudeProvider, setResetAtEnd, setUpEventDetector, setUpUserEventDetectorsaddAdditionalStateProvider, getAdditionalStateProviders, getAttitudeProvider, getFrame, getHarvester, getInitialState, getMultiplexer, getStartDate, initializeAdditionalStates, initializePropagation, setStartDate, setupMatricesComputation, stateChanged, updateAdditionalStates, updateUnmanagedStatesclone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitclearStepHandlers, getDefaultLaw, setStepHandler, setStepHandler@DefaultDataContext public NumericalPropagator(ODEIntegrator integrator)
addForceModel is not
called after creation, the integrated orbit will follow a Keplerian
evolution only. The defaults are OrbitType.EQUINOCTIAL
for propagation
orbit type and PositionAngle.TRUE for position angle type.
This constructor uses the default data context.
integrator - numerical integrator to use for propagation.NumericalPropagator(ODEIntegrator, AttitudeProvider)public NumericalPropagator(ODEIntegrator integrator, AttitudeProvider attitudeProvider)
addForceModel is not
called after creation, the integrated orbit will follow a Keplerian
evolution only. The defaults are OrbitType.EQUINOCTIAL
for propagation
orbit type and PositionAngle.TRUE for position angle type.integrator - numerical integrator to use for propagation.attitudeProvider - the attitude law.public void setIgnoreCentralAttraction(boolean ignoreCentralAttraction)
NewtonianAttraction.ignoreCentralAttraction - if true, NewtonianAttraction is not
added automatically if missingpublic void setMu(double mu)
Setting the central attraction coefficient is
equivalent to add
a NewtonianAttraction force model.
setMu in class AbstractIntegratedPropagatormu - central attraction coefficient (m³/s²)addForceModel(ForceModel),
getAllForceModels()public void addForceModel(ForceModel model)
If this method is not called at all, the integrated orbit will follow a Keplerian evolution only.
model - ForceModel to add (it can be either a perturbing force
model or an instance of NewtonianAttraction)removeForceModels(),
setMu(double)public void removeForceModels()
Once all perturbing forces have been removed (and as long as no new force model is added), the integrated orbit will follow a Keplerian evolution only.
addForceModel(ForceModel)public List<ForceModel> getAllForceModels()
addForceModel(ForceModel),
setMu(double)public void setOrbitType(OrbitType orbitType)
setOrbitType in class AbstractIntegratedPropagatororbitType - orbit type to use for propagation, null for
propagating using AbsolutePVCoordinates rather than Orbitpublic OrbitType getOrbitType()
getOrbitType in class AbstractIntegratedPropagatorAbsolutePVCoordinates rather than Orbitpublic void setPositionAngleType(PositionAngle positionAngleType)
The position parameter type is meaningful only if propagation orbit type
support it. As an example, it is not meaningful for propagation
in Cartesian parameters.
setPositionAngleType in class AbstractIntegratedPropagatorpositionAngleType - angle type to use for propagationpublic PositionAngle getPositionAngleType()
getPositionAngleType in class AbstractIntegratedPropagatorpublic void setInitialState(SpacecraftState initialState)
initialState - initial statepublic void resetInitialState(SpacecraftState state)
resetInitialState in interface PropagatorresetInitialState in class AbstractPropagatorstate - new initial state to considerprotected AbstractMatricesHarvester createHarvester(String stmName, RealMatrix initialStm, DoubleArrayDictionary initialJacobianColumns)
createHarvester in class AbstractPropagatorstmName - State Transition Matrix state nameinitialStm - initial State Transition Matrix ∂Y/∂Y₀,
if null (which is the most frequent case), assumed to be 6x6 identityinitialJacobianColumns - initial columns of the Jacobians matrix with respect to parameters,
if null or if some selected parameters are missing from the dictionary, the corresponding
initial column is assumed to be 0protected void setUpStmAndJacobianGenerators()
setUpStmAndJacobianGenerators in class AbstractIntegratedPropagatorpublic TimeStampedPVCoordinates getPVCoordinates(AbsoluteDate date, Frame frame)
PVCoordinates of the body in the selected frame.getPVCoordinates in interface PVCoordinatesProvidergetPVCoordinates in class AbstractPropagatordate - current dateframe - the frame where to define the positionprotected StateMapper createMapper(AbsoluteDate referenceDate, double mu, OrbitType orbitType, PositionAngle positionAngleType, AttitudeProvider attitudeProvider, Frame frame)
The position parameter type is meaningful only if propagation orbit type
support it. As an example, it is not meaningful for propagation
in Cartesian parameters.
createMapper in class AbstractIntegratedPropagatorreferenceDate - reference datemu - central attraction coefficient (m³/s²)orbitType - orbit type to use for mappingpositionAngleType - angle type to use for propagationattitudeProvider - attitude providerframe - inertial frameprotected AbstractIntegratedPropagator.MainStateEquations getMainStateEquations(ODEIntegrator integrator)
getMainStateEquations in class AbstractIntegratedPropagatorintegrator - numerical integrator to use for propagation.public static double[][] tolerances(double dP,
AbsolutePVCoordinates absPva)
dP - user specified position errorabsPva - reference absolute position-velocity-accelerationtolerances(double, Orbit, OrbitType)public static double[][] tolerances(double dP,
Orbit orbit,
OrbitType type)
The errors are estimated from partial derivatives properties of orbits, starting from a scalar position error specified by the user. Considering the energy conservation equation V = sqrt(mu (2/r - 1/a)), we get at constant energy (i.e. on a Keplerian trajectory):
V r² |dV| = mu |dr|
So we deduce a scalar velocity error consistent with the position error. From here, we apply orbits Jacobians matrices to get consistent errors on orbital parameters.
The tolerances are only orders of magnitude, and integrator tolerances are only local estimates, not global ones. So some care must be taken when using these tolerances. Setting 1mm as a position error does NOT mean the tolerances will guarantee a 1mm error position after several orbits integration.
dP - user specified position errororbit - reference orbittype - propagation type for the meaning of the tolerance vectors elements
(it may be different from orbit.getType())public static double[][] tolerances(double dP,
double dV,
Orbit orbit,
OrbitType type)
The errors are estimated from partial derivatives properties of orbits, starting from scalar position and velocity errors specified by the user.
The tolerances are only orders of magnitude, and integrator tolerances are only local estimates, not global ones. So some care must be taken when using these tolerances. Setting 1mm as a position error does NOT mean the tolerances will guarantee a 1mm error position after several orbits integration.
dP - user specified position errordV - user specified velocity errororbit - reference orbittype - propagation type for the meaning of the tolerance vectors elements
(it may be different from orbit.getType())protected void beforeIntegration(SpacecraftState initialState, AbsoluteDate tEnd)
The default implementation does nothing, it may be specialized in subclasses.
beforeIntegration in class AbstractIntegratedPropagatorinitialState - initial statetEnd - target date at which state should be propagatedCopyright © 2002-2023 CS GROUP. All rights reserved.