Package org.orekit.propagation.covariance

Class StateCovarianceKeplerianHermiteInterpolator

java.lang.Object
org.orekit.time.AbstractTimeInterpolator<TimeStampedPair<Orbit,StateCovariance>>
org.orekit.propagation.covariance.AbstractStateCovarianceInterpolator
org.orekit.propagation.covariance.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:

  • Constructor Details

    • 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
      filter - filter for derivatives from the sample to use in position-velocity-acceleration interpolation
      outLOF - output local orbital frame

    • 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
      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.
      outLOF - output local orbital frame

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

    • 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