SpacecraftStateInterpolator.java

  1. /* Copyright 2002-2023 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.propagation;

  19. import org.hipparchus.util.Pair;
  20. import org.orekit.attitudes.Attitude;
  21. import org.orekit.attitudes.AttitudeInterpolator;
  22. import org.orekit.attitudes.AttitudeProvider;
  23. import org.orekit.attitudes.FrameAlignedProvider;
  24. import org.orekit.errors.OrekitIllegalArgumentException;
  25. import org.orekit.errors.OrekitInternalError;
  26. import org.orekit.errors.OrekitMessages;
  27. import org.orekit.frames.Frame;
  28. import org.orekit.orbits.Orbit;
  29. import org.orekit.orbits.OrbitHermiteInterpolator;
  30. import org.orekit.time.AbsoluteDate;
  31. import org.orekit.time.AbstractTimeInterpolator;
  32. import org.orekit.time.TimeInterpolator;
  33. import org.orekit.time.TimeStamped;
  34. import org.orekit.time.TimeStampedDouble;
  35. import org.orekit.time.TimeStampedDoubleHermiteInterpolator;
  36. import org.orekit.utils.AbsolutePVCoordinates;
  37. import org.orekit.utils.AbsolutePVCoordinatesHermiteInterpolator;
  38. import org.orekit.utils.AngularDerivativesFilter;
  39. import org.orekit.utils.CartesianDerivativesFilter;
  40. import org.orekit.utils.DoubleArrayDictionary;
  41. import org.orekit.utils.PVCoordinatesProvider;
  42. import org.orekit.utils.TimeStampedAngularCoordinatesHermiteInterpolator;

  44. import java.util.ArrayList;
  45. import java.util.Collection;
  46. import java.util.HashMap;
  47. import java.util.List;
  48. import java.util.Map;
  49. import java.util.Optional;

  51. /**
  52.  * Generic class for spacecraft state interpolator.
  53.  * <p>
  54.  * The user can specify what interpolator to use for each attribute of the spacecraft state. However, at least one
  55.  * interpolator for either orbit or absolute position-velocity-acceleration is needed. All the other interpolators can be
  56.  * left to null if the user do not want to interpolate these values.
  57.  *
  58.  * @author Luc Maisonobe
  59.  * @author Vincent Cucchietti
  60.  * @see SpacecraftState
  61.  */
  62. public class SpacecraftStateInterpolator extends AbstractTimeInterpolator<SpacecraftState> {

  64.     /**
  65.      * Output frame.
  66.      * <p><b>Must be inertial</b> if interpolating spacecraft states defined by orbit</p>
  67.      */
  68.     private final Frame outputFrame;

  70.     /** Orbit interpolator. */
  71.     private final TimeInterpolator<Orbit> orbitInterpolator;

  73.     /** Absolute position-velocity-acceleration interpolator. */
  74.     private final TimeInterpolator<AbsolutePVCoordinates> absPVAInterpolator;

  76.     /** Mass interpolator. */
  77.     private final TimeInterpolator<TimeStampedDouble> massInterpolator;

  79.     /** Attitude interpolator. */
  80.     private final TimeInterpolator<Attitude> attitudeInterpolator;

  82.     /** Additional state interpolator. */
  83.     private final TimeInterpolator<TimeStampedDouble> additionalStateInterpolator;

  85.     /**
  86.      * Simplest constructor to create a default Hermite interpolator for every spacecraft state field.
  87.      * <p>
  88.      * The interpolators will have the following configuration :
  89.      * <ul>
  90.      *     <li>Same frame for coordinates and attitude </li>
  91.      *     <li>Default number of interpolation points of {@code DEFAULT_INTERPOLATION_POINTS}</li>
  92.      *     <li>Default extrapolation threshold of {@code DEFAULT_EXTRAPOLATION_THRESHOLD_SEC} s</li>
  93.      *     <li>Use of position and two time derivatives for absolute position-velocity-acceleration coordinates interpolation</li>
  94.      *     <li>Use of angular and first time derivative for attitude interpolation</li>
  95.      * </ul>
  96.      * <p>
  97.      * As this implementation of interpolation is polynomial, it should be used only with small number of interpolation
  98.      * points (about 10-20 points) in order to avoid <a href="http://en.wikipedia.org/wiki/Runge%27s_phenomenon">Runge's
  99.      * phenomenon</a> and numerical problems (including NaN appearing).
  100.      * <p>
  101.      * <b>BEWARE:</b> output frame <b>must be inertial</b> if this instance is going to interpolate between
  102.      * tabulated spacecraft states defined by orbit, will throw an error otherwise.
  103.      *
  104.      * @param outputFrame output frame
  105.      *
  106.      * @see AbstractTimeInterpolator
  107.      */
  108.     public SpacecraftStateInterpolator(final Frame outputFrame) {
  109.         this(DEFAULT_INTERPOLATION_POINTS, outputFrame);
  110.     }

  112.     /**
  113.      * Constructor to create a customizable Hermite interpolator for every spacecraft state field.
  114.      * <p>
  115.      * The interpolators will have the following configuration :
  116.      * <ul>
  117.      *     <li>Same frame for coordinates and attitude </li>
  118.      *     <li>Default extrapolation threshold of {@code DEFAULT_EXTRAPOLATION_THRESHOLD_SEC} s</li>
  119.      *     <li>Use of position and two time derivatives for absolute position-velocity-acceleration coordinates interpolation</li>
  120.      *     <li>Use of angular and first time derivative for attitude interpolation</li>
  121.      * </ul>
  122.      * <p>
  123.      * As this implementation of interpolation is polynomial, it should be used only with small number of interpolation
  124.      * points (about 10-20 points) in order to avoid <a href="http://en.wikipedia.org/wiki/Runge%27s_phenomenon">Runge's
  125.      * phenomenon</a> and numerical problems (including NaN appearing).
  126.      * <p>
  127.      * <b>BEWARE:</b> output frame <b>must be inertial</b> if this instance is going to interpolate between
  128.      * tabulated spacecraft states defined by orbit, will throw an error otherwise.
  129.      *
  130.      * @param interpolationPoints number of interpolation points
  131.      * @param outputFrame output frame
  132.      *
  133.      * @see AbstractTimeInterpolator
  134.      */
  135.     public SpacecraftStateInterpolator(final int interpolationPoints, final Frame outputFrame) {
  136.         this(interpolationPoints, DEFAULT_EXTRAPOLATION_THRESHOLD_SEC, outputFrame, outputFrame);
  137.     }

  139.     /**
  140.      * Constructor to create a customizable Hermite interpolator for every spacecraft state field.
  141.      * <p>
  142.      * The interpolators will have the following configuration :
  143.      * <ul>
  144.      *     <li>Default extrapolation threshold of {@code DEFAULT_EXTRAPOLATION_THRESHOLD_SEC} s</li>
  145.      *     <li>Use of position and two time derivatives for absolute position-velocity-acceleration coordinates interpolation</li>
  146.      *     <li>Use of angular and first time derivative for attitude interpolation</li>
  147.      * </ul>
  148.      * <p>
  149.      * As this implementation of interpolation is polynomial, it should be used only with small number of interpolation
  150.      * points (about 10-20 points) in order to avoid <a href="http://en.wikipedia.org/wiki/Runge%27s_phenomenon">Runge's
  151.      * phenomenon</a> and numerical problems (including NaN appearing).
  152.      * <p>
  153.      * <b>BEWARE:</b> output frame <b>must be inertial</b> if this instance is going to interpolate between
  154.      * tabulated spacecraft states defined by orbit, will throw an error otherwise.
  155.      *
  156.      * @param interpolationPoints number of interpolation points
  157.      * @param outputFrame output frame
  158.      * @param attitudeReferenceFrame reference frame from which attitude is defined
  159.      *
  160.      * @see AbstractTimeInterpolator
  161.      */
  162.     public SpacecraftStateInterpolator(final int interpolationPoints, final Frame outputFrame,
  163.                                        final Frame attitudeReferenceFrame) {
  164.         this(interpolationPoints, DEFAULT_EXTRAPOLATION_THRESHOLD_SEC, outputFrame, attitudeReferenceFrame,
  165.              CartesianDerivativesFilter.USE_PVA, AngularDerivativesFilter.USE_RR);
  166.     }

  168.     /**
  169.      * Constructor to create a customizable Hermite interpolator for every spacecraft state field.
  170.      * <p>
  171.      * The interpolators will have the following configuration :
  172.      * <ul>
  173.      *     <li>Use of position and two time derivatives for absolute position-velocity-acceleration coordinates interpolation</li>
  174.      *     <li>Use of angular and first time derivative for attitude interpolation</li>
  175.      * </ul>
  176.      * <p>
  177.      * As this implementation of interpolation is polynomial, it should be used only with small number of interpolation
  178.      * points (about 10-20 points) in order to avoid <a href="http://en.wikipedia.org/wiki/Runge%27s_phenomenon">Runge's
  179.      * phenomenon</a> and numerical problems (including NaN appearing).
  180.      * <p>
  181.      * <b>BEWARE:</b> output frame <b>must be inertial</b> if this instance is going to interpolate between
  182.      * tabulated spacecraft states defined by orbit, will throw an error otherwise.
  183.      *
  184.      * @param interpolationPoints number of interpolation points
  185.      * @param extrapolationThreshold extrapolation threshold beyond which the propagation will fail
  186.      * @param outputFrame output frame
  187.      * @param attitudeReferenceFrame reference frame from which attitude is defined
  188.      */
  189.     public SpacecraftStateInterpolator(final int interpolationPoints, final double extrapolationThreshold,
  190.                                        final Frame outputFrame, final Frame attitudeReferenceFrame) {
  191.         this(interpolationPoints, extrapolationThreshold, outputFrame, attitudeReferenceFrame,
  192.              CartesianDerivativesFilter.USE_PVA, AngularDerivativesFilter.USE_RR);
  193.     }

  195.     /**
  196.      * Constructor to create a customizable Hermite interpolator for every spacecraft state field.
  197.      * <p>
  198.      * As this implementation of interpolation is polynomial, it should be used only with small number of interpolation
  199.      * points (about 10-20 points) in order to avoid <a href="http://en.wikipedia.org/wiki/Runge%27s_phenomenon">Runge's
  200.      * phenomenon</a> and numerical problems (including NaN appearing).
  201.      * <p>
  202.      * <b>BEWARE:</b> output frame <b>must be inertial</b> if this instance is going to interpolate between
  203.      * tabulated spacecraft states defined by orbit, will throw an error otherwise.
  204.      *
  205.      * @param interpolationPoints number of interpolation points
  206.      * @param extrapolationThreshold extrapolation threshold beyond which the propagation will fail
  207.      * @param outputFrame output frame
  208.      * @param attitudeReferenceFrame reference frame from which attitude is defined
  209.      * @param pvaFilter filter for derivatives from the sample to use in position-velocity-acceleration interpolation
  210.      * @param angularFilter filter for derivatives from the sample to use in attitude interpolation
  211.      */
  212.     public SpacecraftStateInterpolator(final int interpolationPoints, final double extrapolationThreshold,
  213.                                        final Frame outputFrame, final Frame attitudeReferenceFrame,
  214.                                        final CartesianDerivativesFilter pvaFilter,
  215.                                        final AngularDerivativesFilter angularFilter) {
  216.         this(interpolationPoints, extrapolationThreshold, outputFrame,
  217.              new OrbitHermiteInterpolator(interpolationPoints, extrapolationThreshold, outputFrame, pvaFilter),
  218.              new AbsolutePVCoordinatesHermiteInterpolator(interpolationPoints, extrapolationThreshold, outputFrame,
  219.                                                           pvaFilter),
  220.              new TimeStampedDoubleHermiteInterpolator(interpolationPoints, extrapolationThreshold),
  221.              new AttitudeInterpolator(attitudeReferenceFrame,
  222.                                       new TimeStampedAngularCoordinatesHermiteInterpolator(interpolationPoints,
  223.                                                                                            extrapolationThreshold,
  224.                                                                                            angularFilter)),
  225.              new TimeStampedDoubleHermiteInterpolator(interpolationPoints, extrapolationThreshold));
  226.     }

  228.     /**
  229.      * Constructor with:
  230.      * <ul>
  231.      *     <li>Default number of interpolation points of {@code DEFAULT_INTERPOLATION_POINTS}</li>
  232.      *     <li>Default extrapolation threshold of {@code DEFAULT_EXTRAPOLATION_THRESHOLD_SEC} s</li>
  233.      * </ul>
  234.      * <p>
  235.      * At least one interpolator for either orbit or absolute position-velocity-acceleration is needed. All the other
  236.      * interpolators can be left to null if the user do not want to interpolate these values.
  237.      * <p>
  238.      * <b>BEWARE:</b> output frame <b>must be inertial</b> if interpolated spacecraft states are defined by orbit. Throws an
  239.      * error otherwise.
  240.      * <p>
  241.      * <b>BEWARE:</b> it is up to the user to check the consistency of input interpolators.
  242.      *
  243.      * @param outputFrame output frame (inertial if the user is planning to use the orbit interpolator)
  244.      * @param orbitInterpolator orbit interpolator (can be null if absPVAInterpolator is defined)
  245.      * @param absPVAInterpolator absolute position-velocity-acceleration (can be null if orbitInterpolator is defined)
  246.      * @param massInterpolator mass interpolator (can be null)
  247.      * @param attitudeInterpolator attitude interpolator (can be null)
  248.      * @param additionalStateInterpolator additional state interpolator (can be null)
  249.      *
  250.      * @see AbstractTimeInterpolator
  251.      */
  252.     public SpacecraftStateInterpolator(final Frame outputFrame, final TimeInterpolator<Orbit> orbitInterpolator,
  253.                                        final TimeInterpolator<AbsolutePVCoordinates> absPVAInterpolator,
  254.                                        final TimeInterpolator<TimeStampedDouble> massInterpolator,
  255.                                        final TimeInterpolator<Attitude> attitudeInterpolator,
  256.                                        final TimeInterpolator<TimeStampedDouble> additionalStateInterpolator) {
  257.         super(DEFAULT_INTERPOLATION_POINTS, DEFAULT_EXTRAPOLATION_THRESHOLD_SEC);
  258.         checkAtLeastOneInterpolator(orbitInterpolator, absPVAInterpolator);
  259.         this.outputFrame                 = outputFrame;
  260.         this.orbitInterpolator           = orbitInterpolator;
  261.         this.absPVAInterpolator          = absPVAInterpolator;
  262.         this.massInterpolator            = massInterpolator;
  263.         this.attitudeInterpolator        = attitudeInterpolator;
  264.         this.additionalStateInterpolator = additionalStateInterpolator;
  265.     }

  267.     /**
  268.      * Constructor.
  269.      * <p>
  270.      * At least one interpolator for either orbit or absolute position-velocity-acceleration is needed. All the other
  271.      * interpolators can be left to null if the user do not want to interpolate these values.
  272.      * <p>
  273.      * <b>BEWARE:</b> output frame <b>must be inertial</b> if interpolated spacecraft states are defined by orbit. Throws an
  274.      * error otherwise.
  275.      * <p>
  276.      * <b>BEWARE:</b> it is up to the user to check the consistency of input interpolators.
  277.      *
  278.      * @param interpolationPoints number of interpolation points
  279.      * @param extrapolationThreshold extrapolation threshold beyond which the propagation will fail
  280.      * @param outputFrame output frame (inertial if the user is planning to use the orbit interpolator)
  281.      * @param orbitInterpolator orbit interpolator (can be null if absPVAInterpolator is defined)
  282.      * @param absPVAInterpolator absolute position-velocity-acceleration (can be null if orbitInterpolator is defined)
  283.      * @param massInterpolator mass interpolator (can be null)
  284.      * @param attitudeInterpolator attitude interpolator (can be null)
  285.      * @param additionalStateInterpolator additional state interpolator (can be null)
  286.      *
  287.      * @since 12.0.1
  288.      */
  289.     public SpacecraftStateInterpolator(final int interpolationPoints, final double extrapolationThreshold,
  290.                                        final Frame outputFrame, final TimeInterpolator<Orbit> orbitInterpolator,
  291.                                        final TimeInterpolator<AbsolutePVCoordinates> absPVAInterpolator,
  292.                                        final TimeInterpolator<TimeStampedDouble> massInterpolator,
  293.                                        final TimeInterpolator<Attitude> attitudeInterpolator,
  294.                                        final TimeInterpolator<TimeStampedDouble> additionalStateInterpolator) {
  295.         super(interpolationPoints, extrapolationThreshold);
  296.         checkAtLeastOneInterpolator(orbitInterpolator, absPVAInterpolator);
  297.         this.outputFrame                 = outputFrame;
  298.         this.orbitInterpolator           = orbitInterpolator;
  299.         this.absPVAInterpolator          = absPVAInterpolator;
  300.         this.massInterpolator            = massInterpolator;
  301.         this.attitudeInterpolator        = attitudeInterpolator;
  302.         this.additionalStateInterpolator = additionalStateInterpolator;
  303.     }

  305.     /**
  306.      * Check that an interpolator exist for given sample state definition.
  307.      *
  308.      * @param sample sample (non empty)
  309.      * @param orbitInterpolatorIsPresent flag defining if an orbit interpolator has been defined for this instance
  310.      * @param absPVInterpolatorIsPresent flag defining if an absolute position-velocity-acceleration interpolator has been
  311.      * defined for this instance
  312.      *
  313.      * @throws OrekitIllegalArgumentException if there is no defined interpolator for given sample spacecraft state
  314.      * definition type
  315.      */
  316.     public static void checkSampleAndInterpolatorConsistency(final List<SpacecraftState> sample,
  317.                                                              final boolean orbitInterpolatorIsPresent,
  318.                                                              final boolean absPVInterpolatorIsPresent) {
  319.         // Get first state definition
  320.         final SpacecraftState earliestState = sample.get(0);

  322.         if (earliestState.isOrbitDefined() && !orbitInterpolatorIsPresent ||
  323.                 !earliestState.isOrbitDefined() && !absPVInterpolatorIsPresent) {
  324.             throw new OrekitIllegalArgumentException(OrekitMessages.WRONG_INTERPOLATOR_DEFINED_FOR_STATE_INTERPOLATION);
  325.         }
  326.     }

  328.     /**
  329.      * Check that all state are either orbit defined or based on absolute position-velocity-acceleration.
  330.      *
  331.      * @param states spacecraft state sample
  332.      */
  333.     public static void checkStatesDefinitionsConsistency(final List<SpacecraftState> states) {
  334.         // Check all states handle the same additional states and are defined the same way (orbit or absolute PVA)
  335.         final SpacecraftState s0               = states.get(0);
  336.         final boolean         s0IsOrbitDefined = s0.isOrbitDefined();
  337.         for (final SpacecraftState state : states) {
  338.             s0.ensureCompatibleAdditionalStates(state);
  339.             if (s0IsOrbitDefined != state.isOrbitDefined()) {
  340.                 throw new OrekitIllegalArgumentException(OrekitMessages.DIFFERENT_STATE_DEFINITION);
  341.             }
  342.         }
  343.     }

  345.     /**
  346.      * {@inheritDoc}
  347.      * <p>
  348.      * The additional states that are interpolated are the ones already present in the first neighbor instance. The sample
  349.      * instances must therefore have at least the same additional states as this neighbor instance. They may have more
  350.      * additional states, but the extra ones will be ignored.
  351.      * <p>
  352.      * All the sample instances <em>must</em> be based on similar trajectory data, i.e. they must either all be based on
  353.      * orbits or all be based on absolute position-velocity-acceleration. Any inconsistency will trigger an
  354.      * {@link OrekitIllegalArgumentException}.
  355.      *
  356.      * @throws OrekitIllegalArgumentException if there are states defined by orbits and absolute
  357.      * position-velocity-acceleration coordinates
  358.      * @throws OrekitIllegalArgumentException if there is no defined interpolator for given sample spacecraft state
  359.      * definition type
  360.      */
  361.     @Override
  362.     public SpacecraftState interpolate(final AbsoluteDate interpolationDate, final Collection<SpacecraftState> sample) {

  364.         final List<SpacecraftState> sampleList = new ArrayList<>(sample);

  366.         // If sample is empty, an error will be thrown in super method
  367.         if (!sample.isEmpty()) {

  369.             // Check given that given states definition are consistent
  370.             // (all defined by either orbits or absolute position-velocity-acceleration coordinates)
  371.             checkStatesDefinitionsConsistency(sampleList);

  373.             // Check interpolator and sample consistency
  374.             checkSampleAndInterpolatorConsistency(sampleList, orbitInterpolator != null, absPVAInterpolator != null);
  375.         }

  377.         return super.interpolate(interpolationDate, sample);
  378.     }

  380.     /** {@inheritDoc} */
  381.     @Override
  382.     public List<TimeInterpolator<? extends TimeStamped>> getSubInterpolators() {

  384.         // Add all sub interpolators that are defined
  385.         final List<TimeInterpolator<? extends TimeStamped>> subInterpolators = new ArrayList<>();

  387.         addOptionalSubInterpolatorIfDefined(orbitInterpolator, subInterpolators);
  388.         addOptionalSubInterpolatorIfDefined(absPVAInterpolator, subInterpolators);
  389.         addOptionalSubInterpolatorIfDefined(massInterpolator, subInterpolators);
  390.         addOptionalSubInterpolatorIfDefined(attitudeInterpolator, subInterpolators);
  391.         addOptionalSubInterpolatorIfDefined(additionalStateInterpolator, subInterpolators);

  393.         return subInterpolators;

  395.     }

  397.     /**
  398.      * {@inheritDoc}
  399.      */
  400.     @Override
  401.     protected SpacecraftState interpolate(final InterpolationData interpolationData) {

  403.         // Get first state definition
  404.         final SpacecraftState earliestState   = interpolationData.getNeighborList().get(0);
  405.         final boolean         areOrbitDefined = earliestState.isOrbitDefined();

  407.         // Prepare samples
  408.         final List<Attitude> attitudes = new ArrayList<>();

  410.         final List<TimeStampedDouble> masses = new ArrayList<>();

  412.         final List<DoubleArrayDictionary.Entry> additionalEntries = earliestState.getAdditionalStatesValues().getData();
  413.         final Map<String, List<Pair<AbsoluteDate, double[]>>> additionalSample =
  414.                 createAdditionalStateSample(additionalEntries);

  416.         final List<DoubleArrayDictionary.Entry> additionalDotEntries =
  417.                 earliestState.getAdditionalStatesDerivatives().getData();
  418.         final Map<String, List<Pair<AbsoluteDate, double[]>>> additionalDotSample =
  419.                 createAdditionalStateSample(additionalDotEntries);

  421.         // Fill interpolators with samples
  422.         final List<SpacecraftState>       samples      = interpolationData.getCachedSamples().getAll();
  423.         final List<Orbit>                 orbitSample  = new ArrayList<>();
  424.         final List<AbsolutePVCoordinates> absPVASample = new ArrayList<>();
  425.         for (SpacecraftState state : samples) {
  426.             final AbsoluteDate currentDate = state.getDate();

  428.             // Add orbit sample if state is defined with an orbit
  429.             if (state.isOrbitDefined()) {
  430.                 orbitSample.add(state.getOrbit());
  431.             }
  432.             // Add absolute position-velocity-acceleration sample if state is defined with an absolute position-velocity-acceleration
  433.             else {
  434.                 absPVASample.add(state.getAbsPVA());
  435.             }

  437.             // Add mass sample
  438.             if (massInterpolator != null) {
  439.                 masses.add(new TimeStampedDouble(state.getMass(), state.getDate()));
  440.             }

  442.             // Add attitude sample if it is interpolated
  443.             if (attitudeInterpolator != null) {
  444.                 attitudes.add(state.getAttitude());
  445.             }

  447.             if (additionalStateInterpolator != null) {

  449.                 // Add all additional state values if they are interpolated
  450.                 for (final Map.Entry<String, List<Pair<AbsoluteDate, double[]>>> entry : additionalSample.entrySet()) {
  451.                     entry.getValue().add(new Pair<>(currentDate, state.getAdditionalState(entry.getKey())));
  452.                 }

  454.                 // Add all additional state derivative values if they are interpolated
  455.                 for (final Map.Entry<String, List<Pair<AbsoluteDate, double[]>>> entry : additionalDotSample.entrySet()) {
  456.                     entry.getValue().add(new Pair<>(currentDate, state.getAdditionalStateDerivative(entry.getKey())));
  457.                 }
  458.             }
  459.         }

  461.         // Interpolate mass
  462.         final AbsoluteDate interpolationDate = interpolationData.getInterpolationDate();
  463.         final double       interpolatedMass;
  464.         if (massInterpolator != null) {
  465.             interpolatedMass = massInterpolator.interpolate(interpolationDate, masses).getValue();
  466.         } else {
  467.             interpolatedMass = SpacecraftState.DEFAULT_MASS;
  468.         }

  470.         // Interpolate additional states and derivatives
  471.         final DoubleArrayDictionary interpolatedAdditional;
  472.         final DoubleArrayDictionary interpolatedAdditionalDot;
  473.         if (additionalStateInterpolator != null) {
  474.             interpolatedAdditional    = interpolateAdditionalState(interpolationDate, additionalSample);
  475.             interpolatedAdditionalDot = interpolateAdditionalState(interpolationDate, additionalDotSample);
  476.         } else {
  477.             interpolatedAdditional    = null;
  478.             interpolatedAdditionalDot = null;
  479.         }

  481.         // Interpolate orbit
  482.         if (areOrbitDefined && orbitInterpolator != null) {
  483.             final Orbit interpolatedOrbit = orbitInterpolator.interpolate(interpolationDate, orbitSample);

  485.             final Attitude interpolatedAttitude = interpolateAttitude(interpolationDate, attitudes, interpolatedOrbit);

  487.             return new SpacecraftState(interpolatedOrbit, interpolatedAttitude, interpolatedMass, interpolatedAdditional,
  488.                                        interpolatedAdditionalDot);
  489.         }
  490.         // Interpolate absolute position-velocity-acceleration
  491.         else if (!areOrbitDefined && absPVAInterpolator != null) {

  493.             final AbsolutePVCoordinates interpolatedAbsPva = absPVAInterpolator.interpolate(interpolationDate, absPVASample);

  495.             final Attitude interpolatedAttitude = interpolateAttitude(interpolationDate, attitudes, interpolatedAbsPva);

  497.             return new SpacecraftState(interpolatedAbsPva, interpolatedAttitude, interpolatedMass, interpolatedAdditional,
  498.                                        interpolatedAdditionalDot);
  499.         }
  500.         // Should never happen
  501.         else {
  502.             throw new OrekitInternalError(null);
  503.         }

  505.     }

  507.     /**
  508.      * Get output frame.
  509.      *
  510.      * @return output frame
  511.      */
  512.     public Frame getOutputFrame() {
  513.         return outputFrame;
  514.     }

  516.     /**
  517.      * Get orbit interpolator.
  518.      *
  519.      * @return optional orbit interpolator
  520.      *
  521.      * @see Optional
  522.      */
  523.     public Optional<TimeInterpolator<Orbit>> getOrbitInterpolator() {
  524.         return Optional.ofNullable(orbitInterpolator);
  525.     }

  527.     /**
  528.      * Get absolute position-velocity-acceleration interpolator.
  529.      *
  530.      * @return optional absolute position-velocity-acceleration interpolator
  531.      *
  532.      * @see Optional
  533.      */
  534.     public Optional<TimeInterpolator<AbsolutePVCoordinates>> getAbsPVAInterpolator() {
  535.         return Optional.ofNullable(absPVAInterpolator);
  536.     }

  538.     /**
  539.      * Get mass interpolator.
  540.      *
  541.      * @return optional mass interpolator
  542.      *
  543.      * @see Optional
  544.      */
  545.     public Optional<TimeInterpolator<TimeStampedDouble>> getMassInterpolator() {
  546.         return Optional.ofNullable(massInterpolator);
  547.     }

  549.     /**
  550.      * Get attitude interpolator.
  551.      *
  552.      * @return optional attitude interpolator
  553.      *
  554.      * @see Optional
  555.      */
  556.     public Optional<TimeInterpolator<Attitude>> getAttitudeInterpolator() {
  557.         return Optional.ofNullable(attitudeInterpolator);
  558.     }

  560.     /**
  561.      * Get additional state interpolator.
  562.      *
  563.      * @return optional additional state interpolator
  564.      *
  565.      * @see Optional
  566.      */
  567.     public Optional<TimeInterpolator<TimeStampedDouble>> getAdditionalStateInterpolator() {
  568.         return Optional.ofNullable(additionalStateInterpolator);
  569.     }

  571.     /**
  572.      * Check that at least one interpolator is defined.
  573.      *
  574.      * @param orbitInterpolatorToCheck orbit interpolator
  575.      * @param absPVAInterpolatorToCheck absolute position-velocity-acceleration interpolator
  576.      */
  577.     private void checkAtLeastOneInterpolator(final TimeInterpolator<Orbit> orbitInterpolatorToCheck,
  578.                                              final TimeInterpolator<AbsolutePVCoordinates> absPVAInterpolatorToCheck) {
  579.         if (orbitInterpolatorToCheck == null && absPVAInterpolatorToCheck == null) {
  580.             throw new OrekitIllegalArgumentException(OrekitMessages.NO_INTERPOLATOR_FOR_STATE_DEFINITION);
  581.         }
  582.     }

  584.     /**
  585.      * Create empty samples for given additional entries.
  586.      *
  587.      * @param additionalEntries tabulated additional entries
  588.      *
  589.      * @return empty samples for given additional entries
  590.      */
  591.     private Map<String, List<Pair<AbsoluteDate, double[]>>> createAdditionalStateSample(
  592.             final List<DoubleArrayDictionary.Entry> additionalEntries) {
  593.         final Map<String, List<Pair<AbsoluteDate, double[]>>> additionalSamples = new HashMap<>(additionalEntries.size());

  595.         for (final DoubleArrayDictionary.Entry entry : additionalEntries) {
  596.             additionalSamples.put(entry.getKey(), new ArrayList<>());
  597.         }

  599.         return additionalSamples;
  600.     }

  602.     /**
  603.      * Interpolate additional state values.
  604.      *
  605.      * @param interpolationDate interpolation date
  606.      * @param additionalSamples additional state samples
  607.      *
  608.      * @return interpolated additional state values
  609.      */
  610.     private DoubleArrayDictionary interpolateAdditionalState(final AbsoluteDate interpolationDate,
  611.                                                              final Map<String, List<Pair<AbsoluteDate, double[]>>> additionalSamples) {
  612.         final DoubleArrayDictionary interpolatedAdditional;

  614.         if (additionalSamples.isEmpty()) {
  615.             interpolatedAdditional = null;
  616.         } else {
  617.             interpolatedAdditional = new DoubleArrayDictionary(additionalSamples.size());
  618.             for (final Map.Entry<String, List<Pair<AbsoluteDate, double[]>>> entry : additionalSamples.entrySet()) {

  620.                 // Get current entry
  621.                 final List<Pair<AbsoluteDate, double[]>> currentAdditionalSamples = entry.getValue();

  623.                 // Extract number of values for this specific entry
  624.                 final int nbOfValues = currentAdditionalSamples.get(0).getValue().length;

  626.                 // For each value of current additional state entry
  627.                 final double[] currentInterpolatedAdditional = new double[nbOfValues];
  628.                 for (int i = 0; i < nbOfValues; i++) {

  630.                     // Create final index for lambda expression use
  631.                     final int currentIndex = i;

  633.                     // Create sample for specific value of current additional state values
  634.                     final List<TimeStampedDouble> currentValueSample = new ArrayList<>();

  636.                     currentAdditionalSamples.forEach(currentSamples -> currentValueSample.add(
  637.                             new TimeStampedDouble(currentSamples.getValue()[currentIndex], currentSamples.getFirst())));

  639.                     // Interpolate
  640.                     currentInterpolatedAdditional[i] =
  641.                             additionalStateInterpolator.interpolate(interpolationDate, currentValueSample).getValue();
  642.                 }

  644.                 interpolatedAdditional.put(entry.getKey(), currentInterpolatedAdditional);
  645.             }
  646.         }
  647.         return interpolatedAdditional;
  648.     }

  650.     /**
  651.      * Interpolate attitude.
  652.      * <p>
  653.      * If no attitude interpolator were defined, create a default inertial provider with respect to the output frame.
  654.      *
  655.      * @param interpolationDate interpolation date
  656.      * @param attitudes attitudes sample
  657.      * @param pvProvider position-velocity-acceleration coordinates provider
  658.      *
  659.      * @return interpolated attitude if attitude interpolator is present, default attitude otherwise
  660.      */
  661.     private Attitude interpolateAttitude(final AbsoluteDate interpolationDate, final List<Attitude> attitudes,
  662.                                          final PVCoordinatesProvider pvProvider) {
  663.         if (attitudes.isEmpty()) {
  664.             final AttitudeProvider attitudeProvider = new FrameAlignedProvider(outputFrame);
  665.             return attitudeProvider.getAttitude(pvProvider, interpolationDate, outputFrame);
  666.         } else {
  667.             return attitudeInterpolator.interpolate(interpolationDate, attitudes);
  668.         }
  669.     }
  670. }
Created with JaCoCo 0.8.11.202310140853