org.orekit.propagation.semianalytical.dsst

Class DSSTPropagator

java.lang.Object

org.orekit.propagation.AbstractPropagator

org.orekit.propagation.integration.AbstractIntegratedPropagator

org.orekit.propagation.semianalytical.dsst.DSSTPropagator

All Implemented Interfaces:

Propagator, PVCoordinatesProvider

public class DSSTPropagator
extends AbstractIntegratedPropagator

This class propagates orbits using the DSST theory.

Whereas analytical propagators are configured only thanks to their various constructors and can be used immediately after construction, such a semianalytical propagator configuration involves setting several parameters between construction time and propagation time, just as numerical propagators.

The configuration parameters that can be set are:

• the initial spacecraft state (setInitialState(SpacecraftState))
• the various force models (addForceModel(DSSTForceModel), removeForceModels())
• the discrete events that should be triggered during propagation ( AbstractIntegratedPropagator.addEventDetector(org.orekit.propagation.events.EventDetector), AbstractIntegratedPropagator.clearEventsDetectors())
• the binding logic with the rest of the application (AbstractIntegratedPropagator.setSlaveMode(), AbstractPropagator.setMasterMode(double, org.orekit.propagation.sampling.OrekitFixedStepHandler), AbstractIntegratedPropagator.setMasterMode(org.orekit.propagation.sampling.OrekitStepHandler), AbstractIntegratedPropagator.setEphemerisMode(), AbstractIntegratedPropagator.getGeneratedEphemeris())

From these configuration parameters, only the initial state is mandatory. The default propagation settings are in equinoctial parameters with true longitude argument. The central attraction coefficient used to define the initial orbit will be used. However, specifying only the initial state would mean the propagator would use only keplerian forces. In this case, the simpler KeplerianPropagator class would 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 six elements double array. These six elements are:

• the equinoctial orbit parameters (a, e_x, e_y, h_x, h_y, λ_m) in meters and radians,

The same propagator can be reused for several orbit extrapolations, by resetting the initial state without modifying the other configuration parameters. However, the same instance cannot be used simultaneously by different threads, the class is not thread-safe.

Author:

Romain Di Costanzo, Pascal Parraud

See Also:

SpacecraftState, DSSTForceModel

Nested Class Summary

Nested classes/interfaces inherited from class org.orekit.propagation.integration.AbstractIntegratedPropagator

AbstractIntegratedPropagator.MainStateEquations

Field Summary

Fields inherited from interface org.orekit.propagation.Propagator

DEFAULT_LAW, DEFAULT_MASS, EPHEMERIS_GENERATION_MODE, MASTER_MODE, SLAVE_MODE

Constructor Summary

Constructors

Constructor and Description
DSSTPropagator(AbstractIntegrator integrator) Create a new instance of DSSTPropagator.
DSSTPropagator(AbstractIntegrator integrator, boolean meanOnly) Create a new instance of DSSTPropagator.

Method Summary

Methods

Modifier and Type	Method and Description
void	addForceModel(DSSTForceModel force) Add a force model to the global perturbation model.
protected void	afterIntegration() Method called just after integration.
protected void	beforeIntegration(SpacecraftState initialState, AbsoluteDate tEnd) Method called just before integration.
static SpacecraftState	computeMeanState(SpacecraftState osculating, Collection<DSSTForceModel> forces) Conversion from osculating to mean, orbit.
static SpacecraftState	computeOsculatingState(SpacecraftState mean, Collection<DSSTForceModel> forces) Conversion from mean to osculating orbit.
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.
protected AbstractIntegratedPropagator.MainStateEquations	getMainStateEquations(AbstractIntegrator integrator) Get the differential equations to integrate (for main state only).
int	getSatelliteRevolution() Get the number of satellite revolutions to use for converting osculating to mean elements.
boolean	initialIsOsculating() Check if the initial state is provided in osculating elements.
void	removeForceModels() Remove all perturbing force models from the global perturbation model.
void	resetInitialState(SpacecraftState state) Reset the initial state.
void	setAttitudeProvider(AttitudeProvider attitudeProvider) Set attitude provider.
void	setInitialState(SpacecraftState initialState) Set the initial state with osculating orbital elements.
void	setInitialState(SpacecraftState initialState, boolean isOsculating) Set the initial state.
void	setSatelliteRevolution(int satelliteRevolution) Override the default value of the parameter.
static double[][]	tolerances(double dP, Orbit orbit) Estimate tolerance vectors for an AdaptativeStepsizeIntegrator.

Methods inherited from class org.orekit.propagation.integration.AbstractIntegratedPropagator

addAdditionalEquations, addEventDetector, clearEventsDetectors, getBasicDimension, getCalls, getEventsDetectors, getGeneratedEphemeris, getIntegrator, getManagedAdditionalStates, getMu, getOrbitType, getPositionAngleType, initMapper, isAdditionalStateManaged, isMeanOrbit, propagate, propagate, propagate, setEphemerisMode, setMasterMode, setMu, setOrbitType, setPositionAngleType, setSlaveMode, setUpEventDetector, setUpUserEventDetectors

Methods inherited from class org.orekit.propagation.AbstractPropagator

addAdditionalStateProvider, getAdditionalStateProviders, getAttitudeProvider, getFixedStepSize, getFrame, getInitialState, getMode, getPVCoordinates, getStartDate, getStepHandler, setMasterMode, setStartDate, updateAdditionalStates

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

DSSTPropagator

public DSSTPropagator(AbstractIntegrator integrator,
              boolean meanOnly)

Create a new instance of DSSTPropagator.

After creation, there are no perturbing forces at all. This means that if addForceModel is not called after creation, the integrated orbit will follow a keplerian evolution only.

Parameters:

integrator - numerical integrator to use for propagation.

