SpacecraftStateInterpolator.java

  1. /* Copyright 2002-2024 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.      * @deprecated using this constructor may throw an exception if any given interpolator
  253.      * does not use {@link #DEFAULT_INTERPOLATION_POINTS} and {@link
  254.      * #DEFAULT_EXTRAPOLATION_THRESHOLD_SEC}. Use {@link #SpacecraftStateInterpolator(int,
  255.      * double, Frame, TimeInterpolator, TimeInterpolator, TimeInterpolator,
  256.      * TimeInterpolator, TimeInterpolator)} instead.
  257.      */
  258.     @Deprecated
  259.     public SpacecraftStateInterpolator(final Frame outputFrame, final TimeInterpolator<Orbit> orbitInterpolator,
  260.                                        final TimeInterpolator<AbsolutePVCoordinates> absPVAInterpolator,
  261.                                        final TimeInterpolator<TimeStampedDouble> massInterpolator,
  262.                                        final TimeInterpolator<Attitude> attitudeInterpolator,
  263.                                        final TimeInterpolator<TimeStampedDouble> additionalStateInterpolator) {
  264.         super(DEFAULT_INTERPOLATION_POINTS, DEFAULT_EXTRAPOLATION_THRESHOLD_SEC);
  265.         checkAtLeastOneInterpolator(orbitInterpolator, absPVAInterpolator);
  266.         this.outputFrame                 = outputFrame;
  267.         this.orbitInterpolator           = orbitInterpolator;
  268.         this.absPVAInterpolator          = absPVAInterpolator;
  269.         this.massInterpolator            = massInterpolator;
  270.         this.attitudeInterpolator        = attitudeInterpolator;
  271.         this.additionalStateInterpolator = additionalStateInterpolator;
  272.     }

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

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

  329.         if (earliestState.isOrbitDefined() && !orbitInterpolatorIsPresent ||
  330.                 !earliestState.isOrbitDefined() && !absPVInterpolatorIsPresent) {
  331.             throw new OrekitIllegalArgumentException(OrekitMessages.WRONG_INTERPOLATOR_DEFINED_FOR_STATE_INTERPOLATION);
  332.         }
  333.     }

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

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

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

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

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

  380.             // Check interpolator and sample consistency
  381.             checkSampleAndInterpolatorConsistency(sampleList, orbitInterpolator != null, absPVAInterpolator != null);
  382.         }

  384.         return super.interpolate(interpolationDate, sample);
  385.     }

  387.     /** {@inheritDoc} */
  388.     @Override
  389.     public List<TimeInterpolator<? extends TimeStamped>> getSubInterpolators() {

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

  394.         addOptionalSubInterpolatorIfDefined(orbitInterpolator, subInterpolators);
  395.         addOptionalSubInterpolatorIfDefined(absPVAInterpolator, subInterpolators);
  396.         addOptionalSubInterpolatorIfDefined(massInterpolator, subInterpolators);
  397.         addOptionalSubInterpolatorIfDefined(attitudeInterpolator, subInterpolators);
  398.         addOptionalSubInterpolatorIfDefined(additionalStateInterpolator, subInterpolators);

  400.         return subInterpolators;

  402.     }

  404.     /**
  405.      * {@inheritDoc}
  406.      */
  407.     @Override
  408.     protected SpacecraftState interpolate(final InterpolationData interpolationData) {

  410.         // Get first state definition
  411.         final List<SpacecraftState> samples   = interpolationData.getNeighborList();
  412.         final SpacecraftState earliestState   = samples.get(0);
  413.         final boolean         areOrbitDefined = earliestState.isOrbitDefined();

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

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

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

  424.         final List<DoubleArrayDictionary.Entry> additionalDotEntries =
  425.                 earliestState.getAdditionalStatesDerivatives().getData();
  426.         final Map<String, List<Pair<AbsoluteDate, double[]>>> additionalDotSample =
  427.                 createAdditionalStateSample(additionalDotEntries);

  429.         // Fill interpolators with samples
  430.         final List<Orbit>                 orbitSample  = new ArrayList<>();
  431.         final List<AbsolutePVCoordinates> absPVASample = new ArrayList<>();
  432.         for (SpacecraftState state : samples) {
  433.             final AbsoluteDate currentDate = state.getDate();

  435.             // Add orbit sample if state is defined with an orbit
  436.             if (state.isOrbitDefined()) {
  437.                 orbitSample.add(state.getOrbit());
  438.             }
  439.             // Add absolute position-velocity-acceleration sample if state is defined with an absolute position-velocity-acceleration
  440.             else {
  441.                 absPVASample.add(state.getAbsPVA());
  442.             }

  444.             // Add mass sample
  445.             if (massInterpolator != null) {
  446.                 masses.add(new TimeStampedDouble(state.getMass(), state.getDate()));
  447.             }

  449.             // Add attitude sample if it is interpolated
  450.             if (attitudeInterpolator != null) {
  451.                 attitudes.add(state.getAttitude());
  452.             }

  454.             if (additionalStateInterpolator != null) {

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

  461.                 // Add all additional state derivative values if they are interpolated
  462.                 for (final Map.Entry<String, List<Pair<AbsoluteDate, double[]>>> entry : additionalDotSample.entrySet()) {
  463.                     entry.getValue().add(new Pair<>(currentDate, state.getAdditionalStateDerivative(entry.getKey())));
  464.                 }
  465.             }
  466.         }

  468.         // Interpolate mass
  469.         final AbsoluteDate interpolationDate = interpolationData.getInterpolationDate();
  470.         final double       interpolatedMass;
  471.         if (massInterpolator != null) {
  472.             interpolatedMass = massInterpolator.interpolate(interpolationDate, masses).getValue();
  473.         } else {
  474.             interpolatedMass = SpacecraftState.DEFAULT_MASS;
  475.         }

  477.         // Interpolate additional states and derivatives
  478.         final DoubleArrayDictionary interpolatedAdditional;
  479.         final DoubleArrayDictionary interpolatedAdditionalDot;
  480.         if (additionalStateInterpolator != null) {
  481.             interpolatedAdditional    = interpolateAdditionalState(interpolationDate, additionalSample);
  482.             interpolatedAdditionalDot = interpolateAdditionalState(interpolationDate, additionalDotSample);
  483.         } else {
  484.             interpolatedAdditional    = null;
  485.             interpolatedAdditionalDot = null;
  486.         }

  488.         // Interpolate orbit
  489.         if (areOrbitDefined && orbitInterpolator != null) {
  490.             final Orbit interpolatedOrbit = orbitInterpolator.interpolate(interpolationDate, orbitSample);

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

  494.             return new SpacecraftState(interpolatedOrbit, interpolatedAttitude, interpolatedMass, interpolatedAdditional,
  495.                                        interpolatedAdditionalDot);
  496.         }
  497.         // Interpolate absolute position-velocity-acceleration
  498.         else if (!areOrbitDefined && absPVAInterpolator != null) {

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

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

  504.             return new SpacecraftState(interpolatedAbsPva, interpolatedAttitude, interpolatedMass, interpolatedAdditional,
  505.                                        interpolatedAdditionalDot);
  506.         }
  507.         // Should never happen
  508.         else {
  509.             throw new OrekitInternalError(null);
  510.         }

  512.     }

  514.     /**
  515.      * Get output frame.
  516.      *
  517.      * @return output frame
  518.      */
  519.     public Frame getOutputFrame() {
  520.         return outputFrame;
  521.     }

  523.     /**
  524.      * Get orbit interpolator.
  525.      *
  526.      * @return optional orbit interpolator
  527.      *
  528.      * @see Optional
  529.      */
  530.     public Optional<TimeInterpolator<Orbit>> getOrbitInterpolator() {
  531.         return Optional.ofNullable(orbitInterpolator);
  532.     }

  534.     /**
  535.      * Get absolute position-velocity-acceleration interpolator.
  536.      *
  537.      * @return optional absolute position-velocity-acceleration interpolator
  538.      *
  539.      * @see Optional
  540.      */
  541.     public Optional<TimeInterpolator<AbsolutePVCoordinates>> getAbsPVAInterpolator() {
  542.         return Optional.ofNullable(absPVAInterpolator);
  543.     }

  545.     /**
  546.      * Get mass interpolator.
  547.      *
  548.      * @return optional mass interpolator
  549.      *
  550.      * @see Optional
  551.      */
  552.     public Optional<TimeInterpolator<TimeStampedDouble>> getMassInterpolator() {
  553.         return Optional.ofNullable(massInterpolator);
  554.     }

  556.     /**
  557.      * Get attitude interpolator.
  558.      *
  559.      * @return optional attitude interpolator
  560.      *
  561.      * @see Optional
  562.      */
  563.     public Optional<TimeInterpolator<Attitude>> getAttitudeInterpolator() {
  564.         return Optional.ofNullable(attitudeInterpolator);
  565.     }

  567.     /**
  568.      * Get additional state interpolator.
  569.      *
  570.      * @return optional additional state interpolator
  571.      *
  572.      * @see Optional
  573.      */
  574.     public Optional<TimeInterpolator<TimeStampedDouble>> getAdditionalStateInterpolator() {
  575.         return Optional.ofNullable(additionalStateInterpolator);
  576.     }

  578.     /**
  579.      * Check that at least one interpolator is defined.
  580.      *
  581.      * @param orbitInterpolatorToCheck orbit interpolator
  582.      * @param absPVAInterpolatorToCheck absolute position-velocity-acceleration interpolator
  583.      */
  584.     private void checkAtLeastOneInterpolator(final TimeInterpolator<Orbit> orbitInterpolatorToCheck,
  585.                                              final TimeInterpolator<AbsolutePVCoordinates> absPVAInterpolatorToCheck) {
  586.         if (orbitInterpolatorToCheck == null && absPVAInterpolatorToCheck == null) {
  587.             throw new OrekitIllegalArgumentException(OrekitMessages.NO_INTERPOLATOR_FOR_STATE_DEFINITION);
  588.         }
  589.     }

  591.     /**
  592.      * Create empty samples for given additional entries.
  593.      *
  594.      * @param additionalEntries tabulated additional entries
  595.      *
  596.      * @return empty samples for given additional entries
  597.      */
  598.     private Map<String, List<Pair<AbsoluteDate, double[]>>> createAdditionalStateSample(
  599.             final List<DoubleArrayDictionary.Entry> additionalEntries) {
  600.         final Map<String, List<Pair<AbsoluteDate, double[]>>> additionalSamples = new HashMap<>(additionalEntries.size());

  602.         for (final DoubleArrayDictionary.Entry entry : additionalEntries) {
  603.             additionalSamples.put(entry.getKey(), new ArrayList<>());
  604.         }

  606.         return additionalSamples;
  607.     }

  609.     /**
  610.      * Interpolate additional state values.
  611.      *
  612.      * @param interpolationDate interpolation date
  613.      * @param additionalSamples additional state samples
  614.      *
  615.      * @return interpolated additional state values
  616.      */
  617.     private DoubleArrayDictionary interpolateAdditionalState(final AbsoluteDate interpolationDate,
  618.                                                              final Map<String, List<Pair<AbsoluteDate, double[]>>> additionalSamples) {
  619.         final DoubleArrayDictionary interpolatedAdditional;

  621.         if (additionalSamples.isEmpty()) {
  622.             interpolatedAdditional = null;
  623.         } else {
  624.             interpolatedAdditional = new DoubleArrayDictionary(additionalSamples.size());
  625.             for (final Map.Entry<String, List<Pair<AbsoluteDate, double[]>>> entry : additionalSamples.entrySet()) {

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

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

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

  637.                     // Create final index for lambda expression use
  638.                     final int currentIndex = i;

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

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

  646.                     // Interpolate
  647.                     currentInterpolatedAdditional[i] =
  648.                             additionalStateInterpolator.interpolate(interpolationDate, currentValueSample).getValue();
  649.                 }

  651.                 interpolatedAdditional.put(entry.getKey(), currentInterpolatedAdditional);
  652.             }
  653.         }
  654.         return interpolatedAdditional;
  655.     }

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