IntegratedEphemeris.java

  1. /* Copyright 2002-2022 CS GROUP
  2.  * Licensed to CS GROUP (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.integration;

  19. import java.util.List;
  20. import java.util.Map;

  22. import org.hipparchus.ode.DenseOutputModel;
  23. import org.hipparchus.ode.ODEStateAndDerivative;
  24. import org.orekit.attitudes.AttitudeProvider;
  25. import org.orekit.errors.OrekitException;
  26. import org.orekit.errors.OrekitMessages;
  27. import org.orekit.frames.Frame;
  28. import org.orekit.orbits.Orbit;
  29. import org.orekit.propagation.AdditionalStateProvider;
  30. import org.orekit.propagation.BoundedPropagator;
  31. import org.orekit.propagation.PropagationType;
  32. import org.orekit.propagation.SpacecraftState;
  33. import org.orekit.propagation.analytical.AbstractAnalyticalPropagator;
  34. import org.orekit.time.AbsoluteDate;
  35. import org.orekit.utils.DoubleArrayDictionary;
  36. import org.orekit.utils.TimeStampedPVCoordinates;

  38. /** This class stores sequentially generated orbital parameters for
  39.  * later retrieval.
  40.  *
  41.  * <p>
  42.  * Instances of this class are built automatically when the {@link
  43.  * org.orekit.propagation.Propagator#getEphemerisGenerator()
  44.  * getEphemerisGenerator} method has been called. They are created when propagation is over.
  45.  * Random access to any intermediate state of the orbit throughout the propagation range is
  46.  * possible afterwards through this object.
  47.  * </p>
  48.  * <p>
  49.  * A typical use case is for numerically integrated orbits, which can be used by
  50.  * algorithms that need to wander around according to their own algorithm without
  51.  * cumbersome tight links with the integrator.
  52.  * </p>
  53.  * <p>
  54.  * As this class implements the {@link org.orekit.propagation.Propagator Propagator}
  55.  * interface, it can itself be used in batch mode to build another instance of the
  56.  * same type. This is however not recommended since it would be a waste of resources.
  57.  * </p>
  58.  * <p>
  59.  * Note that this class stores all intermediate states along with interpolation
  60.  * models, so it may be memory intensive.
  61.  * </p>
  62.  *
  63.  * @see org.orekit.propagation.numerical.NumericalPropagator
  64.  * @author Mathieu Rom&eacute;ro
  65.  * @author Luc Maisonobe
  66.  * @author V&eacute;ronique Pommier-Maurussane
  67.  */
  68. public class IntegratedEphemeris
  69.     extends AbstractAnalyticalPropagator implements BoundedPropagator {

  71.     /** Event detection requires evaluating the state slightly before / past an event. */
  72.     private static final double EXTRAPOLATION_TOLERANCE = 1.0;

  74.     /** Mapper between raw double components and spacecraft state. */
  75.     private final StateMapper mapper;

  77.     /** Type of orbit to output (mean or osculating).
  78.      * <p>
  79.      * This is used only in the case of semianalitical propagators where there is a clear separation between
  80.      * mean and short periodic elements. It is ignored by the Numerical propagator.
  81.      * </p>
  82.      */
  83.     private PropagationType type;

  85.     /** Start date of the integration (can be min or max). */
  86.     private final AbsoluteDate startDate;

  88.     /** First date of the range. */
  89.     private final AbsoluteDate minDate;

  91.     /** Last date of the range. */
  92.     private final AbsoluteDate maxDate;

  94.     /** Underlying raw mathematical model. */
  95.     private DenseOutputModel model;

  97.     /** Unmanaged additional states that must be simply copied. */
  98.     private final DoubleArrayDictionary unmanaged;

  100.     /** Creates a new instance of IntegratedEphemeris.
  101.      * @param startDate Start date of the integration (can be minDate or maxDate)
  102.      * @param minDate first date of the range
  103.      * @param maxDate last date of the range
  104.      * @param mapper mapper between raw double components and spacecraft state
  105.      * @param type type of orbit to output (mean or osculating)
  106.      * @param model underlying raw mathematical model
  107.      * @param unmanaged unmanaged additional states that must be simply copied
  108.      * @param providers providers for pre-integrated states
  109.      * @param equations names of additional equations
  110.      * @deprecated as of 11.1, replaced by {@link #IntegratedEphemeris(AbsoluteDate,
  111.      * AbsoluteDate, AbsoluteDate, StateMapper, PropagationType, DenseOutputModel,
  112.      * DoubleArrayDictionary, List, String[])}
  113.      */
  114.     @Deprecated
  115.     public IntegratedEphemeris(final AbsoluteDate startDate,
  116.                                final AbsoluteDate minDate, final AbsoluteDate maxDate,
  117.                                final StateMapper mapper, final PropagationType type,
  118.                                final DenseOutputModel model,
  119.                                final Map<String, double[]> unmanaged,
  120.                                final List<AdditionalStateProvider> providers,
  121.                                final String[] equations) {
  122.         this(startDate, minDate, maxDate, mapper, type, model,
  123.              new DoubleArrayDictionary(unmanaged), providers, equations);
  124.     }

  126.     /** Creates a new instance of IntegratedEphemeris.
  127.      * @param startDate Start date of the integration (can be minDate or maxDate)
  128.      * @param minDate first date of the range
  129.      * @param maxDate last date of the range
  130.      * @param mapper mapper between raw double components and spacecraft state
  131.      * @param type type of orbit to output (mean or osculating)
  132.      * @param model underlying raw mathematical model
  133.      * @param unmanaged unmanaged additional states that must be simply copied
  134.      * @param providers providers for pre-integrated states
  135.      * @param equations names of additional equations
  136.      * @since 11.1
  137.      */
  138.     public IntegratedEphemeris(final AbsoluteDate startDate,
  139.                                final AbsoluteDate minDate, final AbsoluteDate maxDate,
  140.                                final StateMapper mapper, final PropagationType type,
  141.                                final DenseOutputModel model,
  142.                                final DoubleArrayDictionary unmanaged,
  143.                                final List<AdditionalStateProvider> providers,
  144.                                final String[] equations) {

  146.         super(mapper.getAttitudeProvider());

  148.         this.startDate = startDate;
  149.         this.minDate   = minDate;
  150.         this.maxDate   = maxDate;
  151.         this.mapper    = mapper;
  152.         this.type      = type;
  153.         this.model     = model;
  154.         this.unmanaged = unmanaged;

  156.         // set up the pre-integrated providers
  157.         for (final AdditionalStateProvider provider : providers) {
  158.             addAdditionalStateProvider(provider);
  159.         }

  161.         // set up providers to map the final elements of the model array to additional states
  162.         for (int i = 0; i < equations.length; ++i) {
  163.             addAdditionalStateProvider(new LocalGenerator(equations[i], i));
  164.         }

  166.     }

  168.     /** Interpolate the model at some date.
  169.      * @param date desired interpolation date
  170.      * @return state interpolated at date
  171.      */
  172.     private ODEStateAndDerivative getInterpolatedState(final AbsoluteDate date) {

  174.         // compare using double precision instead of AbsoluteDate.compareTo(...)
  175.         // because time is expressed as a double when searching for events
  176.         if (date.compareTo(minDate.shiftedBy(-EXTRAPOLATION_TOLERANCE)) < 0) {
  177.             // date is outside of supported range
  178.             throw new OrekitException(OrekitMessages.OUT_OF_RANGE_EPHEMERIDES_DATE_BEFORE,
  179.                     date, minDate, maxDate, minDate.durationFrom(date));
  180.         }
  181.         if (date.compareTo(maxDate.shiftedBy(EXTRAPOLATION_TOLERANCE)) > 0) {
  182.             // date is outside of supported range
  183.             throw new OrekitException(OrekitMessages.OUT_OF_RANGE_EPHEMERIDES_DATE_AFTER,
  184.                     date, minDate, maxDate, date.durationFrom(maxDate));
  185.         }

  187.         return model.getInterpolatedState(date.durationFrom(startDate));

  189.     }

  191.     /** {@inheritDoc} */
  192.     @Override
  193.     protected SpacecraftState basicPropagate(final AbsoluteDate date) {
  194.         final ODEStateAndDerivative os = getInterpolatedState(date);
  195.         SpacecraftState state = mapper.mapArrayToState(mapper.mapDoubleToDate(os.getTime(), date),
  196.                                                        os.getPrimaryState(), os.getPrimaryDerivative(),
  197.                                                        type);
  198.         for (DoubleArrayDictionary.Entry initial : unmanaged.getData()) {
  199.             state = state.addAdditionalState(initial.getKey(), initial.getValue());
  200.         }
  201.         return state;
  202.     }

  204.     /** {@inheritDoc} */
  205.     protected Orbit propagateOrbit(final AbsoluteDate date) {
  206.         return basicPropagate(date).getOrbit();
  207.     }

  209.     /** {@inheritDoc} */
  210.     protected double getMass(final AbsoluteDate date) {
  211.         return basicPropagate(date).getMass();
  212.     }

  214.     /** {@inheritDoc} */
  215.     public TimeStampedPVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame frame) {
  216.         return propagate(date).getPVCoordinates(frame);
  217.     }

  219.     /** Get the first date of the range.
  220.      * @return the first date of the range
  221.      */
  222.     public AbsoluteDate getMinDate() {
  223.         return minDate;
  224.     }

  226.     /** Get the last date of the range.
  227.      * @return the last date of the range
  228.      */
  229.     public AbsoluteDate getMaxDate() {
  230.         return maxDate;
  231.     }

  233.     @Override
  234.     public Frame getFrame() {
  235.         return this.mapper.getFrame();
  236.     }

  238.     /** {@inheritDoc} */
  239.     public void resetInitialState(final SpacecraftState state) {
  240.         throw new OrekitException(OrekitMessages.NON_RESETABLE_STATE);
  241.     }

  243.     /** {@inheritDoc} */
  244.     protected void resetIntermediateState(final SpacecraftState state, final boolean forward) {
  245.         throw new OrekitException(OrekitMessages.NON_RESETABLE_STATE);
  246.     }

  248.     /** {@inheritDoc} */
  249.     @Override
  250.     public void setAttitudeProvider(final AttitudeProvider attitudeProvider) {
  251.         super.setAttitudeProvider(attitudeProvider);
  252.         if (mapper != null) {
  253.             // At the construction, the mapper is not set yet
  254.             // However, if the attitude provider is changed afterwards, it must be changed in the mapper too
  255.             mapper.setAttitudeProvider(attitudeProvider);
  256.         }
  257.     }

  259.     /** {@inheritDoc} */
  260.     public SpacecraftState getInitialState() {
  261.         return updateAdditionalStates(basicPropagate(getMinDate()));
  262.     }

  264.     /** Local generator for additional state data. */
  265.     private class LocalGenerator implements AdditionalStateProvider {

  267.         /** Name of the additional state. */
  268.         private final String name;

  270.         /** Index of the additional state. */
  271.         private final int index;

  273.         /** Simple constructor.
  274.          * @param name name of the additional state
  275.          * @param index index of the additional state
  276.          */
  277.         LocalGenerator(final String name, final int index) {
  278.             this.name  = name;
  279.             this.index = index;
  280.         }

  282.         /** {@inheritDoc} */
  283.         public String getName() {
  284.             return name;
  285.         }

  287.         /** {@inheritDoc} */
  288.         public double[] getAdditionalState(final SpacecraftState state) {

  290.             // extract the part of the interpolated array corresponding to the additional state
  291.             return getInterpolatedState(state.getDate()).getSecondaryState(index + 1);

  293.         }

  295.     }

  297. }
Created with JaCoCo 0.8.7.202105040129