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.OrekitException;
  25. import org.orekit.errors.OrekitIllegalArgumentException;
  26. import org.orekit.errors.OrekitInternalError;
  27. import org.orekit.errors.OrekitMessages;
  28. import org.orekit.frames.Frame;
  29. import org.orekit.orbits.Orbit;
  30. import org.orekit.orbits.OrbitHermiteInterpolator;
  31. import org.orekit.time.AbsoluteDate;
  32. import org.orekit.time.AbstractTimeInterpolator;
  33. import org.orekit.time.TimeInterpolator;
  34. import org.orekit.time.TimeStamped;
  35. import org.orekit.time.TimeStampedDouble;
  36. import org.orekit.time.TimeStampedDoubleHermiteInterpolator;
  37. import org.orekit.utils.AbsolutePVCoordinates;
  38. import org.orekit.utils.AbsolutePVCoordinatesHermiteInterpolator;
  39. import org.orekit.utils.AngularDerivativesFilter;
  40. import org.orekit.utils.CartesianDerivativesFilter;
  41. import org.orekit.utils.DoubleArrayDictionary;
  42. import org.orekit.utils.PVCoordinatesProvider;
  43. import org.orekit.utils.TimeStampedAngularCoordinatesHermiteInterpolator;

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

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

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

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

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

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

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

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

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

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

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

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

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

  222.     /**
  223.      * Constructor.
  224.      * <p>
  225.      * At least one interpolator for either orbit or absolute position-velocity-acceleration is needed. All the other
  226.      * interpolators can be left to null if the user do not want to interpolate these values.
  227.      * <p>
  228.      * <b>BEWARE:</b> output frame <b>must be inertial</b> if interpolated spacecraft states are defined by orbit. Throws an
  229.      * error otherwise.
  230.      * <p>
  231.      * <b>BEWARE:</b> it is up to the user to check the consistency of input interpolators.
  232.      *
  233.      * @param outputFrame output frame (inertial if the user is planning to use the orbit interpolator)
  234.      * @param orbitInterpolator orbit interpolator (can be null if absPVAInterpolator is defined)
  235.      * @param absPVAInterpolator absolute position-velocity-acceleration (can be null if orbitInterpolator is defined)
  236.      * @param massInterpolator mass interpolator (can be null)
  237.      * @param attitudeInterpolator attitude interpolator (can be null)
  238.      * @param additionalStateInterpolator additional state interpolator (can be null)
  239.      */
  240.     public SpacecraftStateInterpolator(final Frame outputFrame, final TimeInterpolator<Orbit> orbitInterpolator,
  241.                                        final TimeInterpolator<AbsolutePVCoordinates> absPVAInterpolator,
  242.                                        final TimeInterpolator<TimeStampedDouble> massInterpolator,
  243.                                        final TimeInterpolator<Attitude> attitudeInterpolator,
  244.                                        final TimeInterpolator<TimeStampedDouble> additionalStateInterpolator) {
  245.         super(DEFAULT_INTERPOLATION_POINTS, DEFAULT_EXTRAPOLATION_THRESHOLD_SEC);
  246.         checkAtLeastOneInterpolator(orbitInterpolator, absPVAInterpolator);
  247.         this.outputFrame                 = outputFrame;
  248.         this.orbitInterpolator           = orbitInterpolator;
  249.         this.absPVAInterpolator          = absPVAInterpolator;
  250.         this.massInterpolator            = massInterpolator;
  251.         this.attitudeInterpolator        = attitudeInterpolator;
  252.         this.additionalStateInterpolator = additionalStateInterpolator;
  253.     }

  255.     /**
  256.      * Check that an interpolator exist for given sample state definition.
  257.      *
  258.      * @param sample sample (non empty)
  259.      * @param orbitInterpolatorIsPresent flag defining if an orbit interpolator has been defined for this instance
  260.      * @param absPVInterpolatorIsPresent flag defining if an absolute position-velocity-acceleration interpolator has been
  261.      * defined for this instance
  262.      *
  263.      * @throws OrekitIllegalArgumentException if there is no defined interpolator for given sample spacecraft state
  264.      * definition type
  265.      */
  266.     public static void checkSampleAndInterpolatorConsistency(final List<SpacecraftState> sample,
  267.                                                              final boolean orbitInterpolatorIsPresent,
  268.                                                              final boolean absPVInterpolatorIsPresent) {
  269.         // Get first state definition
  270.         final SpacecraftState earliestState = sample.get(0);

  272.         if (earliestState.isOrbitDefined() && !orbitInterpolatorIsPresent ||
  273.                 !earliestState.isOrbitDefined() && !absPVInterpolatorIsPresent) {
  274.             throw new OrekitIllegalArgumentException(OrekitMessages.WRONG_INTERPOLATOR_DEFINED_FOR_STATE_INTERPOLATION);
  275.         }
  276.     }

  278.     /**
  279.      * Check that all state are either orbit defined or based on absolute position-velocity-acceleration.
  280.      *
  281.      * @param states spacecraft state sample
  282.      */
  283.     public static void checkStatesDefinitionsConsistency(final List<SpacecraftState> states) {
  284.         // Check all states handle the same additional states and are defined the same way (orbit or absolute PVA)
  285.         final SpacecraftState s0               = states.get(0);
  286.         final boolean         s0IsOrbitDefined = s0.isOrbitDefined();
  287.         for (final SpacecraftState state : states) {
  288.             s0.ensureCompatibleAdditionalStates(state);
  289.             if (s0IsOrbitDefined != state.isOrbitDefined()) {
  290.                 throw new OrekitIllegalArgumentException(OrekitMessages.DIFFERENT_STATE_DEFINITION);
  291.             }
  292.         }
  293.     }

  295.     /**
  296.      * {@inheritDoc}
  297.      * <p>
  298.      * The additional states that are interpolated are the ones already present in the first neighbor instance. The sample
  299.      * instances must therefore have at least the same additional states as this neighbor instance. They may have more
  300.      * additional states, but the extra ones will be ignored.
  301.      * <p>
  302.      * All the sample instances <em>must</em> be based on similar trajectory data, i.e. they must either all be based on
  303.      * orbits or all be based on absolute position-velocity-acceleration. Any inconsistency will trigger an
  304.      * {@link OrekitIllegalArgumentException}.
  305.      *
  306.      * @throws OrekitIllegalArgumentException if there are states defined by orbits and absolute
  307.      * position-velocity-acceleration coordinates
  308.      * @throws OrekitIllegalArgumentException if there is no defined interpolator for given sample spacecraft state
  309.      * definition type
  310.      */
  311.     @Override
  312.     public SpacecraftState interpolate(final AbsoluteDate interpolationDate, final Collection<SpacecraftState> sample) {

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

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

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

  323.             // Check interpolator and sample consistency
  324.             checkSampleAndInterpolatorConsistency(sampleList, orbitInterpolator != null, absPVAInterpolator != null);
  325.         }

  327.         return super.interpolate(interpolationDate, sample);
  328.     }

  330.     /** {@inheritDoc} */
  331.     @Override
  332.     public List<TimeInterpolator<? extends TimeStamped>> getSubInterpolators() {

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

  337.         addOptionalSubInterpolatorIfDefined(orbitInterpolator, subInterpolators);
  338.         addOptionalSubInterpolatorIfDefined(absPVAInterpolator, subInterpolators);
  339.         addOptionalSubInterpolatorIfDefined(massInterpolator, subInterpolators);
  340.         addOptionalSubInterpolatorIfDefined(attitudeInterpolator, subInterpolators);
  341.         addOptionalSubInterpolatorIfDefined(additionalStateInterpolator, subInterpolators);

  343.         return subInterpolators;

  345.     }

  347.     /**
  348.      * @return fail to return number of interpolation points used by this interpolator.
  349.      *
  350.      * @throws OrekitException because multiple interpolator are defined so the number of interpolation points used may
  351.      * differ.
  352.      */
  353.     @Override
  354.     public int getNbInterpolationPoints() {
  355.         throw new OrekitException(OrekitMessages.MULTIPLE_INTERPOLATOR_USED);
  356.     }

  358.     /**
  359.      * {@inheritDoc}
  360.      */
  361.     @Override
  362.     protected SpacecraftState interpolate(final InterpolationData interpolationData) {

  364.         // Get first state definition
  365.         final SpacecraftState earliestState   = interpolationData.getNeighborList().get(0);
  366.         final boolean         areOrbitDefined = earliestState.isOrbitDefined();

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

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

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

  377.         final List<DoubleArrayDictionary.Entry> additionalDotEntries =
  378.                 earliestState.getAdditionalStatesDerivatives().getData();
  379.         final Map<String, List<Pair<AbsoluteDate, double[]>>> additionalDotSample =
  380.                 createAdditionalStateSample(additionalDotEntries);

  382.         // Fill interpolators with samples
  383.         final List<SpacecraftState>       samples      = interpolationData.getCachedSamples().getAll();
  384.         final List<Orbit>                 orbitSample  = new ArrayList<>();
  385.         final List<AbsolutePVCoordinates> absPVASample = new ArrayList<>();
  386.         for (SpacecraftState state : samples) {
  387.             final AbsoluteDate currentDate = state.getDate();

  389.             // Add orbit sample if state is defined with an orbit
  390.             if (state.isOrbitDefined()) {
  391.                 orbitSample.add(state.getOrbit());
  392.             }
  393.             // Add absolute position-velocity-acceleration sample if state is defined with an absolute position-velocity-acceleration
  394.             else {
  395.                 absPVASample.add(state.getAbsPVA());
  396.             }

  398.             // Add mass sample
  399.             if (massInterpolator != null) {
  400.                 masses.add(new TimeStampedDouble(state.getMass(), state.getDate()));
  401.             }

  403.             // Add attitude sample if it is interpolated
  404.             if (attitudeInterpolator != null) {
  405.                 attitudes.add(state.getAttitude());
  406.             }

  408.             if (additionalStateInterpolator != null) {

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

  415.                 // Add all additional state derivative values if they are interpolated
  416.                 for (final Map.Entry<String, List<Pair<AbsoluteDate, double[]>>> entry : additionalDotSample.entrySet()) {
  417.                     entry.getValue().add(new Pair<>(currentDate, state.getAdditionalStateDerivative(entry.getKey())));
  418.                 }
  419.             }
  420.         }

  422.         // Interpolate mass
  423.         final AbsoluteDate interpolationDate = interpolationData.getInterpolationDate();
  424.         final double       interpolatedMass;
  425.         if (massInterpolator != null) {
  426.             interpolatedMass = massInterpolator.interpolate(interpolationDate, masses).getValue();
  427.         } else {
  428.             interpolatedMass = SpacecraftState.DEFAULT_MASS;
  429.         }

  431.         // Interpolate additional states and derivatives
  432.         final DoubleArrayDictionary interpolatedAdditional;
  433.         final DoubleArrayDictionary interpolatedAdditionalDot;
  434.         if (additionalStateInterpolator != null) {
  435.             interpolatedAdditional    = interpolateAdditionalState(interpolationDate, additionalSample);
  436.             interpolatedAdditionalDot = interpolateAdditionalState(interpolationDate, additionalDotSample);
  437.         } else {
  438.             interpolatedAdditional    = null;
  439.             interpolatedAdditionalDot = null;
  440.         }

  442.         // Interpolate orbit
  443.         if (areOrbitDefined && orbitInterpolator != null) {
  444.             final Orbit interpolatedOrbit = orbitInterpolator.interpolate(interpolationDate, orbitSample);

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

  448.             return new SpacecraftState(interpolatedOrbit, interpolatedAttitude, interpolatedMass, interpolatedAdditional,
  449.                                        interpolatedAdditionalDot);
  450.         }
  451.         // Interpolate absolute position-velocity-acceleration
  452.         else if (!areOrbitDefined && absPVAInterpolator != null) {

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

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

  458.             return new SpacecraftState(interpolatedAbsPva, interpolatedAttitude, interpolatedMass, interpolatedAdditional,
  459.                                        interpolatedAdditionalDot);
  460.         }
  461.         // Should never happen
  462.         else {
  463.             throw new OrekitInternalError(null);
  464.         }

  466.     }

  468.     /**
  469.      * Get output frame.
  470.      *
  471.      * @return output frame
  472.      */
  473.     public Frame getOutputFrame() {
  474.         return outputFrame;
  475.     }

  477.     /**
  478.      * Get orbit interpolator.
  479.      *
  480.      * @return optional orbit interpolator
  481.      *
  482.      * @see Optional
  483.      */
  484.     public Optional<TimeInterpolator<Orbit>> getOrbitInterpolator() {
  485.         return Optional.ofNullable(orbitInterpolator);
  486.     }

  488.     /**
  489.      * Get absolute position-velocity-acceleration interpolator.
  490.      *
  491.      * @return optional absolute position-velocity-acceleration interpolator
  492.      *
  493.      * @see Optional
  494.      */
  495.     public Optional<TimeInterpolator<AbsolutePVCoordinates>> getAbsPVAInterpolator() {
  496.         return Optional.ofNullable(absPVAInterpolator);
  497.     }

  499.     /**
  500.      * Get mass interpolator.
  501.      *
  502.      * @return optional mass interpolator
  503.      *
  504.      * @see Optional
  505.      */
  506.     public Optional<TimeInterpolator<TimeStampedDouble>> getMassInterpolator() {
  507.         return Optional.ofNullable(massInterpolator);
  508.     }

  510.     /**
  511.      * Get attitude interpolator.
  512.      *
  513.      * @return optional attitude interpolator
  514.      *
  515.      * @see Optional
  516.      */
  517.     public Optional<TimeInterpolator<Attitude>> getAttitudeInterpolator() {
  518.         return Optional.ofNullable(attitudeInterpolator);
  519.     }

  521.     /**
  522.      * Get additional state interpolator.
  523.      *
  524.      * @return optional additional state interpolator
  525.      *
  526.      * @see Optional
  527.      */
  528.     public Optional<TimeInterpolator<TimeStampedDouble>> getAdditionalStateInterpolator() {
  529.         return Optional.ofNullable(additionalStateInterpolator);
  530.     }

  532.     /**
  533.      * Check that at least one interpolator is defined.
  534.      *
  535.      * @param orbitInterpolatorToCheck orbit interpolator
  536.      * @param absPVAInterpolatorToCheck absolute position-velocity-acceleration interpolator
  537.      */
  538.     private void checkAtLeastOneInterpolator(final TimeInterpolator<Orbit> orbitInterpolatorToCheck,
  539.                                              final TimeInterpolator<AbsolutePVCoordinates> absPVAInterpolatorToCheck) {
  540.         if (orbitInterpolatorToCheck == null && absPVAInterpolatorToCheck == null) {
  541.             throw new OrekitIllegalArgumentException(OrekitMessages.NO_INTERPOLATOR_FOR_STATE_DEFINITION);
  542.         }
  543.     }

  545.     /**
  546.      * Create empty samples for given additional entries.
  547.      *
  548.      * @param additionalEntries tabulated additional entries
  549.      *
  550.      * @return empty samples for given additional entries
  551.      */
  552.     private Map<String, List<Pair<AbsoluteDate, double[]>>> createAdditionalStateSample(
  553.             final List<DoubleArrayDictionary.Entry> additionalEntries) {
  554.         final Map<String, List<Pair<AbsoluteDate, double[]>>> additionalSamples = new HashMap<>(additionalEntries.size());

  556.         for (final DoubleArrayDictionary.Entry entry : additionalEntries) {
  557.             additionalSamples.put(entry.getKey(), new ArrayList<>());
  558.         }

  560.         return additionalSamples;
  561.     }

  563.     /**
  564.      * Interpolate additional state values.
  565.      *
  566.      * @param interpolationDate interpolation date
  567.      * @param additionalSamples additional state samples
  568.      *
  569.      * @return interpolated additional state values
  570.      */
  571.     private DoubleArrayDictionary interpolateAdditionalState(final AbsoluteDate interpolationDate,
  572.                                                              final Map<String, List<Pair<AbsoluteDate, double[]>>> additionalSamples) {
  573.         final DoubleArrayDictionary interpolatedAdditional;

  575.         if (additionalSamples.isEmpty()) {
  576.             interpolatedAdditional = null;
  577.         } else {
  578.             interpolatedAdditional = new DoubleArrayDictionary(additionalSamples.size());
  579.             for (final Map.Entry<String, List<Pair<AbsoluteDate, double[]>>> entry : additionalSamples.entrySet()) {

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

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

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

  591.                     // Create final index for lambda expression use
  592.                     final int currentIndex = i;

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

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

  600.                     // Interpolate
  601.                     currentInterpolatedAdditional[i] =
  602.                             additionalStateInterpolator.interpolate(interpolationDate, currentValueSample).getValue();
  603.                 }

  605.                 interpolatedAdditional.put(entry.getKey(), currentInterpolatedAdditional);
  606.             }
  607.         }
  608.         return interpolatedAdditional;
  609.     }

  611.     /**
  612.      * Interpolate attitude.
  613.      * <p>
  614.      * If no attitude interpolator were defined, create a default inertial provider with respect to the output frame.
  615.      *
  616.      * @param interpolationDate interpolation date
  617.      * @param attitudes attitudes sample
  618.      * @param pvProvider position-velocity-acceleration coordinates provider
  619.      *
  620.      * @return interpolated attitude if attitude interpolator is present, default attitude otherwise
  621.      */
  622.     private Attitude interpolateAttitude(final AbsoluteDate interpolationDate, final List<Attitude> attitudes,
  623.                                          final PVCoordinatesProvider pvProvider) {
  624.         if (attitudes.isEmpty()) {
  625.             final AttitudeProvider attitudeProvider = new FrameAlignedProvider(outputFrame);
  626.             return attitudeProvider.getAttitude(pvProvider, interpolationDate, outputFrame);
  627.         } else {
  628.             return attitudeInterpolator.interpolate(interpolationDate, attitudes);
  629.         }
  630.     }
  631. }
Created with JaCoCo 0.8.11.202310140853