Package org.orekit.propagation

Class 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

    • 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.