KeplerianPropagator.java

  1. /* Copyright 2002-2017 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.NotSerializableException;
  20. import java.io.Serializable;
  21. import java.util.ArrayList;
  22. import java.util.List;
  23. import java.util.SortedSet;

  25. import org.orekit.attitudes.Attitude;
  26. import org.orekit.attitudes.AttitudeProvider;
  27. import org.orekit.errors.OrekitException;
  28. import org.orekit.errors.OrekitInternalError;
  29. import org.orekit.orbits.Orbit;
  30. import org.orekit.orbits.OrbitType;
  31. import org.orekit.orbits.PositionAngle;
  32. import org.orekit.propagation.AdditionalStateProvider;
  33. import org.orekit.propagation.SpacecraftState;
  34. import org.orekit.time.AbsoluteDate;
  35. import org.orekit.utils.TimeSpanMap;

  37. /** Simple Keplerian orbit propagator.
  38.  * @see Orbit
  39.  * @author Guylaine Prat
  40.  */
  41. public class KeplerianPropagator extends AbstractAnalyticalPropagator implements Serializable {

  43.     /** Serializable UID. */
  44.     private static final long serialVersionUID = 20151117L;

  46.     /** Initial state. */
  47.     private SpacecraftState initialState;

  49.     /** All states. */
  50.     private transient TimeSpanMap<SpacecraftState> states;

  52.     /** Build a propagator from orbit only.
  53.      * <p>The central attraction coefficient μ is set to the same value used
  54.      * for the initial orbit definition. Mass and attitude provider are set to
  55.      * unspecified non-null arbitrary values.</p>
  56.      * @param initialOrbit initial orbit
  57.      * @exception OrekitException if initial attitude cannot be computed
  58.      */
  59.     public KeplerianPropagator(final Orbit initialOrbit)
  60.         throws OrekitException {
  61.         this(initialOrbit, DEFAULT_LAW, initialOrbit.getMu(), DEFAULT_MASS);
  62.     }

  64.     /** Build a propagator from orbit and central attraction coefficient μ.
  65.      * <p>Mass and attitude provider are set to unspecified non-null arbitrary values.</p>
  66.      * @param initialOrbit initial orbit
  67.      * @param mu central attraction coefficient (m³/s²)
  68.      * @exception OrekitException if initial attitude cannot be computed
  69.      */
  70.     public KeplerianPropagator(final Orbit initialOrbit, final double mu)
  71.         throws OrekitException {
  72.         this(initialOrbit, DEFAULT_LAW, mu, DEFAULT_MASS);
  73.     }

  75.     /** Build a propagator from orbit and attitude provider.
  76.      * <p>The central attraction coefficient μ is set to the same value
  77.      * used for the initial orbit definition. Mass is set to an unspecified
  78.      * non-null arbitrary value.</p>
  79.      * @param initialOrbit initial orbit
  80.      * @param attitudeProv  attitude provider
  81.      * @exception OrekitException if initial attitude cannot be computed
  82.      */
  83.     public KeplerianPropagator(final Orbit initialOrbit,
  84.                                final AttitudeProvider attitudeProv)
  85.         throws OrekitException {
  86.         this(initialOrbit, attitudeProv, initialOrbit.getMu(), DEFAULT_MASS);
  87.     }

  89.     /** Build a propagator from orbit, attitude provider and central attraction
  90.      * coefficient μ.
  91.      * <p>Mass is set to an unspecified non-null arbitrary value.</p>
  92.      * @param initialOrbit initial orbit
  93.      * @param attitudeProv attitude provider
  94.      * @param mu central attraction coefficient (m³/s²)
  95.      * @exception OrekitException if initial attitude cannot be computed
  96.      */
  97.     public KeplerianPropagator(final Orbit initialOrbit,
  98.                                final AttitudeProvider attitudeProv,
  99.                                final double mu)
  100.         throws OrekitException {
  101.         this(initialOrbit, attitudeProv, mu, DEFAULT_MASS);
  102.     }

  104.     /** Build propagator from orbit, attitude provider, central attraction
  105.      * coefficient μ and mass.
  106.      * @param initialOrbit initial orbit
  107.      * @param attitudeProv attitude provider
  108.      * @param mu central attraction coefficient (m³/s²)
  109.      * @param mass spacecraft mass (kg)
  110.      * @exception OrekitException if initial attitude cannot be computed
  111.      */
  112.     public KeplerianPropagator(final Orbit initialOrbit, final AttitudeProvider attitudeProv,
  113.                                final double mu, final double mass)
  114.         throws OrekitException {

  116.         super(attitudeProv);

  118.         // ensure the orbit use the specified mu and has no non-Keplerian derivatives
  119.         initialState = fixState(initialOrbit,
  120.                                 getAttitudeProvider().getAttitude(initialOrbit,
  121.                                                                   initialOrbit.getDate(),
  122.                                                                   initialOrbit.getFrame()),
  123.                                 mass, mu);
  124.         states = new TimeSpanMap<SpacecraftState>(initialState);
  125.         super.resetInitialState(initialState);

  127.     }

  129.     /** Fix state to use a specified mu and remove derivatives.
  130.      * <p>
  131.      * This ensures the propagation model (which is based on calling
  132.      * {@link Orbit#shiftedBy(double)}) is Keplerian only and uses a specified mu.
  133.      * </p>
  134.      * @param orbit orbit to fix
  135.      * @param attitude current attitude
  136.      * @param mass current mass
  137.      * @param mu gravity coefficient to use
  138.      * @return fixed orbit
  139.      */
  140.     private SpacecraftState fixState(final Orbit orbit, final Attitude attitude, final double mass,
  141.                                      final double mu) {
  142.         final OrbitType type = orbit.getType();
  143.         final double[] stateVector = new double[6];
  144.         type.mapOrbitToArray(orbit, PositionAngle.TRUE, stateVector, null);
  145.         final Orbit fixedOrbit = type.mapArrayToOrbit(stateVector, null, PositionAngle.TRUE,
  146.                                                       orbit.getDate(), mu, orbit.getFrame());
  147.         return new SpacecraftState(fixedOrbit, attitude, mass);
  148.     }

  150.     /** {@inheritDoc} */
  151.     public void resetInitialState(final SpacecraftState state)
  152.         throws OrekitException {

  154.         // ensure the orbit use the specified mu and has no non-Keplerian derivatives
  155.         final double mu = initialState == null ? state.getMu() : initialState.getMu();
  156.         final SpacecraftState fixedState = fixState(state.getOrbit(),
  157.                                                     state.getAttitude(),
  158.                                                     state.getMass(),
  159.                                                     mu);

  161.         initialState = fixedState;
  162.         states       = new TimeSpanMap<SpacecraftState>(initialState);
  163.         super.resetInitialState(fixedState);

  165.     }

  167.     /** {@inheritDoc} */
  168.     protected void resetIntermediateState(final SpacecraftState state, final boolean forward)
  169.         throws OrekitException {
  170.         if (forward) {
  171.             states.addValidAfter(state, state.getDate());
  172.         } else {
  173.             states.addValidBefore(state, state.getDate());
  174.         }
  175.     }

  177.     /** {@inheritDoc} */
  178.     protected Orbit propagateOrbit(final AbsoluteDate date)
  179.         throws OrekitException {

  181.         // propagate orbit
  182.         Orbit orbit = states.get(date).getOrbit();
  183.         do {
  184.             // we use a loop here to compensate for very small date shifts error
  185.             // that occur with long propagation time
  186.             orbit = orbit.shiftedBy(date.durationFrom(orbit.getDate()));
  187.         } while (!date.equals(orbit.getDate()));

  189.         return orbit;

  191.     }

  193.     /** {@inheritDoc}*/
  194.     protected double getMass(final AbsoluteDate date) {
  195.         return states.get(date).getMass();
  196.     }

  198.     /** Replace the instance with a data transfer object for serialization.
  199.      * @return data transfer object that will be serialized
  200.      * @exception NotSerializableException if an additional state provider is not serializable
  201.      */
  202.     private Object writeReplace() throws NotSerializableException {
  203.         try {

  205.             // managed states providers
  206.             final List<AdditionalStateProvider> serializableProviders = new ArrayList<AdditionalStateProvider>();
  207.             for (final AdditionalStateProvider provider : getAdditionalStateProviders()) {
  208.                 if (provider instanceof Serializable) {
  209.                     serializableProviders.add(provider);
  210.                 } else {
  211.                     throw new NotSerializableException(provider.getClass().getName());
  212.                 }
  213.             }

  215.             // states transitions
  216.             final AbsoluteDate[]    transitionDates;
  217.             final SpacecraftState[] allStates;
  218.             final SortedSet<TimeSpanMap.Transition<SpacecraftState>> transitions = states.getTransitions();
  219.             if (transitions.size() == 1  && transitions.first().getBefore() == transitions.first().getAfter()) {
  220.                 // the single entry is a dummy one, without a real transition
  221.                 // we ignore it completely
  222.                 transitionDates = null;
  223.                 allStates       = null;
  224.             } else {
  225.                 transitionDates = new AbsoluteDate[transitions.size()];
  226.                 allStates       = new SpacecraftState[transitions.size() + 1];
  227.                 int i = 0;
  228.                 for (final TimeSpanMap.Transition<SpacecraftState> transition : transitions) {
  229.                     if (i == 0) {
  230.                         // state before the first transition
  231.                         allStates[i] = transition.getBefore();
  232.                     }
  233.                     transitionDates[i] = transition.getDate();
  234.                     allStates[++i]     = transition.getAfter();
  235.                 }
  236.             }

  238.             return new DataTransferObject(getInitialState().getOrbit(), getAttitudeProvider(),
  239.                                           getInitialState().getMu(), getInitialState().getMass(),
  240.                                           transitionDates, allStates,
  241.                                           serializableProviders.toArray(new AdditionalStateProvider[serializableProviders.size()]));
  242.         } catch (OrekitException orekitException) {
  243.             // this should never happen
  244.             throw new OrekitInternalError(null);
  245.         }

  247.     }

  249.     /** Internal class used only for serialization. */
  250.     private static class DataTransferObject implements Serializable {

  252.         /** Serializable UID. */
  253.         private static final long serialVersionUID = 20151202L;

  255.         /** Initial orbit. */
  256.         private final Orbit orbit;

  258.         /** Attitude provider. */
  259.         private final AttitudeProvider attitudeProvider;

  261.         /** Central attraction coefficient (m³/s²). */
  262.         private final double mu;

  264.         /** Spacecraft mass (kg). */
  265.         private final double mass;

  267.         /** Transition dates (may be null). */
  268.         private final AbsoluteDate[] transitionDates;

  270.         /** States before and after transitions (may be null). */
  271.         private final SpacecraftState[] allStates;

  273.         /** Providers for additional states. */
  274.         private final AdditionalStateProvider[] providers;

  276.         /** Simple constructor.
  277.          * @param orbit initial orbit
  278.          * @param attitudeProvider attitude provider
  279.          * @param mu central attraction coefficient (m³/s²)
  280.          * @param mass initial spacecraft mass (kg)
  281.          * @param transitionDates transition dates (may be null)
  282.          * @param allStates states before and after transitions (may be null)
  283.          * @param providers providers for additional states
  284.          */
  285.         DataTransferObject(final Orbit orbit,
  286.                            final AttitudeProvider attitudeProvider,
  287.                            final double mu, final double mass,
  288.                            final AbsoluteDate[] transitionDates,
  289.                            final SpacecraftState[] allStates,
  290.                            final AdditionalStateProvider[] providers) {
  291.             this.orbit            = orbit;
  292.             this.attitudeProvider = attitudeProvider;
  293.             this.mu               = mu;
  294.             this.mass             = mass;
  295.             this.transitionDates  = transitionDates;
  296.             this.allStates        = allStates;
  297.             this.providers        = providers;
  298.         }

  300.         /** Replace the deserialized data transfer object with a {@link KeplerianPropagator}.
  301.          * @return replacement {@link KeplerianPropagator}
  302.          */
  303.         private Object readResolve() {
  304.             try {

  306.                 final KeplerianPropagator propagator =
  307.                                 new KeplerianPropagator(orbit, attitudeProvider, mu, mass);
  308.                 for (final AdditionalStateProvider provider : providers) {
  309.                     propagator.addAdditionalStateProvider(provider);
  310.                 }

  312.                 if (transitionDates != null) {
  313.                     // override the state transitions
  314.                     propagator.states = new TimeSpanMap<SpacecraftState>(allStates[0]);
  315.                     for (int i = 0; i < transitionDates.length; ++i) {
  316.                         propagator.states.addValidAfter(allStates[i + 1], transitionDates[i]);
  317.                     }
  318.                 }

  320.                 return propagator;

  322.             } catch (OrekitException oe) {
  323.                 throw new OrekitInternalError(oe);
  324.             }
  325.         }

  327.     }

  329. }
Created with JaCoCo 0.7.9.201702052155