org.orekit.propagation

Class StateCovarianceKeplerianHermiteInterpolator

java.lang.Object

org.orekit.time.AbstractTimeInterpolator<TimeStampedPair<Orbit,StateCovariance>>

org.orekit.propagation.AbstractStateCovarianceInterpolator

org.orekit.propagation.StateCovarianceKeplerianHermiteInterpolator

All Implemented Interfaces:

TimeInterpolator<TimeStampedPair<Orbit,StateCovariance>>

public class StateCovarianceKeplerianHermiteInterpolator
extends AbstractStateCovarianceInterpolator

State covariance Keplerian quintic interpolator.

Its purpose is to interpolate state covariance between tabulated state covariances using polynomial interpolation. To do so, it uses a HermiteInterpolator and compute the first and second order derivatives at tabulated states assuming a standard Keplerian motion depending on given derivatives filter.

It gives very accurate results as explained here. In the very poorly tracked test case evolving in a highly dynamical environment mentioned in the linked thread, the user can expect at worst errors of less than 0.2% in position sigmas and less than 0.35% in velocity sigmas with steps of 40mn between tabulated values.

However, note that this method does not guarantee the positive definiteness of the computed state covariance as opposed to StateCovarianceBlender.

Author:

Vincent Cucchietti

See Also:

HermiteInterpolator, StateCovarianceBlender

Nested Class Summary

Nested classes/interfaces inherited from class org.orekit.time.AbstractTimeInterpolator

AbstractTimeInterpolator.InterpolationData

Field Summary

Fields inherited from class org.orekit.propagation.AbstractStateCovarianceInterpolator

COLUMN_DIM, DEFAULT_POSITION_ANGLE, ROW_DIM

Fields inherited from class org.orekit.time.AbstractTimeInterpolator

DEFAULT_EXTRAPOLATION_THRESHOLD_SEC, DEFAULT_INTERPOLATION_POINTS

Constructor Summary

Constructors

Constructor and Description
StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints, double extrapolationThreshold, TimeInterpolator<Orbit> orbitInterpolator, CartesianDerivativesFilter filter, Frame outFrame, OrbitType outOrbitType, PositionAngleType outPositionAngleType) Constructor using an output frame.
StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints, double extrapolationThreshold, TimeInterpolator<Orbit> orbitInterpolator, CartesianDerivativesFilter filter, LOFType outLOF) Constructor using an output local orbital frame.
StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints, TimeInterpolator<Orbit> orbitInterpolator, CartesianDerivativesFilter filter, Frame outFrame, OrbitType outOrbitType, PositionAngleType outPositionAngleType) Constructor using an output frame and : Default extrapolation threshold value (DEFAULT_EXTRAPOLATION_THRESHOLD_SEC s) As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).
StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints, TimeInterpolator<Orbit> orbitInterpolator, CartesianDerivativesFilter filter, LOFType outLOF) Constructor using an output local orbital frame and : Use of position and two time derivatives during interpolation As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).
StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints, TimeInterpolator<Orbit> orbitInterpolator, Frame outFrame, OrbitType outOrbitType, PositionAngleType outPositionAngleType) Constructor using an output frame and : Default number of interpolation points of DEFAULT_INTERPOLATION_POINTS Use of position and two time derivatives during interpolation As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).
StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints, TimeInterpolator<Orbit> orbitInterpolator, LOFType outLOF) Constructor using an output local orbital frame and : Default extrapolation threshold value (DEFAULT_EXTRAPOLATION_THRESHOLD_SEC s) Use of position and two time derivatives during interpolation As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).
StateCovarianceKeplerianHermiteInterpolator(TimeInterpolator<Orbit> orbitInterpolator, Frame outFrame, OrbitType outOrbitType, PositionAngleType outPositionAngleType) Constructor using an output frame and : Default number of interpolation points of DEFAULT_INTERPOLATION_POINTS Default extrapolation threshold value (DEFAULT_EXTRAPOLATION_THRESHOLD_SEC s) Use of position and two time derivatives during interpolation As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).
StateCovarianceKeplerianHermiteInterpolator(TimeInterpolator<Orbit> orbitInterpolator, LOFType outLOF) Constructor using an output local orbital frame and : Default number of interpolation points of DEFAULT_INTERPOLATION_POINTS Default extrapolation threshold value (DEFAULT_EXTRAPOLATION_THRESHOLD_SEC s) Use of position and two time derivatives during interpolation As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).

