FieldSpacecraftStateInterpolator.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.CalculusFieldElement;
  20. import org.hipparchus.Field;
  21. import org.hipparchus.util.MathArrays;
  22. import org.hipparchus.util.Pair;
  23. import org.orekit.attitudes.AttitudeProvider;
  24. import org.orekit.attitudes.FieldAttitude;
  25. import org.orekit.attitudes.FieldAttitudeInterpolator;
  26. import org.orekit.attitudes.FrameAlignedProvider;
  27. import org.orekit.errors.OrekitIllegalArgumentException;
  28. import org.orekit.errors.OrekitInternalError;
  29. import org.orekit.errors.OrekitMessages;
  30. import org.orekit.frames.Frame;
  31. import org.orekit.orbits.FieldOrbit;
  32. import org.orekit.orbits.FieldOrbitHermiteInterpolator;
  33. import org.orekit.time.AbstractFieldTimeInterpolator;
  34. import org.orekit.time.AbstractTimeInterpolator;
  35. import org.orekit.time.FieldAbsoluteDate;
  36. import org.orekit.time.FieldTimeInterpolator;
  37. import org.orekit.time.FieldTimeStamped;
  38. import org.orekit.time.TimeStampedField;
  39. import org.orekit.time.TimeStampedFieldHermiteInterpolator;
  40. import org.orekit.utils.AngularDerivativesFilter;
  41. import org.orekit.utils.CartesianDerivativesFilter;
  42. import org.orekit.utils.FieldAbsolutePVCoordinates;
  43. import org.orekit.utils.FieldAbsolutePVCoordinatesHermiteInterpolator;
  44. import org.orekit.utils.FieldArrayDictionary;
  45. import org.orekit.utils.FieldPVCoordinatesProvider;
  46. import org.orekit.utils.TimeStampedFieldAngularCoordinatesHermiteInterpolator;

  48. import java.util.ArrayList;
  49. import java.util.Collection;
  50. import java.util.HashMap;
  51. import java.util.List;
  52. import java.util.Map;
  53. import java.util.Optional;
  54. import java.util.stream.Collectors;

  56. /**
  57.  * Generic class for spacecraft state interpolator.
  58.  * <p>
  59.  * The user can specify what interpolator to use for each attribute of the spacecraft state.  However, at least one
  60.  * interpolator for either orbit or absolute position-velocity-acceleration is needed. All the other interpolators can be
  61.  * left to null if the user do not want to interpolate these values.
  62.  *
  63.  * @param <KK> type of the field element
  64.  *
  65.  * @author Luc Maisonobe
  66.  * @author Vincent Cucchietti
  67.  * @see SpacecraftState
  68.  */
  69. public class FieldSpacecraftStateInterpolator<KK extends CalculusFieldElement<KK>>
  70.         extends AbstractFieldTimeInterpolator<FieldSpacecraftState<KK>, KK> {

  72.     /**
  73.      * Output frame.
  74.      * <p><b>Must be inertial</b> if interpolating spacecraft states defined by orbit</p>
  75.      */
  76.     private final Frame outputFrame;

  78.     /** Orbit interpolator. */
  79.     private final FieldTimeInterpolator<FieldOrbit<KK>, KK> orbitInterpolator;

  81.     /** Absolute position-velocity-acceleration interpolator. */
  82.     private final FieldTimeInterpolator<FieldAbsolutePVCoordinates<KK>, KK> absPVAInterpolator;

  84.     /** Mass interpolator. */
  85.     private final FieldTimeInterpolator<TimeStampedField<KK>, KK> massInterpolator;

  87.     /** Attitude interpolator. */
  88.     private final FieldTimeInterpolator<FieldAttitude<KK>, KK> attitudeInterpolator;

  90.     /** Additional state interpolator. */
  91.     private final FieldTimeInterpolator<TimeStampedField<KK>, KK> additionalStateInterpolator;

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

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

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

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

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

  222.         this(outputFrame,
  223.              new FieldOrbitHermiteInterpolator<>(interpolationPoints, extrapolationThreshold, outputFrame, pvaFilter),
  224.              new FieldAbsolutePVCoordinatesHermiteInterpolator<>(interpolationPoints, extrapolationThreshold, outputFrame,
  225.                                                                  pvaFilter),
  226.              new TimeStampedFieldHermiteInterpolator<>(interpolationPoints, extrapolationThreshold),
  227.              new FieldAttitudeInterpolator<>(attitudeReferenceFrame,
  228.                                              new TimeStampedFieldAngularCoordinatesHermiteInterpolator<KK>(
  229.                                                      interpolationPoints, extrapolationThreshold, angularFilter)),
  230.              new TimeStampedFieldHermiteInterpolator<>(interpolationPoints, extrapolationThreshold));
  231.     }

  233.     /**
  234.      * Constructor.
  235.      * <p>
  236.      * <b>BEWARE:</b> output frame <b>must be inertial</b> if interpolated spacecraft states are defined by orbit. Throws an
  237.      * error otherwise.
  238.      *
  239.      * @param outputFrame output frame
  240.      * @param orbitInterpolator orbit interpolator
  241.      * @param absPVAInterpolator absolute position-velocity-acceleration
  242.      * @param massInterpolator mass interpolator
  243.      * @param attitudeInterpolator attitude interpolator
  244.      * @param additionalStateInterpolator additional state interpolator
  245.      */
  246.     public FieldSpacecraftStateInterpolator(final Frame outputFrame,
  247.                                             final FieldTimeInterpolator<FieldOrbit<KK>, KK> orbitInterpolator,
  248.                                             final FieldTimeInterpolator<FieldAbsolutePVCoordinates<KK>, KK> absPVAInterpolator,
  249.                                             final FieldTimeInterpolator<TimeStampedField<KK>, KK> massInterpolator,
  250.                                             final FieldTimeInterpolator<FieldAttitude<KK>, KK> attitudeInterpolator,
  251.                                             final FieldTimeInterpolator<TimeStampedField<KK>, KK> additionalStateInterpolator) {
  252.         super(DEFAULT_INTERPOLATION_POINTS, DEFAULT_EXTRAPOLATION_THRESHOLD_SEC);
  253.         checkAtLeastOneInterpolator(orbitInterpolator, absPVAInterpolator);
  254.         this.outputFrame                 = outputFrame;
  255.         this.orbitInterpolator           = orbitInterpolator;
  256.         this.absPVAInterpolator          = absPVAInterpolator;
  257.         this.massInterpolator            = massInterpolator;
  258.         this.attitudeInterpolator        = attitudeInterpolator;
  259.         this.additionalStateInterpolator = additionalStateInterpolator;
  260.     }

  262.     /**
  263.      * {@inheritDoc}
  264.      * <p>
  265.      * The additional states that are interpolated are the ones already present in the first neighbor instance. The sample
  266.      * instances must therefore have at least the same additional states as this neighbor instance. They may have more
  267.      * additional states, but the extra ones will be ignored.
  268.      * <p>
  269.      * All the sample instances <em>must</em> be based on similar trajectory data, i.e. they must either all be based on
  270.      * orbits or all be based on absolute position-velocity-acceleration. Any inconsistency will trigger an
  271.      * {@link OrekitIllegalArgumentException}.
  272.      *
  273.      * @throws OrekitIllegalArgumentException if there are states defined by orbits and absolute
  274.      * position-velocity-acceleration coordinates
  275.      * @throws OrekitIllegalArgumentException if there is no defined interpolator for given sample spacecraft state
  276.      * definition type
  277.      */
  278.     @Override
  279.     public FieldSpacecraftState<KK> interpolate(final FieldAbsoluteDate<KK> interpolationDate,
  280.                                                 final Collection<FieldSpacecraftState<KK>> sample) {

  282.         final List<FieldSpacecraftState<KK>> sampleList = new ArrayList<>(sample);

  284.         // Convert to spacecraft state for consistency check
  285.         final List<SpacecraftState> nonFieldSampleList =
  286.                 sampleList.stream().map(FieldSpacecraftState::toSpacecraftState).collect(Collectors.toList());

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

  291.             // Check given that given states definition are consistent
  292.             // (all defined by either orbits or absolute position-velocity-acceleration coordinates)
  293.             SpacecraftStateInterpolator.checkStatesDefinitionsConsistency(nonFieldSampleList);

  295.             // Check interpolator and sample consistency
  296.             SpacecraftStateInterpolator.checkSampleAndInterpolatorConsistency(nonFieldSampleList,
  297.                                                                               orbitInterpolator != null,
  298.                                                                               absPVAInterpolator != null);
  299.         }

  301.         return super.interpolate(interpolationDate, sample);
  302.     }

  304.     /** {@inheritDoc} */
  305.     @Override
  306.     public List<FieldTimeInterpolator<? extends FieldTimeStamped<KK>, KK>> getSubInterpolators() {

  308.         // Add all sub interpolators that are defined
  309.         final List<FieldTimeInterpolator<? extends FieldTimeStamped<KK>, KK>> subInterpolators = new ArrayList<>();

  311.         addOptionalSubInterpolatorIfDefined(orbitInterpolator, subInterpolators);
  312.         addOptionalSubInterpolatorIfDefined(absPVAInterpolator, subInterpolators);
  313.         addOptionalSubInterpolatorIfDefined(massInterpolator, subInterpolators);
  314.         addOptionalSubInterpolatorIfDefined(attitudeInterpolator, subInterpolators);
  315.         addOptionalSubInterpolatorIfDefined(additionalStateInterpolator, subInterpolators);

  317.         return subInterpolators;
  318.     }

  320.     /**
  321.      * {@inheritDoc}
  322.      */
  323.     @Override
  324.     protected FieldSpacecraftState<KK> interpolate(final InterpolationData interpolationData) {

  326.         // Get interpolation date
  327.         final FieldAbsoluteDate<KK> interpolationDate = interpolationData.getInterpolationDate();

  329.         // Get first state definition
  330.         final FieldSpacecraftState<KK> earliestState   = interpolationData.getNeighborList().get(0);
  331.         final boolean                  areOrbitDefined = earliestState.isOrbitDefined();

  333.         // Prepare samples
  334.         final List<FieldAttitude<KK>> attitudes = new ArrayList<>();

  336.         final List<TimeStampedField<KK>> masses = new ArrayList<>();

  338.         final List<FieldArrayDictionary<KK>.Entry> additionalEntries =
  339.                 earliestState.getAdditionalStatesValues().getData();
  340.         final Map<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> additionalSample =
  341.                 createAdditionalStateSample(additionalEntries);

  343.         final List<FieldArrayDictionary<KK>.Entry> additionalDotEntries =
  344.                 earliestState.getAdditionalStatesDerivatives().getData();
  345.         final Map<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> additionalDotSample =
  346.                 createAdditionalStateSample(additionalDotEntries);

  348.         // Fill interpolators with samples
  349.         final List<FieldSpacecraftState<KK>>       samples      = interpolationData.getCachedSamples().getAll();
  350.         final List<FieldOrbit<KK>>                 orbitSample  = new ArrayList<>();
  351.         final List<FieldAbsolutePVCoordinates<KK>> absPVASample = new ArrayList<>();
  352.         for (FieldSpacecraftState<KK> state : samples) {
  353.             final FieldAbsoluteDate<KK> currentDate = state.getDate();

  355.             // Add orbit sample if state is defined with an orbit
  356.             if (state.isOrbitDefined()) {
  357.                 orbitSample.add(state.getOrbit());
  358.             }
  359.             // Add absolute position-velocity-acceleration sample if state is defined with an absolute position-velocity-acceleration
  360.             else {
  361.                 absPVASample.add(state.getAbsPVA());
  362.             }

  364.             // Add mass sample
  365.             if (massInterpolator != null) {
  366.                 masses.add(new TimeStampedField<>(state.getMass(), state.getDate()));
  367.             }

  369.             // Add attitude sample if it is interpolated
  370.             if (attitudeInterpolator != null) {
  371.                 attitudes.add(state.getAttitude());
  372.             }

  374.             if (additionalStateInterpolator != null) {

  376.                 // Add all additional state values if they are interpolated
  377.                 for (final Map.Entry<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> entry : additionalSample.entrySet()) {
  378.                     entry.getValue().add(new Pair<>(currentDate, state.getAdditionalState(entry.getKey())));
  379.                 }

  381.                 // Add all additional state derivative values if they are interpolated
  382.                 for (final Map.Entry<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> entry : additionalDotSample.entrySet()) {
  383.                     entry.getValue().add(new Pair<>(currentDate, state.getAdditionalStateDerivative(entry.getKey())));
  384.                 }
  385.             }

  387.         }

  389.         // Interpolate mass
  390.         final KK one = interpolationData.getOne();
  391.         final KK interpolatedMass;
  392.         if (massInterpolator != null) {
  393.             interpolatedMass = massInterpolator.interpolate(interpolationDate, masses).getValue();
  394.         }
  395.         else {
  396.             interpolatedMass = one.multiply(SpacecraftState.DEFAULT_MASS);
  397.         }

  399.         // Interpolate additional states and derivatives
  400.         final FieldArrayDictionary<KK> interpolatedAdditional;
  401.         final FieldArrayDictionary<KK> interpolatedAdditionalDot;
  402.         if (additionalStateInterpolator != null) {
  403.             interpolatedAdditional    = interpolateAdditionalState(interpolationDate, additionalSample);
  404.             interpolatedAdditionalDot = interpolateAdditionalState(interpolationDate, additionalDotSample);
  405.         }
  406.         else {
  407.             interpolatedAdditional    = null;
  408.             interpolatedAdditionalDot = null;
  409.         }

  411.         // Interpolate orbit
  412.         if (areOrbitDefined && orbitInterpolator != null) {
  413.             final FieldOrbit<KK> interpolatedOrbit =
  414.                     orbitInterpolator.interpolate(interpolationDate, orbitSample);

  416.             final FieldAttitude<KK> interpolatedAttitude =
  417.                     interpolateAttitude(interpolationDate, attitudes, interpolatedOrbit);

  419.             return new FieldSpacecraftState<>(interpolatedOrbit, interpolatedAttitude, interpolatedMass,
  420.                                               interpolatedAdditional, interpolatedAdditionalDot);
  421.         }
  422.         // Interpolate absolute position-velocity-acceleration
  423.         else if (!areOrbitDefined && absPVAInterpolator != null) {

  425.             final FieldAbsolutePVCoordinates<KK> interpolatedAbsPva =
  426.                     absPVAInterpolator.interpolate(interpolationDate, absPVASample);

  428.             final FieldAttitude<KK> interpolatedAttitude =
  429.                     interpolateAttitude(interpolationDate, attitudes, interpolatedAbsPva);

  431.             return new FieldSpacecraftState<>(interpolatedAbsPva, interpolatedAttitude, interpolatedMass,
  432.                                               interpolatedAdditional, interpolatedAdditionalDot);
  433.         }
  434.         // Should never happen
  435.         else {
  436.             throw new OrekitInternalError(null);
  437.         }

  439.     }

  441.     /** Get output frame.
  442.      * @return output frame
  443.      */
  444.     public Frame getOutputFrame() {
  445.         return outputFrame;
  446.     }

  448.     /** Get orbit interpolator.
  449.      * @return optional orbit interpolator
  450.      *
  451.      * @see Optional
  452.      */
  453.     public Optional<FieldTimeInterpolator<FieldOrbit<KK>, KK>> getOrbitInterpolator() {
  454.         return Optional.ofNullable(orbitInterpolator);
  455.     }

  457.     /** Get absolute position-velocity-acceleration interpolator.
  458.      * @return optional absolute position-velocity-acceleration interpolator
  459.      *
  460.      * @see Optional
  461.      */
  462.     public Optional<FieldTimeInterpolator<FieldAbsolutePVCoordinates<KK>, KK>> getAbsPVAInterpolator() {
  463.         return Optional.ofNullable(absPVAInterpolator);
  464.     }

  466.     /** Get mass interpolator.
  467.      * @return optional mass interpolator
  468.      *
  469.      * @see Optional
  470.      */
  471.     public Optional<FieldTimeInterpolator<TimeStampedField<KK>, KK>> getMassInterpolator() {
  472.         return Optional.ofNullable(massInterpolator);
  473.     }

  475.     /** Get attitude interpolator.
  476.      * @return optional attitude interpolator
  477.      *
  478.      * @see Optional
  479.      */
  480.     public Optional<FieldTimeInterpolator<FieldAttitude<KK>, KK>> getAttitudeInterpolator() {
  481.         return Optional.ofNullable(attitudeInterpolator);
  482.     }

  484.     /** Get additional state interpolator.
  485.      * @return optional additional state interpolator
  486.      *
  487.      * @see Optional
  488.      */
  489.     public Optional<FieldTimeInterpolator<TimeStampedField<KK>, KK>> getAdditionalStateInterpolator() {
  490.         return Optional.ofNullable(additionalStateInterpolator);
  491.     }

  493.     /**
  494.      * Check that at least one interpolator is defined.
  495.      *
  496.      * @param orbitInterpolatorToCheck orbit interpolator
  497.      * @param absPVAInterpolatorToCheck absolute position-velocity-acceleration interpolator
  498.      */
  499.     private void checkAtLeastOneInterpolator(final FieldTimeInterpolator<FieldOrbit<KK>, KK> orbitInterpolatorToCheck,
  500.                                              final FieldTimeInterpolator<FieldAbsolutePVCoordinates<KK>, KK> absPVAInterpolatorToCheck) {
  501.         if (orbitInterpolatorToCheck == null && absPVAInterpolatorToCheck == null) {
  502.             throw new OrekitIllegalArgumentException(OrekitMessages.NO_INTERPOLATOR_FOR_STATE_DEFINITION);
  503.         }
  504.     }

  506.     /**
  507.      * Create empty samples for given additional entries.
  508.      *
  509.      * @param additionalEntries tabulated additional entries
  510.      *
  511.      * @return empty samples for given additional entries
  512.      */
  513.     private Map<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> createAdditionalStateSample(
  514.             final List<FieldArrayDictionary<KK>.Entry> additionalEntries) {
  515.         final Map<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> additionalSamples =
  516.                 new HashMap<>(additionalEntries.size());

  518.         for (final FieldArrayDictionary<KK>.Entry entry : additionalEntries) {
  519.             additionalSamples.put(entry.getKey(), new ArrayList<>());
  520.         }

  522.         return additionalSamples;
  523.     }

  525.     /**
  526.      * Interpolate additional state values.
  527.      *
  528.      * @param interpolationDate interpolation date
  529.      * @param additionalSamples additional state samples
  530.      *
  531.      * @return interpolated additional state values
  532.      */
  533.     private FieldArrayDictionary<KK> interpolateAdditionalState(final FieldAbsoluteDate<KK> interpolationDate,
  534.                                                                 final Map<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> additionalSamples) {
  535.         final Field<KK> field = interpolationDate.getField();
  536.         final FieldArrayDictionary<KK> interpolatedAdditional;

  538.         if (additionalSamples.isEmpty()) {
  539.             interpolatedAdditional = null;
  540.         }
  541.         else {
  542.             interpolatedAdditional = new FieldArrayDictionary<>(field, additionalSamples.size());
  543.             for (final Map.Entry<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> entry : additionalSamples.entrySet()) {

  545.                 // Get current entry
  546.                 final List<Pair<FieldAbsoluteDate<KK>, KK[]>> currentAdditionalSamples = entry.getValue();

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

  551.                 // For each value of current additional state entry
  552.                 final KK[] currentInterpolatedAdditional = MathArrays.buildArray(field, nbOfValues);
  553.                 for (int i = 0; i < nbOfValues; i++) {

  555.                     // Create final index for lambda expression use
  556.                     final int currentIndex = i;

  558.                     // Create sample for specific value of current additional state values
  559.                     final List<TimeStampedField<KK>> currentValueSample = new ArrayList<>();

  561.                     currentAdditionalSamples.forEach(currentSamples -> currentValueSample.add(
  562.                             new TimeStampedField<>(currentSamples.getValue()[currentIndex], currentSamples.getFirst())));

  564.                     // Interpolate
  565.                     currentInterpolatedAdditional[i] =
  566.                             additionalStateInterpolator.interpolate(interpolationDate, currentValueSample).getValue();
  567.                 }

  569.                 interpolatedAdditional.put(entry.getKey(), currentInterpolatedAdditional);
  570.             }
  571.         }
  572.         return interpolatedAdditional;
  573.     }

  575.     /**
  576.      * Interpolate attitude.
  577.      * <p>
  578.      * If no attitude interpolator were defined, create a default inertial provider with respect to the output frame.
  579.      *
  580.      * @param interpolationDate interpolation date
  581.      * @param attitudes attitudes sample
  582.      * @param pvProvider position-velocity-acceleration coordinates provider
  583.      *
  584.      * @return interpolated attitude if attitude interpolator is present, default attitude otherwise
  585.      */
  586.     private FieldAttitude<KK> interpolateAttitude(final FieldAbsoluteDate<KK> interpolationDate,
  587.                                                   final List<FieldAttitude<KK>> attitudes,
  588.                                                   final FieldPVCoordinatesProvider<KK> pvProvider) {
  589.         if (attitudes.isEmpty()) {
  590.             final AttitudeProvider attitudeProvider = new FrameAlignedProvider(outputFrame);
  591.             return attitudeProvider.getAttitude(pvProvider, interpolationDate, outputFrame);
  592.         }
  593.         else {
  594.             return attitudeInterpolator.interpolate(interpolationDate, attitudes);
  595.         }
  596.     }
  597. }
Created with JaCoCo 0.8.11.202310140853