KeplerianPropagator.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.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.AttitudeProvider;
  26. import org.orekit.errors.OrekitException;
  27. import org.orekit.errors.OrekitInternalError;
  28. import org.orekit.errors.PropagationException;
  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 PropagationException if initial attitude cannot be computed
  58.      */
  59.     public KeplerianPropagator(final Orbit initialOrbit)
  60.         throws PropagationException {
  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 PropagationException if initial attitude cannot be computed
  69.      */
  70.     public KeplerianPropagator(final Orbit initialOrbit, final double mu)
  71.         throws PropagationException {
  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 PropagationException if initial attitude cannot be computed
  82.      */
  83.     public KeplerianPropagator(final Orbit initialOrbit,
  84.                                final AttitudeProvider attitudeProv)
  85.         throws PropagationException {
  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 PropagationException if initial attitude cannot be computed
  96.      */
  97.     public KeplerianPropagator(final Orbit initialOrbit,
  98.                                final AttitudeProvider attitudeProv,
  99.                                final double mu)
  100.         throws PropagationException {
  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 PropagationException 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 PropagationException {

  116.         super(attitudeProv);

  118.         try {

  120.             // ensure the orbit use the specified mu
  121.             final OrbitType type = initialOrbit.getType();
  122.             final double[] stateVector = new double[6];
  123.             type.mapOrbitToArray(initialOrbit, PositionAngle.TRUE, stateVector);
  124.             final Orbit orbit = type.mapArrayToOrbit(stateVector, PositionAngle.TRUE,
  125.                                                      initialOrbit.getDate(), mu, initialOrbit.getFrame());

  127.             resetInitialState(new SpacecraftState(orbit,
  128.                                                    getAttitudeProvider().getAttitude(orbit,
  129.                                                                                      orbit.getDate(),
  130.                                                                                      orbit.getFrame()),
  131.                                                    mass));

  133.         } catch (OrekitException oe) {
  134.             throw new PropagationException(oe);
  135.         }
  136.     }

  138.     /** {@inheritDoc} */
  139.     public void resetInitialState(final SpacecraftState state)
  140.         throws PropagationException {
  141.         super.resetInitialState(state);
  142.         initialState   = state;
  143.         states         = new TimeSpanMap<SpacecraftState>(initialState);
  144.     }

  146.     /** {@inheritDoc} */
  147.     protected void resetIntermediateState(final SpacecraftState state, final boolean forward)
  148.         throws PropagationException {
  149.         super.resetIntermediateState(state, forward);
  150.         if (forward) {
  151.             states.addValidAfter(state, state.getDate());
  152.         } else {
  153.             states.addValidBefore(state, state.getDate());
  154.         }
  155.     }

  157.     /** {@inheritDoc} */
  158.     protected Orbit propagateOrbit(final AbsoluteDate date)
  159.         throws PropagationException {

  161.         // propagate orbit
  162.         Orbit orbit = states.get(date).getOrbit();
  163.         do {
  164.             // we use a loop here to compensate for very small date shifts error
  165.             // that occur with long propagation time
  166.             orbit = orbit.shiftedBy(date.durationFrom(orbit.getDate()));
  167.         } while(!date.equals(orbit.getDate()));

  169.         return orbit;

  171.     }

  173.     /** {@inheritDoc}*/
  174.     protected double getMass(final AbsoluteDate date) {
  175.         return states.get(date).getMass();
  176.     }

  178.     /** Replace the instance with a data transfer object for serialization.
  179.      * @return data transfer object that will be serialized
  180.      * @exception NotSerializableException if an additional state provider is not serializable
  181.      */
  182.     private Object writeReplace() throws NotSerializableException {
  183.         try {

  185.             // managed states providers
  186.             final List<AdditionalStateProvider> serializableProviders = new ArrayList<AdditionalStateProvider>();
  187.             for (final AdditionalStateProvider provider : getAdditionalStateProviders()) {
  188.                 if (provider instanceof Serializable) {
  189.                     serializableProviders.add(provider);
  190.                 } else {
  191.                     throw new NotSerializableException(provider.getClass().getName());
  192.                 }
  193.             }

  195.             // states transitions
  196.             final AbsoluteDate[]    transitionDates;
  197.             final SpacecraftState[] allStates;
  198.             final SortedSet<TimeSpanMap.Transition<SpacecraftState>> transitions = states.getTransitions();
  199.             if (transitions.size() == 1  && transitions.first().getBefore() == transitions.first().getAfter()) {
  200.                 // the single entry is a dummy one, without a real transition
  201.                 // we ignore it completely
  202.                 transitionDates = null;
  203.                 allStates       = null;
  204.             } else {
  205.                 transitionDates = new AbsoluteDate[transitions.size()];
  206.                 allStates       = new SpacecraftState[transitions.size() + 1];
  207.                 int i = 0;
  208.                 for (final TimeSpanMap.Transition<SpacecraftState> transition : transitions) {
  209.                     if (i == 0) {
  210.                         // state before the first transition
  211.                         allStates[i] = transition.getBefore();
  212.                     }
  213.                     transitionDates[i] = transition.getDate();
  214.                     allStates[++i]     = transition.getAfter();
  215.                 }
  216.             }

  218.             return new DataTransferObject(getInitialState().getOrbit(), getAttitudeProvider(),
  219.                                           getInitialState().getMu(), getInitialState().getMass(),
  220.                                           transitionDates, allStates,
  221.                                           serializableProviders.toArray(new AdditionalStateProvider[serializableProviders.size()]));
  222.         } catch (OrekitException orekitException) {
  223.             // this should never happen
  224.             throw new OrekitInternalError(null);
  225.         }

  227.     }

  229.     /** Internal class used only for serialization. */
  230.     private static class DataTransferObject implements Serializable {

  232.         /** Serializable UID. */
  233.         private static final long serialVersionUID = 20151202L;

  235.         /** Initial orbit. */
  236.         private final Orbit orbit;

  238.         /** Attitude provider. */
  239.         private final AttitudeProvider attitudeProvider;

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

  244.         /** Spacecraft mass (kg). */
  245.         private final double mass;

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

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

  253.         /** Providers for additional states. */
  254.         private final AdditionalStateProvider[] providers;

  256.         /** Simple constructor.
  257.          * @param orbit initial orbit
  258.          * @param attitudeProvider attitude provider
  259.          * @param mu central attraction coefficient (m³/s²)
  260.          * @param mass initial spacecraft mass (kg)
  261.          * @param transitionDates transition dates (may be null)
  262.          * @param allStates states before and after transitions (may be null)
  263.          * @param providers providers for additional states
  264.          */
  265.         DataTransferObject(final Orbit orbit,
  266.                            final AttitudeProvider attitudeProvider,
  267.                            final double mu, final double mass,
  268.                            final AbsoluteDate[] transitionDates,
  269.                            final SpacecraftState[] allStates,
  270.                            final AdditionalStateProvider[] providers) {
  271.             this.orbit            = orbit;
  272.             this.attitudeProvider = attitudeProvider;
  273.             this.mu               = mu;
  274.             this.mass             = mass;
  275.             this.transitionDates  = transitionDates;
  276.             this.allStates        = allStates;
  277.             this.providers        = providers;
  278.         }

  280.         /** Replace the deserialized data transfer object with a {@link KeplerianPropagator}.
  281.          * @return replacement {@link KeplerianPropagator}
  282.          */
  283.         private Object readResolve() {
  284.             try {

  286.                 final KeplerianPropagator propagator =
  287.                                 new KeplerianPropagator(orbit, attitudeProvider, mu, mass);
  288.                 for (final AdditionalStateProvider provider : providers) {
  289.                     propagator.addAdditionalStateProvider(provider);
  290.                 }

  292.                 if (transitionDates != null) {
  293.                     // override the state transitions
  294.                     propagator.states = new TimeSpanMap<SpacecraftState>(allStates[0]);
  295.                     for (int i = 0; i < transitionDates.length; ++i) {
  296.                         propagator.states.addValidAfter(allStates[i + 1], transitionDates[i]);
  297.                     }
  298.                 }

  300.                 return propagator;

  302.             } catch (OrekitException oe) {
  303.                 throw new OrekitInternalError(oe);
  304.             }
  305.         }

  307.     }

  309. }
Created with JaCoCo 0.7.4.201502262128