Method Summary

Modifier and Type	Method and Description
protected StateCovariance	computeInterpolatedCovarianceInOrbitFrame(List<TimeStampedPair<Orbit,StateCovariance>> uncertainStates, Orbit interpolatedOrbit) Compute the interpolated covariance expressed in the interpolated orbit frame.
CartesianDerivativesFilter	getFilter() Get Filter defining if only the state covariance value are used or if first or/and second Keplerian derivatives should be used.

Methods inherited from class org.orekit.propagation.AbstractStateCovarianceInterpolator

expressCovarianceInDesiredOutput, getOrbitInterpolator, getOutFrame, getOutLOF, getOutOrbitType, getOutPositionAngleType, interpolate, interpolateOrbit

Methods inherited from class org.orekit.time.AbstractTimeInterpolator

addOptionalSubInterpolatorIfDefined, checkInterpolatorCompatibilityWithSampleSize, getCentralDate, getExtrapolationThreshold, getNbInterpolationPoints, getSubInterpolators, getTimeParameter, interpolate, interpolate

Methods inherited from class java.lang.Object

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

Constructor Detail

StateCovarianceKeplerianHermiteInterpolator

public StateCovarianceKeplerianHermiteInterpolator(TimeInterpolator<Orbit> orbitInterpolator,
                                                   LOFType outLOF)

Constructor using an output local orbital frame and :

• Default number of interpolation points of DEFAULT_INTERPOLATION_POINTS
• Default extrapolation threshold value (DEFAULT_EXTRAPOLATION_THRESHOLD_SEC s)
• Use of position and two time derivatives during interpolation

As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).

BEWARE: If the output local orbital frame is not considered pseudo-inertial, all the covariance components related to the velocity will be poorly interpolated. Only the position covariance should be considered in this case.

Parameters:

orbitInterpolator - orbit interpolator

outLOF - output local orbital frame

StateCovarianceKeplerianHermiteInterpolator

public StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints,
                                                   TimeInterpolator<Orbit> orbitInterpolator,
                                                   LOFType outLOF)

Constructor using an output local orbital frame and :

• Default extrapolation threshold value (DEFAULT_EXTRAPOLATION_THRESHOLD_SEC s)
• Use of position and two time derivatives during interpolation

As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).

BEWARE: If the output local orbital frame is not considered pseudo-inertial, all the covariance components related to the velocity will be poorly interpolated. Only the position covariance should be considered in this case.

Parameters:

interpolationPoints - number of interpolation points

orbitInterpolator - orbit interpolator

outLOF - output local orbital frame

StateCovarianceKeplerianHermiteInterpolator

public StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints,
                                                   TimeInterpolator<Orbit> orbitInterpolator,
                                                   CartesianDerivativesFilter filter,
                                                   LOFType outLOF)

Constructor using an output local orbital frame and :

• Use of position and two time derivatives during interpolation

As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).

BEWARE: If the output local orbital frame is not considered pseudo-inertial, all the covariance components related to the velocity will be poorly interpolated. Only the position covariance should be considered in this case.

Parameters:

interpolationPoints - number of interpolation points

orbitInterpolator - orbit interpolator

outLOF - output local orbital frame

filter - filter for derivatives from the sample to use in position-velocity-acceleration interpolation

StateCovarianceKeplerianHermiteInterpolator

public StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints,
                                                   double extrapolationThreshold,
                                                   TimeInterpolator<Orbit> orbitInterpolator,
                                                   CartesianDerivativesFilter filter,
                                                   LOFType outLOF)

Constructor using an output local orbital frame.

As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).

BEWARE: If the output local orbital frame is not considered pseudo-inertial, all the covariance components related to the velocity will be poorly interpolated. Only the position covariance should be considered in this case.

Parameters:

interpolationPoints - number of interpolation points

extrapolationThreshold - extrapolation threshold beyond which the propagation will fail

