AbstractAnalyticalPropagator.java

  1. /* Copyright 2002-2016 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.io.NotSerializableException;
  20. import java.io.Serializable;
  21. import java.util.ArrayList;
  22. import java.util.Collection;
  23. import java.util.Collections;
  24. import java.util.Comparator;
  25. import java.util.Iterator;
  26. import java.util.List;

  28. import org.apache.commons.math3.exception.NoBracketingException;
  29. import org.apache.commons.math3.exception.TooManyEvaluationsException;
  30. import org.apache.commons.math3.util.FastMath;
  31. import org.orekit.attitudes.Attitude;
  32. import org.orekit.attitudes.AttitudeProvider;
  33. import org.orekit.errors.OrekitException;
  34. import org.orekit.errors.OrekitInternalError;
  35. import org.orekit.errors.PropagationException;
  36. import org.orekit.frames.Frame;
  37. import org.orekit.orbits.Orbit;
  38. import org.orekit.propagation.AbstractPropagator;
  39. import org.orekit.propagation.AdditionalStateProvider;
  40. import org.orekit.propagation.BoundedPropagator;
  41. import org.orekit.propagation.SpacecraftState;
  42. import org.orekit.propagation.events.EventDetector;
  43. import org.orekit.propagation.events.EventState;
  44. import org.orekit.propagation.sampling.OrekitStepInterpolator;
  45. import org.orekit.time.AbsoluteDate;
  46. import org.orekit.utils.PVCoordinatesProvider;
  47. import org.orekit.utils.TimeStampedPVCoordinates;

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

  62.     /** Internal steps interpolator. */
  63.     private final BasicStepInterpolator interpolator;

  65.     /** Provider for attitude computation. */
  66.     private PVCoordinatesProvider pvProvider;

  68.     /** Start date of last propagation. */
  69.     private AbsoluteDate lastPropagationStart;

  71.     /** End date of last propagation. */
  72.     private AbsoluteDate 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<EventState<?>> eventsStates;

  83.     /** Build a new instance.
  84.      * @param attitudeProvider provider for attitude computation
  85.      */
  86.     protected AbstractAnalyticalPropagator(final AttitudeProvider attitudeProvider) {
  87.         setAttitudeProvider(attitudeProvider);
  88.         interpolator             = new BasicStepInterpolator();
  89.         pvProvider               = new LocalPVProvider();
  90.         lastPropagationStart     = AbsoluteDate.PAST_INFINITY;
  91.         lastPropagationEnd       = AbsoluteDate.FUTURE_INFINITY;
  92.         statesInitialized        = false;
  93.         eventsStates             = new ArrayList<EventState<?>>();
  94.     }

  96.     /** {@inheritDoc} */
  97.     public BoundedPropagator getGeneratedEphemeris() {
  98.         return new BoundedPropagatorView(lastPropagationStart, lastPropagationEnd);
  99.     }

  101.     /** {@inheritDoc} */
  102.     public <T extends EventDetector> void addEventDetector(final T detector) {
  103.         eventsStates.add(new EventState<T>(detector));
  104.     }

  106.     /** {@inheritDoc} */
  107.     public Collection<EventDetector> getEventsDetectors() {
  108.         final List<EventDetector> list = new ArrayList<EventDetector>();
  109.         for (final EventState<?> state : eventsStates) {
  110.             list.add(state.getEventDetector());
  111.         }
  112.         return Collections.unmodifiableCollection(list);
  113.     }

  115.     /** {@inheritDoc} */
  116.     public void clearEventsDetectors() {
  117.         eventsStates.clear();
  118.     }

  120.     /** {@inheritDoc} */
  121.     public SpacecraftState propagate(final AbsoluteDate start, final AbsoluteDate target)
  122.         throws PropagationException {
  123.         try {

  125.             lastPropagationStart = start;

  127.             final double dt      = target.durationFrom(start);
  128.             final double epsilon = FastMath.ulp(dt);
  129.             interpolator.storeDate(start);
  130.             SpacecraftState state = interpolator.getInterpolatedState();

  132.             // evaluate step size
  133.             final double stepSize;
  134.             if (getMode() == MASTER_MODE) {
  135.                 if (Double.isNaN(getFixedStepSize())) {
  136.                     stepSize = FastMath.copySign(state.getKeplerianPeriod() / 100, dt);
  137.                 } else {
  138.                     stepSize = FastMath.copySign(getFixedStepSize(), dt);
  139.                 }
  140.             } else {
  141.                 stepSize = dt;
  142.             }

  144.             // initialize event detectors
  145.             for (final EventState<?> es : eventsStates) {
  146.                 es.init(state, target);
  147.             }

  149.             // initialize step handler
  150.             if (getStepHandler() != null) {
  151.                 getStepHandler().init(state, target);
  152.             }

  154.             // iterate over the propagation range
  155.             statesInitialized = false;
  156.             isLastStep = false;
  157.             do {

  159.                 // go ahead one step size
  160.                 interpolator.shift();
  161.                 final AbsoluteDate t = interpolator.getCurrentDate().shiftedBy(stepSize);
  162.                 if ((dt == 0) || ((dt > 0) ^ (t.compareTo(target) <= 0))) {
  163.                     // current step exceeds target
  164.                     interpolator.storeDate(target);
  165.                 } else {
  166.                     // current step is within range
  167.                     interpolator.storeDate(t);
  168.                 }

  170.                 // accept the step, trigger events and step handlers
  171.                 state = acceptStep(target, epsilon);

  173.             } while (!isLastStep);

  175.             // return the last computed state
  176.             lastPropagationEnd = state.getDate();
  177.             setStartDate(state.getDate());
  178.             return state;

  180.         } catch (PropagationException pe) {
  181.             throw pe;
  182.         } catch (OrekitException oe) {
  183.             throw PropagationException.unwrap(oe);
  184.         } catch (TooManyEvaluationsException tmee) {
  185.             throw PropagationException.unwrap(tmee);
  186.         } catch (NoBracketingException nbe) {
  187.             throw PropagationException.unwrap(nbe);
  188.         }
  189.     }

  191.     /** Accept a step, triggering events and step handlers.
  192.      * @param target final propagation time
  193.      * @param epsilon threshold for end date detection
  194.      * @return state at the end of the step
  195.      * @exception OrekitException if the switching function cannot be evaluated
  196.      * @exception TooManyEvaluationsException if an event cannot be located
  197.      * @exception NoBracketingException if bracketing cannot be performed
  198.      */
  199.     protected SpacecraftState acceptStep(final AbsoluteDate target, final double epsilon)
  200.         throws OrekitException, TooManyEvaluationsException, NoBracketingException {

  202.         AbsoluteDate previousT = interpolator.getGlobalPreviousDate();
  203.         AbsoluteDate currentT  = interpolator.getGlobalCurrentDate();

  205.         // initialize the events states if needed
  206.         if (!statesInitialized) {

  208.             if (!eventsStates.isEmpty()) {
  209.                 // initialize the events states
  210.                 final AbsoluteDate t0 = interpolator.getPreviousDate();
  211.                 interpolator.setInterpolatedDate(t0);
  212.                 final SpacecraftState y = interpolator.getInterpolatedState();
  213.                 for (final EventState<?> state : eventsStates) {
  214.                     state.reinitializeBegin(y, interpolator.isForward());
  215.                 }
  216.             }

  218.             statesInitialized = true;

  220.         }

  222.         // search for next events that may occur during the step
  223.         final List<EventState<?>> occurringEvents = new ArrayList<EventState<?>>();
  224.         for (final EventState<?> state : eventsStates) {
  225.             if (state.evaluateStep(interpolator)) {
  226.                 // the event occurs during the current step
  227.                 occurringEvents.add(state);
  228.             }
  229.         }

  231.         // chronological or reverse chronological sorter, according to propagation direction
  232.         final int orderingSign = interpolator.isForward() ? +1 : -1;
  233.         final Comparator<EventState<?>> sorter = new Comparator<EventState<?>>() {

  235.             /** {@inheritDoc} */
  236.             public int compare(final EventState<?> es0, final EventState<?> es1) {
  237.                 return orderingSign * es0.getEventTime().compareTo(es1.getEventTime());
  238.             }

  240.         };

  242.         while (!occurringEvents.isEmpty()) {

  244.             // handle the chronologically first event
  245.             Collections.sort(occurringEvents, sorter);
  246.             final Iterator<EventState<?>> iterator = occurringEvents.iterator();
  247.             final EventState<?> currentEvent = iterator.next();
  248.             iterator.remove();

  250.             // restrict the interpolator to the first part of the step, up to the event
  251.             final AbsoluteDate eventT = currentEvent.getEventTime();
  252.             interpolator.setSoftPreviousDate(previousT);
  253.             interpolator.setSoftCurrentDate(eventT);

  255.             // trigger the event
  256.             interpolator.setInterpolatedDate(eventT);
  257.             final SpacecraftState eventY = interpolator.getInterpolatedState();
  258.             currentEvent.stepAccepted(eventY);
  259.             isLastStep = currentEvent.stop();

  261.             // handle the first part of the step, up to the event
  262.             if (getStepHandler() != null) {
  263.                 getStepHandler().handleStep(interpolator, isLastStep);
  264.             }

  266.             if (isLastStep) {
  267.                 // the event asked to stop integration
  268.                 return eventY;
  269.             }

  271.             final SpacecraftState resetState = currentEvent.reset(eventY);
  272.             if (resetState != null) {
  273.                 resetIntermediateState(resetState, interpolator.isForward());
  274.                 return resetState;
  275.             }

  277.             // prepare handling of the remaining part of the step
  278.             previousT = eventT;
  279.             interpolator.setSoftPreviousDate(eventT);
  280.             interpolator.setSoftCurrentDate(currentT);

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

  288.         }

  290.         final double remaining = target.durationFrom(currentT);
  291.         if (interpolator.isForward()) {
  292.             isLastStep = remaining <  epsilon;
  293.         } else {
  294.             isLastStep = remaining > -epsilon;
  295.         }
  296.         if (isLastStep) {
  297.             currentT = target;
  298.         }

  300.         interpolator.setInterpolatedDate(currentT);
  301.         final SpacecraftState currentY = interpolator.getInterpolatedState();
  302.         for (final EventState<?> state : eventsStates) {
  303.             state.stepAccepted(currentY);
  304.             isLastStep = isLastStep || state.stop();
  305.         }

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

  312.         return currentY;

  314.     }

  316.     /** Get the mass.
  317.      * @param date target date for the orbit
  318.      * @return mass mass
  319.      * @exception PropagationException if some parameters are out of bounds
  320.      */
  321.     protected abstract double getMass(final AbsoluteDate date)
  322.         throws PropagationException;

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

  331.     /** {@inheritDoc} */
  332.     public void resetInitialState(final SpacecraftState state)
  333.         throws PropagationException {
  334.         super.resetInitialState(state);
  335.         interpolator.globalCurrentDate = state.getDate();
  336.         interpolator.softCurrentDate   = interpolator.globalCurrentDate;
  337.     }

  339.     /** Reset an intermediate state.
  340.      * @param state new intermediate state to consider
  341.      * @param forward if true, the intermediate state is valid for
  342.      * propagations after itself
  343.      * @exception PropagationException if initial state cannot be reset
  344.      */
  345.     protected void resetIntermediateState(final SpacecraftState state, final boolean forward)
  346.         throws PropagationException {
  347.         interpolator.globalCurrentDate = state.getDate();
  348.         interpolator.softCurrentDate   = interpolator.globalCurrentDate;
  349.     }

  351.     /** Extrapolate an orbit up to a specific target date.
  352.      * @param date target date for the orbit
  353.      * @return extrapolated parameters
  354.      * @exception PropagationException if some parameters are out of bounds
  355.      */
  356.     protected abstract Orbit propagateOrbit(final AbsoluteDate date)
  357.         throws PropagationException;

  359.     /** Propagate an orbit without any fancy features.
  360.      * <p>This method is similar in spirit to the {@link #propagate} method,
  361.      * except that it does <strong>not</strong> call any handler during
  362.      * propagation, nor any discrete events, not additional states. It always
  363.      * stop exactly at the specified date.</p>
  364.      * @param date target date for propagation
  365.      * @return state at specified date
  366.      * @exception PropagationException if propagation cannot reach specified date
  367.      */
  368.     protected SpacecraftState basicPropagate(final AbsoluteDate date) throws PropagationException {
  369.         try {

  371.             // evaluate orbit
  372.             final Orbit orbit = propagateOrbit(date);

  374.             // evaluate attitude
  375.             final Attitude attitude =
  376.                 getAttitudeProvider().getAttitude(pvProvider, date, orbit.getFrame());

  378.             // build raw state
  379.             return new SpacecraftState(orbit, attitude, getMass(date));

  381.         } catch (OrekitException oe) {
  382.             throw new PropagationException(oe);
  383.         }
  384.     }

  386.     /** Internal PVCoordinatesProvider for attitude computation. */
  387.     private class LocalPVProvider implements PVCoordinatesProvider {

  389.         /** {@inheritDoc} */
  390.         public TimeStampedPVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame frame)
  391.             throws OrekitException {
  392.             return propagateOrbit(date).getPVCoordinates(frame);
  393.         }

  395.     }

  397.     /** {@link BoundedPropagator} view of the instance. */
  398.     private class BoundedPropagatorView
  399.         extends AbstractAnalyticalPropagator
  400.         implements BoundedPropagator, Serializable {

  402.         /** Serializable UID. */
  403.         private static final long serialVersionUID = 20151117L;

  405.         /** Min date. */
  406.         private final AbsoluteDate minDate;

  408.         /** Max date. */
  409.         private final AbsoluteDate maxDate;

  411.         /** Simple constructor.
  412.          * @param startDate start date of the propagation
  413.          * @param endDate end date of the propagation
  414.          */
  415.         BoundedPropagatorView(final AbsoluteDate startDate, final AbsoluteDate endDate) {
  416.             super(AbstractAnalyticalPropagator.this.getAttitudeProvider());
  417.             if (startDate.compareTo(endDate) <= 0) {
  418.                 minDate = startDate;
  419.                 maxDate = endDate;
  420.             } else {
  421.                 minDate = endDate;
  422.                 maxDate = startDate;
  423.             }

  425.             try {
  426.                 // copy the same additional state providers as the original propagator
  427.                 for (AdditionalStateProvider provider : AbstractAnalyticalPropagator.this.getAdditionalStateProviders()) {
  428.                     addAdditionalStateProvider(provider);
  429.                 }
  430.             } catch (OrekitException oe) {
  431.                 // as the providers are already compatible with each other,
  432.                 // this should never happen
  433.                 throw new OrekitInternalError(null);
  434.             }

  436.         }

  438.         /** {@inheritDoc} */
  439.         public AbsoluteDate getMinDate() {
  440.             return minDate;
  441.         }

  443.         /** {@inheritDoc} */
  444.         public AbsoluteDate getMaxDate() {
  445.             return maxDate;
  446.         }

  448.         /** {@inheritDoc} */
  449.         protected Orbit propagateOrbit(final AbsoluteDate target)
  450.             throws PropagationException {
  451.             return AbstractAnalyticalPropagator.this.propagateOrbit(target);
  452.         }

  454.         /** {@inheritDoc} */
  455.         public double getMass(final AbsoluteDate date) throws PropagationException {
  456.             return AbstractAnalyticalPropagator.this.getMass(date);
  457.         }

  459.         /** {@inheritDoc} */
  460.         public TimeStampedPVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame frame)
  461.             throws OrekitException {
  462.             return propagate(date).getPVCoordinates(frame);
  463.         }

  465.         /** {@inheritDoc} */
  466.         public void resetInitialState(final SpacecraftState state) throws PropagationException {
  467.             AbstractAnalyticalPropagator.this.resetInitialState(state);
  468.         }

  470.         /** {@inheritDoc} */
  471.         protected void resetIntermediateState(final SpacecraftState state, final boolean forward)
  472.             throws PropagationException {
  473.             AbstractAnalyticalPropagator.this.resetIntermediateState(state, forward);
  474.         }

  476.         /** {@inheritDoc} */
  477.         public SpacecraftState getInitialState() throws PropagationException {
  478.             return AbstractAnalyticalPropagator.this.getInitialState();
  479.         }

  481.         /** {@inheritDoc} */
  482.         public Frame getFrame() {
  483.             return AbstractAnalyticalPropagator.this.getFrame();
  484.         }

  486.         /** Replace the instance with a data transfer object for serialization.
  487.          * @return data transfer object that will be serialized
  488.          * @exception NotSerializableException if attitude provider or additional
  489.          * state provider is not serializable
  490.          */
  491.         private Object writeReplace() throws NotSerializableException {
  492.             return new DataTransferObject(minDate, maxDate, AbstractAnalyticalPropagator.this);
  493.         }

  495.     }

  497.     /** Internal class used only for serialization. */
  498.     private static class DataTransferObject implements Serializable {

  500.         /** Serializable UID. */
  501.         private static final long serialVersionUID = 20151117L;

  503.         /** Min date. */
  504.         private final AbsoluteDate minDate;

  506.         /** Max date. */
  507.         private final AbsoluteDate maxDate;

  509.         /** Underlying propagator. */
  510.         private final AbstractAnalyticalPropagator propagator;

  512.         /** Simple constructor.
  513.          * @param minDate min date
  514.          * @param maxDate max date
  515.          * @param propagator underlying propagator
  516.          */
  517.         DataTransferObject(final AbsoluteDate minDate, final AbsoluteDate maxDate,
  518.                            final AbstractAnalyticalPropagator propagator) {
  519.             this.minDate    = minDate;
  520.             this.maxDate    = maxDate;
  521.             this.propagator = propagator;
  522.         }

  524.         /** Replace the deserialized data transfer object with an {@link BoundedPropagatorView}.
  525.          * @return replacement {@link BoundedPropagatorView}
  526.          */
  527.         private Object readResolve() {
  528.             propagator.lastPropagationStart = minDate;
  529.             propagator.lastPropagationEnd   = maxDate;
  530.             return propagator.getGeneratedEphemeris();
  531.         }

  533.     }

  535.     /** Internal class for local propagation. */
  536.     private class BasicStepInterpolator implements OrekitStepInterpolator {

  538.         /** Global previous date. */
  539.         private AbsoluteDate globalPreviousDate;

  541.         /** Global current date. */
  542.         private AbsoluteDate globalCurrentDate;

  544.         /** Soft previous date. */
  545.         private AbsoluteDate softPreviousDate;

  547.         /** Soft current date. */
  548.         private AbsoluteDate softCurrentDate;

  550.         /** Interpolated state. */
  551.         private SpacecraftState interpolatedState;

  553.         /** Forward propagation indicator. */
  554.         private boolean forward;

  556.         /** Build a new instance from a basic propagator.
  557.          */
  558.         BasicStepInterpolator() {
  559.             globalPreviousDate = AbsoluteDate.PAST_INFINITY;
  560.             globalCurrentDate  = AbsoluteDate.PAST_INFINITY;
  561.             softPreviousDate   = AbsoluteDate.PAST_INFINITY;
  562.             softCurrentDate    = AbsoluteDate.PAST_INFINITY;
  563.         }

  565.         /** Restrict step range to a limited part of the global step.
  566.          * <p>
  567.          * This method can be used to restrict a step and make it appear
  568.          * as if the original step was smaller. Calling this method
  569.          * <em>only</em> changes the value returned by {@link #getPreviousDate()},
  570.          * it does not change any other property
  571.          * </p>
  572.          * @param softPreviousDate start of the restricted step
  573.          */
  574.         public void setSoftPreviousDate(final AbsoluteDate softPreviousDate) {
  575.             this.softPreviousDate = softPreviousDate;
  576.         }

  578.         /** Restrict step range to a limited part of the global step.
  579.          * <p>
  580.          * This method can be used to restrict a step and make it appear
  581.          * as if the original step was smaller. Calling this method
  582.          * <em>only</em> changes the value returned by {@link #getCurrentDate()},
  583.          * it does not change any other property
  584.          * </p>
  585.          * @param softCurrentDate end of the restricted step
  586.          */
  587.         public void setSoftCurrentDate(final AbsoluteDate softCurrentDate) {
  588.             this.softCurrentDate  = softCurrentDate;
  589.         }

  591.         /**
  592.          * Get the previous global grid point time.
  593.          * @return previous global grid point time
  594.          */
  595.         public AbsoluteDate getGlobalPreviousDate() {
  596.             return globalPreviousDate;
  597.         }

  599.         /**
  600.          * Get the current global grid point time.
  601.          * @return current global grid point time
  602.          */
  603.         public AbsoluteDate getGlobalCurrentDate() {
  604.             return globalCurrentDate;
  605.         }

  607.         /** {@inheritDoc} */
  608.         public AbsoluteDate getCurrentDate() {
  609.             return softCurrentDate;
  610.         }

  612.         /** {@inheritDoc} */
  613.         public AbsoluteDate getInterpolatedDate() {
  614.             return interpolatedState.getDate();
  615.         }

  617.         /** {@inheritDoc} */
  618.         public SpacecraftState getInterpolatedState() throws OrekitException {
  619.             return interpolatedState;
  620.         }

  622.         /** {@inheritDoc} */
  623.         public AbsoluteDate getPreviousDate() {
  624.             return softPreviousDate;
  625.         }

  627.         /** {@inheritDoc} */
  628.         public boolean isForward() {
  629.             return forward;
  630.         }

  632.         /** {@inheritDoc} */
  633.         public void setInterpolatedDate(final AbsoluteDate date) throws PropagationException {

  635.             // compute the basic spacecraft state
  636.             final SpacecraftState basicState = basicPropagate(date);

  638.             // add the additional states
  639.             interpolatedState = updateAdditionalStates(basicState);

  641.         }

  643.         /** Shift one step forward.
  644.          * Copy the current date into the previous date, hence preparing the
  645.          * interpolator for future calls to {@link #storeDate storeDate}
  646.          */
  647.         public void shift() {
  648.             globalPreviousDate = globalCurrentDate;
  649.             softPreviousDate   = globalPreviousDate;
  650.             softCurrentDate    = globalCurrentDate;
  651.         }

  653.         /** Store the current step date.
  654.          * @param date current date
  655.          * @exception PropagationException if the state cannot be propagated at specified date
  656.          */
  657.         public void storeDate(final AbsoluteDate date)
  658.             throws PropagationException {
  659.             globalCurrentDate = date;
  660.             softCurrentDate   = globalCurrentDate;
  661.             forward           = globalCurrentDate.compareTo(globalPreviousDate) >= 0;
  662.             setInterpolatedDate(globalCurrentDate);
  663.         }

  665.     }

  667. }
Created with JaCoCo 0.7.4.201502262128