Ephemeris.java

  1. /* Copyright 2002-2018 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (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.attitudes.Attitude;
  28. import org.orekit.attitudes.AttitudeProvider;
  29. import org.orekit.errors.OrekitException;
  30. import org.orekit.errors.OrekitInternalError;
  31. import org.orekit.errors.OrekitMessages;
  32. import org.orekit.frames.Frame;
  33. import org.orekit.orbits.Orbit;
  34. import org.orekit.propagation.BoundedPropagator;
  35. import org.orekit.propagation.SpacecraftState;
  36. import org.orekit.time.AbsoluteDate;
  37. import org.orekit.utils.ImmutableTimeStampedCache;
  38. import org.orekit.utils.PVCoordinatesProvider;
  39. import org.orekit.utils.TimeStampedPVCoordinates;

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

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

  56.     /** Serializable UID. */
  57.     private static final long serialVersionUID = 20170606L;

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

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

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

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

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

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

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

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

  98.     /** Constructor with tabulated states.
  99.      * @param states tabulates states
  100.      * @param interpolationPoints number of points to use in interpolation
  101.      * @param extrapolationThreshold the largest time difference in seconds between
  102.      * the start or stop boundary of the ephemeris bounds to be doing extrapolation
  103.      * @exception OrekitException if some states have incompatible additional states
  104.      * @exception MathIllegalArgumentException if the number of states is smaller than
  105.      * the number of points to use in interpolation
  106.      * @since 9.0
  107.      */
  108.     public Ephemeris(final List<SpacecraftState> states, final int interpolationPoints,
  109.                      final double extrapolationThreshold)
  110.         throws OrekitException, MathIllegalArgumentException {

  112.         super(DEFAULT_LAW);

  114.         if (states.size() < interpolationPoints) {
  115.             throw new MathIllegalArgumentException(LocalizedCoreFormats.INSUFFICIENT_DIMENSION,
  116.                                                    states.size(), interpolationPoints);
  117.         }

  119.         final SpacecraftState s0 = states.get(0);
  120.         minDate = s0.getDate();
  121.         maxDate = states.get(states.size() - 1).getDate();
  122.         frame = s0.getFrame();

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

  127.         // check all states handle the same additional states
  128.         for (final SpacecraftState state : states) {
  129.             s0.ensureCompatibleAdditionalStates(state);
  130.         }

  132.         pvProvider = new LocalPVProvider();

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

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

  140.         this.extrapolationThreshold = extrapolationThreshold;
  141.     }

  143.     /** Get the first date of the range.
  144.      * @return the first date of the range
  145.      */
  146.     public AbsoluteDate getMinDate() {
  147.         return minDate;
  148.     }

  150.     /** Get the last date of the range.
  151.      * @return the last date of the range
  152.      */
  153.     public AbsoluteDate getMaxDate() {
  154.         return maxDate;
  155.     }

  157.     /** Get the maximum timespan outside of the stored ephemeris that is allowed
  158.      * for extrapolation.
  159.      * @return the extrapolation threshold in seconds
  160.      */
  161.     public double getExtrapolationThreshold() {
  162.         return extrapolationThreshold;
  163.     }

  165.     @Override
  166.     public Frame getFrame() {
  167.         return frame;
  168.     }

  170.     @Override
  171.     /** {@inheritDoc} */
  172.     public SpacecraftState basicPropagate(final AbsoluteDate date) throws OrekitException {
  173.         final SpacecraftState evaluatedState;

  175.         final AbsoluteDate central;
  176.         if (date.compareTo(minDate) < 0 && FastMath.abs(date.durationFrom(minDate)) <= extrapolationThreshold) {
  177.             // avoid TimeStampedCacheException as we are still within the tolerance before minDate
  178.             central = minDate;
  179.         } else if (date.compareTo(maxDate) > 0 && FastMath.abs(date.durationFrom(maxDate)) <= extrapolationThreshold) {
  180.             // avoid TimeStampedCacheException as we are still within the tolerance after maxDate
  181.             central = maxDate;
  182.         } else {
  183.             central = date;
  184.         }
  185.         final List<SpacecraftState> neighbors = cache.getNeighbors(central).collect(Collectors.toList());
  186.         evaluatedState = neighbors.get(0).interpolate(date, neighbors);

  188.         final AttitudeProvider attitudeProvider = getAttitudeProvider();

  190.         if (attitudeProvider == null) {
  191.             return evaluatedState;
  192.         } else {
  193.             pvProvider.setCurrentState(evaluatedState);
  194.             final Attitude calculatedAttitude = attitudeProvider.getAttitude(pvProvider, date,
  195.                                                                              evaluatedState.getFrame());
  196.             return new SpacecraftState(evaluatedState.getOrbit(), calculatedAttitude, evaluatedState.getMass());
  197.         }
  198.     }

  200.     /** {@inheritDoc} */
  201.     protected Orbit propagateOrbit(final AbsoluteDate date) throws OrekitException {
  202.         return basicPropagate(date).getOrbit();
  203.     }

  205.     /** {@inheritDoc} */
  206.     protected double getMass(final AbsoluteDate date) throws OrekitException {
  207.         return basicPropagate(date).getMass();
  208.     }

  210.     /** {@inheritDoc} */
  211.     public TimeStampedPVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame f)
  212.         throws OrekitException {
  213.         return propagate(date).getPVCoordinates(f);
  214.     }

  216.     /** Try (and fail) to reset the initial state.
  217.      * <p>
  218.      * This method always throws an exception, as ephemerides cannot be reset.
  219.      * </p>
  220.      * @param state new initial state to consider
  221.      * @exception OrekitException always thrown as ephemerides cannot be reset
  222.      */
  223.     public void resetInitialState(final SpacecraftState state)
  224.         throws OrekitException {
  225.         throw new OrekitException(OrekitMessages.NON_RESETABLE_STATE);
  226.     }

  228.     /** {@inheritDoc} */
  229.     protected void resetIntermediateState(final SpacecraftState state, final boolean forward)
  230.         throws OrekitException {
  231.         throw new OrekitException(OrekitMessages.NON_RESETABLE_STATE);
  232.     }

  234.     /** {@inheritDoc} */
  235.     public SpacecraftState getInitialState() throws OrekitException {
  236.         return basicPropagate(getMinDate());
  237.     }

  239.     /** {@inheritDoc} */
  240.     @Override
  241.     public boolean isAdditionalStateManaged(final String name) {

  243.         // the additional state may be managed by a specific provider in the base class
  244.         if (super.isAdditionalStateManaged(name)) {
  245.             return true;
  246.         }

  248.         // the additional state may be managed in the states sample
  249.         for (final String a : additional) {
  250.             if (a.equals(name)) {
  251.                 return true;
  252.             }
  253.         }

  255.         return false;

  257.     }

  259.     /** {@inheritDoc} */
  260.     @Override
  261.     public String[] getManagedAdditionalStates() {
  262.         final String[] upperManaged = super.getManagedAdditionalStates();
  263.         final String[] managed = new String[upperManaged.length + additional.length];
  264.         System.arraycopy(upperManaged, 0, managed, 0, upperManaged.length);
  265.         System.arraycopy(additional, 0, managed, upperManaged.length, additional.length);
  266.         return managed;
  267.     }

  269.     /** Replace the instance with a data transfer object for serialization.
  270.      * <p>
  271.      * This intermediate class serializes only the data needed for generation,
  272.      * but does <em>not</em> serializes the cache itself (in fact the cache is
  273.      * not serializable).
  274.      * </p>
  275.      * @return data transfer object that will be serialized
  276.      */
  277.     private Object writeReplace() {
  278.         return new DataTransferObject(cache.getAll(), cache.getNeighborsSize(), extrapolationThreshold);
  279.     }

  281.     /** Internal class used only for serialization. */
  282.     private static class DataTransferObject implements Serializable {

  284.         /** Serializable UID. */
  285.         private static final long serialVersionUID = 20170606L;

  287.         /** Tabulates states. */
  288.         private final List<SpacecraftState> states;

  290.         /** Number of points to use in interpolation. */
  291.         private final int interpolationPoints;

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

  296.         /** Simple constructor.
  297.          * @param states tabulates states
  298.          * @param interpolationPoints number of points to use in interpolation
  299.          * @param extrapolationThreshold extrapolation threshold beyond which the propagation will fail
  300.          */
  301.         private DataTransferObject(final List<SpacecraftState> states, final int interpolationPoints,
  302.                                    final double extrapolationThreshold) {
  303.             this.states                 = states;
  304.             this.interpolationPoints    = interpolationPoints;
  305.             this.extrapolationThreshold = extrapolationThreshold;
  306.         }

  308.         /** Replace the deserialized data transfer object with a
  309.          * {@link Ephemeris}.
  310.          * @return replacement {@link Ephemeris}
  311.          */
  312.         private Object readResolve() {
  313.             try {
  314.                 // build a new provider, with an empty cache
  315.                 return new Ephemeris(states, interpolationPoints, extrapolationThreshold);
  316.             } catch (OrekitException oe) {
  317.                 // this should never happen
  318.                 throw new OrekitInternalError(oe);
  319.             }
  320.         }

  322.     }

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

  327.         /** Serializable UID. */
  328.         private static final long serialVersionUID = 20160115L;

  330.         /** Current state. */
  331.         private SpacecraftState currentState;

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

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

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

  353.             if (FastMath.abs(dt) > closeEnoughTimeInSec) {
  354.                 throw new OrekitException(LocalizedCoreFormats.OUT_OF_RANGE_SIMPLE, FastMath.abs(dt), 0.0,
  355.                                           closeEnoughTimeInSec);
  356.             }

  358.             return getCurrentState().getPVCoordinates(f);

  360.         }

  362.     }

  364. }
Created with JaCoCo 0.7.9.201702052155