Ephemeris.java

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

  23. import org.apache.commons.math3.exception.MathIllegalArgumentException;
  24. import org.apache.commons.math3.exception.OutOfRangeException;
  25. import org.apache.commons.math3.exception.util.LocalizedFormats;
  26. import org.apache.commons.math3.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.errors.PropagationException;
  33. import org.orekit.frames.Frame;
  34. import org.orekit.orbits.Orbit;
  35. import org.orekit.propagation.BoundedPropagator;
  36. import org.orekit.propagation.SpacecraftState;
  37. import org.orekit.time.AbsoluteDate;
  38. import org.orekit.utils.ImmutableTimeStampedCache;
  39. import org.orekit.utils.TimeStampedPVCoordinates;
  40. import org.orekit.utils.PVCoordinatesProvider;

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

  52.     /** Serializable UID. */
  53.     private static final long serialVersionUID = 20151022L;

  55.      /** First date in range. */
  56.     private final AbsoluteDate minDate;

  58.     /** Last date in range. */
  59.     private final AbsoluteDate maxDate;

  61.     /** Reference frame. */
  62.     private final Frame frame;

  64.     /** Names of the additional states. */
  65.     private final String[] additional;

  67.     /** Local PV Provider used for computing attitude. **/
  68.     private LocalPVProvider pvProvider;

  70.     /** Thread-safe cache. */
  71.     private final transient ImmutableTimeStampedCache<SpacecraftState> cache;

  73.     /** Constructor with tabulated states.
  74.      * @param states tabulates states
  75.      * @param interpolationPoints number of points to use in interpolation
  76.      * @exception OrekitException if some states have incompatible additional states
  77.      * @exception MathIllegalArgumentException if the number of states is smaller than
  78.      * the number of points to use in interpolation
  79.      */
  80.     public Ephemeris(final List<SpacecraftState> states, final int interpolationPoints)
  81.         throws OrekitException, MathIllegalArgumentException {

  83.         super(DEFAULT_LAW);

  85.         if (states.size() < interpolationPoints) {
  86.             throw new MathIllegalArgumentException(LocalizedFormats.INSUFFICIENT_DIMENSION,
  87.                                                    states.size(), interpolationPoints);
  88.         }

  90.         final SpacecraftState s0 = states.get(0);
  91.         minDate = s0.getDate();
  92.         maxDate = states.get(states.size() - 1).getDate();
  93.         frame = s0.getFrame();

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

  98.         // check all states handle the same additional states
  99.         for (final SpacecraftState state : states) {
  100.             s0.ensureCompatibleAdditionalStates(state);
  101.         }

  103.         pvProvider = new LocalPVProvider();

  105.         //User needs to explicitly set attitude provider if they want to use one
  106.         this.setAttitudeProvider(null);

  108.         // set up cache
  109.         cache = new ImmutableTimeStampedCache<SpacecraftState>(interpolationPoints, states);
  110.     }

  112.     /** Get the first date of the range.
  113.      * @return the first date of the range
  114.      */
  115.     public AbsoluteDate getMinDate() {
  116.         return minDate;
  117.     }

  119.     /** Get the last date of the range.
  120.      * @return the last date of the range
  121.      */
  122.     public AbsoluteDate getMaxDate() {
  123.         return maxDate;
  124.     }

  126.     @Override
  127.     public Frame getFrame() {
  128.         return this.frame;
  129.     }

  131.     @Override
  132.     /** {@inheritDoc} */
  133.     public SpacecraftState basicPropagate(final AbsoluteDate date) throws PropagationException {
  134.         try {
  135.             final List<SpacecraftState> neighbors = cache.getNeighbors(date);
  136.             final SpacecraftState interpolatedState = neighbors.get(0).interpolate(date, neighbors);

  138.             final AttitudeProvider attitudeProvider = this.getAttitudeProvider();

  140.             if (attitudeProvider == null) {
  141.                 return interpolatedState;
  142.             }
  143.             else {
  144.                 pvProvider.setCurrentState(interpolatedState);
  145.                 final Attitude calculatedAttitude = attitudeProvider.getAttitude(pvProvider, date, interpolatedState.getFrame());
  146.                 return new SpacecraftState(interpolatedState.getOrbit(), calculatedAttitude, interpolatedState.getMass());
  147.             }

  149.         } catch (OrekitException tce) {
  150.             throw new PropagationException(tce);
  151.         }
  152.     }

  154.     /** {@inheritDoc} */
  155.     protected Orbit propagateOrbit(final AbsoluteDate date) throws PropagationException {
  156.         return basicPropagate(date).getOrbit();
  157.     }

  159.     /** {@inheritDoc} */
  160.     protected double getMass(final AbsoluteDate date) throws PropagationException {
  161.         return basicPropagate(date).getMass();
  162.     }

  164.     /** {@inheritDoc} */
  165.     public TimeStampedPVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame f)
  166.         throws OrekitException {
  167.         return propagate(date).getPVCoordinates(f);
  168.     }

  170.     /** Try (and fail) to reset the initial state.
  171.      * <p>
  172.      * This method always throws an exception, as ephemerides cannot be reset.
  173.      * </p>
  174.      * @param state new initial state to consider
  175.      * @exception PropagationException always thrown as ephemerides cannot be reset
  176.      */
  177.     public void resetInitialState(final SpacecraftState state)
  178.         throws PropagationException {
  179.         throw new PropagationException(OrekitMessages.NON_RESETABLE_STATE);
  180.     }

  182.     /** {@inheritDoc} */
  183.     protected void resetIntermediateState(final SpacecraftState state, final boolean forward)
  184.         throws PropagationException {
  185.         throw new PropagationException(OrekitMessages.NON_RESETABLE_STATE);
  186.     }

  188.     /** {@inheritDoc} */
  189.     public SpacecraftState getInitialState() throws PropagationException {
  190.         return basicPropagate(getMinDate());
  191.     }

  193.     /** {@inheritDoc} */
  194.     @Override
  195.     public boolean isAdditionalStateManaged(final String name) {

  197.         // the additional state may be managed by a specific provider in the base class
  198.         if (super.isAdditionalStateManaged(name)) {
  199.             return true;
  200.         }

  202.         // the additional state may be managed in the states sample
  203.         for (final String a : additional) {
  204.             if (a.equals(name)) {
  205.                 return true;
  206.             }
  207.         }

  209.         return false;

  211.     }

  213.     /** {@inheritDoc} */
  214.     @Override
  215.     public String[] getManagedAdditionalStates() {
  216.         final String[] upperManaged = super.getManagedAdditionalStates();
  217.         final String[] managed = new String[upperManaged.length + additional.length];
  218.         System.arraycopy(upperManaged, 0, managed, 0, upperManaged.length);
  219.         System.arraycopy(additional, 0, managed, upperManaged.length, additional.length);
  220.         return managed;
  221.     }

  223.     /** Replace the instance with a data transfer object for serialization.
  224.      * <p>
  225.      * This intermediate class serializes only the data needed for generation,
  226.      * but does <em>not</em> serializes the cache itself (in fact the cache is
  227.      * not serializable).
  228.      * </p>
  229.      * @return data transfer object that will be serialized
  230.      */
  231.     private Object writeReplace() {
  232.         return new DataTransferObject(cache.getAll(), cache.getNeighborsSize());
  233.     }

  235.     /** Internal class used only for serialization. */
  236.     private static class DataTransferObject implements Serializable {

  238.         /** Serializable UID. */
  239.         private static final long serialVersionUID = -8479036196711159270L;

  241.         /** Tabulates states. */
  242.         private final List<SpacecraftState> states;

  244.         /** Number of points to use in interpolation. */
  245.         private final int interpolationPoints;

  247.         /** Simple constructor.
  248.          * @param states tabulates states
  249.          * @param interpolationPoints number of points to use in interpolation
  250.          */
  251.         private DataTransferObject(final List<SpacecraftState> states, final int interpolationPoints) {
  252.             this.states              = states;
  253.             this.interpolationPoints = interpolationPoints;
  254.         }

  256.         /** Replace the deserialized data transfer object with a {@link Ephemeris}.
  257.          * @return replacement {@link Ephemeris}
  258.          */
  259.         private Object readResolve() {
  260.             try {
  261.                 // build a new provider, with an empty cache
  262.                 return new Ephemeris(states, interpolationPoints);
  263.             } catch (OrekitException oe) {
  264.                 // this should never happen
  265.                 throw new OrekitInternalError(oe);
  266.             }
  267.         }

  269.     }

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

  274.         /** Serializable UID. */
  275.         private static final long serialVersionUID = 20160115L;

  277.         /** Current state. */
  278.         private SpacecraftState currentState;

  280.         /** Get the current state.
  281.          * @return current state
  282.          */
  283.         public SpacecraftState getCurrentState() {
  284.             return currentState;
  285.         }

  287.         /** Set the current state.
  288.          * @param state state to set
  289.          */
  290.         public void setCurrentState(final SpacecraftState state) {
  291.             this.currentState = state;
  292.         }

  294.         /** {@inheritDoc} */
  295.         public TimeStampedPVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame f)
  296.             throws OrekitException {
  297.             final double dt = this.getCurrentState().getDate().durationFrom(date);
  298.             final double closeEnoughTimeInSec = 1e-9;

  300.             if (FastMath.abs(dt) > closeEnoughTimeInSec) {
  301.                 throw new OrekitException(new OutOfRangeException(new Double(FastMath.abs(dt)), 0.0, closeEnoughTimeInSec));
  302.             }

  304.             return this.getCurrentState().getPVCoordinates(f);

  306.         }

  308.     }


  311. }
Created with JaCoCo 0.7.4.201502262128