EventSlopeFilter.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.  */

  18. package org.orekit.propagation.events;

  20. import java.util.Arrays;

  22. import org.hipparchus.ode.events.Action;
  23. import org.orekit.propagation.SpacecraftState;
  24. import org.orekit.propagation.events.handlers.EventHandler;
  25. import org.orekit.time.AbsoluteDate;

  27. /** Wrapper used to detect only increasing or decreasing events.
  28.  *
  29.  * <p>This class is heavily based on the class EventFilter from the
  30.  * Hipparchus library. The changes performed consist in replacing
  31.  * raw types (double and double arrays) with space dynamics types
  32.  * ({@link AbsoluteDate}, {@link SpacecraftState}).</p>
  33.  *
  34.  * <p>General {@link EventDetector events} are defined implicitly
  35.  * by a {@link EventDetector#g(SpacecraftState) g function} crossing
  36.  * zero. This function needs to be continuous in the event neighborhood,
  37.  * and its sign must remain consistent between events. This implies that
  38.  * during an orbit propagation, events triggered are alternately events
  39.  * for which the function increases from negative to positive values,
  40.  * and events for which the function decreases from positive to
  41.  * negative values.
  42.  * </p>
  43.  *
  44.  * <p>Sometimes, users are only interested in one type of event (say
  45.  * increasing events for example) and not in the other type. In these
  46.  * cases, looking precisely for all events location and triggering
  47.  * events that will later be ignored is a waste of computing time.</p>
  48.  *
  49.  * <p>Users can wrap a regular {@link EventDetector event detector} in
  50.  * an instance of this class and provide this wrapping instance to
  51.  * a {@link org.orekit.propagation.Propagator}
  52.  * in order to avoid wasting time looking for uninteresting events.
  53.  * The wrapper will intercept the calls to the {@link
  54.  * EventDetector#g(SpacecraftState) g function} and to the {@link
  55.  * EventHandler#eventOccurred(SpacecraftState, EventDetector, boolean)
  56.  * eventOccurred} method in order to ignore uninteresting events. The
  57.  * wrapped regular {@link EventDetector event detector} will then see only
  58.  * the interesting events, i.e. either only {@code increasing} events or
  59.  * only {@code decreasing} events. The number of calls to the {@link
  60.  * EventDetector#g(SpacecraftState) g function} will also be reduced.</p>
  61.  * @see EventEnablingPredicateFilter
  62.  * @param <T> type of the detector
  63.  */

  65. public class EventSlopeFilter<T extends EventDetector> implements EventDetector {

  67.     /** Number of past transformers updates stored. */
  68.     private static final int HISTORY_SIZE = 100;

  70.     /** Wrapped event detector. */
  71.     private final T rawDetector;

  73.     /** Filter to use. */
  74.     private final FilterType filterType;

  76.     /** Transformers of the g function. */
  77.     private final Transformer[] transformers;

  79.     /** Update time of the transformers. */
  80.     private final AbsoluteDate[] updates;

  82.     /** Indicator for forward integration. */
  83.     private boolean forward;

  85.     /** Extreme time encountered so far. */
  86.     private AbsoluteDate extremeT;

  88.     /** Event detection settings. */
  89.     private final EventDetectionSettings detectionSettings;

  91.     /** Specialized event handler. */
  92.     private final LocalHandler<T> handler;

  94.     /** Wrap an {@link EventDetector event detector}.
  95.      * @param rawDetector event detector to wrap
  96.      * @param filter filter to use
  97.      */
  98.     public EventSlopeFilter(final T rawDetector, final FilterType filter) {
  99.         this(rawDetector.getDetectionSettings(), rawDetector, filter);
  100.     }

  102.     /** Constructor with full parameters.
  103.      * @param detectionSettings event detection settings
  104.      * @param rawDetector event detector to wrap
  105.      * @param filterType filter to use
  106.      * @since 13.0
  107.      */
  108.     public EventSlopeFilter(final EventDetectionSettings detectionSettings,
  109.                             final T rawDetector, final FilterType filterType) {
  110.         this.detectionSettings = detectionSettings;
  111.         this.handler = new LocalHandler<>();
  112.         this.rawDetector  = rawDetector;
  113.         this.filterType = filterType;
  114.         this.transformers = new Transformer[HISTORY_SIZE];
  115.         this.updates      = new AbsoluteDate[HISTORY_SIZE];
  116.     }

  118.     /** {@inheritDoc} */
  119.     @Override
  120.     public EventHandler getHandler() {
  121.         return handler;
  122.     }


  125.     @Override
  126.     public EventDetectionSettings getDetectionSettings() {
  127.         return detectionSettings;
  128.     }

  130.     /**
  131.      * Builds a new instance from the input detection settings.
  132.      * @param settings event detection settings to be used
  133.      * @return a new detector
  134.      */
  135.     public EventSlopeFilter<T> withDetectionSettings(final EventDetectionSettings settings) {
  136.         return new EventSlopeFilter<>(settings, rawDetector, filterType);
  137.     }

  139.     /**
  140.      * Get the wrapped raw detector.
  141.      * @return the wrapped raw detector
  142.      * @since 11.1
  143.      */
  144.     public T getDetector() {
  145.         return rawDetector;
  146.     }

  148.     /** Get filter type.
  149.      * @return filter type
  150.      * @deprecated since 13.0 (use getFilterType)
  151.      */
  152.     @Deprecated
  153.     public FilterType getFilter() {
  154.         return getFilterType();
  155.     }

  157.     /** Get filter type.
  158.      * @return filter type
  159.      * @since 13.0
  160.      */
  161.     public FilterType getFilterType() {
  162.         return filterType;
  163.     }

  165.     /**  {@inheritDoc} */
  166.     @Override
  167.     public void init(final SpacecraftState s0, final AbsoluteDate t) {
  168.         EventDetector.super.init(s0, t);

  170.         // delegate to raw detector
  171.         rawDetector.init(s0, t);

  173.         // initialize events triggering logic
  174.         forward  = AbstractDetector.checkIfForward(s0, t);
  175.         extremeT = forward ? AbsoluteDate.PAST_INFINITY : AbsoluteDate.FUTURE_INFINITY;
  176.         Arrays.fill(transformers, Transformer.UNINITIALIZED);
  177.         Arrays.fill(updates, extremeT);

  179.     }

  181.     /**  {@inheritDoc} */
  182.     @Override
  183.     public void reset(final SpacecraftState state, final AbsoluteDate target) {
  184.         EventDetector.super.reset(state, target);
  185.         rawDetector.reset(state, target);
  186.     }

  188.     /**  {@inheritDoc} */
  189.     @Override
  190.     public void finish(final SpacecraftState state) {
  191.         EventDetector.super.finish(state);
  192.         rawDetector.finish(state);
  193.     }

  195.     /**  {@inheritDoc} */
  196.     @Override
  197.     public double g(final SpacecraftState s) {

  199.         final double rawG = rawDetector.g(s);

  201.         // search which transformer should be applied to g
  202.         if (isForward()) {
  203.             final int last = transformers.length - 1;
  204.             if (extremeT.compareTo(s.getDate()) < 0) {
  205.                 // we are at the forward end of the history

  207.                 // check if a new rough root has been crossed
  208.                 final Transformer previous = transformers[last];
  209.                 final Transformer next     = filterType.selectTransformer(previous, rawG, forward);
  210.                 if (next != previous) {
  211.                     // there is a root somewhere between extremeT and t.
  212.                     // the new transformer is valid for t (this is how we have just computed
  213.                     // it above), but it is in fact valid on both sides of the root, so
  214.                     // it was already valid before t and even up to previous time. We store
  215.                     // the switch at extremeT for safety, to ensure the previous transformer
  216.                     // is not applied too close of the root
  217.                     System.arraycopy(updates,      1, updates,      0, last);
  218.                     System.arraycopy(transformers, 1, transformers, 0, last);
  219.                     updates[last]      = extremeT;
  220.                     transformers[last] = next;
  221.                 }

  223.                 extremeT = s.getDate();

  225.                 // apply the transform
  226.                 return next.transformed(rawG);

  228.             } else {
  229.                 // we are in the middle of the history

  231.                 // select the transformer
  232.                 for (int i = last; i > 0; --i) {
  233.                     if (updates[i].compareTo(s.getDate()) <= 0) {
  234.                         // apply the transform
  235.                         return transformers[i].transformed(rawG);
  236.                     }
  237.                 }

  239.                 return transformers[0].transformed(rawG);

  241.             }
  242.         } else {
  243.             if (s.getDate().compareTo(extremeT) < 0) {
  244.                 // we are at the backward end of the history

  246.                 // check if a new rough root has been crossed
  247.                 final Transformer previous = transformers[0];
  248.                 final Transformer next     = filterType.selectTransformer(previous, rawG, forward);
  249.                 if (next != previous) {
  250.                     // there is a root somewhere between extremeT and t.
  251.                     // the new transformer is valid for t (this is how we have just computed
  252.                     // it above), but it is in fact valid on both sides of the root, so
  253.                     // it was already valid before t and even up to previous time. We store
  254.                     // the switch at extremeT for safety, to ensure the previous transformer
  255.                     // is not applied too close of the root
  256.                     System.arraycopy(updates,      0, updates,      1, updates.length - 1);
  257.                     System.arraycopy(transformers, 0, transformers, 1, transformers.length - 1);
  258.                     updates[0]      = extremeT;
  259.                     transformers[0] = next;
  260.                 }

  262.                 extremeT = s.getDate();

  264.                 // apply the transform
  265.                 return next.transformed(rawG);

  267.             } else {
  268.                 // we are in the middle of the history

  270.                 // select the transformer
  271.                 for (int i = 0; i < updates.length - 1; ++i) {
  272.                     if (s.getDate().compareTo(updates[i]) <= 0) {
  273.                         // apply the transform
  274.                         return transformers[i].transformed(rawG);
  275.                     }
  276.                 }

  278.                 return transformers[updates.length - 1].transformed(rawG);

  280.             }
  281.         }

  283.     }

  285.     /** Check if the current propagation is forward or backward.
  286.      * @return true if the current propagation is forward
  287.      */
  288.     public boolean isForward() {
  289.         return forward;
  290.     }

  292.     /** Local handler. */
  293.     private static class LocalHandler<T extends EventDetector> implements EventHandler {

  295.         /** {@inheritDoc} */
  296.         public Action eventOccurred(final SpacecraftState s, final EventDetector detector, final boolean increasing) {
  297.             @SuppressWarnings("unchecked")
  298.             final EventSlopeFilter<T> esf = (EventSlopeFilter<T>) detector;
  299.             return esf.rawDetector.getHandler().eventOccurred(s, esf.rawDetector, esf.filterType.getTriggeredIncreasing());
  300.         }

  302.         /** {@inheritDoc} */
  303.         @Override
  304.         public SpacecraftState resetState(final EventDetector detector, final SpacecraftState oldState) {
  305.             @SuppressWarnings("unchecked")
  306.             final EventSlopeFilter<T> esf = (EventSlopeFilter<T>) detector;
  307.             return esf.rawDetector.getHandler().resetState(esf.rawDetector, oldState);
  308.         }

  310.     }

  312. }
Created with JaCoCo 0.8.12.202403310830