FieldIntegratedEphemeris.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.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.analytical.FieldAbstractAnalyticalPropagator;
  32. import org.orekit.time.FieldAbsoluteDate;
  33. import org.orekit.utils.TimeStampedFieldPVCoordinates;

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

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

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

  78.     /** Output only the mean orbit. <br/>
  79.      * <p>
  80.      * This is used only in the case of semianalitical propagators where there is a clear separation between
  81.      * mean and short periodic elements. It is ignored by the Numerical propagator.
  82.      * </p>
  83.      */
  84.     private boolean meanFieldOrbit;

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

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

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

  95.     /** Underlying raw mathematical model. */
  96.     private FieldDenseOutputModel<T> model;

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

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

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

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

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

  139.     }

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

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

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

  159.     }

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

  174.     /** {@inheritDoc} */
  175.     protected FieldOrbit<T> propagateOrbit(final FieldAbsoluteDate<T> date) {
  176.         return basicPropagate(date).getOrbit();
  177.     }

  179.     /** {@inheritDoc} */
  180.     protected T getMass(final FieldAbsoluteDate<T> date) {
  181.         return basicPropagate(date).getMass();
  182.     }

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

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

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

  203.     @Override
  204.     public Frame getFrame() {
  205.         return this.mapper.getFrame();
  206.     }

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

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

  218.     /** {@inheritDoc} */
  219.     public FieldSpacecraftState<T> getInitialState() {
  220.         return updateAdditionalStates(basicPropagate(getMinDate()));
  221.     }

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

  226.         /** Name of the additional state. */
  227.         private final String name;

  229.         /** Index of the additional state. */
  230.         private final int index;

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

  241.         /** {@inheritDoc} */
  242.         public String getName() {
  243.             return name;
  244.         }

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

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

  252.         }

  254.     }

  256. }
Created with JaCoCo 0.8.2.201808211720