FieldIntegratedEphemeris.java

  1. /* Copyright 2002-2018 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.OrekitExceptionWrapper;
  26. import org.orekit.errors.OrekitMessages;
  27. import org.orekit.frames.Frame;
  28. import org.orekit.orbits.FieldOrbit;
  29. import org.orekit.propagation.FieldAdditionalStateProvider;
  30. import org.orekit.propagation.FieldBoundedPropagator;
  31. import org.orekit.propagation.FieldSpacecraftState;
  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.  * Another use case is persistence, as this class is one of the few propagators
  53.  * to be serializable.
  54.  * </p>
  55.  * <p>
  56.  * As this class implements the {@link org.orekit.propagation.Propagator Propagator}
  57.  * interface, it can itself be used in batch mode to build another instance of the
  58.  * same type. This is however not recommended since it would be a waste of resources.
  59.  * </p>
  60.  * <p>
  61.  * Note that this class stores all intermediate states along with interpolation
  62.  * models, so it may be memory intensive.
  63.  * </p>
  64.  *
  65.  * @see org.orekit.propagation.numerical.NumericalPropagator
  66.  * @author Mathieu Rom&eacute;ro
  67.  * @author Luc Maisonobe
  68.  * @author V&eacute;ronique Pommier-Maurussane
  69.  */
  70. public class FieldIntegratedEphemeris <T extends RealFieldElement<T>>
  71.     extends FieldAbstractAnalyticalPropagator<T> implements FieldBoundedPropagator<T> {

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

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

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

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

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

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

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

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

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

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

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

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

  142.     }

  144.     /** Interpolate the model at some date.
  145.      * @param date desired interpolation date
  146.      * @return state interpolated at date
  147.      * @exception OrekitException if specified date is outside
  148.      * of supported range
  149.      */
  150.     private FieldODEStateAndDerivative<T> getInterpolatedState(final FieldAbsoluteDate<T> date)
  151.         throws OrekitException {

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

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

  164.     }

  166.     /** {@inheritDoc} */
  167.     @Override
  168.     protected FieldSpacecraftState<T> basicPropagate(final FieldAbsoluteDate<T> date)
  169.         throws OrekitException {
  170.         try {
  171.             final FieldODEStateAndDerivative<T> os = getInterpolatedState(date);
  172.             FieldSpacecraftState<T> state = mapper.mapArrayToState(mapper.mapDoubleToDate(os.getTime(), date),
  173.                                                                    os.getPrimaryState(), os.getPrimaryDerivative(),
  174.                                                                    meanFieldOrbit);
  175.             for (Map.Entry<String, T[]> initial : unmanaged.entrySet()) {
  176.                 state = state.addAdditionalState(initial.getKey(), initial.getValue());
  177.             }
  178.             return state;
  179.         } catch (OrekitExceptionWrapper oew) {
  180.             throw new OrekitException(oew.getException());
  181.         }
  182.     }

  184.     /** {@inheritDoc} */
  185.     protected FieldOrbit<T> propagateOrbit(final FieldAbsoluteDate<T> date)
  186.         throws OrekitException {
  187.         return basicPropagate(date).getOrbit();
  188.     }

  190.     /** {@inheritDoc} */
  191.     protected T getMass(final FieldAbsoluteDate<T> date) throws OrekitException {
  192.         return basicPropagate(date).getMass();
  193.     }

  195.     /** {@inheritDoc} */
  196.     public TimeStampedFieldPVCoordinates<T> getPVCoordinates(final FieldAbsoluteDate<T> date, final Frame frame)
  197.         throws OrekitException {
  198.         return propagate(date).getPVCoordinates(frame);
  199.     }

  201.     /** Get the first date of the range.
  202.      * @return the first date of the range
  203.      */
  204.     public FieldAbsoluteDate<T> getMinDate() {
  205.         return minDate;
  206.     }

  208.     /** Get the last date of the range.
  209.      * @return the last date of the range
  210.      */
  211.     public FieldAbsoluteDate<T> getMaxDate() {
  212.         return maxDate;
  213.     }

  215.     @Override
  216.     public Frame getFrame() {
  217.         return this.mapper.getFrame();
  218.     }

  220.     /** {@inheritDoc} */
  221.     public void resetInitialState(final FieldSpacecraftState<T> state)
  222.         throws OrekitException {
  223.         throw new OrekitException(OrekitMessages.NON_RESETABLE_STATE);
  224.     }

  226.     /** {@inheritDoc} */
  227.     protected void resetIntermediateState(final FieldSpacecraftState<T> state, final boolean forward)
  228.         throws OrekitException {
  229.         throw new OrekitException(OrekitMessages.NON_RESETABLE_STATE);
  230.     }

  232.     /** {@inheritDoc} */
  233.     public FieldSpacecraftState<T> getInitialState() throws OrekitException {
  234.         return updateAdditionalStates(basicPropagate(getMinDate()));
  235.     }

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

  240.         /** Name of the additional state. */
  241.         private final String name;

  243.         /** Index of the additional state. */
  244.         private final int index;

  246.         /** Simple constructor.
  247.          * @param name name of the additional state
  248.          * @param index index of the additional state
  249.          */
  250.         LocalProvider(final String name, final int index) {
  251.             this.name  = name;
  252.             this.index = index;
  253.         }

  255.         /** {@inheritDoc} */
  256.         public String getName() {
  257.             return name;
  258.         }

  260.         /** {@inheritDoc} */
  261.         public T[] getAdditionalState(final FieldSpacecraftState<T> state)
  262.             throws OrekitException {

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

  267.         }

  269.     }

  271. }
Created with JaCoCo 0.7.9.201702052155