EventState.java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * The ASF 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.events;

  19. import org.hipparchus.analysis.UnivariateFunction;
  20. import org.hipparchus.analysis.solvers.BracketedUnivariateSolver;
  21. import org.hipparchus.analysis.solvers.BracketedUnivariateSolver.Interval;
  22. import org.hipparchus.analysis.solvers.BracketingNthOrderBrentSolver;
  23. import org.hipparchus.exception.MathRuntimeException;
  24. import org.hipparchus.util.FastMath;
  25. import org.hipparchus.util.Precision;
  26. import org.orekit.errors.OrekitException;
  27. import org.orekit.errors.OrekitExceptionWrapper;
  28. import org.orekit.errors.OrekitInternalError;
  29. import org.orekit.propagation.SpacecraftState;
  30. import org.orekit.propagation.events.handlers.EventHandler;
  31. import org.orekit.propagation.sampling.OrekitStepInterpolator;
  32. import org.orekit.time.AbsoluteDate;

  34. import java.io.Serializable;

  36. /** This class handles the state for one {@link EventDetector
  37.  * event detector} during integration steps.
  38.  *
  39.  * <p>This class is heavily based on the class with the same name from the
  40.  * Hipparchus library. The changes performed consist in replacing
  41.  * raw types (double and double arrays) with space dynamics types
  42.  * ({@link AbsoluteDate}, {@link SpacecraftState}).</p>
  43.  * <p>Each time the propagator proposes a step, the event detector
  44.  * should be checked. This class handles the state of one detector
  45.  * during one propagation step, with references to the state at the
  46.  * end of the preceding step. This information is used to determine if
  47.  * the detector should trigger an event or not during the proposed
  48.  * step (and hence the step should be reduced to ensure the event
  49.  * occurs at a bound rather than inside the step).</p>
  50.  * @author Luc Maisonobe
  51.  * @param <T> class type for the generic version
  52.  */
  53. public class EventState<T extends EventDetector> implements Serializable {

  55.     /** Serializable version identifier. */
  56.     private static final long serialVersionUID = 4489391420715269318L;

  58.     /** Event detector. */
  59.     private T detector;

  61.     /** Time of the previous call to g. */
  62.     private AbsoluteDate lastT;

  64.     /** Value from the previous call to g. */
  65.     private double lastG;

  67.     /** Time at the beginning of the step. */
  68.     private AbsoluteDate t0;

  70.     /** Value of the event detector at the beginning of the step. */
  71.     private double g0;

  73.     /** Simulated sign of g0 (we cheat when crossing events). */
  74.     private boolean g0Positive;

  76.     /** Indicator of event expected during the step. */
  77.     private boolean pendingEvent;

  79.     /** Occurrence time of the pending event. */
  80.     private AbsoluteDate pendingEventTime;

  82.     /**
  83.      * Time to stop propagation if the event is a stop event. Used to enable stopping at
  84.      * an event and then restarting after that event.
  85.      */
  86.     private AbsoluteDate stopTime;

  88.     /** Time after the current event. */
  89.     private AbsoluteDate afterEvent;

  91.     /** Value of the g function after the current event. */
  92.     private double afterG;

  94.     /** The earliest time considered for events. */
  95.     private AbsoluteDate earliestTimeConsidered;

  97.     /** Integration direction. */
  98.     private boolean forward;

  100.     /** Variation direction around pending event.
  101.      *  (this is considered with respect to the integration direction)
  102.      */
  103.     private boolean increasing;

  105.     /** Simple constructor.
  106.      * @param detector monitored event detector
  107.      */
  108.     public EventState(final T detector) {
  109.         this.detector     = detector;

  111.         // some dummy values ...
  112.         lastT                  = AbsoluteDate.PAST_INFINITY;
  113.         lastG                  = Double.NaN;
  114.         t0                     = null;
  115.         g0                     = Double.NaN;
  116.         g0Positive             = true;
  117.         pendingEvent           = false;
  118.         pendingEventTime       = null;
  119.         stopTime               = null;
  120.         increasing             = true;
  121.         earliestTimeConsidered = null;
  122.         afterEvent             = null;
  123.         afterG                 = Double.NaN;

  125.     }

  127.     /** Get the underlying event detector.
  128.      * @return underlying event detector
  129.      */
  130.     public T getEventDetector() {
  131.         return detector;
  132.     }

  134.     /** Initialize event handler at the start of a propagation.
  135.      * <p>
  136.      * This method is called once at the start of the propagation. It
  137.      * may be used by the event handler to initialize some internal data
  138.      * if needed.
  139.      * </p>
  140.      * @param s0 initial state
  141.      * @param t target time for the integration
  142.      *
  143.      * @throws OrekitException if some specific error occurs
  144.      */
  145.     public void init(final SpacecraftState s0,
  146.                      final AbsoluteDate t) throws OrekitException {
  147.         detector.init(s0, t);
  148.         lastT = AbsoluteDate.PAST_INFINITY;
  149.         lastG = Double.NaN;
  150.     }

  152.     /** Compute the value of the switching function.
  153.      * This function must be continuous (at least in its roots neighborhood),
  154.      * as the integrator will need to find its roots to locate the events.
  155.      * @param s the current state information: date, kinematics, attitude
  156.      * @return value of the switching function
  157.      * @exception OrekitException if some specific error occurs
  158.      */
  159.     private double g(final SpacecraftState s) throws OrekitException {
  160.         if (!s.getDate().equals(lastT)) {
  161.             lastT = s.getDate();
  162.             lastG = detector.g(s);
  163.         }
  164.         return lastG;
  165.     }

  167.     /** Reinitialize the beginning of the step.
  168.      * @param interpolator interpolator valid for the current step
  169.      * @exception OrekitException if the event detector
  170.      * value cannot be evaluated at the beginning of the step
  171.      */
  172.     public void reinitializeBegin(final OrekitStepInterpolator interpolator)
  173.         throws OrekitException {
  174.         forward = interpolator.isForward();
  175.         final SpacecraftState s0 = interpolator.getPreviousState();
  176.         this.t0 = s0.getDate();
  177.         g0 = g(s0);
  178.         while (g0 == 0) {
  179.             // extremely rare case: there is a zero EXACTLY at interval start
  180.             // we will use the sign slightly after step beginning to force ignoring this zero
  181.             // try moving forward by half a convergence interval
  182.             final double dt = (forward ? 0.5 : -0.5) * detector.getThreshold();
  183.             AbsoluteDate startDate = t0.shiftedBy(dt);
  184.             // if convergence is too small move an ulp
  185.             if (t0.equals(startDate)) {
  186.                 startDate = nextAfter(startDate);
  187.             }
  188.             t0 = startDate;
  189.             g0 = g(interpolator.getInterpolatedState(t0));
  190.         }
  191.         g0Positive = g0 > 0;
  192.         // "last" event was increasing
  193.         increasing = g0Positive;
  194.     }

  196.     /** Evaluate the impact of the proposed step on the event detector.
  197.      * @param interpolator step interpolator for the proposed step
  198.      * @return true if the event detector triggers an event before
  199.      * the end of the proposed step (this implies the step should be
  200.      * rejected)
  201.      * @exception OrekitException if the switching function
  202.      * cannot be evaluated
  203.      * @exception MathRuntimeException if an event cannot be located
  204.      */
  205.     public boolean evaluateStep(final OrekitStepInterpolator interpolator)
  206.         throws OrekitException, MathRuntimeException {

  208.         forward = interpolator.isForward();
  209.         final SpacecraftState s1 = interpolator.getCurrentState();
  210.         final AbsoluteDate t1 = s1.getDate();
  211.         final double dt = t1.durationFrom(t0);
  212.         if (FastMath.abs(dt) < detector.getThreshold()) {
  213.             // we cannot do anything on such a small step, don't trigger any events
  214.             return false;
  215.         }
  216.         // number of points to check in the current step
  217.         final int n = FastMath.max(1, (int) FastMath.ceil(FastMath.abs(dt) / detector.getMaxCheckInterval()));
  218.         final double h = dt / n;


  221.         AbsoluteDate ta = t0;
  222.         double ga = g0;
  223.         for (int i = 0; i < n; ++i) {

  225.             // evaluate handler value at the end of the substep
  226.             final AbsoluteDate tb = (i == n - 1) ? t1 : t0.shiftedBy((i + 1) * h);
  227.             final double gb = g(interpolator.getInterpolatedState(tb));

  229.             // check events occurrence
  230.             if (gb == 0.0 || (g0Positive ^ (gb > 0))) {
  231.                 // there is a sign change: an event is expected during this step
  232.                 if (findRoot(interpolator, ta, ga, tb, gb)) {
  233.                     return true;
  234.                 }
  235.             } else {
  236.                 // no sign change: there is no event for now
  237.                 ta = tb;
  238.                 ga = gb;
  239.             }

  241.         }

  243.         // no event during the whole step
  244.         pendingEvent     = false;
  245.         pendingEventTime = null;
  246.         return false;

  248.     }

  250.     /**
  251.      * Find a root in a bracketing interval.
  252.      *
  253.      * <p> When calling this method one of the following must be true. Either ga == 0, gb
  254.      * == 0, (ga < 0  and gb > 0), or (ga > 0 and gb < 0).
  255.      *
  256.      * @param interpolator that covers the interval.
  257.      * @param ta           earliest possible time for root.
  258.      * @param ga           g(ta).
  259.      * @param tb           latest possible time for root.
  260.      * @param gb           g(tb).
  261.      * @return if a zero crossing was found.
  262.      * @throws OrekitException if the event detector throws one
  263.      */
  264.     private boolean findRoot(final OrekitStepInterpolator interpolator,
  265.                              final AbsoluteDate ta, final double ga,
  266.                              final AbsoluteDate tb, final double gb)
  267.             throws OrekitException {
  268.         // check there appears to be a root in [ta, tb]
  269.         check(ga == 0.0 || gb == 0.0 || (ga > 0.0 && gb < 0.0) || (ga < 0.0 && gb > 0.0));

  271.         final double convergence = detector.getThreshold();
  272.         final int maxIterationCount = detector.getMaxIterationCount();
  273.         final BracketedUnivariateSolver<UnivariateFunction> solver =
  274.                 new BracketingNthOrderBrentSolver(0, convergence, 0, 5);

  276.         // event time, just at or before the actual root.
  277.         AbsoluteDate beforeRootT = null;
  278.         double beforeRootG = Double.NaN;
  279.         // time on the other side of the root.
  280.         // Initialized the the loop below executes once.
  281.         AbsoluteDate afterRootT = ta;
  282.         double afterRootG = 0.0;

  284.         // check for some conditions that the root finders don't like
  285.         // these conditions cannot not happen in the loop below
  286.         // the ga == 0.0 case is handled by the loop below
  287.         if (ta.equals(tb)) {
  288.             // both non-zero but times are the same. Probably due to reset state
  289.             beforeRootT = ta;
  290.             beforeRootG = ga;
  291.             afterRootT = shiftedBy(beforeRootT, convergence);
  292.             afterRootG = g(interpolator.getInterpolatedState(afterRootT));
  293.         } else if (ga != 0.0 && gb == 0.0) {
  294.             // hard: ga != 0.0 and gb == 0.0
  295.             // look past gb by up to convergence to find next sign
  296.             // throw an exception if g(t) = 0.0 in [tb, tb + convergence]
  297.             beforeRootT = tb;
  298.             beforeRootG = gb;
  299.             afterRootT = shiftedBy(beforeRootT, convergence);
  300.             afterRootG = g(interpolator.getInterpolatedState(afterRootT));
  301.         } else if (ga != 0.0) {
  302.             final double newGa = g(interpolator.getInterpolatedState(ta));
  303.             if (ga > 0 != newGa > 0) {
  304.                 // both non-zero, step sign change at ta, possibly due to reset state
  305.                 beforeRootT = ta;
  306.                 beforeRootG = newGa;
  307.                 afterRootT = minTime(shiftedBy(beforeRootT, convergence), tb);
  308.                 afterRootG = g(interpolator.getInterpolatedState(afterRootT));
  309.             }
  310.         }

  312.         // loop to skip through "fake" roots, i.e. where g(t) = g'(t) = 0.0
  313.         // executed once if we didn't hit a special case above
  314.         AbsoluteDate loopT = ta;
  315.         double loopG = ga;
  316.         while ((afterRootG == 0.0 || afterRootG > 0.0 == g0Positive) &&
  317.                 strictlyAfter(afterRootT, tb)) {
  318.             if (loopG == 0.0) {
  319.                 // ga == 0.0 and gb may or may not be 0.0
  320.                 // handle the root at ta first
  321.                 beforeRootT = loopT;
  322.                 beforeRootG = loopG;
  323.                 afterRootT = minTime(shiftedBy(beforeRootT, convergence), tb);
  324.                 afterRootG = g(interpolator.getInterpolatedState(afterRootT));
  325.             } else {
  326.                 // both non-zero, the usual case, use a root finder.
  327.                 try {
  328.                     // time zero for evaluating the function f. Needs to be final
  329.                     final AbsoluteDate fT0 = loopT;
  330.                     final UnivariateFunction f = dt -> {
  331.                         try {
  332.                             return g(interpolator.getInterpolatedState(fT0.shiftedBy(dt)));
  333.                         } catch (OrekitException oe) {
  334.                             throw new OrekitExceptionWrapper(oe);
  335.                         }
  336.                     };
  337.                     // tb as a double for use in f
  338.                     final double tbDouble = tb.durationFrom(fT0);
  339.                     if (forward) {
  340.                         final Interval interval =
  341.                                 solver.solveInterval(maxIterationCount, f, 0, tbDouble);
  342.                         beforeRootT = fT0.shiftedBy(interval.getLeftAbscissa());
  343.                         beforeRootG = interval.getLeftValue();
  344.                         afterRootT = fT0.shiftedBy(interval.getRightAbscissa());
  345.                         afterRootG = interval.getRightValue();
  346.                     } else {
  347.                         final Interval interval =
  348.                                 solver.solveInterval(maxIterationCount, f, tbDouble, 0);
  349.                         beforeRootT = fT0.shiftedBy(interval.getRightAbscissa());
  350.                         beforeRootG = interval.getRightValue();
  351.                         afterRootT = fT0.shiftedBy(interval.getLeftAbscissa());
  352.                         afterRootG = interval.getLeftValue();
  353.                     }
  354.                 } catch (OrekitExceptionWrapper oew) {
  355.                     throw oew.getException();
  356.                 }
  357.             }
  358.             // tolerance is set to less than 1 ulp
  359.             // assume tolerance is 1 ulp
  360.             if (beforeRootT.equals(afterRootT)) {
  361.                 afterRootT = nextAfter(afterRootT);
  362.                 afterRootG = g(interpolator.getInterpolatedState(afterRootT));
  363.             }
  364.             // check loop is making some progress
  365.             check((forward && afterRootT.compareTo(beforeRootT) > 0) ||
  366.                   (!forward && afterRootT.compareTo(beforeRootT) < 0));
  367.             // setup next iteration
  368.             loopT = afterRootT;
  369.             loopG = afterRootG;
  370.         }

  372.         // figure out the result of root finding, and return accordingly
  373.         if (afterRootG == 0.0 || afterRootG > 0.0 == g0Positive) {
  374.             // loop gave up and didn't find any crossing within this step
  375.             return false;
  376.         } else {
  377.             // real crossing
  378.             check(beforeRootT != null && !Double.isNaN(beforeRootG));
  379.             // variation direction, with respect to the integration direction
  380.             increasing = !g0Positive;
  381.             pendingEventTime = beforeRootT;
  382.             stopTime = beforeRootG == 0.0 ? beforeRootT : afterRootT;
  383.             pendingEvent = true;
  384.             afterEvent = afterRootT;
  385.             afterG = afterRootG;

  387.             // check increasing set correctly
  388.             check(afterG > 0 == increasing);
  389.             check(increasing == gb >= ga);

  391.             return true;
  392.         }

  394.     }

  396.     /**
  397.      * Get the next number after the given number in the current propagation direction.
  398.      *
  399.      * @param t input time
  400.      * @return t +/- 1 ulp depending on the direction.
  401.      */
  402.     private AbsoluteDate nextAfter(final AbsoluteDate t) {
  403.         return t.shiftedBy(forward ? +Precision.EPSILON : -Precision.EPSILON);
  404.     }

  406.     /** Get the occurrence time of the event triggered in the current
  407.      * step.
  408.      * @return occurrence time of the event triggered in the current
  409.      * step.
  410.      */
  411.     public AbsoluteDate getEventDate() {
  412.         return pendingEventTime;
  413.     }

  415.     /**
  416.      * Try to accept the current history up to the given time.
  417.      *
  418.      * <p> It is not necessary to call this method before calling {@link
  419.      * #doEvent(SpacecraftState)} with the same state. It is necessary to call this
  420.      * method before you call {@link #doEvent(SpacecraftState)} on some other event
  421.      * detector.
  422.      *
  423.      * @param state        to try to accept.
  424.      * @param interpolator to use to find the new root, if any.
  425.      * @return if the event detector has an event it has not detected before that is on or
  426.      * before the same time as {@code state}. In other words {@code false} means continue
  427.      * on while {@code true} means stop and handle my event first.
  428.      * @exception OrekitException if the g function throws one
  429.      */
  430.     public boolean tryAdvance(final SpacecraftState state,
  431.                               final OrekitStepInterpolator interpolator)
  432.         throws OrekitException {
  433.         // check this is only called before a pending event.
  434.         check(!(pendingEvent && strictlyAfter(pendingEventTime, state.getDate())));

  436.         final AbsoluteDate t = state.getDate();

  438.         // just found an event and we know the next time we want to search again
  439.         if (strictlyAfter(t, earliestTimeConsidered)) {
  440.             return false;
  441.         }

  443.         final double g = g(state);
  444.         final boolean positive = g > 0;

  446.         // check for new root, pendingEventTime may be null if there is not pending event
  447.         if ((g == 0.0 && t.equals(pendingEventTime)) || positive == g0Positive) {
  448.             // at a root we already found, or g function has expected sign
  449.             t0 = t;
  450.             g0 = g; // g0Positive is the same
  451.             return false;
  452.         } else {
  453.             // found a root we didn't expect -> find precise location
  454.             return findRoot(interpolator, t0, g0, t, g);
  455.         }
  456.     }

  458.     /**
  459.      * Notify the user's listener of the event. The event occurs wholly within this method
  460.      * call including a call to {@link EventDetector#resetState(SpacecraftState)}
  461.      * if necessary.
  462.      *
  463.      * @param state the state at the time of the event. This must be at the same time as
  464.      *              the current value of {@link #getEventDate()}.
  465.      * @return the user's requested action and the new state if the action is {@link
  466.      * org.orekit.propagation.events.handlers.EventHandler.Action#RESET_STATE Action.RESET_STATE}.
  467.      * Otherwise the new state is {@code state}. The stop time indicates what time propagation
  468.      * should stop if the action is {@link
  469.      * org.orekit.propagation.events.handlers.EventHandler.Action#STOP Action.STOP}.
  470.      * This guarantees the integration will stop on or after the root, so that integration
  471.      * may be restarted safely.
  472.      * @exception OrekitException if the event detector throws one
  473.      */
  474.     public EventOccurrence doEvent(final SpacecraftState state)
  475.         throws OrekitException {
  476.         // check event is pending and is at the same time
  477.         check(pendingEvent);
  478.         check(state.getDate().equals(this.pendingEventTime));

  480.         final EventHandler.Action action = detector.eventOccurred(state, increasing == forward);
  481.         final SpacecraftState newState;
  482.         if (action == EventHandler.Action.RESET_STATE) {
  483.             newState = detector.resetState(state);
  484.         } else {
  485.             newState = state;
  486.         }
  487.         // clear pending event
  488.         pendingEvent     = false;
  489.         pendingEventTime = null;
  490.         // setup for next search
  491.         earliestTimeConsidered = afterEvent;
  492.         t0 = afterEvent;
  493.         g0 = afterG;
  494.         g0Positive = increasing;
  495.         // check g0Positive set correctly
  496.         check(g0 == 0.0 || g0Positive == (g0 > 0));
  497.         return new EventOccurrence(action, newState, stopTime);
  498.     }

  500.     /**
  501.      * Shift a time value along the current integration direction: {@link #forward}.
  502.      *
  503.      * @param t     the time to shift.
  504.      * @param delta the amount to shift.
  505.      * @return t + delta if forward, else t - delta. If the result has to be rounded it
  506.      * will be rounded to be before the true value of t + delta.
  507.      */
  508.     private AbsoluteDate shiftedBy(final AbsoluteDate t, final double delta) {
  509.         if (forward) {
  510.             final AbsoluteDate ret = t.shiftedBy(delta);
  511.             if (ret.durationFrom(t) > delta) {
  512.                 return ret.shiftedBy(-Precision.EPSILON);
  513.             } else {
  514.                 return ret;
  515.             }
  516.         } else {
  517.             final AbsoluteDate ret = t.shiftedBy(-delta);
  518.             if (t.durationFrom(ret) > delta) {
  519.                 return ret.shiftedBy(+Precision.EPSILON);
  520.             } else {
  521.                 return ret;
  522.             }
  523.         }
  524.     }

  526.     /**
  527.      * Get the time that happens first along the current propagation direction: {@link
  528.      * #forward}.
  529.      *
  530.      * @param a first time
  531.      * @param b second time
  532.      * @return min(a, b) if forward, else max (a, b)
  533.      */
  534.     private AbsoluteDate minTime(final AbsoluteDate a, final AbsoluteDate b) {
  535.         return (forward ^ (a.compareTo(b) > 0)) ? a : b;
  536.     }

  538.     /**
  539.      * Check the ordering of two times.
  540.      *
  541.      * @param t1 the first time.
  542.      * @param t2 the second time.
  543.      * @return true if {@code t2} is strictly after {@code t1} in the propagation
  544.      * direction.
  545.      */
  546.     private boolean strictlyAfter(final AbsoluteDate t1, final AbsoluteDate t2) {
  547.         if (t1 == null || t2 == null) {
  548.             return false;
  549.         } else {
  550.             return forward ? t1.compareTo(t2) < 0 : t2.compareTo(t1) < 0;
  551.         }
  552.     }

  554.     /**
  555.      * Same as keyword assert, but throw a {@link MathRuntimeException}.
  556.      *
  557.      * @param condition to check
  558.      * @throws MathRuntimeException if {@code condition} is false.
  559.      */
  560.     private void check(final boolean condition) throws MathRuntimeException {
  561.         if (!condition) {
  562.             throw new OrekitInternalError(null);
  563.         }
  564.     }

  566.     /**
  567.      * Class to hold the data related to an event occurrence that is needed to decide how
  568.      * to modify integration.
  569.      */
  570.     public static class EventOccurrence {

  572.         /** User requested action. */
  573.         private final EventHandler.Action action;
  574.         /** New state for a reset action. */
  575.         private final SpacecraftState newState;
  576.         /** The time to stop propagation if the action is a stop event. */
  577.         private final AbsoluteDate stopDate;

  579.         /**
  580.          * Create a new occurrence of an event.
  581.          *
  582.          * @param action   the user requested action.
  583.          * @param newState for a reset event. Should be the current state unless the
  584.          *                 action is {@link Action#RESET_STATE}.
  585.          * @param stopDate to stop propagation if the action is {@link Action#STOP}. Used
  586.          *                 to move the stop time to just after the root.
  587.          */
  588.         EventOccurrence(final EventHandler.Action action,
  589.                         final SpacecraftState newState,
  590.                         final AbsoluteDate stopDate) {
  591.             this.action = action;
  592.             this.newState = newState;
  593.             this.stopDate = stopDate;
  594.         }

  596.         /**
  597.          * Get the user requested action.
  598.          *
  599.          * @return the action.
  600.          */
  601.         public EventHandler.Action getAction() {
  602.             return action;
  603.         }

  605.         /**
  606.          * Get the new state for a reset action.
  607.          *
  608.          * @return the new state.
  609.          */
  610.         public SpacecraftState getNewState() {
  611.             return newState;
  612.         }

  614.         /**
  615.          * Get the new time for a stop action.
  616.          *
  617.          * @return when to stop propagation.
  618.          */
  619.         public AbsoluteDate getStopDate() {
  620.             return stopDate;
  621.         }

  623.     }

  625. }
Created with JaCoCo 0.7.9.201702052155