FieldIntegratedEphemeris.java

  1. /* Copyright 2002-2020 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;
  21. import org.hipparchus.RealFieldElement;
  22. import org.hipparchus.ode.FieldDenseOutputModel;
  23. import org.hipparchus.ode.FieldODEStateAndDerivative;
  24. import org.orekit.errors.OrekitException;
  25. import org.orekit.errors.OrekitMessages;
  26. import org.orekit.frames.Frame;
  27. import org.orekit.orbits.FieldOrbit;
  28. import org.orekit.propagation.FieldAdditionalStateProvider;
  29. import org.orekit.propagation.FieldBoundedPropagator;
  30. import org.orekit.propagation.FieldSpacecraftState;
  31. import org.orekit.propagation.PropagationType;
  32. import org.orekit.propagation.analytical.FieldAbstractAnalyticalPropagator;
  33. import org.orekit.time.FieldAbsoluteDate;
  34. import org.orekit.utils.TimeStampedFieldPVCoordinates;

  36. /** This class stores sequentially generated orbital parameters for
  37.  * later retrieval.
  38.  *
  39.  * <p>
  40.  * Instances of this class are built and then must be fed with the results
  41.  * provided by {@link org.orekit.propagation.Propagator Propagator} objects
  42.  * configured in {@link org.orekit.propagation.Propagator#setEphemerisMode()
  43.  * ephemeris generation mode}. Once propagation is o, random access to any
  44.  * intermediate state of the orbit throughout the propagation range is possible.
  45.  * </p>
  46.  * <p>
  47.  * A typical use case is for numerically integrated orbits, which can be used by
  48.  * algorithms that need to wander around according to their own algorithm without
  49.  * cumbersome tight links with the integrator.
  50.  * </p>
  51.  * <p>
  52.  * As this class implements the {@link org.orekit.propagation.Propagator Propagator}
  53.  * interface, it can itself be used in batch mode to build another instance of the
  54.  * same type. This is however not recommended since it would be a waste of resources.
  55.  * </p>
  56.  * <p>
  57.  * Note that this class stores all intermediate states along with interpolation
  58.  * models, so it may be memory intensive.
  59.  * </p>
  60.  *
  61.  * @see org.orekit.propagation.numerical.NumericalPropagator
  62.  * @author Mathieu Rom&eacute;ro
  63.  * @author Luc Maisonobe
  64.  * @author V&eacute;ronique Pommier-Maurussane
  65.  */
  66. public class FieldIntegratedEphemeris <T extends RealFieldElement<T>>
  67.     extends FieldAbstractAnalyticalPropagator<T> implements FieldBoundedPropagator<T> {

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

  72.     /** Mapper between raw double components and spacecraft state. */
  73.     private final FieldStateMapper<T> mapper;

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

  83.     /** Start date of the integration (can be min or max). */
  84.     private final FieldAbsoluteDate<T> startDate;

  86.     /** First date of the range. */
  87.     private final FieldAbsoluteDate<T> minDate;

  89.     /** Last date of the range. */
  90.     private final FieldAbsoluteDate<T> maxDate;

  92.     /** Underlying raw mathematical model. */
  93.     private FieldDenseOutputModel<T> model;

  95.     /** Unmanaged additional states that must be simply copied. */
  96.     private final Map<String, T[]> unmanaged;

  98.     /** Creates a new instance of IntegratedEphemeris.
  99.      * @param startDate Start date of the integration (can be minDate or maxDate)
  100.      * @param minDate first date of the range
  101.      * @param maxDate last date of the range
  102.      * @param mapper mapper between raw double components and spacecraft state
  103.      * @param type type of orbit to output (mean or osculating)
  104.      * @param model underlying raw mathematical model
  105.      * @param unmanaged unmanaged additional states that must be simply copied
  106.      * @param providers providers for pre-integrated states
  107.      * @param equations names of additional equations
  108.      */
  109.     public FieldIntegratedEphemeris(final FieldAbsoluteDate<T> startDate,
  110.                                final FieldAbsoluteDate<T> minDate, final FieldAbsoluteDate<T> maxDate,
  111.                                final FieldStateMapper<T> mapper, final PropagationType type,
  112.                                final FieldDenseOutputModel<T> model,
  113.                                final Map<String, T[]> unmanaged,
  114.                                final List<FieldAdditionalStateProvider<T>> providers,
  115.                                final String[] equations) {

  117.         super(startDate.getField(), mapper.getAttitudeProvider());

  119.         this.startDate = startDate;
  120.         this.minDate   = minDate;
  121.         this.maxDate   = maxDate;
  122.         this.mapper    = mapper;
  123.         this.type      = type;
  124.         this.model     = model;
  125.         this.unmanaged = unmanaged;
  126.         // set up the pre-integrated providers
  127.         for (final FieldAdditionalStateProvider<T> provider : providers) {
  128.             addAdditionalStateProvider(provider);
  129.         }

  131.         // set up providers to map the final elements of the model array to additional states
  132.         for (int i = 0; i < equations.length; ++i) {
  133.             addAdditionalStateProvider(new LocalProvider(equations[i], i));
  134.         }

  136.     }

  138.     /** Interpolate the model at some date.
  139.      * @param date desired interpolation date
  140.      * @return state interpolated at date
  141.           * of supported range
  142.      */
  143.     private FieldODEStateAndDerivative<T> getInterpolatedState(final FieldAbsoluteDate<T> date) {

  145.         // compare using double precision instead of FieldAbsoluteDate<T>.compareTo(...)
  146.         // because time is expressed as a double when searching for events
  147.         if (date.compareTo(minDate.shiftedBy(-EXTRAPOLATION_TOLERANCE)) < 0 ||
  148.                 date.compareTo(maxDate.shiftedBy(EXTRAPOLATION_TOLERANCE)) > 0 ) {
  149.             // date is outside of supported range
  150.             throw new OrekitException(OrekitMessages.OUT_OF_RANGE_EPHEMERIDES_DATE,
  151.                                            date, minDate, maxDate);
  152.         }

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

  156.     }

  158.     /** {@inheritDoc} */
  159.     @Override
  160.     protected FieldSpacecraftState<T> basicPropagate(final FieldAbsoluteDate<T> date) {
  161.         final FieldODEStateAndDerivative<T> os = getInterpolatedState(date);
  162.         FieldSpacecraftState<T> state = mapper.mapArrayToState(mapper.mapDoubleToDate(os.getTime(), date),
  163.                                                                os.getPrimaryState(), os.getPrimaryDerivative(),
  164.                                                                type);
  165.         for (Map.Entry<String, T[]> initial : unmanaged.entrySet()) {
  166.             state = state.addAdditionalState(initial.getKey(), initial.getValue());
  167.         }
  168.         return state;
  169.     }

  171.     /** {@inheritDoc} */
  172.     protected FieldOrbit<T> propagateOrbit(final FieldAbsoluteDate<T> date) {
  173.         return basicPropagate(date).getOrbit();
  174.     }

  176.     /** {@inheritDoc} */
  177.     protected T getMass(final FieldAbsoluteDate<T> date) {
  178.         return basicPropagate(date).getMass();
  179.     }

  181.     /** {@inheritDoc} */
  182.     public TimeStampedFieldPVCoordinates<T> getPVCoordinates(final FieldAbsoluteDate<T> date, final Frame frame) {
  183.         return propagate(date).getPVCoordinates(frame);
  184.     }

  186.     /** Get the first date of the range.
  187.      * @return the first date of the range
  188.      */
  189.     public FieldAbsoluteDate<T> getMinDate() {
  190.         return minDate;
  191.     }

  193.     /** Get the last date of the range.
  194.      * @return the last date of the range
  195.      */
  196.     public FieldAbsoluteDate<T> getMaxDate() {
  197.         return maxDate;
  198.     }

  200.     @Override
  201.     public Frame getFrame() {
  202.         return this.mapper.getFrame();
  203.     }

  205.     /** {@inheritDoc} */
  206.     public void resetInitialState(final FieldSpacecraftState<T> state) {
  207.         throw new OrekitException(OrekitMessages.NON_RESETABLE_STATE);
  208.     }

  210.     /** {@inheritDoc} */
  211.     protected void resetIntermediateState(final FieldSpacecraftState<T> state, final boolean forward) {
  212.         throw new OrekitException(OrekitMessages.NON_RESETABLE_STATE);
  213.     }

  215.     /** {@inheritDoc} */
  216.     public FieldSpacecraftState<T> getInitialState() {
  217.         return updateAdditionalStates(basicPropagate(getMinDate()));
  218.     }

  220.     /** Local provider for additional state data. */
  221.     private class LocalProvider implements FieldAdditionalStateProvider<T> {

  223.         /** Name of the additional state. */
  224.         private final String name;

  226.         /** Index of the additional state. */
  227.         private final int index;

  229.         /** Simple constructor.
  230.          * @param name name of the additional state
  231.          * @param index index of the additional state
  232.          */
  233.         LocalProvider(final String name, final int index) {
  234.             this.name  = name;
  235.             this.index = index;
  236.         }

  238.         /** {@inheritDoc} */
  239.         public String getName() {
  240.             return name;
  241.         }

  243.         /** {@inheritDoc} */
  244.         public T[] getAdditionalState(final FieldSpacecraftState<T> state) {

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

  249.         }

  251.     }

  253. }
Created with JaCoCo 0.8.6.202009150832