orbitInterpolator - orbit interpolator

outLOF - output local orbital frame

filter - filter defining if only the state covariance value are used or if first or/and second Keplerian derivatives should be used during the interpolation.

StateCovarianceKeplerianHermiteInterpolator

public StateCovarianceKeplerianHermiteInterpolator(TimeInterpolator<Orbit> orbitInterpolator,
                                                   Frame outFrame,
                                                   OrbitType outOrbitType,
                                                   PositionAngleType outPositionAngleType)

Constructor using an output frame and :

• Default number of interpolation points of DEFAULT_INTERPOLATION_POINTS
• Default extrapolation threshold value (DEFAULT_EXTRAPOLATION_THRESHOLD_SEC s)
• Use of position and two time derivatives during interpolation

As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).

Parameters:

orbitInterpolator - orbit interpolator

outFrame - output frame

outOrbitType - output orbit type

outPositionAngleType - output position angle

StateCovarianceKeplerianHermiteInterpolator

public StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints,
                                                   TimeInterpolator<Orbit> orbitInterpolator,
                                                   Frame outFrame,
                                                   OrbitType outOrbitType,
                                                   PositionAngleType outPositionAngleType)

Constructor using an output frame and :

• Default number of interpolation points of DEFAULT_INTERPOLATION_POINTS
• Use of position and two time derivatives during interpolation

As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).

Parameters:

interpolationPoints - number of interpolation points

orbitInterpolator - orbit interpolator

outFrame - output frame

outOrbitType - output orbit type

outPositionAngleType - output position angle

StateCovarianceKeplerianHermiteInterpolator

public StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints,
                                                   TimeInterpolator<Orbit> orbitInterpolator,
                                                   CartesianDerivativesFilter filter,
                                                   Frame outFrame,
                                                   OrbitType outOrbitType,
                                                   PositionAngleType outPositionAngleType)

Constructor using an output frame and :

• Default extrapolation threshold value (DEFAULT_EXTRAPOLATION_THRESHOLD_SEC s)

As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).

Parameters:

interpolationPoints - number of interpolation points

orbitInterpolator - orbit interpolator

filter - filter defining if only the state covariance value are used or if first or/and second Keplerian derivatives should be used during the interpolation.

outFrame - output frame

outOrbitType - output orbit type

outPositionAngleType - output position angle

StateCovarianceKeplerianHermiteInterpolator

public StateCovarianceKeplerianHermiteInterpolator(int interpolationPoints,
                                                   double extrapolationThreshold,
                                                   TimeInterpolator<Orbit> orbitInterpolator,
                                                   CartesianDerivativesFilter filter,
                                                   Frame outFrame,
                                                   OrbitType outOrbitType,
                                                   PositionAngleType outPositionAngleType)

Constructor using an output frame.

As this implementation of interpolation is polynomial, it should be used only with small number of interpolation points (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).

Parameters:

interpolationPoints - number of interpolation points

extrapolationThreshold - extrapolation threshold beyond which the propagation will fail

orbitInterpolator - orbit interpolator

filter - filter defining if only the state covariance value are used or if first or/and second Keplerian derivatives should be used during the interpolation.

outFrame - output frame

outOrbitType - output orbit type

outPositionAngleType - output position angle

Method Detail

getFilter

public CartesianDerivativesFilter getFilter()

Get Filter defining if only the state covariance value are used or if first or/and second Keplerian derivatives should be used.

Returns:

Filter defining if only the state covariance value are used or if first or/and second Keplerian derivatives should be used.

computeInterpolatedCovarianceInOrbitFrame

protected StateCovariance computeInterpolatedCovarianceInOrbitFrame(List<TimeStampedPair<Orbit,StateCovariance>> uncertainStates,
                                                                    Orbit interpolatedOrbit)

Compute the interpolated covariance expressed in the interpolated orbit frame.

Specified by:

computeInterpolatedCovarianceInOrbitFrame in class AbstractStateCovarianceInterpolator

Parameters:

uncertainStates - list of orbits and associated covariances

interpolatedOrbit - interpolated orbit

Returns:

interpolated covariance expressed in the interpolated orbit frame