meanOnly - output only the mean orbits.

DSSTPropagator

public DSSTPropagator(AbstractIntegrator integrator)

Create a new instance of DSSTPropagator.

After creation, there are no perturbing forces at all. This means that if addForceModel is not called after creation, the integrated orbit will follow a keplerian evolution only. Only the mean orbits will be generated.

Parameters:

integrator - numerical integrator to use for propagation.

Method Detail

setInitialState

public void setInitialState(SpacecraftState initialState)
                     throws PropagationException

Set the initial state with osculating orbital elements.

Parameters:

initialState - initial state (defined with osculating elements)

Throws:

PropagationException - if the initial state cannot be set

setInitialState

public void setInitialState(SpacecraftState initialState,
                   boolean isOsculating)
                     throws PropagationException

Set the initial state.

Parameters:

initialState - initial state

isOsculating - true if the orbital state is defined with osculating elements

Throws:

PropagationException - if the initial state cannot be set

resetInitialState

public void resetInitialState(SpacecraftState state)
                       throws PropagationException

Reset the initial state.

Specified by:

resetInitialState in interface Propagator

Overrides:

resetInitialState in class AbstractPropagator

Parameters:

state - new initial state

Throws:

PropagationException - if initial state cannot be reset

initialIsOsculating

public boolean initialIsOsculating()

Check if the initial state is provided in osculating elements.

Returns:

true if initial state is provided in osculating elements

addForceModel

public void addForceModel(DSSTForceModel force)

Add a force model to the global perturbation model.

If this method is not called at all, the integrated orbit will follow a keplerian evolution only.

Parameters:

force - perturbing force to add

See Also:

removeForceModels()

removeForceModels

public void removeForceModels()

Remove all perturbing force models from the global perturbation model.

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.

See Also:

addForceModel(DSSTForceModel)

computeOsculatingState

public static SpacecraftState computeOsculatingState(SpacecraftState mean,
                                     Collection<DSSTForceModel> forces)
                                              throws OrekitException

Conversion from mean to osculating orbit.

Compute osculating state in a DSST sense, corresponding to the mean SpacecraftState in input, and according to the Force models taken into account.

Since the osculating state is obtained by adding short-periodic variation of each force model, the resulting output will depend on the force models parameterized in input.

Parameters:

mean - Mean state to convert

forces - Forces to take into account

Returns:

osculating state in a DSST sense

Throws:

OrekitException - if computation of short periodics fails

computeMeanState

public static SpacecraftState computeMeanState(SpacecraftState osculating,
                               Collection<DSSTForceModel> forces)
                                        throws OrekitException

Conversion from osculating to mean, orbit.

Compute osculating state in a DSST sense, corresponding to the mean SpacecraftState in input, and according to the Force models taken into account.

Since the osculating state is obtained with the computation of short-periodic variation of each force model, the resulting output will depend on the force models parametrized in input.

The computing is done through a fixed-point iteration process.

Parameters:

osculating - Osculating state to convert

forces - Forces to take into account

Returns:

mean state in a DSST sense

Throws:

OrekitException - if computation of short periodics fails or iteration algorithm does not converge

setSatelliteRevolution

public void setSatelliteRevolution(int satelliteRevolution)

Override the default value of the parameter.

By default, if the initial orbit is defined as osculating, it will be averaged over 2 satellite revolutions. This can be changed by using this method.

Parameters:

satelliteRevolution - number of satellite revolutions to use for converting osculating to mean elements

getSatelliteRevolution

public int getSatelliteRevolution()

Get the number of satellite revolutions to use for converting osculating to mean elements.

Returns:

number of satellite revolutions to use for converting osculating to mean elements

setAttitudeProvider

public void setAttitudeProvider(AttitudeProvider attitudeProvider)

Set attitude provider.

Specified by:

setAttitudeProvider in interface Propagator

Overrides:

setAttitudeProvider in class AbstractIntegratedPropagator

Parameters:

attitudeProvider - attitude provider

beforeIntegration

protected void beforeIntegration(SpacecraftState initialState,
                     AbsoluteDate tEnd)
                          throws OrekitException

Method called just before integration.

The default implementation does nothing, it may be specialized in subclasses.

Overrides:

beforeIntegration in class AbstractIntegratedPropagator

Parameters:

initialState - initial state

tEnd - target date at which state should be propagated

Throws:

OrekitException - if hook cannot be run

afterIntegration

protected void afterIntegration()
                         throws OrekitException

Method called just after integration.

The default implementation does nothing, it may be specialized in subclasses.

Overrides:

afterIntegration in class AbstractIntegratedPropagator

Throws:

OrekitException - if hook cannot be run

createMapper

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. /** Simple constructor.

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.

Specified by:

createMapper in class AbstractIntegratedPropagator

Parameters:

referenceDate - reference date

mu - central attraction coefficient (m³/s²)

orbitType - orbit type to use for mapping

positionAngleType - angle type to use for propagation

attitudeProvider - attitude provider

frame - inertial frame

Returns:

new mapper

getMainStateEquations

protected AbstractIntegratedPropagator.MainStateEquations getMainStateEquations(AbstractIntegrator integrator)

Get the differential equations to integrate (for main state only).

Specified by:

getMainStateEquations in class AbstractIntegratedPropagator

Parameters:

integrator - numerical integrator to use for propagation.

Returns:

differential equations for main state

tolerances

public static double[][] tolerances(double dP,
                    Orbit orbit)
                             throws PropagationException

Estimate tolerance vectors for an AdaptativeStepsizeIntegrator.

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.

Parameters:

dP - user specified position error (m)

orbit - reference orbit

Returns:

a two rows array, row 0 being the absolute tolerance error and row 1 being the relative tolerance error

Throws:

PropagationException - if Jacobian is singular