Ephemeris.java

  1. /* Copyright 2002-2020 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.analytical;

  19. import java.io.Serializable;
  20. import java.util.List;
  21. import java.util.Set;
  22. import java.util.stream.Collectors;

  24. import org.hipparchus.exception.LocalizedCoreFormats;
  25. import org.hipparchus.exception.MathIllegalArgumentException;
  26. import org.hipparchus.util.FastMath;
  27. import org.orekit.annotation.DefaultDataContext;
  28. import org.orekit.attitudes.Attitude;
  29. import org.orekit.attitudes.AttitudeProvider;
  30. import org.orekit.data.DataContext;
  31. import org.orekit.errors.OrekitException;
  32. import org.orekit.errors.OrekitMessages;
  33. import org.orekit.frames.Frame;
  34. import org.orekit.orbits.Orbit;
  35. import org.orekit.propagation.BoundedPropagator;
  36. import org.orekit.propagation.Propagator;
  37. import org.orekit.propagation.SpacecraftState;
  38. import org.orekit.time.AbsoluteDate;
  39. import org.orekit.utils.ImmutableTimeStampedCache;
  40. import org.orekit.utils.PVCoordinatesProvider;
  41. import org.orekit.utils.TimeStampedPVCoordinates;

  43. /** This class is designed to accept and handle tabulated orbital entries.
  44.  * Tabulated entries are classified and then extrapolated in way to obtain
  45.  * continuous output, with accuracy and computation methods configured by the user.
  46.  *
  47.  * @author Fabien Maussion
  48.  * @author Véronique Pommier-Maurussane
  49.  * @author Luc Maisonobe
  50.  */
  51. public class Ephemeris extends AbstractAnalyticalPropagator implements BoundedPropagator {

  53.     /** Default extrapolation time threshold: 1ms.
  54.      * @since 9.0
  55.      **/
  56.     public static final double DEFAULT_EXTRAPOLATION_THRESHOLD_SEC = 1e-3;

  58.      /** First date in range. */
  59.     private final AbsoluteDate minDate;

  61.     /** Last date in range. */
  62.     private final AbsoluteDate maxDate;

  64.     /** The extrapolation threshold beyond which the propagation will fail. **/
  65.     private final double extrapolationThreshold;

  67.     /** Reference frame. */
  68.     private final Frame frame;

  70.     /** Names of the additional states. */
  71.     private final String[] additional;

  73.     /** Local PV Provider used for computing attitude. **/
  74.     private LocalPVProvider pvProvider;

  76.     /** Thread-safe cache. */
  77.     private final transient ImmutableTimeStampedCache<SpacecraftState> cache;

  79.     /** Constructor with tabulated states.
  80.      * <p>
  81.      * This constructor allows extrapolating outside of the states time span
  82.      * by up to the 1ms {@link #DEFAULT_EXTRAPOLATION_THRESHOLD_SEC default
  83.      * extrapolation threshold}.
  84.      * </p>
  85.      *
  86.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.
  87.      *
  88.      * @param states tabulates states
  89.      * @param interpolationPoints number of points to use in interpolation
  90.           * @exception MathIllegalArgumentException if the number of states is smaller than
  91.      * the number of points to use in interpolation
  92.      * @see #Ephemeris(List, int, double)
  93.      * @see #Ephemeris(List, int, double, AttitudeProvider)
  94.      */
  95.     @DefaultDataContext
  96.     public Ephemeris(final List<SpacecraftState> states, final int interpolationPoints)
  97.         throws MathIllegalArgumentException {
  98.         this(states, interpolationPoints, DEFAULT_EXTRAPOLATION_THRESHOLD_SEC);
  99.     }

  101.     /** Constructor with tabulated states.
  102.      *
  103.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.
  104.      *
  105.      * @param states tabulates states
  106.      * @param interpolationPoints number of points to use in interpolation
  107.      * @param extrapolationThreshold the largest time difference in seconds between
  108.      * the start or stop boundary of the ephemeris bounds to be doing extrapolation
  109.      * @exception MathIllegalArgumentException if the number of states is smaller than
  110.      * the number of points to use in interpolation
  111.      * @since 9.0
  112.      * @see #Ephemeris(List, int, double, AttitudeProvider)
  113.      */
  114.     @DefaultDataContext
  115.     public Ephemeris(final List<SpacecraftState> states, final int interpolationPoints,
  116.                      final double extrapolationThreshold)
  117.         throws MathIllegalArgumentException {
  118.         this(states, interpolationPoints, extrapolationThreshold,
  119.                 Propagator.getDefaultLaw(DataContext.getDefault().getFrames()));
  120.     }

  122.     /** Constructor with tabulated states.
  123.      * @param states tabulates states
  124.      * @param interpolationPoints number of points to use in interpolation
  125.      * @param extrapolationThreshold the largest time difference in seconds between
  126.      * the start or stop boundary of the ephemeris bounds to be doing extrapolation
  127.      * @param attitudeProvider attitude law to use.
  128.      * @exception MathIllegalArgumentException if the number of states is smaller than
  129.      * the number of points to use in interpolation
  130.      * @since 10.1
  131.      */
  132.     public Ephemeris(final List<SpacecraftState> states,
  133.                      final int interpolationPoints,
  134.                      final double extrapolationThreshold,
  135.                      final AttitudeProvider attitudeProvider)
  136.         throws MathIllegalArgumentException {

  138.         super(attitudeProvider);

  140.         if (states.size() < interpolationPoints) {
  141.             throw new MathIllegalArgumentException(LocalizedCoreFormats.INSUFFICIENT_DIMENSION,
  142.                                                    states.size(), interpolationPoints);
  143.         }

  145.         final SpacecraftState s0 = states.get(0);
  146.         minDate = s0.getDate();
  147.         maxDate = states.get(states.size() - 1).getDate();
  148.         frame = s0.getFrame();

  150.         final Set<String> names0 = s0.getAdditionalStates().keySet();
  151.         additional = names0.toArray(new String[names0.size()]);

  153.         // check all states handle the same additional states
  154.         for (final SpacecraftState state : states) {
  155.             s0.ensureCompatibleAdditionalStates(state);
  156.         }

  158.         pvProvider = new LocalPVProvider(states, interpolationPoints, extrapolationThreshold);

  160.         // user needs to explicitly set attitude provider if they want to use one
  161.         setAttitudeProvider(null);

  163.         // set up cache
  164.         cache = new ImmutableTimeStampedCache<SpacecraftState>(interpolationPoints, states);

  166.         this.extrapolationThreshold = extrapolationThreshold;
  167.     }

  169.     /** Get the first date of the range.
  170.      * @return the first date of the range
  171.      */
  172.     public AbsoluteDate getMinDate() {
  173.         return minDate;
  174.     }

  176.     /** Get the last date of the range.
  177.      * @return the last date of the range
  178.      */
  179.     public AbsoluteDate getMaxDate() {
  180.         return maxDate;
  181.     }

  183.     /** Get the maximum timespan outside of the stored ephemeris that is allowed
  184.      * for extrapolation.
  185.      * @return the extrapolation threshold in seconds
  186.      */
  187.     public double getExtrapolationThreshold() {
  188.         return extrapolationThreshold;
  189.     }

  191.     @Override
  192.     public Frame getFrame() {
  193.         return frame;
  194.     }

  196.     @Override
  197.     /** {@inheritDoc} */
  198.     public SpacecraftState basicPropagate(final AbsoluteDate date) {
  199.         final SpacecraftState evaluatedState;

  201.         final AbsoluteDate central;
  202.         if (date.compareTo(minDate) < 0 && FastMath.abs(date.durationFrom(minDate)) <= extrapolationThreshold) {
  203.             // avoid TimeStampedCacheException as we are still within the tolerance before minDate
  204.             central = minDate;
  205.         } else if (date.compareTo(maxDate) > 0 && FastMath.abs(date.durationFrom(maxDate)) <= extrapolationThreshold) {
  206.             // avoid TimeStampedCacheException as we are still within the tolerance after maxDate
  207.             central = maxDate;
  208.         } else {
  209.             central = date;
  210.         }
  211.         final List<SpacecraftState> neighbors = cache.getNeighbors(central).collect(Collectors.toList());
  212.         evaluatedState = neighbors.get(0).interpolate(date, neighbors);

  214.         final AttitudeProvider attitudeProvider = getAttitudeProvider();

  216.         if (attitudeProvider == null) {
  217.             return evaluatedState;
  218.         } else {
  219.             pvProvider.setCurrentState(evaluatedState);
  220.             final Attitude calculatedAttitude = attitudeProvider.getAttitude(pvProvider, date,
  221.                                                                              evaluatedState.getFrame());

  223.             // Verify if orbit is defined
  224.             if (evaluatedState.isOrbitDefined()) {
  225.                 return new SpacecraftState(evaluatedState.getOrbit(), calculatedAttitude,
  226.                                            evaluatedState.getMass(), evaluatedState.getAdditionalStates());
  227.             } else {
  228.                 return new SpacecraftState(evaluatedState.getAbsPVA(), calculatedAttitude,
  229.                                            evaluatedState.getMass(),  evaluatedState.getAdditionalStates());
  230.             }

  232.         }
  233.     }

  235.     /** {@inheritDoc} */
  236.     protected Orbit propagateOrbit(final AbsoluteDate date) {
  237.         return basicPropagate(date).getOrbit();
  238.     }

  240.     /** {@inheritDoc} */
  241.     protected double getMass(final AbsoluteDate date) {
  242.         return basicPropagate(date).getMass();
  243.     }

  245.     /** {@inheritDoc} */
  246.     public TimeStampedPVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame f) {
  247.         return propagate(date).getPVCoordinates(f);
  248.     }

  250.     /** Try (and fail) to reset the initial state.
  251.      * <p>
  252.      * This method always throws an exception, as ephemerides cannot be reset.
  253.      * </p>
  254.      * @param state new initial state to consider
  255.      */
  256.     public void resetInitialState(final SpacecraftState state) {
  257.         throw new OrekitException(OrekitMessages.NON_RESETABLE_STATE);
  258.     }

  260.     /** {@inheritDoc} */
  261.     protected void resetIntermediateState(final SpacecraftState state, final boolean forward) {
  262.         throw new OrekitException(OrekitMessages.NON_RESETABLE_STATE);
  263.     }

  265.     /** {@inheritDoc} */
  266.     public SpacecraftState getInitialState() {
  267.         return basicPropagate(getMinDate());
  268.     }

  270.     /** {@inheritDoc} */
  271.     @Override
  272.     public boolean isAdditionalStateManaged(final String name) {

  274.         // the additional state may be managed by a specific provider in the base class
  275.         if (super.isAdditionalStateManaged(name)) {
  276.             return true;
  277.         }

  279.         // the additional state may be managed in the states sample
  280.         for (final String a : additional) {
  281.             if (a.equals(name)) {
  282.                 return true;
  283.             }
  284.         }

  286.         return false;

  288.     }

  290.     /** {@inheritDoc} */
  291.     @Override
  292.     public String[] getManagedAdditionalStates() {
  293.         final String[] upperManaged = super.getManagedAdditionalStates();
  294.         final String[] managed = new String[upperManaged.length + additional.length];
  295.         System.arraycopy(upperManaged, 0, managed, 0, upperManaged.length);
  296.         System.arraycopy(additional, 0, managed, upperManaged.length, additional.length);
  297.         return managed;
  298.     }

  300.     /** Internal PVCoordinatesProvider for attitude computation. */
  301.     private static class LocalPVProvider implements PVCoordinatesProvider, Serializable {

  303.         /** Serializable UID. */
  304.         private static final long serialVersionUID = 20160115L;

  306.         /** Current state. */
  307.         private SpacecraftState currentState;

  309.         /** List of spacecraft states. */
  310.         private List<SpacecraftState> states;

  312.         /** Interpolation points number. */
  313.         private int interpolationPoints;

  315.         /** Extrapolation threshold. */
  316.         private double extrapolationThreshold;

  318.         /** Constructor.
  319.          * @param states list of spacecraft states
  320.          * @param interpolationPoints interpolation points number
  321.          * @param extrapolationThreshold extrapolation threshold value
  322.          */
  323.         LocalPVProvider(final List<SpacecraftState> states, final int interpolationPoints,
  324.                      final double extrapolationThreshold) {

  326.             this.states = states;
  327.             this.interpolationPoints = interpolationPoints;
  328.             this.extrapolationThreshold = extrapolationThreshold;
  329.         }

  331.         /** Get the current state.
  332.          * @return current state
  333.          */
  334.         public SpacecraftState getCurrentState() {
  335.             return currentState;
  336.         }

  338.         /** Set the current state.
  339.          * @param state state to set
  340.          */
  341.         public void setCurrentState(final SpacecraftState state) {
  342.             this.currentState = state;
  343.         }

  345.         /** {@inheritDoc} */
  346.         public TimeStampedPVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame f) {
  347.             final double dt = getCurrentState().getDate().durationFrom(date);
  348.             final double closeEnoughTimeInSec = 1e-9;

  350.             if (FastMath.abs(dt) > closeEnoughTimeInSec) {

  352.                 // used in case of attitude transition, the attitude computed is not at the current date.
  353.                 final Ephemeris ephemeris = new Ephemeris(states, interpolationPoints, extrapolationThreshold, null);
  354.                 return ephemeris.getPVCoordinates(date, f);
  355.             }

  357.             return currentState.getPVCoordinates(f);

  359.         }

  361.     }

  363. }
Created with JaCoCo 0.8.6.202009150832