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.OrekitException;
  28. import org.orekit.errors.OrekitIllegalArgumentException;
  29. import org.orekit.errors.OrekitInternalError;
  30. import org.orekit.errors.OrekitMessages;
  31. import org.orekit.frames.Frame;
  32. import org.orekit.orbits.FieldOrbit;
  33. import org.orekit.orbits.FieldOrbitHermiteInterpolator;
  34. import org.orekit.time.AbstractFieldTimeInterpolator;
  35. import org.orekit.time.AbstractTimeInterpolator;
  36. import org.orekit.time.FieldAbsoluteDate;
  37. import org.orekit.time.FieldTimeInterpolator;
  38. import org.orekit.time.FieldTimeStamped;
  39. import org.orekit.time.TimeStampedField;
  40. import org.orekit.time.TimeStampedFieldHermiteInterpolator;
  41. import org.orekit.utils.AngularDerivativesFilter;
  42. import org.orekit.utils.CartesianDerivativesFilter;
  43. import org.orekit.utils.FieldAbsolutePVCoordinates;
  44. import org.orekit.utils.FieldAbsolutePVCoordinatesHermiteInterpolator;
  45. import org.orekit.utils.FieldArrayDictionary;
  46. import org.orekit.utils.FieldPVCoordinatesProvider;
  47. import org.orekit.utils.TimeStampedFieldAngularCoordinatesHermiteInterpolator;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  318.         return subInterpolators;
  319.     }

  321.     /**
  322.      * @return fail to return number of interpolation points used by this interpolator.
  323.      *
  324.      * @throws OrekitException because multiple interpolator are defined so the number of interpolation points used may
  325.      * differ.
  326.      */
  327.     @Override
  328.     public int getNbInterpolationPoints() {
  329.         throw new OrekitException(OrekitMessages.MULTIPLE_INTERPOLATOR_USED);
  330.     }

  332.     /**
  333.      * {@inheritDoc}
  334.      */
  335.     @Override
  336.     protected FieldSpacecraftState<KK> interpolate(final InterpolationData interpolationData) {

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

  341.         // Get first state definition
  342.         final FieldSpacecraftState<KK> earliestState   = interpolationData.getNeighborList().get(0);
  343.         final boolean                  areOrbitDefined = earliestState.isOrbitDefined();

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

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

  350.         final List<FieldArrayDictionary<KK>.Entry> additionalEntries =
  351.                 earliestState.getAdditionalStatesValues().getData();
  352.         final Map<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> additionalSample =
  353.                 createAdditionalStateSample(additionalEntries);

  355.         final List<FieldArrayDictionary<KK>.Entry> additionalDotEntries =
  356.                 earliestState.getAdditionalStatesDerivatives().getData();
  357.         final Map<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> additionalDotSample =
  358.                 createAdditionalStateSample(additionalDotEntries);

  360.         // Fill interpolators with samples
  361.         final List<FieldSpacecraftState<KK>>       samples      = interpolationData.getCachedSamples().getAll();
  362.         final List<FieldOrbit<KK>>                 orbitSample  = new ArrayList<>();
  363.         final List<FieldAbsolutePVCoordinates<KK>> absPVASample = new ArrayList<>();
  364.         for (FieldSpacecraftState<KK> state : samples) {
  365.             final FieldAbsoluteDate<KK> currentDate = state.getDate();

  367.             // Add orbit sample if state is defined with an orbit
  368.             if (state.isOrbitDefined()) {
  369.                 orbitSample.add(state.getOrbit());
  370.             }
  371.             // Add absolute position-velocity-acceleration sample if state is defined with an absolute position-velocity-acceleration
  372.             else {
  373.                 absPVASample.add(state.getAbsPVA());
  374.             }

  376.             // Add mass sample
  377.             if (massInterpolator != null) {
  378.                 masses.add(new TimeStampedField<>(state.getMass(), state.getDate()));
  379.             }

  381.             // Add attitude sample if it is interpolated
  382.             if (attitudeInterpolator != null) {
  383.                 attitudes.add(state.getAttitude());
  384.             }

  386.             if (additionalStateInterpolator != null) {

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

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

  399.         }

  401.         // Interpolate mass
  402.         final KK one = interpolationData.getOne();
  403.         final KK interpolatedMass;
  404.         if (massInterpolator != null) {
  405.             interpolatedMass = massInterpolator.interpolate(interpolationDate, masses).getValue();
  406.         }
  407.         else {
  408.             interpolatedMass = one.multiply(SpacecraftState.DEFAULT_MASS);
  409.         }

  411.         // Interpolate additional states and derivatives
  412.         final FieldArrayDictionary<KK> interpolatedAdditional;
  413.         final FieldArrayDictionary<KK> interpolatedAdditionalDot;
  414.         if (additionalStateInterpolator != null) {
  415.             interpolatedAdditional    = interpolateAdditionalState(interpolationDate, additionalSample);
  416.             interpolatedAdditionalDot = interpolateAdditionalState(interpolationDate, additionalDotSample);
  417.         }
  418.         else {
  419.             interpolatedAdditional    = null;
  420.             interpolatedAdditionalDot = null;
  421.         }

  423.         // Interpolate orbit
  424.         if (areOrbitDefined && orbitInterpolator != null) {
  425.             final FieldOrbit<KK> interpolatedOrbit =
  426.                     orbitInterpolator.interpolate(interpolationDate, orbitSample);

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

  431.             return new FieldSpacecraftState<>(interpolatedOrbit, interpolatedAttitude, interpolatedMass,
  432.                                               interpolatedAdditional, interpolatedAdditionalDot);
  433.         }
  434.         // Interpolate absolute position-velocity-acceleration
  435.         else if (!areOrbitDefined && absPVAInterpolator != null) {

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

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

  443.             return new FieldSpacecraftState<>(interpolatedAbsPva, interpolatedAttitude, interpolatedMass,
  444.                                               interpolatedAdditional, interpolatedAdditionalDot);
  445.         }
  446.         // Should never happen
  447.         else {
  448.             throw new OrekitInternalError(null);
  449.         }

  451.     }

  453.     /** Get output frame.
  454.      * @return output frame
  455.      */
  456.     public Frame getOutputFrame() {
  457.         return outputFrame;
  458.     }

  460.     /** Get orbit interpolator.
  461.      * @return optional orbit interpolator
  462.      *
  463.      * @see Optional
  464.      */
  465.     public Optional<FieldTimeInterpolator<FieldOrbit<KK>, KK>> getOrbitInterpolator() {
  466.         return Optional.ofNullable(orbitInterpolator);
  467.     }

  469.     /** Get absolute position-velocity-acceleration interpolator.
  470.      * @return optional absolute position-velocity-acceleration interpolator
  471.      *
  472.      * @see Optional
  473.      */
  474.     public Optional<FieldTimeInterpolator<FieldAbsolutePVCoordinates<KK>, KK>> getAbsPVAInterpolator() {
  475.         return Optional.ofNullable(absPVAInterpolator);
  476.     }

  478.     /** Get mass interpolator.
  479.      * @return optional mass interpolator
  480.      *
  481.      * @see Optional
  482.      */
  483.     public Optional<FieldTimeInterpolator<TimeStampedField<KK>, KK>> getMassInterpolator() {
  484.         return Optional.ofNullable(massInterpolator);
  485.     }

  487.     /** Get attitude interpolator.
  488.      * @return optional attitude interpolator
  489.      *
  490.      * @see Optional
  491.      */
  492.     public Optional<FieldTimeInterpolator<FieldAttitude<KK>, KK>> getAttitudeInterpolator() {
  493.         return Optional.ofNullable(attitudeInterpolator);
  494.     }

  496.     /** Get additional state interpolator.
  497.      * @return optional additional state interpolator
  498.      *
  499.      * @see Optional
  500.      */
  501.     public Optional<FieldTimeInterpolator<TimeStampedField<KK>, KK>> getAdditionalStateInterpolator() {
  502.         return Optional.ofNullable(additionalStateInterpolator);
  503.     }

  505.     /**
  506.      * Check that at least one interpolator is defined.
  507.      *
  508.      * @param orbitInterpolatorToCheck orbit interpolator
  509.      * @param absPVAInterpolatorToCheck absolute position-velocity-acceleration interpolator
  510.      */
  511.     private void checkAtLeastOneInterpolator(final FieldTimeInterpolator<FieldOrbit<KK>, KK> orbitInterpolatorToCheck,
  512.                                              final FieldTimeInterpolator<FieldAbsolutePVCoordinates<KK>, KK> absPVAInterpolatorToCheck) {
  513.         if (orbitInterpolatorToCheck == null && absPVAInterpolatorToCheck == null) {
  514.             throw new OrekitIllegalArgumentException(OrekitMessages.NO_INTERPOLATOR_FOR_STATE_DEFINITION);
  515.         }
  516.     }

  518.     /**
  519.      * Create empty samples for given additional entries.
  520.      *
  521.      * @param additionalEntries tabulated additional entries
  522.      *
  523.      * @return empty samples for given additional entries
  524.      */
  525.     private Map<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> createAdditionalStateSample(
  526.             final List<FieldArrayDictionary<KK>.Entry> additionalEntries) {
  527.         final Map<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> additionalSamples =
  528.                 new HashMap<>(additionalEntries.size());

  530.         for (final FieldArrayDictionary<KK>.Entry entry : additionalEntries) {
  531.             additionalSamples.put(entry.getKey(), new ArrayList<>());
  532.         }

  534.         return additionalSamples;
  535.     }

  537.     /**
  538.      * Interpolate additional state values.
  539.      *
  540.      * @param interpolationDate interpolation date
  541.      * @param additionalSamples additional state samples
  542.      *
  543.      * @return interpolated additional state values
  544.      */
  545.     private FieldArrayDictionary<KK> interpolateAdditionalState(final FieldAbsoluteDate<KK> interpolationDate,
  546.                                                                 final Map<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> additionalSamples) {
  547.         final Field<KK> field = interpolationDate.getField();
  548.         final FieldArrayDictionary<KK> interpolatedAdditional;

  550.         if (additionalSamples.isEmpty()) {
  551.             interpolatedAdditional = null;
  552.         }
  553.         else {
  554.             interpolatedAdditional = new FieldArrayDictionary<>(field, additionalSamples.size());
  555.             for (final Map.Entry<String, List<Pair<FieldAbsoluteDate<KK>, KK[]>>> entry : additionalSamples.entrySet()) {

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

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

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

  567.                     // Create final index for lambda expression use
  568.                     final int currentIndex = i;

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

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

  576.                     // Interpolate
  577.                     currentInterpolatedAdditional[i] =
  578.                             additionalStateInterpolator.interpolate(interpolationDate, currentValueSample).getValue();
  579.                 }

  581.                 interpolatedAdditional.put(entry.getKey(), currentInterpolatedAdditional);
  582.             }
  583.         }
  584.         return interpolatedAdditional;
  585.     }

  587.     /**
  588.      * Interpolate attitude.
  589.      * <p>
  590.      * If no attitude interpolator were defined, create a default inertial provider with respect to the output frame.
  591.      *
  592.      * @param interpolationDate interpolation date
  593.      * @param attitudes attitudes sample
  594.      * @param pvProvider position-velocity-acceleration coordinates provider
  595.      *
  596.      * @return interpolated attitude if attitude interpolator is present, default attitude otherwise
  597.      */
  598.     private FieldAttitude<KK> interpolateAttitude(final FieldAbsoluteDate<KK> interpolationDate,
  599.                                                   final List<FieldAttitude<KK>> attitudes,
  600.                                                   final FieldPVCoordinatesProvider<KK> pvProvider) {
  601.         if (attitudes.isEmpty()) {
  602.             final AttitudeProvider attitudeProvider = new FrameAlignedProvider(outputFrame);
  603.             return attitudeProvider.getAttitude(pvProvider, interpolationDate, outputFrame);
  604.         }
  605.         else {
  606.             return attitudeInterpolator.interpolate(interpolationDate, attitudes);
  607.         }
  608.     }
  609. }
Created with JaCoCo 0.8.11.202310140853