KeplerianPropagator.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.NotSerializableException;
  20. import java.io.Serializable;
  21. import java.util.ArrayList;
  22. import java.util.Collections;
  23. import java.util.List;
  24. import java.util.Map;
  25. import java.util.SortedSet;

  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.orbits.Orbit;
  32. import org.orekit.orbits.OrbitType;
  33. import org.orekit.orbits.PositionAngle;
  34. import org.orekit.propagation.AdditionalStateProvider;
  35. import org.orekit.propagation.SpacecraftState;
  36. import org.orekit.time.AbsoluteDate;
  37. import org.orekit.utils.TimeSpanMap;

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

  45.     /** Serializable UID. */
  46.     private static final long serialVersionUID = 20151117L;

  48.     /** Initial state. */
  49.     private SpacecraftState initialState;

  51.     /** All states. */
  52.     private transient TimeSpanMap<SpacecraftState> states;

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

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

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

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

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

  118.         super(attitudeProv);

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

  129.     }

  131.     /** Fix state to use a specified mu and remove derivatives.
  132.      * <p>
  133.      * This ensures the propagation model (which is based on calling
  134.      * {@link Orbit#shiftedBy(double)}) is Keplerian only and uses a specified mu.
  135.      * </p>
  136.      * @param orbit orbit to fix
  137.      * @param attitude current attitude
  138.      * @param mass current mass
  139.      * @param mu gravity coefficient to use
  140.      * @param additionalStates additional states
  141.      * @return fixed orbit
  142.      */
  143.     private SpacecraftState fixState(final Orbit orbit, final Attitude attitude, final double mass,
  144.                                      final double mu, final Map<String, double[]> additionalStates) {
  145.         final OrbitType type = orbit.getType();
  146.         final double[] stateVector = new double[6];
  147.         type.mapOrbitToArray(orbit, PositionAngle.TRUE, stateVector, null);
  148.         final Orbit fixedOrbit = type.mapArrayToOrbit(stateVector, null, PositionAngle.TRUE,
  149.                                                       orbit.getDate(), mu, orbit.getFrame());
  150.         SpacecraftState fixedState = new SpacecraftState(fixedOrbit, attitude, mass);
  151.         for (final Map.Entry<String, double[]> entry : additionalStates.entrySet()) {
  152.             fixedState = fixedState.addAdditionalState(entry.getKey(), entry.getValue());
  153.         }
  154.         return fixedState;
  155.     }

  157.     /** {@inheritDoc} */
  158.     public void resetInitialState(final SpacecraftState state)
  159.         throws OrekitException {

  161.         // ensure the orbit use the specified mu and has no non-Keplerian derivatives
  162.         final double mu = initialState == null ? state.getMu() : initialState.getMu();
  163.         final SpacecraftState fixedState = fixState(state.getOrbit(),
  164.                                                     state.getAttitude(),
  165.                                                     state.getMass(),
  166.                                                     mu,
  167.                                                     state.getAdditionalStates());

  169.         initialState = fixedState;
  170.         states       = new TimeSpanMap<SpacecraftState>(initialState);
  171.         super.resetInitialState(fixedState);

  173.     }

  175.     /** {@inheritDoc} */
  176.     protected void resetIntermediateState(final SpacecraftState state, final boolean forward)
  177.         throws OrekitException {
  178.         if (forward) {
  179.             states.addValidAfter(state, state.getDate());
  180.         } else {
  181.             states.addValidBefore(state, state.getDate());
  182.         }
  183.     }

  185.     /** {@inheritDoc} */
  186.     protected Orbit propagateOrbit(final AbsoluteDate date)
  187.         throws OrekitException {

  189.         // propagate orbit
  190.         Orbit orbit = states.get(date).getOrbit();
  191.         do {
  192.             // we use a loop here to compensate for very small date shifts error
  193.             // that occur with long propagation time
  194.             orbit = orbit.shiftedBy(date.durationFrom(orbit.getDate()));
  195.         } while (!date.equals(orbit.getDate()));

  197.         return orbit;

  199.     }

  201.     /** {@inheritDoc}*/
  202.     protected double getMass(final AbsoluteDate date) {
  203.         return states.get(date).getMass();
  204.     }

  206.     /** Replace the instance with a data transfer object for serialization.
  207.      * @return data transfer object that will be serialized
  208.      * @exception NotSerializableException if an additional state provider is not serializable
  209.      */
  210.     private Object writeReplace() throws NotSerializableException {
  211.         try {

  213.             // managed states providers
  214.             final List<AdditionalStateProvider> serializableProviders = new ArrayList<AdditionalStateProvider>();
  215.             for (final AdditionalStateProvider provider : getAdditionalStateProviders()) {
  216.                 if (provider instanceof Serializable) {
  217.                     serializableProviders.add(provider);
  218.                 } else {
  219.                     throw new NotSerializableException(provider.getClass().getName());
  220.                 }
  221.             }

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

  246.             return new DataTransferObject(getInitialState().getOrbit(), getAttitudeProvider(),
  247.                                           getInitialState().getMu(), getInitialState().getMass(),
  248.                                           transitionDates, allStates,
  249.                                           serializableProviders.toArray(new AdditionalStateProvider[serializableProviders.size()]));
  250.         } catch (OrekitException orekitException) {
  251.             // this should never happen
  252.             throw new OrekitInternalError(null);
  253.         }

  255.     }

  257.     /** Internal class used only for serialization. */
  258.     private static class DataTransferObject implements Serializable {

  260.         /** Serializable UID. */
  261.         private static final long serialVersionUID = 20151202L;

  263.         /** Initial orbit. */
  264.         private final Orbit orbit;

  266.         /** Attitude provider. */
  267.         private final AttitudeProvider attitudeProvider;

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

  272.         /** Spacecraft mass (kg). */
  273.         private final double mass;

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

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

  281.         /** Providers for additional states. */
  282.         private final AdditionalStateProvider[] providers;

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

  308.         /** Replace the deserialized data transfer object with a {@link KeplerianPropagator}.
  309.          * @return replacement {@link KeplerianPropagator}
  310.          */
  311.         private Object readResolve() {
  312.             try {

  314.                 final KeplerianPropagator propagator =
  315.                                 new KeplerianPropagator(orbit, attitudeProvider, mu, mass);
  316.                 for (final AdditionalStateProvider provider : providers) {
  317.                     propagator.addAdditionalStateProvider(provider);
  318.                 }

  320.                 if (transitionDates != null) {
  321.                     // override the state transitions
  322.                     propagator.states = new TimeSpanMap<SpacecraftState>(allStates[0]);
  323.                     for (int i = 0; i < transitionDates.length; ++i) {
  324.                         propagator.states.addValidAfter(allStates[i + 1], transitionDates[i]);
  325.                     }
  326.                 }

  328.                 return propagator;

  330.             } catch (OrekitException oe) {
  331.                 throw new OrekitInternalError(oe);
  332.             }
  333.         }

  335.     }

  337. }
Created with JaCoCo 0.7.9.201702052155