FieldAbstractAnalyticalPropagator.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.analytical;

  19. import java.util.ArrayList;
  20. import java.util.Collection;
  21. import java.util.Collections;
  22. import java.util.Comparator;
  23. import java.util.List;
  24. import java.util.PriorityQueue;
  25. import java.util.Queue;

  27. import org.hipparchus.Field;
  28. import org.hipparchus.RealFieldElement;
  29. import org.hipparchus.exception.MathRuntimeException;
  30. import org.hipparchus.util.FastMath;
  31. import org.orekit.attitudes.AttitudeProvider;
  32. import org.orekit.attitudes.FieldAttitude;
  33. import org.orekit.errors.OrekitException;
  34. import org.orekit.errors.OrekitInternalError;
  35. import org.orekit.frames.Frame;
  36. import org.orekit.orbits.FieldOrbit;
  37. import org.orekit.propagation.BoundedPropagator;
  38. import org.orekit.propagation.FieldAbstractPropagator;
  39. import org.orekit.propagation.FieldAdditionalStateProvider;
  40. import org.orekit.propagation.FieldBoundedPropagator;
  41. import org.orekit.propagation.FieldSpacecraftState;
  42. import org.orekit.propagation.events.FieldEventDetector;
  43. import org.orekit.propagation.events.FieldEventState;
  44. import org.orekit.propagation.events.FieldEventState.EventOccurrence;
  45. import org.orekit.propagation.events.handlers.FieldEventHandler.Action;
  46. import org.orekit.propagation.sampling.FieldOrekitStepInterpolator;
  47. import org.orekit.time.FieldAbsoluteDate;
  48. import org.orekit.utils.FieldPVCoordinatesProvider;
  49. import org.orekit.utils.TimeStampedFieldPVCoordinates;

  51. /** Common handling of {@link org.orekit.propagation.FieldPropagator} methods for analytical propagators.
  52.  * <p>
  53.  * This abstract class allows to provide easily the full set of {@link
  54.  * org.orekit.propagation.FieldPropagator FieldPropagator} methods, including all propagation
  55.  * modes support and discrete events support for any simple propagation method. Only
  56.  * two methods must be implemented by derived classes: {@link #propagateOrbit(FieldAbsoluteDate)}
  57.  * and {@link #getMass(FieldAbsoluteDate)}. The first method should perform straightforward
  58.  * propagation starting from some internally stored initial state up to the specified target date.
  59.  * </p>
  60.  * @author Luc Maisonobe
  61.  */

  63. public abstract class FieldAbstractAnalyticalPropagator<T extends RealFieldElement<T>> extends FieldAbstractPropagator<T> {

  65.     /** Provider for attitude computation. */
  66.     private FieldPVCoordinatesProvider<T> pvProvider;

  68.     /** Start date of last propagation. */
  69.     private FieldAbsoluteDate<T> lastPropagationStart;

  71.     /** End date of last propagation. */
  72.     private FieldAbsoluteDate<T> lastPropagationEnd;

  74.     /** Initialization indicator of events states. */
  75.     private boolean statesInitialized;

  77.     /** Indicator for last step. */
  78.     private boolean isLastStep;

  80.     /** Event steps. */
  81.     private final Collection<FieldEventState<?, T>> eventsStates;

  83.     /** Build a new instance.
  84.      * @param attitudeProvider provider for attitude computation
  85.      * @param field field used as default
  86.      */
  87.     protected FieldAbstractAnalyticalPropagator(final Field<T> field, final AttitudeProvider attitudeProvider) {
  88.         super(field);
  89.         setAttitudeProvider(attitudeProvider);
  90.         pvProvider           = new FieldLocalPVProvider();
  91.         lastPropagationStart = FieldAbsoluteDate.getPastInfinity(field);
  92.         lastPropagationEnd   = FieldAbsoluteDate.getFutureInfinity(field);
  93.         statesInitialized    = false;
  94.         eventsStates         = new ArrayList<FieldEventState<?, T>>();
  95.     }

  97.     /** {@inheritDoc} */
  98.     public FieldBoundedPropagator<T> getGeneratedEphemeris() {
  99.         return new FieldBoundedPropagatorView(lastPropagationStart, lastPropagationEnd);
  100.     }

  102.     /** {@inheritDoc} */
  103.     public Collection<FieldEventDetector<T>> getEventsDetectors() {
  104.         final List<FieldEventDetector<T>> list = new ArrayList<FieldEventDetector<T>>();
  105.         for (final FieldEventState<?, T> state : eventsStates) {
  106.             list.add(state.getEventDetector());
  107.         }
  108.         return Collections.unmodifiableCollection(list);
  109.     }

  111.     /** {@inheritDoc} */
  112.     public void clearEventsDetectors() {
  113.         eventsStates.clear();
  114.     }
  115.     /** {@inheritDoc} */
  116.     public FieldSpacecraftState<T> propagate(final FieldAbsoluteDate<T> start, final FieldAbsoluteDate<T> target)
  117.         throws OrekitException {
  118.         try {
  119.             lastPropagationStart = start;

  121.             final T dt       = target.durationFrom(start);

  123.             final double epsilon  = FastMath.ulp(dt.getReal());

  125.             FieldSpacecraftState<T> state = updateAdditionalStates(basicPropagate(start));

  127.             // evaluate step size
  128.             final T stepSize;
  129.             if (getMode() == MASTER_MODE) {
  130.                 if (Double.isNaN(getFixedStepSize().getReal())) {
  131.                     stepSize = state.getKeplerianPeriod().divide(100).copySign(dt);
  132.                 } else {
  133.                     stepSize = getFixedStepSize().copySign(dt);
  134.                 }
  135.             } else {
  136.                 stepSize = dt;
  137.             }

  139.             // initialize event detectors
  140.             for (final FieldEventState<?, T> es : eventsStates) {
  141.                 es.init(state, target);
  142.             }

  144.             // initialize step handler
  145.             if (getStepHandler() != null) {
  146.                 getStepHandler().init(state, target);
  147.             }

  149.             // iterate over the propagation range
  150.             statesInitialized = false;
  151.             isLastStep = false;
  152.             do {

  154.                 // go ahead one step size
  155.                 final FieldSpacecraftState<T> previous = state;
  156.                 FieldAbsoluteDate<T> t = previous.getDate().shiftedBy(stepSize);
  157.                 if ((dt.getReal() == 0) || ((dt.getReal() > 0) ^ (t.compareTo(target) <= 0))) {
  158.                     // current step exceeds target
  159.                     t = target;
  160.                 }
  161.                 final FieldSpacecraftState<T> current = updateAdditionalStates(basicPropagate(t));
  162.                 final FieldBasicStepInterpolator interpolator = new FieldBasicStepInterpolator(dt.getReal() >= 0, previous, current);



  166.                 // accept the step, trigger events and step handlers
  167.                 state = acceptStep(interpolator, target, epsilon);
  168.             } while (!isLastStep);
  169.             // return the last computed state
  170.             lastPropagationEnd = state.getDate();
  171.             setStartDate(state.getDate());
  172.             return state;

  174.         } catch (OrekitException pe) {
  175.             throw pe;
  176.         } catch (MathRuntimeException mrte) {
  177.             throw OrekitException.unwrap(mrte);
  178.         }
  179.     }

  181.     /** Accept a step, triggering events and step handlers.
  182.      * @param interpolator interpolator for the current step
  183.      * @param target final propagation time
  184.      * @param epsilon threshold for end date detection
  185.      * @return state at the end of the step
  186.      * @exception OrekitException if the switching function cannot be evaluated
  187.      * @exception MathRuntimeException if an event cannot be located
  188.      */
  189.     protected FieldSpacecraftState<T> acceptStep(final FieldBasicStepInterpolator interpolator,
  190.                                          final FieldAbsoluteDate<T> target, final double epsilon)
  191.         throws OrekitException, MathRuntimeException {

  193.         FieldSpacecraftState<T>       previous = interpolator.getPreviousState();
  194.         final FieldSpacecraftState<T> current  = interpolator.getCurrentState();
  195.         // initialize the events states if needed
  196.         if (!statesInitialized) {

  198.             if (!eventsStates.isEmpty()) {
  199.                 // initialize the events states
  200.                 for (final FieldEventState<?, T> state : eventsStates) {
  201.                     state.reinitializeBegin(interpolator);
  202.                 }
  203.             }

  205.             statesInitialized = true;

  207.         }
  208.         // search for next events that may occur during the step
  209.         final int orderingSign = interpolator.isForward() ? +1 : -1;
  210.         final Queue<FieldEventState<?, T>> occurringEvents = new PriorityQueue<>(new Comparator<FieldEventState<?, T>>() {
  211.             /** {@inheritDoc} */
  212.             @Override
  213.             public int compare(final FieldEventState<?, T> es0, final FieldEventState<?, T> es1) {
  214.                 return orderingSign * es0.getEventDate().compareTo(es1.getEventDate());
  215.             }
  216.         });
  217.         for (final FieldEventState<?, T> state : eventsStates) {
  218.             if (state.evaluateStep(interpolator)) {
  219.                 // the event occurs during the current step
  220.                 occurringEvents.add(state);
  221.             }
  222.         }



  226.         FieldBasicStepInterpolator restricted = interpolator;

  228.         do {
  229.             eventLoop:
  230.             while (!occurringEvents.isEmpty()) {
  231.                 // handle the chronologically first event
  232.                 final FieldEventState<?, T> currentEvent = occurringEvents.poll();

  234.                 // get state at event time
  235.                 FieldSpacecraftState<T> eventState = restricted.getInterpolatedState(currentEvent.getEventDate());
  236.                 // try to advance all event states to current time
  237.                 for (final FieldEventState<?, T> state : eventsStates) {
  238.                     if (state != currentEvent && state.tryAdvance(eventState, interpolator)) {
  239.                         // we need to handle another event first
  240.                         occurringEvents.add(currentEvent);
  241.                         occurringEvents.remove(state); // remove if already has pending event
  242.                         occurringEvents.add(state);
  243.                         continue eventLoop;
  244.                     }
  245.                 }
  246.                 // all event detectors agree we can advance to the current event time
  247.                 final EventOccurrence<T> occurrence = currentEvent.doEvent(eventState);
  248.                 final Action action = occurrence.getAction();
  249.                 isLastStep = action == Action.STOP;
  250.                 if (isLastStep) {
  251.                     // ensure the event is after the root if it is returned STOP
  252.                     // this lets the user integrate to a STOP event and then restart
  253.                     // integration from the same time.
  254.                     eventState = interpolator.getInterpolatedState(occurrence.getStopDate());
  255.                     restricted = new FieldBasicStepInterpolator(restricted.isForward(), previous, eventState);
  256.                 }
  257.                 // handle the first part of the step, up to the event
  258.                 if (getStepHandler() != null) {
  259.                     getStepHandler().handleStep(restricted, isLastStep);
  260.                 }

  262.                 if (isLastStep) {
  263.                     // the event asked to stop integration
  264.                     return eventState;
  265.                 }

  267.                 if (action == Action.RESET_DERIVATIVES || action == Action.RESET_STATE) {
  268.                     // some event handler has triggered changes that
  269.                     // invalidate the derivatives, we need to recompute them
  270.                     final FieldSpacecraftState<T> resetState = occurrence.getNewState();
  271.                     if (resetState != null) {
  272.                         resetIntermediateState( resetState, interpolator.isForward());
  273.                         return resetState;
  274.                     }
  275.                 }
  276.                 // at this point we know action == Action.CONTINUE

  278.                 // prepare handling of the remaining part of the step
  279.                 previous = eventState;
  280.                 restricted         = new FieldBasicStepInterpolator(restricted.isForward(), eventState, current);

  282.                 // check if the same event occurs again in the remaining part of the step
  283.                 if (currentEvent.evaluateStep(restricted)) {
  284.                     // the event occurs during the current step
  285.                     occurringEvents.add(currentEvent);
  286.                 }

  288.             }

  290.             // last part of the step, after the last event
  291.             // may be a new event here if the last event modified the g function of
  292.             // another event detector.
  293.             for (final FieldEventState<?, T> state : eventsStates) {
  294.                 if (state.tryAdvance(current, interpolator)) {
  295.                     occurringEvents.add(state);
  296.                 }
  297.             }

  299.         } while (!occurringEvents.isEmpty());

  301.         final T remaining = target.durationFrom(current.getDate());
  302.         if (interpolator.isForward()) {
  303.             isLastStep = remaining.getReal() <  epsilon;
  304.         } else {
  305.             isLastStep = remaining.getReal() > -epsilon;
  306.         }

  308.         // handle the remaining part of the step, after all events if any
  309.         if (getStepHandler() != null) {
  310.             getStepHandler().handleStep(interpolator, isLastStep);
  311.         }
  312.         return current;

  314.     }

  316.     /** Get the mass.
  317.      * @param date target date for the orbit
  318.      * @return mass mass
  319.      * @exception OrekitException if some parameters are out of bounds
  320.      */
  321.     protected abstract T getMass(FieldAbsoluteDate<T> date)
  322.         throws OrekitException;

  324.     /** Get PV coordinates provider.
  325.      * @return PV coordinates provider
  326.      */
  327.     public FieldPVCoordinatesProvider<T> getPvProvider() {
  328.         return pvProvider;
  329.     }

  331.     /** {@inheritDoc} */
  332.     public <D extends FieldEventDetector<T>> void addEventDetector(final D detector) {
  333.         eventsStates.add(new FieldEventState<D, T>(detector));
  334.     }

  336.     /** Reset an intermediate state.
  337.      * @param state new intermediate state to consider
  338.      * @param forward if true, the intermediate state is valid for
  339.      * propagations after itself
  340.      * @exception OrekitException if initial state cannot be reset
  341.      */
  342.     protected abstract void resetIntermediateState(FieldSpacecraftState<T> state, boolean forward)
  343.         throws OrekitException;

  345.     /** Extrapolate an orbit up to a specific target date.
  346.      * @param date target date for the orbit
  347.      * @return extrapolated parameters
  348.      * @exception OrekitException if some parameters are out of bounds
  349.      */
  350.     protected abstract FieldOrbit<T> propagateOrbit(FieldAbsoluteDate<T> date)
  351.         throws OrekitException;

  353.     /** Propagate an orbit without any fancy features.
  354.      * <p>This method is similar in spirit to the {@link #propagate} method,
  355.      * except that it does <strong>not</strong> call any handler during
  356.      * propagation, nor any discrete events, not additional states. It always
  357.      * stop exactly at the specified date.</p>
  358.      * @param date target date for propagation
  359.      * @return state at specified date
  360.      * @exception OrekitException if propagation cannot reach specified date
  361.      */
  362.     protected FieldSpacecraftState<T> basicPropagate(final FieldAbsoluteDate<T> date) throws OrekitException {
  363.         try {

  365.             // evaluate orbit
  366.             final FieldOrbit<T> orbit = propagateOrbit(date);

  368.             // evaluate attitude
  369.             final FieldAttitude<T> attitude =
  370.                 getAttitudeProvider().getAttitude(pvProvider, date, orbit.getFrame());

  372.             // build raw state
  373.             return new FieldSpacecraftState<>(orbit, attitude, getMass(date));

  375.         } catch (OrekitException oe) {
  376.             throw new OrekitException(oe);
  377.         }
  378.     }

  380.     /** Internal FieldPVCoordinatesProvider<T> for attitude computation. */
  381.     private class FieldLocalPVProvider implements FieldPVCoordinatesProvider<T> {

  383.         /** {@inheritDoc} */
  384.         public TimeStampedFieldPVCoordinates<T> getPVCoordinates(final FieldAbsoluteDate<T> date, final Frame frame)
  385.             throws OrekitException {
  386.             return propagateOrbit(date).getPVCoordinates(frame);
  387.         }

  389.     }

  391.     /** {@link BoundedPropagator} view of the instance. */
  392.     private class FieldBoundedPropagatorView extends FieldAbstractAnalyticalPropagator<T>
  393.         implements FieldBoundedPropagator<T> {

  395.         /** Min date. */
  396.         private final FieldAbsoluteDate<T> minDate;

  398.         /** Max date. */
  399.         private final FieldAbsoluteDate<T> maxDate;

  401.         /** Simple constructor.
  402.          * @param startDate start date of the propagation
  403.          * @param endDate end date of the propagation
  404.          */
  405.         FieldBoundedPropagatorView(final FieldAbsoluteDate<T> startDate, final FieldAbsoluteDate<T> endDate) {
  406.             super(startDate.durationFrom(endDate).getField(), FieldAbstractAnalyticalPropagator.this.getAttitudeProvider());
  407.             if (startDate.compareTo(endDate) <= 0) {
  408.                 minDate = startDate;
  409.                 maxDate = endDate;
  410.             } else {
  411.                 minDate = endDate;
  412.                 maxDate = startDate;
  413.             }

  415.             try {
  416.                 // copy the same additional state providers as the original propagator
  417.                 for (FieldAdditionalStateProvider<T> provider : FieldAbstractAnalyticalPropagator.this.getAdditionalStateProviders()) {
  418.                     addAdditionalStateProvider(provider);
  419.                 }
  420.             } catch (OrekitException oe) {
  421.                 // as the providers are already compatible with each other,
  422.                 // this should never happen
  423.                 throw new OrekitInternalError(null);
  424.             }

  426.         }

  428.         /** {@inheritDoc} */
  429.         public FieldAbsoluteDate<T> getMinDate() {
  430.             return minDate;
  431.         }

  433.         /** {@inheritDoc} */
  434.         public FieldAbsoluteDate<T> getMaxDate() {
  435.             return maxDate;
  436.         }

  438.         /** {@inheritDoc} */
  439.         protected FieldOrbit<T> propagateOrbit(final FieldAbsoluteDate<T> target)
  440.             throws OrekitException {
  441.             return FieldAbstractAnalyticalPropagator.this.propagateOrbit(target);
  442.         }

  444.         /** {@inheritDoc} */
  445.         public T getMass(final FieldAbsoluteDate<T> date) throws OrekitException {
  446.             return FieldAbstractAnalyticalPropagator.this.getMass(date);
  447.         }

  449.         /** {@inheritDoc} */
  450.         public TimeStampedFieldPVCoordinates<T> getPVCoordinates(final FieldAbsoluteDate<T> date, final Frame frame)
  451.             throws OrekitException {
  452.             return propagate(date).getPVCoordinates(frame);
  453.         }

  455.         /** {@inheritDoc} */
  456.         public void resetInitialState(final FieldSpacecraftState<T> state) throws OrekitException {
  457.             FieldAbstractAnalyticalPropagator.this.resetInitialState(state);
  458.         }

  460.         /** {@inheritDoc} */
  461.         protected void resetIntermediateState(final FieldSpacecraftState<T> state, final boolean forward)
  462.             throws OrekitException {
  463.             FieldAbstractAnalyticalPropagator.this.resetIntermediateState(state, forward);
  464.         }

  466.         /** {@inheritDoc} */
  467.         public FieldSpacecraftState<T> getInitialState() throws OrekitException {
  468.             return FieldAbstractAnalyticalPropagator.this.getInitialState();
  469.         }

  471.         /** {@inheritDoc} */
  472.         public Frame getFrame() {
  473.             return FieldAbstractAnalyticalPropagator.this.getFrame();
  474.         }
  475.     }


  478.     /** Internal class for local propagation. */
  479.     private class FieldBasicStepInterpolator implements FieldOrekitStepInterpolator<T> {

  481.         /** Previous state. */
  482.         private final FieldSpacecraftState<T> previousState;

  484.         /** Current state. */
  485.         private final FieldSpacecraftState<T> currentState;

  487.         /** Forward propagation indicator. */
  488.         private final boolean forward;

  490.         /** Simple constructor.
  491.          * @param isForward integration direction indicator
  492.          * @param previousState start of the step
  493.          * @param currentState end of the step
  494.          */
  495.         FieldBasicStepInterpolator(final boolean isForward,
  496.                               final FieldSpacecraftState<T> previousState,
  497.                               final FieldSpacecraftState<T> currentState) {
  498.             this.forward             = isForward;
  499.             this.previousState   = previousState;
  500.             this.currentState    = currentState;
  501.         }

  503.         /** {@inheritDoc} */
  504.         public FieldSpacecraftState<T> getPreviousState() {
  505.             return previousState;
  506.         }

  508.         /** {@inheritDoc} */
  509.         public FieldSpacecraftState<T> getCurrentState() {
  510.             return currentState;
  511.         }

  513.         /** {@inheritDoc} */
  514.         public FieldSpacecraftState<T> getInterpolatedState(final FieldAbsoluteDate<T> date)
  515.             throws OrekitException {

  517.             // compute the basic spacecraft state
  518.             final FieldSpacecraftState<T> basicState = basicPropagate(date);

  520.             // add the additional states
  521.             return updateAdditionalStates(basicState);

  523.         }

  525.         /** {@inheritDoc} */
  526.         public boolean isForward() {
  527.             return forward;
  528.         }

  530.     }

  532. }
Created with JaCoCo 0.7.9.201702052155