KeplerianPropagator.java

  1. /* Copyright 2002-2019 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.      */
  60.     public KeplerianPropagator(final Orbit initialOrbit) {
  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.      */
  69.     public KeplerianPropagator(final Orbit initialOrbit, final double mu) {
  70.         this(initialOrbit, DEFAULT_LAW, mu, DEFAULT_MASS);
  71.     }

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

  85.     /** Build a propagator from orbit, attitude provider and central attraction
  86.      * coefficient μ.
  87.      * <p>Mass is set to an unspecified non-null arbitrary value.</p>
  88.      * @param initialOrbit initial orbit
  89.      * @param attitudeProv attitude provider
  90.      * @param mu central attraction coefficient (m³/s²)
  91.      */
  92.     public KeplerianPropagator(final Orbit initialOrbit,
  93.                                final AttitudeProvider attitudeProv,
  94.                                final double mu) {
  95.         this(initialOrbit, attitudeProv, mu, DEFAULT_MASS);
  96.     }

  98.     /** Build propagator from orbit, attitude provider, central attraction
  99.      * coefficient μ and mass.
  100.      * @param initialOrbit initial orbit
  101.      * @param attitudeProv attitude provider
  102.      * @param mu central attraction coefficient (m³/s²)
  103.      * @param mass spacecraft mass (kg)
  104.      */
  105.     public KeplerianPropagator(final Orbit initialOrbit, final AttitudeProvider attitudeProv,
  106.                                final double mu, final double mass) {

  108.         super(attitudeProv);

  110.         // ensure the orbit use the specified mu and has no non-Keplerian derivatives
  111.         initialState = fixState(initialOrbit,
  112.                                 getAttitudeProvider().getAttitude(initialOrbit,
  113.                                                                   initialOrbit.getDate(),
  114.                                                                   initialOrbit.getFrame()),
  115.                                 mass, mu, Collections.emptyMap());
  116.         states = new TimeSpanMap<SpacecraftState>(initialState);
  117.         super.resetInitialState(initialState);

  119.     }

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

  147.     /** {@inheritDoc} */
  148.     public void resetInitialState(final SpacecraftState state) {

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

  158.         initialState = fixedState;
  159.         states       = new TimeSpanMap<SpacecraftState>(initialState);
  160.         super.resetInitialState(fixedState);

  162.     }

  164.     /** {@inheritDoc} */
  165.     protected void resetIntermediateState(final SpacecraftState state, final boolean forward) {
  166.         if (forward) {
  167.             states.addValidAfter(state, state.getDate());
  168.         } else {
  169.             states.addValidBefore(state, state.getDate());
  170.         }
  171.     }

  173.     /** {@inheritDoc} */
  174.     protected Orbit propagateOrbit(final AbsoluteDate date) {

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

  184.         return orbit;

  186.     }

  188.     /** {@inheritDoc}*/
  189.     protected double getMass(final AbsoluteDate date) {
  190.         return states.get(date).getMass();
  191.     }

  193.     /** Replace the instance with a data transfer object for serialization.
  194.      * @return data transfer object that will be serialized
  195.      * @exception NotSerializableException if an additional state provider is not serializable
  196.      */
  197.     private Object writeReplace() throws NotSerializableException {
  198.         try {

  200.             // managed states providers
  201.             final List<AdditionalStateProvider> serializableProviders = new ArrayList<AdditionalStateProvider>();
  202.             for (final AdditionalStateProvider provider : getAdditionalStateProviders()) {
  203.                 if (provider instanceof Serializable) {
  204.                     serializableProviders.add(provider);
  205.                 } else {
  206.                     throw new NotSerializableException(provider.getClass().getName());
  207.                 }
  208.             }

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

  233.             return new DataTransferObject(getInitialState().getOrbit(), getAttitudeProvider(),
  234.                                           getInitialState().getMu(), getInitialState().getMass(),
  235.                                           transitionDates, allStates,
  236.                                           serializableProviders.toArray(new AdditionalStateProvider[serializableProviders.size()]));
  237.         } catch (OrekitException orekitException) {
  238.             // this should never happen
  239.             throw new OrekitInternalError(null);
  240.         }

  242.     }

  244.     /** Internal class used only for serialization. */
  245.     private static class DataTransferObject implements Serializable {

  247.         /** Serializable UID. */
  248.         private static final long serialVersionUID = 20151202L;

  250.         /** Initial orbit. */
  251.         private final Orbit orbit;

  253.         /** Attitude provider. */
  254.         private final AttitudeProvider attitudeProvider;

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

  259.         /** Spacecraft mass (kg). */
  260.         private final double mass;

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

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

  268.         /** Providers for additional states. */
  269.         private final AdditionalStateProvider[] providers;

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

  295.         /** Replace the deserialized data transfer object with a {@link KeplerianPropagator}.
  296.          * @return replacement {@link KeplerianPropagator}
  297.          */
  298.         private Object readResolve() {
  299.             try {

  301.                 final KeplerianPropagator propagator =
  302.                                 new KeplerianPropagator(orbit, attitudeProvider, mu, mass);
  303.                 for (final AdditionalStateProvider provider : providers) {
  304.                     propagator.addAdditionalStateProvider(provider);
  305.                 }

  307.                 if (transitionDates != null) {
  308.                     // override the state transitions
  309.                     propagator.states = new TimeSpanMap<SpacecraftState>(allStates[0]);
  310.                     for (int i = 0; i < transitionDates.length; ++i) {
  311.                         propagator.states.addValidAfter(allStates[i + 1], transitionDates[i]);
  312.                     }
  313.                 }

  315.                 return propagator;

  317.             } catch (OrekitException oe) {
  318.                 throw new OrekitInternalError(oe);
  319.             }
  320.         }

  322.     }

  324. }
Created with JaCoCo 0.8.2.201808211720